commit aff966f603b2fb2c18efa15af74c359e826e1a5b
Author: Sergio Durigan Junior <sergiodj@sergiodj.net>
Date:   Sat Jun 11 13:22:37 2016 -0400

    Imported Upstream version 10.7.0

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..31dd127
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,347 @@
+#
+# USAGE:
+#
+# make <option>
+#
+# to see a list of all options, enter 'make help'
+#
+# Note! on some systems do 'gmake' instead of 'make' (most BSD)
+#
+# for 'make install' you have to login as 'root' else do 'make install_home'
+# note that 'make install_home' will not install guiserver files which
+# must be in /usr/local/share/newlisp in MacOX X and UNIX machines
+#
+# to make the distribution archive:  'make dist'
+#
+# to clean up (delete .o *~ core etc.):  'make clean'
+#
+# for customization options, like install location, 64-bit nerwlisp,
+# newLISP as a library etc., see the file doc/INSTALL.txt
+#
+# Regular expressions are on all platforms Perl Compatible Regular Expresssions PCRE
+# see http://www.pcre.org. PCRE can be localized to other languages than English
+# by generating different character tables, see documentation at www.pcre.org
+# and file LOCALIZATION for details
+#
+
+VERSION = 10.7.0
+INT_VERSION = 10700
+
+default: makefile_build
+	make -f makefile_build
+
+makefile_build:
+	./configure
+
+all: default
+
+help:
+	@echo "\nDo one of the following:"
+	@echo "  make                 # auto-select one of the predefined makefiles and build newLISP"
+	@echo "  make help            # display this help"
+	@echo "  make install         # install on LINUX/UNIX in /usr/local/bin and /usr/local/share (need to be root)"
+	@echo "  make uninstall       # uninstall on LINUX/UNIX from /usr/local/bin and /usr/local/share (need to be root)"
+	@echo "  make install_home    # install on LINUX/UNIX in users home directory "
+	@echo "  make uninstall_home  # uninstall on LINUX/UNIX from users home directory "
+	@echo
+	@echo "  make clean           # remove all *.o and .tar files etc. USE BETWEEN FLAVORS!"
+	@echo "  make check           # run qa-dot, qa-net, qa-xml etc. test scripts"
+	@echo "  make test            # same as 'make check' but less output"
+	@echo "  make testall         # run an extended test suite with less output"
+	@echo "  make version         # replace version number in several files after changing in Makefile"
+	@echo "  make bench           # benchmark relative to 32-bit Mac OS 10.5 on MacMini 1.83Ghz"
+	@echo "  make dist            # make a source distribution .tgz package "
+	@echo "  make android_dist    # make a source package for Android NDK compilation"
+	@echo "  make android_dist_utf8  # make a source package for Android NDK compilationi utf8"
+	@echo
+	@echo "Note! on some systems use gmake instead of make."
+	@echo "Note! not all makefiles are listed in this help, specifically 64-bit versions."
+	@echo " "
+	@echo "Readline is for commandline editing support and requires libreadline and headerfiles."
+	@echo "Not all makefiles contain libreadline support, but is easy to add (see other makefieles)."
+	@echo "If there is no UTF-8 option for your OS, consult makefile_xxx."
+	@echo " "
+	@echo "For more customization options (exe dir, install dir, 64-biti, etc) see the file doc/INSTALL"
+
+# make newlisp.exe and newlisp.dll on a MinGW, MSYS system
+# also needs the installer NSYS installed
+winall:
+	make clean
+	make -f makefile_mingw_ffi
+	rm *.o
+	make -f makefile_mingwdll_ffi
+	rm *.o
+	./newlisp qa-dot
+
+# make newlisp.exe and newlisp.dll in UTF-8 flavor
+winall_utf8:
+	make clean
+	make -f makefile_mingw_utf8_ffi
+	rm *.o
+	make -f makefile_mingwdll_utf8_ffi
+	rm *.o
+	./newlisp qa-dot
+	tar czvf newlisp-win-utf8.tgz newlisp.exe newlisp.dll
+
+winall64:
+	make clean
+	make -f makefile_mingw64_ffi
+	rm *.o
+	make -f makefile_mingw64dll_ffi
+	rm *.o
+	./newlisp qa-dot
+	tar czvf newlisp-win64.tgz newlisp.exe newlisp.dll
+
+# make newlisp.exe and newlisp.dll in UTF-8 flavor
+winall64_utf8:
+	make clean
+	make -f makefile_mingw64_utf8_ffi
+	rm *.o
+	make -f makefile_mingw64dll_utf8_ffi
+	rm *.o
+	./newlisp qa-dot
+	tar czvf newlisp-win64-utf8.tgz newlisp.exe newlisp.dll
+
+# make a Windows installer package
+wings:
+	make -f makefile_wings
+	
+wings64:
+	make -f makefile_wings64
+	
+
+# scripts for making UBUNTU linux packages
+
+dpkg:
+	make clean
+	cp makefile_original_install makefile_install
+	make -f makefile_linuxLP64_ffi
+	cp util/description-pak .
+	sudo checkinstall --nodoc --maintainer "lutz@nuevatec.com" --pkgrelease 1 --default
+	rm description-pak
+	mv *.deb ../Desktop
+
+dpkg_utf8:
+	make clean
+	cp makefile_original_install makefile_install
+	make -f makefile_linuxLP64_utf8_ffi
+	cp util/description-pak .
+	sudo checkinstall --nodoc --maintainer "lutz@nuevatec.com" --pkgrelease utf8 --default
+	rm description-pak
+	mv *.deb ../Desktop
+
+# scripts for making Mac OS X disk image installers
+# makefile_darwin_package needs a previous /Applications/newLISP-GS.app
+dmg_ppc:
+	make clean
+	make -f makefile_darwin_utf8_leopardPPC_ffi 
+	make -f makefile_darwin_package
+	hdiutil create -srcfolder newLISP-image newlisp-$(VERSION)-OSX-ppc.dmg
+	mv newlisp-$(VERSION)-OSX-ppc.dmg ..
+	sudo rm -rf Package_contents
+	sudo rm -rf newLISP-image
+
+# makefile_darwin_package needs a previous /Applications/newLISP-GS.app
+dmg_intel:
+	make clean
+	make -f makefile_darwinLP64_utf8_ffi
+	make -f makefile_darwin_package
+	hdiutil create -srcfolder newLISP-image newlisp-$(VERSION)-OSX-intel.dmg
+	mv newlisp-$(VERSION)-OSX-intel.dmg ..
+	sudo rm -rf Package_contents
+	sudo rm -rf newLISP-image
+
+# this cleans up the distribution directory for a clean build from scratch
+
+# this cleans the tree for a rebuild using the same configuration as before
+clean:
+	-rm -f *~ *.bak *.o *.obj *.map *.core core *.tgz *.txt TEST newlisp-universal
+	-rm -f newlisp-js*.*
+	-rm -rf newlisp-js-$(VERSION)
+	-rm -f guiserver/*.class */*~ */._*
+	-rm -f doc/*.bak util/*.bak examples/*.bak modules/*.bak
+	-chmod 644 *.h *.c Makefile makefile*
+	-chmod 755 configure configure-alt examples/*
+	-chmod 644 doc/* modules/*.lsp examples/*.lsp examples/*.html
+	-chmod 755 doc/index.cgi
+	-chmod 644 guiserver/*
+	-chmod 755 guiserver/index.cgi
+	-chmod 755 guiserver/images
+	-chmod 644 guiserver/images/*
+	-chmod 755 guiserver/images/index.cgi
+	-chmod 755 guiserver/java
+	-chmod 644 guiserver/java/*
+	-chmod 755 guiserver/java/index.cgi
+	-rm -f makefile_build makefile_install config.h test-*
+
+# run test scripts
+sharebug:
+	./newlisp qa-dot
+
+
+check:
+	./newlisp qa-dot
+	./newlisp qa-specific-tests/qa-dictionary
+	./newlisp qa-specific-tests/qa-xml
+	./newlisp qa-specific-tests/qa-json
+	./newlisp qa-specific-tests/qa-setsig
+	./newlisp qa-specific-tests/qa-net
+	./newlisp qa-specific-tests/qa-cilk
+	./newlisp qa-specific-tests/qa-ref
+	./newlisp qa-specific-tests/qa-message
+	./newlisp qa-specific-tests/qa-win-dll
+	./newlisp qa-specific-tests/qa-bigint 10000
+	./newlisp qa-specific-tests/qa-bench
+
+# old naming for check 
+test: 
+	make check | grep '>>>'
+
+checkall:
+	./newlisp qa-dot ; echo qa-dot
+	./newlisp qa-specific-tests/qa-dictionary
+	./newlisp qa-specific-tests/qa-xml
+	./newlisp qa-specific-tests/qa-json
+	./newlisp qa-specific-tests/qa-setsig
+	./newlisp qa-specific-tests/qa-net
+	./newlisp qa-specific-tests/qa-net6
+	./newlisp qa-specific-tests/qa-cilk
+	./newlisp qa-specific-tests/qa-ref
+	./newlisp qa-specific-tests/qa-message
+	./newlisp qa-specific-tests/qa-win-dll
+	./newlisp qa-specific-tests/qa-blockmemory
+	./newlisp qa-specific-tests/qa-exception
+	./newlisp qa-specific-tests/qa-float
+	./newlisp qa-specific-tests/qa-foop
+	./newlisp qa-specific-tests/qa-local-domain
+	./newlisp qa-specific-tests/qa-inplace
+#	./newlisp qa-specific-tests/qa-utf16path
+	./newlisp qa-specific-tests/qa-pipefork
+	./newlisp qa-specific-tests/qa-libffi
+	./newlisp qa-specific-tests/qa-bigint 10000
+	./newlisp qa-specific-tests/qa-longnum
+	./newlisp qa-specific-tests/qa-factorfibo 60
+	./newlisp qa-specific-tests/qa-bench
+
+testall: 
+	make checkall | grep '>>>'
+
+# benchmark
+bench: 
+	./newlisp qa-specific-tests/qa-bench
+
+# install
+
+# makefile_install normally is created by the configure script
+# but when using 'make -f makefile_xxx' the file hasn't been
+# created and is created with this dependency
+
+makefile_install:
+	cp makefile_original_install makefile_install
+
+install: makefile_install
+	-make -f makefile_install install
+
+uninstall:
+	-make -f makefile_install uninstall
+
+install_home:
+	-make -f makefile_install install_home
+
+uninstall_home:
+	-make -f makefile_install uninstall_home
+
+# This makes the main newlisp-x.x.x.tgz source distribuition package
+dist: clean
+	-mkdir newlisp-$(VERSION)
+	-mkdir newlisp-$(VERSION)/guiserver
+	-mkdir newlisp-$(VERSION)/guiserver/images
+	-mkdir newlisp-$(VERSION)/guiserver/java
+	-mkdir newlisp-$(VERSION)/modules
+	-mkdir newlisp-$(VERSION)/examples
+	-mkdir newlisp-$(VERSION)/doc
+	-mkdir newlisp-$(VERSION)/util
+	-mkdir newlisp-$(VERSION)/qa-specific-tests
+	-mkdir newlisp-$(VERSION)/newlisp-js
+	cp README newlisp-$(VERSION)
+	cp nl*.c newlisp.c *.h pcre*.c index.cgi newlisp-$(VERSION)
+	cp win64-dll.def win-*.* unix*.c newlisp-$(VERSION)
+	cp Makefile configure* makefile* qa-dot qa-comma newlisp-$(VERSION)
+	cp modules/* newlisp-$(VERSION)/modules
+	cp examples/* newlisp-$(VERSION)/examples
+	cp doc/* newlisp-$(VERSION)/doc
+	cp util/* newlisp-$(VERSION)/util
+	cp qa-specific-tests/* newlisp-$(VERSION)/qa-specific-tests
+	cp -R guiserver/* newlisp-$(VERSION)/guiserver
+	cp -R newlisp-js/* newlisp-$(VERSION)/newlisp-js
+	tar czvf newlisp-$(VERSION).tgz newlisp-$(VERSION)/*
+	rm -rf newlisp-$(VERSION)
+	mv newlisp-$(VERSION).tgz ..
+
+
+# this makes a Android source package for compilation using the Android NDK
+# may want to change APP_PLATFORM spec to something different
+android_dist_utf8:
+	-mkdir newlisp-ndk-utf8-$(VERSION)
+	-mkdir newlisp-ndk-utf8-$(VERSION)/jni
+	-mkdir newlisp-ndk-utf8-$(VERSION)/libs
+	-mkdir newlisp-ndk-utf8-$(VERSION)/libs/armeabi
+	-mkdir newlisp-ndk-utf8-$(VERSION)/obj
+	-mkdir newlisp-ndk-utf8-$(VERSION)/obj/local
+	-mkdir newlisp-ndk-utf8-$(VERSION)/obj/local/armeabi
+	cp nl*.c newlisp.c *.h pcre*.c newlisp-ndk-utf8-$(VERSION)/jni
+	rm newlisp-ndk-utf8-$(VERSION)/jni/win-ffi.h
+	cp doc/Android.html newlisp-ndk-utf8-$(VERSION)
+	cp util/Android-utf8.mk newlisp-ndk-utf8-$(VERSION)/jni/Android.mk
+	cp util/Application.mk newlisp-ndk-utf8-$(VERSION)/jni
+	tar czvf newlisp-ndk-utf8-$(VERSION).tgz newlisp-ndk-utf8-$(VERSION)/*
+	rm -rf newlisp-ndk-utf8-$(VERSION)
+	mv newlisp-ndk-utf8-$(VERSION).tgz ..
+
+android_dist:
+	-mkdir newlisp-ndk-$(VERSION)
+	-mkdir newlisp-ndk-$(VERSION)/jni
+	-mkdir newlisp-ndk-$(VERSION)/libs
+	-mkdir newlisp-ndk-$(VERSION)/libs/armeabi
+	-mkdir newlisp-ndk-$(VERSION)/obj
+	-mkdir newlisp-ndk-$(VERSION)/obj/local
+	-mkdir newlisp-ndk-$(VERSION)/obj/local/armeabi
+	cp nl*.c newlisp.c *.h pcre*.c newlisp-ndk-$(VERSION)/jni
+	rm newlisp-ndk-$(VERSION)/jni/win-ffi.h
+	rm newlisp-ndk-$(VERSION)/jni/nl-utf8.c 
+	cp doc/Android.html newlisp-ndk-$(VERSION)
+	cp util/Android.mk newlisp-ndk-$(VERSION)/jni
+	cp util/Application.mk newlisp-ndk-$(VERSION)/jni
+	tar czvf newlisp-ndk-$(VERSION).tgz newlisp-ndk-$(VERSION)/*
+	rm -rf newlisp-ndk-$(VERSION)
+	mv newlisp-ndk-$(VERSION).tgz ..
+
+# this changes to the current version number in several files
+#
+# before doing a 'make version' the VERSION variable at the beginning
+# of this file has to be changed to the new number
+#
+version:
+	sed -i.bak -E 's/int version = .+;/int version = $(INT_VERSION);/' newlisp.c
+	sed -i.bak -E 's/newLISP v.[[:digit:]]+.[[:digit:]]+.[[:digit:]]+(-dev)? /newLISP v.$(VERSION) /' newlisp.c
+	sed -i.bak -E 's/newLISP\/[[:digit:]]+.[[:digit:]]+.[[:digit:]]+(-dev)?/newLISP\/$(VERSION)/' nl-web.c
+	sed -i.bak -E 's/newLISP v.+ Manual/newLISP v.$(VERSION) Manual/' doc/newlisp_manual.html
+	sed -i.bak -E 's/Reference v.+<\/h2>/Reference v.$(VERSION)<\/h2>/' doc/newlisp_manual.html
+	sed -i.bak -E 's/newlisp-.....-win/newlisp-$(INT_VERSION)-win/' guiserver/newlisp-gs.nsi
+	sed -i.bak -E 's/and newLISP .+ on /and newLISP $(VERSION) on /' guiserver/newlisp-gs.nsi
+	sed -i.bak -E 's/newlisp-.....-win/newlisp-$(INT_VERSION)-win/' guiserver/newlisp64-gs.nsi
+	sed -i.bak -E 's/and newLISP .+ on /and newLISP $(VERSION) on /' guiserver/newlisp64-gs.nsi
+	sed -i.bak -E 's/VERSION=.+/VERSION=$(VERSION)/' configure-alt
+	sed -i.bak -E 's/VERSION=.+/VERSION=$(VERSION)/' makefile_original_install 
+	sed -i.bak -E 's/VERSION=.+/VERSION=$(VERSION)/' makefile_darwin_package
+	sed -i.bak -E 's/VERSION=.+/VERSION=$(VERSION)/' makefile_wings
+	sed -i.bak -E 's/VERSION=.+/VERSION=$(VERSION)/' makefile_wings64
+
+# Prepare the manual file for PDF conversion, by replaceing all <span class="function"></span>
+# with <font color="#DD0000"></font> in the syntax statements and replacing &rarr; (one line
+# arrow with &rArr; (double line arrow). This is necessary when using OpenOffcice PDF conversion 
+#
+preparepdf:
+	util/preparepdf doc/newlisp_manual.html doc/newlisp_manual_preparepdf.html
+
+# end of file
diff --git a/README b/README
new file mode 100644
index 0000000..d16f1b3
--- /dev/null
+++ b/README
@@ -0,0 +1,129 @@
+newLISP version 10.x.x for LINUX, FreeBSD, Mac OSX Solaris and Win32
+===================================================================
+
+
+INTRODUCTION
+------------
+newLISP(tm) is LISP like scripting language for general programming
+artificial intelligence and statistics. 
+
+For more details about newLISP see the Users Manual and Reference in the
+distribution file: 'doc/newlisp_manual.html' 
+
+Code contributions, bug fixes, reports and comments are welcome. New
+versions are available at:
+
+    http://newlisp.org
+      or
+    http://newlisp.org/downloads
+      or
+    http://sourceforge.net/projects/newlisp
+
+See the file doc/CHANGES in the source distribtion for changes over 
+previous versions or
+
+    http://newlisp.org/downloads/newLISP_xx_Release_Notes.html
+
+New versions in development are available at:
+
+    http://newlisp.org/downloads/development
+
+Please contact me via email at: lutz@nuevatec.com.
+
+Some of the information in this file is expanded in file newlisp-x.x.x/doc/INSTALL.
+
+
+BUILD, CHECK and INSTALL
+------------------------
+
+Normally the correct makefile_xxxxx will be picked automatically just typing: 
+
+  make
+
+to discover the current platform and make for Linux, MacOSX, FreeBSD, OpenBSD,
+NetBSD, Solaris/SunOS and Win32 (MinGW on MSYS). Sometimes the makefile_xxxxx
+must be specified explicitely, e.g. when compiling for the RaspberryPi runnning
+a sub-flavor of Linux and cross-compiled on a desktop system:
+
+  make -f makefile_raspberrypi
+
+Any other makefile_xxxxx can be picked the same way, but always read the
+makefile_xxxxx first, sometimes it contains special instructions!
+
+To test the compiled newlisp executable do:
+
+  make check
+
+or showing only success or failure:
+
+  make testall
+
+From a user account if the sudo command and admin password is available:
+
+  sudo make install
+
+If root permissions are not available:
+
+  make install_home
+
+home_install does not install the newLISP-GS Java based IDE, but installs
+the supportig documentation.
+
+see all flavors and platforms available for install:
+
+  make help
+
+will list all available platforms and flavors, newLISP can also be made as
+a shared, dhynamic library: newlisp.so, newlisp.dylib or  newlisp.dll
+
+To discover the platform in an extra step do:
+
+  ./configure
+
+  make
+
+this discovers the platform and generates a makefile_build which
+is used subsequently by make. As an alternative use:
+
+  ./configure-alt
+
+  make
+
+this does a more elaborate analysys of options supported on a specific
+platform and custom makes a makefile_build.
+
+See the files doc/INSTALL, doc/LOCALIZATION and doc/FILES for more
+detailed information.
+
+MINIMUM INSTALL
+---------------
+Note that for a minumum install only the executable newlisp or newlisp.exe
+in Win32 is necessary.
+
+On Mac OS X or other UNIX copy  newlisp to /usr/local/bin or /usr/bin or ~/bin 
+and give it executable permissions.
+
+
+LICENSE
+-------
+newLISP and Nuevatec are trademarks of Lutz Mueller. Files in the newLISP
+distribution are protected by the "GNU General Public License Version 3, June 2007". 
+For the full text of this license see the accompanying file COPYING in the doc
+directory, or the appendix in the file newlisp_manual.html. Documentation files
+are protected by the "GNU Free Doumentation License Version 1.2, November 2002".
+A copy of this license is also included in the file COPYING.
+
+This and information about lcensing from other contributors to newLISP is
+contained in the file COPYING in the source distribution.
+
+
+MORE INFO AND CONTACT
+---------------------
+See in the doc/ directory of the source distribution
+
+lutz@nuevatec.com
+
+last edit February 2013
+
+                                  +++
+
diff --git a/configure b/configure
new file mode 100755
index 0000000..edd06f8
--- /dev/null
+++ b/configure
@@ -0,0 +1,144 @@
+#!/bin/sh
+
+# Only LP64, LLP64 and ILP32 memory models are supported
+echo
+echo "removing old objects and setting correct permissions ..."
+make clean > /dev/null
+cp makefile_original_install makefile_install
+echo "discovering platform and default memory model ..."
+echo
+
+case `uname` in 
+	Darwin) true ${os_type:=MAC_OSX} ;;
+	Linux)  true ${os_type:=LINUX} ;;
+	FreeBSD) true ${os_type:=_BSD} ;;
+	NetBSD) true ${os_type:=_BSD} ;;
+	OpenBSD) true ${os_type:=_BSD} ;;
+	SunOS) true ${os_type:=SUNOS} ;;
+	AIX) true ${os_type:=AIX} ;; 
+	OSF1) true ${os_type:=TRU64} ;;
+	MINGW32_*) true ${os_type:=WINDOWS} ;;
+	MINGW64_*) true ${os_type:=WINDOWS} ;;
+	CYGWIN*) true ${os_type:=CYGWIN} ;;
+	OS/2) true ${os_type:=OS2} ;;
+	*)
+		echo Could not discover your OS platform use one of the following commands:
+		make help
+		;;
+esac
+
+cat > test-memorymodel.c <<EOF
+/* test-memorymodel.c Ted Walther <ted@reactor-core.org>
+ *
+ * return a string with the type of memory model the current compiler is using.
+ */
+
+#include <stdio.h>
+
+int
+main(int argc, char** argv) {
+	short sc = sizeof(char) * 8;
+	short ss = sizeof(short) * 8;
+	short si = sizeof(int) * 8;
+	short sl = sizeof(long) * 8;
+	short sp = sizeof(void*) * 8;
+
+	if (si == 32 && sl == 64 && sp == 64) { printf("LP64\n"); return 0; }
+	if (si == 64 && sl == 64 && sp == 64) { printf("ILP64\n"); return 0; }
+	if (si == 32 && sl == 32 && sp == 64) { printf("LLP64\n"); return 0; }
+	if (si == 32 && sl == 32 && sp == 32) { printf("ILP32\n"); return 0; }
+	if (si == 16 && sl == 32 && sp == 32) { printf("LP32\n"); return 0; }
+	printf("UNKNOWN\n"); return 1;
+}
+EOF
+
+if [ `which gcc` ] ; then
+	gcc test-memorymodel.c -o test-memorymodel >/dev/null
+else
+	cc test-memorymodel.c -o test-memorymodel >/dev/null
+fi
+
+true ${memory_model:=`./test-memorymodel`}
+
+# clean up
+rm -f test-memorymodel*
+
+echo "detected memory model ${memory_model}"
+echo "detected Operating System ${os_type}"
+echo "creating makefile_build ..."
+echo
+
+if   [ ${os_type} = MAC_OSX ] ; then
+	cp makefile_darwinLP64_utf8_ffi makefile_build
+elif [ ${os_type} = LINUX ] ; then
+	if [ -f /etc/redhat-release ] ; then
+		libffi_version=$(ls -d /usr/lib*/libffi*/include)
+        if [ -z "${libffi_version}" ] ; then
+            libffi_version="/usr/include"
+        fi
+		if [ ${memory_model} = LP64 ] ; then
+			sed "s,LIBFFI_VERSION,${libffi_version},g" makefile_linuxLP64_redhat_utf8_ffi > makefile_build
+		else
+			sed "s,LIBFFI_VERSION,${libffi_version},g" makefile_linux_redhat_utf8_ffi > makefile_build
+		fi
+	else
+		if [ ${memory_model} = LP64 ] ; then
+			cp makefile_linuxLP64_utf8_ffi makefile_build
+		else
+			cp makefile_linux_utf8_ffi makefile_build
+		fi		
+	fi
+elif [ ${os_type} = _BSD ] ; then
+	if [ ${memory_model} = LP64 ] ; then
+		if [ -f /usr/local/include/ffi.h ] ; then
+			cp makefile_bsdLP64_utf8_ffi makefile_build
+		else
+			cp makefile_bsdLP64_utf8 makefile_build
+		fi
+	else
+		cp makefile_bsd_utf8 makefile_build
+	fi
+elif [ ${os_type} = SUNOS ] ; then
+	if [ ${memory_model} = LP64 ] ; then
+		cp makefile_sunosLP64_uf8 makefile_build
+	else
+		cp makefile_sunos_utf8 makefile_build
+	fi
+elif [ ${os_type} = AIX ] ; then
+	if [ ${memory_model} = LP64 ] ; then
+		cp makefile_aixLP64_utf8_gcc makefile_build
+	else
+		cp makefile_aix_utf8_gcc makefile_build
+	fi
+elif [ ${os_type} = TRU64 ] ; then
+	cp makefile_tru64 makefile_build
+elif [ ${os_type} = WINDOWS ] ; then
+	if [ ${memory_model} = LLP64 ] ; then
+		cp makefile_mingw64_ffi makefile_build
+	else
+		cp makefile_mingw_ffi makefile_build
+	fi
+elif [ ${os_type} = CYGWIN ] ; then
+	cp makefile_cygwin makefile_build
+	if [ ${memory_model} = LP64 ]; then
+	cp makefile_cygwinLP64 makefile_build
+	else 
+	cp makefile_cygwin makefile_build
+    fi
+elif [ ${os_type} = OS2 ] ; then
+	cp makefile_os2 makefile_build
+fi
+
+
+
+if   [ ${os_type} = MAC_OSX ] ; then
+    echo "to make for 64-bit on MAC_OSX type:"
+else
+	echo "to make for ${memory_model} on ${os_type} type:"
+fi
+echo "    make"
+echo "to make for any other system do:"
+echo "    make -f makefile_xxx"
+echo "where makefile_xxx is one of the preconfigured makefiles"
+echo
+
diff --git a/configure-alt b/configure-alt
new file mode 100755
index 0000000..d1bdd8f
--- /dev/null
+++ b/configure-alt
@@ -0,0 +1,630 @@
+#!/bin/sh
+
+PACKAGE=newlisp
+VERSION=10.7.0
+
+rm -f config.h makefile_build makefile_install
+
+# this script tries to discover the OS platform and configuration
+# and then makes newLISP using the appropiate makefile
+# if this script fails and for other special flavors, like
+# making shared libraries etc., type: 
+#
+#      make help
+# to see all options specified in Makefile
+#
+# to change $(prefix) edit prefix in Makefile
+
+# Generate a config.h file with all our different option settings that are set
+# by #define
+
+# Now we set the default values for our new Makefile
+DEFAULT_CC="cc"
+DARWIN_CC="${DEFAULT_CC}"
+LINUX_CC="gcc"
+BSD_CC="${DEFAULT_CC}"
+SUNOS_CC="gcc"
+AIX_CC="xlc_r"
+TRU64_CC="cc"
+WIN32_CC="gcc"
+OS2_CC="${DEFAULT_CC}"
+
+DEFAULT_CFLAGS=" -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c"
+DARWIN_CFLAGS=" -Wall -Wno-long-long -Wno-strict-aliasing -O2 -c"
+LINUX_CFLAGS=" -Wall -Wno-long-long -Wno-strict-aliasing -O2 -c"
+BSD_CFLAGS=" -Wall -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -O2 -c"
+SUNOS_CFLAGS=" -Wall -pedantic -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -O2 -c"
+AIX_XLCFLAGS=" -O2 -c"
+AIX_GCCFLAGS=" -Wall -pedantic -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -O2 -c"
+TRU64_CFLAGS=" -ieee -pedantic -O3 -c -D_POSIX_PII_SOCKET"
+WIN32_CFLAGS=" -Wall -Wno-uninitialized -Wno-long-long -O1 -c"
+OS2_CFLAGS=" -Wall -pedantic -Wno-uninitialized -Wno-long-long -Wno-strict-aliasing -O2 -c -s"
+
+DEFAULT_LDFLAGS="-lm"
+DARWIN_LDFLAGS="${DEFAULT_LDFLAGS}"
+LINUX_LDFLAGS="-lm -ldl"
+BSD_LDFLAGS="${DEFAULT_LDFLAGS}"
+SUNOS_LDFLAGS="-lm -ldl -lrt -lsocket -lnsl"
+AIX_LDFLAGS="-lm -ldl -lrt -lnsl"
+TRU64_LDFLAGS="-lm -lrt -ldb -lbsd"
+WIN32_LDFLAGS="-lws2_32"
+OS2_LDFLAGS="-Zomf -Zmt -lm -ldl"
+
+DEFAULT_OBJS="newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o"
+
+DEFAULT_STRIP="strip"
+WIN32_STRIP="strip"
+
+DEFAULT_TARG="newlisp"
+WIN32_TARG="newlisp.exe"
+OS2_TARG="newlisp.exe"
+
+echo
+case `uname` in 
+	Darwin) true ${os_type:=MAC_OSX} ;;
+	Linux)  true ${os_type:=LINUX} ;;
+	FreeBSD) true ${os_type:=_BSD} ;;
+	NetBSD) true ${os_type:=_BSD} ;;
+	OpenBSD) true ${os_type:=_BSD} ;;
+	SunOS) true ${os_type:=SUNOS} ;;
+	AIX) true ${os_type:=AIX} ;; 
+	OSF1) true ${os_type:=TRU64} ;;
+	MINGW*) true ${os_type:=WINDOWS} ;;
+	OS/2) true ${os_type:=OS2} ;;
+	*)
+		echo Could not discover your OS platform use one of the following commands:
+		make help
+		exit
+		;;
+esac
+
+echo "Detected Operating System ${os_type}"
+
+if   [ ${os_type} = MAC_OSX ] ; then
+	DEFAULT_CFLAGS="${DARWIN_CFLAGS}"
+elif [ ${os_type} = LINUX ] ; then
+	DEFAULT_CFLAGS="${LINUX_CFLAGS}"
+	DEFAULT_LDFLAGS="${LINUX_LDFLAGS}"
+elif [ ${os_type} = _BSD ] ; then
+	DEFAULT_CFLAGS="${BSD_CFLAGS}"
+elif [ ${os_type} = SUNOS ] ; then
+	DEFAULT_CFLAGS="${SUNOS_CFLAGS}"
+	DEFAULT_LDFLAGS="${SUNOS_LDFLAGS}"
+elif [ ${os_type} = AIX ] ; then
+	DEFAULT_CC="${AIX_CC}"
+	DEFAULT_CFLAGS="${AIX_XLCFLAGS}"
+	true ${enable_readline:=no};
+elif [ ${os_type} = TRU64 ] ; then
+	DEFAULT_CC="${TRU64_CC}"
+	DEFAULT_CFLAGS="${TRU64_CFLAGS}"
+	DEFAULT_LDFLAGS="${TRU64_LDFLAGS}"
+elif [ ${os_type} = WINDOWS ] ; then
+	DEFAULT_CC="${WIN32_CC}"
+	DEFAULT_CFLAGS="${WIN32_CFLAGS}"
+	DEFAULT_LDFLAGS="${WIN32_LDFLAGS}"
+	DEFAULT_OBJS="${DEFAULT_OBJS} win-util.o win-path.o"
+	DEFAULT_STRIP="${WIN32_STRIP}"
+	DEFAULT_TARG="${WIN32_TARG}"
+	true ${enable_readline:=no};
+	true ${enable_utf8:=no};
+elif [ ${os_type} = OS2 ] ; then
+	DEFAULT_CFLAGS="${OS2_CFLAGS}"
+	DEFAULT_LDFLAGS="${OS2_LDFLAGS}"
+	DEFAULT_TARG="${OS2_TARG}"
+	true ${enable_readline:=yes};
+fi
+
+# Only LP64 and ILP32 memory models are officially supported, but we'll try to
+# support the others too.
+cat > test-memorymodel.c <<EOF
+/* test-memorymodel.c Ted Walther <ted@reactor-core.org>
+ *
+ * return a string with the type of memory model the current compiler is using.
+ */
+
+#include <stdio.h>
+
+int
+main(int argc, char** argv) {
+	short sc = sizeof(char) * 8;
+	short ss = sizeof(short) * 8;
+	short si = sizeof(int) * 8;
+	short sl = sizeof(long) * 8;
+	short sp = sizeof(void*) * 8;
+
+	if (si == 32 && sl == 64 && sp == 64) { printf("LP64\n"); return 0; }
+	if (si == 64 && sl == 64 && sp == 64) { printf("ILP64\n"); return 0; }
+	if (si == 32 && sl == 32 && sp == 64) { printf("LLP64\n"); return 0; }
+	if (si == 32 && sl == 32 && sp == 32) { printf("ILP32\n"); return 0; }
+	if (si == 16 && sl == 32 && sp == 32) { printf("LP32\n"); return 0; }
+	printf("UNKNOWN\n"); return 1;
+}
+EOF
+${CC:-${DEFAULT_CC}} test-memorymodel.c -o test-memorymodel 2>/dev/null
+true ${memory_model:=`./test-memorymodel`}
+echo "Detected memory model `./test-memorymodel`"
+rm -f test-memorymodel*
+
+# time_t is 64 bits on modern platforms.  Support this.
+cat > test-time-t.c <<EOF
+#include <stdio.h>
+#include <time.h>
+
+int
+main(int argc, char** argv) {
+	short bits = sizeof(time_t) * 8;
+
+	if (bits == 64) { printf("64BIT"); return 0; }
+	if (bits == 32) { printf("32BIT"); return 0; }
+	printf("UNSUPPORTED\n"); return 1;
+}
+EOF
+${CC:-${DEFAULT_CC}} test-time-t.c -o test-time-t 2>/dev/null
+true ${time_t_size:=`./test-time-t`}
+echo "Detected time_t size `./test-time-t`"
+rm -f test-time-t*
+
+# If we can't compile with readline, and the environment variables don't
+# specify otherwise, we will disable it.
+cat > test-readline.c <<EOF
+/* test-readline.c Fri Jul 10 14:57:33 PDT 2009 Ted Walther <ted@reactor-core.org>
+ *
+ * code for testing the compiler options to use for libreadline
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <readline/readline.h>
+#include <readline/history.h>
+
+char **
+test_completion (char * text, int start, int end) {
+	return NULL;
+}
+
+int
+main(int argc, char** argv) {
+
+	rl_readline_name = "test";
+	rl_attempted_completion_function = (CPPFunction *)test_completion;
+	readline(NULL);
+	add_history("test");
+
+	exit(0);
+}
+EOF
+for cclibreadline in "-lreadline" "-lreadline -lncurses" "-lreadline -ltermcap" "-lreadline -lterminfo"; do
+	if ${CC:-${DEFAULT_CC}} test-readline.c ${cclibreadline} -o test-readline 2>/dev/null ; then
+		true ${enable_readline:=yes};
+		DEFAULT_RLFLAGS="${cclibreadline}";
+		echo "Detected readline flags: ${cclibreadline}";
+		break;
+	fi
+done
+true ${enable_readline:=no};
+rm -f test-readline*
+
+# If we can't compile with ffi, and the environment variables don't
+# specify otherwise, we will disable it.
+cat > test-ffi.c <<EOF
+/* test-ffi.c Fri Jul 10 14:57:33 PDT 2009 Ted Walther <ted@reactor-core.org>
+ *
+ * code for testing the compiler options to use for libffi
+ */
+
+#include <stdio.h>
+#include <ffi.h>
+
+int main(int argc, char** argv) {
+       ffi_cif cif;
+       ffi_type *args[1];
+       void *values[1];
+       char *s;
+       int rc;
+     
+       args[0] = &ffi_type_pointer;
+       values[0] = &s;
+     
+       if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
+     		       &ffi_type_uint, args) == FFI_OK)
+         {
+           s = "Hello World!";
+           ffi_call(&cif, puts, &rc, values);
+         }
+     
+       return 0;
+}
+EOF
+for cclibffi in "-lffi"; do
+	if ${CC:-${DEFAULT_CC}} test-ffi.c ${DEFAULT_LDFLAGS} ${cclibffi} -o test-ffi 2>/dev/null ; then
+		true ${enable_ffi:=yes};
+		DEFAULT_FFIFLAGS="${cclibffi}";
+		echo "Detected ffi flags: ${cclibffi}";
+		break;
+	fi
+done
+true ${enable_ffi:=no};
+rm -f test-ffi*
+
+# Safe defaults; 
+true ${enable_utf8:=yes};
+
+# Default values to control how the Makefile is generated
+true ${enable_static:=no};
+true ${enable_debug:=no};
+
+for nlc_arg in "$@"; do
+	if test -n "$nlc_prev"; then
+		eval "$nlc_prev=\$nlc_arg"
+		nlc_prev=
+		continue
+	fi
+	case "${nlc_arg}" in
+		--*=*) nlc_optarg=`echo "$nlc_arg" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+		*) nlc_optarg= ;;
+	esac
+case "${nlc_arg}" in
+	--enable-utf8) enable_utf8=yes; ;;
+	--disable-utf8) enable_utf8=no; ;;
+	--enable-readline) enable_readline=yes; ;;
+	--disable-readline) enable_readline=no; ;;
+        --enable-ffi) enable_ffi=yes; ;;
+        --disable-ffi) enable_ffi=no; ;;
+	--enable-static) enable_static=yes; ;;
+	--disable-static) enable_static=no; ;;
+	--enable-debug) enable_debug=yes; ;;
+	--disable-debug) enable_debug=no; ;;
+	--LP64)  memory_model=LP64; ;;
+	--ILP64) memory_model=ILP64; ;;
+	--LLP64) memory_model=LLP64; ;;
+	--LP32)  memory_model=LP32; ;;
+	--ILP32) memory_model=ILP32; ;;
+	--prefix) nlc_prev=prefix ;;
+	--prefix=*) prefix="$nlc_optarg" ;;
+	--exec-prefix) nlc_prev=exec_prefix ;;
+	--exec-prefix=*) exec_prefix="$nlc_optarg" ;;
+	--bindir) nlc_prev=bindir ;;
+	--bindir=*) bindir="$nlc_optarg" ;;
+	--mandir) nlc_prev=mandir ;;
+	--mandir=*) mandir="$nlc_optarg" ;;
+	--man1dir) nlc_prev=man1dir ;;
+	--man1dir=*) man1dir="$nlc_optarg" ;;
+	--docdir) nlc_prev=docdir ;;
+	--docdir=*) docdir="$nlc_optarg" ;;
+	--datadir) nlc_prev=datadir ;;
+	--datadir=*) datadir="$nlc_optarg" ;;
+	--help) cat <<EOF
+Usage: ./configure-alt [options]
+     --help              # Show this help message.
+
+     --prefix=dir        # standard GNU option
+     --exec-prefix=dir   # standard GNU option
+     --bindir=dir        # standard GNU option
+     --datadir=dir       # standard GNU option
+     --docdir=dir        # standard GNU option
+     --mandir=dir        # standard GNU option
+     --man1dir=dir       # standard GNU option
+
+     --enable-utf8       # (default) Enable UTF8 support
+     --disable-utf8      # Disable UTF8 support
+     --enable-readline   # (default) Enable readline support
+     --disable-readline  # Disable readline support
+     --enable-ffi        # (default) Enable foreign function interface
+     --disable-ffi       # Disable foreign function interface
+     --enable-static     # Link newlisp statically, suitable for use in chroot jails
+     --disable-static    # (default) Link newlisp dynamically
+     --enable-debug      # Include debugging information in the newlisp binary
+     --disable-debug     # (default) Compile without debugging information
+     --LP64              # Use LP64 memory model, overriding auto-detection
+     --ILP64             # Use ILP64 memory model, overriding auto-detection    
+     --LLP64             # Use LLP64 memory model, overriding auto-detection
+     --LP32              # Use LP32 memory model, overriding auto-detection
+     --ILP32             # Use ILP32 memory model, overriding auto-detection
+EOF
+	exit; ;;	
+	*) echo "Unrecognized option, ignoring: ${arg}" ;;
+esac
+done
+
+if [ -z "$prefix" ] ; then prefix="/usr/local"; fi
+if [ -z "$exec_prefix" ] ; then exec_prefix="$prefix"; fi
+if [ -z "$bindir" ] ; then bindir="${exec_prefix}/bin"; fi
+if [ -z "$datarootdir" ] ; then datarootdir="${prefix}/share"; fi
+if [ -z "$datadir" ] ; then datadir="${datarootdir}"; fi
+if [ -z "$docdir" ] ; then docdir="${datarootdir}/doc/${PACKAGE}"; fi
+if [ -z "$mandir" ] ; then mandir="${prefix}/man"; fi
+if [ -z "$man1dir" ] ; then man1dir="${mandir}/man1"; fi
+if [ -z "$pkgdatadir" ] ; then pkgdatadir="${datadir}/${PACKAGE}-${VERSION}"; fi
+
+cat >> config.h <<EOF
+/* This file was generated automatically by ./configure-alt */
+
+#define NEWLISPDIR "${pkgdatadir}"
+
+EOF
+
+cat >> config.h <<EOF
+/* Operating System Type */
+#define ${os_type}
+
+/* Memory model for the platform */
+#define MEMORY_MODEL_${memory_model}
+
+EOF
+
+
+if [ $memory_model = LP64 ] ; then
+	cat >> config.h <<EOF
+/* This platform is using the LP64 memory model.  Adding legacy #define */
+#define NEWLISP64
+
+EOF
+fi
+
+if [ $time_t_size = 64BIT ] ; then
+	cat >> config.h <<EOF
+/* Large values of time_t are supported. */
+#define TIME_T_64
+
+EOF
+fi
+
+if [ $enable_utf8 = yes ] ; then
+	DEFAULT_OBJS="${DEFAULT_OBJS} nl-utf8.o"
+	cat >> config.h <<EOF
+/* UTF8 support was chosen */
+#define SUPPORT_UTF8
+
+EOF
+echo "UTF-8 is enabled"
+fi
+
+if [ $enable_readline = yes ] ; then
+	cat >> config.h <<EOF
+/* READLINE support was chosen */
+#define READLINE
+
+EOF
+	echo "readline support is enabled"
+else
+	DEFAULT_RLFLAGS=""
+	cat <<EOF
+readline support is disabled
+
+To enable readline support, use the --enable-readline option, and specify the
+proper libraries to link by setting the RLFLAGS variable when running
+configure.  Also if necessary, use the INCLUDES variable to specify where the
+readline header files are.
+
+EOF
+fi
+
+if [ $enable_ffi = yes ] ; then
+	cat >> config.h <<EOF
+/* FFI support was chosen */
+#define FFI
+
+EOF
+	echo "ffi support is enabled"
+else
+	cat <<EOF
+ffi support is disabled
+
+To enable ffi support, use the --enable-ffi option, and specify the proper
+libraries to link by setting the FFIFLAGS variable when running configure.
+Also if necessary, use the INCLUDES variable to specify where the ffi header
+files are.
+
+EOF
+fi
+
+echo "/* EOF */" >> config.h
+
+if [ $enable_static = yes ] ; then
+	DEFAULT_LDFLAGS="${DEFAULT_LDFLAGS} -static"
+	echo "Static linking enabled"
+fi
+
+if [ $enable_debug = yes ] ; then
+	DEFAULT_CFLAGS="${DEFAULT_CFLAGS} -g"
+	DEFAULT_LDFLAGS="${DEFAULT_LDFLAGS} -g"
+	echo "Debugging enabled"
+fi
+
+cat >test-archflag.c <<EOF
+#include <stdio.h>
+
+int
+main(int argc, char** argv) {
+  printf("Hello World.\n");
+}
+EOF
+
+DEFAULT_ARCHFLAGS=""
+if   [ $memory_model = LP64 ] ; then
+	if   [ $os_type = AIX -a ${CC:-${DEFAULT_CC}} = xlc_r ] ; then
+		DEFAULT_ARCHFLAGS="-q64"
+	elif [ $os_type = AIX -a ${CC:-${DEFAULT_CC}} = gcc ] ; then
+    DEFAULT_ARCHFLAGS="-maix64"
+  else
+    if ${CC:-${DEFAULT_CC}} -m64 -o test-archflag test-archflag.c 2>/dev/null; then
+      DEFAULT_ARCHFLAGS="-m64"
+    fi
+	fi
+elif [ $memory_model = ILP32 ] ; then
+    if ${CC:-${DEFAULT_CC}} -m32 -o test-archflag test-archflag.c 2>/dev/null; then
+      DEFAULT_ARCHFLAGS="-m32"
+    fi
+fi
+rm -f test-archflag*
+
+STRIPBINARY="	\$(STRIP) \$(TARG)"
+LINKSTAGE="	\$(CC) \$(OBJS) \$(ARCHFLAGS) \$(LDFLAGS) \$(RLFLAGS) \$(FFIFLAGS) -o \$(TARG)"
+COMPILEOBJS="	\$(CC) \$(ARCHFLAGS) \$(CFLAGS) -DNEWCONFIG $<"
+
+if [ $os_type = OS2 ] ; then
+	STRIPBINARY=""
+elif [ $os_type = AIX -a $memory_model = LP64 ] ; then
+	LINKSTAGE=" OBJECT_MODE=64 \$(CC) \$(OBJS) \$(ARCHFLAGS) \$(LDFLAGS) \$(RLFLAGS) \$(FFIFLAGS) -o \$(TARG)"
+fi
+
+# Now let us make the Makefile (makefile_build)
+cat > makefile_build <<EOF
+# makefile for newLISP v. 10.1.x generated by the configure script (configure-alt)
+CC = ${CC:-${DEFAULT_CC}}
+CFLAGS = ${CFLAGS:-${DEFAULT_CFLAGS}} ${INCLUDES}
+LDFLAGS = ${LDFLAGS:-${DEFAULT_LDFLAGS}}
+OBJS = ${OBJS:-${DEFAULT_OBJS}}
+STRIP = ${STRIP:-${DEFAULT_STRIP}}
+TARG = ${TARG:-${DEFAULT_TARG}}
+RLFLAGS = ${RLFLAGS:-${DEFAULT_RLFLAGS}}
+FFIFLAGS = ${FFIFLAGS:-${DEFAULT_FFIFLAGS}}
+ARCHFLAGS = ${ARCHFLAGS:-${DEFAULT_ARCHFLAGS}}
+
+default: \$(OBJS)
+${LINKSTAGE}
+${STRIPBINARY}
+
+.c.o:
+${COMPILEOBJS}
+
+\$(OBJS): primes.h protos.h config.h makefile_build
+EOF
+
+cat > makefile_install <<EOF
+# This file was generated automatically by ./configure-alt
+
+package=${PACKAGE}
+version=${VERSION}
+prefix=\$(DESTDIR)${prefix}
+exec_prefix=\$(DESTDIR)${exec_prefix}
+bindir=\$(DESTDIR)${bindir}
+datarootdir=\$(DESTDIR)${datarootdir}
+datadir=\$(DESTDIR)${datadir}
+pkgdatadir=\$(DESTDIR)${pkgdatadir}
+docdir=\$(DESTDIR)${docdir}
+mandir=\$(DESTDIR)${mandir}
+man1dir=\$(DESTDIR)${man1dir}
+
+install:
+	-install -d \$(pkgdatadir)
+	-install -d \$(pkgdatadir)/modules
+	-install -d \$(pkgdatadir)/util
+	-install -d \$(docdir)
+	-install -d \$(man1dir)
+	-install -d \$(bindir)
+	-rm -f \$(bindir)/newlisp
+	-install -m 755  newlisp \$(bindir)/\$(package)-\$(version)
+	-cd \$(bindir); ln -s \$(package)-\$(version) newlisp
+	-install -m 755 util/newlispdoc \$(bindir)/newlispdoc
+	-install -m 644 util/syntax.cgi \$(pkgdatadir)/util/syntax.cgi
+	-install -m 644 util/newlisp.vim \$(pkgdatadir)/util/newlisp.vim
+	-install -m 644 doc/COPYING \$(docdir)/COPYING
+	-install -m 644 doc/CREDITS \$(docdir)/CREDITS
+	-install -m 644 doc/newlisp_manual.html \$(docdir)/newlisp_manual.html
+	-install -m 644 doc/newlisp_index.html \$(docdir)/newlisp_index.html
+	-install -m 644 doc/manual_frame.html \$(docdir)/manual_frame.html
+	-install -m 644 doc/CodePatterns.html \$(docdir)/CodePatterns.html
+	-install -m 644 doc/newLISPdoc.html \$(docdir)/newLISPdoc.html
+	-install -m 644 doc/newLISP-${version}-Release.html \$(docdir)/newLISP-${version}-Release.html
+	-install -m 644 doc/newlisp.1 \$(man1dir)/newlisp.1
+	-install -m 644 doc/newlispdoc.1 \$(man1dir)/newlispdoc.1
+	-install -m 644 modules/canvas.lsp \$(pkgdatadir)/modules/canvas.lsp
+	-install -m 644 modules/cgi.lsp \$(pkgdatadir)/modules/cgi.lsp
+	-install -m 644 modules/crypto.lsp \$(pkgdatadir)/modules/crypto.lsp
+	-install -m 644 modules/ftp.lsp \$(pkgdatadir)/modules/ftp.lsp
+	-install -m 644 modules/getopts.lsp \$(pkgdatadir)/modules/getopts.lsp
+	-install -m 644 modules/gsl.lsp \$(pkgdatadir)/modules/gsl.lsp
+	-install -m 644 modules/infix.lsp \$(pkgdatadir)/modules/infix.lsp
+	-install -m 644 modules/macro.lsp \$(pkgdatadir)/modules/macro.lsp
+	-install -m 644 modules/mysql.lsp \$(pkgdatadir)/modules/mysql.lsp
+	-install -m 644 modules/odbc.lsp \$(pkgdatadir)/modules/odbc.lsp
+	-install -m 644 modules/plot.lsp \$(pkgdatadir)/modules/plot.lsp
+	-install -m 644 modules/pop3.lsp \$(pkgdatadir)/modules/pop3.lsp
+	-install -m 644 modules/postgres.lsp \$(pkgdatadir)/modules/postgres.lsp
+	-install -m 644 modules/postscript.lsp \$(pkgdatadir)/modules/postscript.lsp
+	-install -m 644 modules/smtp.lsp \$(pkgdatadir)/modules/smtp.lsp
+	-install -m 644 modules/smtpx.lsp \$(pkgdatadir)/modules/smtpx.lsp
+	-install -m 644 modules/sqlite3.lsp \$(pkgdatadir)/modules/sqlite3.lsp
+	-install -m 644 modules/stat.lsp \$(pkgdatadir)/modules/stat.lsp
+	-install -m 644 modules/unix.lsp \$(pkgdatadir)/modules/unix.lsp
+	-install -m 644 modules/xmlrpc-client.lsp \$(pkgdatadir)/modules/xmlrpc-client.lsp
+	-install -m 644 modules/zlib.lsp \$(pkgdatadir)/modules/zlib.lsp
+	# GUI-Server install
+	-install -d \$(pkgdatadir)/guiserver
+	-install -d \$(docdir)/guiserver
+	-install -m 755 guiserver/newlisp-edit.lsp \$(bindir)/newlisp-edit
+	-install -m 644 guiserver/guiserver.jar \$(pkgdatadir)/guiserver.jar
+	-install -m 644 guiserver/guiserver.lsp \$(pkgdatadir)/guiserver.lsp
+	-install -m 644 guiserver/images/newLISP128.png \$(pkgdatadir)/newLISP128.png
+	-install -m 644 guiserver/COPYING \$(docdir)/guiserver/COPYING
+	-install -m 644 guiserver/index.html \$(docdir)/guiserver/index.html
+	-install -m 644 guiserver/guiserver.lsp.html \$(docdir)/guiserver/guiserver.lsp.html
+	-install -m 644 util/newlispdoc.css \$(docdir)/guiserver/newlispdoc.css
+	-install -m 644 guiserver/allfonts-demo.lsp \$(pkgdatadir)/guiserver/allfonts-demo.lsp
+	-install -m 644 guiserver/animation-demo.lsp \$(pkgdatadir)/guiserver/animation-demo.lsp
+	-install -m 644 guiserver/border-layout-demo.lsp \$(pkgdatadir)/guiserver/border-layout-demo.lsp
+	-install -m 644 guiserver/button-demo.lsp \$(pkgdatadir)/guiserver/button-demo.lsp
+	-install -m 644 guiserver/clipboard-demo.lsp \$(pkgdatadir)/guiserver/clipboard-demo.lsp
+	-install -m 644 guiserver/cursor-demo.lsp \$(pkgdatadir)/guiserver/cursor-demo.lsp
+	-install -m 644 guiserver/drag-demo.lsp \$(pkgdatadir)/guiserver/drag-demo.lsp
+	-install -m 644 guiserver/font-demo.lsp \$(pkgdatadir)/guiserver/font-demo.lsp
+	-install -m 644 guiserver/frameless-demo.lsp \$(pkgdatadir)/guiserver/frameless-demo.lsp
+	-install -m 644 guiserver/html-demo.lsp \$(pkgdatadir)/guiserver/html-demo.lsp
+	-install -m 644 guiserver/image-demo.lsp \$(pkgdatadir)/guiserver/image-demo.lsp
+	-install -m 644 guiserver/midi-demo.lsp \$(pkgdatadir)/guiserver/midi-demo.lsp
+	-install -m 644 guiserver/midi2-demo.lsp \$(pkgdatadir)/guiserver/midi2-demo.lsp
+	-install -m 644 guiserver/mouse-demo.lsp \$(pkgdatadir)/guiserver/mouse-demo.lsp
+	-install -m 644 guiserver/move-resize-demo.lsp \$(pkgdatadir)/guiserver/move-resize-demo.lsp
+	-install -m 644 guiserver/pinballs-demo.lsp \$(pkgdatadir)/guiserver/pinballs-demo.lsp
+	-install -m 644 guiserver/properties-demo.lsp \$(pkgdatadir)/guiserver/properties-demo.lsp
+	-install -m 644 guiserver/rotation-demo.lsp \$(pkgdatadir)/guiserver/rotation-demo.lsp
+	-install -m 644 guiserver/shapes-demo.lsp \$(pkgdatadir)/guiserver/shapes-demo.lsp
+	-install -m 644 guiserver/sound-demo.lsp \$(pkgdatadir)/guiserver/sound-demo.lsp
+	-install -m 644 guiserver/stroke-demo.lsp \$(pkgdatadir)/guiserver/stroke-demo.lsp
+	-install -m 644 guiserver/tabs-demo.lsp \$(pkgdatadir)/guiserver/tabs-demo.lsp
+	-install -m 644 guiserver/table-demo.lsp \$(pkgdatadir)/guiserver/table-demo.lsp
+	-install -m 644 guiserver/textfield-demo.lsp \$(pkgdatadir)/guiserver/textfield-demo.lsp
+	-install -m 644 guiserver/textrot-demo.lsp \$(pkgdatadir)/guiserver/textrot-demo.lsp
+	-install -m 644 guiserver/widgets-demo.lsp \$(pkgdatadir)/guiserver/widgets-demo.lsp
+	-install -m 644 guiserver/word-count.lsp \$(pkgdatadir)/guiserver/word-count.lsp
+	-install -m 644 guiserver/uppercase.lsp \$(pkgdatadir)/guiserver/uppercase.lsp
+
+
+uninstall:
+	-rm  \$(bindir)/\$(package)
+	-rm  \$(bindir)/\$(package)-\$(version)
+	-rm  \$(bindir)/newlispdoc
+	-rm  \$(bindir)/newlisp-edit
+	-rm  -rf \$(pkgdatadir)
+	-rm  -rf \$(docdir)
+	-rm  \$(man1dir)/newlisp.1
+	-rm  \$(man1dir)/newlispdoc.1
+
+install_home uninstall_home:
+	@echo "This option is disabled; please use the prefix variables at the configure stage."
+
+# End of file
+EOF
+
+cat <<EOF
+
+Variables:
+
+	package=${PACKAGE}
+	version=${VERSION}
+	prefix=${prefix}
+	exec_prefix=${exec_prefix}
+	bindir=${bindir}
+	datarootdir=${datarootdir}
+	datadir=${datadir}
+	pkgdatadir=${pkgdatadir}
+	docdir=${docdir}
+	mandir=${mandir}
+	man1dir=${man1dir}
+
+Type "make" to build your newlisp binary.
+EOF
+
diff --git a/doc/ANDROID.txt b/doc/ANDROID.txt
new file mode 100644
index 0000000..f28f0c5
--- /dev/null
+++ b/doc/ANDROID.txt
@@ -0,0 +1,93 @@
+Fore the following download: http://www.newlisp.org/code/newlisp-ndk-10.4.5.tgz 
+
+
+From: http://newlispfanclub.alh.net/forum/viewtopic.php?f=2&p=20877&sid=a41fb6a4fd35618d8266d88acb102297#p20877
+
+by kanen ยป Fri Dec 21, 2012 7:23 am
+
+We have it working. It's stable.
+
+It is missing (semaphore), which requires libraries that do not exist on Android. I'm attaching the full source, hoping Lutz will add everything necessary to make this work as part of the main newlisp download.
+
+Steps to compile:
+
+1. Download the android-ndk - http://developer.android.com/tools/sdk/ndk/index.html
+2. Make sure your environment works (see above documentation) on your platform
+3. Unpack and put newlisp-ndk in the android-ndk directory
+4. Compile newlisp
+
+Code:
+  kanen (~/Code/android-ndk)$ ./ndk-build -C newlisp-ndk/
+  make: Entering directory `/Users/kanen/Code/android-ndk/newlisp-ndk'
+  Compile thumb  : newlisp <= newlisp.c
+  Compile thumb  : newlisp <= nl-symbol.c
+  Compile thumb  : newlisp <= nl-math.c
+  Compile thumb  : newlisp <= nl-list.c
+  Compile thumb  : newlisp <= nl-liststr.c
+  Compile thumb  : newlisp <= nl-string.c
+  Compile thumb  : newlisp <= nl-sock.c
+  Compile thumb  : newlisp <= nl-import.c
+  Compile thumb  : newlisp <= nl-xml.c
+  Compile thumb  : newlisp <= nl-web.c
+  Compile thumb  : newlisp <= nl-matrix.c
+  Compile thumb  : newlisp <= nl-debug.c
+  Compile thumb  : newlisp <= pcre.c
+  Compile thumb  : newlisp <= nl-filesys.c
+  Executable     : newlisp
+  Install        : newlisp => libs/armeabi/newlisp
+  make: Leaving directory `/Users/kanen/Code/android-ndk/newlisp-ndk'
+
+The binary gets put into libs/armeabi/newlisp. From there, you just have to build an Android emulator and you can copy newLisp over to it.
+
+For that, you need the android-sdk - http://developer.android.com/sdk/index.html
+
+First, list the targets and find the armeabi version you want to use. I use Target 4, which isn't the most recent, but is the most widely deployed, at API level 15.
+Code:
+  kanen (~/Code/android-sdk/tools)$ ./android list targets
+  Available Android targets:
+  id: 4 or "Google Inc.:Google APIs:15"
+       Name: Google APIs
+       Type: Add-On
+       Vendor: Google Inc.
+       Revision: 2
+       Description: Android + Google APIs
+       Based on Android 4.0.3 (API level 15)
+       ABIs : armeabi-v7a
+
+Now, generate an emulator from that target platform:
+Code:
+  kanen (~/Code/android-sdk/tools)$ ./android create avd -n MyEmulator -t 4
+
+
+Then, run the emulator:
+Code:
+  kanen (~/Code/android-sdk/tools)$ ./emulator -avd TrustMe
+
+Attach a shell to the emulator:
+Code:
+  kanen (~/Code/android-sdk/platform-tools)$ ./adb shell
+
+Make sure everything's ok and create a directory for newLisp:
+Code:
+  # mkdir /data/nl
+  # chmod 777 /data/nl
+  # exit
+
+
+Copy newLisp to the emulator:
+Code:
+  ./adb push ~/Code/android-ndk/newlisp-ndk/libs/armeabi/newlisp /data/nl
+
+
+Go back into the shell and run newLisp:
+Code:
+  kanen (~/Code/android-sdk/platform-tools)$ ./adb shell
+  # cd /data
+  # cd trustpipe
+  # ls
+  newlisp
+  # ./newlisp
+  newLISP v.10.4.5 on Linux IPv4/6, execute 'newlisp -h' for more info.
+
+  >
+
diff --git a/doc/Android.html b/doc/Android.html
new file mode 100644
index 0000000..f5a4dcf
--- /dev/null
+++ b/doc/Android.html
@@ -0,0 +1,97 @@
+<body style="font-family: Helvetica, Verdanan, Arial, sans-serif;">
+<h2>Make newLISP for Android Linux</h2>
+<p>Download the latest version of the newLISP Android source distribution from the 
+<a href="http://www.newlisp.org/index.cgi?page=Downloads"> downloads page</a></p>
+<p>This package can also be made using the following command from the main distribution directory:</p>
+<pre>
+  make android_dist
+  # or
+  make android_dist_utf8
+</pre>
+<p>This will make a newlisp-ndk-x.x.x.tgz in the parent directory of the distribution directory where x.x.x is the version number.</p>
+<p>It is missing the <tt>semaphore</tt>, which requires libraries that do not exist on Android. It also does not contain the READLINE compile flavor. UTF8 support can be added by making a source package using <tt>make android_dist_utf8</tt>.</p>
+
+<p>In order for <tt>share</tt> to work for more than 4072 bytes a <tt>/data/tmp</tt> directory must be created on the Android device. This directory is also required if more than 4072 data are transferred when using the <tt>spawn</tt> function.</p>
+
+<p>Thanks to <i>Kanen Flowers</i> from <a href="http://www.scruffy.tv/">www.scruffy.tv</a> for doing the adaptation to the Android flavor of Linux and putting together the following instructions:</p>
+
+<h2>Steps to compile:</h2>
+<ol>
+<li>Download the <a href="http://developer.android.com/tools/sdk/ndk/index.html">android-ndk</a></li>
+<li>Make sure your environment works (see above documentation) on your platform</li>
+<li>Unpack and put newlisp-ndk in the android-ndk directory</li>
+<li>Compile newlisp</li>
+</ol>
+<pre>
+  kanen (~/Code/android-ndk)$ ./ndk-build -C newlisp-ndk/
+  make: Entering directory `/Users/kanen/Code/android-ndk/newlisp-ndk'
+  Compile thumb  : newlisp <= newlisp.c
+  Compile thumb  : newlisp <= nl-symbol.c
+  Compile thumb  : newlisp <= nl-math.c
+  Compile thumb  : newlisp <= nl-list.c
+  Compile thumb  : newlisp <= nl-liststr.c
+  Compile thumb  : newlisp <= nl-string.c
+  Compile thumb  : newlisp <= nl-sock.c
+  Compile thumb  : newlisp <= nl-import.c
+  Compile thumb  : newlisp <= nl-xml.c
+  Compile thumb  : newlisp <= nl-web.c
+  Compile thumb  : newlisp <= nl-matrix.c
+  Compile thumb  : newlisp <= nl-debug.c
+  Compile thumb  : newlisp <= pcre.c
+  Compile thumb  : newlisp <= nl-filesys.c
+  Executable     : newlisp
+  Install        : newlisp => libs/armeabi/newlisp
+  make: Leaving directory `/Users/kanen/Code/android-ndk/newlisp-ndk'
+</pre>
+<p>The binary gets put into <tt>libs/armeabi/newlisp</tt>. From there, you just have to build an Android emulator and you can copy newLISP over to it.</p>
+<p>For that, you need the <a href="http://developer.android.com/sdk/index.html">android-sdk</a>.</p>
+<p>First, list the targets and find the armeabi version you want to use. I use Target 4, which isn't the most recent, but is the most widely deployed, at API level 15.</p>
+<pre>
+  kanen (~/Code/android-sdk/tools)$ ./android list targets
+  Available Android targets:
+  id: 4 or "Google Inc.:Google APIs:15"
+       Name: Google APIs
+       Type: Add-On
+       Vendor: Google Inc.
+       Revision: 2
+       Description: Android + Google APIs
+       Based on Android 4.0.3 (API level 15)
+       ABIs : armeabi-v7a
+</pre>
+<p>Now, generate an emulator from that target platform:</p>
+<pre>
+  kanen (~/Code/android-sdk/tools)$ ./android create avd -n MyEmulator -t 4
+</pre>
+<p>Then, run the emulator:</p>
+<pre>
+  kanen (~/Code/android-sdk/tools)$ ./emulator -avd MyEmulator &
+</pre>
+<p>Attach a shell to the emulator:</p>
+<pre>
+  kanen (~/Code/android-sdk/platform-tools)$ ./adb shell
+</pre>
+<p>Make sure everything's ok and create a directory for newLisp:</p>
+<pre>
+  # mkdir /data/nl
+  # chmod 777 /data/nl
+  # exit
+</pre>
+<p>Copy newLisp to the emulator:</p>
+<pre>
+  ./adb push ~/Code/android-ndk/newlisp-ndk/libs/armeabi/newlisp /data/nl
+</pre>
+<p>Go back into the shell and run newLisp:</p>
+<pre>
+  kanen (~/Code/android-sdk/platform-tools)$ ./adb shell
+  # cd /data
+  # cd nl 
+  # ls
+  newlisp
+  # ./newlisp
+  newLISP v.10.4.5 on Linux IPv4/6, execute 'newlisp -h' for more info.
+
+  >
+</pre>
+
+<center>+++</center>
+</body>
diff --git a/doc/CHANGES b/doc/CHANGES
new file mode 100644
index 0000000..753fcb4
--- /dev/null
+++ b/doc/CHANGES
@@ -0,0 +1,7149 @@
+6.0.25
+'find', 'replace' and 'search' now have an option for case insensitive
+search, updated source and manual
+
+6.0.26 - 6.0.27 - 11:34 AM 4/4/99
+'trace' got stuck in executeCommandline() in traceExit() because an empty
+ fgets() in LINUX still has a '\n'
+
+6.0.27 - 6.0.28 - 6:30 PM 4/6/99
+'import' now returns primitve address
+'define' now also works like (define x y) ; as in SCHEME
+'char' now defaults to 0 on offset and returns unsigned int
+new 'mod' floating point modular function
+new 'abs' floating point absolute value function
+new 'trim' trims spaces or characters both sides
+
+6.0.28 - 6.0.29
+'filter' new primitive
+
+6.0.29 - 6.0.30
+'dump' now displays address of cell
+'make-dir' mode parameter now optional defaults to 493 = drwxr-xr-x
+
+6.0.30 - 6.0.31
+fixed trim, which had all kinds of problems
+new 'difference' returns set difference of two lists
+new 'intersect' resturns set intersection of two lists
+new 'unique' returns unique set from list (duplicates removed)
+when comparing lambda expressions, now state lists also get compared
+
+6.0.31 - 6.0.33
+'match' now also works on list expressions, wildcard symbols 
+can occur on different nesting levels. 
+ 
+6.0.33 - 6.0.34 Released on www.newlisp.org
+in 'substring' the length parameter is now optional 
+math exception showed wrong error message 
+tty setup now only when tty detected else supress buffering 
+for usage with 'socker'
+
+6.0.33 - 6.0.35 4/20/2000
+inlined cleanupResults() in evaluateExpression() ca. 4% speedup !
+took out all #pragma statements
+took out termio stuff, works better without
+new functions read-file, write-file
+new functions read-process, write-process
+new function error-text
+
+6.035 - 6.0.36 4/21/2000
+'char' now also can take a number as an argument converting it to a 
+string of one character: 
+(char 65) => "A"
+(char "A") => 65
+'integer' and 'float' now return 'nil' if the string passed does
+not start with a number digit or +/-
+strings can now encode characters in the form \nnn where nnn
+is a 3 digit decimal (leading 0' if less 100) e.g.:
+"\065\066\067" => "ABC"
+
+6.036 - 6.039 4/28/2000
+added 'chop', 'explode', 'get-float', 'starts-with', 'ends-with'
+added 'random' 'normal'
+renamed 'get-number' to 'get-integer'
+added script for httpd webserver demon
+
+6.039 - 6.043
+'symbol' now takes optional context argument
+'symbols' now gives error message if symbol args is not context
+eliminated 'sourcePtr' which wasn't used anyway, introduced
+'sourceLine' for keeping track of line-numbers in error messages
+added 'encrypt' for one-time-pad encryption/decryption
+
+6.043 - 6.044
+speedup in deleteList() and copyList()
+
+6.044 - 6.045
+took out 'sourceLine', too much confusing situtations which are
+unresolvable. 'eval-string' now does multiple expressions
+
+6.045 - 6.048
+put back pushResultFlag, 'eval' needed it. 
+fixed bug in 'substring' for trailing 0's, changed tokeString to 
+resemble split() and taking separators > 1 char.
+This also changes pack/unpack in parsePackFormat() to take care of
+more than one space between formats. 
+After reset and execution of 'error-event' errorReg now set to 0.
+
+6.048 - 6.049
+took out executeSymbolParams modifying executeParams for optional arg
+'reset' now throws 'user reset - no error' - error, so it can be handled as
+a non-error in user defined error handlers, also takes now optional
+symbol for 'resetEvent to be exuted after errorEvent.
+
+6.049 - 6.051
+'reset' now takes optional third parameter for stacksize. So the
+syntax for reset is nor (reset [resetEventSymbol] [stacksize])
+
+6.051 - 6.052
+no length limitiation anymore for printing strings to the console
+'replace-nth' new primitive
+
+6.052 - 6.054 5/19/2000
+'let' new primitive like in other Lisp but dynamically scoped
+'seed' new primitive seeds random generator for rand, random, normal
+now feature complete for 6.1 release
+
+6.054 - 6.055 5/20/2000
+fixed memory leek in varPrintf()
+'integer' and 'float' now take optional thirsd parameter for default
+return value if string cannot be parsed.
+
+6.055 - 6.056
+fixed bug in 'symbol' which would not overwrite symbols in MAIN for
+symbols in other contexts so (symbol "set" 'MyContext) now works
+creating a symbol 'set in MyContext.
+
+6.056 - 6.059 5/29/2000
+improved pretty printing for 'let', which takes now the same flag
+as 'cond'. Improved httpd script, now sends http header for each
+file.
+
+6.059 - 6.060 5/29/2000
+httpd did fail on POST on some browsers now 'upper-case' when matching
+'content-length'. Alos fixed in manuual
+
+6.060 - 6.0.61
+changed 'parse' so it parses a max token length of 2048 (256 previous)
+this was already changed erarlier on the Win32 versions.
+The read-line limit of 16384 should be changed at some point to infinite
+similar to the print buffer. At the moment cgi vi std/IO is limited by
+read-line to forms no bigger than 16384.
+
+6.0.61 - 6.0.62
+varPrintf was still limited. MAX_PRINT_LEN changed to size.
+
+6.0.62 - 6.0.63
+'integer' now parses also hex strings eg: (integer "0xFF") => 255
+'write-line' now retuenw nil on file errors
+
+6.0.63 - 6.0.64
+5% speedup introducing cell type masks
+
+6.0.64 - 6.0.65
+1% speedup taking out symbol in evaluateExpression
+
+6.0.65 - 6.0.67
+new 'count' counts elements of one list in another list
+
+6.0.67 - 6.0.68
+fixed error in 'reverse'
+
+6.0.68 - 6.0.69
+'parse' now without size limitations in tokens when using breakstr argument.
+
+6.0.69 - 6.0.70
+'string' now without size limitations of printing in string
+
+6.0.69 - 6.0/71
+'read-line' now without size limitations
+
+6.0.71 - 6.0.72
+'for' fixed bug when from and to where equal would run forever
+
+6.0.72 - 6.0.73
+'putenv' didn't work, fixed
+
+6.0.73 - 6.0.75
+problem with ebaluateLambda when passing (set 'p ...) to (foo p) as an argument 
+for parameter p.
+
+6.0.75 - 6.0.76
+additional functions: prob-z prob-chi2 and crit-chi2. (for ...) no works with
+floating point numbers. Additional module xml.lsp
+
+6.0.76 - 6.0.77
+additional function: join. Additional module mail.lsp
+additional function: sequence
+
+6.0.77 - 6.0.79
+additional functions: xml-parse, xml-error
+fixed buffer overflow bug in varPrintf to string device (function 'string)
+
+6.0.79 -> 6.1.0
+new function println
+6.1.14 documentation
+
+6.1.0 -> 6.1.1
+new function fft and ifft
+6.1.15 documentation
+
+6.1.1 -> 6.1.2
+the length parameter in 'sublist' is now optional (assumes all)
+
+6.1.2 -> 6.1.3
+fixed default for 'true' in 'case'
+
+6.1.3 -> 6.1.4
+new function 'swap' for swapping elements in a list
+
+6.1.4 -> 6.1.5
+new function 'read-url' for reading pages/files via http
+revision of httpd script more RFC compliant
+
+6.1.5 -> 6.1.6
+'read-url' nl-web.c now handles proxy's if HTTP_PROXY is set to proxy URL
+new functions 'collect'and 'select' for selecting multiple elements from a
+list
+
+6.1.6 -> 6.1.7 Release
+'rand' now takes an optional second parameter to return a list of random
+numbers (similar to 'random' and 'normal')
+many formatting changes in manual.
+
+================================================================================
+6.1.7exp -> experimental '-p port' mode
+
+6.1.7 -> 6.1.8
+fixed bug in error event handling when error==0
+
+6.1.8 -> 6.1.9
+trace now is a source level debugger, similar in funcitonality to the Win32
+version, but for a character console.
+linking now encrypted, new functions 'betai' and 'gammaln'
+
+6.1.9 -> 6.1.10 
+fixed bug which could affect parsing \xxx in getToken() where isdigit(x)
+'prob-chi2' now more precise using gammap(),
+new functions 'crit-z', 'beta' and 'gammai'
+
+6.1.10 -> 6.1.11
+new 'debug-highlight' for setting pre and post string in debugger
+highlighting. Eliminated example httpget because 'read-url' does
+the same. 
+
+6.1.12 -> 6.1.12
+'swap' now treats negative values as the last element, consistent
+with other functions, 'read-url' fix in error message text
+init.lsp, mysql.lsp etc have moved to /usr/local/newlisp
+
+6.1.12 -> 6.1.15
+'read-url' now handles also redirects
+
+6.1.15 -> 6.1.16
+fixed bug in trace mode, trace stopped at all args evals in function
+calls. Still stops and shows result for each 'map', which is ok, but
+must be documented. Improved subroutines for handling POP3 and SMTP mail.
+
+6.1.16 -> 6.1.17
+new matrix functions 'invert', 'multiply', 'transpose'
+
+6.1.17 -> 6.1.18
+fixed dimension problem in transpose
+
+6.1.18 - > 6.1.19
+fixed missing error text for 'singular matrix' in invert
+
+6.1.19 -> 6.1.20
+ifft didn't normalize right when N not a power of 2
+evaluateLambda() rewritten to store statics in a way that
+anonymous lambda expressions with static data can be stored
+this also gave a general speed up of about 5%.
+
+6.1.20p2
+(nth -1 lst) now returns the last element instead of nil. This
+is consisten with other functions
+
+6.1.20p4
+eliminated optional parameters in reset, because never worked right.
+instead the error-event can be used for code after reset and the stack
+size can now be specified on the command line.
+
+6.1.20p5
+eliminated get-state and set-state as primitves, they are now written
+in newLISP and part of the initialization file /usr/local/newlisp/init.lsp
+
+6.1.20p6
+new function 'regex for POSIX 1003.2 regular expressions (GNU library)
+ifdef'ed readline, only works in CYGWIN, cannot figure unresolved 'tputs()' etc in
+libreadline.so in LINUX, seems not to see libcurses?
+
+6.1.20p7
+cleanup makefile for different features NANOSLEEP, READLINE, REGEX
+cleanup fft
+took out replace-match, new function index
+
+6.1.20p8
+cleanup regex, additions changes in manual
+
+6.1.20 -> 6.3.pre1
+READLINE finally working on Mandrake missing link to 'libtermcap.so'
+lots of manual changes
+ 
+6.3.pre2
+preparing to replace simple binary tree for symbols woth RB balanced tree
+
+6.3.pre4
+running RB balanced tree code
+
+6.3.pre5
+fixed bug in 'symbols for context and 'delete for context
+
+6.3.pre6
+changed httpd CHANGES
+===============================================================================
+6.3 Release
+time-of-day new function
+
+6.3.01
+a fix for 'regex' in the CYGWIN version sent in by Steve Adams
+
+6.3.02
+additional optional parameter in 'eval-string'
+streamlining code in nl-web.c, reformatting manual so it is easier converted
+to PDF
+
+6.3.04
+new -p commandline parameter for TCP/IP port mode of newLISP.
+Fixed format for default data type (will treat as string),
+also format will permit now unlimeted size of the formatted 
+output (was 2047 bytes).
+
+6.3.05
+cleanup -p with trace for rt/lf translation
+
+===============================================================================
+6.3.06 Release  July 8th, 2001
+optional parameter 'nil in 'eval for silent evaluation evaulates without return
+value and prompt on the console, needed for Tcl/Tk integration
+
+6.3.07 Release
+a new function 'debug (shortcut fr using trace) and various bugfixes in the
+trace/debug functions. '{' and '}' characters are allowed as string delimiters
+but only on the outer level, they get replaced by the parser. This allows
+writing 'nicer' source for HTML and TK stuff.
+
+6.3.08
+regex now also returns sub expressions. further changes in debugger to accomodate
+remote TclTk controlled debugging: (q)uit now quits execution, (c)ontinue stops
+debugging but continues execution.
+
+===============================================================================
+6.3.09 Release July 16th, 2001
+string now can take more than one parameters, like concat but works on different
+data types
+
+6.3.10
+added symbol count to 'sys-info'
+added ERR: string in error message when in trace for TclTk frontend
+
+6.3.11
+new function 'dotree' to iterate thrugh symbol trees, usefull for simulating
+arrays and hashes
+
+===============================================================================
+6.3.12 Release July 30th, 2001
+new function 'catch' for catching errors when evaluating expressions
+fixed bug in net-connect when trying to connect to dead port
+
+===============================================================================
+6.3.14 Release August 2nd, 2001
+changes in newlisp_manual.html and newlisp-tk.html
+cleanup and improvment of qa file
+fixed crash-bug in markReferences and saveSymbol when copying contexts
+function 'args' now works also for lambda, no symbol param necessary anymore
+===============================================================================
+6.3.15 Release September 3rd, 2001
+xml-parse now accepts empty atribute value strings e.g.: <ATAG ATT=""></ATAG>
+net-lookup now works in both directions: ip->name and name->ip
+===============================================================================
+6.3.16 Release September 6th, 2001
+float division by 0.0 now yields 'Inf', as specified by IEE 754. Before 6.3.16
+it would couse a Math exception. Now all compare operations with NaN return 'nil'.
+new functions 'floor' and 'ceil' and 'NaN?'.
+ 
+Ctrl-D will now longer crash but exit newLISP
+
+More LSB compliance in install directories used: now /usr/share/newlisp
+instead of old /usr/local/newlisp
+
+===============================================================================
+6.3.17 Release September 9th, 2001
+fixed a memory leak in 'regex'. The leak could not be fixed in the CYGWIN
+version which uses regexp !
+
+
+6.3.18
+fixed rounding problem in 'sequence', Ctrl-D will not exit but only do newline
+if at beginning of line, else it will behave as expected under readline, to exit
+newLISP with one keystoke use Ctrl-C instead.
+output cleanup in error-text and error-event
+better standard behaviour of 'cond' when action clause is missing
+new function 'series' for generating geometric sequences.
+new function 'rotate' for rotating lists
+
+6.3.20 Release October 22nd, 2001
+bug fix in xml-parse when parsing closing tags without opening tags
+bug fix memory leak in catch and eval-string uder error conditions
+about 30% speedup removing copyCell/pushResult in: inc set define
+manual changes and additions.
+tookout net-cleanup in  network examples
+
+6.3.21p1
+bug fix in 'char' when using with floats
+'integer' now also takes floats converting them into integer
+also now translates "055" to 45 taking it as an octal number,
+which is consistend now with the parser.
+'float' now also takes integeres converting into floats
+
+6.3.21p2
+eliminated symbol->type in SYMBOL typdef, which reduces symbol memory by from 36 to 32 byte
+fixed a bug where sometimes newlisp wouldn't exit after tk-frontend exited
+
+===============================================================================
+6.3.21 Release November 13th, 2001
+MAX_ERROR_NUMBER was to high, parenthesis count wasn't reset when evalCatchFlag
+
+6.3.22
+fixed potential bug in join with memory intialization
+fixed problem parsing URL when redirection in 'read-url'
+'get-url/read-url' now also handles 205 and 307 return codes
+'get-url/read-url' now always only returns header portion if "header" option is specified
+new -d demon mode, like -p but newLISP stays in memory to accept a new connection
+new function 'put-url' for HTTP PUT method
+new function 'post-url' for HTTP POST method
+
+===============================================================================
+6.3.23 Release January 6th, 2002
+new function 'binomial'
+
+6.3.24
+'exit' now closes net work connection when running in '-d' demon mode.
+new function 'now' returns detailed date/time info: (y m d h m s us dy dw)
+new function 'date-value' converts date/time into seconds since 1970-1-1
+new financial functions 'pmt', 'nper', 'pv', 'fv', 'npv'
+bug fix in 'map' which would crash when last arg was not a list (as it should be)
+replaced 'MySQL:close' with 'MySQL:close-db' to avoid overwriting of close in MAIN in mysql.lsp
+
+===============================================================================
+6.4.00 Release March 20th, 2002
+inclusion of BWidget set in the Win32 tk v 0.80 distibution, many manual changes
+
+6.4.1
+main-args now returns path of program as first list member
+get-url "debug" option now can be specified together with "header" option
+post-url content-type now is optional and defaults to "application/x-www-form-urlencoded"
+added closing channel in get-url
+fixed bug in 'join', which could crash on an empty list
+httpd, finger and gettime changes for new 'main-args'
+balloon help in newlisp-tk v. 081
+new '(tk-args)' when running Tcl/Tk frontend returns newlisp-tk commandline args
+several changes in stat.lsp/plot directing temporal files to /tmp
+fixed potential crash bug in 'dotree'
+Win32 installer now puts desktop icon
+
+===============================================================================
+6.4.2 Release April 22nd, 2002
+'format' now for multiple args
+
+6.4.3 development release
+'parse' now correctly does handles trailing separator by returning an empty token ""
+
+6.4.4
+buffer limit in vsnprintf() was not handled correctly, putting a space limitation
+on 'string' (16k), 'format' (2k) and 'C' functions depending on varPrintf(),
+fixed potential buffer overflow in writeStreamStr().
+'tranpose' did not check for matrix type.
+experimental function 'throw'
+
+6.4.5 Development release
+starts-with, ends-with 
+now are working type polymorph on strings and lists
+rotate now takes negative numbers for left rotation
+rearranged lambda evaluation (eval args before saving environment),
+which causes 6% speed improvements
+'args' only available in define-macro (again as before 6.3.14)
+changed 'if', 'unless', 'while', 'until' for less CPU stack requirements
+
+6.4.6
+'nth', 'first', 'last', 'rest'
+now are working type polymorph on strings and lists
+'cons' works now correctly on 1 arg  (who cares? -> consistency proof)
+potenial cell-memory leak on error in 'apply'
+
+6.4.7 Development release
+improved syntax for statics environment list as assoc list:
+(define  (foo a b c ((x 1) (y 2) (z 3))) ....)
+to retrieve statics environment just do:
+(last (first foo) => ((x 1) (y 2) (z 3))
+also improves speed of ststic processing by about 10%
+
+===============================================================================
+6.4.8 Release May 16, 2002
+empty? now works on strings
+fix for 'cons' when lambda expr is second argument
+fix for (rest "") which now returns ""
+fix for (first "") now returns nil
+purelisp.lsp for prooving consistency
+fix for link.lsp on CYGWIN
+
+6.4.9 Development release May 21st, 2002
+'nil' as a symbol was not always treated as nil value constant
+(push exp lst) now works even if lst does not contain a list
+in that case old contents of lst gets deleted and initialized
+with () before pushing exp, this makes initialization of lists
+to '() before pushing on it unnecessary.
+'time' now works as a timer returning mseconds needed to evaluate
+this is also mor compatible how other Lisp's define 'time'
+an expression, for old funcitonality of 'time' use (apply date-value (now))
+'sort' now takes an optional parameter '< or '> for ascending/descending
+also about 30% speedup, like in: (sort myList '>)
+
+6.4.10 Development release May 21st, 2002
+correct treatment of symbol 'nil in 'and' and 'or'
+eliminated orSymbol reference in soirce code
+speedup parsing source
+dump with parameter now returns list (cellAdress, cellType, cellNext, cellAux, cellContents)
+stepsize in 'for' 'sequence' always forced to positive
+
+6.4.11
+'push' in its new form did not respect 'nil and 'true
+new error message when trying to set/define/push on 'nil, 'true or context
+speedup in multiple compares in nl-math.c 
+speedup in upper-case, lower-case
+speedup in get-char, get-string, get-integer and get-float
+
+
+6.4.12
+boolean types and symbols are equal
+another speed improvement in lambad and expression evaluation
+over all speed improvement over 6.4.8 now about 5-10% depending
+on expression mix.
+local iterator symbols are now handled on environment stack for
+better error recovery.
+new chapter "Data structure objects in lists" in docs and
+many little doc changes.
+
+===============================================================================
+6.5.0 Release May 28th, 2002
+no changes related to newlisp itself except for versioning
+changes in httpd (see httpd file)
+changes in newlisp-IDE for changes in httpd and changes for date display
+
+6.5.1
+compiles with -Wall -pedantic -Wno-uninitialized -O2 
+-Wall -pedantic for better portability
+-Wno-uninitialized to suppress 'fork' 'longjmp' warning in -O2
+-O2 does ~25% speed and size improvement!
+'let' did not handle empty parameter lists and now double fast
+
+6.5.2 development release June 3rd
+'concat' is deprecated 'append' doubles functionality of 'concat'
+new individual makefiles for making newLISP on different platforms without
+the need to tweak makefiles.
+
+6.5.4
+'find', 'replace' and file 'search' now can do Regular Expressions.
+Regular Expressions are not dependend any more on the C-library
+on the OS platform used, instead PCRE (Perl Compatible Regular Expressions)
+is used on all platforms and the source is contained in the distribution.
+Additions to INSTALL file about PCRE and localization of newLISP.
+
+6.5.5
+fix for 'replace' in regex mode
+
+6.5.5 -> 6.5.7
+changes in win32.lsp and makefile_win32
+eliminated file: nl-importDM.c was already merged
+new chapter 'Lambda expressions in newLISP' in newlisp_manual.html
+
+===============================================================================
+6.5.8 Released version (functionally equal to 6.5.7) June 13th 2002
+#ifdef NOIMPORT instead of MAC_OSC in evaluateExpression()
+spelling stuff in newlisp_manual.html
+
+6.5.10
+- incorporated nl-web.c into native win32 version to make work get-url, post-url
+and put-url. Server modes -p and -d now are working too in native win32 version.
+
+- newlisp-tk.tcl changed to work with win32 because read-line/write-line don't 
+work on sockets in win32. 
+
+- writeStramChar() now works also on binary streams
+
+- newlisp-tk.tcl changed to work on remote connection over the internet.
+Shows acceptable speed on dial-up (old newlisp-tk.conf should be deleted)
+
+- 'reload last' button in newlisp-tk GUI
+
+- dependency fix in makefile_win32
+
+
+6.5.11
+- moved to Borlanc C++ v5.5 compiler, gives faster and smaller executable than 
+ Digital Mars compiler previously used. Now all functions of the Linux version
+ also work in the Win32 version.
+
+6.5.12
+- changes in newlisp-tk.tcl for faster performance on remote and working
+  reliable with win32 version. Old newlisp-tk.conf should be deleted.
+  Win-tk version can now be distributed without CYGWIN DLLs using the
+  Borland 'C' Win32 compile.
+
+6.5.13
+- fixed problem in 'net-receive', which was introduced in 6.5.10
+  httpd now works fine with win32 compile (with change in line 147 of httpd)
+
+- send() in net-send and win32_fprintf() now performs check and resend
+
+6.5.14
+- reintroduced writeStreamChar in 'net-receive', writeStreamChar did not zero buffer
+- debug was broken with TK because of missing redefine of fgets() in nl-debug.c
+
+6.5.15
+- net-close wasn't working in win32 version, which gave problems in cgi in httpd
+- new newlisp-IDE-1.3.tgz with fixes for LF -> RET/LF translation which was happening
+  in win32 pipes
+
+6.5.16
+- doc changes
+- took out again size-check and resend in netSend() and win32_fprintf() as it is
+  not relevant in blocking sockets
+- mail.lsp was broken because of change how optional parameter in 'find' works
+- 'read-process' and 'write-process' collapsed to 'exec'
+- match for lists now behaves like match for string returning a list of matches
+  ie. (match '(I * you) '(I love you)) => (I (love) you)
+  this allows easier substituting of star/* patterns in pattern matches in chat
+  robots
+
+6.5.17
+- new option# parameter in 'xml-parse' 
+    (a) option# 1 to surpress white-space TEXT fields (for data XMLs)
+    (b) option# 2 to surpress empty attribute tags (for tags which never have attributes)
+    (c) option# 4 to surpress comments
+    (d) option# 8 to tanslate tag names into symbols
+
+- new 'xml-type-tags' for definig alternative tags for "ELEMENT", "CDATA", "COMMENT"
+  and "ELEMENT". Instead symbol can be defined or nil can be specified to surpress
+  the type tag completely.
+
+- the newlisp-tk_win32 version now comes with the win32 native compile
+
+- fixed bug in 'string', which was not reentrant
+
+===============================================================================
+6.5.18 Release August 3, 2002
+- fixed stream problem in 'eval-string' in Win32
+- fixed openStrStream, didn't initialize stream->handle to 0
+
+6.5.19
+- doc changes, renamed mail.lsp to pop3.lsp, sendmail.lsp to smtp.lsp
+- memory initialization in p_format()
+
+6.5.20
+- fixed p_format again, vsnprintf() doesn't include null-char in return count
+  as advertised in GNU docs
+- doc changes
+
+6.5.21
+- 'explode' now also works on binary contents
+- 'file-info' modification and creation time where added
+- can now specify \000 in string constants
+- in imported function now up to 10 parameters (previous 8)
+- odbc.lsp module for ODBC communications
+
+6.5.22
+- comparing symbols now includes the context name in their comparison
+- 'name' new function to extract the name of a symbol as astring without the context
+- milli second resolution in 'time-of-day', 'now' and 'time' in Win32
+- newlisp_manual.book for conversion html->pdf with HTMLDOC http://www.easysw.com
+  this makes a printable manual. Print double sided then cut 8.0 x 9 inch, which is
+  2 from the bottom and 0.5 from the right side when printed on 8.5 x 11 inch paper;
+  then spiral bind (thin round spirals, not the flat once).
+- post-url was never working on win32 becuase of missing win32_fwrite
+
+
+===============================================================================
+6.5.23 ----------- released September 17, 2002
+- httpd fix for empty query string 
+- newlisp-IDE-1.6.tgz now saves files up to 10k, changed POST encoding to multi part
+
+6.5.24
+- quote wil not evaluate it's argument anymore, but work like Scheme or Common Lisp
+- in newlisp-tk the lisp file estension can now be configured in newlisp-tk.config
+- in Win32 now line termination gets written as RT-LF, 
+  change also in newlisp-tk.tcl when filling editbox
+- net-read-line now protected from deletion in newlisp-tk browser
+- prettyPrint will never put newline after quote
+- fixed prettyPrint bug when printing empty prettyPrint constructs (while, dotimes etc)
+
+6.5.25
+- quote fixed again (quoted twice)
+
+6.5.26
+- doc fixes
+- date crashed on values resulting in dates before 1970-Jan-1 00:00:00
+  in the Win32 version. In Win32 now minimum value for date is 86400,
+  which is safely on or after 1970-Jan-1 00:00:00 for all time zones
+- NaN can now be put into a variable for comparison
+- division by zero now causes a math exception also in floats (previously
+  inf was returned in cygwin/Unix version and Win32 crashed)
+- in mixed arithmetik using integer operators NaN is taken as 0
+
+6.5.27
+- new function 'constant' to protect symbol contents from changing
+- fixed bug in newlisp-tk.tcl which was introduced after 6.5.23
+  which caused problems in Mouse.lsp (_result -> result in 'tk')
+- 'div' with NaN value raised exception/crashed in Win32, now
+   returns NaN
+- DOMAIN error messages in the Win32 versions are now silenced
+
+6.5.28
+- doc changes
+- new function 'setq', both 'set' and 'setq' and now can take multiple args
+  note that old init.lsp should be updated because of macro for 'setq'
+- new option number 16 in xml-parse for generating SXML output
+
+- 7.0.0 pre release
+- bug fix for 'string', suppresses all pretty-print formatting
+- better error reporting on pop3.lsp and smtp.lsp with debug-flag true
+===============================================================================
+- 7.0.1 release October 24, 2002
+  merged caveGuy's pop3.lsp mail-id improvements
+
+- 7.0.2
+- readLineStream was not initizlized during program startup and caused
+  'current-line' to crash if not used after a 'read-line'
+- direct execution mode with new command line option -e
+- in SXML parsing attribute tags where left strings instead of symbols
+- 'find' now also does regex when looking up a string in list of strings
+
+- 7.0.3
+- example in newLISP for put.cgi in newlisp_manual.html
+- include cgi.lsp in distribution
+- the header in the SMTP interface smtp.lsp was not finished with empty line
+- 'save now can save multiple contexts and/or symbols at once
+- 'open now has a "append" or "a" option
+
+===============================================================================
+- 7.0.4 release February 2, 2003
+  replace now gives error instead of returning 'nil when second arg not
+  list or string
+  new primitive 'lookup' works like assoc with extracting parameter
+  fixed bug in pop3.lsp
+  moved to version 5.4 of Freewrap for making the newlisp-tk.exe, which
+  is now doubled in size because 5.4 doesn't compress anymore (see Freewrap
+  docs).
+
+- 7.0.5
+  Manual improvements in for correct conversion with HTML2DOC
+  additional hour offset parameter in 'now' and 'date'
+  fixed bug in dotree which caused crashes on Windows
+  'context', 'dotree' and 'symbols' now accept unquoted
+  symbol if the symbols is a context.
+  contexts can be deleted again when empty
+  The newlisp-tk Windows version is now wrapped with freewrap v.5.5
+  and based on Tcl/Tk version 8.4.1 and BWidget v.1.6
+  newlisp-tk.tcl has been changed for better usage of 'context'
+
+- 7.1.0-rc1
+  PCRE Perl Compatible Regular Expression support updated to version 4.3
+  in 'replace' now replacement pattern with back references and as 
+  lisp expression. Sub expressions are stored in variable $1, $2 ... etc.
+  $0 contains the whole pattern found. These variables are also filled
+  in 'regex' 'find' (all functions doing regular expressions).
+  The new implementation of 'replace' is also faster (about 15%).
+  example: 
+  (replace "%([0-9A-F][0-9A-F])" str (char (integer(append "0x" $1))) 1)
+  This will do URL translation i.e.: "xxx%41xxx%42" -> "xxxAxxxB".
+
+- 7.1.0-rc2
+  'parse' can take regular expressions in sepearator when additional
+  options parameter is defined (as in find, replace)  
+
+===============================================================================
+- 7.1.0 Release August 28, 2003
+  'search' like 'find' and 'replace' also accepts regular expression
+  when extra options parameter is given.
+  [text] and [/text] can be used as string limiters for large text regions
+  i.e. for HTML in cgi pages written with newLISP. Text limited this way
+  stays completely unprocessed and contain any characters.
+  The function 'symbol' accepts unquoted symbol for context parameter
+  (like 'dotree', 'context', 'symbols')
+  PCRE Perl Compatible Regular Expression support updated to version 4.4
+  extensive manual changes formatting and PDF release  
+
+- 7.1.1
+  surpression of some compiler warnings in Mac OSX compile
+  makefile for linux has strip turned on and readline support
+  was not the default
+
+- 7.1.2
+  third parameter in 'symbol' for supression of symbol creation, if
+  not found; return 'nil instead.
+  HTML manual had formatting error, which caused all after 'regex'
+  to be in curier.
+
+===============================================================================
+- 7.1.3 release September 3, 2003
+  [text]...[/text] caused problems in TCP/IP communications
+ 
+===============================================================================
+- 7.1.4 release September 6, 2003
+  uninitialized memory in writeStreamStr() caused problems when
+  running newlisp-tk and transferring bigger string buffers.
+  win32_fprintf() did not work right for buffers > 2048, which
+  caused problems in browsing bigger buffers in newLISP-tk.
+
+- 7.1.6
+  new function 'process' for launching independent child processes
+  (will not block), new function 'pipe' for use with child processes.
+
+  'if' now accepts multiple condition-exp pairs and then works like a
+  cond without parenthesis around condition-value. 'if' with
+  condition-exp-exp or condition-exp still works like before.
+
+  new 'net-send-udp' and 'net-receive-udp' for UDP communications
+  without need of net-listen,net-accept and net-connect. 
+
+  On Mac OSX 'import' is now enabled using to addtional files
+  osx-dlfcn.n/h for compiling. This import is for '.dylib'
+  libaries.
+  'append' now also can append binary strings (i.e. containing 0's)
+  'joint' now also can joint binary strings (including the joint string)
+
+  if the length of a sublist in slice is 0 then sice returns the empty
+  list '(), previously returned nil. This is more consistent with the
+  behavior of slice on strings and at the end of lists.
+
+  'write-buffer' now acepts both: a symbol or a string
+
+  'send' now accepts both: a symbol or a string
+  
+  'symbol' pretended to create a symbol although context would not exist
+
+  error messages now include the offending expression/parameter which
+  caused the error.
+
+
+- 7.1.7
+  speedup in UDP communications (no session registration)
+  memory leak fixed in 'net-receive-udp'
+
+  'first' of an empty string now returns an empty string, previously nil
+
+  improved cgi.lsp
+
+  'reverse' now works on strings
+
+- 7.1.8
+  'throw' now is documented (actually happened in 7.1.7)
+
+  'collect' and 'select' now also work on strings
+  i.e: (collect "2001-09-20" 5 6 8 9 0 1 2 3) => "09202001"
+
+  'slice' couldn't slice lambda's
+
+  memory leak in searchBufferRegex() affecting 'find' and 'replace' was fixed
+
+- 7.1.9  
+  'set' with multiple args had a cell memory leak
+
+  'transpose' had a memory leak
+
+- 7.1.10
+  logfile support for remote mode -p and -d with '-l logfilename'
+
+  fixed bug in pretty print on command line
+
+  fixed bug in 'save', which went into a loop when saving symbols containing
+  contexts
+
+- 7.1.12 
+  logfile with string -L options also logs remote command line input
+ 
+  'fft' and 'ifft' now can take plain numbers instead of complex numbers
+  or a mixture of both
+
+  regular expression speedup 5 to 50% by chaching the search pattern
+  and avoiding recompile, speedup greatly depends on complexity of
+  pattern relatively to the length of the search string
+
+  rearranged functions in source files to make newlisp.c more manageable
+
+  eliminated various unecessary typedefs
+
+  Sun SOLARIS is now supported (not much tested though)
+
+  operating system number in last position of 'sys-info'
+  linux 1, bsd 2, osx 3, solaris 4, cygwin 5, win32 6
+
+  strings containig zeros are now displayed correctly i.e. 
+  (pack "c c c" 0 1 2 3) => "\000\001\002\003"
+
+- 7.1.14
+  redundancy in printString() eliminated
+
+  memory leak in 'parse' with regex fixed
+
+  the userdefined function for an error is now reported
+
+  overall speedup since 7104 of about 5%
+
+  commented out undocumented function 'symbol-dump'
+
+===============================================================================
+- 7.2.0 is 7.1.14 released October 2nd, 2003
+
+
+- 7.2.1
+  moved check for symbol type of lambdaFunc to errorProc for efficiency
+
+  cleanup of unecessary defines in newlisp.h
+
+  defined 'vasprintf()' to take advantage of vasprintf() where available
+
+  'format' now checks for correct number of arguments and well formed
+  format string, it should not crash anymore on mismatch of number
+  and type of parameters
+
+  newLISP-tk is now version 1.0 with changes for multiline 'tk' statements
+  (stements containing line-breaks), this allows sending bigger Tcl/Tk
+  code portions in one 'tk' statement
+
+- 7.2.2
+  force creation of $0, $1 ... in MAIN even when used in different context
+  for the first time
+
+  supress $0, $1 ... in newlisp-tk frontend in variable listbox
+  (the $ would confuse tk)
+
+- 7.2.3
+  replace-assoc now also uses the system variable $0 for the old
+  list, which can be reused in the replacement expression, i.e:
+
+  (set 'lst '((a 1)(b 2)(c 3))) 
+  (replace-assoc 'b lst (list 'b (+ 1 (last $0))))
+  lst => ((a 1)(b 3)(c 3))
+
+  replace-nth now also uses the system variable $0 for the old element, i.e:
+
+  (set 'lst '(1 2 3 4))
+  (replace-nth 1 lst (+ $0 1))
+  lst => '(1 3 3 4)
+
+  added new module 'ftp.lsp' for get/put ftp transfers
+
+  updated module smtp.lsp and program spam-filter
+
+  symbols set with 'constant' now also gets saved with 'constant'
+
+  introduced getContext() for code savings
+
+  added error message in 'import' for win32
+  
+  eliminated win32.cmd
+
+  many documentation changes/fixes, rewritten introduction
+  added chapter about deprecated functions
+
+  changes in set/define functions for better protection and
+  error messages of protected symbols
+
+  full stack trace on error messages
+
+- 7.2.4
+  replace-assoc now returns the changed list instead of the old
+  association found (which is now in $0)
+  
+  replace-nth now return the changed list instead of the old
+  expression found (which is now in $0)
+  now checks also for missing last argument
+
+  replace now returns changed list or string
+  for changed list count of replacements in $0
+  count for string replacements is not available any more
+  (could be handled in replacement expression)
+  now checks also for missing last argument
+
+  remove now returns the changed list
+  and the number of removed elements in $0
+
+- 7.2.5
+  chop now also works on lists
+
+  coding improvements in slice/sublist() and substring()
+
+  newlisp-tk 1.02 now on Linux tmp directory is in the home
+  directory of the user running newlisp-tk
+
+  replace with expression in replacement would overflow CPU stack
+  after 2048 replacements, now no limit
+
+  cgi.lsp v.1.2 now lives in a context CGI for better isolation
+
+  httpd v.3.0 with bugfixes for big POST buffers
+
+  new module infix.lsp for parsing infix expressions
+
+  in newlisp-tk changed /tmp to tmp for Linux/UNIX
+
+- 7.2.6
+  (new CTX 'CTX2) copies context CTX to CTX2, helps using
+  contexts a objects, which can be instantiated from a template
+  context
+
+  'define' 'constant' used in contexts will always force creation
+  of the symbol in that context, never overwrite definitions in
+  MAIN. This is changed behaviour also be reflected in the documentation.
+  The old way was leading to unexpected definitions in MAIN of symbols
+  although loaded from a context. 'set' still will first look for a
+  global in MAIN.
+
+  fixed false error messaging on certain parenthesis errors
+
+  fixed wrong error message when trying to define protected
+  symbol
+
+  error message 'parameter out of range when calling 'gammai',
+ 'beta' or 'gammaln' with first parameter 0.
+
+- 7.2.7
+  contexts now can be assigned to variables and referenced
+  during runtime, i.e. 'contextVar:varName' with late binding
+  of contextVar.  New possibilities of OO programming and lexically
+  scoped programming, see new chapter in the users manual
+  about 'Programming with context objects'.
+
+  stronger separation of contexts from context MAIN, only
+  primitive symbols, context symbols, true and nil are
+  inherited
+
+  'new' now returns the new context, formerly 'true'
+
+  'set', 'setq', 'set!', 'constant' now return the value of
+  the symbol set when the rvalue is missing i.e:
+  (constant 'foo) will make foo a constant and return it's
+  curent value
+
+  protected all symbols in MAIN in newlisp-tk.tcl v 1.03
+  against accidental overwrite
+
+  cleaned up toal mess of tem pdir detection in unix mode
+
+  cleaned up init.lsp
+
+  'nth' now can take multiple indices, i.e.:
+  (nth 1 2 0 '(1 (a b (c d)))) => c
+  good for working with matrices or sparse matrices
+  out of bounds indices return the last in dimension
+
+  'set-nth' like former 'replace-nth' but multidimensional
+  like 'nth'
+  (set-nth 1 2 0 '(1 (a b (c d))) 'x) =>  (1 (a b (x d)))
+
+- 7.2.8
+  eliminated statics in lambda expression, not necessary
+  anymore as we have dynamic contexts, which also
+  create a lexically closure around vars
+
+  fix in dolist, how cleanup is done
+
+===============================================================================
+- 7.3.0 Released version 2003/11/03
+  (cpymen fromAddress toAdress nBytes), address may be integer
+  or string, only for internal use, not documented. Could be
+  used with 'dump' to hack lisp-cells and symbols-cells.
+  i.e. to unprotect a symbol :
+  (cpymem (pack "c c" 0 32) (last (dump 'sym)) 2)
+
+  fixed error message reporting in 'set-nth'
+
+- 7.3.1 released Nov 11 2003
+  'import' was broken in Win32 native version when working
+  inside contexts (odbc.lsp and mysql.lsp)
+
+  (pretty-print line-length indent-string)
+  experimental not documented yet, to change pretty printing
+  behaviour, without args returns current status => (64 " ")
+  64 length 1 space for indenting
+
+- 7.3.2
+  'char', 'collect', 'lookup', 'nth', 'pop', 'push', 'select', 'set-nth'
+  and 'slice' now all accept negative offset which will count from the 
+  end of a list i.e. (slice "newLISP" -4 2) => "LI"
+
+  'push' and 'pop' now can take multidimensional offsets like
+  'nth' and 'set-nth'
+
+  'collect'/'select' now return the last element for offsets to big
+  (formerly nil)
+
+  'pretty-print' now tested and documented
+
+  1.e-1 or 123. , a decimal point without following digits is
+  no an accepted number format
+
+  in newlisp-tk the windows position gets now saved when saving
+  Options/Settings
+
+  fixed bug in 'let' when returning a local var
+
+- 7.3.3
+  new 'push' changed 'nilCell'
+
+- 7.3.4
+  newlisp_manual.html with Kazemori edits
+  
+  'list' now accepts unlimited number of arguments
+
+- 7.3.5
+  'push' could not append to an empty list
+
+  handling big buffers in newlisp-tk in evaluation
+
+  common floating point exception handling on all
+  platforms (BorlandC and GCC)
+
+  block mode for remote connection starting with [cmd]
+  on a line by itself and finishing with [/cmd] on
+  a line by itself
+ 
+  sets locale environment on non-US versions of an OS
+  platform, this enables automatically correct character
+  handling (i.e. upper-case) on non-engish character sets
+ 
+- 7.3.7
+  newlisp-tk.tcl now takes advantage of new block mode (multiple
+  lines in interactive mode). This ways one of the ports in
+  communication with newlisp could be eliminated and browser-editor
+  buffers of unlimited length can be evaluated, preferrably in
+  evaluation without printing (left of the two buttons)
+
+  doc changes for 'silent'
+
+- 7.3.8
+  'let' now accepts also alternative syntax without the parenthesis
+  around var - exp pairs: (let (var1 exp1 var2 exp2 ...) body )
+
+  doc changes for 'let' and chapter 'Lambda expression'
+  doc change new function 'set-locale'
+  doc change new sub chapter 'Switching the locale' in chapter
+  'Localization and customization'
+  doc change new file LOCALIZATION
+
+  'fn' may be used instaed of 'lambda' (save typing)
+ 
+  'set-locale' changes usage: (set-locale) => return current
+  setting, (set-locale "") => switches to local locale with
+  all option turned on. (set-locale str int) switches to locale
+  in str with category option int as speicied in "locale.h" of
+  platform/OS, look for defs of LC_ALL, LC_NUNMERIC etc..
+  on  startup newLISP tries to swithc to ISO "C" locale.
+
+- 7.3.9
+  'push' and 'pop' now can take the int-offsets in a list to
+   work together with new 'ref' which reports the position of an
+   expression in a nested list
+
+   doc changes (sometimes only small changes)
+        'push', 'pop', 'symbol?' new function 'ref'
+	'save', 'set', 'Arrays and Hash Tables ...', 'close',
+	'cons', 'context', 'delete', 'explode', 'fft', 'find',
+	'format', 'intersect', 'lambda?', 'length', 'let'
+	'make-dir', 'match', 'net-receive', 'net-select',
+	'net-send', 'new'
+
+   changed options flag will trigger recompile when caching regular
+   expression patterns
+
+   'select' evaluated args in offset list
+
+   'join' evaluated args in string list
+
+   'append'' evaluated the first string arg double
+
+   all type predicates now given an error message if the
+   argument is missing, previously 'nil' ('true' on atom?)
+
+   getting an int from a 'inf' floating point crashed on  Borland Win32
+   now returns 0 like on other platforms
+
+- 7.3.10
+  'remove' didn't check for list type in second arg and bombed
+
+- 7.3.11
+  new compile for Win32 DLL with makefile_win32dll
+  see file win32dll.readme for unsolved issues
+
+- 7.3.12
+  (replace expr aList) now works like 'remove', but for removing
+  strings the empty string "" must still be specified:
+  (replace str aString "")
+  'remove' is deprecated and will not be available anymore in 8.0
+
+  new 'flat' to flatten lists complements multidimensional set
+  of list functions, example:
+  (set 'lst '(a (b (c d))))
+  (map (fn (x) (ref x lst)) (flat lst)) => ((0) (1 0) (1 1 0) (1 1 1))
+
+  newlisp.dll now runs qa suite
+
+- 7.3.14
+  DLL now suppresses pop up on FP domain error (thanks Steve)
+  DLL now also can use print statment, output will be in return
+  value.
+
+  'replace' did not work correctly when removing multiple expressions
+  at the beginning of a list
+
+  doc changes 'replace', 'flat', chapter 'Deprecated functions'
+               chapter 'DLL module ...'
+
+  error message for "string too long" now reports shorter string
+
+- 7.3.15
+  better error reporting on some string getting functions when arg
+  is missing
+
+  doc changes license change for documentation, misc. links
+
+  replace could not handle empty search string
+
+  Win32 DLL no contained in Win32 distribution
+
+  fixed error in httpd
+
+- 7.3.16
+  error messages in newlisp.dll where broken becuase of wrong makefile_win32dll
+
+  newlisp-tk.html now reformatted to manual HTML for better maintenance/conversion
+
+  slight optimixation in 'nth' and 'set-nth'
+
+  fix for 'nth' on empty string
+
+  better error messages on missing args in various functions
+
+  link.lsp now also works on win32 DLLs but is not supported anymore
+  for CYGWIN, use a win32 compiled newlisp.exe and newlisp.dll instead,
+  both work fine under CYGWIN
+
+  doc change for chapter 'Win32 DLL  ...'
+ 
+  fixed 'silent' mode for DLL
+
+  'float' conversion noe accepts leading . without zero like the
+  internal parser
+
+- 7.3.17
+  doc changes as of Sam Cox's and Nigel's postings on 
+  http://www.alh.net/newlisp/phpbb/ on 2003-12-07
+
+  new functions 'atan2' and 'irr' and documentation
+
+  eliminated compiler warnings for Linux GCC 3.3.1
+
+- 7.4.0rc1
+  'irr' now strips of digits less than precision 1e-5
+
+  'set-nth' alsow works on strings (singular index)
+
+  'swap' now works on strings, also return value changed
+  from swapped pair to changes list/string
+
+  'pretty-print' had a cell leak
+
+  in the installation for LINUX/BSD etc. the doc directory has been
+  moved from /usr/doc/newlisp to /usr/share/doc/newlisp
+  newlisp-tk.tcl 1.07 changed accordingly
+
+  upgrade to PCRE 4.5 files
+
+  'integer' didn't truncate to -MAX_LONG
+
+  'integer' did not truncate to MAX_LONG when feeding big
+  floating point numbers, but crashed on Win32
+
+  on Win32 float functions on NaN crashed
+
+  doc changes: integer, NaN?, error-event, error-text, atan2
+
+- 7.4.0rc2
+  enabled error events in Win32 DLL module
+
+  update finger example file and example in doc
+  doc change 'net-connect'
+
+- 7.4.0rc3
+  floats now work in imported fuctions (tested on x86 platforms)
+  and up to 14 parameters (previously 10) are accepted, floats
+  count as two
+
+  nth-set like set-nth but different return value, was in rc2
+  but now documented
+
+  doc changes: chapter 'Functions in groups', 'import', 'inc', 'dec'
+              arithmetik operators +,-,*,/, 'set-nth', 'nth-set'
+              'sort', '%', 'mod', '<,>,=,<=,>='
+
+  doc new file: hacking_newlisp.html with describes previously
+  undocumented features
+
+  'for', 'dotimes', 'seqence', 'series' now return a 'invalid parameter: NAN'
+  error when NaN parameters are passed
+
+===============================================================================
+- 7.4.0 release 2003/12/20
+- 7.4.1
+  commandline switch '-m N' where N is the max number of megabyte newLISP
+  is allowed to allocate for LISP cells
+
+  setq,set!, define (as set) did not work right with dynamic context vars
+
+- 7.4.2
+  %s format now recognizes precision i.e: (format "%5.2" "hello") => "   he"
+
+  various doc changes
+
+  pop3.lsp now handles pop3 servers w/o LAST command, but only on the
+  functions: get-all-mail and delete-all-mail
+
+  char did not convert the  0 correctly, now: (char 0) => "\000"
+
+- 7.4.3
+  fixed printing context name when in a context other than MAIN
+  this affected the newlisp-tk frontend since v. 7.2.7
+
+  many doc corrections, now rev 5
+
+- 7.4.4
+  (now ... ) returns an additional number 'minutes west of GMT' 
+  for the timezone offset 
+
+  the optional time ofset parameter in 'date' and 'now' must now
+  be given in minutes west of GMT, was previously in hours, 
+  standard when using time zone offsets
+
+  max cell count as specified in command line swith -m now second
+  number in 'sys-info' if not specified defaults to 0x10000000
+
+  doc addition of -m commandline switch and change in 'sys-info'
+
+- 7.4.5
+  format now can take unlimited number of parameters, before 2048
+
+  changes in stat.lsp, smtp.lsp and httpd for new 'sys-info'
+
+- 7.4.6
+  fixed problem in float -> integer conversion of big numbers
+
+  attempt to fix for last parameter of 'now' for solaris (not tested)
+
+- 7.4.7
+  updated to BWidget-1.7 in newlisp-tk (since 7.4.6)
+
+  timezone offset in return value for 'now' set to 0 on SOLARIS
+
+  plotting with stat.lsp and gnuplot was messed up on Win32, now
+  can also do multiple plot one after another using 'process' instead
+  of exec
+
+  eliminated 'gettime' example, as that service doesn't run on most
+  computers these days
+
+  'import' on Win32 now can use cdecl calling conventions with
+  additional parameter string "cdecl" when importing functions. 
+  This allows calling many third party DLLs without special wrapper DLLs
+  On LINUX etc. the extra parameter is ignored.
+  
+  mysql.lsp version 2.0, several functions changed and offsets defined
+  for MySQL v.4.0, previous versions will not work
+
+- 7.4.8
+  improved error message for missing par
+
+  sqlite.lsp - module for SQLite datavase from http://www.sqlite.org
+  
+  mysql.lsp small fixes and revised test routine, tested on MySQL v. 4.0
+
+  'transpose' now transposes any kind of matrix (previously only matrices
+  containing numbers; it also rectangualarizes matrices; speed improved
+  3 fold.
+ 
+  in 'if' and 'cond': if the last condition given is the empty listy ()
+  which evaluates to nil in a boolean context, and if no then/else actions
+  or now cond action is given, then the empty list () is returned (previusly nil) .
+
+  fix for 'date' which crashed at values overflowing int32 (2038 1 19 3:14:07)
+
+  logging has been changed to a fixed filename 'newlisp-log.txt
+
+  new command line switch -h
+
+  better pretty printing of symbols which are constant and global
+
+===============================================================================
+- 7.5.0 RELEASE 2004-01-21
+  cgi.lsp, form.html, form.cgi where missing from FILES inventory
+
+  new 'sqlite.cgi' web script for administering SQLite database in newLISP
+
+  eliminated various unused vars with -w8004
+
+  fixded bug in 'global' printing
+ 
+  changed directory structure, new dirs: doc, examples, modules 
+ 
+- 7.5.1
+  (rotate '()) crashed because of list length zero
+
+  fixed nested catch/throw
+
+  fixed lambda stack oberflow after 3000 catch
+ 
+  eliminated array.lsp instead shorter hash.lsp for hash functions
+
+  changed sqlite.lsp to version 1.6, name change for future 
+  reserved word 'array' 
+
+  dynamic context var refs now work inside contexts, this makes
+  it possible to call constructors from inside the class context
+
+  improvement of floating point speed 60% in simple arithmetik
+  and 25% in most floating point functions
+
+  (format "%d" 1.23) => "1" before this was not permitted
+  (format "%5.2f" 10) => "10.00" also allowed now
+
+- 7.5.2
+  (array i j k aList), returns a 1 to 8 dimensional array and
+  initializes optionally from flat list in aList 
+
+  (array-list myArray) returns a list conversion of myArray
+
+  (aray? expr) tests if expression is a list
+
+  all array acces modification via nth, set-nth and nth-set
+
+  also released benchmarks  comparing with Perl, Python and Guile,
+  see at: http://newlisp.org/benchmarks
+
+
+- 7.5.3
+  (seek 0) now returns numbers of characters printed to stdout,
+  works on BSD but on LINUX and Win32 will always return -1
+
+  'integer' now takes additional base parameter after the
+  default parameter, i.e:  (integer "1111" 0 2) => 15
+  note, that hex numbers still need to be prefixed with 0x
+  even when specifying base 16
+
+  added txt2pdf.lsp as a new module in the module directory
+
+  comprehensive manual edit by Brian Clausing (thanks!)
+
+  new chapter about linking LISP source and executable
+
+  all deprecated functions thrown out:
+  concat, remove, replace-nth, sublist, substring, read-process
+  read-url, write-process. All have replacements, see manual.
+
+  changed cgi.lsp, stat.lsp, spam-filter for deprecated functions
+
+  1% overall speed improvement 0.5% size reduction
+
+  nth didn't work on lambda in 7502
+
+  'format' increasing of ars beyond 2048 has been rolled back
+  because of problems when evaluation of args is deeply nested
+
+- 7.5.3a
+  changes in newlisp-tk.tcl for deprecated 'remove'
+  changes in qa for deprecated functions
+
+ 
+- 7.5.4
+  15% speedup in 'format'
+
+  writeStreamStr() and readStreamText() did not handle zeros
+
+  'source' like save on strings eliminates tmp directory in
+  new newlisp-tk v.1.09
+
+  1000+ times speedup in XML parsing of bigger files 
+  changing a strncpy() to a memcpy()
+
+- 7.5.6
+  newlisp-tk 1.10 now shows message box when trying to open
+  debugger with browsers at the same time
+
+  updated FILES inventory
+
+  logging did not work as described (was always on with -p -d)
+
+  net-listen and net-receive-udp take as an additional optional
+  parameter the address the listening socket should bind for
+  computers with multiple network adapters
+
+  optional last parameter in net-send-udp for specifying 
+  broadcast mode with 'true' (or anything not evaluating to nil), 
+  not necessary on wome Win OS where '255' on last address byte 
+  is enough to turn on broadcast mode
+
+  Ctrl-C handler simple on Win32 and with continue, exit, reset
+  menu on LINUX/BSD (somewhat unreliable?)
+
+  Broken Pipe on net-send now handled correctly on Linux/BSD
+  is handled by socket stack on Win32
+
+  (slice str 1 -1) does not crash anymore (length arg should
+  never be negative)
+
+- 7.5.7
+  signal handlers now initialized before loading commandline
+  scripts
+
+- 7.5.8
+  shorter code for swap
+  
+  defunct zombie child processes now cleaned up by 'process'
+  on UNIXs
+
+  fixed potential bug in regex replace when replacement expression
+  evaluates to no-string
+
+- 7.5.9
+  all functions changing the contents of a symbol (destructive
+  functions) will now cause an error when used on symbols protected
+  with 'constant', previously it worked only with set, set!, setq
+  and define, define-macro; loop variables in dotimes, for, dolist
+  and dotree are protected against change by user with an error 
+  message during looping and may not be constant before the looping
+  starts using them
+  
+  new manual chapter about 'Variable names and numbers syntax"
+  
+  bug fixes/additions in httpd, now version 3.3
+  
+  fixed potential memory overwrites in nl-web.c
+
+  error message length limited to 1024 characters
+
+- 7.5.10
+  rolled back symbol protection for dotree and dolist, which
+  is not necessary
+
+- 7.5.11
+  new mode for 'open' "pipe' or "p" opens a named pipe non-blocking
+  for reading
+
+- 7.5.12
+  rolled back protection for dotimes, for loop variable solving
+  crash problem in different way
+
+- 7.5.14
+  documentation fixes and compiler warnings fixes
+
+  two additional file for viewing manual in frames with index
+
+  the Win32 installer puts entries in startmenu including an uninstall
+
+  The WIn32 installer puts a newLISP icon in desktop and startmenu links
+
+  protect built-in functions from overwriting with import but the 
+  function can still be imported in a context different from MAIN
+
+  eliminated "pipe" or "p" mode in 'open' instead "non-block" or "n"
+  as additional option after "read" or "write" option
+
+  net-lookup, net-select, net-send-udp, net-peek did not clear net-error
+
+  net-select now can accept a list of sockets instead of one socket
+  net-select now has a third mode "exception" or "e" to test error
+  conditions on socket
+
+  apply works reducing a list when additional reduce count is given
+
+  load takes multiple filenames
+
+- 7.5.15
+  integer and float now return nil or the default value when type
+  other than string or number is specified, previously this
+  caused an error message
+
+  expanded chapter on Tcl/Tk Variables in:
+  "Writing applications with newLISP and Tcl/Tk"
+
+- 8.0.0rc1  
+  added more examples to newlisp-tk.html
+
+  allow [cmd] tag in -d mode
+
+  reopen mode in [cmd] section for potential memory leak after
+  error conditions or on reconnect
+
+  allow contexts to be overcopied (broke benchmarks)
+ 
+- 8.0.0rc3
+  re-fixes the memory leak for [cmd] tags
+
+- 8.0.0rc4
+  doc changes manpage
+
+  take abs() value in -m commandline option 
+
+  reorder help menu for logical sequence of options
+
+  newlisp-tk 1.12 now tolerant for not finding "Fixedsys",
+  "Lucida Console" or "fixed" fnt. Will take first font found
+  
+  newlisp-tk 1.12 now save newlisp-tk.con correctly in home directory
+  of UNIX (startup dir in Win32)
+  
+  man page for LINUX et al, thankyou Nigel Brown 
+
+- 8.0 released April 7 2004 ============================================
+  version nunbers changed from 8.0.0 to 8.0 to distinguish
+  rc versions from final version
+
+  sys-info now returns 7 as OS number of win32dll
+
+  corrections in MemoryManagement.html and newlisp_manual.html
+
+- 8.0.1
+  changed package version number to dotted form for compatibility with
+  RPM packaging
+
+  changed Makefile install option for RPM compatibility and added
+  'make rpm' for makeing rpm package
+
+  man page for newlisp-tk 
+
+  array was not serialized correctly in 'source' and 'save'
+
+  negative indices in arrays, which are too big now give out-of-bounds 
+  error (previously took first element as for lists)
+
+  now up to 16 indices can be specified, previously 8
+
+  changes in docs for array chapter and functions
+
+  in newLISP-tk under Linux/Unix file open dialog now starts
+  with /usr/share/newlisp/newlisp-tk
+
+
+- 8.0.2 Released 2004-05-02 ============================================
+
+  httpd version 3.5
+  
+  doc changes
+
+- 8.0.3
+  constant did not allow multiple args
+
+  parse now recognizes zero length token and stops parsing
+  instaed of going into a loop
+
+  fix for contextvars in tcl/tlk IDE v1.15 and p_context()
+
+  bug fixes in cgi.lsp now v.1.5
+
+  documentation corrections
+
+  a bug fix in the reset routine
+
+- 8.0.4
+  fixed the fix in reset
+ 
+  cell leaks in error messages in catch/throw situations are now avoided
+
+- 8.0.5
+  filter now filters nil symbols like nil values (like if, while, not etc)
+  this effects the function index in the same way
+
+  access system variables $0, $1 ... etc. with an index ($ 0), ($ 1) .. ($ i)
+  where i is an integer
+
+  bug fix for catch when result variable has same contents as return from
+  catch statement
+
+- 8.0.6 Released 2004-06-06 ============================================
+  new env replaces deprecated environ, getenv, putenv (still available but
+  to be eliminated in 8.1)
+
+  additional paragraph about ovewriting global symbols in the chapter
+  'Contexts' 
+
+- 8.0.7
+  net-receive-udp can take an additional timeout parameter 
+
+  doc changes for net-receive-udp
+
+  new example whitelist-filter for email filtering
+
+- 8.0.8
+  trim now can take optional second trim-character parameter:
+  (trim "---HELLO===" "-" "=") => "HELLO"
+  (trim "0001234" "0" "") => "1234"
+  allows trimming of only one side (empty string) or different
+  trimming left and right
+
+  new functions 'utf8' and 'unicode' to convert between utf8
+  and UCS-4 encoded Unicode
+
+  UTF-8 versions of: char, upper-case, lower-case, first, rest,
+                    chop, explode, last, trim, collect select,
+		    nth, set-nth, nth-set
+
+  any positions/indices in the UTF-8 versions  of char, nth
+  set-nth and nth-set refer to (multibyte)character positions
+  rather than byte positions
+
+  find and regex return byte positions, slice takes byte positions
+  reverse always works on byte level, to reverse utf8 strings use:
+  (join (reverse (explode str)))
+
+  changed parsing of octal numbers 090 now "0" "90"
+
+- 8.0.9
+  'source' now also working on context symbols
+  fix for 'trim' in utf8 version
+  fix for 'set-nth' and 'nth-set' in utf8 version
+  version 3.7 httpd fixing problems with post on IE
+
+- 8.0.10
+  'net-sessions' now registers connecting peer in -p -d modes
+  makefiles for MinGW compiler for newlisp.exe and newlisp.dll
+  MinGW will eventually replace Borland BCC 5.5 as the default
+  compiler for the Win32 binary distribution
+ 
+- 8.0.11
+  a fix for server crash in -d mode when reconnecting on Linux
+
+- 8.0.12
+  now will reset when client exits in -d demon mode (still does
+  not maintain demon mode on slackware 2.4 but Debian 2.6
+  Linux Mandrakae 9.2/2.4.22 and FreeBSD  4.7 are OK)
+
+  new function (dup expr n) repeats expression n times in
+  list or string
+  function 'pipe' works on MinGW compiled version
+
+- 8.0.13-14
+  fix of 'test-pipe' in fle qa
+  new option in Makefile: make uninstall
+  /usr/share/newlisp/init.lsp now tries to load $HOME/.init.lsp
+  as a user specific .init.lsp after the system wide init.lsp
+  $HOME gets defined as (env "HOME") or (env "USERPROFILE") 
+  or (env "DOCUMENT_ROOT")  
+  whatever is available in that sequence
+  fixes restart problem in demon mode
+
+- 8.0.15
+  makefiles for newlisp as a shared library on Linux and BSD:
+  newlisp.so, the function to import is: newlispEvalStr
+
+  'print' and 'println' in newlisp.dll now  are always
+   returned correctly in the return value of 'dllEvaStr'
+   was not working correctly before in many cirumstances
+
+  'newlispEvalStr' will replace 'dllEvalStr' in future
+   version in newlisp.dll, at the moment both work
+   this change was made for consistency over platforms
+
+   new chapter "Shared library newlisp.so on Linux/BSD" in users manual
+
+- 8.0.16
+   doc changes for 'net-receive-udp'
+   'net-receive-udp' can now receive on a specific IP address, this
+   was documented already but not working
+
+   'net-connect' and 'net-listen' ca use a "udp" option to do
+   nonblocking UDP data exchange with net-send and net-receive and
+   without immediate closing of socket as happening using
+   net-receive-udp and net-send-udp. See documenataion for
+   net-listen and net-connect in the manual
+
+   improved error message for missing parenthesis 
+
+   newlisp.vim VIM syntax file now included in source distribution
+   thanks to David from http://www.geocities.com/excaliborus/ for
+   this contribution
+  
+   updated the CREDITS file
+
+   all predicates, which ended in p when using HTML (i.e. listp for list?)
+   have been renamed to using the '?' instead of 'p' in HTML to make
+   utilities, which position in the newlisp_manual.html work
+
+- 8.1.0rc1
+   fixed memory leak in 'irr'
+  
+   new 'net-receive-from' and 'net-send-to' for non-blocking UDP
+   communications over open connections
+
+- 8.1.0rc2 
+   an almost double speed and smaller parser for pack/unpack format strings,
+   which does not need spaces in between the format specifiers
+
+   a fix in net-send-udp not closing the socket after the new changes in rc1
+
+   doc changes
+
+- 8.1.0 Released version on 2004-08-10 ========================================
+  two new example programs: udp-server.lsp and udp-client.lsp to demo
+  non-blockig UDP communications
+
+  merged bugfixes from dlcompat as of cvs 2004-07-12  Peter O'Gorman
+  this affects only Mac OSX
+
+  added -c option for suppressing the prompt
+
+  added node.lsp in modules directory for building newLISP clusters.
+
+  new versions of several modules and example files to account for
+  new version numbering
+
+- 8.1.1
+  sleep now rounds to the nearest full second on systems where nanosleep()
+  is not available.
+
+  timeout option in net-receive-udp works again
+
+- 8.1.2
+  'make install_home' and 'make uninstall_home' of installations on Linux/UNIX
+  in the home directory of the user in $HOME/bin and $HOME/share/
+
+  'search' crashed on invalid filehandles
+
+  new 'expand' for expanding variable bindings in lists
+
+- 8.1.3
+  a fix for 'get-url' on some Solaris installations
+
+- 8.1.4 released August 21st, 2004 ==========================================
+  doc changes ansd new option 'make version' for changing version numbers
+  in all affected files
+
+- 8.1.5
+  nl-sock.c missed a change for Win CE, PocketPC
+
+  qa - testfile now complete with all functions, use: ./newlisp qa to test
+  without process and test functions using process, or use: ./newlisp qa ext
+  to test for all function (only Win32 and Linux)
+
+  a fix for timeout values > 1000000 usec on BSD and Solaris in net-select
+  and net-receive-udp
+
+  in net-listen and net-connect specify "multi" or "m" instead of "udp"
+  for UDP Multicast mode
+
+- 8.1.6
+  'collect' and 'select' are collapsed into 'select' which is now also
+  type polymorph on the second parameter.
+
+  new makefile_solaris_utf8
+
+  new 'fork' function for lauching a newLISP child process thread
+  on Linux/UNIX only and CYGWIN on Win32.
+
+- 8.1.7
+  fixed rounding error in 'sleep' when compiled with NANOSLEEP
+
+  improved qa routines using 'fork' on Linux/UNIX for some tests
+
+- 8.1.8
+  new 'wait-pid'for watching the status of child threads created with 'fork'
+  and proccesses created with 'process'
+
+  upgraded to PCRE v. 5.0
+
+  more tweaks in qa file
+
+  fixed potential memory leak in 'new'
+
+- 8.2.0 Release September 21st, 2004 ======================================
+
+- 8.2.1
+  write-buffer can now take string instead of file handle to write
+  to a string in a string growing (concatenating) fashion, this is
+  much faster then doing (set 'str (append str content)) now:
+  (write-buffer str content)
+
+  'symbol' now can overwrite global symbols from MAIN (i.e. built-ins)
+  i.e. (symbol "print" 'MyContext)
+
+  'process' now ca take to addtioal pipe handle parameters, which
+  get mapped to stdin and stdout for the new process:
+  (map '(myin bcout) (pipe))
+  (map '(bcin myout) (pipe))
+  (process "bc" bcin bcout)
+  (write-buffer myout "3 + 4\n")
+  (read-line myin) => "7"
+
+  'semaphore' lets you create wait and signal semaphores
+  (set 'sid (semaphore)) ; aquire
+  (semaphore sid -1)     ; wait
+  (semaphore sid 1)      ; signal
+  (semaphore sid) => 1   ; status
+  (semaphore sid 0)      ; release/delete
+
+  'share' to create shared memrory regions
+  (share) => address off mmap share
+  (share addr exp) => sets addr to exp for integers, floats and strings
+  (share addr) => returns integer, float or string exp
+
+  added newLISP-Excel-Import.xls example to examples/ directory
+  added prodcons.lsp - demo for fork, wait-pid, semaphore and share
+
+- 8.2.2
+  'write-line' with string device like 'write-buffer', in both
+  symbol is now protected if protected with constant
+
+  share was broken for strings
+
+- 8.2.3
+
+  pipe is now also available on CGWIN and Borland compiled versions
+  on all Win32 versions pipe can now remap std I/O like on Linux/UNIX:
+
+  (map '(myin bcout) (pipe))
+  (map '(bcin myout) (pipe))
+  (process "bc" bcin bcout)
+  (write-buffer myout "3 + 4\n")
+  (read-line myin) => "7"
+
+  process on Win32 can hide or minimize window:
+  (process application 0 0 0) => hide app
+  (process application 0 0 1) => show app
+  (process application 0 0 2) => minimize app
+
+  'share' and 'semaphore' are now also available on Win32
+
+  improvements in qa file, now tests all functions by default w/o ext option
+  better syncronization on some tests with semaphores
+
+  'match' in list mode now only returns matched expressions
+
+  (map set '(x y) (match '(a (? c) d *) '(a (b c) d e f)))
+  x => b
+  y => (e f)
+
+  when using match with an optional third parameter 'true', it works
+  in the old fashion:  (map pattern aList true) => works like before
+
+  The context default function is a userdefined function with the same name
+  as the context it resides in, i.e: (define (ctx:ctx a b) (+ a b)) and can
+  be called just with the context name (ctx 3 4) => 7. 
+  Default functions should only be called rom MAIN, or have already been 
+  loaded or their context created before referred to in another context or
+  default function.  Not yet 'official' see doc/default_functions.html
+
+  fixed cell leak in 'match' on backtracking
+
+  bug fix in let which did not honor protected symbols
+
+- 8.2.4
+  deprecated collect, getenv, putenv and environ completely eliminated from
+  newlisp and examples, modules: httpd, cgi.lsp, sqlite.lsp
+
+  '+' new wildcard operator 'match': take one or more
+
+  net-error now returns error number and text separate in a list
+
+  net-connect failure did not set net-error
+
+  'now' has now the daylight-savings-flag 0 or 1 as last parameter
+
+  new 'sys-error' for reporting C-library errno values
+
+  'newlisp -e' without a command string crashed
+
+  'push' now optimized when pushing as last element with -1
+
+  (new ...) now will not overwrite existing symbols, to allow true
+  mixins of other contexts. To overwrite symbols as before version
+  8.2.4 use the true as a third parameter i.e. (new A 'B true).
+
+- 8.2.5
+  'symbol?' can now be used on dymamic context vars, i.e
+  (set 'ctx MyCTX) ; MyCTX is existing context
+  (symbol? 'ctx:x) ; true if MyCTX:x exists, nil if not  
+  This checks the xistence without inadvertantly creating it.
+  previously (symbol "x" ctx nil) had to be used.
+
+  'replace' can now take an additional option bit 0x8000 for replacing
+   only once in a string: (replace "a" "aaa" "A" 0x8000) => "Aaa"
+
+
+  'define-new' copies individual funtions from
+  other contexts with or without renaming them to a new function:.
+  (define-new 'foo:func 'bar:func) copy to different context
+  (define-new 'foo:func 'foofa) copy to current and rename
+
+  forward referece to a symbol in symbol did not work in mixin mode
+  of 'new'
+
+  the space between optioncharacter (-s,-m,-p,-d,-e) and optionvalue
+  can now be omitted, i.e. -s 10000 and -s10000, both work.
+
+  'date' without an argument returns the character string for the current
+  local time, this avoids the construct (date (apply date-value (now)))
+
+  'date-value' without and argument returns the time of seconds
+  since 1970-1-1 0:00 equivalent to (apply date-value (now))
+
+8.2.6
+  'delete' now can delete an entire context without removing conatined 
+   symbols first
+
+  serialization of contexts to a file using 'save' now is done correctly 
+  when the context context contains overwrites of global symbols.
+
+  a more flexible and faster 'symbol' function, which can take any character
+  sequence and numbers, and can be used this way for hash-like associative 
+  memory access. New module hash.lsp to show usage.
+
+  'define-new' renamed to 'def-new', for shorter typing and for not 
+   associating it to 'define' but rather to 'new' (was introduced in 8.2.5)
+
+  'letn' works similar to 'let' but incrementally uses the local variable 
+   bindings like multiple nested let when evaluating the initializer expressionsi
+   for locals.
+
+8.2.7
+  'address' (previously only documented  in 'hacking_newlisp.html') now also 
+  returns addresses to integer and double float data type, useful when passing
+  int * or double * to imported functions, now documented in main manual
+
+  'sym' is an abbreviated form of 'symbol', since 'symbol' starting in 8.2.6
+  can take any sequence of characters, including strings which are illegal
+  symbols in newLISP syntax, and is used for hash/dictionat like lookups, it
+  is used more often, therefore this shorter form 'sym' is introduced
+
+  added configuration variable in newlisp-tk.config to specify a newLISP
+  application. See newlisp-tk.html "Delievering Applications" for details
+
+  'apply' and 'map' now can be used on macros
+
+  'pack' and 'unpack' have new format specifier 'b' for unsigned 8bit numbers
+
+  'encrypt' crashed on empty strins in key
+
+8.2.8
+  'encrypt' crashed on empty key-string, now gives error message
+
+  'int' as shorter writing of 'integer'
+
+  'pack' now converts all types as needed, i.e. (unpack "b" (pack "b" -1.0)) => 255
+  from-to integer-floats, did it before only for "f" and "lf"
+
+  'flt' converts a number to a 32bit float repesented by an integer for usage
+  in calling imported library routines, which take floats.
+
+  'array' skipped wrong index types instead of giving error message
+
+8.3.0 Released Nov 21st, 2004
+
+8.3.1 Released Nov 23rd, 2004 ============================================
+  'nth-set' gave error on protected symbol in index
+
+  'apply' 'map' on macro was returned to 8.2.0 behaviour
+
+8.3.2
+   more cleanup in qa file
+
+   cleaned up makefiles -D definitions eliminating redundant -DOPSYS
+
+   eliminated 'break', which did not do anything after introduction
+   of 'debug' in version 6.3.07
+
+   overall speedup of about 5% by predefining system symbols
+   $0 -> $15, speedup of 80% to 100% in functions using system
+   symbols like set-nth, nth-set, find, parse, regex, replace
+
+   new 'do-while' and 'do-until' check condition _after_ evaluating
+   the body expressions
+
+   new 'read-key' reads nonblocking keyboard character code
+   not working on Mac OSX but all other flavors
+
+   superflous args in user defined function call caused cell leak
+   never happened, i.e.: (define (foo x) ..) and (foo a b c)
+
+   'get-url' now handles "Transfer-Encoding: chunked" correctly
+
+   'amb' picks an argument at random and evaluates it
+
+   -x command line switch for server mode with handler function 
+   'x-event' i.e: newlisp my-httpd -x 8080 
+   my-httpd is a lisp file containing the user defined handler 
+   function i.e: (define (x-event request) .....)
+   this way servers for different protocols / requests can be simply
+   programmed using 'print','read-line', etc., for IO to the specified
+   port, the connection stays up until closed by the client.
+   See chapter 'Command line options ...' in the manual
+
+   fixed a bug in 'new' and 'def-new' when the source was MAIN 
+   this fix was necessary to write a function (def-static ....)
+   for writing statically scoped functions (see int the manual
+   chapter 'Lexical, static scoping in newLISP', subchapter
+   of 'Programming with context objects'.
+
+8.3.3
+   'debug' did not handle default functions written without colon
+
+   'save' 'source' did not space symbols under sum circumstances
+
+   'dolist' now double as fast and safe to break out with 'throw'
+
+   'catch' now has an additional syntax with just one argument to write
+   easier returns from functions, loops or blocks, ie:
+   (catch (dotimes (x 1000) (if (x 500) (throw "fin"))) => "fin"
+   returns the result  or throw argument
+
+8.3.4
+  'save' 'source' spacing-fix was incomplete
+
+8.3.5
+  If the a '!' is entered as the first character on the command line immediately 
+  followed y a shell command, that command will be executed, i.e. !lsi in Unix 
+  or !dir in Win32 would show a directory listing. There should be no space 
+  between '!' and the shell command.
+
+  URL length in get-url and post-url is now unlimited
+
+8.3.6
+  manual corrections, additions and new sub-chapter about XML-RPC
+
+  BASE64 encoding and decoding with 'base64-enc' and 'base64-dec'.
+
+  new sign-on message, and different for remote modes
+
+  added 'xmlrpc-server' to examples directory
+  added 'xmlrpc-client.lsp' to modules directory
+
+  fix for 'Transfer-encoding: chunked' if 'Content-length:'
+  is given too (which should not happen but is found occasionally)
+
+8.4.0 Released 2005-01-18 ============================================
+  added xmlrpc.cgi for handling XML-RPC requests as CGI
+
+  fixed a file descriptor leak in -d -x modes
+
+  after the 'debug' fix in 8.3.3 debug did not recurse into funcs
+
+  'args' can take an index argment i.e. (args 0) (args 1) etc.
+
+8.4.1
+  fixed signon message missing 'n'ewLISP
+
+  added UTF-8 to signon message
+
+  added f-prob to stat.lsp (probability of F ratio for df1/def2)
+
+  (throw-error expr) throws an error with message printed in expr
+  error thrown this way can be handled like any other newLISP error
+  using (catch foo 'result) or with (error-event ...)
+
+  changed/added docs for catch, throw, throw-error and chapter:
+  Integer abnd Floating point ...
+
+  newlisp-tk.exe now wrapped with freewrap v.6.0 and Tcl/Tk 8.4.8
+  suppresses occasional display of tcwish console
+
+  added updated newlisp.jsf syntax file for JOE editor to distribution
+
+8.4.2
+  [cmd] tags did not work when compiled with READLINE option
+
+  (args) which previously worked only in macros now too works in
+  functions. The behaviour of (args) has changed: only unbound arguments
+  for which there is now local variable in the macro (or function) are 
+  returned in the list. This makes changes in existing macros necessary, 
+  which specify both, local variables and they use args. Most changes
+  lead to simpler macros or function, because (args) already contains
+  only the unassigned args.
+
+  changed macro definition of 'tk' in newlisp-tk.tcl to function
+
+  changed plot 'macro' in stat.lsp and 'defun' in init.lsp
+
+8.4.3 Release 2005-02-12  =================================================
+  cleanup from (args) changes, protect $args from deletion
+
+8.4.4
+  misplaced paren in conditional def of defun in init.lsp
+
+  OS number in sys-info was incrementing on every call when DLL or UTF-8
+
+  decimal point setting from locale is now used correctly when parsing source
+  i.e. after performing (set-locale "German_Germany.1252") in Germany
+  1,23 will be recognized corectly as a decimal number with comma as the 
+  decimal separator.
+
+  qa_comma QA test file for German or other locales using ',' comma as
+  decimal separator, qa renamed to qa_dot for decimal-dot locales.
+  In comma locales both, qa_dot and qa_comma should work, in decimal
+  dot countries onlz qa_dot will work.
+
+  daylights savings field in 'now' function now shows a flag 1/0 if time
+  zone may have DST at certain time of the year on Linux/UNIX. On Win32
+  it shows a 'daylight minutes bias' for timezones which may have DST.
+  Note that flag/bias is set through all the year even if DST is not
+  in effect at a given moment. May not work on all platforms.
+  
+  additional format parameter in (date num offset fmt), see GNU gcc
+  strftime() function for details
+
+  Win32 installation now to $PROGRAMFILES/newlisp, which is 
+  c:\Program Files\newlisp on English Windows. This defines a
+  fixed location for $PROGRAMFILES/newlisp/newlisp.dll for applications
+  loading newlisp.dll. 'PROGRAMFILES' is an environment variable available
+  on all MS Windows installations.
+
+  newLISP is now correctly registered in the
+  'control panel/add or remove programs' applet
+
+8.4.5
+  newlisp.exe compiled on MinGW or Borland now will look for init.lsp
+  in the same directory where newlisp.exe resides
+
+  installer now sets path on Win32, this allows to import the DLL without 
+  specifying the full path and allows to start newlisp or newlisp-tk from
+  anywhere on Win32
+
+  installer now allows installing without newlisp-tk
+
+  'nth' upgraded to 16 indices (like set-nth and nth-set)
+
+  'sort' now allows any binary operator user defined function as
+  compare funtion in third parameter
+
+  'implicit indexing' on lists, arrays and strings i.e.:
+  (lst 1 3) equivalent to (nth 1 3 lst)
+  (ary 0 -1) equivalent to (nth 0 -1 ary)
+  ("newLISP" 3) equivalent to (nth 3 "newLISP")
+  unlimited number of indices and faster than explicit form
+
+  'pack' and 'unpack' now allow switching between little and big endian
+  byte order using new format characters '<' and '>'
+
+
+8.4.6
+  'new' and 'def-new' did not replicate arrays, could cause crash
+
+8.4.7
+  added 'upload.htm', 'uplload.cgi' to examples directory
+  minor fix in xmlrpc.cgi xmlrpc-server
+
+  better handling of bad server responses in get/post/put-url avoiding
+  an ifinite loop on some types of bad server responses
+
+  fix for endian switch in 'unpack' which changed the original buffer
+
+  re-arranged arrays, hashes and indexing chapters in the manual and
+  enhanced hashing chapter, added Win32 trailing slash warning to
+  manual entries of 'directory' and 'directory?'
+
+  experimental implicit indexing with nrest: 
+  (1 '(a b c)) => (b c)
+  (1 "abc") => "bc"
+
+8.4.8
+  implicit indexing with slice:
+  (3 2 '(a b c d e f g)) => (d e)
+  (-4 2 "abcdefg") => "de"
+
+  updated infix.lsp to version 1.4/5 was broken after newLISP 8.2.0
+  because of change in 'symbol' functioanality
+
+  possibility to check legality of a string as a newLISP source symbol
+  with (symbol? string), i.e: (symbol? "a b") => nil
+
+  illegal symbols are now serialized correctly in 'save' using a
+  set expression with (sym str context)
+
+  the Win32 installer now will correctly change settings in
+  newlisp-tk.config when chaning the install path during installation
+  will only work Windows 2000 and later
+
+8.4.9
+  did not evaluate length in implicit slice-length
+
+8.4.10
+  separated legal symbol? functionality into 'legal?' function. 'symbol?'
+  back to pre 8.4.8 functionality
+
+8.5.0 Released April 8, 2005
+  '=' fixed problem when comparing strings and binary buffers
+
+  'args' with negative index did hang
+
+  'main-args' nor can be indexed like args, both accept negative indices
+
+8.5.1
+  newlisp-tk tripped over file spec "", changed to "." in lastLoadedFile
+  on MacOSX. Changed Demo.lsp to work with TLCKAqua on MacOSX.
+
+  new function 'factor' for factoring numbers up to 15 digits 
+  (must give floats for numbers bigger max int)
+
+  in newlisp.so and newlisp.dll main-args was initilized to nil instead of
+  the empty list ()
+
+  list in 'dolist' now safe to modify (back to 8.3.2 behaviour), but can
+  leave with 'throw' without leaking cells
+
+  signalling SIGUSR1 will perform a 'reset' but not kill newLISP
+
+  'timer' start a one shot timer event and registers a user defined
+  event handler, i.e: (define (ticker) (println (date)) (timer 'ticker 1))
+  defines a self starting and retriggering ticker.
+
+8.5.2
+  added debug option to SIGINT handler, eliminated SIGUSR1 handler, because
+  is redundant
+
+8.5.3
+  added 'signal' for userdefined signal handlers: (signal sig-no symbol)
+
+  args was not reset to '() when left unused in recursion levels
+ 
+8.5.4
+  signal handler can pass the signal number as an argument (see manual)
+
+  new makefiles for OSX/Darwin UTF-8: make 'osx_utf8' and make 'darwin_osx_utf8'
+  (Darwin means: OSX + readline support)
+
+  when compiled with readline support newLISP will now exit pressing Ctrl-D
+  (Linux/UNIX)
+
+  'net-select' crashed on an empty list
+
+8.5.5
+  fixed UTF-8 problems in file names in newlisp-tk.tcl (thanks Norman)
+
+  UTF-8 symbols where not treated as legal symbols in 'save' , 'legal?'
+  This prevented UTF-8 symbols to show up in the editor/browser listbox.
+  This is now fine on all UTF-8 and non-UTF-8 version.
+
+  UTF-8 now handled correctly in hostnames in net-xxx routines
+
+  UTF-8 now handled correctly in 'float' and 'integer', took some
+  UTF-8 characters for numbers.
+
+  'net-connect' and 'net-select' did not accept/convert floats for 
+  portnumbers/sockets
+
+  sqlite3.lsp v.1.3 now handles FLOAT and BLOB datatypes and finds the correct
+  library/location depending on the OS platform
+
+  newlisp-tk did not save pathnames correctly in newlisp-tk.conf. New
+
+  version newLISP-tk 1.26 now works correctly when installing on MacOSX
+  use 'sudo make install' after build with 'make darwin' or 'make osx'
+  needs TclTk Aqua installed with darwin port tools
+
+8.5.6
+  fixed potential problem in 'net-connect' with multicast option on
+  big-endian CPUs (MacOSX)
+
+  added broadcast option to 'net-connect' as udp mode plus broadcast specified
+  with "b" or "broadcast" instead od "udp". Broadcast mode was already possible
+  in 'net-send-udp'. Now broadcast can be set up in non-blocking mode on the 
+  receiver side.
+
+
+8.5.7
+  big speedup of 'replace' with strings on a file of 100k about 30x on
+  500k about 500x times speedup.
+
+  added example/tcltk.lsp for showing how to make GUIs without newlisp-tk
+  controlled from a newlisp script
+
+
+8.5.8 
+  added true/nil as allowed data in memory shares
+
+  added new make flavor osx_lib for shared library newlisp.so
+
+  MacOSX binary are smaller now because since 10.3 osx-dlfcn.o
+  is not required anymore, but extra makefile_osx_10.2 for older
+  Mac's
+
+  flushing stdio after output if not in terminal mode lets newLISP
+  now serve as a UNIX inetd handler 
+
+8.5.9
+  'timer' now can take fractions of a second, i.e. (timer 'alarm 0.1)
+  for 100 millisec
+
+  'read-buffer' now can take an optional wait string as 4th parameter
+  similar to 'net-receive' with wait string
+
+  added Mac OSX package preperation to Makefile
+
+  dropped cygwin support. MinGW and Borland remain as Win32 options
+  #ifdef's for cygwin are still there but have not been tested for
+  several versions
+
+8.5.10
+  fixed a crash when hitting cursor-up inbetween [cmd]...[/cmd] tags
+
+  'timer' now avalailable on Win32
+
+  fixed a regex error, when expression found is of length 0
+  only one replacement was made
+
+  implicit indexing did not accept indices after a var-index, if
+  var-index was the first.
+
+8.6.0 released June 10 2005
+ a bug fix for unpack when passing a number as an address on
+ OpenBSD where virtual memory pointers may be > 0x7fffffff
+
+ new function crc32, version: http://www.w3.org
+
+ share on Win32 leaked memory
+
+8.6.1
+ 'sql3:open' now returns nil and sets error the message when trying
+ to sql3:open twice.
+
+ 'timer' now returns the elapsed time when calling just with the
+  event symbol, useful for checking timer progress or programming
+  timelines/schedules.
+
+  'source' now works like 'save' and can take multiple symbols;
+  context symbols are serialized including all of the contained
+  symbols.
+
+  Files are now created without execution permission with rw-rw-rw
+  which results in rw-r--r-- on UNIX systems assuming a user mask
+  of 0022.
+
+  'peek' similar to 'net-peek' but for any file descriptor, returns
+  number of bytes ready to read works also on std I/O 0/1. Only UNIX.
+
+  Added gmp.lsp for GNU Multi Precision library, contains
+  integer functions for arithmetik, see header of file gmp.lsp
+  for details.
+
+  optional parameter 'true' in 'difference' and 'intersect' puts
+  these functions in list-mode (versus normally set-mode).
+
+  new function 'title-case' upper-cases first character and
+  optionally lowercases the rest characters
+
+8.6.2
+  changed  makefile_darwin_utf8 to work on standard 10.4 installation
+
+  a parameter in utf8 version of upper/lower was evaluated twice 
+  caused by new title-case code in 8.6.1
+
+  fixed append mode in file 'open' which created file with ------ 
+  permissions when file did not exists
+ 
+  optional 'true' flag in net-lookup to force hostbyname() lookup
+  for strings like "216.16.84.66.sbl-xbl.spamhaus.org"
+
+  huge speedup for 'difference' and 'intersect'. On a 10000 elment
+  list about 100 times speedup, both functions now scale linearly
+  with n+m instead of n*m, when n an m are the lenghts of the two
+  lists
+
+  speedup of 'count' for big item lists now scales m+n instead m*n
+  when m is the list of items to count in list with length n
+
+8.6.3
+  'difference' did sometimes not unique, 'nil' treated incorrectly
+
+8.6.4
+  fixed problems in  'count' and 'sort' caused by changes in 'sort'
+  necessary in new version of 'count', 'difference', 'intersect' and
+  'unique'
+
+8.6.5
+  'catch' did not respect protection of symbols in the catch symbol
+   
+   make version with sed finally working on UNIX previously only
+   cygwin
+ 
+   new function 'randomize' shuffles the elements of a list
+
+   new function 'net-eval' evaluates a batch of functions remotely
+   on newlisp servers, manages Tcp/Ip communications and data collection
+   with multiple servers started with: newlisp -c -d <portno>
+   timeout and optional callback/idle function
+
+   'array' with 0 length dimension crashed, now ignores 0-length
+
+   -d mode would exit when loss of communication in multiline [cmd] mode
+   now just cycles to restart
+
+   'error-event' only worked in programs loaded interactively, now works
+    also defined in scripts started on the command line
+
+   -l and -L now usable for logging in normal console mode, -l logs only
+   user input -L logs both user input and newLISP output (without prompt)
+   new chapter for logging in users manual
+
+   when evaluating multiple expressions on the command line or a batch
+   of expressions enclosed in [cmd],[/cmd] tags multiple results are now 
+   separated by one space.
+
+8.6.5-7
+   'ramdomize' looped on listlen 1
+
+   'load' now throws an eror when the file cannot be found or returns
+   the value of the last expression in the file evaluated. Before 'load'
+   returned 'nil' when file was not found and else 'true'. Note that this
+   required a change in init.lsp to catch error when trying to load
+   $HOME/.init.lsp
+
+   eliminated all sprintf() to avoid security warnings on openBSD compiles
+
+   'erf' and 'sgn' new functions
+
+   took out txt2pdf which is broken, will come back when fixed
+
+   fixed leak in evluateStream introduced with 'net-eval'
+
+8.7.0-rc1 released October 10th 2005
+   'get-url' now acccepts https:// pages in main url or moved location
+
+   'sgn' extended with optional triconditional functionality
+
+   fixed result stack leak in 'net-eval'
+
+   'get-url', 'post-url' and 'put-url' now can take a timeout parameter
+
+   'read-buffer' with wait string now will put bytes read in buffer
+    including when the wait string was not found. When no bytes are
+    read buffer is nil.
+
+   'date-value' returned negative numbers on dates earlier 1970, now returns
+    0 on dates previous to 1970
+ 
+    'net-eval' would loop on connection errors, more detailed error messages
+
+8.7.0 released October 15th
+    'append-file' like 'write-file' but appends
+
+    'select' on lists with an empty selection list now returns the empty list
+    previously nil.
+
+8.7.1 RELEASE Nov 7th, 2005
+    fixed bug for push -1 optimization and various doc corrections
+
+    replaced 'integer' with 'int', 'get-integer' with 'get-int' and 'symbol'
+    with 'sym' in several examples/ and modules/ files
+
+    (nth <list> <list>) now throws error (list index only allowed in
+    push/pop and implicit indexing)
+
+8.7.2 development Release November 20th
+    new (net-ping host wait-time) returns ip-no or multiple ip-no for multiple
+    addresses in batch-mode or broadcast. Must have root privileges to use, or 
+    set the newlisp executable set-user-ID with: chmod u+s /usr/bin/newlisp or: 
+    chmod 4755 /usr/bin/newlisp; only on UNIX
+
+    'time' now safe for midnight wrap
+
+    'dup' with optional 'true' flag now can force list return  when a string argument
+    is given; by default 'dup' concatenates the string
+
+    sys-error now reset after readline(), which caused it set to 22
+
+    'transpose' on empty lists segfaulted when on zero length dimension in the
+    first row, now an error message will be issued if the first row is empty
+
+    imnplicit rest failed strings when n was >= length of string
+
+    'count', 'difference' and 'intersect' crashed when handling  identical lists
+
+8.7.3 development release November 27th
+   added "list" flag to 'get-url', which permits capturing header and page in a list.
+
+   added custom header option to get-url, post-url and put-url
+
+   string display translation for char > 126 to \nnn format
+
+8.7.4 development release December 5th, 2005
+   expanded functionality for 'context': (context 'CTX "symstr" value)
+   adds symbol to context CTX, (context 'CTX "symstr") returns value
+   this is a short form for: (set (sym "symstr" 'CTX) 123)
+
+   expanded form of 'context?' for checking existence of a symbol
+
+   'time' takes an additional parameter for the number of times the
+   expression should be evaluated for timing
+
+   cleanup format, file and directory routines (less code)
+
+   the terminating character from an expression returned in the console has been
+   changed from a space to a line feed
+
+8.7.5 Development release December 23rd
+   added util/newlisp.plist syntax file for OSX BBEdit or TextWrangler editors
+
+   raw mode in 'net-eval' now documented
+
+   recognize simple path-href in 'location:' header spec in get/post/put -url
+
+   in 'process' on UNIX an optional pipe handle for standard error can be specified
+   if not present standard error gets redirected to stdout
+
+   allow default functions to be defined as primitives
+
+   shortened symbol param loop in evaluateLambda and evlaluateMacro
+
+   getContext() now safe for debug mode
+
+   'replace-assoc' gets additional (long overdue) syntax to remove associations 
+
+   help-option in context console menu on newlisp-tk (not working on OS X)
+
+8.7.6 
+   Help buttons now work on MacOS X in newlisp-tk
+
+   fixed and issue with 'case' when a 'true' clause was assembled from an
+   evaluated 'true
+
+   handle some cases of self reference in set-nth/nth-set, i.e: the replacement sub
+   expression itlself changes the place its supposed to be assigned:
+   (set-nth i L (set-nth i L 99)) ) 
+ 
+   : (colon) now will be returned as token even if attached to other following chars
+
+   'parse' without regex parameter couild overrun string when it ended in \
+
+8.7.7
+   regular expression support in 'directory'
+
+   new 'number?' works like (or (float? x) (integer? x))
+
+   in newlisp-tk help on hightlighted reserved word now works on MacOS X bringing
+   up browser with manual on right spot.   (Ctrl-Left-Button for context menu)
+
+   new (bayes-train list-A list-B [list-C ...] context-symbol) lists contain
+   string tokens; and  (bayes-query list-query context), not documented yet, 
+   still testing and modifying
+
+   memory error fix in 'get-url' for chunked pages
+
+8.7.8 development release January 16th 2006
+   'apply' now works on lists with unlimited length, no stack limit
+
+    both Bayesan modes: Chain Bayesian and R.A. Fisher CHi2, are now supported with 
+    new 'bayes-train' and 'bayes-query', working and tested, see manual for
+    details
+
+    moved 'prob-chi2' and 'pob-z' in manual to "Simulation and modelling" group
+    together with 'bayes-train' and 'bayes-query'
+
+    ATTENTION:
+
+    calling into a context now changes the current run-time context:
+
+    (context 'FOO)
+    (define (foo) (context))
+    (context MAIN)
+
+    (FOO:foo) => MAIN ; old behaviour
+
+    (FOO:foo) => FOO  ; new behaviour
+
+    The new behaviour is more intuitive and is what most programmers would expect.
+    Only applications using 'eval-string' or 'sym' (w/o specifying a context) are 
+    effected. From all apps published by newlisp.org (blog, wiki, ide) only the file
+    cgi.lsp packaged with these applications is affected and should be changed to
+    the new cgi.lsp v.1.9 packaged with 8.7.8.
+
+    Users should check all applications using 'eval-string' and 'sym' (or the
+    deprecated 'symbol'). Pre 8.7.8 'eval-string' and 'sym' work with the runtime-
+    context beeing MAIN, the context where the program was started. Now both functions
+    work with the context they are part of:
+    
+    (context 'FOO)
+    (set 'x 999)
+    (define (foo s) (eval-string s))
+    (define (bar s) (eval (sym s)))
+    (context MAIN)
+    (set 'x 123)
+
+    (FOO:foo "x") => 123    ; old behaviour
+    (FOO:bar "x") => 123    ; old behaviour
+
+    (FOO:foo "x") => 999    ; new behaviour
+    (FOO:bar "x") => 999    ; new behaviour 
+
+    Changes to old code:
+
+    (1) Replace all cgi.lsp in newlisp-ide, newlisp-blog and newlisp-wiki apps.
+    the replacement will also work with newLISP versions previous to 8.7.8.
+
+    (2) Change old apps by preceding the 'eval-string' statement with (context MAIN)
+    or other required context change. Most of the time it's MAIN, the context where
+    th whole program was started.
+
+    (3) Change old apps adding explicitly the desired context in 'sym' as a
+    second parameter, i.e. (sym s 'MAIN) or (sym s ctx) where 'ctx' is a context
+    variable.
+
+    The new behaviour is more intuitive and will make OO based programming based
+    on contexts easier, it also increases isoloation of contexts because the current
+    run-time context is not dependend from where the program was started originally,
+    but only on the situation internal to that context.
+    
+8.7.9
+    added a configure script for compatibility with the popular autoconf/configure
+    system. An installation of autoconf is not required but the same sequence
+    of commands as on autoconf systems will work to make newLISP. newLISP's old
+    ways of making newLISP will also still work:
+
+    ./configure will just try to discover the platform and give a message
+    make will try to discover the platform and make it
+
+    if make cannot discover the platform it will give a message
+
+    the module/context is now reported in error messages
+
+    'load' will never cause the runtime context changed, but the same run-time
+     context that was valid before the call to 'load' will be valid when 'load'
+     returns
+
+    'eval-string' now can specify the context under which it's string argument
+    should be parsed and evaluated.
+
+    'log' can be specify an additional parameter for a different base than the
+    default natural log
+
+    fixed a problem with reading very long UTF-8 source string constants
+
+    big speedup of parse with regular expression, now scaling linear
+    this enables tokenizing big documents in one piece
+
+    args in functions should be evaluated in callers context
+    (for: sym, context, eval-string)
+
+8.7.10
+    raw string ouput (upper ascii in \nnn codes) in the newLISP commandline shell
+    return value only when locale is the default "C" locale.
+
+    'trim' was changing the original string in UTF-8 mode
+
+    'find', 'replace' and 'search' now do binary in both regex and non-regex modes
+     searched buffer, key/patterns string and replacement string can all contain 
+     binary 0s
+
+8.7.11
+    'string' now optimized double fast on string arguments
+
+    getCreateContext() checking symbol protection
+
+     'load' switches to context MAIN when loading file except if different
+     context is specified in file, on return 'load' switches back to callers
+     context (8.7.9)
+
+     'reset' adds an additional parameter for restarting newLISP with same
+     command line parameters with fresh memory in a new process space.
+
+     many security improvements for OpenBSD compiles
+
+     'reset' with optional 'true' (or non 'nil') parameter will restart
+     newLISP with the same commandline parameters, reloading files etc.
+     Not available on Win32 (execv() leave the system unstable when compiling
+     with MinGW.
+
+8.8.0-p1 pre-release 1
+     'reset' was always exiting on UNIX after the change in 8.7.11
+
+     text buffers returned in 'net-eval' > 2048 characters and containing zero
+     characters where throwing  a 'string too long error' 
+
+8.8.0-p2 pre-rlease 2
+     Many doc corrections
+
+	 system symbols in set-nth was broken in 8.7.6
+
+     self refs in set-nth now safe
+
+     added  and changed some cases to qa_dot and qa_comma, now safe again
+	 for memory leak tests.
+
+8.8.0 released February 20th, 2006
+     large file system support for files > 2 GB can now be turned on in newlisp.h 
+     specifying #define LFS. File positions > 2^31 must then be specified as
+     floats up to 999999999999999.0 for 999 terabyte (TB). 'seek' will always 
+     return a float, file positions should be handled as floats using
+     add, sub, mul, div instead +,-,*,/
+
+	 Documentation corrections (thanks Ryon, Nigel et al.)
+
+     moved sql.c and types.c into the util directory
+
+     updated newlisp.vim (v1.27) and newlisp.jsf (v.1.9)
+
+     bug fix in cgi.lsp for '=' in key value strings
+
+8.8.1
+     realloc compiler warning fix in nl-filesys.c/readBuffer()
+
+     error-event, net-eval (edited 4/13/20060), signal and timer can now take 
+     a function or lambda expression, previously only  a symbol holding a lambda: 
+     (signal 2 exit) 
+     (timer (fn () (println "hello")) 5)
+	 The old syntax still works too.
+
+     Could not compile to a library (also fixed in re-release of 8.8.0)
+
+     code cleanup for allocMemory() + memset() => callocMemory()
+
+	 now memory cleanup after exception in functor passed by:
+     'filter', 'index', 'net-eval' and 'replace'. 
+
+     implicit n-rest and slice on default lists and strings:
+     (set 'foo:foo '(a s d f g h j))
+     (2 foo) => (d f g h j)
+     (-3 2 foo) => (g h)
+
+     'save' and 'source' will always serialize from context MAIN perspective 
+     (like 'load') (source reverted back in 8.8.2)
+
+	 fixed odd/even problem for 'rand' on FreeBSD, NetBSD, OpenBSD
+
+8.8.2
+     'source' reverted back to 8.8.0 behaviour: serialize to current context
+
+8.8.3
+     'signal' fixed format of internal symbol when passing functions
+
+     suppress saving/sourcing system symbols starting with '$' unless specified
+     specifically
+
+     new built-in function 'real-path' translates a relative path into an
+     absolute path. (read-path) same as (real-path ".") returns the current
+     working directory
+
+8.8.4
+    'real-path' now also in Win32
+
+    handle self reference of result of while expression in condition
+
+    allow (sys-info 3) or (sys-info -1) as with 'args' and 'main-args'
+
+    'dup' will assume 0 for negative values
+
+    when entering multiline expressions/definitions bracketed by [cmd] ... [/cmd]
+    tags (each on a separate line] and hitting <enter><up-arrow> after the closing 
+    [/cmd], newLISP compiled with lib readline support segfaulted, this long standing
+    bug as finallly been fixed
+
+    in 'xml-parse' when a closing CDATA tag was preceded by a forward slash, then
+    an extra text element containing part of the closing tag was emmitted, 
+    this is fixed
+
+    support for MySQL v. 5.0 was added with mysql5.lsp
+
+8.8.5
+    'read-key' now also works on MacOS X
+
+    a bug in the second syntax of 'context' has been fixed now can do:
+    (push i (context 'CTX "foo")) which now works if CTX:foo is a list
+
+    'load' now can take http:// (and file://) URL prefixes in filnames to retrieve/load 
+    files via HTTP from remote servers
+
+    'xml-parse' now can take a context to place symbols/tags from SXML conversion
+
+    zlib.lsp: new module for in memory and .gz compatible file compression 
+
+    'net-eval' idle loop did not pass parameter (broken in 8.8.1)
+
+    fixed a cell leak caused by 'while' self ref handling in 8.8.4
+
+8.8.6
+ 
+    fix for error reporting of strings, which are too long
+
+    an optional break condition in all looping constructs allows early return:
+        (for (i from to step condition) ...)
+        (dotimes (i N condition) ...)
+        (dolist (i lst conditon) ...)
+    When condition returns non-nil the loop returns with the value of the condition.
+    When loop comes to end end the result of the last body expression gets returned.
+
+    describing the effects of non-rectangular matrices in the "Data types" chapter
+    and for the functions 'multiply', 'invert' and 'transpose'.
+
+    sqlite.lsp vor SQLite v.2.x has been discontinued, use sqlite3.lsp and SQLite3
+
+    error message was printed for each catch level where error was not caught,
+    should only be printed on top level if uncatched
+
+    new 'letex': let expression with expansion of let vars into body expressions
+    before evaluation
+
+    file open for append now atomic
+
+8.8.7
+    new 'clean':
+    (clean predicate? aList) works like:
+    (filter (fn (x) (not (predicate? x))) aList)
+
+    "Transfer-Encoding: chunked" did not trigger chunked decoding
+    when more than one space after the ':' before 'chunked'
+
+    $0 counter did not count first element when in remove mode of 
+    'replace'
+
+    'unify' does Prolog like unification with occur-check
+    (unify '(f (g A) A) '(f B xyz)) => ((B (g xyz)) (A xyz))
+
+    'unify' can take additional assoc params list:
+	(unify '(A (B) X) '(A (A) Z) '((A 1) (Z 4)))
+    => ((A 1) (Z 4) (B 1) (X 4))
+	this is useful when chanining/nesting 'unify' to pass on
+    a newly bound environment
+
+    new mode in 'expand' with parameter assoc list:
+    (expand '(a (B (c) (d a B))) '((a 1) (B 2) (c 3) (d 4))) =>
+	(1 (2 (3) (4 1 2))) 
+    
+    new mode in 'expand' without symbol or assoc list:
+	(set 'X 2)
+	(expand '(a ((X)) b)) => (a ((2)) b))
+	expands only uppercase variables for use with the new Prolog like
+    'unify' function
+
+    added file syntax.cgi for syntax highlighting in HTML of newLISP source
+    to examples directory
+
+8.8.8
+	eliminates several cell leaks in unify
+
+	'pop' can be used on strings (pop str [pos] [len]) pos can be negative
+    'push' can be used on strings (push str [pos]) pos can be negative
+    'push' now will only do list mode when lst is list  or nil:
+    (push new lst) lst has to be list  or nil, previous to string mode of push
+    any existing datatype non-list was initializeed to () now only nil is allowed
+
+    system var $idx contains the offset in dolist:
+		 (dolist (e '(a b c d e)) (println $idx "->" e))
+	0->a
+	1->b etc.
+
+    indexing mode of 'args' now works with multiple indices, i.e (args 3 -1)
+    and is much faster
+
+	implicit indexing syntax now allowed in 'nth-set' and 'set-nth':
+	(set 'd '(a b c d e f g))
+    (nth-set (d 3) 99) => d
+    d => (a b c 99 e f g)
+    or with default functor:
+    (set 'db:db '(a b c d e f g))
+    (nth-set (db -1) 99) => g
+    db:db => (a b c d e f 99)
+    This also works for strings and arrays
+    
+    many fixes/changes/additions in the manual and reference
+
+8.8.9
+    'net-ping' didn't work on localhost
+
+    'nth-set/nth-set' bugfix for new feature breaking old
+
+     complete manual pass of the first 3 chapters by Michael - thanks
+
+8.8.10
+    rotate works also on strings
+
+    (cons item lst -1) for consing at the end of the list (undocumented)
+
+    allow 0 length in chunked pages happening on put-url
+
+    give error message for unterminated [text] in interactive console
+
+8.9.0 Release June 25th
+    complete pass through Users Manual by Michael Michaels
+
+    example programs in Appendix are now syntax highlighted
+
+    dolist $idx safe for nested loops
+
+    member works for strings
+
+    (starts-with s k true) should behave like the default (starts-with s k)
+    same with ends-with. This bug never surfaced because nobody specified
+    anything for the default of case sensitivity
+
+8.9.1
+    (rand x n) returned n+1 after fix in 8.9.0, also looped on n=-1
+
+    new 'zero?' was broken for floats with fractional parts
+
+    newlisp -c -d <portno> and newlisp -c controlled by inetd now understand 
+    simple HTTP GET requests. This feature is mainly intended for use with
+    (get-url "http://...) and (load "http://...) for retrieving or loading
+    files from remote newlisp/inetd worker nodes in a distributed computing
+    environment. 
+
+    manual reviewed/edited up to and including the letter C
+
+8.9.2
+
+    new (find-all pattern string [func [options]]) finds all regex-patterns in a 
+    string and returns a list of matching strings:
+    (find-all {\d+} "asdf2kjh44hgfhgf890") 
+    => ("2" "44" "890")
+    (find-all {(new)(lisp)} "newLISPisNEWLISP" (append $2 $1) 1) 
+    => ("LISPnew" "LISPNEW")
+
+    the parameters in 'format' after the format string can now also be
+    given in a list: (format "%d %s" '(123 "hello"))
+
+    'read-key' did not work on SUSE Linux
+
+8.9.3
+     default values in function and macro parameters: (define (foo (a 1) (b 2)) (list a b))
+    (foo) => (1 2)
+    (foo 3) => (3 2)
+    (foo 3 4) => (3 4)
+    no performance loss for normal syntax without defaults
+
+    format partly rewritten for better portability, 
+    no tru64.c or ffi required after removing TRU64 for p_format in nl-string.c
+
+8.9.4
+    removed tru64.c and changed makefile_true64
+
+    starts-with and ends-with can do reguluar expressions and take a regex option number, 
+    the old nil-option for case insensitivity still works and is translated to regex 
+    option = 1, but is deprecated and will be eliminated in the future
+
+    member for strings can take regular expressions, the old case insensitivity option
+    will not work (member for strings was introduced only recently
+
+    'symbol' the old writing for 'sym' has been eliminated
+
+    fixed create context bug in newlisp-tk.tcl
+
+    (<< num) works like (<< num 1), (>> num) like (>> num 1), (div num) like (div 1.0 num)
+
+    function 'uuid' for creating Universal Unique IDs type 1 and 4 (RFC 4122)
+
+    -C command option for Emacs forces prompt even if in pipe mode
+
+    manual edits up to letter J, thanks Michael
+
+8.9.5
+    type 4 UUID now closer to RFC 4122 specification
+
+    trying to use set-nth or nth-set on an empty list corrupted the list
+
+8.9.6
+    UUID type 1 got timestamp wrong, UUID 4 always started the same sequence
+
+
+-------------------------- 64 Bit Integers  ------------------------------------
+
+
+8.9.7
+    all integer arithmetik 64 bit
+
+    'factor' now takes integers with  max 64 bits and is 4x faster than previously
+
+    'import', 'pack', still take ints as 32bit, taking the least significant 32 bits
+	to pack 64bits do: (pack "ldld" int64 (>> int64 32)) for little endian
+	for big endian do: (pack "ldls" (>> int64 32) int64)
+    
+    'format' has new 64 bit formats "%lld", "%llu" "%llx" for 64bit decimals and
+    hex numbers on UNIX on Win32 use "%I64d", "%I64u", "%I64x"
+
+    'format' now also recognises 'e' and 'E' scientific folating point formatting
+
+    32 bit format strings "%d" "%u" "%x" will truncate on int64 numbers
+
+    in float->int conversions floats out of range are converted to min/max 64 bit int
+    -9223372036854775808, 9223372036854775807 and 18446744073709551615 for unsigned
+
+	if an int32/uint32 is required by a function int64 values overflow to 
+    min/max 32 bit int -2147483648/2147483647 and 4294967295 for unsignde int
+
+    LFS (large file support) in file operations for files opened with 'open'
+    now full 64 Bits (before 40 Bits)
+
+    (for (i from to step)...) has float in i, only when optional step value is specified 
+    (sequence from to step) produces float only when optional step value is specified 
+    (dotimes (i N)...) always has integer in i
+    this is consistend with 'inc' and 'dec'
+
+    net-select now can go to 68 :) years waiting time specifying 64bit  higher timeout
+    values and a timeout of -1 waits forever
+
+	'net-close' with optional parameter: (net-close sock true) will suppress shutdown()
+    before closing the socket. In this case net-close will wait for undergoing traffic
+    to finish
+
+    new function (gcd x y ...) for greatest common deviser of n arguments
+
+    (pow x) defaults to (pow x 2)
+
+    wrong format could segfault (this bug was introduced in 8.9.3)
+
+    when replacing the first element in an association list with 'replace-assoc' and 
+    an error occured when evaluating the replacement expression a segfault occured
+    (thanks to Ingo for catching this)
+
+    Note that bits shifts <<,>> now work on 64-bit integers too (added 2006-09-12)
+
+8.9.8
+    'net-eval' now evaluates node parameters, before constants where required
+    (set 'host "localhost" 'port 4711 'cmd "(+ 3 4)")
+    (net-eval '((host port cmd)) 1000) = (7)
+
+    'net-eval' if no timeout specified waits forever
+
+    'net-eval' short form for one node: (net-eval host port cmd [timeout idle-loop])
+    timeout an idle loop are optional: (net-eval host port cmd)
+
+    Similar as for (load "http:// ...) and (get-url "http//..) in 8.9.1;
+    server mode: newlisp -c with -p or -d, now understands HTTP PUT requests
+    for saving/writing text files to a newLISP server node on UNIX using:
+    (save "http://..." ...) and (put-url "http://...") ...)
+    The server mode together with the beefed up 'net-eval', 'load', 'save'
+    'get-url' and 'put-url' assemble a nice toolset for distributed applications
+    with newLISP. The server node can also be started by inetd or xinetd. 
+    (See manual). Must give full path-file-name in URLs i.e:
+    (put-url "http://localhost:50001//Myfiles/afile.txt" (read-file "somefile"))
+
+    newLISP server mode with HTTP capabilities in not yet available on Win32.
+
+    target context MAIN is now disabled in 'def-new' and 'new' because it would
+    cause ambigous situations when copying context vars after fixing a related
+    bug: def-new and new on context-vars
+
+    on UNIX a shared memory address obtained with 'share' can be unmapped using
+    (share nil <address>)
+
+	'put-url' with "Pragma: append\r\n" in header option appends when talking
+    to newLISP server
+
+    'read-file', 'write-file' and 'append-file' accept "http:// ..." and
+    for HTTP mode and "file://..." for normal file mode.
+    in HTTP mode they work exactly like 'get-url', 'put-url' and 'put-url'
+    with "Pragma: append" in the header option.
+ 
+    new QA file qa-net for testing newLISP server modes with:
+    net-eval, load, save, read-file, write-file, append-file
+
+    new QA file qa-utf8 to display UTF8 characters, this is not a test for 
+    newLISP but rather the UTF8 display capabilities of the platform running on 
+
+8.9.9
+    matrix operations now can be performed on arrays (previously only lists)
+    matrix operations will return the type (list or arrray) which was given
+    as input. In case of mixed input (i.e. in multiply), array type is
+    returned.
+
+    new function 'det' returns the determinant of a square matrix expressed
+    as a list or array.
+
+    fixed cell leak in define-macro when exercising default values
+
+    64-bit integers where not displayed correctly in Win32 MinGW
+
+8.9.10
+    'append', 'first', 'last', 'rest', 'slice' (and implicit slicing) now also
+     available for arrays 
+
+    (timer 'event 0) did not stop on Win32
+
+    a fix in Curl_base64_decode() for bad base64 strings
+
+    20% speed up for append on strings and join
+
+8.9.11
+    'append' did not append correctly to lambda lists, which lost lambda attribute
+
+    'qa-net' fixed (this file only tests on UNIX)
+
+8.9.12
+    'int' did a signed instead of unsigned conversion
+
+     'save' did not save global protected symbols in a way they
+     could be reloaded
+
+8.9.13
+     'local' like 'let' but no initialization of locals (all nil): 
+     (local (x b x) body)
+
+     'swap' has a third syntax pattern to swap the contents of symbols: (swap x y)
+
+8.9.14
+     speedup and memory savings on 'apply'
+
+     fixed INT64->string conversion in sym for True64/WINCC
+ 
+     error checking on all reallocs()
+
+     changed to realloc() in writeStream() routines
+
+8.9.15
+	(join '(1 2 3)) was hanging, instead of wrong datatype error message
+	
+	support "\x41\x42\xff" in string hex format equivalent to "\065\066\255"
+
+	new 'ref-all' returns a list of index vectors for all ref's of an expression
+	(ref-all 'a '(a b c (d a f (a h a)) (k a (m n a) (x))))
+	=> ((0) (3 1) (3 3 0) (3 3 2) (4 1) (4 2 2))
+
+9.0.0 Release October 15th, 2006
+
+9.0.1
+    'read-file' did not read extended http:// mode parameters correctly
+
+    new 'doargs' works like 'dolist' iterates through (args)
+	(define (foo) (doargs (i) (println i)))
+    (foo 1 2 3) => prints 1 2 3
+    implemented on top of 'dolist' also does $idx and break-expressions	
+
+    'explode' takes extra parameter for # of characters (works on UTF-8 too):
+    (explode "newlisp" 2) => ("ne" "wl" "is" "p")
+
+    new 'utf8len' length of a string in UTF-8 characters
+
+    new scalar matrix operations (matrix is a 2 dimensional list or array): 
+    (set 'A '((1 2 3) (4 5 6))
+    (set 'B A)
+    (mat + A B) => ((2 4 6) (8 10 12))
+    (mat - A B) => ((0 0 0) (0 0 0))
+    (mat * A B) => ((1 4 9) (16 25 36))
+    (mat / A B) => ((1 1 1) (1 1 1))
+    Note that all matrix operations are in floating point
+
+9.0.2
+    explode works on lists: 
+    (explode '(a b c d e)) => '((a) (b) (c) (d) (e))
+    (explode '(a b c d e) 2) => '((a b) (c d) (e))
+    many structural transformations can be done combining 'explode' and 'transpose'
+
+    fixed cell-leak in 'ref-all'
+
+    in (mat <op> A B) B can be a single number: 
+    (mat + '((1 2 3) (4 5 6)) 2) => ((3 4 5) (6 7 8))
+
+    some fixes for HTTP mode on UNIX
+
+    HTTP mode now working on Win32 but with some timing issues,
+    see header of file qa-net for details
+
+9.0.3
+    $idx was broken after 9.0 starting with 1 instead of 0
+
+9.0.4
+    fixed midnight rollover in 'timer' on Win32
+
+    new (round <number> <precision>) rounds a number to precision digits
+    left (positive) or rigt (negative) of the decimal point
+
+    new hyperbolic functions sinh cosh tanh
+
+    fixed push -1 optimization when popping only remaining element in list
+
+    new 'ostype' symbol holds os type string
+
+    new 'delete-url', needs to be enabled on target www server (most aren't)
+    else => "ERR: server code 405: HTTP/1.1 405 Method Not Allowed\r\n"
+    and must have file permissions set accordingly on target file;
+    additional parameters like timeout and custom headers are available
+    exactly as in 'get-url', the feature is also available in:
+    (delete-file "http://......"), similar to HTTP mode in 'read-file', 
+    'write-file' and 'append-file' and is also implemented in newlisp
+    server mode (not working on Win32 newlisp server mode)
+
+    GET queries are now supported in newlisp server mode (not yet Win32)
+
+9.0.5
+    'and' and 'or' now () when failing and last evaluation was ()
+
+     GET and POST cgi now working on UNIX and Win32 (9.0.6)
+
+     new -w <working-directory> commandline switch 
+     useful for changing working directory after newlisp startup:
+         newlisp -c -d 8080 -w /Users/lutz/ide
+     this is the same as going into the directory and starting newlisp
+         newlisp -c -d 8080
+
+     newlisp can now run as a webserver doing newlisp based CGI. It runs both
+     newlisp-ide-x.x.tgz and newlisp-wiki-x.x.tgz, to run the ide on the local
+     machine:
+         newlisp -c -d 8080 -w /usr/home/www/ide
+     then in a webbrowser enter the URL http://localhost:8080/
+     index.cgi and index.html are looked for by default if no filename is
+     specified in URL
+
+     httpd example programm has been eliminated, because httpd mode now built-in
+     into newLISP
+
+     'file-info' now correctly reports filesizes > 2G (2147483647) bytes
+     now also can index: (file-info <path-name> 0) => filesize
+
+     the -x commandlne switch has been disabled, use newlisp server modes instead
+
+     fixed problems with break-condition in dolist/doargs introduced in 9.0.1
+     fixed problem when break-condition is the loop symbol itself 
+
+9.0.6
+     'nth' now with similar syntax options as 'net-set/set-nth'
+     new in 'nth':
+        (nth (L <idx1> <idx2> ...))
+        (nth (L <aref>)) ; where <aref> is a list of indices
+     new in 'set=nth', 'nth-set'
+        (set-nth (L <aref>) <newval>)
+        (nth-set (L <aref>) <newval>)
+
+     'file-info' now distinguishes in the mode field (12th bit) between links 
+     and normal files: 
+        (define (link? fname) (= 0x2000 (& (file-info fname 1) 0x2000)))
+     not on Win32, who knows the correct Win32 function for lstat() on MinGW gcc?A
+
+9.0.7
+     HTTP server mode looks for procedure httpd-conf for processing/transforming
+     the path-file-name of the request. This way security checks, remappings etc
+     can be performed. In this case a file httpd.conf containing the definition
+     of httpd-conf can be loaded when starting the server:
+        newlisp httpd.conf -c -d 8080 -w www/httpddocs
+     if the file httpd.conf contains:
+        (define (httpd-conf request) 
+            (if (ends-with request ".exe") "errorpage.html" request))
+     now any request for a file which finishes in .exe will be transformed into a
+     request for errorpage.html containing an error message for the client.
+
+     fixed HTTP server mode crash on LINUX
+
+     fixed 'nth' which failed on old mode when indices where expressions
+
+9.0.8
+    new syntax of 'nth' should work on protected symbols
+
+    new syntax of 'set-nth/nth-set' did not check for index maximum of 16
+
+    make httpd-conf safe for non-string returns
+
+    server mode now correctly remaps directory paths when performing CGI
+    in directories not web root, i.e. http://ahost.com:/ide/ will work with CGI,
+    note that directories need to end with "/" to make the resolve to index.html
+    or iondex.cgi work correctly
+    
+    new -http flag like -c (suppressing prompts) but only allow HTTP commands
+    no newLISP statements (-c allows both), this is a 'safe' HTTP mode not
+    allowing 'net-eva' or other commandline protocols.
+    The following configurations can be used:
+	
+    (1) serve HTTP requests only
+        newlisp -http -d <portno> -w <www-root>
+        newlisp -http -w <www-root> # started vi INIX inetd or xinetd
+
+    (2) serve 'net-eval', HTTP and command line without prompt
+        newlisp -c -d <portno> -w <www-root>
+        newlisp -c -w <www-root> # started via UNIX inetd or xinetd
+    this mode is useful when running newLISP server in a controlled environment
+    behind a secured firewall in a distributed computing environment where 
+    newLISP server must answer to both: net-eval and HTTP requests.
+
+    Note that on Win32 a \tmp directory must be created on the same drive
+    which is current for CGI processes for newLISP HTTP mode to work correctly
+    for CGI processing. On UNIX /tmp is standard.
+
+    fixed 'invert' crash (since v.9.0.2) on not-invertible matrices
+
+    upgraded to better random number generation in 'rand' and 'random'
+	(not available on Win32)
+
+    fixed (rotate '(1) -1)
+
+9.0.9
+    another fix for 'nth' and protected symbols
+	
+    if 'httpd-conf' returns 'nil' nothing will be processed, this can be
+    used to completely hand off CGI request processing to httpd-conf
+
+9.0.10
+    moved env variable creation of DOCOUMENT_ROOT earlier, so it is available
+    in httpd-conf.lsp
+
+    added httpd-conf.lspi to the examples directory in the source distribution,
+    now filters csertain file extensions and does not allow access to files 
+    outside the web directory tree specified with the -w option:
+        newlisp httpd-conf.lsp -http -d 8080 -w /wwwdocs
+    or outside the startup directory if no -w is given, also takes care
+    of request for directories when no trailing '/' is present
+
+    cleaned up nthArray  and implicitIndexList/array code
+
+    trying to 'set-nth' and empty list should return the empty list not nil
+
+    more tests in qa-dot and qa-comma for symbol protection and 'nth'
+
+9.0.11
+    rework of whole indexing area, now correctly honors symbol protection in
+    all modes if symbol is nested inside an expression. The old flat mode: 
+      (nth i j alist)
+    is much slower, instead use one of the following modes:
+      (nth (alist i j)) or (alist i j) or (nth (alist aref)) or (alist aref)
+	ehere aref is a list of nymbers, i.e.: (1 2), same modes in set-nth,nth-set
+
+    reworked nil and empty list detection throughout all files. 'nil' and the
+    empty list '() are logic false, things work like this:
+        (map true? '(nil () 0 "")) => (nil nil true true)
+        (map nil? '(nil () 0 "")) => (true nil nil nil)
+        (map not '(nil () 0 "")) => (true true nil nil)
+        (map null? '(nil () 0 "")) => (true true true true)
+    in v9.0.0:
+        (true? '()) => true, which was wrong because also 
+        (true? (not '()) => true, which is correct
+    this affects filter and index usage with true? as predicate, but does not
+    affect: if, unless, while, until, do-while, do-until, which always worked
+    correctly assuming '() as logical false
+
+    'name' also can take contexts i.e.: 
+        (set 'L:L '(a b cd)) (set 'x L) (name x) => "L"
+
+    now when evaluating a context by itself it returns the default symbol
+    if the default symbol does not exists it gets created:
+          (set 'foo:foo '(a b c d e f g))
+          (foo) => foo:foo
+          (eval (foo)) => '(a b c d e f g)
+    this can be used for reference passing:
+          (define (mysort ctx func) 
+              (sort (eval (ctx)) func))
+          (mysort foo >) => (g f e d c b a)
+          foo:foo => (g f e d c b a)
+    previously a passed context could only be used for functions using
+    index lists and implicit indexing as in (nth-set (ctx idx) value) etc.
+    now functions working on the entire list can be used with reference passed
+    data. THIS FUNCTIONALITY HAS BEEN DISABLED IN 9.0.14, as a workaround
+    use (sym (name ctx) ctx) to retrieve the functor
+
+9.0.12
+    the newLISP-tk installer now contains a file md5-checksums.txt with
+    checksums for newlisp-tk.exe, newlisp.exe and newlisp.dll
+    
+    bit not ~ was still on 32 bits now 64 like all integer arithmetik since 9.0
+    
+    all buffer variables moved to size_t and ssize_t type in preparation for
+    64-bit model LP64 compile for 64-bit memory addressing.
+    
+    get-char, get-int, get-float and get-string failed when using on 64-bit
+    addresses, which where not truncated correctly on little-endian CPUs.
+    This affected the mysql.lsp and mysql5.lsp modules when using with newLISP
+    versions 8.9.7 and later and on Intel CPUs. On Mac PPC and other big-endian
+    architectures this problem did not occur. All other modules where not affected
+    on any architecture.
+    
+    <,>,<=,>=,= when given only one argument compare agains 0, "" or (),
+    all other data types return true as before
+       (< 1) =>nil, (= 0) =>true, (> "abc") => true, (= "") =>true etc.
+
+    64-bit file poisitioning fixed under Win32 (now runs qa-lfs)
+
+9.0.13
+    fixed problems in the new <,>,<=,>=,= single argument feature
+ 
+9.0.14
+    further fix in 64-bit ~ function
+
+    a context feature intoduced in 9.0.11 to extract the default functor from an 
+    unknown context has been disabled, instead use the workaround:
+        (set 'foo:foo '(a b c d e f g))
+        (set 'ctx foo)
+        (sym (name ctx) ctx) => foo:foo
+        (sort (eval (sym (name ctx) ctx)) >) => (g f e d c b a)
+        foo:foo => (g f e d c b a)
+    a more elegant way will be supplied in the future
+
+    both string and list versions of 'explode' now return an empty list if optional
+    length <= 0
+
+    'nt-set/set-nth' did not honor constant protection of default functors
+
+	now compiles for LP64 64-bit memory model on 64-bit LINUX using the makefile:
+       make -f makefile_linux64LP64
+    or simply:
+       make linux64LP64
+
+    the old makefile for making a ILP32 32-bit newlisp on 64-bit LINUX has been
+    renamed:
+       make -f makefile_linux64ILP32
+    or simply:
+       make linux64ILP32
+
+    tested on a AMD64 CPU with LINUX 2.6 64-bit Fedora 3
+
+    enjoy up to 17,179,869,184 gigabytes or 16 exabytes of RAM, on AMD64
+    the LP64 compiled version is 12 to 25% faster than the ILP32 version
+
+    avoid sign extension when unpacking signed 32bit into unsigned 32bit displayed
+    in 64-bit: (unpack "lu" (pack "ld" -1)) => (4294967295) ; not (-1)
+
+    added 'get-long' and "Ld", "Lu" 64-bit packing formats 
+
+    new 'parse-date' for parsing date strings (not yet working for Win32)
+
+9.0.15
+    more manual additions and changes, moved all predicates into own group
+
+    fixed dynamic symbols compare
+
+    fixed warnings fo missing -Wno-strict-alasing GCC message on older Solaris
+    and BSD GCC versions
+
+    fixed parsing of [text] tag on 64-bit compiles
+
+    fixed 'flt' for TRU64 compile
+
+    tried Linux debian package, Ok on Ubuntu, will be included from now on
+    in newlisp.org releases, but appreciate help in getting it into Ubunto
+    and Debian for inclusion into their lists
+
+    The Tru64UNIX compile using makefile_tru64 is now a large pointer model LP64
+    compile, thanks to Peter for porting and testing on an Alpha CPU
+
+    added makefile_darwin_LP64 for 64-bit compile/link, but cannot test it
+    on my  PPC-G4 (I believe I need a G5 for this)
+
+    fixed 'char' on UTF-8, bug due to 64-bit changes
+
+    LP64 mode for Solaris workng, use makefile_solarisLP64
+
+    new 'make test' to run qa-dot, qa-net, qa-xml
+
+9.0.16
+    OS/2 compile flavor now part of distribution
+
+    fix for Solaris in some networking routines broken in 9.0.2 !
+
+    fixed: (dup x -1), which was broken since 9.0.14
+
+    'make test' now does qa-dot, qa-xml, qa-setsig, qa-net all one after
+     another. The qa-setsig script will drop out on Win32 with a message.
+
+     A small change in the 'test-process' routine in the qa-dot script will 
+     cause less failure message for 'process' on slow computers.
+
+     qa-dot now will set to locale "en_US' when testing an UTF-8 version,
+     this has been done to suppress failure messages for UTF-8 'upper-case'
+     and 'lower-case' which do not work in the default 'C' locale in
+     UTF-8 mode on some platforms.
+     qa-comma always sets to "de_DE"
+
+     'asinh', 'acosh', 'atanh' complete the triginometric functions
+
+     up to 8 'callback' routines cain be defined to be called by an imported
+     library, example for Glut lib:
+        (glutDisplayFunc (callback 0 'draw))
+        (glutKeyboardFunc (callback 1 'keyboard))
+        (glutMouseFunc (callback 2 'mouse))
+     up to four parameters (32-bit ints) are received by the user-defined
+     callback handlers. See the file newlisp-9.0.16/examples/opengl-demo.lsp
+     for details. Note that OpenGL passes floating point data, which are only
+     handled correctly on x86 based platforms. On the Mac PPC this file will
+     not work (although the callback interface itself does work, but no
+     drawing will be visible).
+
+9.0.17
+     fixed 'non-blocking' bug for write on Linux, thanks Peter!
+
+     number of maximum cells was not reported correctly in 64-bit newLISP
+
+     'ref' and 'ref-all' now can take a comparison functor (like 'sort') for
+     comparison: (ref-all key List func), if no func is specified
+     assumes = (equal), ref-all now much faster on big lists with  many finds.
+
+     'find' and 'replace' (both in their list forms) can take a comparison
+     functor like 'sort', 'ref', 'ref-all'.
+     'replace' for lists now also processes $0 (old entry) in replacement 
+     expression. 
+
+     using replace for lists with 'match' or 'unify' as comparison functor 
+     makes 'replace' as powerful as 'replace for strings with regular expressions.
+     This is an important new feature with many applications.  It also gives
+     the much overlooked 'match' and 'unify' the more frequent usage they deserve.
+
+     new logic functions 'exists' and 'for-all' apply a condition to each
+     element in a list and return the result.
+
+     match now will accept atoms in the entry expressions to make it usable 
+     for 'ref' and 'ref-all'
+
+9.0.18
+     fixed a bug in (pop <string> <idx>)
+
+9.0.19
+     (find <str> <str> [<option>]) will do both: regex if option is a number
+     (as before) and function comparison if option is a funtor or user-defined
+     function.
+
+     fixed 'pop' on an empty string
+
+     fixed newlisp -h where new options didm't show
+
+     'file-info' was hanging on name pipes now shows 0 for file size
+
+     trying to start server mode with no or zero port will fail
+
+     'array' will give error message on negative parameters, before
+     they where simply skippped
+
+     Ctrl-C signal handler crashed on Linux when in -d mode
+
+     'explode' will take optionl 'true' to omit chunksize too short when
+      chunk size is given (strings and lists)
+      (explode "newlisp" 3) => ("new" "lis" "p")
+      (explode "newlisp" 3 true) => ("new" "lis")
+
+9.0.20
+     -l and -L mode now always must specify a path-name for the
+     log file (either attached or detached):
+         newlisp -l /usr/home/www/logfile.txt
+     logging is allowed in all modes. -l will only log network connections
+     or commandline or net-eval requests input. -L will log also HTTP requests 
+     and newLISP output from commandline and net-eval
+
+     doc installation directory changes from /usr/share/newlisp/doc to
+     /usr/share/doc/newlisp
+
+     CodePatterns.html ammended with chapter for HTTP only server mode
+     MemoryManagement.html ammended with implementation chapter
+
+     newLISPdoc.html and inewLISP-X.x-Release.html added to install 
+     in /usr/share/doc/newlisp, this file will only change on mayor
+     releases
+
+    
+9.0.21
+     a crash bug in 'match' introduced in 9.0.17 was fixed
+
+     new 'curry' (curry f x) => (lambda (y) (f x y)), makes a unary opearator
+     out of a binary operator, useful when using 'match' 'unify' and other 
+     binary ops in: 'filter', 'clean', 'index' etc., i.e:
+     (filter (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+     => ((a 10) (a 3) (a 9))
+
+9.0.22
+     integrated syntax highlighting into newlispdoc, which now is part of
+     installation in /usr/bin/ and with man page in /usr/share/man/man1 
+
+     added media types for .pdf .mov. .mpg  and .mp3 in HTTP request handling
+     additionally to .jpg .png .gif
+
+     protect stack from overflow when loading huge contexts in sysEvalString()
+
+
+9.1.0 Release February 15th, 2007
+
+9.1.1 Release March 15t, 2007
+     safer memory allocation for net-ping when using wildcard *
+
+     new module crypto.lsp with md5 and sha1 hash functions
+
+     fixed bug in Win32 version when stdout of more than 2048 chars
+     in shell window
+
+9.1.2
+    net-peer, net-local and net-receive-from where dropping the third digit of the
+    least siginificant IP group in the IP-string return value on 12 digit IP numbers
+
+9.1.3
+    makefile_osxLP64 produces a 64-Bit version on intel core 2 duo which passes
+    'make test'. Use: make osxLP64 or: make -f makefile_osxLP64
+
+    some cleanup in nl-sock.c
+
+    newlisp-tk.tcl now detects default browser in Debian LINUX
+
+9.1.4
+    passed all rand() to newer, better random() in nl-math.c
+
+    local domain UNIX sockets using: (NOTE THAT SYNTAX CHANGES IN 9.1.5)
+		 (net-listen <str-path> "local") and (net-connect <str-path> "local")
+    then use 'net-accept', 'net-select, 'net-send' and 'net-receive' as usual
+    see also file qa-local-domain
+
+    fixed many problems with 'net-ping' which did not work correctly on
+    machines rejecting out of sequence errors in ICMP packets. Now will handle
+    EHOSTDOWN and EHOSTUNREACH errors correctly
+
+    'net-ping' now also can accept ranges, e.g: (net-ping 192.168.1.120-150) 
+    additionally to the '*' star, i.e: (net-ping 102.168.1.*)
+    superuser permission are required for net-ping
+
+    added MySQL:escape to mysql.lsp (v.4) and mysql5.lsp, thanks to Jeff
+    for submitting this addition
+
+    added HTTP_COOKIE to environemnt variables set by newLISP HTTP server
+    mode
+
+    leading and trailing white space now gets removed from environment variables
+    set by newLISP server mode, specifically in HTTP_HOST, HTTP_USER_AGENT and 
+    HTTP_COOKIE
+
+9.1.5
+	changed the way of specifying local-domain UNIX sockets in net-connect and net-listen:
+    (net-connect <local-socket-path>) ; don't specify a port
+    (net-listen <local-socket-path>) ; specify socket-name instead of port)
+
+	local domain UNIX socket support in newlisp -d server mode and net-eval:
+    server mode: newlisp -d /tmp/mysocket
+	client: (net-eval "/tmp/mysocket"  0 "(+ 3 4)") => 7
+
+    speedup utf8_wlen()
+
+    load and save do not use lisp source anymore but call getPutPostDeleteUrl() directly
+    this increases speed and leaves get-url/put-url to be renamed if required
+
+    guard against partial send()'s in net-eval and HTTP mode on Win32
+
+    'net-eval', 'net-ping', 'net-receive-from' and 'net-receive-udp' now set
+    timeout error for retrieval with 'net-error'
+
+    'net-ping' will stop waiting for response when the number of responses
+    reaches the number of pings even if no max count was not specified.
+
+    a fix for local-domain UNIX sockets on OS/2
+
+    reorderd "3. Functions in groups" subchapters adding group "Pattern recognition"
+
+    now any keystroke/mouse-button will close the about windows in newLISP-tk.
+    Before only <esc> worked
+
+9.1.6
+    newlisp-x.x.x/util/nclocal.c utility program similar to nc/netcat but for
+    local domain UNIX sockets. 
+
+    When deleting contexts the context symbol now will stay and not be deleted 
+    but demoted to a normal unprotected symbol.
+
+    It is now possible to create contexts on local variables in 'define', 
+    'lambda' or 'local' expressions without error messages on usage of these 
+    symbols/variables subsequently. After leaving the 'define', 'lambda' or 
+    'local' the variable symbols will be returned to their previous status in 
+    the upper scope. Before this version they staid protected. 
+    Note: For efficiency reasons this coding practice is not recommended but 
+    will not cause an error anymore.
+
+	use strncmp() instead of strcmp() in netReieive() to avoid buffer overflows
+
+    read empty [text][/text] tagged text correctly
+
+    newlisp doc v.1.1 fixes formatting of the syntax line when parenthesized 
+    expressions are part of the syntax line.
+
+9.1.7
+    a fix for ends-with when using with regular expression option (did not anchor
+    correctly to the end)
+
+    net-listen didn't evaluate the port parameter since 9.1.4 when local domain 
+    sockets where introduced
+
+9.1.8
+    fixed a crash bug on Win32 when using a permission mask in make-dir
+
+	'%%' as a last spec in format was not translated correctly
+
+9.1.9
+    when a system wide error handler defined with error-event contained 'nil
+    newLISP would go into a loop caused by an error invoked by the error handler
+    now an error-event defined with a symbol containing nil will simply to
+    nothing.
+
+    xml-parse now can take an optional callback functor (see manual for detail)
+
+    on the Win32 UTF-8 versions UTF-16 file-path names now are processed
+    correctly, thanks to Michael Sabin for contributing the file win32-path.c
+
+    this is the first release containing the source of Java based GUI-server 
+	in the guiserver subdirectory of the distribution. guiserver.jar is
+    already prebuilt contained in the source distributin and installed
+    drng the normal newlisp install. It also can be installed individually
+    descending into newlisp-x.x.x/guiserver (read README.txt found there)
+
+    new global? property function checks if a symbol is global
+    new protected? property function checks if a symbol s protected
+
+    a bug in push on strings when the index was > the length of the string
+    and a fix for utf8
+
+9.1.10
+    this development release was made for additions in newLISP-GS
+
+9.1.11
+    fixed a bug in explode when specifying N > length of string
+
+    negative second length in slicing now interpreted as offset
+    from the right: (2 3 "abcdefg") => "cde", (2 -3 "abcdefg") => "cd"
+    before negative length would be interpreted as going to the end
+
+    implicit n-resting on strings was UTF-8 sensitive which it should
+    not be, all implicit indexing and slice on strings is on byte borders,
+    only first,last,rest are UTF-8 sensitive.
+
+    fixed crash when net-select was interrrupted by timer, traceExit()
+    was not protected from entry when signal handlers where defined
+
+9.1.12
+    newlisp invoked on the command line can take URLs for filespecs to execute
+    remote programs: newlisp http://newlisp.org/example.lsp
+
+    join now can take an extra flag to force a joint string after the last element:
+    (join '("A" "B" "C") "-" true) => "A-B-C-"
+
+9.2.0 Release August 15th, 2007
+
+9.2.1
+    rewritten 'count is about 3-4 times faster than before when counting 100 
+    in 1,000,000 elements. Only on Mac OS X and other UNIX. On the older
+    MinGW GCC C library the required functions tsearch() and tfind() are not
+    available.
+    
+    fix for special characters in cookies cookies in cgi.lsp
+
+    'pack' now can take lists for data:
+    (set 'lst '("A" "B" "C"))
+    (set 'adr (pack "lululu" lst))
+    (map get-string (unpack "lululu" adr)) => ("A" "B" "C")
+    This was imnplemented in response to a request for a (address <list-of-strings>).
+    Note that the lst should not be changed and be referenced directly in 'pack'
+    so the pointers passed by 'adr' are valid. 'adr' would be a 'char * adr[]' in the 
+    C-programming language
+
+    fixed cell leak in indexed sys-info and indexed file-info
+
+    new 'dostring' iterates over a string with character values in loop variable. 
+    On UTF-8 compiled newLISP UTF8 character values are returned by the loop variable
+
+    documented 'bind' : 
+    (bind '((a 1) (b 2) (c 3))) same as  (map set '(a b c) '(1 2 3))
+    This function was already in earlier versions, but not documented.
+
+    on startup NEWLISPDIR will be registered as either: /usr/share/newlisp
+    on Mac OS X / UNIX as: PROGRAMFILES/newlisp on Win32, where ROGRAMFILES
+    is an exisiting Windows environmnt variable. (env "NEWLISPDIR") =>
+
+    additions in guisserver.lsp and newlisp-edit.lsp, see guiserver/CHANGES
+
+9.2.2
+    iterators segfaulted when evaluating the iterator variable was the last
+    statement in the iterator body: dostring, dolist, dotree. 
+    Added test-cases for this situation.
+
+    (main-args) could be pop'ed which was due to an implementaion error, main-args
+    cannot be popped any more, if necessary, assign to another variable first:
+    (set 'margs (main-args)), (pop margs) etc.
+
+    additions in guisserver.lsp and newlisp-edit.lsp, see guiserver/CHANGES
+
+9.2.3
+    addtions, changes in guiserver.lsp and newlisp-edit.lsp, see guiserver/CHANGES
+    for details
+
+    misc. code cleanups in core
+
+9.2.4
+    in 'set-nth/nth-set' when no replacement arg is given, the old value should
+    be returned only as in 'set'. Was replacing with nil.
+
+    fixed a cell-leak in 'set' when using mutliple arg pairs.
+
+    allow symbols for the name in (context <ctx> <name> [<value>]), previously
+    only strings where allowed.
+
+    speedup in symbol deletion
+
+    in (signal <sig-no> <handler | flag> the nil flag now specifies SIG_IGN
+    and the true flag SIG_DFL. Before 9.2.4 nil would specifiy an empty newLISP
+    handler and the true flag was not available.
+ 
+    reworked 'process' now creates the new process without the previous
+    time and memory overhaead (on UNIX) of an extra newlisp fork which stayed
+    in memory until the newly created process had finished.
+    In most cases the full path must be given for the command in 'process'.
+
+    new 'destroy' to destroy  processes created with 'process' or 'fork'	
+    see reworked docmentation for 'fork' and 'process'
+
+    fixed a bug when sorting (ordered compare) mixed  boolean values/symbols
+
+9.2.5
+    'dup' without the repetition number parameter will assume 2, i.e:
+     (dup 'x) == (dup 'x 2) => (x x) ;  Thanks to Lance Bradley for this idea.
+
+    'find-all' will return an empty list '() when nothing is found, previously
+    nil was returned.
+    
+	':' now also works like a function and can be attached to symbol following
+    it. The colon operator forms a context symbol from the symbol following it
+    and the context symbol found as the first element of the list contained
+    in the next argument.
+
+    (define (rectangle:area p)
+	    (mul (p 3) (p 4)))
+
+    (define (circle:area c)
+	    (mul (pow (c 3) 2) (acos 0) 2))
+
+    (set 'myrect '(rectangle 5 5 10 20)) ; x y width height
+    (set 'mycircle '(circle 1 2 10)) ; x y radius
+
+    (:area myrect) => 200 ; same as (rectangle:area myrect)
+    (:area mycircle) => 314.1592654 ; same as (circle:area mycircle)
+
+    This can be used for simple OO programming where objects are represented 
+    as lists and methods are packaged contexts / namespaces serving as object
+    classes. The colon ':' operator implements polymorphism by looking up
+    the class / context of the object as the first symbol in the object list.
+
+    'integer' the long writing of 'int' will be eliminated in the next
+     development version!!!
+     new versions newlisp-ide-4.1.tgz and newisp-wiki-4.2.tgz have changed
+    'integer' to 'int'
+
+    better platform independent library detection routines in modules:
+    crypto.lsp, gmp.lsp, sqlite3.lsp and zlib.lsp
+
+    crypto.lsp has new 'crypto:hmac' as of RFC 2104 used for Amazon REST API
+
+    new util/newlisp.vim, for matching .vimrc see http://newlisp.org/code/vimrc.txt
+
+9.2.6
+    Moved to MinGW 5.1.3 with gcc v.3.4.5 and eliminated declarations for
+    struct timezone and gettimeofday(). Changed sleep() to Sleep().
+    -> grep 3\.4\.5 *.c <- shows all changes 
+
+    Improved random number generation with 'rand' now gives better integer quality
+    random numbers on Win32, which only does 16 bits in 'C' random(), even for
+    ranges close to or > 16bit.
+
+    newLISP GS 1.07 now automatically restarts monitor shell, if required by run-command.
+
+    newLISP GS 1.07 now loads, saves and displays UTF-8 correctly in editor and 
+    interactive monitor area
+
+    new manual chapter: "Object Oriented Programming in newLISP" explaining
+    newLISP object format and how to use the new : (colon) operator.
+
+9.2.7
+    changes in newLISP-GS to automatically detect and switch to UTF-8 mode, depending
+    on the newLISP executable. Edited chapter "17. Object-Oriented Programming in newLISP"
+    (thanks Michael Michaels)
+
+	In Guiserver 1.08:
+    new gs:window-moved and gs:window-resized. See new demo file move-resize-demo.lsp
+
+9.2.8
+	get-url, post-url, put-url and delete-url have been extended and reworked:
+
+    - now return extended error information if supplied by the server, before only 
+    the error cocd was reported.
+
+    - now can take a trailing "debug" in the option string, i.e."list debug" or 
+    "header debug" or simply "debug" when neither "list" or "header" applies. The 
+    debug option will print all outgoing info onto the console screen.
+
+    in some situations an empty document returned was reported as "ERR: empty document"
+    when ist was not an error but intended by the server.
+
+    in some situations customheaders were only taken when the option string was
+    present too. The manual showed the option-string optional, which it is.
+
+    the server response code 204 is now handled correctly
+   
+    when using a custom header "Content-type:" must be defined for put-url, before
+    "Content-type: text/html\r\n" was assumed. 
+
+9.2.9
+    last element speed optimization for 'last', 'nth', 'nth-set', 'set-nth' and
+    implicit indexing with index -1. 
+
+    'sort' can now be used on arrays too
+
+    changes in newLISP-GS for editor keyboard short cuts and list-boxes, see
+    guiserver/CHANGES file
+
+    the newlispdoc utility has improved pager headers and a feature to point to
+    other module collections from the index page.
+
+9.2.10
+    new functions to modify nested lists by reference via a key:
+
+    (set-ref (L key) value)
+    (ref-set (L key) value)
+    (set-ref-all (L key) value)
+
+    basically 'set-ref' and 'ref-aset' are shortcuts for doing a ref and
+    using set-nth/nth-set on the result:
+
+    (set-ref (L key) value)) equivalent to (set-nth (L (ref key L)) value)
+    (ref-set (L key) value)) equivalent to (nth-set (L (ref key L)) value)
+
+    all ref functions support either:
+           (<func> (L key) [...]) or (<func> key L [...]) 
+    syntax similar to nth functions working with indices instead of keys
+
+	like with 'set-nth' and 'nth-set' L can be the context of the default
+    functor L:L containing the list for passing lists by reference
+
+    all 8 'nth' and 'ref' functions together now constitute a complete set of
+    functions for indexing, referencing, accessing, modifying and search and
+    replace on nested lists. All 8 functions are also capable of receiving
+    lists passed by reference via context default functors, passed only by
+    their context name. All functions now offer the same two syntax patterns
+    with either one index and the key followed by the list:
+        (<function> <idx>|<key> <list> ...)
+    or the parethesized formi, which also can take contexts as default functors:
+        (<function> (<list> <idx>|<key>) ...)
+
+    on Win32 function 'directory?' now will accept training slahes '\' or '/'
+    before it would always fails on trailing slashes
+
+9.2.11
+   'ends-with' with regex options failed when alternative pattersn where used
+    and the succeeding pattern was last
+
+    fixed directory? for drives on Win32
+
+    define MY_RAND_MAX as 0x7FFFFFFF for TRU64 flavor
+
+    added mysql51.lsp module for MySQL v.5.1
+
+9.2.12
+    indices overshooting the list at the end (too big positive index) and
+    indices overshooting the list at the beginning (too big negative index)
+    now cause a "list index out of bounds" error. Before the last or
+    first element of a list was returned instead.
+
+    This affects the functions: nth, set-nth, nth-set, push and pop
+
+    If more indices are present than nesting levels, these are discarded as before.
+    Popping an empty list will return nil.
+
+    Fixed a stack overflow in the new 'set-ref-all'
+
+    Changes in the newlisp-edit.lsp GS editor, see guiserver/CHANGES
+
+    The environment variable NEWLISPDIR will only be created and set if it does
+    not exist. An exisiting definition of NEWLISPDIR will not be overwritten.
+
+9.2.13
+    a bug fix in set-nth, nth-set, ser-ref, ref-set (in getList() ) when first 
+    element in an implicit index parameter list evaluates to a context
+
+9.2.15
+    assoc, set-assoc (old replace-assoc) and new assoc-set all take mutiple keys
+    for multilevel association lists
+
+    fixed stack overflow in ref, set-ref, ref-set
+
+9.2.16
+    set-assoc and assoc-set redone, fixes for set-ref, ref-set, set-ref-all
+	newlisop_manual.html updates
+
+9.2.17
+    Fixes for 'set-assoc' and 'set-ref' when using the wrong syntax
+
+    new 'pop-assoc' for removing associations
+
+    'find' and 'ref' put their last found expression into $0 when used with a
+    cpmparison functor as parameter 
+
+    'find-all' has two additional syntax patterns
+
+    'process' now parses commands and args delimited by single or double quotes.
+    This is necessary when using file name or argumemnts containing spaces.
+    On Win32 do: (process {newlisp '"test prog.lsp"'}) 
+    On Unix do: (process {newlisp 'test prog.lsp'}) ; single or double quotes work
+
+    The octal format spcecifier (format "%o" 8) => "10" will work on many
+    platforms compilers. This is now documented and useful when inspecting
+    the mode number from the 'file-info' function.
+
+9.3.0 prerelease January 28th, 2008
+    fix in 'sys-info' for some 64-bit compilations, and other int -> size_t
+
+    reset -w base directory after http requests, this is important in -c mode
+    when both, http and net-eval requests may come in, so that http requests
+    cannot change the current directory of the server for net-eval requests
+
+9.3.0 final release February 1st, 2008
+    a fix for newlisp server mode when using IE explorer on Win32
+
+    documentation changes
+
+9.3.1
+    doc changes
+
+    fixes for guiserver v.115 (see guiserver/CHANGES)
+
+    fixed error message for unclosed curl brace
+
+	'pop-assoc' should not set $0 as do 'set-assoc', 'assoc-set' 
+
+	: colon operator should not evaluate args after the object
+
+	new 'read' exposes the internal source code reader. 'read' can be used to 
+	write preprocessor for newLISP source or specialized newLISP editors and 
+	evaluators. When using 'read' in string mode, comments are preserved.
+
+	'read' takes as argument a source string, a callback function and an optional 
+	context.  The callback function is called with each expression as either a string 
+	including comments or an expression if the context argument is present. 
+	When a context argument is present the source gets compiled in the namespace
+	specified by the context, except when overwritten by context statements in
+	the source. The string mode (no context is specified) still will check
+	the source if it is well formed, with balanced parenthesis and quotes and
+	interrupt processing with an error messages, if finding mal-formed s-expressions.
+
+	'read' returns the last return value of the callback function.
+
+	syntax: (read <str-source> <functor-callback> [<context>])
+
+	example:
+		(define (crunch sx) (println "=>" sx))
+
+		(set 'code "; a statement\n(+ 3 4)\n(define (double x) (+ x x))")
+
+		> (read code crunch)
+		=>; a statement
+		(+ 3 4)
+		=>
+		(define (double x) (+ x x))
+		"\n(define (double x) (+ x x))"
+		> 
+
+	Note, that string mode conserves orignal formatting in the expression and 
+	leading comments returned. 
+ 
+	Following a context is specified forcing 'read' to return compiled expressions:
+
+		> (read code crunch MAIN)
+		=>(+ 3 4)
+		=>(define (double x) 
+ 		(+ x x))
+		(define (double x) 
+ 		(+ x x))
+		> 
+	
+	'read' is renamed to 'read-expr' in 9.3.4
+
+9.3.2
+    new compile flavor for IPv6 with the following makefiles:
+      makefile_darwin_utf8_IPv6
+      makefile_linux_IPv6
+      makefile_bsd_IPv6
+
+    elimnate quirky symbol syntax in 'net-send'
+
+    functions called by dynamic symbols now switch to the dynamic
+    context:
+        (define (foo:foo) (context))
+        (set 'ctx foo)
+        (ctx) => foo
+        (ctx:foo) => foo ; previously MAIN
+
+    changed report format in 'net-ping' now includes roundtrip time in 
+    micro-seconds
+
+9.3.3
+    fixed display of signon banner, which made newlisp-tk.tcl not work. Also, in order
+    to make newlisp-tk.tcl work on 9.3.0 and after, the line in newlisp-tk.tcl:
+		(net-send SYS:tk-sock 'result)
+	should be changed
+		(net-send SYS:tk-sock result)	
+
+    in the runtk.lsp utility (see http://www.newlisp.org/index.cgi?page=Tk_and_newLISP)
+    the line: 
+		(process "wish" tcin tcout)
+	changed to:
+		(process "/usr/bin/wish" tcin tcout)
+	to make it work on v9.3.0 and after
+
+    'search' has a new flag parameter to put the filepointer after the search to either
+     the beginnig (nil) or the end (true) of the searched string.
+
+    added <hr> as a legal tag in v.1.5 newlispdoc formatted documentation 
+
+    'xml-parse' crashed when not passing a valid symbol or context
+
+    extra boolean flag in 'bind' forces evaluation of bound parameters:
+
+    (bind assocList true) same as: (apply set (flat assocList))
+    this enables an efficient way to define functions with names parameters:
+
+        (define-macro (foo)
+	      (local (len width height)
+		  (bind (args) true)
+		  (println "len: " len " width:" width " height:" height)
+	    ))
+
+        (foo (width 20) (height (+ 5 25)) (len 10))
+
+      outputs -> len: 10 width:20 height:30
+
+    a fix for 'expand' when expanding upper-case characters, now limited to 65->90
+    to prevent expansion of symbols starting with special characters
+
+    took out the 'read' from 9.3.1. Just couldn't see the benefit of it. Everything
+    which can be done with it can be done by redefining 'define', or create other
+    special def- functions which transform top-level expressions.
+
+    'env' now removes an enviroment variable when setting it to an empty string
+    except when on Solaris, where it stays as an empty string.
+    (env "VAR" "value") (env "VAR") => "value" (env "VAR" "") (env "VAR") => nil
+    On Solaris (env "VAR") = "". 
+    For a platform independent check use (null? (env "VAR"))
+
+    fixed a memory leak on Win32 and Solaris when repeatedly setting the same 
+    environment variable
+
+    9.3.2 did not compile on Solaris, 9.3.3 now does
+
+9.3.4
+   creating dictionaries (hashes in other languages) got faster and shorter:
+   the default symbol if it contains nil works like a hash function creating
+   and setting the symbol made from the string following it:
+
+      (define Foo:Foo) ; create namespace and default functor
+
+      (Foo "bar" 123)
+      (Foo "bar") => 123 
+
+   'read' which was introduced in 9.3.1 but taken out in 9.3.3, has been put
+   back as 'read-expr' and documented. The critical advantage over using
+   eval-string on quoted strings is, theat read-epr is reading only one expr
+   at a time and its ability to return comments when returning strings
+
+   a fix when serializing illegal symbols with (save (sym <str> <context>) ...) 
+   forcing the <context> to be written with MAIN prefix, also: overwrites of 
+   'set' and 'sym' will not be saved, as they make it impossible to load 
+   serialized contexts.
+
+   newlispddoc now does create HTML files without CSS style definitions but HTML
+   files try to to read newlispdoc.css from the same directory and load it, if
+   they find one.  A sample newlispdoc.css with the usual style definitions can 
+   be found in newlisp-9.3.4/util/newlispdoc.css
+
+   (sys-info -3) is now the current process id (pid). This pid can be usedd to
+   'destroy' (kill) the process on MAc OS X and other UNIX. On Windows the pid
+   returned seems to have a different meaning and does not respond to destroy.
+   The Win32 SDK function GetCurrentProcessId() is used by newLISP internally to 
+   get the pid.
+
+9.3.5
+   Internally when using contexts as hashes, now an unserscore "_" is
+   automaically prepended. This eliminates the danger of overwriting
+   the default symbol or overwwriting 'set' or 'sym' in the namespace.
+   This way hash namespaces can be saves and loaded without taking precautions.
+
+   This is transparent to the user and the inetface has not changed:
+
+      (define Foo:Foo) ; create namespace and default functor
+      (Foo "bar" 123)
+      (Foo "bar") => 123 
+
+   an association list can be passed to create a series of association hashes:
+
+      (Foo '(("var" 123) ("bar" 456) ("baz" 789))) ; create hashes from a batch
+
+      (Foo "var") => 123 ; (foo "bar") => 456 ; (foo "baz") => 789
+
+   without any parameter the context is converted to an association list
+
+      (Foo) => (("bar" 456) ("baz" 789) ("var" 123))
+
+   internally symbols are created with a prepended underscore
+
+      (symbols Foo)
+      (Foo:Foo Foo:_bar Foo:_baz Foo:_var)
+
+   'start-with', 'ends-with'  and 'sym' now accept a quoted 'nil like other functions
+   taking flags
+
+   New 'regex-comp' allows to precompile patterns for all functions which take
+   regular expression patterns. newLISP already caches the last compiled pattern,
+   but 'regex-comp' is useful in case where repeated patterns alternate and the
+   single cache never gets reused.
+
+     (regex-comp <str-pattern> [<int-options>]) => compiled pattern
+
+   When using a regular expression function the compiled pattern gets passed
+   with the special option 0x10000, all other options are already contained in
+   the compiled pattern.
+
+     (set 'cp (regex-comp pattern))
+     (replace cp thetext replacement 0x10000)
+
+   Note that the option 0x8000 for replace once, cannot be compiled into the
+   pattern, but can be given together with 0x10000 as: 0x18000
+  
+   fixed a bug for invalid (<list> <key>) syntax
+
+9.3.6
+   smtp.lsp now can take user-name and password parameters for authorization
+
+   The behavior of 'wait-pid' has changed for finer control of child processes:
+
+   If nil is specified instead of the options number in 'wait-pid' then 'wait-pid'
+   will not block (WNOHANG option) and return 0 in the pid field of the return list,
+   if no childs exited, or -1 if no child processes are present, else the pid
+   ands status value of the signalling child are returned in a list. Previous
+   versions returned only the status value;
+
+   Using 'wait-pid' now causes the the SIGCHLD handler be set to the
+   default signal handler (SIG_DFL) of the OS as if (signal 20 true) has been
+   executed. This way 'wait-pid' can return pid values when handling child signals
+   On startup of newLISP the SIGCHLD handler is set to waitpipd(-1, 0, WNOHANG) 
+   to avoid zombie processes when 'wait-pid' is not used for processes created
+   with fork or process.
+
+   added error message to 'error-event', 'signal' and 'timer' when handler parameter
+   supplied is not a symbol, lambda function or primitive
+
+   fixed an error in new namespace hash functionality when evaulating the value
+   expression
+
+   'lookup' can take an optional default expression, which is returned when the
+   association is not found: (looup <key> <assoc-list> [<index>] [<default>])
+
+   Various smaller speed ond code size optimizations introducing makeCell() helper
+   function and inlining getCell() into various functions
+
+9.3.7
+   Cilk interface: 'spawn', 'sync' and 'abort'. See qa-cilk for workings.
+   Only available on Mac OS X and other UNIX like operating systems.
+   This API makes it easy to spawn child processes and collect results. 
+   The API can be used recursively and automizes housekeeping and zombie
+   collection of finished processes.
+
+   'spawn' forks a process and  passes a symbol for the result. 
+   A 'sync' function waits for a max timeout on all processes and assigns the 
+   results to the symbols spawned by 'spawn'. 'abort' can abort a specific or
+   processes. 'spawn' can be used recursively, so spawned child processes can
+   in turn spawn other children. newLISP uses shared memory to pass data up
+   to 4096 bytes or whatever the pageszie on the platform running. For data sizes
+   bigger than the pagesize newLISP automatically switches to a file based
+   data transfer using temporary files in /tmp/, where newLISP needs full
+   permissions to create, read, write and delete files.
+
+   SYNTAX:
+
+   (spawn <quoted-symbol> <function>) ; spawns the child process
+   returns the pid of the forked process
+
+   (sync <int-timeout>) ; waits for result up to milliseconds specified
+   returns 'nil' on timeout, or 'true' if all childs have finished. If
+   there are still pending childs 'sync' with a timeout parameter can
+   be called again.
+
+   (sync) ; only returns a list of pending child processes or an empty
+   list if nothing is pending. Does not do any other child processing.
+
+   (abort <int-pid>) ; aborts a specific child process and returns 'true'
+   (abort) ; aborts all child processes and returns 'true'
+
+   EXAMPLE:
+
+       (spawn 'x (foo-x a b c)) ; start first child
+       (spawn 'y (foo-y d e f)) ; start second child
+       (sync 10000) ; wait a maximum of 10 seconds and collect results
+       (println "x=" x " y=" y) ; print results
+
+   for more examples and a recursive application woth fibonacci see the
+   file newlisp-9.3.7/qa-cilk
+
+   For the original Cilk project (C-library API) see here:
+   http://supertech.csail.mit.edu/cilk/
+
+9.3.8
+	Cilk API in WIN32 now simulates behaviour in UNIX. 'spawn' works
+    like 'set', 'sync' always returns an empty list and 'abort' always
+    returns 'true'. This way Cilk API code written for UNIX will also 
+    run in WIN32, albeit slower.
+    
+    bugfixes and improvments in Guiserver for newlis-edit.lsp, see changes 
+    file for newLISP-GS.
+
+    added implicit indexing specific error messages.
+
+    'file-info' can be indexed (was not in docs)
+
+    second syntax in 'destroy' lets send any signal to UNIX process
+    (was not in docs)
+
+9.3.9
+    'spawn' allowed usage of protected symbols
+
+    errors in child processes launched by 'spawn' are now automatically
+    catched and returned as a result string, before control was lost
+    and child processes could not be 'sync'ed
+
+    some refactoring/streamlining in error handling code
+
+9.3.10
+	now the default functor as a container for lists or strings can be
+    used for any built-in function asking for a string or list. Until
+    now only functons of the special form (... (L idx) ...) could use:
+        (nth-set (L idx) value) when L:L => '(a b c d)
+    now any function can take lists or strings packaged this way:
+        (pop L) => a
+    or with strings:
+        (set 'S:S "abcdefg") (upper-case S) => "ABCDEFG"
+    This means that any user defined function when given a list or string
+    packed with a default functor will pass this list or string by reference
+    to any built-in function.
+
+    (char "") will return nil, caused out of range error message before,
+    'nil' more practical because one can switch on it: (if (char str) ...)
+
+    char, get-char, get-int, get-float, get-string now give an error for
+    missing parameter
+
+    server mode with -c or -http now disables commandline shell feature
+    with ! at the beginning of the commandline
+
+9.3.11
+    (last S), (first S) and (rest S) did not work  when S is a default 
+	functor S:S with a list or string.
+	
+    Fixed push when pushing at -1 on a sublist with one element
+
+	Fixed error messages text in list indexing area
+
+    Added out of bound error messages for 'swap'
+
+    Sortorder in manual should be as in (symbols) except for number ops.
+    Fixed many small HTML formatting inconsistencies in the manual. This
+    facilitates parseing out syntax lines for autimatic help functions.
+
+    'net-eval' now returns the error string if the remote server task ended
+    with error. Before the server would first time out then return 'nil'.
+    The new behaviour gives the choice of handling errors on the client
+    side and wihtout ewaiting for timeout.
+
+    New 'prompt-event' can redefine the interactive prompt with a newLISP
+    routine, e.g: 
+
+        (prompt-event (fn () (append (real-path) "$ ")))
+
+    changes the prompt to a UNIX shell-like prompt. See manual for more
+    details.
+
+    New 'command-event' can specify a function written in newLISP to pre-process
+    the newLISP command line and newLISP server mode requests before they are
+    evaluated. This can be used to write customized newLISP shells, and to
+    filter or trasform HTTP requests when running in server mode. 
+
+        (command-event 
+            (fn (s) (if (starts-with s "[a-zA-Z]" 0) (append "!" s) s)))
+
+	UNIX commands are passed to the shell via the ! operator. Lines starting
+    with a parenthesis or space are passed to the newLISP interpretor.
+    See the manual reference for 'command-event' with more examples and
+    how to write a preprocessor for HTTP requests. This new function obsolotes
+    the old 'command-line' and old way of writing 'httpd-conf.lsp' files.
+
+9.3.12
+    'series' can take lambda expression instead of number factor:
+		(series p (fn (x) (div 1 (add 1 x))) 20) => converges to Phi for any p != 0
+
+    synchronization in the Cilk multiprocessing interface can now be event driven
+    by defining a function instead of a timeout in 'sync'
+
+    Bugfixes in newlisp-edit.lsp for newLISP-GS
+
+    cleanup in nl-debug.c
+
+    restore SIGCHLD behavior after Cilk to newLISP startup conditions
+
+    using 'constant' or creating contexts on local symbols is not permitted
+    and causes an error message in: lambda, lambda-macro, ley, letn, letex, local
+
+    fixed a memory leak in net-receive-udp
+
+9.3.13
+    Better distribution with new Knuth algorithm for 'randomize'.
+
+    Several bug-fixes in newlisp-edit.lsp for newLISP-GS and new functions.
+
+9.3.14
+	New functions for MIDI sequencing several tracks/channels in parallel. 
+    See the new demo files midi-demo.lsp and  midi2-demo.lsp.
+
+9.3.15
+  Non-default directory install on Win32 now works. Windows must be rebooted
+  when not accepting the default directory, so the different path set in
+  the environment variable NEWLISPDIR can come into effect.
+
+  In newLISP-GS loading of external soundbanks and saving of sequences to
+  MIDI files and channel pitch bending. See newLISP-GS changes notes for details.
+
+  Added reference passing to some missing functions.
+
+  Cilk API for 'sync' changed handling the inlet function as an optional second
+  parameter.
+
+9.3.16
+  bug fixes in p_randomize and p_rand
+
+9.3.17
+  big speedup when deleting the entire contents of a namespace at once using
+  (delete <context-symbol>)
+
+9.4.0 release July 1st, 2008
+  eliminate mysql.lsp v.4.0 from the distribution
+
+  fixed an error in MySQL:escape in mysql5.lsp, mysql51.lsp (thanks Tim Johnson)
+
+  added newlisp.jsf (syntax highlighting for joe editor) and nanorc (syntax high-
+  lighting for the GNU nano editor) to the util directory
+
+  in module cgi.lsp CGI:url-translate did not translate correctly when taking a 
+  url-encoded UTF-8 strings as input and running UTF-8 enabled newLISP. The new 
+  version 2.3 does the translation correctly on  UTF-8 and non-UTF-8 url-encoded 
+  strings and on both versions of newLISP.
+
+9.4.1 release July 6th, 2008
+  Filled some gaps in namespace reference passing and fixed memory leaks in the
+  matrix API and 'count' function (on Unix). Passes the Valgrind memory check with 
+  0 bytes lost memory! 
+  
+  In parse-date the default day offset has been changed to more sensible 1 (was 0).
+  
+9.4.2
+  fixed a bug in the hash functionality when doing self-referential expressions:
+  (define foo:foo) (foo "x" 0) (foo "x" (+ 1 (foo "x"))) ; now works
+
+  don't allow 3rd semicolon in newlispdoc documentation line (for Emacs)
+  
+  fixes in guiserver
+  
+9.4.3 July 13 2008
+  cleanup -h help message
+  
+9.4.4
+  fixed reentrance bug in format
+ 
+  fixed compilation as Unix library
+
+  fixed $args losing protection under error conditions
+
+  updated gmp.lsp module documentation and library load locations
+  
+  new 'if-not' works like current 'unless' which will loose the else-clause
+  in a future version to work like a (when (not ... ) ..)
+  
+  'inc' and 'dec' on a variable containing 'nil' assumes 0 contents, this
+  makes initialization of variables used in 'inc' and 'dec' un-necessary,
+  but is also compatible with existing code
+
+  additionally to doargs, dolist, dostring, dotree now all other non-counting
+  iterators: map, while, until, do-while, do-until upate the internal $idx symbol, 
+  e.g: (map (fn (x) (list $idx x)) '(a b c)) => ((0 a) (1 b) (2 c))
+    
+  eliminated deprecated (in 9.3) replace-assoc, use set-assoc and pop-assoc 
+  instead
+  
+9.4.5 release August 5th, 2008
+  cleanup in define constant, define, set, setq  assignment group of functions, 
+  'constant' should not return a reference as the others in the group.
+
+9.4.6
+  a fix for 'xml-type-tags' parameter passing
+    
+  desktop shortcut in Windows install no optional 
+
+  fixed copy-paste bug in monitor area in newLISP-GS
+  
+9.4.7
+  Eliminated dependence on stack-size in 'find-all' when using the functor
+  parameter. Gathering large lists with 'find-all' will not affect the stack.
+  
+  unify took some special, non-alpha characters as variables
+  
+9.4.8 development release Sept 1st, 2008
+  Small speedup in environment, result and lambda stack management and symbol 
+  access
+  
+  tags in 'xml-type-tags' are now reset to the default on un-caught error 
+  conditions which cause a reset.
+  
+  code cleanup in share
+  
+  key-handling improvements in the monitor-shell area in newLISP-GS
+  
+  
+;;;;;;;;;;;;;;;;
+
+9.9.1 and 9.9.2 towards newLISP v10.0
+
+ - Reference returns
+ - Other changes
+ - Short conversion guide
+
+  Reference returns
+  =================
+
+  Any built-in function returning a list or an array or a listelelent or array
+  element, will return a reference and not a copy if the list or array is bound
+  to a symbol. This make it possible to work on with destructive function on
+  on the return value of other function modifying the original list or array:
+    
+      (set 'lst '(a b c))
+      (setf (first lst) 99)
+      lst => (99 b c)
+  
+      (setf (lst -1) 'C)
+      lst => (99 b C)
+  
+      (set 'A '((a 1) (b 2) (c 3)))
+      (push 'z (assoc 'c A))
+      A => ((a 1) (b 2) (z c 3))
+      
+      (set 'L '(a b (c d e f g)))
+      (= (replace 'f (nth (+ 1 1) L) 'z) '(c d e z g))
+      (= L '(a b (c d e z g)))
+                                
+  		... and similar with many other functions ...
+  
+  The following functions now return a reference to the list, array or string
+  or element of a list or array, which can be modified by other functions. 
+  Previously a copy was returned:
+  
+      'assoc'
+      'first'
+      'last'
+      'lookup'
+      'ntn'
+      'replace'
+      'reverse'
+      'rotate'
+      'set'  (returned reference already)
+      'setf' (new function)
+      'setq' (old function now working like setf)
+      'set-ref'
+      'set-ref-all'
+      'sort'
+      'swap'
+
+
+  'setf' is a new introduced function working not only on symbol references like 'setq'
+   but also on any other reference returned from an expression. 'setq' now works like
+  'setf' and both point to the same internal code and are interchangeable. It is 
+  recommended to use 'setq' for setting symbol variables and use 'setf' whenever a sublist 
+  or subarray is referenced, this follows usage in other LISPs:
+
+      (setq l '(a b c d e f))
+      (setf (first l) 99)
+      (setf (last l) 9900)
+      (setf (nth 3 l) 'Z)
+      (setf (l 3) 'z)
+      l => (99 b c z e 9900)
+      
+      (setq l '((a 1) (b 2) (c 3)))
+      (setf (assoc 'b l) '(b 20))
+      l => ((a 1) (b 20) (c 3))
+  
+  The changes make many of the involved functions faster. It also obsoletes the functions 
+  'set-assoc', 'assoc-set', 'set-nth 'nth-set', 'ref-set'. As these function don't occur 
+  much in average newLISP, source changes necessary in existing code are minimal.
+
+  In 55 lisp source files shipped with newLISP only 3 files needed minor changes:
+
+      modules/stat.lsp /modules/xmlrpc-client.lsp guiserver/newlisp-edit.lsp
+  
+  the parenthesized syntax for assoc, nth, ref, set-ref and set-ref-all
+  has been eliminated. Only the traditional flat syntax is allowed. When multiple 
+  indices or keys are used a list is specified instead of a single index or key:
+  
+      (nth i myList)
+      (nth idxList myList)
+      (assoc key aList)
+      (assoc list-of-keys aList)
+      ....
+  
+  Index list vectors are the same as returned by 'ref' and 'ref-all'. Index vectors 
+  have been supported with 'pop' and 'push' for several years. as befor index vectors 
+  tie together 'nth', 'ref', 'ref-all', 'push' and 'pop' Using index vectors in the
+  (only) flat syntax of 'nth', give 'nth' a uniform arity regardless of the number
+  of indices involved.
+  
+  In the 9.x.x series of newLISP support of the parenthesized syntax was inconsistent 
+  and lead to ambiguities when using expression for the key in the 'ref' family of 
+  functons. Parentheses in this syntax where similar to to parentheses in looping forms
+  like (dotimes (x N) ..) etc.. Because they where part of the syntax and not part
+  of the normal s-expression these forms where not suitable for 'apply', 'curry' and 'map'.
+  In the functions 'ref' and 'ref-all' they createted ambiguities when reading sourc
+  about what syntax was used the flat or the parenthesised form.
+  
+  Now the flat syntax is consistenly the only syntax supported. Multiple indices are 
+  espressed as lists (index vetors).
+
+  No changes to implicit indexing, which is conveniently used now when using setf:
+  
+      (set 'l '(a b c d e f))
+      (setf (nth 3 l) 'Z) ; explicit
+      (setf (l 3) 'z) ; implicit and fastest
+
+  Other changes
+  =============
+
+  'unless' is reintroduced working like (when (not ...) ...) with no else clause
+
+  'lookup' now can take multiple keys like to 'assoc'
+  
+  All control structures without local variables maintain reference for last return
+  value if that value is tied directly or indirectly to a symbol:
+  'begin' 'if', 'if-not', 'when', 'unless', 'while', 'until', 'do-while', 'do-until', 
+  'cond' and 'case'. 'begin' cannot be used anymore to make a copy of an expression,
+  use a lambda function instead: (define (copy x) x)
+      
+  the initialization file in either $HOME/.init.lsp or $USERPROFILE/.init.lsp or 
+  $DOCUMENT_ROOT/.init is loaded if it exists, else if $NEWLISPDIR/init.lsp exists,
+  it is loaded
+    
+  'set' and 'setq' will not allow a missing value argument as was possible before
+    
+  ("" 0) and ("" -1) will return "". Before ("" 1) also returned "", now will give 
+  out-of-bounds error
+
+  added "text/css" and "application/javascript" media types for -http mode
+
+  'eval-string' has dropped the optional error-handler parameter, use 'catch' instead
+  (reintroduced in 9.9.4)
+
+  'read-expr' redone, simplified, more useful:
+        (read-expr <str-expr> [<context>]) => expr
+  basically works like 'eval-string' but doesn't evaluate the expression it compiles
+  length of string parsed is in $0
+    
+  'net-eval' internal cleanup, now uses sysEvalString() like 'spawn'
+
+   Short conversion guide
+   ======================
+   
+   This is a summary of changes necessary to pre 9.9.2 lisp source code to make it 
+   run under 9.9.2 and versions after:
+   
+   - 'unless' - the new version of this function does not have an else-clause but 
+   works like: (when (not ...) ...). If old code contains 'unless' with else-clause,
+   rename it to 'if-not'
+   
+   - 'set-nth', 'nth-set', 'set-assoc', 'assoc-set' all have to be relaced by a 
+   combination of the new 'setf' and 'nth' or 'assoc, e.g:
+   
+       (nth-set (lst idx) value)  => change to => (setf (lst idx) value)
+       (set-assoc (aList key) value) => change to => (setf (assoc key aList) value
+   
+   - Multitple indices in 'nth' have to be put in a list and in flat syntax:
+   
+       (nth i j k aList) => change to => (nth (list i j k) aList)
+      
+   - 'eval-string' and 'read-expr' lost the error handler parameter, use 'catch' instead to 
+   capture and handle errors.
+     
+   - Nested expressions of built-in destructive functions must not rely on functions
+   returning a copy. E.g. in previous versions (pop (sort myList)), myList was sorted
+   but the 'pop' of the first element happened on a copy:
+       (set 'myList '(b d c a))
+       
+       ; in 9.4.5
+       (pop (sort myList))
+       myList => (a b c d) 
+   
+       ; in 9.9.2 and later
+       (pop (sort myList))
+       myList => (b c d)
+       
+    The new behavior leads to faster and more efficiently coded programs. It is also, 
+    what many newcomers to newLISP coming from other programming languages would 
+    expect intuitively.
+
+    - a 'set-nth' or 'nth-set' used on strings must be replaced with either a 
+    combination of 'push' and 'pop' when working on utf-8 or ascii content or 
+    combination of 'append' 'slice' when working on ascii or binary content. 
+    Note that 'push' and 'pop' both can handle more than one character at once.
+    
+9.9.3 and 9.9.4
+    Some default functor handling was broken, giving errorneous protection messages
+    and bad results on contexts in 'setf'
+    
+    'apply' now honors ref-returns: 
+        (push 99 (apply set '(var ())))
+        var => (99)
+        
+    Fixed context-symbol <-> context comparison to make assoc in FOOP more 
+    flexible (may be quoted or unquoted in FOOP)
+    
+    Fixed a stack overflow in eval-string (bug introduced in 9.4.8)
+    
+    Anaphoric $it in all functions, which can do self referential expression evaluation
+    like: 'setf', hashes, 'replace', 'set-ref', 'set-ref-all', 'find-all'
+    
+       (setf (l idx) (+ $it 1)) ; increments value
+       (setf (str idx) (upper-case $it)) ; upper-cases a letter in a string
+       (MyHash "var" (upper-case $it)) ; uppercases string in hash value
+       
+    Note that the anaphoric $it is not reentrant (neither are $0 - $15) and
+    will forget its value after exiting the expression (unlike $0 - $15).
+    The functions 'replace', 'set-ref', 'set-ref-all' and 'find-all' use both $0 
+    and $it for the same value. 'setf' and hashes use only $it.  
+        
+    Error procedure in 'eval-string' and 'read-expr' returned as last parameter.
+    Context and error procedure parameter are swapped compared to 9.4.x series
+    this way the error procedure doesn't need to be specified when using context
+    spec. Before a nil had to begiven to suppress error-handler.
+    
+    A few more MIME media types have been added: css, js, avi, wav, zip. 
+    See Users Manual.
+
+    'env' without any parameters now returns an association list, not a list of
+    flat strings as before:
+        (env) => ( ("TERM" "xterm-color") ... ("SHLVL" "1") ...) 
+    This way 'env' simulates hash syntax in all aspects. To generate the old-type
+    environmnt list use (exec "env") which returns a list of environment strings
+    of the form "key=value".
+          
+    'setf' working on indexed string references:
+    
+    	(setf (nth idx str) newStr) 
+    	(setf (str idx) newStr) ; faster
+    	(setf (last str) newStr)
+    	(setf (first str) newStr)
+        (setf (last s) (dup $it))
+    	
+     All will change the original string in s and return newStr. All can also work on
+     string returns of other built-in functions, i.e:
+     
+        (set 's "a-b-c-d-e-f-g")
+        (setf (first (replace "-" s "")) (upper-case $it))
+        s => "Abcdefg"  
+      
+     translate old: (set-nth (s idx) value)  ; same for nth-set
+     into: (setf (s idx) value)
+
+9.9.5
+    'push' now returns a reference to the changed list instead of the pushed element.
+    Now both combinations: (push (pop ...) ...) and now: (pop (push ..) ...)
+    are possible. Previously this was avoided, to avoid copying the list, which now 
+    is returned by reference, without the need to copy it. In the following  exampple 
+    a (pop (push ...)...) combination is used to model a left-moving queue in one 
+    statement:
+
+       (set 'L '(a b c d e))
+       (pop (push 'f L -1)) => a
+       L => '(b c d e f)
+       (pop (push 'g L -1)) => b
+       L => '(c d e f g)
+       
+    No code has changed in any of the modules or applications shipped with
+    newLISP but in many places the code could be written shorter and faster
+    executing as a consequence of this change.
+    
+    System variables $0 - $15, $args, $idx, $it and $main-args are now documented
+    in the appendix for the "Users Manual and Reference".
+    
+    Corrected sort-order in the reference section of the manual.
+    
+    Changed enhnaced 10.0 release notes
+    
+    'copy' makes a destructive function non-destructive: 
+        (replace x (copy theList) y) ; leaves theList untouched
+        
+    newLISP-GS editor fixes
+
+9.9.6
+    'amb' now has reference return too
+
+	Fixes in 'env' and NEWLISPDIR detection for SOLARIS OS
+
+    Doc changes
+
+    New 'net-interface' allows selecting a default network interface card on
+    multihoned network nodes. In previous versions only net-listen could
+    specify a specific interface IP address, now a different interface card can also
+    be selected for outgoing communications by changing the default IP-address.
+    
+    
+9.9.7
+    protection error was not traceable in 'swap' symbols
+    
+    a fix for 'local' when using setf/setq on uninitialized symbols
+
+    replaced all evalChekSymbol with getDefaultOrEval
+    
+    doc changes
+       
+9.9.8
+    fixed the reduce parameter in 'apply'
+   
+9.9.9
+    swapped parameters in 'write-line' syntax with device parameter coming first
+    as in 'write-buffer', 'write-char', etc. The return value is now the number 
+    of characters written as in 'write-buffer'. This made changes necessary in 
+    the following files:
+	   examples/sqlite.cgi
+       examples/tcltk.lsp
+       examples/upload.cgi
+       modules/postsrcipt.lsp
+       modules/stat.lsp
+       util/newlispdoc
+       util/syntax.lsp
+
+    (first '()) and (last '()) now throw error as in Scheme. Before 'nil' was
+    returned as in other LISPs. The change makes more sense in the new v.10.0 
+    of newLISP, where 'first' and 'last' can return a place changed by 'setf':
+       (set 'l '(a b c)) 
+       (setf (first l) 9) 
+       (setf (last l) 99)
+       l => (9 b 99)
+    Leaving the old behavior would ill-define 'setf', because their would be
+    no place to change. The change also avoids the ambiguity of (first '(nil))
+    Thanks to the community for comments on this topic!
+
+	'set-locale' now returns the locale name and the decimal point character in
+    a list. Previously only the locale string was returned. This makes it easier
+    to write locale independent code containing decimal number constants.
+
+    'file-info' now can take an extra flag to report on the original instead
+    of the link, when the node is a link.
+
+	'integer' (removed from docs a long time ago) now eliminated. Use 'int'.
+
+    Eliminated odd symbol syntax in write-buffer, no changes where necessary
+    in shipped files, as the symbols was never quoted.
+
+    Code Patterns and Users Manual Reference changes.
+
+9.9.91
+    The system variable $status-header can be set to a different string.  Currently 
+    "HTTP/1.0 200 OK\r\n" is the fixed response. As an example for a no response 
+    header you would specify:
+        (set '$status-header "HTTP/1.0 204 No Response\r\n")
+    and then exit the cgi program without outputting any content.
+
+    'read-buffer' and 'net-receive' both loose the quote before the buffer
+    symbol. Now a context symbol for a default functor can be passed when writing 
+    user-defined fuctions where the the buffer can be passed in/out by reference. 
+    The change in 'read-buffer' and 'net-receive' requires taking away the quote
+    from the buffer symbol in the following files:
+        modules/ftp.lsp
+        examples/client
+        examples/finger
+        examples/server
+        examples/udp-client.lsp
+        examples/udp-server.lsp
+        examples/upload.cgi
+
+    set and inc/dec are now the only built-in functions where a quote is required before 
+    a symbol. Correct quoting is one of the difficulties new-comers to Lisp have.
+
+    In the Reference Manual all destructive functions are marked with an excla-
+    mation mark "!" which links to the relevant Users Manual chapter.
+    All functions with special behavior on UTF-8 strings are marked as "utf8" 
+    and linked to the relevant Users Manual section.
+
+9.9.92
+    'inc' and 'dec' now don't quote the symbol and also can increment or decrement
+    a place in a list structure or an unreferenced (unlike setf) number:
+
+     (inc x) => 1   ; if x is nil initially 0 is assumed (as before)
+     (inc x) => 2
+     (set 'l '(1 2 3 4))
+     (inc (l 1)) => 3
+	 (dec (nth 0 l) 2) => -1
+     (dec (last l) 0.1) = 3.9
+     (inc (+ 3 4)) => 8
+     l => (-1 3 3 3.9)
+
+    as before nil is taken as 0 before inc/dec and floats are returned whenever
+    the amount is specified else assumes 1 for amount and returns integers
+
+    The status header feature introduced in 9.9.91 has been reworked and is
+    simpler to use now. Whenever the first line output by an CGI program starts
+    with "HTTP/", newLISP server mode will suppress putting out the standard
+    status "HTTP/1.0 200 Ok" line and "Server: newLISP ..." line. Instead
+    *all* header information must be supplied by the CGI program. The following
+    example would redirect a request to a different URL:
+
+        #!/usr/bin/newlisp
+	    (print "HTTP/1.0 301 Moved Permanently\r\n")
+        (print "Location: http://www.newlisp.org/index.cgi\r\n\r\n")
+	    (exit)
+
+    works on OSX 10.5 and Safari browser
+
+9.9.93
+    When answering HTTP requests, newLISP server mode sets the environment
+    variable SERVER_SOFTWARE to "newLISP/n.n.n" where n.n.n is the version 
+    number. This is used to write server independent CGI programs. The same
+    environment variable is also written by the Apache and Microsoft-IIS web 
+    servers.
+
+    Updated versions newlisp-ide-4.2.tgz and newlisp-wiki-4.3.tgz for 10.0.
+
+    The library newlisp.dll or newlisp.so will look for the environment variable 
+    NEWLISPLIB_INIT and load the file specified there instead of looking for 
+    HOME/.init.lsp or NEWLISPDIR/init.lsp. NEWLISPLIB_INIT must contain the full 
+    path/file-name of the file to be loaded.
+
+	'write-line' with just one argument will still take that argument as a 
+    either a file or string device to write too and write the string found
+    in 'current-line'. The previous (9.4.5) behaviour of writing that string to
+    the console is a historic relic when there was no 'println'. So the first
+    argument is always the device to write too.
+
+    Fixed error behavior for 'inc', 'dec'. 
+
+    Many manual corrections
+
+9.9.94
+    suppress loading of any init.lsp or .init.lsp using -n as the first 
+    command line option, i.e.: newlisp -n
+
+    fixed a bug in replace when key cell is self referential
+
+    corrections in accompanying files
+
+    Users Manual corrections
+
+    CodePatterns.html corrections, separate chapter about HTTP mode.
+
+    Experimental 'estack' with variable environment history.
+
+9.9.95
+    No NEWLISPDIR/init.lsp or HOME/.init.lsp will be loaded by a newlisp.dll
+    or newlisp.so shared library module. Only if NEWLISPLIB_INIT is defined
+    the full path-name contained in it is loaded, else nothing is loaded.
+
+    file:// urls now allowed on 'get-url', 'put-url' and 'delete-url'. Was documented
+    already for 'get-url' but never implemented. 
+
+    file:// url was missing for 'delete-file'.
+
+    'save' now throws error when using http:// url just like w/o url mode. Before
+    the HTTP error message was returned. This allows writing error
+    handlers working equally on all modes specifying the file-path in 'save'
+    and 'load'.
+
+	fixed a crash bug when deleting a symbols containing the context of the symbol
+    to be deleted.  Strickter syntax now for 'delete', when deleting contexts, the
+    symbol of the context must be given, not the evaluated context:
+        (delete Ctx) => must now be =>  (delete 'Ctx)
+
+    in newLISP console now keyword completion when hitting TAB once/twice for newLISP
+    built-in primitives (Mac OS X, Linux and other UNIX only).
+
+    On Linux and other UNIX .inputrc with the keyword "newlisp" will also be
+    recognized.
+
+    fixed indx/dec for integers when compiling for 64bit CPUs
+
+    Manual corrections
+
+9.9.96
+    'write-buffer' reported a wrong parameter on error
+
+    'prompt-event' now receives the current context as a parameter
+
+    'curry' now almost 50% faster and hygienic
+
+    'integer' which has been deprecated and not documented for some time
+    is now eliminated, use 'int'
+
+    'default' documented again
+
+    a bug fix in infix.lsp for trailing lower priority ops
+
+    'set-ref-all' now will not overflow the stack on large lists
+
+    'bits' function for binary conversion now documented
+        (bits 1234) => "10011010010"
+        (bits 1234 true) => (nil true nil nil true nil true true nil nil true)
+        ((bits 1234 true) 0) => nil
+
+    'inc' will throw error on missing argument 
+
+9.9.97
+    misc. cleanup in net-receive and net-select
+    updated syntax.cgi and newlispdoc to handle <? ...> XML tags
+
+    $idx gets also updated in the second syntax of the series function.
+
+    all HTML files delivered with distribution pass: tidy -utf8 
+
+    HTML generated with newlispdoc and syntax.cgi passes: tidy -utf8 
+    except when generating for gmp.lsp (special characters +,-,*,/,=,<,> in function names)
+    (see http://tidy.sourceforge.net)
+
+    updated newlispdoc v2.1, syntax.cgi v2.5
+
+
+10.0 Release December 8th, 2008
+
+10.0.1 Release January 8th, 2009
+     Eliminated warning messages for new gcc version 4.3.2 compile.
+
+     Fixed stat:plot and stat:plotXY routines in stat.lsp for gnupot. Tested 
+     on Gnuplot version 4.2.4 on Mac OS X and Win32. The routines broke in 9.3 
+     when process required the full pathnam for the process launched.
+
+     Documentation for syntax pattern for stat:plot was wrong. The stat.lsp
+     module now looks for the gnuplot executable and gives a message if gnuplot
+     cannot be found. The module also looks for $HOME/tmp or c:/temp on Windows.
+
+     Additional offset parameter in 'read-expr' and 'eval-string'
+
+     Allow default functors to contain FOOP objects. This allows writing destructive 
+     FOOP procedures, e.g.: 
+        (new Class 'Foo)
+        (define (Foo:modify obj val) (setf (obj 1) val))
+        (define (Foo:show obj) (default obj))
+        (set 'MyFoo:MyFoo (Foo 123)) =>  (Foo 123)
+        (:modify MyFoo 999) => 999
+        (:show MyFoo) => (Foo 999)
+
+     All looping functions with locals variables: for, dotimes, dolist, doargs
+     and dotree now can return references too. Now all built-in functions
+     except: let, letn, letx and local return references when possible. 
+
+     Fixed potential memory leaks in the Win32 utf16 functions.
+
+     'bayes-query' produced wrong results for non-existing tokens when using 
+     Fisher's Chi2 method 
+
+     'last' on strings as reference in non-UTF8 versions always referenced first.
+
+     The link.lsp feature was broken in 9.9.95
+
+     'callback' expanded to 8 parameters and 16 callbacks
+
+     changes in examples/upload.cgi demo
+
+     redone documentation and examples for UDP communications in Code Patterns
+     and reference documentation
+
+10.0.2 Release March 9th, 2009
+    Addition of READ_ME-OS2 in doc directory and of readline mode in makefile_os2
+
+    Treatment of trailing slashes in file-names for the 'file?' function is
+    now consistent with Mac OS X and other UNIX. (file? <directory-name>)
+    should always return true, regardless of trailing slash
+
+    'sys-error' now returns last OS errno and text in a list similar to net-error
+    (sys-error 0) resets (as before), any other number reports the error text
+
+    overhaul of makefiles for linux/debian and naming of some osx makefiles
+        make linux
+    or
+        make debian
+    will allways compile a 32-bit newLISP even when on 64-bit Linux. This is the
+    preferred mode to compile for linux, as most libraries and other apps run
+    an 32-bit API even if the OS is 64-bit. Same is true for OS X. This gives
+    newLISP 4G of workspace, with integer operations and file positioning 64-bit.
+    Only if newLISP has access to more than 4G of memory it makes sense to compile
+    fully 64-bit using one of the makefiles with '64' in the name.
+
+    added two amalgamation makefiles in the util directory for Darwin and Linux,
+    no advantage over normal compile, but perhaps different results on other
+    platforms,
+
+    new 'read-utf8' like 'read-char' but reads multibyte utf8 chars
+
+    'eval' did only pass symbol references, now also references from indexed
+    expressions:
+        (define-macro (foo) (list (args 0) 0)) 
+
+        (setf bar '(1 2 3)) 
+        (foo bar) => (bar 0) 
+        (setf (eval (foo bar)) 3) => 3 ; was not possible before
+        bar => (3 2 3) 
+
+    The "Status:" response line for CGI processing has been redone. When newLISP
+    server mode sees CGI output starting with Status: it will compose the HTTP 
+    status header with the rest of the line appearing after "Status:" in the line. 
+    See the Code Patterns document for an example.
+
+    Eliminated all references to opsys (OS number from sys-info) in favor of 
+    Labels "Linux", "Win32" etc. in qa-xxxx files and added "AIX" for future 
+    makefile_aix and makefile_aix_utf8 .
+
+10.0.3
+    Expanded 3rd syntax in 'swap' (swap <place-1> <place-2>) The first two old
+    call patterns are deprecated and will be removed in a future version.
+
+    Eliminated a stacksize dependence when using 'find' with 'match'
+	
+    IBM AIX for PPC has been added as a platform and using the IBM xlc_r or gcc
+    compiler. Some issues with newLISP server mode are not resolved yet.
+
+    Fixed a memory mapping problem surfacing on IBM AIX 32-bit compiles
+
+    Better handling of status in HTTP headers sent back from server
+
+    'nil' and 'true' confused 'sort' and 'unique', fixed.
+
+10.0.4
+    Improved precision and shorter source for 'prob-z' function
+
+	'expand' and 'letex' now also expand a top-level symbol not in expr list or 
+    quoted:
+        (set 'x 123 'y 456)
+        (expand 'x 'x) => 123 ; threw error before
+        (letex (x 'y) x) => 456 ; returned y before
+		(letex (x '(+ 3 4)) x) => 7 ; returned (+ 3 4) before
+    previously some of these caused an error in 'expand' and did no expansion
+    in 'letex'
+
+    Definition of 'legal?' for symbols was to strict 
+   
+10.0.5
+    makefiles for 64Bit Linux missed the NEWLISP64 flag since 10.0.2
+    added makefiles for BSD LP64 mode
+
+    code cleanup for OpenBSD warnings
+ 
+    new 'xfer-event' can monitor byte-transfer in get-url, post-url
+    and put-url and all file operations which take URLs.
+        (xfer-event (fn (n) (println "->" n)))
+		(length (get-url "http://newlisp.org"))
+         ->10240
+         ->11221
+         11221
+
+    'write-buffer' now behaves like 'write-line' when supressing second or
+    first parameter
+
+    new 'last-error' replaces 'error-number' and 'error-text' and returns
+    number and text in a list consistent with the behavior of 'net-error' and
+    'sys-error'. All three now behave the same way and can enumerate all
+    errors when given the error number as parameter.
+
+    'bind' did not allow recursive definitions
+
+10.0.6
+    some HTTP net errors where not registered with 'net-error'
+
+    readline tab expanson formatting was broken in 10.0.5
+
+    fixed a bug in 'replace' remove mode when all list members are nil
+
+    lambda functions (not lambda-macro) now allow for large or infinite
+    running bodies without stack impact
+
+10.0.7
+    'net-lookup' now sets 'net-error' when lookup fails
+
+    Miscellanous cleanup in nl-sock.c
+
+    Two NaNs should compare nil, division by zero will throw a div-zero-error
+    now only in integer division (/) with floats (div) it will return inf(inity).
+
+    New 'inf?' tests for inifinity: (inf? (div 1 0)) => true
+    now (NaN? (div 0 0)) => true
+
+    Thanks to Nelson H.F.Beebe from math.utah.edu to point out the correct IEE-754
+    behavior for division by 0.0, and NaN? and inf? tests.
+
+    The build process now also accepts  'make check' additionally to 'make test'
+    for GNU compatibility: 'make all check' and then 'sudo make install' makes
+    tests and installs.
+
+    When installing using 'make install' or when installing from the UBUNTU Linux
+    binary installer a newlisp-x.x.x (where x.x.x is the version number) and a i
+    symbolic link is created for newlisp -> newlisp.x.x.x. This way older versions 
+    stay and are still accessible. The binary installers for Win32 and Mac OS X 
+    have not changed.
+
+    The newlispdoc utility now accepts custom tags, which can be made up by just 
+    prepending the custom name with a: @.  The text after the custom tag will be 
+    translated as usual, e.g. it may contain @link tag etc.. Like in most other 
+    tags, text is limited to the same line.
+
+10.0.8
+    'pack' now converts floats to integer when the format is integer but the
+    argument is a floating point (double). It already converted integers to float
+    when the format was float, but didn't handle the other direction.
+
+    (int "ff" 0 16), (int "+ff" 0 16) and (int "-ff" 0 16) now all work. In former
+    versions a leading 0 or 0x was required.
+
+    An optional boolean flag in 'dotree' allows filtering hash symbols or symbols
+    from 'bayes-train' starting with an underscore character in their name.
+
+    Small fixes for syntax highlighting in newlisp-edit.lsp.
+
+    newlisp-edit.lsp now can change fonts in both, the editor and monitor areas,
+    depending on cursor position.
+
+    The syntax highlighter in syntax.cgi and newlispdoc now colors newLISPdoc 
+    tags too.
+
+10.1.0 - release June 22nd, 2009
+    fixed a memory leak in 'sync' when transferring data bigger memory page-size
+
+    (add) and (+) now return 0 and (mul) and (*) return 1. Before a missing
+    parameter error occured.
+
+    (and) now returns true. Before it returned nil. (or) still returns (nil).
+
+    new 'send' and 'receive' message functions for communications between 
+    parent and 'spawn'ed child processes. Transfers any expression any size.
+
+    new 'qa-message' file for testing new 'send/receive' message functionality
+
+    Makefiles with 'solaris' have been renamed to 'sunos'  and the built-in
+    variable 'ostype' now reports "SunOS" for Sparc SunOS and "Solaris" only for
+    OpenSolaris. Before "Solaris" was reported for all.
+
+    All UNIX except AIX and TRU64 are now compiled for readline and UTF-8 support
+    by default: make. Do make -f makefile_xxx. to choose a different configuration.
+
+    The util/ directory contains an alternate configure script called configure-alt
+    this can be copied up to the main distribution directory as an alternate
+    comnfigure utility. See util/configure.txt for more info on this.
+
+    if an 'until' or 'do-until' body is empty the last condition evaluation
+    should be returned
+
+10.1.1 - release update July 21st 2009
+    'string' function now 25% faster on expressions
+
+    It is not necessary anymore to give the program expression in 'net-eval' as a
+    string, if not given as string net-eval will convert automatically:
+        (net-eval "remote.com" 12345 "(+ 3 4)") => 7
+        ; same as
+        (net-eval "remote.com" 12345 '(+ 3 4)) => 7
+    Same works for the nested syntax with map of sites and expressions.
+
+    Added optional offset parameter in 'regex' and 'find' (in string syntax)
+        (regex <pattern> <string> [option [offset]])
+
+    'series' with the function argument now can make series of any data type
+
+    'swap' was not throwing error when second parameter was missing
+
+    Fixed a bug in 'eval-string' when the error procedure was specified.
+
+    In newLISP-GS gs:color-tag was documented but not implemented in Java
+
+    In newlisp-edit.lsp (newLISP-GS IDE) Ctrl-x/v/z/Z and Cmd-x/v/z/Z did not
+    set the buffer-dirty red light
+
+    New 'configure' makes old 'build' script obsolete.  After extracting the source 
+    distribution, simply 'make' will look for a 'makefile_configure' and generate
+    it calling 'configure' if it doesn't exist, then it builds the newlisp excutable
+    using 'makefile_configure'. An alternative: configure-alt can be found in the 
+    main distribution directory. See doc/INSTALL for more details.
+
+    SunOS makefiles now have support for readline by default
+
+    makefile_linuxLP64_urf8 had nl-utf8.o missing in OBJS
+	
+    makefile for ARM CPU on Nokia N810 tablet. To make for ARM:
+        make -f makefile_linux_maemo_armel
+
+    New module smtpx.lsp like smtp.lsp but allows attachments
+
+10.1.2 Windows only release update , August 3rd, 2009
+    to correct printing to stdout problem
+
+10.1.3 development release Aug. 9th, 2009
+	'inf?' and 'NaN?' where not working correctly on Win32, a new qa-float
+    can be used to check several aspects of IEE 754 Floating point compliance
+    regarding inifinitive and NaN (not a number) floating point values.
+
+    In 'now' the last 2 fields "minutes west of UCT" and "daylight savings" 
+    are now working correctly on Linux, Mac OS X, SunOS, BSDs and Win32.
+    Daylight savings on Win32 as minutes on all others as 0 to 6 flag depending
+    on geographical area. On AIX, OS2 and TRU64 0 is returned for both fields. 
+
+    The 'time' function now returns float milliseconds with fractional part
+    instead integer milliseconds.
+
+    The return string size from 'command-event' is now unlimited, before
+    254 length was maximum.
+
+    New -t <connection-timeout> commandline option, specifies timeout in
+    micorsoseconds after connection when in demon mode. This avoids an un-
+    responsive server when a client connects, but doesn't do anything else.
+
+    New makefile_darwin_utf8_llvm on OSX for building newLISP using the LLVM
+    compiler. Improves performance by about 10%, needs developer tools installed.
+
+    New versions of syntax.cgi and newlispdoc correct highlighting for & and ^.
+
+    New version of nls (combined newLISP and BASH shell) adapts the help function
+    to the manual formatting introduced in 10.1.1.
+
+    Long overdue removal of internal cell mark/sweep routines. 
+
+    Net sessions list now avoids socket doubles in server mode.
+
+10.1.4
+    'now' offset parameter crashed broken in 10.1.3, working again
+
+10.1.5 Maintenance Release September 15th, 2009
+
+    Fix for OS2 compile in nl-filesys.c
+
+    Fixed stray i in fetch-all in mysql.lsp,
+
+    Return milliSec float with decimals for 'time-of-day'; on modern systems
+    this enables microsecond resolution.
+
+    On Mac OSX 10.6 Snow Leopard, the make/configure script will make a 32-bit
+    newLISP although 64-bit is detected as the default. To make 64-bit newLISP
+    use one of the supplied makefiles explicitly as in earlier Mac OSX versions.
+
+    Copying a zero-length file will not throw an error anymore.
+
+10.1.6 Maintenance Release October 20th, 2009
+    Fixes for 'net-error' and 'sys-error' when supplying out-of range numbers
+    o 0s. 
+
+    Documentation fixes in the 'Users Manual and Reference'.
+
+    'inf' is now signed in floating point opertions: (div -1 0) => -inf
+	'mod' will return NaN for a 0 divisor, % will still throw an exception
+    when divisor is 0.
+
+    Fixed a memory bug in 'starts-/ends-with' when using regular expressions.
+
+    'nil' and 'true' symbols where not always taken as boolean value which
+    affected 'sort' and 'difference'.
+
+    New 'reader-event' triggers when an expression was read. The function
+    specified in 'reader-event' can translate the expression before
+    evaluation returning a modified version of the input. This can be used
+    to create a reader macro facility.
+
+    New module file macro.lsp implements reader/rewrite macros by means
+    of the new 'reader-event' function.  
+
+    Change in sqlite3.lsp in bind-parameter, how text and blobs are retrieved.
+
+    deprecate usage of $0 in set-ref and set-ref-all .
+
+	throw error when trying to do a replace on a system symbol
+
+    some cleanup of itSymbol
+
+10.1.7 maintenance release November 24th, 2009
+
+    URLs now decoded correctly when compiled in IPv6 mode.
+	IPv6 compiled version now runs qa-net.
+
+    'net-ping' does not require root/superuser privileges anymore when on Mac OS X.
+
+    Small speed improvement in map and fixing treatment of missing arguments:
+    (map list '(a b) (A)) => ((a A) b) ; not ((a A (b nil))
+	(map string '(a b) '(1)) => ("a1" "b") ; not ("a1" "bnil")
+
+    'swap' can work in-place like: inc, dec, pop, push, replace, rotate, sort,
+    write-buffer and write-line always could.
+
+    Optional true-flag parameter in ref/ref-all returns item(s) found instead of 
+    index vectors when a compare function is specified. Instead of:
+        (map mylist (ref-all pattern mylist match)
+    do:
+        (ref-all pattern mylist match true)
+
+    Bad application of errorProcExt2() in netReceive() could crash on error.
+
+    Protect local symbols in caller hierarchy from 'constant' and 'context'.
+
+    All event fuctions now can take either nil or 'nil (quoted) to disable an
+    event handler, before only quoted 'nil was working, unquoted nil could crash.
+
+    Removed experimental 'estack' from code and newlisp.vim (introduced in v9.9.94)
+
+    Throw reference error in 'setf' on string when base ptr is not from sub-expression 
+    string. Wouldn't do anything before.
+
+    Accept chars > 127 in HTTP headers received from remote servers in web functions.
+
+    Do URL translation of path-file names in HTTPD server mode.
+
+    A 'sql3:colnames' function has been added to the sqlite3.lsp module.
+
+
+Dec 6, 2009
+10.1.8 This development version starts the v.10.2 generation of newLISP 
+
+    Fixed a bug when replicating primitives with 'new'.
+
+    FOOP objects are now mutable, anonymous or not. The old obj parameter has been
+    dropped from FOOP methods. Instead a new function 'self' is used to access and
+    index the target object:
+
+       (new Class 'Circle)
+
+	   (define (Circle:move dx dy) 
+           (inc (self 1) dx) 
+           (inc (self 2) dy))
+       
+       (set 'aCircle (Circle 1 2 3))
+
+       (:move aCircle 10 20)
+
+       aCircle => (Circle 11 22 3)
+
+    Old FOOP methods have to be rewritten to drop the obj parameter:
+
+    old : (define (Foo:method obj p1 p2) ...)
+    new : (define (Foo:method p1 p2) ...)
+
+    This has also reduced the overhead required in FOOP methods. Allthough this
+    change creates an incompatibility with older FOOP code, the advantage
+    of having mutable objects compensates for that incompatibility. Destructive
+    methods was the FOOP feature most asked for ind newLISP.
+
+10.1.9 Jan 12, 2010
+    Fixed executeCommandLine() for 64-bit UBUNTU, which could cause writeStreamStr()
+    related functions to crash.
+
+    (delete <sym> nil) will delete symbols without checking any references. The 
+    symbol can be a context symbol. Note that this mode of 'delete' can crash 
+    the system if if symbols are referenced from anywhere else. 
+ 
+    Fixed double evaluation in nil? predicate
+
+    Fixed a bug in 'legal?'.
+
+    Better error reporting for url based file operations.
+
+    A sign-extension fix for 'get-int' under 64-bit
+
+    Fix in gmp.lsp for 64-bit >,<,>=,<= but still problems with 'factor'
+
+    Fix for push on fresh symbols. Did return the element pushed not the list.
+
+    Fix for push -1 optimization when copying contexts with 'new' 
+
+    Fix for a memory leak in certain applications of 'new' 
+
+    Fix for 'self' in nested FOOP functions, also eliminated FOOP stack
+
+    New smtpx.lsp module for (multiple) attachements and UTF-8 safe encoding
+
+
+10.1.10 Jan 26, 2010
+    New 'extend' works like 'append' but modifies first list or string
+    parameter.
+
+    New ++ and -- increment/decrement in integer mode.
+
+    Functions 'inc/dec' now always work in floating point mode.
+
+    In 'find' the regex option can be specified as nil when offset is present,
+    this way 'find' with offset does not have to be a regex search.
+
+    In 'starts-with/ends-with' nil is not allowed as a parameter for
+    case insensitivity anymore use the regex option 1 instead (nil always
+    did regex anyway).
+
+    Changed configure-alt now allows defintion of different install and
+    exe prefixes. For questions and support for configure-alt, please
+    contact Ted Walther: ted@reactor-core.org.
+
+    Makefile has been simplified and the install part extracted as:
+    makefile_original_install, (used by configure).
+
+10.1.11
+   Various documentation fixes and changes.
+
+   Additional, optional list-index parameter in 'now' makes it return a list 
+   member instead of the whole list:
+      (now 0 0) => 2010 ; year
+      (now 0 -2) => 300 ; offset west of GMT (in EST)
+
+   A string slice offset out of bounds now throws error as in lists.
+
+   'pretty-print' can addtionally define the default print format for
+   floating point numbers.
+
+   New 'prefix' returns the context of a symbol.
+
+   New 'term' replaces deprecated 'name'.
+
+   New 'caller' returns the symbol of the caller function.
+
+   'read' and 'write' may be used as shorter writings of the elementary 
+   'read-buffer' and 'write-buffer' I/O functions.
+
+   Addtional chapter in doc/INSTALL for package creators and installation
+   customization.
+
+   Updated syntax highlighing for nano, joe, and vim editors.
+
+   Added back cleaning into 'make dist'.
+
+   Re-added Cygwin flavor with 'make -f makefile_cygwin'. The make file gets
+   also chosen by 'configure' and makes a newlisp.exe, but has to be installed
+   manually together with cygwin1.dll in %NEWLISPDIR%; on Win32 normally
+   defined as C:\Program Files\newlisp. 
+   Many thanks to Niek from http://daansystems.com for helping with this.
+
+10.1.12
+   Symbol protection for containers of mutable FOOP objects
+
+   Functions 'crit-chi2' and 'prob-chi2' produced value too low on odd degrees 
+   of freedom. 'bayes-query' in Chi2 mode was not affected.
+
+   moved most qa-xxx files into qa-specific, only qa-do and qa-comma stay in
+   main source directory. The commands 'make test' alias 'make test' work like
+   before, but now taking qa-xxx files from qa-specific. A new 'make testall'
+   can be used to test with allmost all qa-xxx files. 
+   To reduce output do: make test | grep '>>>>>'
+
+   Rework of setf for in-place changes.
+
+   'caller' introduced in previous development version 10.1.11 has been
+   eliminated.
+
+   'define-macro's (fexpr's) are now included in error reporting:
+      define (foo) (bar))
+      (define-macro (bar) (+ a s f))
+      (foo) =>
+      
+      ; in older verssion 'bar' doesn't show
+      ERR: value expected in function + : a
+      called from user defined function foo
+
+      ; now 'bar' is reported
+      ERR: value expected in function + : a
+      called from user defined function bar
+      called from user defined function foo
+
+    In newLISP-GS on Win32 a messagebox pops up if a connection cannot be
+    established between the newLISP process ad Java GUI server.
+
+10.2.0 stable release March 16th, 2010
+    new 'configure-alt' fixes a problem for debian package making.
+
+    The enviroment variable REQUEST_METHOD is now set by newLISP server mode
+    to one of the strings GET, HEAD, PUT, POST, DELETE.
+
+    'det' and 'inv' now return 'nil' on singular matrices, but fall back
+    to the old behaviour when specifying a new optional 'true' flag. With
+    the flag pivot elements of 0 will assume a very small value as in
+    older versions of newLISP.
+
+    'xml-parse' did ot parse UTF-8 chracters correctly.
+
+    'make test' and 'make testall' now by default do the short display
+    with only the end result. 'make check' and 'make checkall' produce
+    the long output.
+
+    Fixed wrong error message in context creation.
+
+    The int-type field in all financial functions is optional.
+
+10.2.1 stable release March 17th, 2010
+    'setf' and 'swap' could change the values of 'true' and 'nil'.
+
+10.2.2
+    'time' did overflow after 35 minutes now can count to about 68 years.
+
+    Speed up of Hash deletion with: (<tree> <token> nil). No reference
+    checks are made. This means that tree hashes should only be used as
+    such and symbols not be referenced directly with the prepended 
+    underscore, as is usual practice already, or be deleted explicitely 
+    using 'delete'.
+
+    'xml-parse' with context option did not convert names of built-in
+    primitives.
+
+    New second syntax pattern for 'net-service':
+       (net-service <port> <protocol>) => service-name
+       (net-service 22 "tcp") => "ssh"
+
+10.2.3
+    The 'net-connection' functons now can take a timeout ms parameter:
+       (net-connnect <str-host> <int-port> <int-milli-sec>)
+    on UNIX the function will fail returning 'nil' before the timeout
+    expires. On Win32 the 'net-connect' will not fail until the timout 
+    is run out. This makes the function return 'nil' on closed ports
+    much faster on UNIX.
+
+    New documentation for 'net-service' and 'net-connect'
+
+10.2.4
+    'find-all' will not exit anymore on loop conditions but retry
+    incrementing the the search offset by 1. 
+
+    'load' in HTTP mode did not return to previous context, but always
+    went into MAIN.
+
+    "file://C:/example.txt" and "file:///C:/example.txt" both forms are
+    now valid on Win32.
+
+    On Win32 negative Inf lost the sign when converting to maxint
+
+    Shorten p_setLocale() code. 
+
+    A fix for ref-passing out of loop primitives.
+
+10.2.5
+    Additions, modifications to qa-xxx files
+
+    The 'true' flag in 'delete' was not handled correctly since 10.2.0
+
+    10 times speedup of 'save'
+
+    new 'net-packet' function, UNIX only tested on Mac OSX 10.4 PPC G4,
+    Mac OSX 10.6 Intel, Linux UBUNTU 9.10  (root privileges required).
+    See newlisp-10.2.5/qa-specific-tests/qa-packet for working TCP examples.
+    Change target IP numbers in packet examples in qa-packet to working ones.
+    Protocols TCP, UDP and ICMP have all been tested on OSX X PPC, OSX Intel
+    and Linux UBUNTU 9.10 communicating with raw packets between Big-Endian
+    and Little-Endian CPUs, sending a raw-packet and receiving a correct
+    response packet.
+
+    handling on short lists when mapping strings now consistent: 
+    'map' stops collecting as soon as one argument list is short. This
+    ensures that elements in the nth row appear always in the nth column
+    after the transposition caused by 'map'. This was working on lists
+    but did not work accordingly on strings.
+
+10.2.6
+    In 'get-url' the "list" option in combination with the "debug" options
+    did return a string instead of a list.
+
+    'net-packet' now also works with OpenBSD addtonally to: Mac OS X on 
+    PPC and Intel and Linux on Intel CPUs. 
+
+    The timeout parameter in 'get-url', 'post-url' and 'put-url' did not 
+    work correctly since 10.2.3 after introducing the 'net-connect' timeout
+    parameter.
+ 
+    OpenBSD 4.6 now added as a regular test environment additionally
+    to Mac OSX, FreeBSD, UBUNTU Linux, SunOs Sparc and Windows XP/7.
+
+10.2.7
+    In  'pmt', 'ipv', 'nper' int -> long for Linux 64-bit
+
+    Cell leak in 'find-all' when new handling of looping condition (v.10.2.4)
+
+    Fixes in qa-net for IPv6
+
+	Note, that net-packet is currently coded only for IPV4
+
+    Fixed a bug in URL parsing for IPv6
+
+    'find' did not evaluate regex option parameter since 10.1.10
+
+10.2.8 stable maintenance release May 20th 2010
+    Backed out some IPv4/6 changes in 10.2.7 reverting to 10.2.6 plus some
+    IPv6 fixes. Next development version will split up nl-sock.c into UNIX 
+    and Windows versions; recoding the UNIX version using getaddrinfo() and 
+	getnameinfo() for dynamic IPv4 and IPv6 support in the same version.
+
+10.2.9 development release May 27th, source only
+    Large portions of nl-sock.c have now been re-written to switch between 
+    IPv4 and IPv6 during runtime using the new 'net-ipv' function:
+        (net-ipv) ; show current protocol as 4 and 6
+        (net-ipv 4) ; switch to IPv4
+        (net-ipv 6) ; switch to IPv6
+
+    By default newLISP starts in IPv4 mode, to start up in IPv6 mode:
+        newlisp -6
+    When the IPv4 to IPv6 transition is completed in a few years, the
+    default will be changed to IPv6 and a 'newlisp -4' startup option
+    will be introduced. The current -6 option is only necessary when starting 
+    newLISP in server mode. In normal mode a (net-ipv ...) code switch can be used.
+
+    The nl-sock.c  uses the newer POSIX 'C' getaddrinfo() and getnameinfo() 
+    functions. Wondows 95 is not supported anymore. The minimum MS Windows version 
+    for newLISP is now Windows NT 5.01. This allowed mostly similar code
+    on Windows and UNIX and made a split into platform dependent files unnecessary.
+
+
+    New 'qa-specific-tests/qa-net6' for IPv6 testing included in:
+        make testall
+    UNIX like OSs test fine on IPv4 and IPv6. Currently I have no IPv6
+    capable MS Windows, FreeBSD and SunOS installations for testing.
+    But on all platforms this version compiles and links well.
+
+    Following systems test fine:
+        Mac OS X 10.6, IPv4 and 6, 32 and 64-bit
+        Windows XP SP2, IPv4 only, 32-bit
+        Linux UBUNTU 10.4, IPv4 and 6, 32-bit
+        OpenBSD 4.6, IPv4 and 6, 32 and 64-bit
+        FreeBSD 7.2, IPv4 only, 32-bit
+        SunOS 5.8 on Sparc Ultra-2, IPv4 only, 32-bit 
+
+10.2.10
+    Allow binary zeros in 'exec' piped-in data
+
+    Cleanup for sendHTTPpage()
+
+    Fixed a bug in 'copy', which passed on a wrong protection status, when
+    copying protected variables since 10.1.12
+
+    IPv6 not currently working on the Win32 MinGW compiled version
+
+    Changed winsock initialization to v.2.2
+
+10.2.11
+    Windows versions now compiled using wspiapi.h in nl-sock.c. This guarantees
+    working of freeaddrinfo(), needed for IPv6, on some older Win 2000 systems.
+
+    New multiline mode on the commandline, without using [cmd], [/cmd] tags:
+    just hitting [enter] on an empty line gets into and out of multiline mode. 
+    The [cmd], [/cmd] still work too and are needed internally when newLISP is 
+    working in server mode, for some IDEs and when pasting source containing
+    empty lines into the terminal. Tab-expansion (on Unix only) for built-in 
+    function names also works in multiline mode.
+
+    Minor changes in version 1.37 of the Java based Guiserver.
+
+    In 'net-ping' specify optional third parameter to get an error string instead
+    of response time, if the host did not respond. This behavior was present in
+    previous versions, but was not documented.
+
+10.2.12
+	Fixes and additions for newLISP-GS guiserver.jar. See guiserver/CHANGES
+
+10.2.13
+    More fixes in guiserver see guiserver/CHANGES
+    no changes in newlisp interpreter
+
+    New 'date-list' returns list of year, month, day, hours, minutes, seconds from
+    time value in seconds since January 1st, 1900 (reverse of 'date-value')
+
+    'date-parse' is new name of old 'parse-date'
+
+    The week-day value in 'now' and the new 'date-list' has been changed to
+    conform to the ISO-8601 standard (international standrad for time and date
+    related data). Now 1-7 for Monday thru Sunday.
+
+    Font size in syntax.cgi now bigger on iOS devices iPad and iPhone
+
+    newlisp_manual.html, CodePatterns.html, ExpressionEvaluation.html and 
+    MemoryManagement.html are now XHTML 1.0 Transitional compliant.
+
+    New users manual chapter "3. Interactive Lisp mode" explains all the
+    features of the read-eval-print-loop (REPL) in newLISP.
+
+    Guisererver: Fix in TextShape.java to fox crashes when painting canvas.
+
+10.2.14 Development Release Sept 2nd, 2010
+
+10.2.15
+    Increased maximum length of command-line to 511. This affects the interactive
+    command line and line length in HTTP request headers. 
+
+    Default connection timeout set to 10 secs, up from 3 secs. Always can be
+    overwritten by timeout parameters in net-connect and get,post,put and
+    delete -url functions.
+
+    The boolean flag in 'title_case' in non-UTF8 versions was not calculated
+    correctly.
+
+    All HTML files in the doc directory are UTF8 and XHTML 1.0 Trans. compliant.
+
+    Additional parameter in '!' on MS Windows can be used to enter process creation
+    flags, e.g. for suppressing creation of a command window. Not using the parameter
+    assumes the old '!' method. When the parameter is present (can be 0) an alter
+    native method of process creation is used without dependence on a command shell
+    window. On Unix this parameter is ignored.
+
+    Fixed a bug in symbol compare routines when comparing dynamic symbols.
+
+    Result of 'map' should always be unprotected.
+
+    More adjustments in switchable IPv4/6 mode. 
+
+    Last sys-info field should change 7th bit (512) with 'net-ipv'
+
+    A change in guiserver.lsp to fix instabilities when gs:check-event was called
+    from gs:listen invoked event handler functions.
+
+10.2.16
+    New table widget and supporting functions in Guiserver.
+
+10.2.17
+    Fixes in error handlers of xmlrpc-client.lsp and xmlrpc.cgi
+
+    Fixes in guiserver.jar in Table UI
+
+    The sniff and scan utilities are added to newlisp-x.x.x/examples 
+    directory in the source distribution.
+
+    On 64-bit versions 'date' and 'date-value' will work for dates year 2038 
+    and up to January 2100.
+
+    The 'mod' function assumes the second parameter to be 1 if missing, thus
+    returning the fractional part of a number.
+
+    Updates to configure-alt for Windows 7.
+
+    POST with multipart/form-data content-type now works with newLISP HTTPD
+    and CONTENT_TYPE is added to the environment by newLISP server.
+    now added.
+
+10.2.18
+    'extend' will take an un-initialized variable and create a list or string
+    depending on the second argument (similar to 'push'). Before a variable
+    in the first argument had to be initialized to a string or list.
+
+    Added path for Fedora Linux in mysql.lsp
+
+    PCRE was not configured correctly for utf8 when using configure-alt.
+    pcre-config.h now includes config.h when using configure-alt to build.
+    Builds with the standrad configure where never affected. 
+    versions.
+
+    Added a "divert" option to 'net-listen'. In this case a IPPROTO_DIVERT 
+    option is added to a raw socket. 'net-receive-from' and 'net-send-to' 
+    are used to serve the divert-socket returned by 'net-listen'. The 
+    interface address is given as an empty string for INADDR_ANY. 
+    BSD 'ipfw' or Linux 'ipchains' rules must be defined in the configuration 
+    of the FreeBSD, OpenBSD or Linux platform for the divert-port and the 
+    ports to be diverted. 'net-receive-from' will contain the local interface 
+    address for incoming packets and will contain 0.0.0.0 for outgoing packets. 
+    See the man page for divert. The same address received by 'net-receive-from' 
+    is used in the 'net-send-to' call when re-injecting the packet:
+
+        (set 'divertSocket (net-listen divertPort "" "divert"))
+
+        (until (net-error)
+            (set 'rlist (net-receive-from divertSocket maxBytes))
+            (set 'buffer (rlist 1))
+            ; buffer can be processed here before reinjecting
+            (net-send-to (rlist 0) divertPort buffer divertSocket)
+        )
+
+     newLISP must be run in superuser mode to be able to create divertSocket.
+
+     Some internal cleanup for p_first(), p_last()
+
+     Bug fixes for modules/json.lsp
+
+     Fixed cell leaks when 'ref', 'ref-all' failed with error in
+     compareFunc()
+
+     The return value for 'ref' has changed from () to nil, when not
+     finding anything.
+
+     Fixed cell leak when 'setf/q' failed with protection error
+
+     symbolCheck cleanup in 'assoc', 'lookup', 'ref', 'set-ref' and all
+     flow constructs results in some speedup for these functions.
+
+10.3.0 Stable Release, February 2nd, 2011
+     newLISP HTTP server now also sets  CONTENT_LENGTH environment 
+     variable when present in incoming client header.
+
+     In cgi.lsp added (outcommented) alternative method for reading 
+     POST data. This relies on CONTENT_LENGTH set in the environment.
+
+     Fixed a problem in assoc, lookup and pop-assochen nil is passed
+     as key.
+
+     cgi.lsp now uses CONTENT_LENGTH if present to receive POST data
+
+     Fisher Chi-2 derived probabilities in bayes-query are not normalized
+     any  more.
+
+10.3.1  development release May 17th, 2011
+     Documentation changes
+
+     When a list reference changes while being indexed an error is thrown.
+     Code written this way will normally not make sense, but now fails
+     more gracefully.
+
+     (set 'lst '(1 2 3 4 5))
+     (lst (set 'lst '(1 2 3)))
+     ---> ERR: list reference changed
+
+     MBCS coded characters in pathnames in the Windows UTF-8 version.
+
+     Better worded error message when wrong parameter type in implicit
+     indexing of strings and lists.
+
+     Fixed a buffer overflow for interactive multiline mode for long
+     input lines.
+
+     Fix for 'filter', 'index', 'clean', 'exist' and 'for-all' when
+     handling empty list elements (). Also, these functions are now
+     several times faster.
+
+     Check for missing parameter in inc, dec, ++, --. Using these
+     without any parameter messed up the value of 'nil'.
+
+     Fixed crash bug with boolean 'true' parameter in 'dotree'
+
+     Minimum SDK changed to 10.5 Leopard for makefiles:
+       makefile_darwin_utf8_leopardPPC
+       makefile_darwin_utf8_leopardIntel
+     to make a universal Tiger 10.4 based version the file:
+       makefile_darwin_universal_utf8_compat
+     still exists (for questions about this -> Greg Slepak).
+
+     bug fix for 'timer' when using recursively and not using symbols
+     but lambda expressions, e.g.: (timer foo 1) instead of (timer 'foo 1)
+     when the (timer ...) statement is part of foo.
+
+     New version 0.3 of json.lsp module now processes backslashed characters
+     as of JSON spec (thanks Ted Walther).
+
+     Speedup and memory lossless error recovery in 'map'.
+
+     Better memory management in error recovery of evaluateStream()
+     and sysEvalString()
+
+     Did not clear EOF error in 'read-line'.
+
+10.3.2 stable maintenance release July 20th, 2011
+     New 'debugConsole' in newlisp.dll can be imported and called for
+     re-opening std I/O to CONOUT$ and CONIN$.
+
+     Fixed memory leak in library mode.
+
+     Doc changes and additions.
+
+     makefile_darwin_utf8_lib for newlisp.dylib
+
+     Fix for "debug" option in 'get-url' when passing url-encoded
+     strings (thanks to Kosh for catching and fixing this)
+
+     The newlisp.1 man page showed an old invalid method to define
+     redirections in http-conf.lsp.
+
+     Significant speedup of 'series' with function in second argument.
+
+     Speedup of 'find-all' (for lists and strings) when function is used
+     as third argument.
+
+     Quoted strings now can contain unicode characters encoded using
+     \u.... , where .... are four hex digits e.g. "\u03b1\u03b2\u3b3"
+     for the Greek letters "ฮฑฮฒฮณ" (alpha, beta, gamma). When reading 
+     the string, newLISP will translate it to UTF8 encoded characters
+     on UTF8 enabled versions of newLISP.
+
+     More work on 'map': speedup now also on smaller lists.
+
+     Avoid redundant cellCopy() when cell already on result stack
+     (needed change in array initialization).
+
+     Fixed and error message in gs:save-sequence
+
+10.3.3 stable maintenance release September 20th, 2011
+     Manual updates.
+
+     On MS Windows newlisp.dll now lives in windows/system32 or whatever
+     the main 32bit DLL directory is on the specific Windows platform,
+     chosen by the $SYSDIR variable in the NSIS installer.
+
+     Fixed broken memory sharing for date sizes > 4084 bytes.
+     This affected 'spawn' and 'share' for memory transfers > 4084 bytes.
+     Also inlined stream writing for this fucntion again for better 
+     memory cleanup.
+
+     Share file in tmp is now deleted when unmapping under UNIX. Unmapping is
+     not available in Windows but in all OS a (share mymem nil) will
+     always delete any existing tmp file for this share.
+
+     When in trace/debug mode and an error occurs in a function call
+     inside a 'catch' statement, an error message will now be printed,
+     Processing will continue as before with the offending function
+     returning either 0 or nil depending on the nature of the function.
+     This allows to inspect the current state of the program.
+
+     2 new example programs in newlisp-10.3.3/examples/ :
+     Script 'async' show how to do asynchronous web page retrieval.
+     Script 'query' shows how to retrieve 20 pages in parallel spawned
+     child processes. 
+
+     Fixed return value from callback funtions when 64-bit integers
+     are returned.
+
+     From newLISP library a new function "newlispCallback" can be imported
+     to register callback functions (see manual for details)
+
+     -l -L now always create a logfile if it doesn't exist. Evaluation
+     results prepended with "-> ". [cmd],[/cmd] are not logged
+
+     Save memory in 'string' and 'format'. 
+
+10.3.4
+     Reworked 'send'/'receive' message API is multiple times faster and has
+     more consistent performance on different platforms. Better on BSDs
+     than on Linux. The channel for each child is now a dual read/write
+     message queue. In previous version only one message could be written
+     to the queue with send, now mutiple message can be send on the same
+     channel and retrieved on the receiving side with multiple 'receive'
+     until returning 'nil'.
+
+     In the new syntax of 'receive' the <message> parameter is optional:
+
+        (receive <pid>) ; returns the message or nil
+        (receive <pid> <message>) ; returns true or nil
+
+     Both 'send' and 'receive' now have syntax to return a list of all
+     ready child channels using either (send) to get a list of child
+     pid's ready to receive data or (receive) to get a list od child
+     pid's ready to be read. This greatly speeds up asyncrounous
+     messaging, where multiple child processes, but not all, have sent 
+     messages. Previously:
+
+        (dolist (p (sync)) (until (receive p msg))) ; (sync) -> child pids
+
+     Now using only a ready subset, 'receive' can be used non-blocking
+     and only a subset of all child pids is iterated through:
+
+        (dolist (p (receive)) (receive p msg))
+
+     Now, when a 'spawn'ed child process ends abormally the variable in the
+     spawn command will contain an error message and a result number,
+     e.g. '9' from a kill signal sent by an external process.
+
+     Fixed longstanding bug for list-mode 'net-select'. Now returns
+     socket numbers in the ready list not 0's.
+
+     Documention for the messaging API has been updated in the reference
+     manual and code patterns documents.
+
+10.3.5
+     'invert' over-allocated memory
+
+     Fixed a crash bug in purgeSpawnList()
+   
+     icmp6.h include for cygwin in nl-sock.c (thanks KOSH)
+
+     The creation of a communications channel between and parent process
+     and 'spawn'ed child processes for usage with the message API  of 
+     'send' and 'receive', is now optional:
+
+         (spawn <sym-variable> <child-process> [true])
+
+     If the'send' or 'receive' is used on the child process spawned, the
+     optional flag must be set to 'true'.
+
+     The fakes versions on 'spawn', 'sync' and 'abort' in Win32 have been
+     taken out.
+
+     The newLISP shell "newlisp-x.x.x/util/nls" now works on MS Windows too.
+
+     The link feature using util/link.lsp did no works with 64-bit versions
+     of newLISP.
+
+     In the MinGW compile of nl-sock.c the include file wspapi.h has been
+     replaced with ws2spi.h. This file is part of the normal MinGW install.
+
+     newlisp.dll now lives in NEWLISPDIR again as it did before 10.3.3
+
+10.3.6 development release November 18th, 2011
+
+     Speedup of string stream conversion for 'format', 'string'.
+
+     A bug fix in 'spawn' when aborting child processes
+
+     Preparations for expanded FFI (grep for FFI in all files)
+
+10.3.7 development release
+     
+     Fix in printing FFI primitives (FFI is disabled by default)
+
+     Updated newlispdoc now all tags (including custom) are title-case'ed
+
+     Simple libffi calls working on Mac OSX, UBUNTU Linux (Intel) and Win32
+     three (and more) new ffi makfiles:
+        makefile_darwin_utf8_ffi  # std OSX install has libs and headers
+        makefile_linux_utf8_ffi   # must install package libffi-dev
+        makefile_mingw_ffi        # must install libffi.a library for build
+
+     New qa-specific-tests/qa-ffi for ffi API testing
+
+     The new ffi extension work with the existing 'import' functon:
+        (import "libc.dylib" "atof" "double" "char*") 
+        (atof "123.456") => 123.456
+
+     No "cdecl" or "stdcall" mustbe specified. The parameter after
+     the function name is the return type. The remaining parameters
+     are the function arguments.
+
+     As before, the imported function can be renamed:
+
+        (set 'strtof (import "libc.dylib" "atof" "double" "char*"))
+        (strtof "123.456") => 123.456
+
+     The following types are implemented for LP64, LLP64 and ILP32
+
+         "byte"
+         "char"
+         "short int"
+         "unsigned short int"
+         "unsigned int"
+         "int"
+         "long long"
+         "float"
+         "double"
+         "char*"
+         "void*"
+
+      For pointer return values "char*" and "void*", the address
+      is returned as a number. Use 'get-string' or 'unpack' to retrieve 
+      contents. This method allows returning binary info. THIS IS CHANGED 
+      IN 10.3.9 where "char*" returns a string directly and "void*" a number.
+
+10.3.8
+      Make sure FFIMPORT struct memory gets freed when doing multiple
+      'import' of the same function or deleting the func symbol.
+
+      When using 'configure' and 'make' FFI will be chosen by
+      default on Mac OSX, Linux and Windows (MinGW)
+
+      Both "char*" and "void*" accept either a  newLISP string buffer or an 
+      address number as input. On return "char*" will return a newLISP
+      string buffer and "void*" will return an address number.
+
+      Comprehensive qa-specific-tests/qa-ffitest compiles util/ffitest.c
+      on the current platform then tests all data types.
+
+      Now ffi checks for nummber of arguments matching call pattern.
+
+      The opengl-demo-ffi.lsp now runs on both 32-bit and 64-bit newLISP
+      and libraries. On Windows glut32.dll is required. On Mac OSX everything 
+      is installed by default.
+
+      ffi callback (ffi closure) working now on Mac OS X, Win32 and UBUNTU Linux
+      with standard installed libraries. Only for compiling/linking
+      libfffi-dev is necessary on UBUNTU linux. 
+
+      The extended 'callback' API will not work on 64-bit Mac OSX newLISP, 
+      but there is no problem to mix extended 'import' and simple 'callback' API
+      (see examples/opengl-demo.lsp)
+
+      Bit 11 for 0x400 in the last field of 'sys-info' is set for extended ffi 
+      enabled versions requiring ffilib.
+            (not (zero? (& 0x400 (sys-info -1)))) => true for FFI support
+
+      Avoid passing on list or string references in primitives taking strings
+      or lists but creating new objects.  This caused an error when doing 
+      (inc (char str)) when str is protected. symbolCheck = NULL only neccessary
+      if not set to NULL by previous evaluateExprtession() to non-string/list.
+      Fixed on selected primitives.
+
+      qa-ffi and qa-libffi are now part of 'make testall'. They will not be
+      executed on versions not compiled for libffi based FFI.
+
+10.3.9 development release December 21st 2011
+     'struct' function for extended FFI usage now working for 32 and 64 bit
+        (struct 'foo "char" "int" "short int")
+     Foo can now be used as a data type in the extended FFI API:
+        (import "thelib" "afunc" "foo" "foo") ; takes ans returns a struct foo
+     (unpack foo (afunc (pack foo 1 2 3))) => returns a list with 3 numbers
+     The additional syntax forms of 'pack' and 'unpack' take care for packing
+     and unpacking wirth the correct number of pad bytes to make align
+     structures on different Architectures.
+ 
+     See qa-special-tests/qa-libffi for an example.
+
+     Accept data lists in struct packing just like in traditional 'pack':
+        (struct 'pair "int" "int") => pair
+        (pack pair 1 2)    => "\001\000\000\000\002\000\000\000"
+        (pack pair '(1 2)) => "\001\000\000\000\002\000\000\000"
+
+     Nested structure now can be packed:
+        (struct 'pair "char" "char") => pair
+        (struct 'comp "pair" "short int") => comp
+        (pack comp (pack pair 1 2) 3) => "\001\002\003\000"
+
+     Sub-structures are unpacked manually (may be changed):
+        (unpack comp (pack comp (pack pair 1 2) 3)) => ("\001\002" 3)
+        (set 'p (first (unpack comp (pack comp (pack pair 1 2) 3))))
+        (unpack pair p) => (1 2)
+
+     Because of memory management issues with cells in FFI symbols
+     extended ffi functions, structs and callbacks can only be defined
+     once. Subsequent definitions return nil and the existing definition
+     stays untouched.
+
+     Miscellanous fixes for 64-bit newLISP and ffilib usage.
+
+     Added custom ffi_type ffi_type_charpointer for displayable strings
+     now 'unpack' unpacks strings for "char*", not address numbers.
+
+     On Mac OSX 64-bits extended callback (ffi closure) does now work.
+
+     SHA256 crypto algorithm has been added to the module crypto.lsp.
+     Thanks to Marc Hildman for this contribution. 
+
+10.3.10 Development release Janaury 10th, 2012
+     Repeating ffi 'callback' with the same symbol will just return the old
+     address but not redefine the callback or return nil (as in 10.3.9).
+
+     examples/opengl-demo-ffi.lsp now also working with extended callback API 
+     on 32-bit and 64-bit.
+
+     Huge speed improvement in 'read-line' with file handle parameter,
+     now as fast as STDIN. For file and pipe operations.
+
+     'struct's returned by the extended FFI will now be unpacked automatically.
+     Nested structures will be unpacked recursively too:
+
+         (struct 'pair "char" "char") -> pair
+         (struct 'comp "pair" "int") => comp
+         (pack comp (pack pair 1 2) 3) => "\001\002\000\000\003\000\000\000"
+         (unpack comp "\001\002\000\000\003\000\000\000") => ((1 2) 3)
+
+     Imported functions can now be default functors:
+        (define myprintf:myprintf (import "libc.dylib" "printf"))
+        (myprintf "%s %d" "hello world" 123)
+
+     All makefile_mingwdll* tweaked for MinGW gcc 4.6.2. But binaries are still
+     delivered compiled on gcc 4.4.0 and made on Windows XP SP2, run fine on
+     Windows 7. 10.3.6 to 10.3.9 had newlisp.dll compiled for cdecl now in
+     10.3.10 newlisp.dll calling conventations are back to stdcall.
+
+10.4.0 stable release February 14th, 2012
+     UCT offset minutes as reported by the 'now' function now have reversed the
+     sign conform to ISO 8601. Positive for locations east of UCT and negative
+     for locations west of the UCT meridian (formerly GMT). Days of the year are
+     now reported from 1 - 365 (366 in leap years) instead of starting with
+     offset 0. 
+
+     'read-char' w/o file handle reads from the current I/O device.
+
+     New version Guiserver 1.45 avoids error loops when midi system is unavailable.
+
+     In 'unify' the underscore symbol '_' matches any atom or list or variable.
+
+     Two new make files for the Raspberry PI development VM from:
+         http://russelldavis.org/2012/01/20/new-raspberry-pi-development-vm-v0-2/
+     These makefikes don't need the readline library, although it could be installed
+     as shown here:
+         http://russelldavis.org/2012/01/23/building-newlisp-for-the-raspberry-pi-using-the-development-vm/
+
+     newlisp.dll now also on Winsock version 2.2 (like the main executable since 10.2.10)
+
+10.4.1 Development release April 3rd, 2012
+     The day-of-year value in 'date-list' now also starts with 1, like in 'now'.
+
+     Added CELL_IMPORT_FFI to various output functions (source, save etc.).
+
+     Added UTF-8 meta tag to newlispdoc HTML output.
+
+     Protect internally variable $x used in 'curry' and predefined 'module'.
+
+     When extended 'import' FFI is compiled, show 'libffi' in banner. 
+
+     Added new function 'union' (composed of (unique (append ...))).
+
+     New functions 'odd?' and 'even?'
+
+     Fixed unix.lsp for new overwrite protection of imported symbols in ffilib version
+
+     An additional 'true' flag in (char str idx true) returns the byte value instead
+     of the UTF-8 character value at index idx in the string.
+
+     Handle probablilities less 0.5 in crit-z.
+
+     New 'prob-t', 'crit-t', 'prob-f', 'crit-f' for Student's t and F statistic.
+     'crit-chi2' redone for extreme values. All report small, significant
+     one-tailed probabilities for higher values of t, or F.
+
+     Adjustments in 'normal' for better fit.
+
+     Optional 'true' flag in 'file?' lets it return filename string.
+
+     Windows version should cut off trailing CR-LFs in string passed to 'command-event'.
+
+10.4.2 stable  maintenance release May 2nd, 2012
+     In extended ffi "char*" will now only accept strings not integer addresses to
+     string buffers. For passing integer addresses use "void*" - internally libffi
+     treats them as the same, but the new approach gives automatic type-checking
+     at the newLISP level without causing a segfault. Already for return values
+     "char*" always returns a newLISP string and "void*" an integer address.
+
+     A fix for 'pack' when packing structures made with 'struct' in 64-bit newLISP.
+
+     In 'import' for OSX/Linux/Unix allow libraries to be opened without importing
+     functions. This is necessary if an imported library refers to another one, e.g.:
+        (import "libgslcblas.dylib")
+    
+     New module gsl.lsp with SVD, QR and Cholesky decompositions.
+ 
+     Added  'corr', 't-test' and 'stats' statistical functions.
+
+     New standard module gsl.lsp for SDV, QR and Cholesky decomp. and solver routines.
+
+     Updated plot.lsp with line and XY plot now a standard module.
+
+10.4.3 stable maintenance release May 7th, 2012
+     (seek <file-handle>) after (read-line <file-handle>) was broken in 10.4.0 when
+     introducing faster file stream reading on 'read-line' and file closing could
+     leak memory.
+
+10.4.4 Stable Maintenance Release September 15th, 2012
+     Eliminated getFloatFromCell() and replaced by getDirectFloat() in nl-math.c
+
+     Fixed error message for missing [/text] -tag when loading source from file.
+
+     read-file, write-file, append-file, delete-file when used with http:// URLs will 
+     now return nil under error conditions instead of throwing an error. This is
+     consistent with error behavior on local files.  When nil is returned, net-error 
+     gives more error information. For remote server-side errors on URLs the server 
+     HTTP error page is returned.
+
+     Check for UTF8 string validity in functions which are UTF8 sensitive. 
+     An error message "invalid UTF8 string" is issued for invalid UTF8 strings.
+
+     Several - and continuing - manual updates, most of them also going into current
+     online version of manual.
+
+     guiserver.jar 1.47 fixes getting text from an empty gs:text-field.
+
+     Binary number format can be used with either 0b or 0B as prefix to up to 64
+     1's and 0's, e.g. 0b101010 for the  number 42.
+
+     A 'true' flag as optional parameter in base64-enc will force the empty string
+     to be translated as "" instead of "====". Both cases translate correctly to
+     the empty string when fed into base64-dec.
+
+     Fixed a result stack overflow problem on callback's.
+
+     On OSX Mountain Lion 10.8.0 compiles also using clang instead of gcc.
+
+
+10.4.5 Maintenance Release, November 21st, 2012
+     Doc changes.
+
+     Avoid overrun of invalid utf8 strings in utf8_wlen() in nl-utf8.c and
+     new error message "invalid UTF8 string". Used by several string functions
+     and indexing.
+
+     'process' on Windows now returns a real pid (process id) as on UNIX. Before
+     a Windows specific process handle was returned - thanks Johu -
+
+     Fix for loading .init.lsp on OpenBSD.
+
+     cgi.lsp now can handle mutipart form data in POST requests - thanks Unya -
+
+     Additions to postgres.lsp - thanks Unya -
+
+     Fixed a bug in 'ref' when multiple nested matching expressions.
+
+     Fixed a bug when using 'float' on list members (took the next element as
+     conversion default).
+
+     Added comments in newlisp.h and makefile_linuxLP64_utf8_ffi for CentOS 6.
+
+     Added makefile_linuxLP64_redhat_utf8_ffi and makefile_linux_redhat_utf8_ffi.
+     Work Centos and Fedora. Use ./configure to configure these makefiles for correct
+     libffi version. Thanks to Ivan Ribeiro for this contribution. 
+
+10.4.6  development version released on 2013-02-05
+     When using option 8 in xml-parse (translation of XML tags into newLISP symbols),
+     then the colon : in XML tags with namespace part, will be translated into a dot.
+
+     macro.lsp now works when defining default functors as macros.
+
+     A fix in cgi.lsp for receiving large POST data.
+
+     Fix for newlisp-edit.lsp for usage in OSX homebrew distribution.
+
+     In 'file?' the 'true' flag not only causes the filename to be returned but now
+     also implies that the filename is not a directory, else 'nil' is returned.
+
+     Crtl-D in Unix now will emit a line feed before exiting.
+
+     Added 'make android_dist' and 'make android_dist_utf8' for making 
+     newlisp-ndk-x.x.x.tgz and newlisp-ndk-utf8-x.x.x.tgz package.
+
+     A fix in sort when the sorting function is generated at run-time.
+
+     On LINUX and BSD when compiled with GNU libreadline support a matching paren will 
+     blink on the simple or multiple newLISP command line. For this the following line:
+         set blink-matching-paren on
+     should be put into Bash .inputrc
+
+     When making for Linux Android, 'share' and 'spawn' now work for data > 4072 bytes,
+     when a /data/tmp directory is created on the Android device. 
+     
+     This /data/tmp directory must also be present for CGI when running newLISP HTTP
+     server on Android. 
+
+     Lower 4 bits of (sys-info -1) on Android is 11 but 'ostype' is "Linux".
+
+     JSON parser function (json-parse <string>) translates a JSON formatted string
+     into a S-expression. (json-error) returns error information of the form:
+     (<text str> <int-position>) when (json-parse <string>) returned 'nil'. 
+     ECMA-262 compliant as defined at  http://json.org 
+
+     big/small -endian initilaization wasn't happening in LIBRARY compile flavor, 
+     always assumed big-endian.
+
+     The module files: cgi.lsp, macro.lsp, plot.lsp and sqlite3.lsp have been updated.
+
+     Added error checking on net-select mode parameter.
+
+     Server mode now sets the REMOTE_ADDR environment variable to the IP-string of 
+     the connecting client.
+
+     Last cell speed optimization for lists made with 'append', 'sequence', series
+     and 'rotate'.
+
+10.4.7
+     Eliminate unused JSON error message.
+
+     Elminated usage of $0 in replace on lists (no regular expressions). The count
+     of replacements now is contained in the new $count system var, not $0. The usage
+     of $0 - $15 now is strictly for regular expressions. This also speeds up replace.
+
+     read-expr now uses $count instead of $0 for the number of characters processed.
+
+     Eliminated undocumented usage of $0 for found elements in find-all on lists.
+     Only $it is used. $0 only on find-all on strings with regular expressions.
+     The system variable $count is updated for all forms of find-all, ref-all and
+     set-ref-all.
+
+     Link feature now built in with comandline flag -x for all OS flavors:
+        newlisp -x <source-file> <executable-file>
+     The file util/link.lsp is not required anymore but has been included and 
+     adapted to changes for the -x linkage. The file illustrates the internals
+     of the linkage process when using the -x option.
+
+     An additional true flag in the real-path function allows finding the executable
+     path of executables - similar to the "which" utility on UNIX. This is a by-
+     product of fixing the link.lsp feature for UNIX. The additional flag works
+     on all platforms. 'real-path' on Windows and BSD now also veryfies that path 
+     and file are valid, as it already did on non-BSD Unix (OSX, Linux).
+
+     Enforce MAX_SYMBOL for tags in xml-parse and symbol creation using sym.
+
+     Security fixes for strncpy and strncat.
+
+     Windows CGI server mode was broken in development version 10.4.6 (isDir()).
+
+     Preparation for 64-bit Windows (in early summer).
+
+10.4.8
+    Cleanup of the factor function.
+
+    Like date-parse, date-value will produce negative values for dates before 1970-1-1
+    til 1901-12-14.
+
+    The function 'flat' now can take an optioal depth parameter to limit flattening
+    a list up to certain level: (flat <list> [<level>])
+
+        (flat '(1 2 (3 4 (5 6)) (7 8 (9 10)))  ) => (1 2 3 4 5 6 7 8 9 10)
+        (flat '(1 2 (3 4 (5 6)) (7 8 (9 10))) 1) => (1 2 3 4 (5 6) 7 8 (9 10))
+        (flat '(1 2 (3 4 (5 6)) (7 8 (9 10))) 2) => (1 2 3 4 5 6 7 8 9 10)
+
+    A fix for 'extend' when passing wrong type to unitialized symbol.
+
+    A fix in the parser to accept -.9 as -0.9 or +.9 as +0.9
+
+    =, +, -, *, /, %, ++, --, >, <, <=, >=, !=  operators and the functions 'abs', 
+    'even?', 'odd?', 'length', 'number?' and 'zero?' are all working on big-integers 
+    of unlimited size. 'float' and 'int' convert bigints into double floats and 
+    64-bit integers and the function 'bigint' converts integers and floats to big 
+    integers. See the section "Big integer, unlimited precision arithmetik" in 
+    chapter 8. of the Users Manual for more information.
+
+    Extended commandline buffer to 1024 bytes.
+
+    The "debug" option in: (get-url "http://newlisp.org" "header debug") will now also 
+    output the status header line of the server response in the console.
+
+10.5.0 Stable Release May 21st, 2013
+    Further speed improvements on big integer multiplication and division/modulus.
+
+    Check for division by zero in big integer division/modulus.
+
+    Memory fix for ++, -- on big integers.
+
+    The OSX Intel version is now 64-bit by default.
+
+10.5.1 development release Jun 4th, 2013
+    bigint will take mal-formed integers:
+       (bigint "hello") -> nil 
+       (bigint "123hello") -> 123L
+       (bigint "+123hello") -> 123L
+       (bigint "-123hello") -> -123L
+       (bigint "123.456") -> 123L
+    but should not be used on string of scientific notation, it only converts the mantissa
+       (bigint "123.456e10" -> 123L
+
+    Fixed division when aligned or not aligned embedded bigint 0s (9 zeros).
+
+    Fixed more big integer division problems and added more tests to qa-bigint.
+
+    Compiler optimizations are now supressed in part of the big integer 
+    division code to make it work on Linux. Does not affect performance.
+
+10.5.2 development release June 26th, 2013
+   Fix for Java 7u21 in guisserver.jar, guiserver.lsp and newlisp-edit.
+   function gs:run-shell now takes separate command and args parameters.
+
+   New functions 'kmeans-train' and 'kmeans-query' for cluster analysis. The
+   Function 'kmeans-train' allows starting centroids to be either generated
+   randomly or be passed as an extra parameter. This allows clustering like
+   in Kmeans++ or other advanced schemes of pre-calculated start centroids.
+   When pre-calculated centroids are given, they are allowed to have less 
+   columns, thus forcing kmeans clustering with less columns. This allows
+   to pre- or post-label the data set by including cluster-membership labels
+   in the last column. 
+
+        (kmeans-train matrix-data int-k context [matrix-centroids]) 
+            return => list of inner SSQs for all iterations
+
+        matrix-data -> n rows by m columns (list or array)
+        int-k       -> number of desired clusters
+        context     -> new or existing context for results
+        matrix-centroids -> optional k * m starting centroids (list or array)
+
+        ctx:centroids -> k * m matrix of k centroids
+        ctx:deviations -> list of average intra cluster deviations = sqrt(ssq-cluster/n-cluster)
+        ctx:clusters  -> list with k sublists each containing indices into data
+        ctx:labels    -> list of n cluster labels, one for each data record
+
+        (kmeans-query list-data centroids)
+            return => list of k Eucledian distances from the k centroids
+
+        list-data -> data record to be classified
+        centroids -> result in namespace from previous kmeans-train or any other
+                     list of data records to calculate Eucledian distances
+    
+ 
+        'kmeans-query' can also be used for KNN (K Nearest Neighbour) analysis,
+        as it calculates the Eucledean distances for any matrix given in
+        the second argument, not only centroids, but e.g. the original
+        dataset. If the data-set is pre-labeled, then list-data has less
+        columns forcing to not include the label in analysis.
+ 
+   Fixed handling escaped " (quote) in JSON strings.
+
+
+10.5.3 stable release July 10th, 2013
+
+   fixed escaping of back slashes in json-parse
+
+   file nl-xml.c renamed to nl-xml-json.c and makefiles changed accordingly
+
+   refactored  nl-matrix.c/multiply() to avoid memory leak on wrong parameters
+
+
+10.5.4 stable release October 1st, 2013
+
+   3.7 newlispdoc cleanup ";; *" regex
+
+   New FFI ffi.h include directory in makefile_linux* when installing libffi 
+
+   Fix for last list element optimization in push, pop and pop-assoc when 
+   popping and inserting last element
+
+   Accessing a deleted context will never hang but give an error message
+
+   Some changes in nl-filesys.c for AIX and new makefile for AIX ILP32
+
+   On Windows: a fix for correctly closing logfiles initiated by newlisp -l or 
+   newlisp -L and for closing files created by the HTTP PUT operation.
+
+   Two sample 't-test' when variances are different (independent samples) with
+   new syntax:
+        (t-test <list-vector-A> <list-vector-B> <float-probabilty>)
+   When <float-probabilty> is specified, an internal F-test for variance
+   equality in data A and B is performed. If the probablity of F is
+   smaller than <float-probabilty>, then Welch's variant of the t-test for
+   independent samples is performed. Using 1.0 <float-probabilty>, Welch
+   can be forced even when variances are not significantly different.
+
+   One sample 't-test' using new syntax pattern: 
+        (t-test <list-vector-data> <float-value>)
+   Gives the two-tailed probability that observed mean is differs from <float-value> 
+   Instead of sdev for second list-vector the standard error for the observed mean
+   is reported.
+
+   Some cleanup and changes in scripts (makefiles) for binary installers
+
+
+10.5.5 2013 November 20th, development release
+   Allow trailing , (comma) in JSON arrays. The new JSON ECMA-404 seems not 
+   to allow it but the JavaScript standard ECMA-262 and many browsers do.
+
+   Added makefile_linux_openwrt for for TP-link TL-WR703N travel router
+   contributed by Dexter.
+
+   In arithmetik big integer operations + - * / % more than two operands
+   are allowed as in normal precision integer operations.
+
+   On Windows support UNIX conventions for formatting 64-bit integers.
+   I.e.: %lld %llu %llx %llX additionally to %I64d %I64u %I64x %I64X
+
+   Added ++, -- to qa-bigint. Fixed sign change on second operand of
+   bigint -- when second operand was negative.
+
+   Some cleanup in Cilk API when releasing resources.
+
+   The 'gcd' function now also works on big integers and > 2 operands. 
+
+   On UBUNTU Linux decimal numbers can be formatted using a GNU extension
+   in libc, e.g: (format "%'d" 12345) => 12,345 
+   The optional ' (single quote) after the % character causes thousands
+   to be separated with the appropiate character for the current locale. 
+
+   Fixed a cell leak introduced in 10.5.5 when deleting contexts.
+
+   The default pretty-print float setting has been changed to "%1.15g".
+
+   'reset' now also cancels command line parameter processing.
+ 
+   A fix in 'round' when number is exacty 0.5.
+
+   'map', 'apply', 'stats', 'corr', 't-test' now also can take arrays
+
+   'bayes-query' with Fisher's Chi2 method calculated wrong probabilities
+   when training in more than two categories. When training in two
+   categories the result probabilities were swapped - reporting the
+   probability for the second category first. 'bayes-query' calculating
+   probabilities with the Chain Bayesian method - using the true flag - 
+   was not affected.
+
+   Many documentation changes and corrections.
+
+10.5.6 December 10th, 2013, development release
+   Since OSX 10.9 Maverick (format "%'d" 12345) => 12,345 will work too.
+   Will not work on any locale but works on en_US.UTF-8.
+
+   Fixed 'apply' for arrays introduced in 10.5.5 for a cell/memory leak.
+
+   When making hash trees using the predefined context 'Tree', 
+   the default symbol in the new context is protected as is 'Tree:Tree'.
+   Default symbols in hash trees must be 'nil' in order for the hash 
+   statement syntax for namespaces to work.  
+
+   When copying symbols from a source context to a target contest using 'new'
+   or 'def-new', the 'protected?' property is copied too.
+
+   An empty list as index vector for a list or array yields the original
+   list or array as return value: 
+       (set 'L '(1 2 (3 4)))
+       (L '())    => (1 2 (3 4))
+       (nth '() L) => (1 2 (3 4))
+
+   Many document changes, additions and corrections.
+
+   'int' can convert binarys numbers like (int "0b11111") => 31
+   This format is recognized by the code reader/loader since v.10.4.4.
+
+   Integers are accepted as hash keys. This allows creating sparse vectors: 
+       (new Tree 'V) 
+       (V 123 "hello") 
+       (V 123) => "hello"
+
+   'reverse' can be used on arrays.
+  
+   Anaphoric system variable $it is now set to the value of the conditional 
+   expression in 'if'.
+
+   Speed improvements in evaluateExpression().  For this The -pendatic option 
+   has been turned off in Linux to avoid ISO C90 mixed declaration warnings.
+
+   'length' on integers will return the number of digits, just like it already
+   does on bigint numbers, on floats returns the number of decimal digits before
+   the decimal separator.
+
+
+10.5.7
+   Fixes for deprecated CYGWIN compile. See also makefile_cygwin for more info.
+
+   Clear potential error condition when doing 'import'.
+
+   In guiserver.jar: When adding columns with empty string headers, this will not 
+   any more put the column number as header. This allows to add columns to 
+   headerless tables, as possible when supplying empty string headers in the 
+   initial gs:table statement.
+
+   Debugger will now always highlight the correct expression, not highlight
+   the first one if multiple instances exist.
+
+   Eliminated strncat() for BSD and better speed with memcpy() in most places.
+
+   Delay signal-behavior change in spawn after getting parameters. Makes better
+   error recovery.
+
+   In guiserver.jar: New table functions. Thanks to Ferry de Bruin.
+     gs:table-remove-row, gs:table-set-column-name and gs:table-set-row-count. 
+   To avoid API naming confusions, the naming of old gs:table-set-row-number 
+   is deprecated and should be called as gs:table-show-row-number. 
+   The old naming will continue to work. Three new optional parameters for 
+   'gs:scroll-pane' can specify colun header, row headers and a widget
+   for the top left corner of a table used in the scroll pane.
+
+   'find-all' should return an empty list as documented when nothing is found
+   on strings too.
+
+   Some renaming of functions and constants for better code readability and
+   some small refactoring in several files.
+ 
+   qa-bench has been redone with changes for Emscripten compiled newLISP.
+   Now calibrates for comparison with Mac OSX 9.1 on 2.3GHz Intel Core i5.
+
+   Fixed a crash bug when colon operator has missing or wrong-type args
+   on 64-bit compiles.
+
+   newLISP compiled to JavaSript with Emscripten
+   ---------------------------------------------
+   Added makefile_emscripten_lib_utf8. For this
+   Must download and install the Emscripten-SDK from here: 
+       https://github.com/kripken/emscripten/wiki/Emscripten-SDK
+   Tested on OSX 10.9 installing emsdk-portable.tar.gz v.1.7.8
+
+   The newlisp-js-lib.js is made using makefile_emscripten_lib_utf8.
+
+   The new function 'eval-string-js' takes a JavaSript string.
+   New 'display-html' can either replace the current page or display 
+   a page in a new tab of the host browser. 'display-html' must be
+   defined in Emscripten appplication .html
+
+   Some functions (filter, index, clean, exists, forl-all) will not show
+   error messages under certain circumstanmces in the monitor, although
+   newLISP behaves correctly throwing the exception (setjmp/longjmp), they 
+   just don't reach the Emscripten console (log). In this case, if the error 
+   is not 'catch'ed newLISP exits without advising why. This problem goes away
+   when compiling with Emscriptem without any optimizations, but slows
+   everything down by a factor of 40 to 50. Normal performance is around
+   1.5 of native on Mac OSX when excluding all time/date related functions 
+   and a few other outliers. Including outliers about 2.65.
+   See also here: https://github.com/kripken/emscripten/issues/810
+   (volatile declaration did not help)
+
+   All file and directory functions work (almost all did all the time),
+   but changes are lost after leaving the page or reloading the page.
+   Storage is 'session storage' only. No URLs are in allowed in file
+   functions as is on native compiled newLISP.
+
+   As editor, CodeMirror from codemirror.net is used and mode/newlisp.js
+   was created for syntax high-lighting.
+
+10.5.8
+   'macro' is now a built-in primitive function working exactly as described
+   in the macro.lsp module, which is now obsolete. Macros cannot be redefined
+   using 'macro'. Macros can be nested. A symbol used as a macro can only be
+   used as a macro, even if changing the definition of it.
+
+   Another speed improvement for 'read-line' on file handles (the first speed
+   improvement happend in 10.3.10).
+
+10.6.0
+   Eliminated emscripten-lib.c, gets handled by unix-lib.c.
+
+   A fix for 'file?' and 'directory?' predicates when applied to root 
+   directories on Windows.
+
+   Updated examples/udp-server.lsp to nmake it work on Windows.
+
+10.6.1 Development release September 16th, 2014
+   Added typedefs for CPPFunction and CPFuncition to compile on UBUNTU 14.04
+   with libreadline v.6.1.
+
+   Make qa-bigint and qa-bench work for UTF8 versions on all platform locales 
+   by forcing the "C" "." locale  at the beginning.
+
+   Report the result of the 'flt' function on all platforms as an unsigned
+   integer. Previously on 32bit newLISP versions a signed integer was
+   reported and an unsigned integer on 64bit versions.
+
+   'rotate' on (copy str) corrupted memory when using optimized copyCell().
+
+   Delay cell deletion for indexed strings if not referenced by a symbol; 
+   already happens for lists.
+
+   In 'regex' in utf8 versions and when specifying the PCRE_UTF8 parameter
+   - 2048 or "u" - give offset and length in number utf8 characters:
+        (regex "ฮฉ" "ฮจฮฉ") => ("ฮฉ" 2 2)
+        (regex "ฮฉ" "ฮจฮฉ" "u") => ("ฮฉ" 1 1)
+        (regex "ฮฉ" "ฮจฮฉ" 2048) => ("ฮฉ" 1 1)
+
+   A second call pattern for 'copy'
+        (copy <s-expr>)        ; <- original syntax
+        (copy <int-addr> true) ; <- new syntax
+   The new syntax marked by the true 'flag' takes a memory address of a cell 
+   and copies it. The following expressions are equivalent:
+        (copy cell) <=> (copy (first (dump cell)) true)
+
+
+   'get-string' now can take one or two additional optional parameters:
+        (get-string <address>) ; gets an zero terminated ASCII or UTF-8 string
+        (get-string <address> <bytes>) ; gets a buffer of <bytes> of binary data
+        (get-string <address> <max-bytes> <str-limit) ; reads to <str-limit> or max
+
+        The second pattern would work for UTF-32/UCS-4 this way:
+
+        (get-string <address> <max-bytes> "\000\000\000\000")
+
+        Any other string in <str-limit> can be specified to stop reading
+
+        If comparing with \000\000 or \000\000\000\000 comparison is aligned
+        to 2 or 4 byte boundary for specifying UCS-2 or UCS-4 string limits.
+
+    Highest bit of crc32 does should not get sign extended in 32-bit newLISP.
+
+    New function (collect <exp>) collects in a list while <exp> evaluates to
+    not nil:
+        (let (x 0) (collect (if (<= (inc x) 5) x))) => (1 2 3 4 5)
+
+    the int-option parameter in functions using regular expressiona can now be
+    a string for PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, PCRE_EXTENDED
+    PCRE_UTF8, PRECOMPILED using the letters i,m,s,x,u,p.
+    example:    (find "x.z" "abcX\nZ" "is") => 3
+    in functions: directory, ends-with, find, find-all, parse, regex, regex-comp,
+    replace, search and starts-with 
+
+    The protected? function did not recognize macro symbols as protected.
+
+    Cleanup for 64-bit time_t on 32-bit Windows. Thanks Kosh!
+
+    The 'macro?' function also works on 'macro' symbols.
+
+    A wrong UDP option in net-connect and net-listen now throws an error.
+
+    Distribution packages for Linux are now with a newLISP executable compiled
+    for 64-bit.
+
+    In Emscripten v.1.22.0 compiled newLISP exception handling now works.
+
+10.6.2 January 20, 2015
+    When parsing binary, hex, decimal, float and integer numbers, now up to
+    1000 digits are parsed when present. The rest will be read as new token(s).
+    Note that IEEE 754 64-bit doubles distinguish only up to 16 significant 
+    digits. For big integers the 1000 limitation exists only when parseing 
+    source. There is no limit when a result of big integers math exceeds 1000 
+    digits.
+ 
+    Added makefile_bsdLP64_utf8_ffi
+
+    varPrintf() now always avoids printing format strings without args.
+
+    Improve libffi detection with newlisp-x.x.x/configure on RedHat Linux.
+
+    On BSDs if /usr/local/include/ffi.h is present the libffi versions gets
+    compiled when using: ./configure, which is used by default when just
+    issuing: make
+
+    Fixed multi-line shell mode on Windows when comments are present.
+
+    New definition of stuffFloat() to avoid compiler error in p_getFloat()
+    which needed inlining old stuffFloat(). Test using:
+        (get-float (address (get-long (address 17.4)))) => 17.4
+
+    Optional int-max-count parameter for the 'collect' primitive.
+
+    Cacheing crc-table in crc32 function for speedup in repeated use.
+
+    The default print floating point format changed from "%1.15g" to "%1.16g".
+    (can always be user changed using pretty-print function)
+ 
+    A third syntax of 'reset' allows resetting the maximum cell count without
+    restarting the system. The minimum is 4095. Trying to allocate more cells
+    than the minimum allocated makes the program exit.
+
+    When using 'json-parse', null now gets translated to a symbol 'null' in 
+    newLISP not 'nil' as before. So all three JSON values true, false and null 
+    keep their appearance in newLISP symbolic expressions.
+
+    Many small additions and changes to newlisp_manual.html.
+
+10.6.3 July 8th, 2015 Development release
+    Starting with this version only use the TDM-GCC-64 toolchain, it
+    uses mingw32 and can compile for both, 32-bit and 64-bit.
+
+    On some Windows versions negative time value in 'date-list' for dates
+    before 1970-1-1 are not handled by gmtime() and could crash newLISP.
+    Now an error 44 is thrown when gmtime() cannot handle negative values.
+
+    Fixed 'det' and 'mat' for Ubuntu Linux when using wrong dimensions. 
+    Tested on OSX, OpenBSD, FreeBSD Ubuntu Linux, Windows.
+
+    Changes in several files for compiling a 64-bit version for Windows
+    using mingw64. Thanks to Shigeru Kobayashi for doing this work.
+
+    Filenames win32xxx.c change to win-xxx.c.
+
+    The 'dolist' function now also works on arrays. 
+
+    The 'net-eval' functions now return the result of the last expression 
+    in the string argument, not the first.
+        (net-eval host port "(+ 3 4) (* 3 4)" => 12 ; previously 7
+    In previous versions, although all expressions in 'net-eval' would be
+    evaluated, the result of the first was returned. The possibility
+    of multiple expressions in a string was not documented. The new
+    behaviour is more in line with the behaviour of 'eval-string' and
+    'load'.
+
+    Fixed a bug on Windows when APACHE was starting newlisp and no 
+    NEWLISPDIR wnd PROGRAMFILES environment variables were defined.
+
+    New makefiles for Windows: 
+	makefile_mingw64 makefile_mingw64_ffi 
+	makefile_mingw64_utf8 makefile_mingw64_utf8_ffi
+	makefile_mingw64dll makefile_mingw64dll_ffi 
+	makefile_mingw64dll_utf8 makefile_mingw64dll_utf8_ffi
+    are working. Tested using tdm gcc 64 (MinGW based).
+
+    The configure utility now uses the mingw64 makefiles if LLP64 is present.
+    The configure-alt utility still only compiles for 32-bit. 
+
+    Both, 32-bit and 64-bit newLISP on Windows, now have ostype "Windows".
+    In modules canvas.lsp and gsl.lsp ostype has been changed to "Windows"
+    from "Win32". Same change in many qa-* files and web applications.
+
+    C type cleanup for string size_t length in some C-functions.
+
+    Server mode -http did not reject net-eval requests.
+
+    'net-eval' connection timeout changed to 15 secs from 60 secs.
+    Processing timeout still set by user in 'net-eval' parameter.
+
+    Added HTTP_AUTHORIZATION to environment variables in HTTP server.
+   
+    Additional syntax for 'date-value' -> (date-value list-date-time).
+    Additional syntax (date-list) now same as (date-list (date-value)).
+
+    The 'trim' function without trim-char parameters will trim all
+    white-space characters, not only spaces.
+
+    Fixed 'expand' bug when evaluating binding lists.
+
+    'dump' now returns the number of cells dumped not 'true'
+
+    New 'trace' syntax: (trace device-no) prints an evaluation trace to
+    device-no. Example:
+        (trace (open "trace.txt" "w")) ; open trace file (or "a")
+        ... ; one or more expressions to evaluate
+        (trace nil) ; close trace file
+
+    Stack trace in error message changed from function name to full
+    expression.
+
+    tmp directory is now defined on newLISP startup. For UNIX it is /tmp
+    for Windows it is taken from TMP environment variable or assumed /tmp. 
+    This directory is used by the 'share' functions and the built-in http 
+    server.
+
+    When char* in libffi returns 0 (NULL) then an error message will be
+    thrown: "cannot convert NULL to string".
+
+    A new newLISP library call (newlispLibConsole 1) forces console output
+    for stdout instead of writing it to the return string of newlispEvalStr.
+    The same also enables console input on stdin.
+
+    The 'json-parse' function now handles 64-bit number also in 32-bit versions
+    of newLISP.
+
+    Fixed shape sign error in canvas.lsp for bezier curves in shapes.
+
+10.6.4 September 24th, 2015 Development Release
+    Now can retrieve 0-length document with 'get-url'.
+
+    A fix for 'share' on Linux (bug introduced in development v.10.6.3)
+
+    In 'get/put/post-url' the new string option "raw" inhibits 'Location'
+    redirection. "raw" can also be combined with the "list" and "debug" options.
+    When in "list" mode now the server status code is added as a third list
+    member.
+ 
+    Fixed a error date-value introduced in 10.6.3.
+
+    Fixed potential error in my_vasprintf() only used on Windows, OS2, TRU64,
+    Solaris and AIX.
+
+    Avoid calling varargs function sendf() with empty argptr nl-web.c.
+
+    Avoid allocating too much stack space in getPutPostDeleteUrl().
+
+    Response string from 'get/put/post-url' was not zero-terminated for
+    HTTP error returns.
+
+    When a HTTP server returns an error code and also returns content, 
+    the string "ERR: " with the HTTP server response line gets prepended when 
+    not in list mode. This is necessary for compatibility with previous
+    versions, as delete/get/put/post -url always return a string and errors
+    are marked by a beginning "ERR: " of the string. 
+    In list mode the second string in the list contains only the returned content.
+    The third list member is the server HTTP response line. The fourth list
+    member contains the status-code, which is 0 for an invalid HTTP response.
+
+    date-value did not evaluate month, day parameters.
+
+    Last element list optimization now always retained when using pop on the list.
+
+    PCRE options PCRE_NOTBOL, PCRE_NOTEOL and PCRE_NOTEMPTY did not work.
+
+    Expansion 'macro' definitions can be redefined with 'contanst' not 'define'
+    as described in the manual.
+
+    Installation prefix changed from /usr to /usr/local for OSX and other Unix.
+
+    The 'save' function now saves symbols with strings longer 2047 chars 
+    appending multiple partial lines of "," delimited strings of up to 72
+    characters. This allows to \ escape non-displayable  characters, which
+    [text],[/text] delimited text not allows.
+
+    New version 1.7 canvas.lsp fixes ellipse, petal, pie, polygon, shape: 
+    now first fill() then stroke() as in postscript.lsp.
+
+    Loading an empty file should return nil.
+
+    On Mac OS X guiserver expects newlisp in /usr/local/bin/newlisp on all other
+    OS it is only is expected in the executable path, as in previous versions.
+
+10.6.5
+    In the crypto.lsp module "cdecl" must be used when importing on Windows.
+    (since v.10.6.3 a new compiler setup is used)
+
+    A second PRNG with variable initial N for seed initialization
+    via (seed S true N) and inquiry of current seed state via (seed).
+    This PRNG is built-in with same results across all platforms and
+    compilers. The current PRNG will stay as it offers a bigger set of
+    random numbers on Unix platforms. This new PRNG is necessary for doing
+    computer simulations and AI art, which is reproducable across
+    platforms and where random number sequences can be broken up in 
+    repeatable layers using the (seed) instruction to save state. 
+    When using the default libc based PRNG (seed) now returns the last
+    seed set by the programmer. On the new PRNG (seed) returns the last 
+    seed state. - Not yet documented, may replace old PRNG in the future.
+
+    A (ssq vector) sum of squares function has been added. The vector can
+    be either a list or array vector.
+
+    guiserver.jar version 1.65 now correctly forces updates of a gs:canvas
+    in a gs:scroll-pane.
+
+    When a deleted symbol was prefix in a dynamic symbol, memory got corrupted.
+    The dynamic symbol reference is now replaced with nil like other symbol
+    references.
+ 
+    A illegal symbol when trying to create a context could crash the system,
+    when referenced again after the error message.
+
+10.7.0 version 10.6.5 released as stable release January 2016.
+
diff --git a/doc/COPYING b/doc/COPYING
new file mode 100644
index 0000000..22122fa
--- /dev/null
+++ b/doc/COPYING
@@ -0,0 +1,1147 @@
+Copyright information
+---------------------
+
+Source code for this package copyright (c) Lutz Mueller is
+licensed under the "GNU GENERAL PUBLIC LICENSE Version 3, June 2007".
+The text of this license is contained in this file.
+Contact address: lutz@nuevatec.com
+
+Documentation found in this package is licensed under the
+"GNU Free Documentation License Version 1.2, November 2002".
+The text of this license is contained in this file.
+
+All icons and images are copyright (c) Michael Michaels
+under the "GNU GENERAL PUBLIC LICENSE Version 3, June 2007".
+
+Files starting with the letters "pcre" are copyright (c) University 
+of Cambridge. The text of this license is contained in this file.
+
+Code for base-64 conversions from the cURL project is included 
+in nl-web.c and copyright (c) Daniel Stenberg, <daniel@haxx.se>. 
+The text of this license is contained in this file.
+
+The Red-Black Binary Tree in nl-symbol.c is adapted from
+Thomas Niemann: Sorting and Searching Algorithms.
+The text of this license is contained in this file.
+
+The file win32-path.c is copyright (c) Michael Sabin using the
+Zlib license. The text of this license is contained in this file.
+
+
+Following:
+
+- GNU General Public License v. 3
+- GNU Free Documentation License
+- Universiy of Cambridge License
+- Daniel Stenbers, cURL License
+- Thomas Niemann License
+- Michael Sabin, Zlib License
+
+---------------------------------------------------------------------
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+ 
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+  
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+		     END OF TERMS AND CONDITIONS
+
+
+-----------------------------------------------------------------------------
+
+		GNU Free Documentation License
+		  Version 1.2, November 2002
+
+
+ Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+0. PREAMBLE
+
+The purpose of this License is to make a manual, textbook, or other
+functional and useful document "free" in the sense of freedom: to
+assure everyone the effective freedom to copy and redistribute it,
+with or without modifying it, either commercially or noncommercially.
+Secondarily, this License preserves for the author and publisher a way
+to get credit for their work, while not being considered responsible
+for modifications made by others.
+
+This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense.  It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does.  But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book.  We recommend this License
+principally for works whose purpose is instruction or reference.
+
+
+1. APPLICABILITY AND DEFINITIONS
+
+This License applies to any manual or other work, in any medium, that
+contains a notice placed by the copyright holder saying it can be
+distributed under the terms of this License.  Such a notice grants a
+world-wide, royalty-free license, unlimited in duration, to use that
+work under the conditions stated herein.  The "Document", below,
+refers to any such manual or work.  Any member of the public is a
+licensee, and is addressed as "you".  You accept the license if you
+copy, modify or distribute the work in a way requiring permission
+under copyright law.
+
+A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A "Secondary Section" is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject.  (Thus, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.)  The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License.  If a
+section does not fit the above definition of Secondary then it is not
+allowed to be designated as Invariant.  The Document may contain zero
+Invariant Sections.  If the Document does not identify any Invariant
+Sections then there are none.
+
+The "Cover Texts" are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License.  A Front-Cover Text may
+be at most 5 words, and a Back-Cover Text may be at most 25 words.
+
+A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, that is suitable for revising the document
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters.  A copy made in an otherwise Transparent file
+format whose markup, or absence of markup, has been arranged to thwart
+or discourage subsequent modification by readers is not Transparent.
+An image format is not Transparent if used for any substantial amount
+of text.  A copy that is not "Transparent" is called "Opaque".
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML, PostScript or PDF designed for human modification.  Examples of
+transparent image formats include PNG, XCF and JPG.  Opaque formats
+include proprietary formats that can be read and edited only by
+proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML, PostScript or PDF produced by some word
+processors for output purposes only.
+
+The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page.  For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+A section "Entitled XYZ" means a named subunit of the Document whose
+title either is precisely XYZ or contains XYZ in parentheses following
+text that translates XYZ in another language.  (Here XYZ stands for a
+specific section name mentioned below, such as "Acknowledgements",
+"Dedications", "Endorsements", or "History".)  To "Preserve the Title"
+of such a section when you modify the Document means that it remains a
+section "Entitled XYZ" according to this definition.
+
+The Document may include Warranty Disclaimers next to the notice which
+states that this License applies to the Document.  These Warranty
+Disclaimers are considered to be included by reference in this
+License, but only as regards disclaiming warranties: any other
+implication that these Warranty Disclaimers may have is void and has
+no effect on the meaning of this License.
+
+
+2. VERBATIM COPYING
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License.  You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute.  However, you may accept
+compensation in exchange for copies.  If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+
+3. COPYING IN QUANTITY
+
+If you publish printed copies (or copies in media that commonly have
+printed covers) of the Document, numbering more than 100, and the
+Document's license notice requires Cover Texts, you must enclose the
+copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover.  Both covers must also clearly and legibly identify
+you as the publisher of these copies.  The front cover must present
+the full title with all words of the title equally prominent and
+visible.  You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a computer-network location from which the general network-using
+public has access to download using public-standard network protocols
+a complete Transparent copy of the Document, free of added material.
+If you use the latter option, you must take reasonably prudent steps,
+when you begin distribution of Opaque copies in quantity, to ensure
+that this Transparent copy will remain thus accessible at the stated
+location until at least one year after the last time you distribute an
+Opaque copy (directly or through your agents or retailers) of that
+edition to the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+
+4. MODIFICATIONS
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it.  In addition, you must do these things in the Modified Version:
+
+A. Use in the Title Page (and on the covers, if any) a title distinct
+   from that of the Document, and from those of previous versions
+   (which should, if there were any, be listed in the History section
+   of the Document).  You may use the same title as a previous version
+   if the original publisher of that version gives permission.
+B. List on the Title Page, as authors, one or more persons or entities
+   responsible for authorship of the modifications in the Modified
+   Version, together with at least five of the principal authors of the
+   Document (all of its principal authors, if it has fewer than five),
+   unless they release you from this requirement.
+C. State on the Title page the name of the publisher of the
+   Modified Version, as the publisher.
+D. Preserve all the copyright notices of the Document.
+E. Add an appropriate copyright notice for your modifications
+   adjacent to the other copyright notices.
+F. Include, immediately after the copyright notices, a license notice
+   giving the public permission to use the Modified Version under the
+   terms of this License, in the form shown in the Addendum below.
+G. Preserve in that license notice the full lists of Invariant Sections
+   and required Cover Texts given in the Document's license notice.
+H. Include an unaltered copy of this License.
+I. Preserve the section Entitled "History", Preserve its Title, and add
+   to it an item stating at least the title, year, new authors, and
+   publisher of the Modified Version as given on the Title Page.  If
+   there is no section Entitled "History" in the Document, create one
+   stating the title, year, authors, and publisher of the Document as
+   given on its Title Page, then add an item describing the Modified
+   Version as stated in the previous sentence.
+J. Preserve the network location, if any, given in the Document for
+   public access to a Transparent copy of the Document, and likewise
+   the network locations given in the Document for previous versions
+   it was based on.  These may be placed in the "History" section.
+   You may omit a network location for a work that was published at
+   least four years before the Document itself, or if the original
+   publisher of the version it refers to gives permission.
+K. For any section Entitled "Acknowledgements" or "Dedications",
+   Preserve the Title of the section, and preserve in the section all
+   the substance and tone of each of the contributor acknowledgements
+   and/or dedications given therein.
+L. Preserve all the Invariant Sections of the Document,
+   unaltered in their text and in their titles.  Section numbers
+   or the equivalent are not considered part of the section titles.
+M. Delete any section Entitled "Endorsements".  Such a section
+   may not be included in the Modified Version.
+N. Do not retitle any existing section to be Entitled "Endorsements"
+   or to conflict in title with any Invariant Section.
+O. Preserve any Warranty Disclaimers.
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant.  To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section Entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version.  Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity.  If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+
+5. COMBINING DOCUMENTS
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice, and that you preserve all their Warranty Disclaimers.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy.  If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections Entitled "History"
+in the various original documents, forming one section Entitled
+"History"; likewise combine any sections Entitled "Acknowledgements",
+and any sections Entitled "Dedications".  You must delete all sections
+Entitled "Endorsements".
+
+
+6. COLLECTIONS OF DOCUMENTS
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+
+7. AGGREGATION WITH INDEPENDENT WORKS
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, is called an "aggregate" if the copyright
+resulting from the compilation is not used to limit the legal rights
+of the compilation's users beyond what the individual works permit.
+When the Document is included in an aggregate, this License does not
+apply to the other works in the aggregate which are not themselves
+derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one half of
+the entire aggregate, the Document's Cover Texts may be placed on
+covers that bracket the Document within the aggregate, or the
+electronic equivalent of covers if the Document is in electronic form.
+Otherwise they must appear on printed covers that bracket the whole
+aggregate.
+
+
+8. TRANSLATION
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections.  You may include a
+translation of this License, and all the license notices in the
+Document, and any Warranty Disclaimers, provided that you also include
+the original English version of this License and the original versions
+of those notices and disclaimers.  In case of a disagreement between
+the translation and the original version of this License or a notice
+or disclaimer, the original version will prevail.
+
+If a section in the Document is Entitled "Acknowledgements",
+"Dedications", or "History", the requirement (section 4) to Preserve
+its Title (section 1) will typically require changing the actual
+title.
+
+
+9. TERMINATION
+
+You may not copy, modify, sublicense, or distribute the Document except
+as expressly provided for under this License.  Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License.  However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+
+10. FUTURE REVISIONS OF THIS LICENSE
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time.  Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.  See
+http://www.gnu.org/copyleft/.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation.  If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+
+
+ADDENDUM: How to use this License for your documents
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+    Copyright (c)  YEAR  YOUR NAME.
+    Permission is granted to copy, distribute and/or modify this document
+    under the terms of the GNU Free Documentation License, Version 1.2
+    or any later version published by the Free Software Foundation;
+    with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
+    A copy of the license is included in the section entitled "GNU
+    Free Documentation License".
+
+If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
+replace the "with...Texts." line with this:
+
+    with the Invariant Sections being LIST THEIR TITLES, with the
+    Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+
+If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
+
+---------------------------------------------------------------------
+
+           Copyright (c) 1997-2004 University of Cambridge
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+-----------------------------------------------------------------------------
+
+Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
+
+This software is licensed as described in the file COPYING, which
+you should have received as part of this distribution. The terms
+are also available at http://curl.haxx.se/docs/copyright.html.
+
+You may opt to use, copy, modify, merge, publish, distribute and/or sell
+copies of the Software, and permit persons to whom the Software is
+furnished to do so, under the terms of the COPYING file.
+
+This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+KIND, either express or implied.
+
+$Id: base64.c,v 1.32 2004/12/15 01:38:25 danf Exp $
+
+-----------------------------------------------------------------------------
+
+Thomas Niemann: Sorting and Searching Algorithms
+
+http://epaperpress.com/sortsearch/index.html
+
+Permission to reproduce portions of this document is given provided the web 
+site listed below is referenced, and no additional restrictions apply. Source 
+code, when part of a software project, may be used freely without reference 
+to the author. 
+  
+Thomas Niemann 
+Portland,  Oregon 
+epaperpress.com
+
+-----------------------------------------------------------------------------
+
+Copyright (C) 2007,2008,2010 Michael Sabin
+
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+-----------------------------------------------------------------------------
diff --git a/doc/CREDITS b/doc/CREDITS
new file mode 100644
index 0000000..b4eef45
--- /dev/null
+++ b/doc/CREDITS
@@ -0,0 +1,173 @@
+CREDITS
+-------
+
+Over the years many users have contributed to newLISP with suggestions,
+critiques and code. They were crucial in making newLISP what it is today.
+I want to thank everybody and encourage them to continue
+to contribute with code and comments. My special thanks go to
+(in historical order):
+
+Steve Adams 
+  Did the first CYGWIN port and the new native Win32 ports, suggested many
+  other features and functions found today in newLISP.
+
+Stellan Borg 
+  Some of the string functions where suggested by him, discovered and
+  prompted the fixing of many shortcomings in newLISP, built first
+  commercial product (the knowledge manager SUCCEED tm) based on newLISP.
+
+Lars Hard
+  Many insights and ideas (where are you?, I want to contact you).
+
+Ryon Root
+  Set up and maintains the web board for discussing newLISP at
+  http://www.alh.net/newlisp/phpbb/index.php .
+
+Eddie Rucker
+  His comments, insights and ideas have prompted many changes and additions
+  since the Unix versions of newLISP have appeared in 2001.
+
+Hans Peter Wickern
+  Many usability suggestions and newlisp-tk.tcl improvements. Hans-Peter
+  also introduced newLISP to many NeoBook and PowerBasic users and has
+  written various DLLs which can be imported by newLISP on the Win32
+  platform: http://hpwsoft.de/anmeldung/html1/newLISP/newLISP.html .
+
+Nigel Brown
+  Helped making floating point behaviour consistent across platforms, 
+  researched the use of setlocale(), triggered bugfixes and changes in
+  math functions and contributed many other suggestions, which
+  helped to improve newLISP.
+
+Keith Trenton
+  Helped initiating the documentation thread on the discussion board. Since
+  that time many useres have pointed out errors in the documentation and
+  suggested improvements.
+
+Samuel CoX
+  Pointed out many flaws in the documentation, prompted addition of atan2
+  and contributed code examples.
+
+Brian Clausing
+  did the first complete pass through the manual taking care not only of
+  spelling and punctuation but also improving style.
+
+Norman Deppenbroek and Peter van Eerten, http://gtk-server.org
+  both from the GTK-server project helped improving networking functions.
+  Peter's GTK-server is an alternative to Tcl/Tk when doing platform
+  independent GUIs or graphics with newLISP.
+  Norman has contributed many useful newISP command line utilities
+  for the Internet and other usages http://www.nodep.nl/newlisp/.  
+
+David S. de Lis from http://www.geocities.com/excaliborus/
+  contributed the newlisp.vim file for VIM editor syntax highlighting
+  now part of the newLISP source distribution
+
+Luis Carvalho (Kozure) ported newLISP to the PocketPC running Win CE
+  using Alexander Mamaich's pocket gcc, a port of gcc for ARM cpu based
+  PocketPC, http://mamaich.kasone.com/fr_pocket.htm.
+
+John Small
+  initiated the advancement of logical programming in newLISP and contributed
+  many scripts showing how to use newLISP macros. He also wrote the popular
+  introduction "newLISP in 21 minutes"
+
+Greg Ben
+  contributed an account and space on a Sun Sparc workstation for better
+  development and testing on the Sun Solaris platform.
+
+Lucas Wix
+  developed the first newlisp.jsf syntax file for the Joe editor
+  now part of the newLISP source distribution
+
+Tim Johnson
+  developed the first syntax file for Emacs.
+
+John DeSanto, Gordon Fischer, John Flowers, Martin Quiroga (alphabetical order)
+  from Kozoru.com for their ideas and suggestions for improvements and enhancements
+  of the newLISP language and improvements and work-out of the database libraries
+  sqlite.lsp (Flowers) and mysql.lsp (Fischer). In June 2006 Kozoru released
+  http://byoms.com, a distributed application almost entirely built with newLISP. 
+
+Cormullion cormullion@mac.com, http://unbalanced-parentheses.nfshost.com
+  for evangelizing newLISP on the MacOS X platform and publishing many ideas
+  how to use newLISP on that platform and writing the "Introduction to newLISP"
+
+Michael and Melissa Michaels, http://www.neglook.com
+  for a complete review of the Users Manual and evangelizing efforts for newLISP
+  and other good ideas, i.e. defaults in argument lists: (define (foo x (y 1)) ...) 
+  Michael also designed the icons for newLISP-GS in v9.2 and much of the FOOP system 
+  released in 9.3 and has released a series of training videos.
+
+Bob Bae (aka frontera000, http://sparebandwidth.blogspot.com/)
+  bringing many ideas to the advancement of newLISP and actively advocating for
+  newLISP on his and other peoples blogs.
+
+Jeremy Dunn
+  introduced the idea of default args for several operators i.e. (> x) => (> x 0)
+  and for (>> x) => (>> x 1), (div x) => (div 1 x) ... and suggestions.
+
+Michael Sabin
+  contributed UTF-16 capable file and directory routines for the Win32 versions.
+
+Dmitri Cherniak from http://en.feautec.pp.ru/
+  many ideas for the newLISP API and big contributor of newLISP expansion
+  modules.
+
+Cyril Slobin from http://wagner.pp.ru/~slobin/
+  contributed a new newlisp.vim syntax-highlighing file for the vim editor.
+
+Kazimir Majorinc from http://kazimirmajorinc.blogspot.com/
+  has contributed many ideas and has helped to make newLISP known through his
+  thoughtful blog posts.
+
+Jeff Ober from http://www.artfulcode.net/
+  many of his ideas and comments have improved newLISP. On his blog a variety 
+  of interesting and useful code examples and modules can be found.
+
+Ted Walther from http://reactor-core.org/~djw/
+  helped to improve the build process.
+
+Joh from http://johu02.spaces.live.com/default.aspx and http://johu02.wordpress.com/
+  did a  thorough pass through the manual correcting many erros. His website  
+  and his Japanese translations of the reference manual and other documentation
+  help to make newLISP popular in Japan.
+
+Stefan Sonnenberg implemented the extended libffi based API for the import
+  and callback functions starting version 10.3.8. This has opened the door
+  to connect to many C-libraries, which were not accessible before.
+  
+Shigeru Kobayashi contributed newLISP modules for Emacs, Curl and fixed various
+  bugs in the newLISP C-source code. He also made many contributions to Windows
+  specific code. He prepared the first 64-bit compilation for Windows.
+
+------------------------- other contributors, sources ----------------------------
+Phillip Hazel
+  wrote the PCRE (Perl Regular Expressions) library, it is an essential
+  part of newLISP and many other scripting languages and Open Source applications
+  (i.e. Apache)
+
+Jorge Acereda and Peter O'Gorman
+  wrote dyna link library functions for OSX which are used in this project,
+  their files osx-dlfcn.c/.h were necessary on pre 10.3 versions of MacOSX
+  (functionality/code? now part of OS X since 10.3)
+
+Daniel Stenberg
+  from the cURL project, newLISP adapted the base64 encoding and decoding routines
+
+Thomas Niemannn
+  wrote a red-black binary tree algorithm used in newLISP with modifications.
+
+Sourceforge.net
+  Has helped newLISP and many other Open Source projects to get more visibility,
+  the newLISP project enjoys their compile farm to port newLISP to other platforms
+
+Richard M. Stallman
+  GCC and many other GNU - tools make it possible to write platform independent
+  software for many OSs and hardware platforms. The GNU Public License is the 
+  strongest force in the open source movement from which newLISP has benefited.
+
+My apologies to anybody, who has been forgotten on this list (let me know).
+
+                                  +++
+
diff --git a/doc/CodePatterns.html b/doc/CodePatterns.html
new file mode 100644
index 0000000..14b10e1
--- /dev/null
+++ b/doc/CodePatterns.html
@@ -0,0 +1,4349 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+   <meta name="author" content="Lutz Mueller"/>
+   <meta name="keywords" 
+         content="newLISP LISP SCHEME programming language manual reference Artificial Intelligence AI NUEVATEC"/>
+   <meta name="description" content="newLISP Code Patterns"/>
+   <title>newLISP Code Patterns</title>
+
+<style type="text/css" media="screen">
+
+<!--
+
+.title {
+    font-family:Optima, Georgia, Times New Roman, Times, serif; 
+    font-size:300%;
+    font-weight: 500;
+	color: #404040;
+    }
+
+body, h4, p {
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+	color: #404040;
+	}
+
+h1, h2, h3 {
+	margin-top: 3%;
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+    font-weight: 300;
+	color: #202020;
+    }
+
+table {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: solid;
+	border-width: 0px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+	font-size: 95%;
+    }
+    
+th {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #eeeeee;
+    font-size: 100%;
+    }
+    
+td {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+    font-size: 100%;
+    }
+    
+pre {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: dashed;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 4px;
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 90%;
+	background: #f8ffff;
+    }
+
+tt {
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 100%;
+    }
+    
+-->
+</style>
+</head>
+<body style="margin: 20px;" text="#000000" bgcolor="#FFFFFF" link="#376590" vlink="#551A8B" alink="#ffAA28">
+
+<br/><br/>
+
+<center>
+<h1 class="title">Code Patterns in newLISP<font size="-1">&#174;</font>
+</h1>Version 2015 July 11<sup>th</sup><br/>
+<a href="http://newlisp.org">newLISP</a> v.10.6.4
+</center>
+
+<br/><br/><br/>
+
+<center>
+<span style="line-height:80%;">
+<font size="-2">
+Copyright &copy; 2015 Lutz Mueller, <a href="http://www.nuevatec.com">www.nuevatec.com</a>. All rights reserved.<br/>
+Permission is granted to copy, distribute and/or modify this document under the terms of the <a href="#GFDL">GNU Free Documentation License</a>,<br/>
+Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts,<br/>
+and no Back-Cover Texts. A copy of the license is included in the section entitled GNU Free Documentation License.<br/>
+<br/>
+newLISP is a registered trademark of Lutz Mueller.
+</font>
+</span>
+</center>
+
+
+<ul>
+<li><a href="#toc-1">1. Introduction</a>
+</li>
+<li><a href="#toc-2">2. newLISP script files</a>
+  <ul>
+  <li>Command line options</li>
+  <li>Scripts as pipes</li>
+  <li>File filters</li>
+  </ul></li>
+<li><a href="#toc-3">3. Writing software in modules</a>
+  <ul>
+  <li>Structuring an application</li>
+  <li>More than one context per file</li>
+  <li>The default function</li>
+  <li>Packaging data with contexts</li>
+  <li>Passing objects by reference</li>
+  </ul></li>
+<li><a href="#toc-4">4. Local variables</a>
+  <ul>
+  <li>Locals in looping functions</li>
+  <li>Locals in <tt>let</tt>, <tt>letn</tt>, <tt>local</tt> and <tt>letex</tt></li>
+  <li>Unused parameters as locals</li>
+  <li>Default variable values</li>
+  <li><tt>args</tt> as local substitute</li>
+  <li><tt>args</tt> and <tt>local</tt> used together for named variables</li>
+  </ul></li>
+<li><a href="#toc-5">5. Walking through lists and data</a>
+  <ul>
+  <li>Recursion or iteration?</li>
+  <li>Speed up with memoization</li>
+  <li>Walking a tree</li>
+  <li>Walking a directory tree</li>
+  </ul></li>
+<li><a href="#toc-6">6. Modifying and searching lists</a>
+  <ul>
+  <li><tt>push</tt> and <tt>pop</tt></li>
+  <li>Extend using <tt>extend</tt></li>
+  <li>Accessing lists</li>
+  <li>Selecting more elements</li>
+  <li>Filtering and differencing lists</li>
+  <li>Changing list elements</li>
+  <li>The anaphoric variable</li>
+  <li>Replace in simple lists</li>
+  <li>Replace in nested lists</li>
+  <li>Passing lists by reference</li>
+  <li>Variable expansion</li>
+  <li>Destructuring nested lists</li>
+  </ul></li>
+<li><a href="#toc-7">7. Program flow</a>
+  <ul>
+  <li>Loops</li>
+  <li>Blocks</li>
+  <li>Branching</li>
+  <li>Fuzzy flow</li>
+  <li>Flow with <tt>catch</tt> and <tt>throw</tt></li>
+  <li>Leave loops with a break condition</li>
+  <li>Change flow with <tt>and</tt> or <tt>or</tt></li>
+  </ul></li>
+<li><a href="#toc-8">8. Error handling</a>
+  <ul>
+  <li>newLISP errors</li>
+  <li>User defined errors</li>
+  <li>Error event handlers</li>
+  <li>Catching errors</li>
+  <li>Operating system errors</li>
+  </ul></li>
+<li><a href="#toc-9">9. Functions as data</a>
+  <ul>
+  <li>Manipulate after definition</li>
+  <li>Mapping and applying</li>
+  <li>Functions making functions</li>
+  <li>Functions with memory</li>
+  <li>Functions using self modifying code</li>
+  </ul></li>
+<li><a href="#toc-10">10. Text processing</a>
+  <ul>
+  <li>Regular expressions</li>
+  <li>Scanning text</li>
+  <li>Appending strings</li>
+  <li>Growing strings in place</li>
+  <li>Rearranging strings</li>
+  <li>Modifying strings</li>
+  </ul></li>
+<li><a href="#toc-11">11. Dictionaries and hashes</a>
+  <ul>
+  <li>Hash-like key โ†’ value access</li>
+  <li>Saving and loading dictionaries</li>
+  </ul></li>
+<li><a href="#toc-12">12. TCP/IP client server</a>
+  <ul>
+  <li>Open connection</li>
+  <li>Closed transaction</li>
+  </ul></li>
+<li><a href="#toc-13">13. UDP communications</a>
+  <ul>
+  <li>Open connection</li>
+  <li>Closed transaction</li>
+  <li>Multi-cast communications</li>
+  </ul></li>
+<li><a href="#toc-14">14. Non-blocking communications</a>
+  <ul>
+  <li>Using <tt>net-select</tt></li>
+  <li>Using <tt>net-peek</tt></li>
+  </ul></li>
+<li><a href="#toc-15">15. Controlling other applications</a>
+  <ul>
+  <li>Using <tt>exec</tt></li>
+  <li>STD I/O pipes</li>
+  <li>Communicate via TCP/IP</li>
+  <li>Communicate via named FIFO</li>
+  <li>Communicate via UDP</li>
+  </ul></li>
+<li><a href="#toc-16">16. Launching apps blocking</a>
+  <ul>
+  <li>Shell execution</li>
+  <li>Capturing std-out</li>
+  <li>Feeding std-in</li>
+  </ul></li>
+<li><a href="#toc-17">17. Semaphores, shared memory</a>
+</li>
+<li><a href="#toc-18">18. Multiprocessing and Cilk</a>
+  <ul>
+  <li>Starting concurrent processes</li>
+  <li>Watching progress</li>
+  <li>Invoking spawn recursively</li>
+  <li>Event driven notification</li>
+  </ul></li>
+<li><a href="#toc-19">19. Message exchange</a>
+  <ul>
+  <li>Blocking message sending and receiving</li>
+  <li>Blocking message exchange</li>
+  <li>Non blocking message exchange</li>
+  <li>Message timeouts</li>
+  <li>Evaluating messages</li>
+  <li>Acting as a proxy</li>
+  </ul></li>
+<li><a href="#toc-20">20. Databases and lookup tables</a>
+  <ul>
+  <li>Association lists</li>
+  <li>Nested associations</li>
+  <li>Updating nested associations</li>
+  <li>Combining associations and hashes</li>
+  </ul></li>
+<li><a href="#toc-21">21. Distributed computing</a>
+  <ul>
+  <li>Setting up in server mode</li>
+  <li>Start a state-full server</li>
+  <li>Stateless server with inetd</li>
+  <li>Test the server with telnet</li>
+  <li>Test with netcat on Unix</li>
+  <li>Test from the command line</li>
+  <li>Test HTTP with a browser</li>
+  <li>Evaluating remotely</li>
+  <li>Setting up the <tt>net-eval</tt> parameter structure</li>
+  <li>Transferring files</li>
+  <li>Loading and saving data</li>
+  <li>Local domain Unix sockets</li>
+  </ul></li>
+<li><a href="#toc-22">22. HTTPD web server only mode</a>
+  <ul>
+  <li>Environment variables</li>
+  <li>Pre-processing the request</li>
+  <li>CGI processing in HTTP mode</li>
+  <li>Media types in HTTP modes</li>
+  </ul></li>
+<li><a href="#toc-23">23. Extending newLISP</a>
+  <ul>
+  <li>Simple versus extended FFI interface</li>
+  <li>A shared library in C</li>
+  <li>Compile on Unix</li>
+  <li>Compile a DLL on MS Windows</li>
+  <li>Importing data structures</li>
+  <li>Memory management</li>
+  <li>Unevenly aligned structures</li>
+  <li>Passing parameters</li>
+  <li>Extracting return values</li>
+  <li>Writing library wrappers</li>
+  <li>Registering callbacks in external libraries</li>
+  </ul></li>
+<li><a href="#toc-24">24. newLISP as a shared library</a>
+  <ul>
+  <li>Evaluating code in the shared library</li>
+  <li>Registering callbacks</li>
+  </ul></li>
+</ul>
+<br/><br/>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-1"></a>
+<h2>1. Introduction</h2>
+
+<p>When programming in newLISP, certain functions and usage patterns occur repeatedly. For some problems, an optimal way to solve them evolves over time. The following chapters present example code and explanations for the solution of specific problems when programming in newLISP.</p>
+
+<p>Some content is overlapping with material covered in the newLISP Users Manual and Reference or presented here with a different slant.</p>
+
+<p>Only a subset of newLISP's total function repertoire is used here. Some functions demonstrated have additional calling patterns or applications not mentioned on these pages.</p>
+
+<p>This collection of patterns and solutions is a work in progress. Over time, material will be added or existing material improved.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-2"></a>
+<h2>2. newLISP script files</h2>
+
+<h3>Command line options</h3>
+
+<p>On Linux/Unix, put the following in the first line of the script/program file:</p>
+
+<pre>
+#!/usr/bin/newlisp
+</pre>
+
+<p>specifying a bigger stack:</p>
+
+<pre>
+#!/usr/bin/newlisp -s 100000
+</pre>
+
+<p>or</p>
+
+<pre>
+#!/usr/bin/newlisp -s100000
+</pre>
+
+<p>Operating systems' shells behave differently when parsing the first line and extracting parameters. newLISP takes both attached or detached parameters. Put the following lines in small script to test the behavior of the underlying OS and platform. The script changes the stack size allocated to 100,000 and limits newLISP cell memory to about 10 M bytes.</p>
+
+<pre>
+#!/usr/bin/newlisp -s 100000 -m 10
+     
+(println (main-args))
+(println (sys-info))
+
+(exit) ; important
+</pre>
+
+<p>A typical output executing the script from the system shell would be:</p>
+
+<pre>
+./arg-test
+     
+("/usr/bin/newlisp" "-s" "100000" "-m" "10" "./arg-test")
+(308 655360 299 2 0 100000 8410 2)
+</pre>
+
+<p>Note that few programs in newLISP need a bigger stack configured; most programs run on the internal default of 2048. Each stack position takes an average of 80 bytes. Other options are available to start newLISP. See the Users Manual for details.</p>
+
+<h3>Scripts as pipes</h3>
+
+<p>The following example shows how a file can be piped into a newLISP script. </p>
+
+<pre>
+#!/usr/bin/newlisp
+#
+# uppercase - demo filter script as pipe
+#
+# usage:
+#          ./uppercase &lt; file-spec
+#
+# example:
+#          ./uppercase &lt; my-text
+#
+#
+     
+(while (read-line) (println (upper-case (current-line))))
+     
+(exit)
+</pre>
+
+<p>The file will be printed to <tt>std-out</tt> translated to uppercase.</p>
+
+<p>The following program would also work with binary non-textual information
+containing <tt>0</tt>'s :</p>
+
+<pre>
+#!/usr/bin/newlisp
+;
+; inout - demo binary pipe
+;
+; read from stdin into buffer
+; then write to stdout
+;
+; usage: ./inout < inputfile > outputfile
+;
+
+(while (read 0 buffer 1024)
+    (write 1 buffer 1024))
+
+(exit)
+</pre>
+
+<p>Set buffersize to best performance.</p>
+
+
+<h3>File filters</h3>
+
+<p>The following script works like a Unix <tt>grep</tt> utility iterating through files and filtering each line in a file using a regular expression pattern.</p>
+
+<pre>
+#!/usr/bin/newlisp
+#
+# nlgrep - grep utility on newLISP
+#
+# usage:
+#          ./nlgrep "regex-pattern" file-spec
+#
+# file spec can contain globbing characters
+#
+# example:
+#          ./nlgrep "this|that" *.c
+#
+# will print all lines containing 'this' or 'that' in *.c files
+#
+     
+(dolist (fname (3 (main-args)))
+    (set 'file (open fname "read"))
+    (println "file ---&gt; " fname)
+    (while (read-line file)
+        (if (find (main-args 2) (current-line) 0)
+            (write-line)))
+    (close file))
+    
+(exit)
+</pre>
+
+<p>The expression:</p>
+
+<pre>
+(3 (main-args))
+</pre>
+
+<p>is a short form of writing:</p>
+
+<pre>
+(rest (rest (rest (main-args))))
+</pre>
+
+<p>It returns a list of all the filenames. This form of specifying indexes for rest is called implicit indexing. See the Users Manual for implicit indexing with other functions. The expression <tt>(main-args 2)</tt> extracts the 3rd argument from the command line containing the regular expression pattern.</p>
+
+<h3>newLISP as a pipe</h3>
+
+<p>Pipe one-liners directly into the executable for evaluation of short expressions:</p>
+
+<pre>
+~&gt; echo '(+ 1 2 3)' | newlisp
+6
+~&gt; 
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-3"></a>
+<h2>3. Writing software in modules</h2>
+
+<h3>Structuring an application</h3>
+
+<p>When writing bigger applications or when several programmers are working on the same code base, it is necessary to divide the code base into modules. Modules in newLISP are implemented using contexts, which are namespaces. Namespaces allow lexical isolation between modules. Variables of the same name in one module cannot clash with variables of the same name in another module.</p>
+
+<p>Typically, modules are organized in one context per file. One file module may contain database access routines.</p>
+
+<pre>
+; database.lsp
+;
+(context 'db)
+   
+   
+(define (update x y z)
+...
+)
+   
+(define (erase x y z)
+...
+)
+</pre>
+
+<p>Another module may contain various utilities</p>
+
+<pre>
+; auxiliary.lsp
+;
+(context 'aux)
+ 
+(define (getval a b)
+...
+)
+</pre>
+
+<p>Typically, there will be one MAIN module that loads and controls all others:</p>
+
+<pre>
+; application.lsp
+;
+   
+(load "auxiliary.lsp")
+(load "database.lsp")
+   
+(define (run)
+    (db:update ....)
+    (aux:putval ...)
+    ...
+    ...
+)
+   
+(run)
+</pre>
+
+<h3>More than one context per file</h3>
+
+<p>When using more than one context per file, each context section should be closed with a <tt>(context MAIN)</tt> statement:</p>
+
+<pre>
+; myapp.lsp
+;
+(context 'A)
+   
+(define (foo ...) ...)
+   
+(context MAIN)
+   
+(context 'B)
+   
+(define (bar ...) ...)
+   
+(context MAIN)
+   
+(define (main-func)
+    (A:foo ...)
+    (B:bar ...)
+)
+</pre>
+
+<p>Note that in the namespace statements for contexts <tt>A</tt> and <tt>B</tt> that the context names are quoted because they are newly created, but <tt>MAIN</tt> can stay unquoted because it already exists when newLISP starts up. However, quoting it does not present a problem.</p>
+
+<p>The line <tt>(context MAIN)</tt> that closes a context can be omitted by using the following technique:</p>
+
+<pre>
+; myapp.lsp
+;
+(context 'A)
+   
+(define (foo ...) ...)
+   
+(context 'MAIN:B)
+   
+(define (bar ...) ...)
+   
+(context 'MAIN)
+   
+(define (main-func)
+    (A:foo ...)
+    (B:bar ...)
+)
+</pre>
+
+<p>The line <tt>(context 'MAIN:B)</tt> switches back to MAIN then opens the new context <tt>B</tt>.</p>
+
+<h3>The default function</h3>
+
+<p>A function in a context may have the same name as the host context itself. This function has special characteristics:</p>
+
+<pre>
+(context 'foo)
+  
+(define (foo:foo a b c)
+...
+)
+</pre>
+
+<p>The function <tt>foo:foo</tt> is called the <tt>default function</tt>, because when using the context name <tt>foo</tt> like a function, it will default to <tt>foo:foo</tt></p>
+
+<pre>
+(foo x y z)
+; same as
+(foo:foo x y z)
+</pre>
+
+<p>The default function makes it possible to write functions which look like normal functions but carry their own lexical namespace. We can use this to write functions which keep state:</p>
+
+<pre>
+(context 'generator)
+   
+(define (generator:generator)
+    (inc acc)) ; when acc is nil, assumes 0
+ 
+(context MAIN)
+   
+(generator) โ†’ 1
+(generator) โ†’ 2
+(generator) โ†’ 3
+</pre>
+
+<p>The following is a more complex example for a function generating a Fibonacci sequence:</p>
+
+<pre>
+(define (fibo:fibo)
+    (if (not fibo:mem) (set 'fibo:mem '(0 1)))
+    (last (push (+ (fibo:mem -1) (fibo:mem -2)) fibo:mem -1)))
+   
+(fibo) โ†’ 1
+(fibo) โ†’ 2
+(fibo) โ†’ 3
+(fibo) โ†’ 5
+(fibo) โ†’ 8
+...
+</pre>
+
+<p>This example also shows how a default function is defined <tt>on-the-fly</tt> without the need of explicit <tt>context</tt> statements. As an alternative, the function could also have been written so that the context is created explicitly:</p>
+
+<pre>
+(context 'fibo)
+(define (fibo:fibo)
+        (if (not mem) (set 'mem '(0 1)))
+        (last (push (+ (mem -1) (mem -2)) mem -1)))
+(context MAIN)
+  
+(fibo) โ†’ 1
+(fibo) โ†’ 2
+(fibo) โ†’ 3
+(fibo) โ†’ 5
+(fibo) โ†’ 8
+</pre>
+
+<p>Although the first form is shorter, the second form is more readable.</p>
+
+<h3>Packaging data with contexts</h3>
+
+<p>The previous examples already presented functions packaged with data in a namespace. In the <tt>generator</tt> example the <tt>acc</tt> variable kept state. In the <tt>fibo</tt> example the variable <tt>mem</tt> kept a growing list. In both cases, functions and data are living together in a namespace. The following example shows how a namespace holds only data in a default functor:</p>
+
+<pre>
+(set 'db:db '(a "b" (c d) 1 2 3 x y z))
+</pre>
+
+<p>Just like we used the default function to refer to <tt>fibo</tt> and <tt>generator</tt> we can refer to the list in <tt>db:db</tt> by only using <tt>db</tt>. This will work in all situations where we do list indexing:</p>
+
+<pre>
+(db 0)    โ†’ a
+(db 1)    โ†’ "b"
+(db 2 1)  โ†’ d
+(db -1)   โ†’ z
+(db -3)   โ†’ x
+   
+(3 db)    โ†’ (1 2 3 x y z)
+(2 1 db)  โ†’ ((c d))
+(-6 2 db) โ†’ (1 2)
+</pre>
+
+<h3>Passing objects by reference</h3>
+
+<p>When the default functor is used as an argument in a user defined function, the default functor is passed by reference. This means that a reference to the original contents is passed, not a copy of the list or string. This is useful when handling large lists or strings:</p>
+
+<pre>
+(define (update data idx expr)
+    (if (not (or (lambda? expr) (primitive? expr)))
+        (setf (data idx) expr)
+        (setf (data idx) (expr $it))))
+   
+(update db 0 99) โ†’ a
+db:db โ†’ (99 "b" (c d) 1 2 3 x y z)
+   
+(update db 1 upper-case) โ†’ "b"
+db:db โ†’ (99 "B" (c d) 1 2 3 x y z)
+   
+(update db 4 (fn (x) (mul 1.1 x))) โ†’
+db:db โ†’ (99 "B" (c d) 1 2.2 3 x y z)
+</pre>
+
+<p>The data in <tt>db:db</tt> is passed via the <tt>update</tt> function parameter <tt>data</tt>, which now holds a reference to the context <tt>db</tt>. The <tt>expr</tt> parameter passed is checked to determine if it is a built-in function, operator or a user defined lambda expression and then works on <tt>$it</tt>, the anaphoric system variable containing the old content referenced by <tt>(data idx)</tt>.</p>
+
+<p>Whenever a function in newLISP asks for a string or list in a parameter, a default functor can be passed by its context symbol. Another example:</p>
+
+<pre>
+(define (pop-last data)
+(pop data -1))
+   
+(pop-last db) โ†’ z
+   
+db:db         โ†’ (99 "B" (c d) 1 2.2 3 x y)
+</pre>
+
+<p>The function <tt>update</tt> is also a good example of how to pass operators or functions as a function argument (<tt>upper-case</tt> working on <tt>$it</tt>). Read more about this in the chapter <a href="#toc-9">Functions as data</a>.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-4"></a>
+<h2>4. Local variables</h2>
+
+<h3>Locals in looping functions</h3>
+
+<p>All looping functions like <tt>doargs</tt>, <tt>dolist</tt>, <tt>dostring</tt>, <tt>dotimes</tt>, <tt>dotree</tt> and <tt>for</tt> use local variables. During loop execution, the variable takes different values. But after leaving the looping function, the variable regains its old value. <tt>let</tt>, <tt>define</tt>, and <tt>lambda</tt> expressions are another method for making variables local:</p>
+
+<h3>Locals in <tt>let</tt>, <tt>letn</tt>, <tt>local</tt> and <tt>letex</tt></h3>
+
+<p><tt>let</tt> is the usual way in newLISP to declare symbols as local to a block.</p>
+
+<pre>
+(define (sum-sq a b)
+    (let ((x (* a a)) (y (* b b)))
+        (+ x y)))
+ 
+(sum-sq 3 4) โ†’ 25
+ 
+; alternative syntax
+(define (sum-sq a b)
+    (let (x (* a a) y (* b b))
+        (+ x y)))
+</pre>
+
+
+<p>The variables x and y are initialized, then the expression (+ x y) is evaluated. The <tt>let</tt> form is just an optimized version and syntactic convenience for writing:</p>
+
+<pre>
+((lambda (sym1 [sym2 ...]) exp-body ) exp-init1 [ exp-init2 ...])
+</pre>
+
+<p>When initializing several parameters, a nested <tt>let</tt>, <tt>letn</tt> can be used to reference previously initialized variables in subsequent initializer expressions:</p>
+
+<pre>
+(letn ((x 1) (y (+ x 1)))
+    (list x y))              โ†’ (1 2)
+</pre>
+
+<p><tt>local</tt> works the same way but variables are initialized to <tt>nil</tt></p>
+
+<pre>
+(local (a b c) 
+   ...          ; expressions using the locale variables a b c
+)
+</pre>
+
+<p><tt>letex</tt> works similar to <tt>let</tt> but variables are expanded in the body to
+values assigned.</p>
+
+<pre>
+; assign to local variable and expand in body
+
+(letex ( (x 1) (y '(a b c)) (z "hello") ) '(x y z))
+โ†’ (1 (a b c) "hello")
+
+; as in let, parentheses around the initializers can be omitted
+
+(letex (x 1 y 2 z 3) '(x y z))    โ†’ (1 2 3)
+</pre>
+
+<p>After exiting any of the <tt>let</tt>, <tt>letn</tt>, <tt>local</tt> or <tt>letex</tt>
+expressions, the variable symbols used as locals get their old values back.</p> 
+
+
+<h3>Unused parameters as locals</h3>
+
+<p>In newLISP, all parameters in user defined functions are optional. Unused parameters are filled with <tt>nil</tt> and are of local scope to the dynamic scope of the function. Defining a user function with more parameters than required is a convenient method to create local variable symbols:</p>
+
+<pre> 
+(define (sum-sq a b , x y)
+    (set 'x (* a a))
+    (set 'y (* b b))
+    (+ x y))
+</pre>
+
+<p>The comma is not a special syntax feature but only a visual helper to separate normal parameters from local variable symbols. (Technically, the comma, like x and y, is a local variable and is set to nil.)</p>
+
+<h3>Default variable values</h3>
+
+<p>In the definition of a function default values can be specified:</p>
+
+<pre>
+(define (foo (a 1) (b 2))
+    (list a b))
+  
+    (foo)      โ†’  (1 2)
+    (foo 3)    โ†’  (3 2)
+    (foo 3 4)  โ†’  (3 4)
+</pre>
+
+<h3><tt>args</tt> as local substitute</h3>
+
+<p>Using the <tt>args</tt> function no parameter symbols need to be used at all and <tt>args</tt> returns a list of all parameters passed but not taken by declared parameters:</p>
+
+<pre>
+(define (foo)
+    (args))
+   
+(foo 1 2 3)   โ†’ (1 2 3)
+   
+   
+(define (foo a b)
+    (args))
+   
+(foo 1 2 3 4 5)   โ†’ (3 4 5)
+</pre>
+
+<p>The second example shows how <tt>args</tt> only contains the list of arguments not bound by the variable symbols <tt>a</tt> and <tt>b</tt>.</p>
+
+<p>Indices can be used to access members of the <tt>(args)</tt> list:</p>
+
+<pre>
+(define (foo)
+      (+ (args 0) (args 1)))
+   
+(foo 3 4)   โ†’ 7
+</pre>
+
+<h3><tt>args</tt> and <tt>local</tt> used together for named variables</h3>
+
+<pre>
+(define-macro (foo)
+   (local (len width height)
+      (bind (args) true)
+      (println "len:" len " width:" width " height:" height)
+   ))
+
+(foo (width 20) (height 30) (len 10))
+
+<b>len:10 width:20 height:30</b>
+</pre>
+
+<p><tt>local</tt> will shadow / protect the values of the variables <tt>len</tt>, <tt>width</tt>
+and <tt>height</tt> at higher dynamic scoping levels.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-5"></a>
+<h2>5. Walking through lists and data</h2>
+
+<h3>Recursion or iteration?</h3>
+
+<p>Although recursion is a powerful feature to express many algorithms in a readable form, it can also be inefficient in some instances. newLISP has many iterative constructs and high level functions like <tt>flat</tt> or the built-in XML functions, which use recursion internally. In many cases this makes defining a recursive algorithm unnecessary.</p>
+
+<p>Some times a non-recursive solution can be much faster and lighter on system resources.</p>
+
+<pre>
+; classic recursion
+; slow and resource hungry
+(define (fib n)
+    (if (&lt; n 2) 1
+        (+  (fib (- n 1))
+            (fib (- n 2)))))
+</pre>
+
+<p>The recursive solution is slow because of the frequent calling overhead. Also, the recursive solution uses a lot of memory for holding intermediate and frequently redundant results.</p>
+
+<pre>
+; iteration
+; fast and also returns the whole list
+(define (fibo n , f)
+    (set 'f '(1 0))
+    (dotimes (i n)
+         (push (+ (f 0) (f 1)) f)) )
+</pre>
+
+<p>The iterative solution is fast and uses very little memory.</p>
+
+<h3>Speed up with memoization</h3>
+
+<p>A memoizing function caches results for faster retrieval when called with the same parameters again. The following function makes a memoizing function from any built-in or user defined function with an arbitrary number of arguments. A namespace is created for the memoizing function as a data cache.</p>
+
+<pre>
+; speed up a recursive function using memoization
+(define-macro (memoize mem-func func)
+    (set (sym mem-func mem-func)
+        (letex (f func  c mem-func)
+          (lambda ()
+              (or (context c (string (args)))
+              (context c (string (args)) (apply f (args))))))))
+       
+(define (fibo n)
+    (if (&lt; n 2)  1
+        (+  (fibo (- n 1))
+            (fibo (- n 2)))))
+       
+(memoize fibo-m fibo)
+       
+(time (fibo-m 25)) โ†’ 148
+(time (fibo-m 25)) โ†’ 0
+</pre>
+
+<p>The function creates a context and <tt>default</tt> function for the original function with a new name and stores all results in symbols in the same context.</p>
+
+<p>When memoizing recursive functions, include the raw lambda specification of the function so recursive calls are memoized too:</p>
+
+<pre>
+(memoize fibo
+    (lambda (n)
+        (if(&lt; n 2) 1
+            (+  (fibo (- n 1))
+                (fibo (- n 2))))))
+        
+(time (fibo 100)) โ†’ 1
+(fibo 80)         โ†’ 37889062373143906
+</pre>
+
+<p>The <tt>fibo</tt> function in the last example would take hours to calculate without memoization. The memoized version takes only about a milli-second for an argument of <tt>100</tt>.</p>
+
+<h3>Walking a tree</h3>
+
+<p>Tree walks are a typical pattern in traditional LISP and in newLISP as well for walking through a nested list. But many times a tree walk is only used to iterate through all elements of an existing tree or nested list. In this case the built-in <tt>flat</tt> function is much faster than using recursion:</p>
+
+<pre>
+(set 'L '(a b c (d e (f g) h i) j k))
+   
+; classic car/cdr and recursion
+;
+(define (walk-tree tree)
+    (cond ((= tree '()) true)
+          ((atom? (first tree))
+             (println (first tree))
+             (walk-tree (rest tree)))
+          (true
+             (walk-tree (first tree))
+             (walk-tree (rest tree)))))
+   
+; classic recursion
+; 3 times faster
+;
+(define (walk-tree tree)
+    (dolist (elmnt tree)
+        (if (list? elmnt)
+            (walk-tree elmnt)
+            (println elmnt))))
+   
+(walk-tree L) โ†’
+     a
+     b
+     c
+     d
+     e
+     ...
+</pre>
+
+<p>Using the built-in <tt>flat</tt> in newLISP a nested list can be transformed into a flat list. Now the list can be processed with a <tt>dolist</tt> or <tt>map</tt>:</p>
+
+<pre>
+; fast and short using 'flat'
+; 30 times faster with map
+;
+(map println (flat L))
+ 
+; same as
+ 
+(dolist (item (flat L)) (println item))
+</pre>
+
+<h3>Walking a directory tree</h3>
+
+<p>Walking a directory tree is a task where recursion works well:</p>
+
+<pre> 
+; walks a disk directory and prints all path-file names
+;
+(define (show-tree dir)
+    (when (directory? dir)
+        (dolist (nde (directory dir))
+            (if (and (directory? (append dir "/" nde))
+                     (!= nde ".") (!= nde ".."))
+                (show-tree (append dir "/" nde))
+                (println (append dir "/" nde))))))
+</pre>
+
+<p>In this example recursion is the only solution, because the entire nested list of files is not available when the function is called but gets created recursively during function execution.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-6"></a>
+<h2>6. Modifying and searching lists</h2>
+
+<p>newLISP has facilities for multidimensional indexing into nested lists. There are <tt>destructive</tt> functions like <tt>push</tt>, <tt>pop</tt>, <tt>setf</tt>, <tt>set-ref</tt>, <tt>set-ref-all</tt>, <tt>sort</tt> and <tt>reverse</tt> and many others for <tt>non-destructive</tt> operations, like <tt>nth</tt>, <tt>ref</tt>, <tt>ref-all</tt>, <tt>first</tt>, <tt>last</tt> and <tt>rest</tt> etc.. Many of the list functions in newLISP also work on strings.</p>
+
+<p>Note that any list or string index in newLISP can be negative starting with -1 from the right side of a list:</p>
+
+<pre>
+(set 'L '(a b c d))
+(L -1)   โ†’ d
+(L -2)   โ†’ c
+(-3 2 L) โ†’ (b c)
+   
+(set 'S  "abcd")
+   
+(S -1)   โ†’ d
+(S -2)   โ†’ c
+(-3 2 S) โ†’ "bc")
+</pre>
+
+<h3><tt>push</tt> and <tt>pop</tt></h3>
+
+<p>To add to a list use <tt>push</tt>, to eliminate an element from a list use <tt>pop</tt>. Both functions are destructive, changing the contents of a list:</p>
+
+<pre>
+(set 'L '(b c d e f))
+   
+(push 'a L) โ†’ (a b c d e f)
+(push 'g L -1) ; push to the end with negative index
+(pop L)        ; pop first a
+(pop L -1)     ; pop last g
+(pop L -2)     ; pop second to last e
+(pop L 1)      ; pop second c
+   
+L โ†’ (b d f)
+   
+; multidimensional push / pop
+(set 'L '(a b (c d (e f) g) h i))
+   
+(push 'x L 2 1) โ†’ (a b (c x d (e f) g) h i)
+   
+L โ†’ (a b (c x d (e f) g) h i)
+   
+(pop L 2 1) โ†’ x
+
+; the target list is a place reference
+(set 'lst '((a 1) (b 2) (c 3) (d)))
+
+(push 4 (assoc 'd lst) -1) โ†’ (d 4)
+
+lst โ†’ ((a 1) (b 2) (c 3) (d 4))
+</pre>
+
+<p>Pushing to the end of a list repeatedly is optimized in newLISP and as fast as pushing in front of a list.</p>
+
+<p>When pushing an element with index vector V it can be popped with the same index vector V:</p>
+
+<pre>
+(set 'L '(a b (c d (e f) g) h i))
+(set 'V '(2 1))
+(push 'x L V)
+L โ†’ (a b (c x d (e f) g) h i))
+(ref 'x L) โ†’ (2 1) ; search for a nested member
+(pop L V) โ†’ 'x
+</pre>
+
+<h3>Extend using <tt>extend</tt></h3>
+
+<p>Using <tt>extend</tt> lists can be appended destructively.
+Like <tt>push</tt> and <tt>pop</tt>, <tt>extend</tt> modifies the list in the first
+argument.</p>
+
+<pre>
+(set 'L '(a b c))
+(extend L '(d e) '(f g))
+
+L &rarr; '(a b c d e f g)
+
+; extending in a place
+
+(set 'L '(a b "CD" (e f)))
+(extend (L 3) '(g))
+L โ†’ (a b "CD" (e f g))
+</pre>
+
+<h3>Accessing lists</h3>
+
+<p>Multiple indexes can be specified to access elements in a nested list structure:</p>
+
+<pre>
+(set 'L '(a b (c d (e f) g) h i))
+   
+; old syntax only for one index
+(nth 2 L) โ†’ (c d (e f) g)
+   
+; use new syntax for multiple indices
+(nth '(2 2 1) L) โ†’ f
+(nth '(2 2) L) โ†’ (e f)
+   
+; vector indexing
+(set 'vec '(2 2))
+(nth vec L) โ†’ (e f)
+   
+; implicit indexing
+(L 2 2 1) โ†’ f
+(L 2 2)   โ†’ (e f)
+   
+; implicit indexing with vector
+(set 'vec '(2 2 1))
+(L vec)   โ†’ f
+</pre>
+
+<p>Implicit indexing shown in the last example can make code more readable. Indexes before a list select subsections of a list, which in turn are always lists.</p>
+
+<p>Implicit indexing is also available for rest and slice:</p>
+
+<pre>
+(rest '(a b c d e))      โ†’ (b c d e)
+(rest (rest '(a b c d e) โ†’ (c d e)
+; same as
+(1 '(a b c d e)) โ†’ (b c d e)
+(2 '(a b c d e)) โ†’ (c d e)
+   
+; negative indices
+(-2 '(a b c d e)) โ†’ (d e)
+   
+; slicing
+(2 2 '(a b c d e f g))  โ†’ (c d)
+(-5 3 '(a b c d e f g)) โ†’ (c d e)
+</pre>
+
+<h3>Selecting more elements</h3>
+
+<p>Sometimes more than one element must be selected from a list. This is done using select:</p>
+
+<pre>
+; pick several elements from a list
+(set 'L '(a b c d e f g))
+(select L 1 2 4 -1) โ†’ (b c e g)
+   
+; indices can be delivered in an index vector:
+(set 'vec '(1 2 4 -1))
+(select L vec) โ†’ (b c e g)
+</pre>
+
+<p>The selecting process can re-arrange or double elements at the same time:</p>
+
+<pre>
+(select L 2 2 1 1) โ†’ (c c b b)
+</pre>
+
+<h3>Filtering and differencing lists</h3>
+
+<p>Lists can be filtered, returning only those elements that meet a specific condition:</p>
+
+<pre>
+(filter (fn(x) (&lt; 5 x)) '(1 6 3 7 8))    โ†’ (6 7 8)
+(filter symbol? '(a b 3 c 4 "hello" g)) โ†’ (a b c g)
+(difference '(1 3 2 5 5 7) '(3 7)) โ†’ (1 2 5)
+</pre>
+
+<p>The first example could be written more concisely, as follows:</p>
+
+<pre>
+(filter (curry &lt; 5) '(1 6 3 7 8))
+</pre>
+
+<p>The <tt>curry</tt> function makes a one argument function out of a two argument function:</p>
+
+<pre>
+(curry &lt; 5) โ†’ (lambda (_x) (&lt; 5 _x))
+</pre>
+
+<p>With <tt>curry</tt>, a function taking two arguments can be quickly converted into a predicate taking one argument.</p>
+
+<h3>Changing list elements</h3>
+
+<p><tt>setf</tt> can be used to change a list element by referencing it with either <tt>nth</tt> or <tt>assoc</tt>:</p>
+
+<pre>
+; modify a list at an index
+(set 'L '(a b (c d (e f) g) h i))
+   
+(setf (L 2 2 1) 'x) โ†’ x   
+L โ†’ (a b (c d (e x) g) h i)
+(setf (L 2 2) 'z) โ†’ z
+L โ†’ (a b (c d z g) h i)
+   
+; modify an association list
+(set 'A '((a 1) (b 2) (c 3)))
+   
+; using setf with assoc
+(setf (assoc 'b A) '(b 22)) โ†’ (b 22)
+A โ†’ ((a 1) (b 22) (c 3))
+; using setf with lookup
+(setf (lookup 'c A) 33) โ†’ 33
+A โ†’ ((a 1) (b 22) (c 33))
+</pre>
+
+<h3>The anaphoric variable</h3>
+
+<p>The internal <em>anaphoric</em> system variable <tt>$it</tt> holds the old list element. This can be used to configure the new one:</p>
+
+<pre>
+(set 'L '(0 0 0))
+(setf (L 1) (+ $it 1)) โ†’ 1 ; the new value
+(setf (L 1) (+ $it 1)) โ†’ 2
+(setf (L 1) (+ $it 1)) โ†’ 4
+L โ†’ '(0 3 0)
+</pre>
+
+<p>The following functions use the anaphoric <tt>$it</tt>:&nbsp;
+<tt>find-all</tt>, <tt>if</tt>, <tt>replace</tt>, <tt>set-ref</tt>, <tt>set-ref-all</tt> and <tt>setf setq</tt>.</p>
+
+<h3>Replace in simple lists</h3>
+
+<p>Replace, which can also be used on strings, can search for and replace multiple elements in a list at once. Together with <tt>match</tt> and <tt>unify</tt> complex search patterns can be specified. Like with <tt>setf</tt>, the replacement expression can use the old element contents to form the replacement.</p>
+
+<pre>
+(set 'aList '(a b c d e a b c d))
+     
+(replace 'b aList 'B) โ†’ (a B c d e a B c d)
+</pre>
+
+<p>The function <tt>replace</tt> can take a comparison function for picking list elements:</p>
+
+<pre>
+; replace all numbers where 10 &lt; number
+(set 'L '(1 4 22 5 6 89 2 3 24))
+     
+(replace 10 L 10 &lt;) โ†’ (1 4 10 5 6 10 2 3 10)
+</pre>
+
+<p>Using the built-in functions <tt>match</tt> and <tt>unify</tt> more complex selection criteria can be defined:</p>
+
+<pre>
+; replace only sublists starting with 'mary'
+    
+(set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+   
+(replace '(mary *)  AL (list 'mary (apply + (rest $it))) match)
+โ†’ ((john 5 6 4) (mary 14) (bob 4 2 7 9) (jane 3))
+    
+; make sum in all expressions
+    
+(set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+   
+(replace '(*) AL (list ($it 0) (apply + (rest $it))) match)
+โ†’ ((john 15) (mary 14) (bob 22) (jane 3))
+    
+$0 โ†’ 4  ; replacements made
+    
+; change only sublists where both elements are the same
+    
+(replace '(X X) '((3 10) (2 5) (4 4) (6 7) (8 8)) (list ($it 0) 'double ($it 1)) unify)
+โ†’ ((3 10) (2 5) (4 double 4) (6 7) (8 double 8))
+    
+$0 โ†’ 2  ; replacements made
+</pre>
+
+<p>During replacements <tt>$0</tt> and the anaphoric system variable <tt>$it</tt> contain the current found expression.</p>
+
+<p>After a replacement statement is executed the newLISP system variable <tt>$0</tt> contains the number of replacements made.</p>
+
+<h3>Replace in nested lists</h3>
+
+<p>Sometimes lists are nested, e.g. the SXML results from parsing XML. The functions <tt>ref-set</tt>, <tt>set-ref</tt> and <tt>set-ref-all</tt> can be used to find a single element or all elements in a nested list, and replace it or all.</p>
+
+<pre>
+(set 'data '((monday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))))
+   
+(set-ref 'monday data tuesday)
+โ†’ ((tuesday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))) 
+</pre>
+
+<p>The function <tt>set-ref-all</tt> does a <tt>set-ref</tt> multiple times, replacing all found occurrences of an element.</p>
+
+<pre>
+(set 'data '((monday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))))
+   
+(set-ref-all 'apples data "Apples")
+โ†’ ((monday ("Apples" 20 30) (oranges 2 4 9)) (tuesday ("Apples" 5) (oranges 32 1)))
+</pre>
+
+<p>Like <tt>find</tt>, <tt>replace</tt>, <tt>ref</tt> and <tt>ref-all</tt>, more complex searches can be expressed using <tt>match</tt> or <tt>unify</tt>:</p>
+
+<pre>
+(set 'data '((monday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))))
+   
+(set-ref-all '(oranges *) data (list (first $0) (apply + (rest $it))) match)
+โ†’ ((monday (apples 20 30) (oranges 15)) (tuesday (apples 5) (oranges 33)))
+</pre>
+
+<p>The last example shows how <tt>$0</tt> can be used to access the old list element in the updating expression. In this case the numbers for <tt>oranges</tt> records have been summed. Instead of <tt>$0</tt> the anaphoric system variable <tt>$it</tt> can also be used.</p>
+
+<h3>Passing lists by reference</h3>
+
+<p>Sometimes a larger list (more than a few hundred elements) must be passed to a user-defined function for elements in it to be changed. Normally newLISP passes all parameters to user-defined functions by value. But the following snippet shows a technique that can be used to pass a bigger list or string object by reference:</p>
+
+<pre>
+(set 'data:data '(a b c d e f g h))
+   
+(define (change db i value)
+    (setf (db i) value))
+   
+(change data 3 999) โ†’ d
+   
+data:data โ†’ '(a b c 999 d e f g h)
+</pre>
+
+<p>In this example the list is encapsulated in a context named <tt>data</tt> holding a variable <tt>data</tt> with the same name.</p>
+
+<p>Whenever a function in newLISP looks for a string or list parameter, a context can be passed, which will then be interpreted as the default functor.</p>
+
+<p>When returning a list or array or an element belonging to a list or array referenced by a symbol, many built-in functions return a //reference// to the list โ€“ not a copy. This can be used to nest built-in functions when modifying a list:</p>
+
+<pre>
+(set 'L '(r w j s r b))
+   
+(pop (sort L)) โ†’ b
+   
+L โ†’ (j r r s w)
+</pre>
+
+<h3>Variable expansion</h3>
+
+<p>Two functions are available to do macro-expansion: <tt>expand</tt> and <tt>letex</tt>. The <tt>expand</tt> function has three different syntax patterns.</p>
+
+<p>Symbols get expanded to their value:</p>
+
+<pre>
+; expand from one or more listed symbols
+(set 'x 2 'a '(d e))
+(expand '(a x (b c x)) 'x 'a)  โ†’ ((d e) 2 (b c 2))
+</pre>
+
+<p><tt>expand</tt> is useful when composing lambda expressions or when doing variable expansion inside functions and function macros (fexpr with <tt>define-macro</tt>):</p>
+
+<pre>
+; use expansion inside a function
+(define (raise-to power)
+    (expand (fn (base) (pow base power)) 'power))
+(define square (raise-to 2))
+(define cube (raise-to 3))
+(square 5)  โ†’ 25
+(cube 5)    โ†’ 125
+</pre>
+
+<p><tt>expand</tt> can take an association list:</p>
+
+<pre>
+; expand from an association list
+(expand '(a b c) '((a 1) (b 2)))                โ†’ (1 2 c)
+(expand '(a b c) '((a 1) (b 2) (c (x y z))))    โ†’ (1 2 (x y z))
+</pre>
+
+<p>and the value part in associations can be evaluated first:</p>
+
+<pre>
+; evaluate the value parts in the association list before expansion
+(expand '(a b) '((a (+ 1 2)) (b (+ 3 4))))      โ†’ ((+ 1 2) (+ 3 4))
+(expand '(a b) '((a (+ 1 2)) (b (+ 3 4))) true) โ†’ (3 7)
+</pre>
+
+<p><tt>expand</tt> does its work on variables starting with an uppercase letter when expansion variables have neither been specified stand-alone nor in an association list.</p>
+
+<pre>
+; expand from uppercase variables
+(set 'A 1 'Bvar 2 'C nil 'd 5 'e 6)
+(expand '(A (Bvar) C d e f))  โ†’ (1 (2) C d e f)
+</pre>
+
+<p>Using this, a previous function definition can be made even shorter.</p>
+
+<pre>
+; use expansion from uppercase variables in function factories
+(define (raise-to Power) 
+    (expand (fn (base) (pow base Power))))
+(define cube (raise-to 3)) โ†’ (lambda (base) (pow base 3))
+(cube 4) โ†’ 64
+</pre>
+
+<p>The <tt>letex</tt> function works like <tt>expand</tt>, but expansion symbols are local to the <tt>letex</tt> expression.</p>
+
+<pre>
+; use letex for variable expansion
+(letex ( (x 1) (y '(a b c)) (z "hello") ) '(x y z)) โ†’ (1 (a b c) "hello")
+</pre>
+
+<p>Note that in the example the body expression in <tt>letex</tt>: <tt>(x y z)</tt> is quoted to prevent evaluation.</p>
+
+<h3>Destructuring nested lists</h3>
+
+<p>The following method can be used to bind variables to subparts of a nested list:</p>
+
+<pre>
+; uses unify together with bind for destructuring
+(set 'structure '((one "two") 3 (four (x y z))))
+(set 'pattern '((A B) C (D E))) ; unify needs uppercase for binding
+(bind (unify pattern structure))
+A โ†’ one
+B โ†’ "two"
+C โ†’ 3
+D โ†’ four
+E โ†’ (x y z)
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-7"></a>
+<h2>7. Program flow</h2>
+
+<p>Program flow in newLISP is mostly functional but it also has looping and branching constructs and a <tt>catch</tt> and <tt>throw</tt> to break out of the normal flow.</p>
+
+<p>Looping expressions as a whole behave like a function or block returning the last expression evaluated.</p>
+
+<h3>Loops</h3>
+
+<p>Most of the traditional looping patterns are supported. Whenever there is a looping variable, it is local in scope to the loop, behaving according the rules of dynamic scoping inside the current name-space or context:</p>
+
+<pre>
+; loop a number of times
+; i goes from 0 to N - 1
+(dotimes (i N)
+    ....
+)
+   
+; demonstrate locality of i
+(dotimes (i 3)
+    (print i ":")
+    (dotimes (i 3) (print i))
+    (println)
+)
+   
+โ†’ ; will output
+ 0:012
+ 1:012
+ 2:012
+   
+; loop through a list
+; takes the value of each element in aList
+(dolist (e aList)
+    ...
+)
+   
+; loop through a string
+; takes the ASCII or UTF-8 value of each character in aString
+(dostring (e aString)
+    ...
+)
+   
+; loop through the symbols of a context in
+; alphabetical order of the symbol name
+(dotree (s CTX)
+    ...
+)
+   
+; loop from to with optional step size
+; i goes from init to &lt;= N inclusive with step size step
+; Note that the sign in step is irrelevant, N can be greater
+; or less then init.
+(for (i init N step)
+    ...
+)
+   
+; loop while a condition is true
+; first test condition then perform body
+(while condition
+    ...
+)
+   
+; loop while a condition is false
+; first test condition then perform body
+(until condition
+    ...
+)
+   
+; loop while a condition is true
+; first perform body then test
+; body is performed at least once
+(do-while condition
+    ...
+)
+   
+; loop while a condition is false
+; first perform body then test
+; body is performed at least once
+(do-until condition
+    ...
+)
+</pre>
+
+<p>Note that the looping functions <tt>dolist</tt>, <tt>dotimes</tt> and <tt>for</tt> can also take a break condition as an additional argument. When the break condition evaluates to true the loop finishes:</p>
+
+<pre>
+(dolist (x '(a b c d e f g) (= x 'e))
+    (print x))
+โ†’ ; will output
+ abcd
+</pre>
+
+<h3>Blocks</h3>
+
+<p>Blocks are collections of s-expressions evaluated sequentially. All looping constructs may have expression blocks after the condition expression as a body.</p>
+
+<p>Blocks can also be constructed by enclosing them in a begin expression:</p>
+
+<pre>
+(begin
+    s-exp1
+    s-exp2
+     ...
+    s-expN)
+</pre>
+
+<p>Looping constructs do not need to use an explicit begin after the looping conditions. <tt>begin</tt> is mostly used to block expressions in <tt>if</tt> and <tt>cond</tt> statements.</p>
+
+<p>The functions <tt>and</tt>, <tt>or</tt>, <tt>let</tt>, <tt>letn</tt> and <tt>local</tt> can also be used to form blocks and do not require <tt>begin</tt> for blocking statements.</p>
+
+<h3>Branching</h3>
+
+<pre>
+(if condition true-expr false-expr)
+   
+;or when no false clause is present
+(if condition true-expr)
+   
+;or unary if for (filter if '(...))
+(if condition)
+   
+; more than one statement in the true or false
+; part must be blocked with (begin ...)
+(if (= x y)
+    (begin
+        (some-func x)
+        (some-func y))
+    (begin
+        (do-this x y)
+        (do-that x y))
+)
+ 
+; the when form can take several statements without
+; using a (begin ...) block
+(when condition
+    exp-1
+    exp-2
+    ...
+)
+   
+; unless works like (when (not ...) ...)
+(unless condition
+    exp-1
+    exp-2
+    ...
+)
+</pre>
+
+<p>Depending on the condition, the <tt>exp-true</tt> or <tt>exp-false</tt> part is evaluated and returned.</p>
+
+<p>More than one <tt>condition/exp-true</tt> pair can occur in an if expression, making it look like a <tt>cond</tt>:</p>
+
+<pre>
+(if condition-1 exp-true-1
+    condition-2 exp-true-2
+    ...
+    condition-n exp-true-n
+    expr-false
+)
+</pre>
+
+<p>The first <tt>exp-true-i</tt> for which the <tt>condition-i</tt> is not <tt>nil</tt> is evaluated and returned, or the <tt>exp-false</tt> if none of the <tt>condition-i</tt> is <tt>true</tt>.</p>
+
+<p><tt>cond</tt>works like the multiple condition form of if but each part of <tt>condition-i</tt> <tt>exp-true-i</tt> must be braced in parentheses:</p>
+
+<pre>
+(cond
+    (condition-1 exp-true-1 )
+    (condition-2 exp-true-2 )
+                ...
+    (condition-n exp-true-n )
+    (true exp-true)
+)
+</pre>
+
+<h3>Fuzzy flow</h3>
+
+<p>Using <tt>amb</tt> the program flow can be regulated in a probabilistic fashion:</p>
+
+<pre>
+(amb
+    exp-1
+    exp-2
+    ...
+    exp-n
+)
+</pre>
+
+<p>One of the alternative expressions <tt>exp-1</tt> to <tt>exp-n</tt> is evaluated with a probability of <tt>p = 1/n</tt> and the result is returned from the amb expression.</p>
+
+<h3>Flow with <tt>catch</tt> and <tt>throw</tt></h3>
+
+<p>Any loop or other expression block can be enclosed in a catch expression. The moment a throw expression is evaluated, the whole catch expression returns the value of the throw expression.</p>
+
+<pre>
+(catch
+    (dotimes (i 10)
+    (if (= i 5) (throw "The End"))
+    (print i " "))
+)
+; will output
+0 1 2 3 4
+; and the return value of the catch expression will be
+โ†’ "The End"
+</pre>
+
+<p>Several <tt>catch</tt> expressions can be nested. The function <tt>catch</tt> can also catch errors. See the chapter on //Error Handling// below.</p>
+
+<h3>Leave loops with a break condition</h3>
+
+<p>Loops built using <tt>dotimes</tt>, <tt>dolist</tt> or <tt>for</tt> can specify a break condition for leaving the loop early:</p>
+
+<pre>
+(dotimes (x 10 (&gt; (* x x) 9))
+    (println x))
+โ†’
+ 0
+ 1
+ 2
+ 3
+   
+(dolist (i '(a b c nil d e) (not i))
+    (println i))
+โ†’
+ a
+ b
+ c
+</pre>
+
+<h3>Change flow with <tt>and</tt> or <tt>or</tt></h3>
+
+<p>Similar to programming in the Prolog language, the logical <tt>and</tt> and <tt>or</tt> can be used to control program flow depending on the outcome of expressions logically connected:</p>
+
+<pre> 
+(and
+   expr-1
+   expr-2
+    ...
+   expr-n)
+</pre>
+
+<p>Expressions are evaluated sequentially until one <tt>expr-i</tt> evaluates to <tt>nil</tt> or the empty list <tt>()</tt> or until all <tt>expr-i</tt> are exhausted. The last expression evaluated is the return value of the whole <tt>and</tt> expression.</p>
+
+<pre>
+(or
+   expr-1
+   expr-2
+    ...
+   expr-n)
+</pre>
+
+<p>Expressions are evaluated sequentially until one <tt>expr-i</tt> evaluates to <b>not</b> <tt>nil</tt> and not <tt>()</tt> or until all <tt>expr-i</tt> are exhausted. The last expression evaluated is the return value of the whole <tt>or</tt> expression.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-8"></a>
+<h2>8. Error handling</h2>
+
+<p>Several conditions during evaluation of a newLISP expression can cause error exceptions. For a complete list of errors see the Appendix in the newLISP Reference Manual.</p>
+
+<h3>newLISP errors</h3>
+
+<p>newLISP errors are caused by the programmer using the wrong syntax when invoking functions, supplying the wrong number of parameters or parameters with the wrong data type, or by trying to evaluate nonexistent functions.</p>
+
+<pre>
+; examples of newLISP errors
+;
+(foo foo)   โ†’ invalid function : (foo foo)
+(+ "hello") โ†’ value expected in function + : "hello"
+</pre>
+
+<h3>User defined errors</h3>
+
+<p>User errors are error exceptions thrown using the function throw-error:</p>
+
+<pre>
+; user defined error
+;
+(define (double x)
+    (if (= x 99) (throw-error "illegal number"))
+    (+ x x)
+)
+   
+(double 8)   โ†’ 16
+(double 10)  โ†’ 20
+(double 99)
+โ†’
+user error : illegal number
+called from user defined function double
+</pre>
+
+<h3>Error event handlers</h3>
+
+<p>newLISP and user defined errors can be caught using the function error-event to define an event handler.</p>
+
+<pre>
+; define an error event handler
+;
+(define (MyHandler)
+    (println  (last (last-error))  " has occurred"))
+   
+(error-event 'MyHandler)
+   
+(foo) โ†’ ERR: invalid function : (foo) has occurred 
+</pre>
+
+<h3>Catching errors</h3>
+
+<p>A finer grained and more specific error exception handling can be achieved using a special syntax of the function catch.</p>
+
+<pre>
+(define (double x)
+    (if (= x 99) (throw-error "illegal number"))
+    (+ x x))
+</pre>
+
+<p>catch with a second parameter can be used to catch both system and user-defined errors:</p>
+
+<pre>
+(catch (double 8) 'result) โ†’ true
+result โ†’ 16
+(catch (double 99) 'result) โ†’ nil
+(print result)
+ โ†’
+user error : illegal number
+called from user defined function double
+    
+(catch (double "hi") 'result) โ†’ nil
+(print result)
+โ†’
+value expected in function + : x
+called from user defined function double
+</pre>
+
+<p>The catch expression returns true when no error exception occurred, and the result of the expression is found in the symbol <tt>result</tt> specified as a second parameter.</p>
+
+<p>If an error exception occurs, it is caught and the catch clause returns nil. In this case the symbol <tt>result</tt> contains the error message.</p>
+
+<h3>Operating system errors</h3>
+
+<p>Some errors originating at operating system level are not caught by newLISP, but can be inspected using the function <tt>sys-error</tt>. For example the failure to open a file could have different causes:</p>
+
+<pre>
+; trying to open a nonexistent file
+(open "blahbla" "r")  โ†’  nil
+(sys-error)           โ†’  (2 "No such file or directory")
+   
+   
+; to clear errno specify 0
+(sys-error 0)         โ†’  (0 "Unknown error: 0")
+</pre>
+
+<p>Numbers returned may be different on different Unix platforms. Consult the file <tt>/usr/include/sys/errno.h</tt> on your platform.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-9"></a>
+<h2>9. Functions as data</h2>
+
+<h3>Manipulate after definition</h3>
+
+<pre>
+(define (double x) (+ x x))
+โ†’ (lambda (x) (+ x x))
+    
+(first double) โ†’ (x)
+(last double)  โ†’ (+ x x)
+    
+; make a fuzzy double
+(setf (nth 1 double) '(mul (normal x (div x 10)) 2))
+    
+(double 10) โ†’ 20.31445313
+(double 10) โ†’ 19.60351563
+</pre>
+
+<p>lambda in newLISP is not an operator or symbol, but rather a special s-expression or list attribute:</p>
+
+<pre>
+(first double) โ†’ (x)   ; not lambda
+</pre>
+
+<p>The lambda attribute of an s-expression is right-associative in <tt>append</tt>:</p>
+
+<pre>
+(append (lambda) '((x) (+ x x))) โ†’ (lambda (x) (+ x x))
+; or shorter
+(append (fn) '((x) (+ x x))) โ†’ (lambda (x) (+ x x))
+    
+(set 'double (append (lambda) '((x) (+ x x)))
+    
+(double 10) โ†’ 20
+</pre>
+
+<p>and left-associative when using cons:</p>
+
+<pre>
+(cons '(x) (lambda) โ†’ (lambda (x))
+</pre>
+
+<p>Lambda expressions in newLISP never lose their first class object property.</p>
+
+<p>The word <tt>lambda</tt> can be abbreviated as <tt>fn</tt>, which is convenient when mapping or applying functions to make the expression more readable and shorter to type.</p>
+
+<h3>Mapping and applying</h3>
+
+<p>Functions or operators can be applied to a list of data at once and all results are returned in a list</p>
+
+<pre>
+(define (double (x) (+ x x))
+     
+(map double '(1 2 3 4 5)) โ†’ (2 4 6 8 10)
+</pre>
+
+<p>Functions can be applied to parameters occurring in a list:</p>
+
+<pre>
+(apply + (sequence 1 10)) โ†’ 55
+</pre>
+
+<h3>Functions making functions</h3>
+
+<p>Here an expression is passed as a parameter:</p>
+
+<pre>
+; macro expansion using expand
+(define (raise-to power)
+    (expand (fn (base) (pow base power)) 'power))
+     
+; or as an alternative using letex
+(define (raise-to power)
+    (letex (p power) (fn (base) (pow base p))))
+     
+(define square (raise-to 2))
+     
+(define cube (raise-to 3))
+     
+(square 5)   โ†’ 25
+(cube 5)     โ†’ 125
+</pre>
+
+<p>The built-in function <tt>curry</tt> can be used to make a function taking one argument from a function taking two arguments.</p>
+
+<pre>
+(define add-one (curry add 1))  โ†’ (lambda () (add 1 ($args 0)))
+     
+(define by-ten (curry mul 10))  โ†’ (lambda () (mul 10 ($args 0)))
+   
+(add-one 5)    โ†’ 6
+     
+(by-ten 1.23)  โ†’ 12.3
+</pre>
+
+<p>Note that the 'curried' parameter is always the first parameter of the original function.</p>
+
+<h3>Functions with memory</h3>
+
+<p>newLISP can create local state variables using a name-space context:</p>
+
+<pre>
+; newLISP generator
+
+(define (gen:gen)
+    (setq gen:sum 
+    (if gen:sum (inc gen:sum) 1)))
+
+; this could be written even shorter, because
+; 'inc' treats nil as zero
+
+(define (gen:gen)
+    (inc gen:sum))
+
+(gen) &rarr; 1
+(gen) &rarr; 2 
+(gen) &rarr; 3
+</pre>
+
+<p>The example uses a default functor &mdash; functions name equals names-space name &mdash;
+to give it the appearance of a normal function. Other functions could be added to the
+namespace, e.g. for initializing the sum.</p>
+
+<pre>
+(define (gen:init x)
+    (setq gen:sum x))
+
+(gen:init 20) &rarr; 20
+
+(gen) &rarr; 21
+(gen) &rarr; 22
+</pre>
+
+<h3>Functions using self modifying code</h3>
+
+<p>The first class nature of lambda expressions in newLISP makes 
+it possible to write self modifying code:</p>
+
+<pre>
+;; sum accumulator
+(define (sum (x 0)) (inc 0 x))
+
+(sum 1)    &rarr; 1
+(sum 2)    &rarr; 3
+(sum 100)  &rarr; 103
+(sum)      &rarr; 103
+
+sum  &rarr; (lambda ((x 0)) (inc 103 x))
+</pre>
+
+<p>The following example shows a function making a self modifying 
+stream function using <tt>expand</tt> :</p>
+
+<pre>
+(define (make-stream lst)
+    (letex (stream lst) 
+        (lambda () (pop 'stream))))
+
+(set 'lst '(a b c d e f g h))
+(define mystream (make-stream lst))
+
+(mystream)  &rarr; a
+(mystream)  &rarr; b
+(mystream)  &rarr; c
+</pre>
+
+<p>Because <tt>pop</tt> works on both: lists and strings, the same 
+function factory can be used for a string stream:</p>
+
+<pre>
+(set 'str "abcddefgh")
+(define mystream (make-stream str))
+
+(mystream)  &rarr; "a"
+(mystream)  &rarr; "c"
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-10"></a>
+<h2>10. Text processing</h2>
+
+<h3>Regular expressions</h3>
+
+<p>Regular expressions in newLISP can be used in a number of functions:</p>
+
+<table  summary='table'>
+<tr align='left'><th> function </th><th> function description </th></tr>
+<tr><td> <tt>directory</tt></td><td> Return a list of files whose names match a pattern.</td></tr>
+<tr><td> <tt>ends-with</tt></td><td> Test if a string ends with a key string or pattern.</td></tr>
+<tr><td> <tt>find</tt></td><td> Find the position of a pattern.</td></tr>
+<tr><td> <tt>find-all</tt></td><td> Assemble a list of all patterns found.</td></tr>
+<tr><td> <tt>parse</tt></td><td> Break a string into tokens at patterns found between tokens.</td></tr>
+<tr><td> <tt>regex</tt></td><td> Find patterns and returns a list of all sub patterns found, with offset and length.</td></tr>
+<tr><td> <tt>replace</tt></td><td> Replace found patterns with a user defined function, which can take as input the patterns themselves.</td></tr>
+<tr><td> <tt>search</tt></td><td> Search for a pattern in a file.</td></tr>
+<tr><td> <tt>starts-with</tt></td><td> Test if a string starts with a key string or pattern.</td></tr>
+</table>
+<p>The functions find, regex, replace and search store pattern matching results in the system variables $0 to $15. See the newLISP Users Manual for details.</p>
+
+<p>The following paragraphs show frequently-used algorithms for scanning and tokenizing text.</p>
+
+<h3>Scanning text</h3>
+
+<p>The <tt>replace</tt> function, together with a regular expression pattern, can be used to scan text. The pattern in this case describes the tokens scanned for. As each token is found, it is pushed on a list. The work is done in the replacement expression part of <tt>replace</tt>. This example saves all files linked on a web page:</p>
+
+<pre>
+#!/usr/bin/newlisp
+
+; tokenize using replace with regular expressions
+; names are of the form &lt;a href="example.lsp"&gt;example.lsp&lt;/a&gt;
+   
+(set 'page (get-url "http://newlisp.digidep.net/scripts/"))
+(replace {&gt;(.*lsp)&lt;} page (first (push $1 links)) 0) ; old technique
+;(set 'links (find-all {&gt;(.*lsp)&lt;} page $1)) ; new technique
+  
+(dolist (fname links)
+   (write-file fname (get-url (append "http://newlisp.digidep.net/scripts/" fname)))
+   (println "-&gt;" fname))
+
+(exit)
+</pre>
+
+<p>Curly braces (<tt>{</tt>,<tt>}</tt>) are used in the regular expression pattern to avoid having to escape the quotes (<tt>"</tt>) or other characters that have special meanings in regular expressions.</p>
+
+<p>The following alternative technique is even shorter. The <tt>find-all</tt> function puts all matching strings into a list:</p>
+
+<pre>
+(set 'links (find-all {&gt;(.*lsp)&lt;} page $1)) ; new technique
+</pre>
+
+<p>In an additional expression <tt>find-all</tt> can be directed to do additional work with the sub expressions found:</p>
+
+<pre>
+(find-all {(new)(lisp)} "newLISPisNEWLISP" (append $2 $1) 1)
+โ†’ ("LISPnew" "LISPNEW")
+</pre>
+
+<p>In the last example <tt>find-all</tt> appends the sub expressions found in reverse order before returning them in the result list.</p>
+
+<p>Another technique for tokenizing text uses <tt>parse</tt>. Whereas with <tt>replace</tt> and <tt>find-all</tt> the regular expression defined the token, when using <tt>parse</tt>, the regex pattern describes the space between the tokens:</p>
+
+<pre>
+; tokenize using parse
+(set 'str "1 2,3,4 5, 6 7  8")
+(parse str {,\ *|\ +,*} 0)
+โ†’ ("1" "2" "3" "4" "5" "6" "7" "8")
+</pre>
+
+<p>Without the curly braces in the parse pattern, the backslashes would need to be doubled. Note that there is a space after each backslash.</p>
+
+<h3>Appending strings</h3>
+
+<p>When appending strings append and join can be used to form a new string:</p>
+
+<pre>
+(set 'lstr (map string (rand 1000 100)))
+โ†’ ("976" "329" ... "692" "425")
+   
+; the wrong slowest way
+(set 'bigStr "")
+(dolist (s lstr)
+    (set 'bigStr (append bigStr s)))
+   
+; smarter way - 50 times faster
+;
+(apply append lstr)
+</pre>
+
+<p>Sometimes strings are not readily available in a list like in the above examples. In this case push can be used to push strings on a list while they get produced. The list then can be used as an argument for join, making the fastest method for putting strings together from existing pieces:</p>
+
+<pre>
+; smartest way - 300 times faster
+; join an existing list of strings
+;
+(join lstr) โ†’ "97632936869242555543 ...."
+   
+; join can specify a string between the elements
+; to be joined
+(join lstr "-") โ†’ "976-329-368-692-425-555-43 ...."
+</pre>
+
+<h3>Growing strings</h3>
+
+<p>Often it is best to grow a string in place. The function <tt>extend</tt> can be used to append to a string at the end. The function <tt>push</tt> can be used to insert new content at any place in the string.</p>.
+
+<pre>
+; smartest way - much faster on big strings
+; grow a string in place
+
+; using extend
+(set 'str "")
+(extend str "AB" "CD")
+str &rarr; "ABCD"
+
+; extending in a place
+(set 'L '(a b "CD" (e f)))
+(extend (L 2) "E")
+L &rarr; (a b "CDE" (e f))
+
+; using push
+(set 'str "")
+(push "AB" str -1)
+(push "CD" str -1)
+str &rarr; "ABCD"
+</pre>
+
+<h3>Rearranging strings</h3>
+
+<p>The function select for selecting elements from lists can also be used to select and re-arrange characters from strings:</p>
+
+<pre>
+(set 'str "eilnpsw")
+(select str '(3 0 -1 2 1 -2 -3)) โ†’ "newlisp"
+   
+; alternative syntax
+(select str 3 0 -1 2 1 -2 -3) โ†’ "newlisp"
+</pre>
+
+<p>The second syntax is useful when indexes are specified not as constants but occur as variables.</p>
+
+<h3>Modifying strings</h3>
+
+<p>newLISP has a variety of functions, which can destructively change a string:</p>
+
+<table  summary='table'>
+<tr align='left'><th> function </th><th> description </th></tr>
+<tr><td> <tt>extend</tt></td><td>Extend a string with another string.</td></tr>
+<tr><td> <tt>push pop</tt></td><td> Insert or extract one or more characters at a specific position.</td></tr>
+<tr><td> <tt>replace</tt></td><td> Replace all occurrences of a string or string pattern with a string.</td></tr>
+<tr><td> <tt>setf</tt></td><td> Replace a character in a string with one or more characters.</td></tr>
+</table>
+<p><tt>replace</tt> can also be used to remove all occurrences of string or string pattern when specifying an empty string <tt>""</tt> as replacement.</p>
+
+<p>When indexing strings with either <tt>nth</tt> or implicit indexing, the string is addressed at <em>character</em> rather than <em>byte</em> boundaries to work correctly on UTF-8 enabled versions of newLISP. A UTF-8 character can contain more than one byte.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-11"></a>
+<h2>11. Dictionaries and hashes</h2>
+
+<h3>Hash-like key โ†’ value access</h3>
+
+<p>newLISP has functions to create and manipulate symbols using the functions <tt>sym</tt> and a special syntax of the function <tt>context</tt>. In older versions of newLISP, these functions were used to program hash-like creation and access of key-value pairs. Now a shorter and more convenient method is available, using the un-initialized <tt>default functor</tt> of a namespace context:</p>
+
+<pre>
+(define Myhash:Myhash) ; establish the namespace and default functor
+</pre>
+
+<p>As an alternative to the above methods, the predefined namespace and default functor <tt>Tree</tt> can be used to instantiate a new one:</p>
+
+<pre>
+(new Tree 'Myhash)
+</pre>
+
+<p>Both methods produce the same result, but the second method also protects the default functor <tt>Myhash:Myhash</tt> from change.</p>
+
+<p>A <em>default functor</em> is the symbol with the same name as the namespace (context) it belongs to. If this default functor symbol does not contain anything except <tt>nil</tt>, it works like a hash function:</p>
+
+<pre>
+(Myhash "var" 123) ; create and set variable/value pair
+ 
+(Myhash "var") โ†’ 123 ; retrieve value
+ 
+(Myhash "foo" "hello")
+ 
+(Myhash "bar" '(q w e r t y))
+ 
+(Myhash "!*@$" '(a b c))
+
+; numbers can be used too and will be converted to strings internally
+
+(Myhash 555 42)
+
+(Myhash 555) โ†’ 42
+</pre>
+
+<p>Setting a hash symbol to <tt>nil</tt> will effectively erase it:</p>
+
+<pre>
+(Myhash "bar" nil)
+</pre>
+
+<p>The key can be any string; newLISP prevents symbol clashes with built-in newLISP symbols by prepending an underscore character (_) to all key strings internally. The value can be any string, number or any other newLISP s-expression.</p>
+
+<p>The <tt>Myhash</tt> namespace can be transformed in an association list:</p>
+
+<pre>
+(Myhash) โ†’ (("!*@$" (a b c)) ("foo" "hello") ("var" 123))
+</pre>
+
+<p>Or the raw contents of <tt>Myhash</tt> can be shown using the <tt>symbols</tt> function:</p>
+
+<pre>
+(symbols Myhash) โ†’ (Myhash:Myhash Myhash:_!*@$ Myhash:_foo Myhash:_var)
+</pre>
+
+<p>Dictionaries can be built by converting an existing association list:</p>
+
+<pre>
+(set 'aList '(("one" 1) ("two" 2) ("three")))
+ 
+(Myhash aList)
+ 
+(Myhash) โ†’ (("!*@$" (a b c)) ("foo" "hello") ("one" 1) ("three" nil) ("two" 2) ("var" 123))
+</pre>
+
+<h3>Saving and loading dictionaries</h3>
+
+<p>The dictionary can be easily saved to a file by serializing the namespace <tt>Myhash</tt>:</p>
+
+<pre>
+(save "Myhash.lsp" 'Myhash)
+</pre>
+
+<p>The whole namespace is saved to the file <tt>Myhash.lsp</tt> and can be reloaded into newLISP at a later time:</p>
+
+<pre>
+(load "Myhash")
+</pre>
+
+<p>Note that hashes create contexts similar to the <tt>bayes-train</tt> function. All string keys are prepended with an underscore and then transformed into a symbol. This means that namespaces created using <tt>bayes-train</tt> can be used like hashes to retrieve words and their statistics. See the <tt>bayes-train</tt> function in the manual for more detail.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-12"></a>
+<h2>12. TCP/IP client server</h2>
+
+<h3>Open connection</h3>
+
+<p>In this pattern the server keeps the connection open until the client closes the connection, then the server loops into a new <tt>net-accept</tt>:</p>
+
+<pre>
+; sender listens
+(constant 'max-bytes 1024)
+(if (not (set 'listen (net-listen 123)))
+    (print (net-error)))
+(while (not (net-error))
+    (set 'connection (net-accept listen)) ; blocking here
+    (while (not (net-error))
+         (net-receive connection message-from-client max-bytes)
+         .... process message from client ...
+         .... configure message to client ...
+         (net-send connection message-to-client)) 
+)
+</pre>
+
+<p>and the client:</p>
+
+<pre>
+; client connects to sender
+(if (not (set 'connection (net-connect "host.com" 123)))
+    (println (net-error)))
+; maximum bytes to receive
+(constant 'max-bytes 1024)
+; message send-receive loop
+(while (not (net-error))
+     .... configure message to server ...
+     (net-send connection message-to-server)
+     (net-receive connection message-from-server max-bytes)
+     .... process message-from-server ...
+)
+</pre>
+
+<h3>Closed transaction</h3>
+
+<p>In this pattern the server closes the connection after each transaction exchange of messages.</p>
+
+<pre>
+; sender
+(while (not (net-error))
+    (set 'connection (net-accept listen)) ; blocking here
+    (net-receive connection message-from-client max-bytes)
+        .... process message from client ...
+        .... configure message to client ...
+    (net-send connection message-to-client)
+    (close connection)
+)
+</pre>
+
+<p>and the client again tries to connect to the sender:</p>
+
+<pre> 
+; client
+(unless (set 'connection (net-connect "host.com" 123))
+    (println (net-error))
+    (exit))
+; maximum bytes to receive
+(constant 'max-bytes 1024)
+  .... configure message to server ...
+(net-send connection message-to-server)
+(net-receive connection message-from-server max-bytes)
+  .... process message-from-server ...
+</pre>
+
+<p>There are many different ways to set up a client/server connection, see also the examples in the newLISP manual.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-13"></a>
+<h2>13. UDP communications</h2>
+
+<p>They are fast and need less setup than TCP/IP and offer <tt>multi casting</tt>. UDP is also less reliable because the protocol does less checking, i.e. of correct packet sequence or if all packets are received. This is normally no problem when not working on the Internet but in a well controlled local network or when doing machine control. A simple more specific protocol could be made part of the message.</p>
+
+<h3>Open connection</h3>
+
+<p>In this example the server keeps the connection open. UDP communications with net-listen, net-receive-from and net-send-to can block on receiving.</p>
+
+<p>Note that both, the client and server use <tt>net-listen</tt> with the <tt>"udp"</tt> option. In this case <tt>net-listen</tt> is used only for binding the socket to the address, it is not used for listening for a connection. The server could receive messages from several clients. The <tt>net-send-to</tt> function extracts the target address from the message received.</p>
+
+<p>The sender:</p>
+
+<pre>
+; sender
+(set 'socket (net-listen 10001 "localhost" "udp"))
+(if socket (println "server listening on port " 10001)
+   (println (net-error)))
+(while (not (net-error))
+    (set 'msg (net-receive-from socket 255))
+    (println "-&gt; " msg)
+    (net-send-to (first (parse (nth 1 msg) ":"))
+                 (nth 2 msg) (upper-case (first msg)) socket))
+(exit)
+</pre>
+
+<p>and the client:</p>
+
+<pre>
+(set 'socket (net-listen 10002 "" "udp"))
+(if (not socket) (println (net-error)))
+(while (not (net-error))
+    (print "enter something -&gt; ")
+    (net-send-to  "127.0.0.1" 10001 (read-line) socket)
+    (net-receive socket buff 255)
+    (println "=&gt; " buff))
+(exit)
+</pre>
+
+<h3>Closed transaction</h3>
+
+<p>This form is sometimes used for controlling hardware or equipment. No setup is required, just one function for sending, another one for receiving.</p>
+
+<pre>
+; wait for data gram with maximum 20 bytes
+(net-receive-udp 1001 20)
+; or
+(net-receive-udp 1001 20 5000000)  ; wait for max 5 seconds
+; the sender
+(net-send-udp "host.com" 1001 "Hello")
+</pre>
+
+<p>MS Windows and Unix's show different behavior when sending less or more bytes than specified on the receiving end.</p>
+
+<h3>Multi-cast communications</h3>
+
+<p>In this scheme the server subscribes to one of a range of multi cast addresses using the net-listen function.</p>
+
+<pre>
+; example server
+(net-listen 4096 "226.0.0.1" "multi") โ†’ 5
+(net-receive-from 5 20)
+ 
+; example client I
+(net-connect "226.0.0.1" 4096 "multi") โ†’ 3
+(net-send 3 "hello")
+; example client II
+(net-connect "" 4096 "multi") โ†’ 3
+(net-send-to "226.0.0.1" 4096 "hello" 3)
+</pre>
+
+<p>The connection in the example is blocking on <tt>net-receive</tt> but could be de-blocked using <tt>net-select</tt> or <tt>net-peek</tt></p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-14"></a>
+<h2>14. Non-blocking communications</h2>
+
+<h3>Using <tt>net-select</tt></h3>
+
+<p>In all previous patterns the client blocks when in receive. The net-select call can be used to unblock communications:</p>
+
+<pre> 
+; optionally poll for arriving data with 100ms timeout
+(while (not (net-select connection "r" 100000))
+    (do-something-while-waiting ...))
+ 
+(net-receive...)
+</pre>
+
+<p><tt>connection</tt> can be a single number for a connection socket or a list of numbers to wait on various sockets.</p>
+
+<h3>Using <tt>net-peek</tt></h3>
+
+<p><tt>net-peek</tt> returns the number of characters pending to read.</p>
+
+<pre>
+(while ( = (net-peek aSock) 0)
+    (do-something-while-waiting ...))
+(net-receive...)
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-15"></a>
+<h2>15. Controlling other applications</h2>
+
+<h3>Using <tt>exec</tt></h3>
+
+<p>This method is only suited for short exchanges, executing one command and receiving the output.</p>
+
+<pre>
+(exec "ls *.c") โ†’ ("." ".." "util.c" "example.ls")
+</pre>
+
+<p>The <tt>exec</tt> function opens a process pipe for the Unix command-line utility <tt>ls</tt> and collects each line of STDOUT into a list of strings.</p>
+
+<p>Most following examples use <tt>process</tt> to launch an application. This function returns immediately after launching the other application and does not block.</p>
+
+<p>In all of the following patterns the server is not independent but controlled by the client, which launches the server and then communicates via a line oriented protocol:</p>
+
+<pre>
+     โ†’ launch server
+     โ†’ talk to server
+     โ† wait for response from server
+     โ†’ talk to server
+     โ† wait for response from server
+          ...
+</pre>
+
+<p>Sometimes a sleep time is necessary on the client side to wait for the server to be ready loading. Except for the first example, most of these are condensed snippets from GTK-Server from [http://www.gtk-server.org www.gtk-server.org]. The basic program logic will be the same for any other application.</p>
+
+<h3>STD I/O pipes</h3>
+
+<p>The <tt>process</tt> function allows specifying 2 pipes for communications with the launched application.</p>
+
+<pre>
+; setup communications
+(map set '(myin tcout) (pipe))
+(map set '(tcin myout) (pipe))
+(process "/usr/bin/wish" tcin tcout)
+ 
+; make GUI
+(write myout
+[text]
+wm geometry . 250x90
+wm title . "Tcl/Tk and newLISP"
+bind . &lt;Destroy&gt; {puts {(exit)}}
+[/text])
+ 
+; run event loop
+(while (read-line myin)
+    (eval-string (current-line))
+)
+</pre>
+
+<p>This is the preferred way to set up longer lasting, bidirectional communications with Unix command line utilities and languages. For one-command exchanges the <tt>exec</tt> function does the job shorter.</p>
+
+<p>For a more elaborate Tcl/Tk example see the application <tt>examples/tcltk.lsp</tt> in the source distribution.</p>
+
+<h3>Communicate via TCP/IP</h3>
+
+<pre>
+; Define communication function
+(define (gtk str , tmp)
+    (net-send connection str)
+    (net-receive connection tmp 64)
+    tmp)
+ 
+; Start the gtk-server
+(process "gtk-server tcp localhost:50000")
+(sleep 1000)
+ 
+; Connect to the GTK-server
+(set 'connection (net-connect "localhost" 50000))
+(set 'result (gtk "gtk_init NULL NULL"))
+(set 'result (gtk "gtk_window_new 0"))
+               .....
+</pre>
+
+<h3>Communicate via named FIFO</h3>
+
+<p>Make a FIFO first (looks like a special file node):</p>
+
+<pre>
+(exec "mkfifo myfifo")
+ 
+; or alternatively
+ 
+(import "/lib/libc.so.6" "mkfifo")
+(mkfifo "/tmp/myfifo" 0777)
+ 
+; Define communication function
+(define (gtk str)
+	(set 'handle (open "myfifo" "write"))
+	(write handle str)
+	(close handle)
+	(set 'handle (open "myfifo" "read"))
+	(read handle tmp 20)
+	(close handle)
+tmp)
+</pre>
+
+<h3>Communicate via UDP</h3>
+
+<p>Note that the listen function with "udp" option just binds the sockets to a address/hardware but not actually listens as in TCP/IP.</p>
+
+<pre>
+; Define communication function
+(define (gtk str , tmp)
+(net-send-to "localhost" 50000 str socket)
+(net-receive socket 'tmp net-buffer)
+tmp)
+ 
+; Start the gtk-server
+(define (start)
+	(process "gtk-server udp localhost:50000")
+	(sleep 500)
+	(set 'socket (net-listen 50001 "localhost" "udp")) )
+ 
+(set 'result (gtk "gtk_init NULL NULL"))
+ 
+(set 'result (gtk "gtk_window_new 0"))
+.....
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-16"></a>
+<h2>16. Launching apps blocking</h2>
+
+<h3>Shell execution</h3>
+
+<p>This is frequently used from newLISP's interactive command line to execute processes in a blocking fashion, which need a shell to run:</p>
+
+<pre>
+(! "ls -ltr")
+</pre>
+
+<p>There is an interesting variant of this form working not inside a newLISP expression, but only on the command line:</p>
+
+<pre>
+!ls -ltr
+</pre>
+
+<p>The <tt>!</tt> should be the first character on the command line. This form works like a shell escape in the VI editor. It is useful for invoking an editor or doing quick shell work without completely leaving the newLISP console.</p>
+
+<h3>Capturing std-out</h3>
+
+<pre>
+(exec "ls /") โ†’ ("bin" "etc" "home" "lib")
+</pre>
+
+<h3>Feeding std-in</h3>
+
+<pre>
+(exec "script.cgi" cgi-input)
+</pre>
+
+<p>In this example <tt>cgi-input</tt> could contain a string feeding a query input, normally coming from a web server. Note that output in this case is written directly to the screen, and cannot be returned to newLISP. Use process and pipe for two way std i/o communications with other applications.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-17"></a>
+<h2>17. Semaphores, shared memory</h2>
+
+<p>Shared memory, semaphores and processes work frequently together. Semaphores can synchronize tasks in different process threads and shared memory can be used to communicate between them.</p>
+
+<p>The following is a more complex example showing the working of all three mechanisms at the same time.</p>
+
+<p>The producer loops through all n values from i = 0 to n - 1 and puts each value into shared memory where it is picked up by the consumer thread. Semaphores are used to signal that a data value is ready for reading.</p>
+
+<p>Although controlling processes with semaphores and shared memory is fast, it is also error prone, specially when more the two processes are involved. It is easier to control multiple processes using the Cilk API and messaging between processes. See chapters 18. and 19. for these topics.</p>
+
+<pre>
+#!/usr/bin/newlisp
+# prodcons.lsp -  Producer/consumer
+#
+# usage of 'fork', 'wait-pid', 'semaphore' and 'share'
+ 
+(when (= ostype "Windows")
+    (println "this will not run on Windows OS")
+    (exit))
+ 
+(constant 'wait -1 'sig 1 'release 0)
+ 
+(define (consumer n)
+    (set 'i 0)
+    (while (&lt; i n)
+        (semaphore cons-sem wait)
+        (println (set 'i (share data)) " &lt;-")
+        (semaphore prod-sem sig))
+    (exit))
+ 
+(define (producer n)
+    (for (i 1 n)
+        (semaphore prod-sem wait)
+        (println "-&gt; " (share data i))
+        semaphore cons-sem sig))
+    (exit))
+ 
+(define (run n)
+    (set 'data (share))
+    (share data 0)
+    (set 'prod-sem (semaphore)) ; get semaphores
+    (set 'cons-sem (semaphore))
+    (set 'prod-pid (fork (producer n))) ; start processes
+    (set 'cons-pid (fork (consumer n)))
+    (semaphore prod-sem sig) ; get producer started
+    (wait-pid prod-pid) ; wait for processes to finish
+    (wait-pid cons-pid) ;
+    (semaphore cons-sem release) ; release semaphores
+    (semaphore prod-sem release))
+ 
+(run 10)
+ 
+(exit)
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-18"></a>
+<h2>18. Multiprocessing and Cilk</h2>
+
+<p>On multiprocessor CPUs the operating system will distribute processes and child processes created on different processor cores in an optimized fashion. newLISP offers a simple API which does all the work of launching processes and does the synchronized collection of evaluation results. The <a href="http://supertech.csail.mit.edu/cilk/">Cilk</a> API consists of only 3 function calls, implemented in newLISP as <tt>spawn</tt>, <tt>sync</tt> and <tt>abort</tt></p>
+
+<p>Since v.10.1 newLISP's <tt>message</tt> function enables communications between parent and child processes. For more details about this, see the next chapter <b>19. Message exchange</b>.</p>
+
+<h3>Starting concurrent processes</h3>
+
+<pre>
+; calculate primes in a range
+(define (primes from to)
+    (let (plist '())
+    (for (i from to)
+        (if (= 1 (length (factor i)))
+        (push i plist -1)))
+plist))
+ 
+; start child processes
+(set 'start (time-of-day))
+ 
+(spawn 'p1 (primes 1 1000000))
+(spawn 'p2 (primes 1000001 2000000))
+(spawn 'p3 (primes 2000001 3000000))
+(spawn 'p4 (primes 3000001 4000000))
+ 
+; wait for a maximum of 60 seconds for all tasks to finish
+(sync 60000) ; returns true if all finished in time
+; p1, p2, p3 and p4 now each contain a lists of primes
+</pre>
+
+<p>The example shows how the task of generating a range of prime numbers can be organized for parallel processing by splitting the range into sub-ranges. All <tt>spawn</tt> calls will return immediately, but <tt>sync</tt> will block until all child processes have finished and the result lists are available in the four variables <tt>p1</tt> to <tt>p4</tt>.</p>
+
+<h3>Watching progress</h3>
+
+<p>When the timeout value specified is too short for all processes to finish, <tt>sync</tt> will return <tt>nil</tt>. This can be used to watch progress:</p>
+
+<pre>
+; print a dot after each 2 seconds of waiting
+(until (sync 2000) (println "."))
+</pre>
+
+<p>When <tt>sync</tt> is called without parameters, it returns a list of still active process ids:</p>
+
+<pre>
+; show a list of pending process ids after
+;each three-tenths of a second
+(until (sync 300) (println (sync)))
+</pre>
+
+<h3>Invoking spawn recursively</h3>
+
+<pre>
+(define (fibo n)
+    (let (f1 nil f2 nil)
+        (if (&lt; n 2) 1
+            (begin
+                (spawn 'f1 (fibo (- n 1)))
+                (spawn 'f2 (fibo (- n 2)))
+                (sync 10000)
+                (+ f1 f2)))))
+ 
+(fibo 7)  โ†’ 21
+</pre>
+
+<h3>Event driven notification</h3>
+
+<p>When processes launched with <tt>spawn</tt> finish, an <tt>inlet</tt> function specified in the <tt>sync</tt> statement can be called.</p>
+
+<pre>
+(define (report pid)
+    (println "process: " pid " has returned"))
+ 
+; call the report function, when a child returns
+(sync 10000 report)
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-19"></a>
+<h2>19. Message exchange</h2>
+
+<p>Parent and child processes started with <tt>spawn</tt> can exchange messages. 
+Messages flow either from the parent to child processes or from child processes 
+to the parent. By means of evaluating messages in the parent process, the parent 
+process can be used as a proxy routing messages between child peers.</p>
+
+<p>Internally newLISP uses UNIX local domain sockets for dual message queues
+between parent and child processes. When the receiving side of a queue is empty 
+a <tt>receive</tt> call will return <tt>nil</tt>. Likewise when a queue is full,
+a <tt>send</tt> call will return <tt>nil</tt>. The looping function <tt>until</tt> 
+can be used to make <tt>send</tt> and <tt>receive</tt> statements blocking.</p>
+
+<h3>Blocking message sending and receiving</h3>
+
+<pre>
+     ; blocking sender
+     (until (send pid msg))     ; true when a msg queued up
+ 
+     ; blocking receiver
+     (until (receive pid msg))  ; true after a msg is read
+</pre>
+
+<h3>Blocking messages exchange</h3>
+
+<p>The parent process loops through all child process IDs and uses the
+<tt>(until (receive cpid msg))</tt> form of <tt>receive</tt> to wait
+for pending messages. <tt>(sync)</tt> returns a list of all child PIDs
+from processes launched by <tt>spawn</tt>.</p>
+
+<pre>
+#!/usr/bin/newlisp 
+
+; child process transmits random numbers
+(define (child-process)
+    (set 'ppid (sys-info -4)) ; get parent pid
+    (while true
+        (until (send ppid (rand 100))))
+)
+
+; parent starts 5  child processes, listens and displays
+; the true flag enables usage of send and receive 
+
+(dotimes (i 5) (spawn 'result (child-process) true))
+
+(for (i 1 3)
+    (dolist (cpid (sync)) ; iterate thru pending child PIDs
+        (until (receive cpid msg))
+        (print "pid:" cpid "-&gt;>" (format "%-2d  " msg)))
+    (println)
+)
+
+(abort) ; cancel child-processes
+(exit)
+</pre>
+
+<p>generates this output:</p>
+
+<pre>
+pid:53181-&gt;47  pid:53180-&gt;61  pid:53179-&gt;75  pid:53178-&gt;39  pid:53177-&gt;3
+pid:53181-&gt;59  pid:53180-&gt;12  pid:53179-&gt;20  pid:53178-&gt;77  pid:53177-&gt;47
+pid:53181-&gt;6   pid:53180-&gt;56  pid:53179-&gt;96  pid:53178-&gt;78  pid:53177-&gt;18
+</pre>
+
+<h3>Non blocking message exchange</h3>
+
+<p>Neither the sending child process nor the receiving parent process block. 
+Each sends and receives messages as fast as possible. There is no guarantee
+that all messages will be delivered. It depends on the size of the sending
+queue and the speed of pick-up of messages by the parent process. If the
+sending queue for a child process is full, the <tt>(send ppid (rand 100))</tt> 
+call will fail and return <tt>nil</tt>.</p>
+
+<pre>
+#!/usr/bin/newlisp
+
+; child process transmits random numbers non-blocking
+; not all calls succeed
+(set 'start (time-of-day))
+ 
+(define (child-process)
+    (set 'ppid (sys-info -4)) ; get parent pid
+    (while true
+        (send ppid (rand 100)))
+)
+ 
+; parent starts 5  child processes, listens and displays
+(dotimes (i 5) (spawn 'result (child-process) true))
+ 
+(set 'N 1000)
+ 
+(until finished
+    (if (= (inc counter) N) (set 'finished true))
+    (dolist (cpid (receive)) ; iterate thru ready child pids
+        (receive cpid msg)
+    (if msg (print "pid:" cpid "-&gt;" (format "%-2d  \r" msg))))
+)
+ 
+(abort) ; cancel child-processes
+(sleep 300)
+ 
+(exit)
+</pre>
+
+<h3>Message timeouts</h3>
+
+<p>A messaging statement can be made to block for a certain time:</p>
+
+<pre>
+(define (receive-timeout pid msec)
+    (let ( (start (time-of-day)) (msg nil))
+        (until (receive pid msg)
+            (if (&gt; (- (time-of-day) start) 1000) (throw-error "timeout")))
+    msg)
+)
+; use it
+    
+(receive-timeout pid 1000)  ; return message or throw error after 1 second
+</pre>
+
+<p>In this example blocking will occur for 1000 ms. Many methods exist to implement timeout behavior.</p>
+
+<h3>Evaluating messages</h3>
+
+<p>Messages sent can contain expressions which can be evaluated in the recipient's environment. 
+This way variables can be set in the evaluator's environment, and messages can be routed to other 
+processes. The following example implements a message router:</p>
+
+<pre>
+#!/usr/bin/newlisp
+
+; sender child process of the message
+(set 'A (spawn 'result 
+    (begin
+        (dotimes (i 3)
+            (set 'ppid (sys-info -4))
+            /* the following statement in msg will be evaluated in the proxy */
+            (set 'msg '(until (send B (string "greetings from " A))))
+            (until (send ppid msg)))
+        (until (send ppid '(begin 
+            (sleep 200) ; make sure all else is printed
+            (println "parent exiting ...\n")
+            (set 'finished true))))) true)) 
+
+; receiver child process of the message
+(set 'B (spawn 'result 
+    (begin
+        (set 'ppid (sys-info -4))
+        (while true
+            (until (receive ppid msg))
+            (println msg)
+            (unless (= msg (string "greetings from " A))
+                (println "ERROR in proxy message: " msg)))) true))
+
+(until finished (if (receive A msg) (eval msg))) ; proxy loop
+
+(abort)
+(exit)
+</pre>
+
+<h3>Acting as a proxy</h3>
+
+<p>In the last example program the expression:</p>
+
+<pre>
+; content of message to be evaluated by proxy
+(until (send B (string "greetings from " A)))
+</pre>
+
+<p>A programming statement sent from child process ID A to the parent, 
+where it is evaluated, causing a message to be sent to child process B. 
+The parent process acts as a proxy agent for the child process A.</p>
+
+<pre>
+; the set statement is evaluated in the proxy
+(until (send ppid '(set 'finished true)))
+</pre>
+
+<p>The expression <tt>(set 'finished true)</tt> is sent to the parent where it gets 
+evaluated and causes the parent's <tt>until</tt> loop to finish.</p>
+
+<p>The <tt>sleep</tt> statement in the A process ensures that the 
+<tt>"parent exiting ..."</tt> message does not appear
+before all received messages are reported by process identified with B.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-20"></a>
+<h2>20. Databases and lookup tables</h2>
+
+<p>For smaller tables of not more than a few hundred entries association lists can be
+used. For larger databases use dictionaries and hashes as described in
+<a href="#toc-11">chapter 11.</a></p>
+
+<h3>Association lists</h3>
+
+<p>The association list is a classic LISP data structure for storing information for associative retrieval:</p>
+
+<pre>
+; creating association lists
+; pushing at the end with -1 is optimized and
+; as fast as pushing in front
+ 
+(push '("John Doe" "123-5555" 1200.00) Persons -1)
+(push '("Jane Doe" "456-7777" 2000.00) Persons -1)
+.....
+ 
+Persons โ†’  (
+("John Doe" "123-5555" 1200.00)
+("Jane Doe" "456-7777" 2000.00) ...)
+ 
+; access/lookup data records
+(assoc "John Doe" Persons)
+ 
+โ†’ ("John Doe" "123-5555" 1200.00 male)
+ 
+(assoc "Jane Doe" Persons)
+ 
+โ†’ ("Jane Doe" "456-7777" 2000.00 female)
+</pre>
+
+<p>newLISP has a lookup function similar to what is used in spreadsheet software. This function which works like a combination of <tt>assoc</tt> and <tt>nth</tt> can find the association and pick a specific member of the data record at the same time:</p>
+
+<pre>
+(lookup "John Doe" Persons 0)   โ†’ "123-555"
+(lookup "John Doe" Persons -1)  โ†’ male
+(lookup "Jane Doe" Persons 1)   โ†’ 2000.00
+(lookup "Jane Doe" Persons -2)  โ†’ 2000.00
+ 
+; update data records
+(setf (assoc "John Doe" Persons)
+    '("John Doe" "123-5555" 900.00 male))
+ 
+; replace as a function of existing/replaced data
+(setf (assoc "John Doe" Persons) (update-person $it))
+ 
+; delete data records
+(replace (assoc "John Doe" Persons) Persons)
+</pre>
+
+<h3>Nested associations</h3>
+
+<p>If the data part of an association is itself an association list, we have a nested association:</p>
+
+<pre>
+(set 'persons '(
+    ("Anne" (address (country "USA") (city "New York")))
+    ("Jean" (address (country "France") (city "Paris")))
+))
+</pre>
+
+<p>A different syntax of the <tt>assoc</tt> function can be used to specify multiple keys:</p>
+
+<pre>
+; one key
+(assoc "Anne" persons) โ†’ ("Anne" (address (country "USA") (city "New York")))
+ 
+; two keys
+(assoc '("Anne" address) persons) โ†’ (address (country "USA") (city "New York"))
+ 
+; three keys
+(assoc '("Anne" address city) persons) โ†’ (city "New York")
+ 
+; three keys in a vector
+(set 'anne-city '("Anne" address city))
+(assoc anne-city persons) โ†’ (city "New York")
+</pre>
+
+<p>When all keys are symbols, as is in <tt>address</tt>, <tt>country</tt> 
+and <tt>city</tt>, simple and nested associations in newLISP have the same 
+format as newLISP <tt>FOOP</tt> (Functional Object Oriented Programming) objects. 
+See the users manual chapter "18. Functional object-oriented programming" for details.</p>
+
+<h3>Updating nested associations</h3>
+
+<p>The functions <tt>assoc</tt> and <tt>setf</tt> can be used to update simple or nested associations:</p>
+
+<pre>
+(setf (assoc '("Anne" address city) persons) '(city "Boston")) โ†’ (city "New York")
+</pre>
+
+<p><tt>setf</tt> always returns the newly set element.</p>
+
+<h3>Combining associations and hashes</h3>
+
+<p>Hashes and FOOP objects can be combined to form an in-memory database with keyed access.</p>
+
+<p>In the following example, data records are stored in a hash namespace and access is with the name of the person as a key.</p>
+
+<p><tt>setf</tt> and <tt>lookup</tt> are used to update nested FOOP objects:</p>
+
+<pre>
+(new Tree 'Person)
+(new Class 'Address)
+(new Class 'City)
+(new Class 'Telephone)
+ 
+ 
+(Person "John Doe" (Address (City "Small Town") (Telephone 5551234)))
+ 
+(lookup 'Telephone (Person "John Doe"))
+(setf (lookup 'Telephone (Person "John Doe")) 1234567)
+(setf (lookup 'City (Person "John Doe")) (lower-case $it))
+ 
+(Person "John Doe") โ†’ (Address (City "small town") (Telephone 1234567))
+</pre>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-21"></a>
+<h2>21. Distributed computing</h2>
+
+<p>Many of todays applications are distributed on to several computers on the network or distributed on to several processes on one CPU. Often both methods of distributing an application are used at the same time.</p>
+
+<p>newLISP has facilities to evaluate many expressions in parallel on different network nodes or processes running newLISP. The <tt>net-eval</tt> function does all the work necessary to communicate to other nodes, distribute expressions for evaluation and collect results in either a blocking or event driven fashion.</p>
+
+<p>The functions <tt>read-file</tt>, <tt>write-file</tt>, <tt>append-file</tt> and <tt>delete-file</tt> can also be used to access with files on remote nodes when using URLs in file specifications. In a similar way the functions <tt>load</tt> and <tt>save</tt> can be used to load and save code from and to remote nodes.</p>
+
+<p>newLISP uses existing HTTP protocols and newLISP command line behavior to implement this functionality. This means that programs can be debugged and tested using standard Unix applications like terminal, telnet or a web browser. This also enables easy integration of other tools and programs into distributed applications built with newLISP. For example the Unix utility <tt>netcat</tt> (<tt>nc</tt>) could be used to evaluate expressions remotely or a web browser could be used to retrieve webpages from nodes running a newLISP server.</p>
+
+<h3>Setting up in server mode</h3>
+
+<p>A newLISP server node is essentially a newLISP process listening to a network port and behaving like a newLISP command-line console and HTTP server for HTTP <tt>GET</tt>, <tt>PUT</tt>, <tt>POST</tt> and <tt>DELETE</tt> requests. Since version 9.1 newLISP server mode also answers <tt>CGI</tt> queries received by either <tt>GET</tt> or <tt>POST</tt> request.</p>
+
+<p>Two methods are used to start a newLISP server node. One results in a state full server, maintaining state in between communications with different clients, the other method a server with no state, reloading for every new client connection.</p>
+
+<h3>Start a state-full server</h3>
+
+<pre>
+newlisp -c -d 4711 &amp;
+ 
+newlisp myprog.lsp -c -d 4711 &amp;
+ 
+newlisp myprog.lsp -c -w /home/node25 -d 4711 &amp;
+</pre>
+
+<p>newLISP is now listening on port 4711, the &amp; (ampersand) sign tells newLISP to run in the background (Unix only). The <tt>-c</tt> switch suppresses command line prompts. newLISP now behaves like a newLISP console without prompts listening on port 4711 for command line like input. Any other available port could have been chosen. Note that on Unix, ports below 1024 need administrator access rights.</p>
+
+<p>The second example also pre-loads code. The third example also specifies a working directory using the <tt>-w</tt> option. If no working directory is specified using <tt>-w</tt>, the startup directory is assumed to be the working directory.</p>
+
+<p>After each transaction, when a connection closes, newLISP will go through a reset process, reinitialize stack and signals and go to the <tt>MAIN</tt> context. Only the contents of program and variable symbols will be preserved.</p>
+
+<h3>Stateless server with inetd</h3>
+
+<p>On Unix the <tt>inetd</tt> or <tt>xindetd</tt> facility can be used to start a stateless server. In this case the TCP/IP net connections are managed by a special Unix utility with the ability to handle multiple requests at the same time. For each connection made by a client the <tt>inetd</tt> or <tt>xinetd</tt> utility will start a fresh newLISP process. After the connection is closed the newLISP process will shut down.</p>
+
+<p>When nodes are not required to keep state, this is the preferred method for a newLISP server node, for handling multiple connections at the same time.</p>
+
+<p>The <tt>inetd</tt> or <tt>xinetd</tt> process needs to be configured using configuration files found in the <tt>/etc</tt> directory of most Unix installations.</p>
+
+<p>For both the <tt>inetd</tt> and <tt>xinetd</tt> configurations add the following line to the <tt>/etc/services</tt> file:</p>
+
+<pre>
+net-eval        4711/tcp     # newLISP net-eval requests
+</pre>
+
+<p>Note that any other port than <tt>4711</tt> could be supplied.</p>
+
+<p>When configuring <tt>inetd</tt> add also the following lines to the <tt>/etc/inetd.conf</tt> file:</p>
+
+<pre>
+net-eval  stream  tcp  nowait  root  /usr/bin/newlisp -c
+ 
+# as an alternative, a program can also be preloaded
+ 
+net-eval  stream  tcp  nowait  root  /usr/bin/newlisp myprog.lsp -c
+ 
+# a working directory can also be specified
+ 
+net-eval  stream  tcp  nowait  newlisp  /usr/bin/newlisp -c -w /usr/home/newlisp
+</pre>
+
+<p>The last line also specified a working directory and a user <tt>newlisp</tt> instead of the <tt>root</tt> user. This is a more secure mode limiting newLISP server node access to a specific user account with restricted permissions.</p>
+
+<p>On some Unix system a modern flavor of <tt>inetd</tt>: the <tt>xinetd</tt> facility can be used. Add the following configuration to a file <tt>/etc/xinet.d/net-eval</tt>:</p>
+
+<pre>
+service net-eval
+    {
+    socket_type = stream
+    wait = no
+    user = root
+    server = /usr/bin/newlisp
+    port = 4711
+    server_args = -c -w /home/node
+    }
+</pre>
+
+<p>Note that a variety of parameter combinations are possible to restrict access from different places or limit access to certain users. Consult the man-pages for <tt>inetd</tt> and <tt>xinetd</tt> for details.</p>
+
+<p>After configuring <tt>inetd</tt> or <tt>xinetd</tt> either process must be restarted to re-read the configuration files. This can be accomplished by sending the Unix <tt>HUP</tt> signal to either the <tt>inetd</tt> or <tt>xinetd</tt> process using the Unix <tt>kill</tt> or Unix <tt>nohup</tt> utility.</p>
+
+<p>On Mac OS X the <tt>launchd</tt> facility can be used in a similar fashion. The newLISP source distribution contains the file <tt>org.newlisp.newlisp.plist</tt> in the <tt>util/</tt> directory. This file can be used to launch newlisp server during OS boot time as a persistent server.</p>
+
+<h3>Test the server with telnet</h3>
+
+<p>A newLISP server node can be tested using the Unix <tt>telnet</tt> utility:</p>
+
+<pre>
+telnet localhost 4711
+ 
+; or when running on a different computer i.e. ip 192.168.1.100
+ 
+telnet 192.168.1.100 4711
+</pre>
+
+<p>Multi-line expressions can be entered by enclosing them in <tt>[cmd]</tt>, 
+<tt>[/cmd]</tt> tags, each tag on a separate line. Both the opening and closing 
+tags should be on separate lines. Although newLISP has a second, new
+multi-line mode for the interactive shell since version 10.3.0 without tags, 
+when using <tt>netcat</tt> or other Unix utilities, multi-line expressions still have 
+to be enclosed in <tt>[cmd]</tt>, <tt>[/cmd]</tt> tags.</p>
+
+<h3>Test with netcat on Unix</h3>
+
+<pre>
+echo '(symbols) (exit)' | nc localhost 4711
+</pre>
+
+<p>Or talking to a remote node:</p>
+
+<pre>
+echo '(symbols) (exit)' | nc 192.168.1.100 4711
+</pre>
+
+<p>In both examples <tt>netcat</tt> will echo back the result of evaluating the <tt>(symbols)</tt> expression.</p>
+
+<p>Multi-line expressions can be entered by enclosing them in <tt>[cmd]</tt>, <tt>[/cmd]</tt> tags, each tag on a separate line.</p>
+
+<h3>Test from the command line</h3>
+
+<p>The <tt>net-eval</tt> function as a syntax form for connecting to only one remote server node. This mode is practical for quick testing from the newLISP command line:</p>
+
+<pre>
+(net-eval "localhost" 4711 "(+ 3 4)" 1000) โ†’ 7
+ 
+; to a remote node
+ 
+(net-eval "192.168.1.100" 4711 {(upper-case "newlisp")} 1000) โ†’ "NEWLISP"
+</pre>
+
+<p>In the second example curly braces <tt>{,}</tt> are used to limit the program string for evaluation. This way quotes can be used to limit a string inside the expression.</p>
+
+<p>No <tt>[cmd]</tt>, <tt>[/cmd]</tt> tags are required when sending multi-line expressions. <tt>net-eval</tt> supplies these tags automatically.</p>
+
+<h3>Test HTTP with a browser</h3>
+
+<p>A newLISP server also understands simple HTTP <tt>GET</tt> and <tt>PUT</tt> requests. Enter the full path of a file in the address-bar of the browser:</p>
+
+<pre>
+http://localhost:4711//usr/share/newlisp/doc/newlisp_manual.html
+</pre>
+
+<p>The manual file is almost 800 Kbyte in size and will take a few seconds to load into the browser. Specify the port-number with a colon separated from the host-name or host IP. Note the double slash necessary to specify a file address relative to the root directory.</p>
+
+<h3>Evaluating remotely</h3>
+
+<p>When testing the correct installation of newLISP server nodes, we were already sending expressions to remote node for evaluation. Many times remote evaluation is used to split up a lengthy task into shorter subtasks for remote evaluation on different nodes.</p>
+
+<p>The first example is trivial, because it only evaluates several very simple expressions remotely, but it demonstrates the principles involved easily:</p>
+
+<pre>
+#!/usr/bin/newlisp
+ 
+(set 'result (net-eval '(
+    ("192.168.1.100" 4711 {(+ 3 4)})
+    ("192.168.1.101" 4711 {(+ 5 6)})
+    ("192.168.1.102" 4711 {(+ 7 8)})
+    ("192.168.1.103" 4711 {(+ 9 10)})
+    ("192.168.1.104" 4711 {(+ 11 12)})
+) 1000))
+ 
+ 
+(println "result: " result)
+ 
+(exit)
+</pre>
+
+<p>Running this program will produce the following output:</p>
+
+<pre>
+result: (7 11 15 19 23)
+</pre>
+
+<p>When running Unix and using an <tt>inetd</tt> or <tt>xinetd</tt> configured newLISP server, the servers and programs can be run on just one CPU, replacing all IP numbers with <tt>"localhost"</tt> or the same local IP number. The <tt>indetd</tt> or <tt>xinetd</tt> daemon will then start 5 independent newLISP processes. On MS Windows 5 state-full newLISP servers could be started on different port numbers to accomplish the same.</p>
+
+<p>Instead of collecting all results at once on the return of <tt>net-eval</tt>, a callback function can be used to receive and process results as they become available:</p>
+
+<pre>
+#!/usr/bin/newlisp
+ 
+(define (idle-loop p)
+    (if p (println p)))
+ 
+(set 'result (net-eval '(
+    ("192.168.1.100" 4711 {(+ 3 4)})
+    ("192.168.1.101" 4711 {(+ 5 6)})
+    ("192.168.1.102" 4711 {(+ 7 8)})
+    ("192.168.1.103" 4711 {(+ 9 10)})
+    ("192.168.1.104" 4711 {(+ 11 12)})
+) 1000 idle-loop))
+ 
+(exit)
+</pre>
+
+<p>While <tt>net-eval</tt> is waiting for results, it calls the function <tt>idle-loop</tt> repeatedly with parameter <tt>p</tt>. The parameter <tt>p</tt> is <tt>nil</tt> when no result was received during the last 1000 milli seconds, or <tt>p</tt> contains a list sent back from the remote node. The list contains the remote address and port and the evaluation result. The example shown would generate the following output:</p>
+
+<pre>
+("192.168.1.100" 4711 7)
+("192.168.1.101" 4711 11)
+("192.168.1.102" 4711 15)
+("192.168.1.103" 4711 19)
+("192.168.1.104" 4711 23)
+</pre>
+
+<p>For testing on just one CPU, replace addresses with <tt>"localhost"</tt>; the Unix <tt>inetd</tt> or <tt>xinetd</tt> daemon will start a separate process for each connection made and all listening on port <tt>4711</tt>. When using a state-full server on the same MS Windows CPU specify a different port number for each server.</p>
+
+<h3>Setting up the 'net-eval' parameter structure</h3>
+
+<p>In a networked environment where an application gets moved around, or server nodes with changing IP numbers are used, it is necessary to set up the node parameters in the <tt>net-eval</tt> parameter list as variables. The following more complex example shows how this can be done. The example also shows how a bigger piece of program text can be transferred to a remote node for evaluation and how this program piece can be customized for each node differently:</p>
+
+<pre>
+#!/usr/bin/newlisp
+ 
+; node parameters
+(set 'nodes '(
+    ("192.168.1.100" 4711)
+    ("192.168.1.101" 4711)
+    ("192.168.1.102" 4711)
+    ("192.168.1.103" 4711)
+    ("192.168.1.104" 4711)
+))
+ 
+; program template for nodes
+(set 'program [text]
+    (begin
+        (map set '(from to node) '(%d %d %d))
+        (for (x from to)
+		(if (= 1 (length (factor x)))
+        (push x primes -1)))
+    primes)
+[/text])
+ 
+; call back routine for net-eval
+(define (idle-loop p)
+    (when p
+        (println (p 0) ":" (p 1))
+        (push (p 2) primes))
+)
+ 
+(println "Sending request to nodes, and waiting ...")
+ 
+; machines could be on different IP addresses.
+; For this test 5 nodes are started on localhost
+(set 'result (net-eval (list
+    (list (nodes 0 0) (nodes 0 1) (format program 0 99999 1))
+    (list (nodes 1 0) (nodes 1 1) (format program 100000 199999 2))
+    (list (nodes 2 0) (nodes 2 1) (format program 200000 299999 3))
+    (list (nodes 3 0) (nodes 3 1) (format program 300000 399999 4))
+    (list (nodes 4 0) (nodes 4 1) (format program 400000 499999 5))
+) 20000 idle-loop))
+ 
+(set 'primes (sort (flat primes)))
+(save "primes" 'primes)
+ 
+(exit)
+</pre>
+
+<p>At the beginning of the program a <tt>nodes</tt> list structure contains all the relevant node information for hostname and port.</p>
+
+<p>The <tt>program</tt> calculates all prime numbers in a given range. The <tt>from</tt>, <tt>to</tt> and <tt>node</tt> variables are configured into the program text using <tt>format</tt>. All instructions are placed into a <tt>begin</tt> expression block, so only one expression result will be send back from the remote node.</p>
+
+<p>Many other schemes to configure a <tt>net-eval</tt> parameter list are possible. The following scheme without <tt>idle-loop</tt> would give the same results:</p>
+
+<pre>
+(set 'node-eval-list (list
+    (list (nodes 0 0) (nodes 0 1) (format program 0 99999 1))
+    (list (nodes 1 0) (nodes 1 1) (format program 100000 199999 2))
+    (list (nodes 2 0) (nodes 2 1) (format program 200000 299999 3))
+    (list (nodes 3 0) (nodes 3 1) (format program 300000 399999 4))
+    (list (nodes 4 0) (nodes 4 1) (format program 400000 499999 5))
+))
+ 
+(set 'result (net-eval node-eval-list  20000))
+</pre>
+
+<p>The function <tt>idle-loop</tt> aggregates all lists of primes received and generates the following output:</p>
+
+<pre>
+192.168.1.100:4711
+192.168.1.101:4711
+192.168.1.102:4711
+192.168.1.103:4711
+192.168.1.104:4711
+</pre>
+
+<p>As with the previous examples all IP numbers could be replaced with <tt>"localhost"</tt> or any other host-name or IP number to test a distributed application on a single host before deployment in a distributed environment with many networked hosts.</p>
+
+<h3>Transferring files</h3>
+
+<p>Files can be read from or written to remote nodes with the same functions used to read and write files to a local file system. This functionality is currently only available on Unix systems when talking to newLISP servers. As functions are based on standard <tt>GET</tt> and <tt>PUT</tt> HTTP protocols they can also be used communicating with web servers. Note that few Apache web-server installations have enabled the <tt>PUT</tt> protocol by default.</p>
+
+<p>The functions <tt>read-file</tt>, <tt>write-file</tt> and <tt>append-file</tt> can all take URLs in their filename specifications for reading from and writing to remote nodes running a newLISP server or a web-server:</p>
+
+<pre>
+(write-file "http://127.0.0.1:4711//Users/newlisp/afile.txt" "The message - ")
+โ†’ "14 bytes transferred for /Users/newlisp/afile.txt\r\n"
+ 
+(append-file "http://127.0.0.1:4711//Users/newlisp/afile.txt" "more text")
+โ†’ "9 bytes transferred for /Users/newlisp/afile.txt\r\n"
+ 
+(read-file "http://127.0.0.1:4711//Users/newlisp/afile.txt")
+โ†’ "The message - more text"
+</pre>
+
+<p>The first two function return a message starting with the numbers of bytes transferred and the name of the remote file affected. The <tt>read-file</tt> function returns the contents received.</p>
+
+<p>Under all error conditions an error message starting with the characters <tt>ERR:</tt> would be returned:</p>
+
+<pre>
+(read-file "http://127.0.0.1:4711//Users/newlisp/somefile.txt")
+โ†’ "ERR:404 File not found: /Users/newlisp/somefile.txt\r\n"
+</pre>
+
+<p>Note the double backslash necessary to reference files relative to root on the server node.</p>
+
+<p>All functions can be used to transfer binary non-ascii contents containing zero characters. Internally newLISP uses the functions <tt>get-url</tt> and <tt>put-url</tt>, which could be used instead of the functions <tt>read-file</tt>, <tt>write-file</tt> and <tt>append-file</tt>. Additional options like used with <tt>get-url</tt> and <tt>put-url</tt> could be used with the functions <tt>read-file</tt>, <tt>write-file</tt> and <tt>append-file</tt> as well. For more detail see the newLISP function reference for these functions.</p>
+
+<h3>Loading and saving data</h3>
+
+<p>The same <tt>load</tt> and <tt>save</tt> functions used to load program or LISP data from a local file system can be used to load or save programs and LISP data from or to remote nodes.</p>
+
+<p>By using URLs in the file specifications of <tt>load</tt> and <tt>save</tt> these functions can work over the network communicating with a newLISP server node.:</p>
+
+<pre>
+(load "http://192.168.1.2:4711//usr/share/newlisp/mysql5.lsp")
+ 
+(save "http://192.168.1.2:4711//home/newlisp/data.lsp" 'db-data)
+</pre>
+
+<p>Although the <tt>load</tt> and <tt>save</tt> functions internally use <tt>get-url</tt> and <tt>put-url</tt> to perform its works they behave exactly as when used on a local file system, but instead of a file path URLs are specified. Both function will timeout after 60 seconds if a connection could not be established. When finer control is necessary use the functions <tt>get-url</tt> and <tt>put-url</tt> together with <tt>eval-string</tt> and <tt>source</tt> to realize a similar result as when using the <tt>load</tt> and <tt>save</tt> in HTTP mode.</p>
+
+<h3>Local domain Unix sockets</h3>
+
+<p>newLISP supports named local domain sockets in newLISP server mode and using the built-in functions <tt>net-eval</tt>, <tt>net-listen</tt>, <tt>net-connect</tt> together with the functions <tt>net-accept</tt>, <tt>net-receive</tt>, <tt>net-select</tt> and <tt>net-send</tt>.</p>
+
+<p>Using local domain sockets fast communications between processes on the same file system and with newLISP servers is possible. See the Users Manual for more details.</p>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-22"></a>
+<h2>22. HTTPD web server only mode</h2>
+
+<p>In all previous chapters the <tt>-c</tt> server mode was used. This mode can act as a <tt>net-eval</tt> server and at the same time answer <tt>HTTP</tt> requests for serving web pages or transfer of files and programs. The <tt>-c</tt> mode is the preferred mode for secure operation behind a firewall. newLISP also has a <tt>-http</tt> mode which works like a restricted <tt>-c</tt> mode. In <tt>-http</tt> mode only <tt>HTTP</tt> requests are served and command-line like formatted requests and <tt>net-eval</tt> requests are not answered. In this mode newLISP can act like a web server answering HTTP <tt>GET</tt>, <tt>PUT</tt>, <tt>POST</tt> and <tt>DELETE</tt> requests as well as <tt>CGI</tt> requests, but additional efforts should be made to restrict the access to unauthorized files and directories to secure the server when exposed to the internet.</p>
+
+<h3>Environment variables</h3>
+<p>In both server modes <tt>-c</tt> and <tt>-http</tt> the environment variables 
+DOCUMENT_ROOT, REQUEST_METHOD, SERVER_SOFTWARE and QUERY_STRING are set. 
+The variables CONTENT_TYPE, CONTENT_LENGTH, HTTP_HOST, HTTP_USER_AGENT 
+and HTTP_COOKIE are set too if present in the HTTP header sent by the client.</p>
+
+<h3>Pre-processing the request</h3>
+
+<p>When the newLISP server answers any kind of requests (<tt>HTTP</tt> and command line), the newLISP function <tt>command-event</tt> can be used to pre-process the request. The pre-processing function can be loaded from a file <tt>httpd-conf.lsp</tt> when starting the server:</p>
+
+<pre>
+server_args = httpd-conf.lsp -http -w /home/node
+</pre>
+
+<p>The above snippet shows part of a <tt>xinetd</tt> configuration file. A startup program <tt>httpd-conf.lsp</tt> has been added which will be loaded upon invocation of newLISP. The <tt>-c</tt> options has been replaced with the <tt>-http</tt> option. Now neither <tt>net-eval</tt> nor command-line requests will be answered but only HTTP requests.</p>
+
+<p>The startup file could also have been added the following way when starting the server in the background from a command shell, and <tt>httpd-conf.lsp</tt> is in the current directory:</p>
+
+<pre>
+newlisp httpd-conf.lsp -http -d 80 -w /home/www &amp;
+</pre>
+
+<p>All requests will be pre-processed with a function specified using <tt>command-event</tt> in <tt>httpd-conf.lsp</tt>:</p>
+
+<pre>
+; httpd-conf.lsp
+;
+; filter and translate HTTP request for newLISP
+; -c or -http server modes
+; reject query commands using CGI with .exe files
+ 
+(command-event (fn (s)
+    (let (request nil)
+    (if (find "?" s) ; is this a query
+        (begin
+            (set 'request (first (parse s "?")))
+            ; discover illegal extension in queries
+            (if (ends-with request ".exe")
+                (set 'request "GET /errorpage.html")
+                (set 'request s)))
+        (set 'request s))
+    request)
+))
+ ; eof
+</pre>
+
+<p>All CGI requests files ending with <tt>.exe</tt> would be rejected and the request translated into the request of an error page.</p>
+
+<h3>CGI processing in HTTP mode</h3>
+
+<p>On http://www.newlisp.org various CGI examples can be found. In the download directory at http://www.newlisp.org/downloads two more complex applications can be found: <tt>newlisp-ide</tt> is a web based IDE and <tt>newlisp-wiki</tt> is a content management system which also runs the [http://www.newlisp.org www.newlisp.org] website.</p>
+
+<p>CGI program files must have the extension <tt>.cgi</tt> and have executable permission on Unix. </p>
+
+<p>The following is a minimum CGI program:</p>
+
+<pre>
+#!/usr/bin/newlisp
+ 
+(print "Content-type: text/html\r\n\r\n")
+(println "&lt;h2&gt;Hello World&lt;/h2&gt;")
+(exit)
+</pre>
+
+<p>newLISP normally puts out a standard <tt>HTTP/1.0 200 OK\r\n</tt> response header plus a <tt>Server: newLISP v. ...\r\n</tt> header line. If the first line of CGI program output starts with "Status:" then newLISP's standard header output is suppressed, and the CGI program must supply the full status header by itself. The following example redirects a request to a new location:</p>
+
+<pre>
+#!/usr/bin/newlisp
+(print "Status: 301 Moved Permanently\r\n")
+(print "Location: http://www.newlisp.org/index.cgi\r\n\r\n")
+(exit)
+</pre>
+
+<p>A newLISP installation contains a module file <tt>cgi.lsp</tt>. 
+This module contains subroutines for extracting parameters from 
+HTTP GET and POST requests, extract or set cookies and other useful 
+routines when writing CGI files. See the modules section 
+at: http://www.newlisp.org/modules/.</p>
+
+<h3>Media types in HTTP modes</h3>
+
+<p>In both the <tt>-c</tt> and <tt>-http</tt> HTTP modes the following file types are recognized and a correctly formatted <tt>Content-Type:</tt> header is sent back:</p>
+
+<table  summary="media types">
+<tr align="left"><th>file extension</th><th>media type</th></tr>
+<tr><td>.avi</td><td>video/x-msvideo</td></tr>
+<tr><td>.css</td><td>text/css</td></tr>
+<tr><td>.gif</td><td>image/gif</td></tr>
+<tr><td>.htm</td><td>text/htm</td></tr>
+<tr><td>.html</td><td>text/html</td></tr>
+<tr><td>.jpg</td><td>image/jpg</td></tr>
+<tr><td>.js</td><td>application/javascript</td></tr>
+<tr><td>.mov</td><td>video/quicktime</td></tr>
+<tr><td>.mp3</td><td>audio/mpeg</td></tr>
+<tr><td>.mpg</td><td>video/mpeg</td></tr>
+<tr><td>.pdf</td><td>application/pdf</td></tr>
+<tr><td>.png</td><td>image/png</td></tr>
+<tr><td>.wav</td><td>audio/x-wav</td></tr>
+<tr><td>.zip</td><td>application/zip</td></tr>
+<tr><td><em>any other</em></td><td>text/plain</td></tr>
+</table>
+
+<br/><center>&sect;</center><br/>
+<a name="toc-23"></a>
+<h2>23. Extending newLISP</h2>
+
+<p>newLISP has an import function, which allows importing function from DLLs (Dynamic Link Libraries) on MS Windows or shared libraries on Linux/Unix (ending in .so, ending in .dylib on Mac OS X).</p>
+
+<h3>Simple versus extended FFI interface</h3>
+
+<p>In version 10.4.0 newLISP introduced an extended syntax for the <tt>import</tt>, 
+<tt>callback</tt> and <tt>struct</tt> functions and for the <tt>pack</tt> and <tt>unpack</tt>
+support functions. This extended syntax is only available 
+on newLISP versions built with <a href="http://sourceware.org/libffi/">libffi</a> . 
+All standard binary versions distributed on www.newlisp.org are enabled to use the new 
+extensions additionally to the simpler API. The simpler API is used by all standard extension 
+modules part of the distribution except for the module <tt>gsl.lsp</tt>.</p>
+
+<p>The extended syntax allows specifying C-language types for parameter and return values of imported 
+functions and for functions registered as callbacks. The extended syntax also allows handling
+of floating point values and C-structures in parameters and returns. Handling of floating point 
+types was either impossible or unreliable using the simple API that depended on pure <em>cdecl</em>
+calling conventions. These are not available on all platforms. The extended API also handles
+packing and unpacking of C-structures with automatic alignment of C-types on different CPU
+architectures. See the extended syntax of the <tt>pack</tt> and <tt>unpack</tt> functions in
+the <a href="http://www.newlisp.org/newlisp_manual.html">User Manual and Reference</a>
+and <a href="http://www.newlisp.org/syntax.cgi?code/opengl-demo-ffi-lsp.txt">OpenGL demo</a>.</p>
+
+<p>The following chapters describe the older simple API. Much of it is applicable to the 
+extended API as well. For details on the new API, consult the 
+<a href="http://www.newlisp.org/newlisp_manual.html">User Manual and Reference</a> 
+for the functions <tt>import</tt>, <tt>callback</tt>, <tt>struct</tt>, <tt>pack</tt>
+and <tt>unpack</tt>.</p>
+
+<h3>A shared library in C</h3>
+
+<p>This chapter shows how to compile and use libraries on both, MS Windows and Linux/Unix 
+platforms. We will compile a DLL and a Linux/Unix shared library from the following 'C' program.</p>
+
+
+<pre>
+#include &lt;stdio.h&gt;
+#include &lt;stdlib.h&gt;
+#include &lt;ctype.h&gt;
+ 
+int foo1(char * ptr, int number)
+     {
+     printf("the string: %s the number: %d\n", ptr, number);
+     return(10 * number);
+     }
+ 
+char * foo2(char * ptr, int number)
+     {
+     char * upper;
+     printf("the string: %s the number: %d\n", ptr, number);
+     upper = ptr;
+     while(*ptr) { *ptr = toupper(*ptr); ptr++; }
+     return(upper);
+     }
+ 
+/* eof */
+</pre>
+
+<p>Both functions foo1 and foo2 print their arguments, but while foo1 returns the number multiplied 10 times, foo2 returns the uppercase of a string to show how to return strings from 'C' functions.</p>
+
+<h3>Compile on Unix</h3>
+
+<p>On Mac OS X and Linux/Unix we can compile and link <tt>testlib.so</tt> in one step:</p>
+
+<pre>
+gcc testlib.c -shared -o testlib.so
+</pre>
+
+<p>Or On Mac OSX/darwin do:</p>
+
+<pre>
+gcc testlib.c -bundle -o testlib.dylib
+</pre>
+
+<p>The library <tt>testlib.so</tt> will be built with Linux/Unix default <tt>cdecl</tt> conventions. Importing the library is very similar on both Linux and MS Windows platforms, but on MS Windows the library can be found in the current directory. You may have to specify the full path or put the library in the library path of the os:</p>
+
+<pre>
+&gt; (import "/home/newlisp/testlib.so" "foo1")
+foo1 &lt;6710118F&gt;
+ 
+&gt; (import "/home/newlisp/testlib.so" "foo2")
+foo2 &lt;671011B9&gt;
+ 
+&gt; (foo1 "hello" 123)
+the string: hello the number: 123
+1230
+ 
+&gt; (foo2 "hello" 123)
+the string: hello the number: 123
+4054088
+ 
+&gt; (get-string (foo2 "hello" 123))
+the string: hello the number: 123
+"HELLO"
+&gt;
+</pre>
+
+<p>Again, the number returned from <tt>foo2</tt> is the string address pointer and get-string can be used to access the string. When using get-string only character up to a zero byte are returned. When returning the addresses to binary buffers different techniques using unpack are used to access the information.</p>
+
+<h3>Compile a DLL on MS Windows</h3>
+
+<p>DLLs on MS Windows can be made using the MinGW, Borland or CYGWIN compilers. This example shows, how to do it using the MinGW compiler.</p>
+
+<p>Compile it:</p>
+
+<pre>
+gcc -c testlib.c -o testlib.o
+</pre>
+
+<p>Before we can transform <tt>testlib.o</tt> into a DLL we need a <tt>testlib.def</tt> declaring the exported functions:</p>
+
+<pre>
+LIBRARY  testlib.dll
+EXPORTS
+         foo1
+         foo2
+</pre>
+
+<p>Now wrap the DLL:</p>
+
+<pre>
+dllwrap testlib.o --def testlib.def -o testlib.dll -lws2_32
+</pre>
+
+<p>The library <tt>testlib.dll</tt> will be built with default MS Windows <tt>stdcall</tt> conventions. The following shows an interactive session, importing the library and using the functions:</p>
+
+<pre>
+&gt; (import "testlib.dll" "foo1")
+foo1 &lt;6710118F&gt;
+ 
+&gt; (import "testlib.dll" "foo2")
+foo2 &lt;671011B9&gt;
+ 
+&gt; (foo1 "hello" 123)
+the string: hello the number: 123
+1230
+ 
+&gt; (foo2 "hello" 123)
+the string: hello the number: 123
+4054088
+ 
+&gt; (get-string (foo2 "hello" 123))
+the string: hello the number: 123
+"HELLO"
+ 
+&gt;
+; import a library compiled for cdecl
+; calling conventions
+&gt; (import "foo.dll" "func" "cdecl")
+</pre>
+
+<p>Note that the first time using <tt>foo2</tt> the return value 4054088 is the memory address of the string returned. Using get-string the string belonging to it can be accessed. If the library is compiled using <tt>cdecl</tt> calling conventions, the <tt>cdecl</tt> keyword must be used in the import expression.</p>
+
+<h3>Importing data structures</h3>
+
+<p>Just like 'C' strings are returned using string pointers, 'C' structures can be returned using structure pointers and functions like <tt>get-string</tt>, <tt>get-int</tt> or <tt>get-char</tt> can be used to access the members. The following example illustrates this:</p>
+
+<pre>
+typedef struct mystruc
+   {
+   int number;
+   char * ptr;
+   } MYSTRUC;
+ 
+MYSTRUC * foo3(char * ptr, int num )
+   {
+   MYSTRUC * astruc;
+   astruc = malloc(sizeof(MYSTRUC));
+   astruc-&gt;ptr = malloc(strlen(ptr) + 1);
+   strcpy(astruc-&gt;ptr, ptr);
+   astruc-&gt;number = num;
+   return(astruc);
+   }
+</pre>
+
+<p>The newLISP program would access the structure members as follows:</p>
+
+<pre>
+&gt; (set 'astruc (foo3 "hello world" 123))
+4054280
+ 
+&gt; (get-string (get-integer (+ astruc 4)))
+"hello world"
+ 
+&gt; (get-integer astruc)
+123
+&gt;
+</pre>
+
+<p>The return value from <tt>foo3</tt> is the address to the structure <tt>astruc</tt>. To access the string pointer, 4 must be added as the size of an integer type in the 'C' programming language. The string in the string pointer then gets accessed using get-string.</p>
+
+<h3>Memory management</h3>
+
+<p>Any allocation performed by imported foreign functions has to be 
+deallocated manually if there's no call in the imported API to do so.
+The <tt>libc</tt> function <tt>free</tt> can be imported and used 
+to free memory allocated inside imported functions:</p>
+
+<pre>
+(import "/usr/lib/libc.so" "free")
+
+(free astruc) ; astruc contains memory address of allocated structure
+</pre>
+
+<p>In case of calling foreign functions with passing by reference, 
+memory for variables needs to be allocated beforehand by newLISP,
+and hence, memory needs not be deallocated manually.</p>
+
+<h3>Unevenly aligned structures</h3>
+
+<p>Sometimes data structures contain data types of different length than the normal CPU register word:</p>
+
+<pre>
+struct mystruct
+    {
+    short int x;
+    int z;
+    short int y;
+    } data;
+ 
+struct mystruct * foo(void)
+    {
+    data.x = 123;
+    data.y = 456;
+    data.z = sizeof(data);
+    return(&amp;data);
+    }
+</pre>
+
+<p>The <tt>x</tt> and <tt>y</tt> variables are 16 bit wide and only z takes 32 bit. When a compiler on a 32-bit CPU packs this structure the variables x and y will each fill up 32 bits instead of the 16 bit each. This is necessary so the 32-bit variable z can be aligned properly. The following code would be necessary to access the structure members:</p>
+
+<pre>
+&gt; (import "/usr/home/nuevatec/test.so" "foo")
+foo &lt;281A1588&gt;
+ 
+&gt; (unpack "lu lu lu" (foo))
+(123 12 456)
+</pre>
+
+<p>The whole structure consumes 3 by 4 = 12 bytes, because all members have to be aligned to 32 bit borders in memory.</p>
+
+<p>The following data structure packs the short 16 bit variables next to each other. This time only 8 bytes are required: 2 each for <tt>x</tt> and <tt>y</tt> and 4 bytes for <tt>z</tt>. Because <tt>x</tt> and <tt>y</tt> are together in one 32-bit word, none of the variables needs to cross a 32-bit boundary:</p>
+
+<pre>
+struct mystruct
+     {
+     short int x;
+     short int y;
+     int z;
+     } data;
+ 
+ struct mystruct * foo(void)
+    {
+    data.x = 123;
+    data.y = 456;
+    data.z = sizeof(data);
+    return(&amp;data);
+    }
+</pre>
+
+<p>This time the access code in newLISP reflects the size of the structure members:</p>
+
+<pre>
+&gt; (import "/usr/home/nuevatec/test.so" "foo")
+foo &lt;281A1588&gt;
+ 
+&gt; (unpack "u u lu" (foo))
+(123 456 8)
+</pre>
+
+<h3>Passing parameters</h3>
+
+<table  summary='table'>
+<tr align='left'><th> data Type </th><th> newLISP call </th><th> C function call </th></tr>
+<tr><td> <tt>integer</tt></td><td> <tt>(foo 123)</tt></td><td> <tt>foo(int number)</tt></td></tr>
+<tr><td> <tt>double float</tt></td><td> <tt>(foo 1.234)</tt></td><td> <tt>foo(double number)</tt></td></tr>
+<tr><td> <tt>float</tt></td><td> <tt>(foo (flt 1.234))</tt></td><td> <tt>foo(float number)</tt></td></tr>
+<tr><td> <tt>string</tt></td><td> <tt>(foo "Hello World!")</tt></td><td> <tt>foo(char * string)</tt></td></tr>
+<tr><td> <tt>integer array</tt></td><td> <tt>(foo (pack "d d d" 123 456 789))</tt></td><td> <tt>foo(int numbers[])</tt></td></tr>
+<tr><td> <tt>float array</tt></td><td> <tt>(foo (pack "f f f" 1.23 4.56 7.89))</tt></td><td> <tt>foo(float[])</tt></td></tr>
+<tr><td> <tt>double array</tt></td><td> <tt>(foo (pack "lf lf lf) 1.23 4.56 7.89)</tt></td><td> <tt>foo(double[])</tt></td></tr>
+<tr><td> <tt>string array</tt></td><td> <tt>(foo (pack "lu lu lu" "one" "two" "three")))</tt></td><td> <tt>foo(char * string[])</tt></td></tr>
+</table>
+<p>Note that <tt>floats</tt> and <tt>double floats</tt> are only passed correctly on x86 
+platforms with <em>cdecl</em> calling conventions or when passed by pointer reference as 
+in variable argument functions, i.e: <tt>printf()</tt>. For reliable handling of single
+and double precision floating point types and for advanced usage of <tt>pack</tt> and
+<tt>unpack</tt> for handling C-structures, see the descriptions of the <tt>import</tt>,
+<tt>callback</tt> and <tt>struct</tt> functions in the 
+<a href="http://www.newlisp.org/newlisp_manual.html">newLISP User Manual and Reference</a>.</p>
+
+<p><tt>pack</tt> can receive multiple arguments after the format specifier in a list too:</p>
+
+<pre> 
+(pack "lu lu lu" '("one" "two" "three"))
+</pre>
+
+<h3>Extracting return values</h3>
+
+<table  summary='table'>
+<tr align='left'><th> data Type </th><th> newLISP to extract return value </th><th> C return </th></tr>
+<tr><td> <tt>integer</tt></td><td> <tt>(set 'number (foo x y z))</tt></td><td> <tt>return(int number)</tt></td></tr>
+<tr><td> <tt>double float</tt></td><td> n/a - only 32bit returns, use double float pointer instead </td><td> not available</td></tr>
+<tr><td> <tt>double float ptr</tt></td><td> <tt>(set 'number (get-float (foo x y z)))</tt></td><td> <tt>return(double * numPtr)</tt></td></tr>
+<tr><td> <tt>float</tt></td><td> not available</td><td> not available</td></tr>
+<tr><td> <tt>string</tt></td><td> <tt>(set 'string (get-string (foo x y z)</tt></td><td> <tt>return(char * string)</tt></td></tr>
+<tr><td> <tt>integer array</tt></td><td> <tt>(set 'numList (unpack "ld ld ld" (foo x y z)))</tt></td><td> <tt>return(int numList[])</tt></td></tr>
+<tr><td> <tt>float array</tt></td><td> <tt>(set 'numList (unpack "f f f" (foo x y z)))</tt></td><td> <tt>return(float numList[])</tt></td></tr>
+<tr><td> <tt>double array</tt></td><td> <tt>(set 'numList (unpack "lf lf lf") (foo x y z)))</tt></td><td> <tt>return(double numList[])</tt></td></tr>
+<tr><td> <tt>string array</tt></td><td> <tt>(set 'stringList (map get-string (unpack "ld ld ld" (foo x y z))))</tt></td><td><tt>return(char * string[])</tt></td></tr>
+</table>
+<p><tt>Floats</tt> and <tt>doubles</tt> can only be returned via address pointer references.</p>
+
+<p>When returning array types the number of elements in the array must be known. The examples always assume 3 elements.</p>
+
+<p>All pack and unpack and formats can also be given without spaces, but are spaced in the examples for better readability.</p>
+
+<p>The formats <tt>"ld"</tt> and <tt>"lu"</tt> are interchangeable, but the 16-bit formats <tt>"u"</tt> and <tt>"d"</tt> may produce different results, because of sign extension when going from unsigned 16 bits to signed 32 or 64-bits bits of newLISP's internal integer format.</p>
+
+<p>Flags are available for changing endian byte order during <tt>pack</tt> and <tt>unpack</tt>.</p>
+
+<h3>Writing library wrappers</h3>
+
+<p>Sometimes the simple version of newLISP's built-in import facility cannot be used with a library. This happens whenever a library does not strictly adhere to <tt>cdecl</tt> calling conventions expecting all parameters passed on the stack. E.g. when running Mac OS X on older PPC CPUs instead of Intel CPUs, the OpenGL libraries installed by default on Mac OS X cannot be used.</p>
+
+<p>Since newLISP version 10.4.0, the problem can be solved easiest using the newer extended syntax of <tt>import</tt>, which automatically resolves platform and architectural differences. On very small systems or whenever the needed <tt>libffi</tt> system library is not present on a platform, a special wrapper library can be built to translate <tt>cdecl</tt> conventions expected by newLISP into the calling conventions expected by the target library.</p>
+
+<pre>
+/* wrapper.c - demo for wrapping library function
+ 
+compile:
+    gcc -m32 -shared wrapper.c -o wrapper.so
+or:
+    gcc -m32 -bundle wrapper.c -o wrapper.dylib
+ 
+usage from newLISP:
+ 
+    (import "./wrapper.dylib" "wrapperFoo")
+ 
+    (define (glFoo x y z)
+        (get-float (wrapperFoo 5 (float x) (int y) (float z))) )
+ 
+ (glFoo 1.2 3 1.4) =&gt; 7.8
+ 
+*/
+ 
+#include &lt;stdio.h&gt;
+#include &lt;stdarg.h&gt;
+ 
+ 
+/* the glFoo() function would normally live in the library to be
+   wrapped, e.g. libopengl.so or libopengl.dylib, and this
+   program would link to it.
+   For demo and test purpose the function has been included in this
+   file
+*/
+ 
+double glFoo(double x, int y, double z)
+    {
+    double result;
+ 
+    result = (x + z) * y;
+ 
+    return(result);
+    }
+ 
+/* this is the wrapper for glFoo which gets imported by newLISP
+   declaring it as a va-arg function guarantees 'cdecl'
+   calling conventions on most architectures
+*/
+ 
+double * wrapperFoo(int argc, ...)
+    {
+    va_list ap;
+    double x, z;
+    static double result;
+    int y;
+ 
+    va_start(ap, argc);
+ 
+    x = va_arg(ap, double);
+    y = va_arg(ap, int);
+    z = va_arg(ap, double);
+ 
+    va_end(ap);
+ 
+    result = glFoo(x, y, z);
+    return(&amp;result);
+    }
+ 
+/* eof */
+</pre>
+
+<h3>Registering callbacks in external libraries</h3>
+
+<p>Many shared libraries allow registering callback functions to
+call back into the controlling program. The function <tt>callback</tt>
+is used in newLISP to extract the function address from a user-defined
+newLISP function and pass it to the external library via a registering
+function:</p>
+
+<pre>
+(define (keyboard key x y)
+    (if (= (&amp; key 0xFF) 27) (exit)) ; exit program with ESC
+    (println "key:" (&amp; key 0xFF) " x:" x  " y:" y))
+
+(glutKeyboardFunc (callback 1 'keyboard))
+</pre>
+
+<p>The example is a snippet from the file <tt>opengl-demo.lsp</tt> in
+the <tt>newlisp-x.x.x/examples/</tt> directory of the source distribution.
+A file <tt>win32demo.lsp</tt> can be found in the same directory demonstrating 
+callbacks on the Windows platform.</p>
+
+<p>For an advanced syntax of <tt>callback</tt> using C-type specifiers see
+<a href="http://www.newlisp.org/newlisp_manual.html">newLISP User Manual and Reference</a>.
+</p>
+
+<br/><center>&sect;</center><br/>
+
+<a name="toc-24"></a>
+<h2>24. newLISP as a shared library</h2>
+
+<p>On all platforms, newLISP can be compiled as a shared library. On MS Windows, the library
+is called <tt>newlisp.dll</tt>, on Mac OS X <tt>newlisp.dylib</tt> and on Linux and
+BSDs, the library is called <tt>newlisp.so</tt>. Makefiles are included in the source 
+distribution for most platforms. Only on MS Windows, the installer comes with a precompiled 
+<tt>newlisp.dll</tt> and will install it in the <tt>Program Files/newlisp/</tt> directory.</p>
+
+<h3>Evaluating code in the shared library</h3>
+
+<p>The first example shows how to import <tt>newlispEvalStr</tt> from newLISP 
+itself as the caller:</p>
+
+<pre>
+(import "/usr/lib/newlisp.so" "newlispEvalStr")
+(get-string (newlispEvalStr "(+ 3 4)")) &rarr;  "7\n"
+</pre>
+
+<p>When calling the library function <tt>newlispEvalStr</tt>, output normally 
+directed to the console (e.g. return values or print statements) is returned 
+in the form of an integer string pointer. The output can be accessed by passing 
+this pointer to the <tt>get-string</tt> function. To silence the output from 
+return values, use the <tt>silent</tt> function. All Results, even if they are 
+numbers, are always returned as strings and a trailing linefeed as in interactive 
+console mode. Use the <tt>int</tt> or <tt>float</tt> functions to convert the
+strings to other data types.</p>
+
+<p>When passing multi-line source to newlispEvalStr, that source should be 
+bracketed by <tt>[cmd]</tt>, <tt>[/cmd]</tt> tags, each on a different line:</p>
+
+<pre>
+(set 'code [text][cmd]
+...
+...
+...
+[/cmd][/text])
+</pre>
+
+<p>The second example shows how to import <tt>newlispEvalStr</tt> into a
+C-program:</p>
+
+<pre>
+/* libdemo.c - demo for importing newlisp.so
+ * 
+ * compile using: 
+ *    gcc -ldl libdemo.c -o libdemo
+ *
+ * use:
+ *
+ *    ./libdemo '(+ 3 4)'
+ *    ./libdemo '(symbols)'
+ *
+ */
+#include &lt;stdio.h&gt;
+#include &lt;dlfcn.h&gt;
+ 
+int main(int argc, char * argv[])
+{
+void * hLibrary;
+char * result;
+char * (*func)(char *);
+char * error;
+ 
+if((hLibrary = dlopen("/usr/lib/newlisp.so",
+                       RTLD_GLOBAL | RTLD_LAZY)) == 0)
+    {
+    printf("cannot import library\n");
+    exit(-1);
+    }
+ 
+func = dlsym(hLibrary, "newlispEvalStr");
+if((error = dlerror()) != NULL)
+    {
+    printf("error: %s\n", error);
+    exit(-1);
+    }
+ 
+printf("%s\n", (*func)(argv[1]));
+ 
+return(0);
+}
+
+/* eof */
+</pre>
+
+<p>This program will accept quoted newLISP expressions and print the evaluated results.</p>
+
+<h3>Registering callbacks</h3>
+
+<p>Like many other share libraries, callbacks can be registered in newLISP library.
+The function <tt>newlispCallback</tt> must be imported and is used for registering
+callback functions. The example shows newLISP importing newLISP as a library and
+registering a callback <tt>callme</tt>:</p>
+
+<pre>
+#!/usr/bin/newlisp
+
+; path-name of the library depending on platform
+(set 'LIBRARY (if (= ostype "Windows") "newlisp.dll" "newlisp.dylib"))
+
+; import functions from the newLISP shared library
+(import LIBRARY "newlispEvalStr")
+(import LIBRARY "newlispCallback")
+
+; set calltype platform specific
+(set 'CALLTYPE (if (= ostype "Windows") "stdcall" "cdecl"))
+
+; the callback function
+(define (callme p1 p2 p3 result)
+    (println "p1 =&gt; " p1 " p2 =&gt; " p2 " p3 =&gt; " p3)
+    result)
+
+; register the callback with newLISP library
+(newlispCallback "callme" (callback 0 'callme) CALLTYPE)
+
+; the callback returns a string
+(println (get-string (newlispEvalStr
+    {(get-string (callme 123 456 789 "hello world"))})))
+
+; the callback returns a number
+(println (get-string (newlispEvalStr
+    {(callme 123 456 789 99999)})))
+</pre>
+
+<p>Depending on the type of the return value, different code is used. The program
+shows the following output:</p>
+
+<pre>
+p1 =&gt; 123 p2 =&gt; 456 p3 =&gt; 789
+"hello world"
+
+p1 =&gt; 123 p2 =&gt; 456 p3 =&gt; 789
+99999
+</pre>
+
+<p>Note that MS Windows  and many Unix flavors will look for <tt>newlisp.dll</tt> 
+in the system library path, but Mac OS X will look for <tt>newlisp.dylib</tt> 
+first in the current directory, if the full file path is not specified. The 
+program above can also be found as <tt>callback</tt> in the source distribution 
+in the <tt>newlisp-x.x.x/examples</tt> directory.</p>
+
+
+<br/><center>&sect;</center><br/><hr/><br/>
+
+<a NAME="appendix"></a>
+<a NAME="GFDL"></a>
+<center>
+<h2><font color="#EE0000">GNU Free Documentation License</font></h2>
+<p>Version 1.2, November 2002</p>
+
+<p>
+Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
+59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.</p>
+</center>
+
+<br/><br/>
+
+<b>0. PREAMBLE</b>
+
+<p>The purpose of this License is to make a manual, textbook, or other
+functional and useful document "free" in the sense of freedom: to
+assure everyone the effective freedom to copy and redistribute it,
+with or without modifying it, either commercially or noncommercially.
+Secondarily, this License preserves for the author and publisher a way
+to get credit for their work, while not being considered responsible
+for modifications made by others.
+</p>
+<p>This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense. It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+</p>
+<p>We have designed this License in order to use it for manuals for
+free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does. But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book. We recommend this License
+principally for works whose purpose is instruction or reference.
+</p>
+<p><b>1. APPLICABILITY AND DEFINITIONS</b>
+</p>
+<p>This License applies to any manual or other work, in any medium,
+that
+contains a notice placed by the copyright holder saying it can be
+distributed under the terms of this License. Such a notice grants a
+world-wide, royalty-free license, unlimited in duration, to use that
+work under the conditions stated herein. The "Document", below,
+refers to any such manual or work. Any member of the public is a
+licensee, and is addressed as "you". You accept the license if you
+copy, modify or distribute the work in a way requiring permission
+under copyright law.
+</p>
+<p>A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+</p>
+<p>A "Secondary Section" is a named appendix or a front-matter section
+of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject. (Thus, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.) The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+</p>
+<p>The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License. If a
+section does not fit the above definition of Secondary then it is not
+allowed to be designated as Invariant. The Document may contain zero
+Invariant Sections. If the Document does not identify any Invariant
+Sections then there are none.
+</p>
+<p>The "Cover Texts" are certain short passages of text that are
+listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License. A Front-Cover Text may
+be at most 5 words, and a Back-Cover Text may be at most 25 words.
+</p>
+<p>A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, that is suitable for revising the document
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters. A copy made in an otherwise Transparent file
+format whose markup, or absence of markup, has been arranged to thwart
+or discourage subsequent modification by readers is not Transparent.
+An image format is not Transparent if used for any substantial amount
+of text. A copy that is not "Transparent" is called "Opaque".
+</p>
+<p>Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML, PostScript or PDF designed for human modification. Examples of
+transparent image formats include PNG, XCF and JPG. Opaque formats
+include proprietary formats that can be read and edited only by
+proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML, PostScript or PDF produced by some word
+processors for output purposes only.
+</p>
+<p>The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page. For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+</p>
+<p>A section "Entitled XYZ" means a named subunit of the Document whose
+title either is precisely XYZ or contains XYZ in parentheses following
+text that translates XYZ in another language. (Here XYZ stands for a
+specific section name mentioned below, such as "Acknowledgements",
+"Dedications", "Endorsements", or "History".) To "Preserve the Title"
+of such a section when you modify the Document means that it remains a
+section "Entitled XYZ" according to this definition.
+</p>
+<p>The Document may include Warranty Disclaimers next to the notice
+which
+states that this License applies to the Document. These Warranty
+Disclaimers are considered to be included by reference in this
+License, but only as regards disclaiming warranties: any other
+implication that these Warranty Disclaimers may have is void and has
+no effect on the meaning of this License.
+</p>
+<p><b>2. VERBATIM COPYING</b>
+</p>
+<p>You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License. You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute. However, you may accept
+compensation in exchange for copies. If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+</p>
+<p>You may also lend copies, under the same conditions stated above,
+and
+you may publicly display copies.
+</p>
+<p><b>3. COPYING IN QUANTITY</b>
+</p>
+<p>If you publish printed copies (or copies in media that commonly have
+printed covers) of the Document, numbering more than 100, and the
+Document's license notice requires Cover Texts, you must enclose the
+copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover. Both covers must also clearly and legibly identify
+you as the publisher of these copies. The front cover must present
+the full title with all words of the title equally prominent and
+visible. You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+</p>
+<p>If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+</p>
+<p>If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a computer-network location from which the general network-using
+public has access to download using public-standard network protocols
+a complete Transparent copy of the Document, free of added material.
+If you use the latter option, you must take reasonably prudent steps,
+when you begin distribution of Opaque copies in quantity, to ensure
+that this Transparent copy will remain thus accessible at the stated
+location until at least one year after the last time you distribute an
+Opaque copy (directly or through your agents or retailers) of that
+edition to the public.
+</p>
+<p>It is requested, but not required, that you contact the authors of
+the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+</p>
+<p><b>4. MODIFICATIONS</b>
+</p>
+<p>You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it. In addition, you must do these things in the Modified Version:
+</p>
+<ul>
+  <li><b>A.</b> Use in the Title Page (and on the covers, if
+any) a title distinct from that of the Document, and from those of
+previous versions (which should, if there were any, be listed in the
+History section of the Document). You may use the same title as a
+previous version if the original publisher of that version gives
+permission.
+  </li>
+  <li><b>B.</b> List on the Title Page, as authors, one or
+more persons or entities responsible for authorship of the
+modifications in the Modified Version, together with at least five of
+the principal authors of the Document (all of its principal authors, if
+it has fewer than five), unless they release you from this requirement.
+  </li>
+  <li><b>C.</b> State on the Title page the name of the
+publisher of the Modified Version, as the publisher.
+  </li>
+  <li><b>D.</b> Preserve all the copyright notices of the
+Document.
+  </li>
+  <li><b>E.</b> Add an appropriate copyright notice for your
+modifications adjacent to the other copyright notices.
+  </li>
+  <li><b>F.</b> Include, immediately after the copyright
+notices, a license notice giving the public permission to use the
+Modified Version under the terms of this License, in the form shown in
+the Addendum below.
+  </li>
+  <li><b>G.</b> Preserve in that license notice the full
+lists of Invariant Sections and required Cover Texts given in the
+Document's license notice.
+  </li>
+  <li><b>H.</b> Include an unaltered copy of this License.
+  </li>
+  <li><b>I.</b> Preserve the section Entitled "History",
+Preserve its Title, and add to it an item stating at least the title,
+year, new authors, and publisher of the Modified Version as given on
+the Title Page. If there is no section Entitled "History" in the
+Document, create one stating the title, year, authors, and publisher of
+the Document as given on its Title Page, then add an item describing
+the Modified Version as stated in the previous sentence.
+  </li>
+  <li><b>J.</b> Preserve the network location, if any, given
+in the Document for public access to a Transparent copy of the
+Document, and likewise the network locations given in the Document for
+previous versions it was based on. These may be placed in the "History"
+section. You may omit a network location for a work that was published
+at least four years before the Document itself, or if the original
+publisher of the version it refers to gives permission.
+  </li>
+  <li><b>K.</b> For any section Entitled "Acknowledgements"
+or "Dedications", Preserve the Title of the section, and preserve in
+the section all the substance and tone of each of the contributor
+acknowledgements and/or dedications given therein.
+  </li>
+  <li><b>L.</b> Preserve all the Invariant Sections of the
+Document, unaltered in their text and in their titles. Section numbers
+or the equivalent are not considered part of the section titles.
+  </li>
+  <li><b>M.</b> Delete any section Entitled "Endorsements".
+Such a section may not be included in the Modified Version.
+  </li>
+  <li><b>N.</b> Do not retitle any existing section to be
+Entitled "Endorsements" or to conflict in title with any Invariant
+Section.
+  </li>
+  <li><b>O.</b> Preserve any Warranty Disclaimers.
+  </li>
+</ul>
+<p>
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant. To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+</p>
+<p>You may add a section Entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+</p>
+<p>You may add a passage of up to five words as a Front-Cover Text, and
+a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version. Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity. If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+</p>
+<p>The author(s) and publisher(s) of the Document do not by this
+License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+</p>
+<p><b>5. COMBINING DOCUMENTS</b>
+</p>
+<p>You may combine the Document with other documents released under
+this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice, and that you preserve all their Warranty Disclaimers.
+</p>
+<p>The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy. If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+</p>
+<p>In the combination, you must combine any sections Entitled "History"
+in the various original documents, forming one section Entitled
+"History"; likewise combine any sections Entitled "Acknowledgements",
+and any sections Entitled "Dedications". You must delete all sections
+Entitled "Endorsements."
+</p>
+<p><b>6. COLLECTIONS OF DOCUMENTS</b>
+</p>
+<p>You may make a collection consisting of the Document and other
+documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+</p>
+<p>You may extract a single document from such a collection, and
+distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+</p>
+<p><b>7. AGGREGATION WITH INDEPENDENT WORKS</b>
+</p>
+<p>A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, is called an "aggregate" if the copyright
+resulting from the compilation is not used to limit the legal rights
+of the compilation's users beyond what the individual works permit.
+When the Document is included in an aggregate, this License does not
+apply to the other works in the aggregate which are not themselves
+derivative works of the Document.
+</p>
+<p>If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one half of
+the entire aggregate, the Document's Cover Texts may be placed on
+covers that bracket the Document within the aggregate, or the
+electronic equivalent of covers if the Document is in electronic form.
+Otherwise they must appear on printed covers that bracket the whole
+aggregate.
+</p>
+<p><b>8. TRANSLATION</b>
+</p>
+<p>Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections. You may include a
+translation of this License, and all the license notices in the
+Document, and any Warranty Disclaimers, provided that you also include
+the original English version of this License and the original versions
+of those notices and disclaimers. In case of a disagreement between
+the translation and the original version of this License or a notice
+or disclaimer, the original version will prevail.
+</p>
+<p>If a section in the Document is Entitled "Acknowledgements",
+"Dedications", or "History", the requirement (section 4) to Preserve
+its Title (section 1) will typically require changing the actual
+title.
+</p>
+<p><b>9. TERMINATION</b>
+</p>
+<p>You may not copy, modify, sublicense, or distribute the Document
+except
+as expressly provided for under this License. Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License. However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+</p>
+<p><b>10. FUTURE REVISIONS OF THIS LICENSE</b>
+</p>
+<p>The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns. See
+http://www.gnu.org/copyleft/.
+</p>
+<p>Each version of the License is given a distinguishing version
+number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation. If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+</p>
+
+<center>&part;</center>
+
+</body>
+</html>
+
diff --git a/doc/ExpressionEvaluation.html b/doc/ExpressionEvaluation.html
new file mode 100644
index 0000000..e716a29
--- /dev/null
+++ b/doc/ExpressionEvaluation.html
@@ -0,0 +1,484 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<title>Expression Evaluation in newLISP</title>
+<style type="text/css" media="screen">
+
+<!--
+body, h4, p {
+	font-family: Lucida Sans, Helvetica, sans-serif;
+	line-height: 120%;
+	max-width: 1000px;
+	}
+
+h1, h2, h3 {
+	margin-top: 3%;
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+	color: #404040;
+    }
+
+table {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: solid;
+	border-width: 0px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+	font-size: 95%;
+    }
+    
+th {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #eeeeee;
+    font-size: 100%;
+    }
+    
+td {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+    font-size: 100%;
+    }
+    
+pre {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: dashed;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 4px;
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 90%;
+	background: #f8ffff;
+    }
+
+tt {
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 100%;
+    }
+    
+-->
+</style>
+</head>
+
+<body text="#000000" bgcolor="#FFFFFF" link="#376590" vlink="#551A8B" alink="#ffAA28">
+
+<br />
+<blockquote>
+<center><h2>Expression evaluation, Implicit Indexing, Contexts and Default Functors in the newLISP Scripting Language</h2></center>
+<center>
+<font size="-1">Lutz Mueller, 2007-2015. Last edit December 6th 2013, rev r9<br/></font>
+</center>
+
+<center><blockquote><blockquote><i>
+Implicit indexing and Default Functors in newLISP are an extension of normal LISP expression evaluation rules. Contexts provide lexically closed state-full namespaces in a dynamically scoped programming language.
+</i></blockquote></blockquote></center>
+<br />
+
+<h3>S-expression evaluation and implicit indexing</h3>
+
+<p>In an earlier paper it was explained how s-expression evaluation in newLISP relates to ORO (One Reference Only) automatic memory management [1]. The following pseudo code of the expression evaluation function in newLISP shows how implicit indexing is an extension of Lisp s-expression evaluation rules:</p>
+
+<blockquote><pre>
+function evaluateExpression(expr)
+    {
+    if typeOf(expr) is constant (BOOLEAN, NUMBER, STRING, CONTEXT)
+        return(expr)
+
+    if typeOf(expr) is SYMBOL
+        return(symbolContents(expr))
+
+    if typeOf(expr) is QUOTED
+        return(unQuotedContents(expr))
+
+    if typeOf(expr) is LIST
+        {    
+        func = evaluateExpression(firstOf(expr))
+        args = rest(expr)
+        if typeOf(func) is BUILTIN_FUNCTION
+            result = evaluateFunc(func, args)
+        else if typeOf(func) = LAMBDA_FUNCTION
+            result = evaluateLambda(func, args)
+		/* extensions for default functor */
+        if typeOf(func) is CONTEXT
+            func = defaultFunctor(func)
+                if typeOf(func) = LAMBDA_FUNCTION
+                    result = evaluateLambda(defaultFunctor(func), args)
+        /* extensions for implicit indexing */
+        else if typeOf(func) = LIST
+            result = implicitIndexList(func, args)
+        else if typeOf(func) = STRING
+            result = implicitIndexString(func, args)
+        else if typeOf(func) = ARRAY
+            result = implicitIndexArray(func, args)
+        else if typeOf(func) = NUMBER
+            result = implicitNrestSlice(func, args)
+        }
+    }
+
+    return(result)
+    }
+</pre></blockquote>
+
+<p>The general working of the function reflects the general structure of the <i>eval</i> function as described by <i>John McCarthy</i> in 1960, [2].</p> 
+
+<p>The function first processes atomic expression types. Constants evaluate to themselves and are returned. Symbols evaluate to their contents.</p> 
+
+<p>If the expression is a list the first element gets applied to the rest elements. As in Scheme, newLISP evaluates the first element before applying it the result to its arguments.</p>
+
+<p>Traditional Lisp or Scheme only permit a built-in function, operator or user defined lambda expression in the first, functor position of the s-expression list for evaluation. In newLISP the context symbol type, list, array and number type also act as functions when in the functor position.</p>
+
+<p>Built-in functions are evaluated calling <i>evaluateFunc(func, args)</i>, functors which are lambda expressions call the <i>evaluateLambda(func, args)</i> function. Both functions in turn will call <i>evaluateExpression(expr)</i> again for evaluation of function arguments.</p>
+
+<p>The working of a context symbol in the functor position of an s-expression will be explained further down in the chapter about <i>namespaces and default functors</i>.</p>
+
+<p>The list type causes newLISP to evaluate the whole s-expression to the element indexed by the number(s) following the list and interpreted as index or indices (in newLISP elements in nested lists can be addressed using multiple indices):</p>
+
+<blockquote><pre>
+(set 'lst '(a b (c d e) f g))
+(lst 2)  &rarr; (c d e)
+(lst 2 1)  &rarr; d
+
+(set 'str "abcdefg")
+(str 2)  &rarr; "c"
+</pre></blockquote>
+
+<p>A number in the functor position will assume slicing functionality and slice the following list at the offset expressed by the number. When the number is followed by a second number, the second number specifies the size or length of the sliced part of the list:</p>
+
+<blockquote><pre>
+(1 lst)  &rarr; (b (c d e) f g)
+(1 2 lst)  &rarr; (b (c d e))
+
+(1 2 str)  &rarr; "bc"
+</pre></blockquote>
+
+<p>On first sight it seems logical to extend the same principle to the boolean data type. A ternary conditional expressions could be constructed without the necessity of the <tt>if</tt> operator, but in practical programming this leads to difficulties when reading code and causes too much ambiguity in error messages. Most of the time implicit indexing leads to better readable code, because the data object is grouped together with it's indices. Implicit indexing performs faster, but is also optional. The keywords <tt>nth</tt>, <tt>first</tt>, <tt>last</tt> and <tt>rest</tt> and <tt>slice</tt> can be used in the few cases where readability is better when using the explicit form of indexing.</p>
+
+<h3>The environment stack and dynamic scoping</h3>
+
+<p>In the original Lisp <i>eval</i> function a <i>variable environment</i> is implemented as an association list of symbols and their values. In newLISP a symbol is implemented as a data structure with one value slot and the environment is not an association list but a binary tree structure of symbols and an <i>environment stack</i> storing previous values of symbols in higher evaluation levels.</p>
+
+<p>When entering a lambda function, the parameter symbols and their current values are pushed 
+on to the environment stack. When leaving the function, the symbols are restored to their 
+previous values when popping the environment stack. Any other function called will see symbol 
+values as currently defined in the scope of the calling function. The variable environment 
+changes dynamically while calling and returning from functions. The scope of a variable extends 
+dynamically into lower call levels.</p>
+
+<p>The following example sets two variables and defines two lambda functions. After the function definitions the functions are used in a nested fashion. The changing parts of the variable environment are shown in bold type face:</p>
+
+<blockquote><pre>
+; x  &rarr; nil, y  &rarr; nil;
+; foo  &rarr; nil
+; double  &rarr; nil
+; environment stack: [ ]
+
+(define (foo x y)       
+	(+ (double (+ x 1)) y))
+
+; x &rarr; nil, y  &rarr; nil, 
+<b>; foo  &rarr; (lambda (x y) (+ (double (+ x 1)) y))</b>
+; double  &rarr; nil
+; environment stack: [ ]
+
+(define (double x)
+	(* 2 x))
+
+; x  &rarr; nil, y  &rarr; nil
+; foo  &rarr; (lambda (x y) (+ (double (+ x 1)) y))
+<b>; double  &rarr; (lambda (x) (* 2 x)))</b>
+; environment stack: [ ]
+
+(set 'x 10) (set 'y 20)
+
+<b>; x  &rarr; 10, y  &rarr; 20</b>
+; foo  &rarr; (lambda (x y) (+ (double (+ x 1)) y))
+; double  &rarr; (lambda (x) (* 2 x)))
+; environment stack: [ ]
+</pre></blockquote>
+
+<p>Similar to Scheme newLISP uses the same namespace for variable symbols and symbols holding user-defined lambda functions. The <tt>define</tt> function is just a short-cut for writing:</p>
+
+<blockquote><pre>
+(set 'foo (lambda (x y) (+ (double (+ x 1)) y)))
+</pre></blockquote>
+
+<p>During all these operations the environment stack stays empty <tt>[ ]</tt>. Symbol variables holding lambda expressions are part of the same namespace and treated the same way as variables holding data. Now the the first function  <tt>foo</tt> gets called:</p>
+
+<blockquote><pre>
+(foo 2 4)
+
+; after entering the function foo
+<b>; x &rarr; 2, y &rarr; 4</b>
+; foo &rarr; (lambda (x y) (+ (double (+ x 1)) y))
+; double &rarr; (lambda (x) (* 2 x)))
+<b>; environment stack: [x -> 10, y -> 20]</b>
+</pre></blockquote>
+
+<p>After entering the functions, the old values of <tt>x</tt> and <tt>y</tt> are pushed on the environment stack. This push-operation is initiated by the function <i>evaluateLambda(func, args)</i>, discussed later in this paper. Inside <tt>foo</tt> the second function <tt>double</tt> is called:</p>
+
+<blockquote><pre>
+(double 3)
+; after entering the function double
+<b>; x -> 3, y -> 4</b>
+; foo &rarr; (lambda (x y) (+ (double (+ x 1)) y))
+; double &rarr; (lambda (x) (* 2 x)))
+<b>; environment stack: [x -> 10, y -> 20, x -> 2]</b>
+
+; after return from double
+<b>; x &rarr; 2, y &rarr; 4</b>
+; foo &rarr; (lambda (x y) (+ (double (+ x 1)) y))
+; double &rarr; (lambda (x) (* 2 x)))
+<b>; environment stack: [x -> 10, y -> 20]</b>
+
+; after return from foo
+<b>; x &rarr; 10, y &rarr; 20</b>
+; foo &rarr; (lambda (x y) (+ (double (+ x 1)) y))
+; double &rarr; (lambda (x) (* 2 x)))
+<b>; environment stack: [ ]</b>
+</pre></blockquote>
+
+<p>Note that in newLISP dynamic scoping of parameter symbols in lambda expressions does not create lexical state-full closures around those symbols as in the Scheme dialect of Lisp. On return from the lambda function the symbol contents gets destroyed and memory is reclaimed. The parameter symbols regain their old values on exit from the lambda function by popping them from the environment stack. </p>
+
+<p>In newLISP lexical state-full closures are not realized using lambda closures but using lexical namespaces. Lambda functions in newLISP do not create closures but can create a new scope and new temporary content for existing symbols during lambda function execution.</p>
+
+<h3>Lambda function evaluation</h3>
+
+<p>All of the processing just described happens in <tt>evaluateLambda(func, args)</tt>. The following pseudo code shows more detail:</p>
+
+<blockquote><pre>
+function evaluateLambda(lambda-func, args)
+    {
+    for each parameter symbol in lambda-func
+        pushEnvironmentStack(symbol, value)
+
+    for each arg in args and the symbol belonging to arg
+        ; evaluation of arg happens in old symbol environment
+        assignSymbolValue(symbol, evaluateExpression(arg))
+
+    for each body expression expr in lambda-func
+        result = evaluateExpression(expr)
+
+    for each parameter symbol in lambda-func
+        popEnvironmentStack()
+
+    return(result)
+    }	
+</pre></blockquote>
+
+<p>The <tt>evaluateExpression(args)</tt> function and <tt>evaluateLambda(func, args)</tt> call each other in a recursive cycle.</p>
+
+<p>Note that arguments to lambda functions are evaluated in the variable environment as defined previous to the lambda function call. Assignments to parameters symbols do happen after all argument evaluations. Only the arguments are evaluated which have a corresponding parameter symbol. If there are more parameter symbols than arguments passed, then parameter symbols are assigned <tt>nil</tt> or a default value.</p>
+
+<h3>Namespaces and the translation and evaluation cycle</h3>
+
+<p>All memory data objects in newLISP are bound directly or indirectly to a symbol. Either memory objects are directly referenced by a symbol or they are part of an enclosing s-expression memory object referenced by a symbol. Unbound objects only exist as transient objects as returned values from evaluations and are referenced on the result stack for later deletion [1].</p> 
+
+<p>Except for symbols, all data and program objects are referenced only once. Symbols are created and organized in a binary tree structure. Namespaces, called <i>contexts</i> in newLISP, are sub-branches in this binary tree. A context is bound to a symbol in the root context <tt>MAIN</tt>, which itself is a symbol in the root context.</p>
+
+<p>With few exceptions all symbols are created during the code loading and translation phase of the newLISP interpreter. Only the functions <tt>load</tt>, <tt>sym</tt>, <tt>eval-string</tt> and a special syntax of <tt>context</tt> create symbols during runtime execution.</p>
+
+<p>The two symbols <tt>MAIN:x</tt> and <tt>CTX:x</tt> are two different symbols at all times. A symbol under no circumstances can change it's context after it was created. A context, e.g <tt>CTX</tt>, itself is a symbol in <tt>MAIN</tt> containing the root pointer to a sub-branch in the symbol tree.</p>
+
+<p>The working of context switching is explained using the following two code pieces:</p>
+
+<blockquote><pre>
+(set 'var 123)
+(define (foo x y)
+    (context 'CTX)
+    (println var " " x " " y))
+</pre></blockquote>
+
+<p>The <tt>(context 'CTX)</tt> statement only has been included here to show, it has no effect in this position. A switch to a different namespace context will only have influence on subsequent symbol creation using <tt>sym</tt> or <tt>eval-string</tt>. By the time <tt>(context 'CTX)</tt> is executed <tt>foo</tt> has already been defined and all symbols used in it have been looked up and translated. Only when using <tt>(context ...)</tt> on the top level it will influence the symbol creation of code following it:</p>
+
+<blockquote><pre>
+(context 'CTX)
+(set 'var 123)
+(define (foo x y)
+    (println var " " x " " y))
+(context MAIN)
+</pre></blockquote>
+
+<p>Now the context is created and switched to on the top-level. When newLISP translates the subsequent set-statement and function definition, all symbols will be part of <tt>CTX</tt> as <tt>CTX:var</tt>, <tt>CTX:foo</tt>, <tt>CTX:x</tt> and <tt>CTX:y</tt>.</p>
+
+
+<p>When loading code newLISP reads a top-level expression translating then evaluating it. This cycle is repeated until all top-level expression are read and evaluated.</p>
+
+<blockquote><pre>
+(set 'var 123)
+(define (foo x y)
+    (println var " " x " " y))
+</pre></blockquote>
+
+<p>In the previous code snippet two top-level expressions are translated and evaluated resulting in the creation of the three symbols: <tt>MAIN:var</tt>, <tt>MAIN:foo</tt>, <tt>MAIN:x</tt>, <tt>MAIN:y</tt> and <tt>MAIN:CTX</tt>.</p> 
+
+<p>The symbol <tt>MAIN:var</tt> will contain the number <tt>123</tt> and the <tt>MAIN:foo</tt> symbols will contain the lambda expression <tt>(lambda (x y) (println var " " x " " y))</tt>. The symbols <tt>MAIN:x</tt> and <tt>MAIN:y</tt> both will contain <tt>nil</tt>. The <tt>var</tt> inside the definition of <tt>foo</tt> is the same as the <tt>var</tt> previously set to <tt>123</tt> and will be printed as <tt>123</tt> during execution of <tt>foo</tt>.</p>
+
+<p>In detail the following steps are happening:</p>
+
+<ol>
+<li> current context is <tt>MAIN</tt></li>
+<li> read the opening top-level parenthesis <tt>I</tt> and create a Lisp cell of type <tt>EXPRESSION</tt>.</li> 
+<li> read and lookup <tt>set</tt> in <tt>MAIN</tt> and find it to be a built-in primitive in <tt>MAIN</tt>, translate it to the address of this primitive function in memory. Create a Lisp cell of type <tt>PRIMITIVE</tt> containing the functions address in its contents slot.</li>
+<li> read the quote <tt>'</tt> and create a Lisp cell of type <tt>QUOTE</tt>.</li>
+<li> read and lookup lookup <tt>var</tt> in <tt>MAIN</tt>, it is not found in <tt>MAIN</tt>, create it in <tt>MAIN</tt> and translate it to the address in the binary symbol tree. Create a Lisp cell of type <tt>SYMBOL</tt> containing the symbols address in its contents slot. The previously created quote cell serves as an envelop for the symbols cell.</li>
+<li> read <tt>123</tt> and create a Lisp cell of type <tt>INTEGER</tt> with <tt>123</tt> in its contents slot.</li>
+<li> read the closing top-level parenthesis finish the following list structure in memory:<br />
+
+
+<blockquote><pre>
+[ ]                          ; cell of type: EXPRESSION
+  \
+ [MAIN:set]  &rarr; [']  &rarr; [123]  ; three cells of type: PRIMITIVE, QUOTE, INTEGER
+                 \
+               [MAIN:var]    ; cell of type: SYMBOL
+</pre></blockquote>
+
+<p>The above list diagram shows the five Lisp cells, which are created. List and quote cells are envelope cells containing a list or a quoted expression.</p>
+
+<p>The statement <tt>(set 'var 123)</tt> is not executed yet, but symbol translation and creation have finished and the statement exists as a list structure in memory. The whole list structure can be referenced with one memory address, the address of the first created cell of type <tt>EXPRESSION</tt>.</p>
+</li>
+
+<li>Evaluate the statement</li>
+</ol>
+
+<p>In similar fashion newLISP will read and translate the next top-level expression, which is the function definition of <tt>foo</tt>. Evaluating this top-level expression will result in an assignment of a lambda expression to the <tt>foo</tt> symbol.</p>
+
+<p>In the above code snippet both instances of <tt>var</tt> refer to <tt>MAIN:var</tt>. The <tt>(context  'CTX)</tt> statement only changes the context, namespaces for newly created symbols. The symbol <tt>var</tt> was created during loading translating the <tt>foo</tt> function. By the time <tt>foo</tt> is called and executed <tt>var</tt> already exists inside the <tt>foo</tt> function as <tt>MAIN:var</tt>. The <tt>(context 'CTX)</tt> statement doesn't have any effect of the subsequent execution of <tt>(println var)</tt>.</p>
+
+<p>Context statements like <tt>(context 'CTX)</tt> above, change the current context for symbol creation during the loading and translation phase. The current context defines under which branch in the symbol tree new symbols are created. This affects only the the functions <tt>sym</tt>, <tt>eval-string</tt> and a special syntax of <tt>context</tt> to create symbols. Once a symbol belongs to a context it stays there.</p>
+
+<h3>Namespace context switching</h3>
+
+<p>Previous chapters showed how to use context switching on the top-level of a newLISP source file to influence symbol creation and translation during the source loading process. Once different namespaces exist, calling a function which belongs to different context, will cause a context switch to the namespace the called lambda function resides in. If the called function doesn't execute any <tt>sym</tt> or <tt>eval-string</tt> statements, then these context switches don't have any effect. Even the <tt>load</tt> command will always start file loading relative to context <tt>MAIN</tt> unless a different context is specified as a special parameter in <tt>load</tt>. Inside the file loaded context switches will have an effect of symbol creation during the load process as explained previously.</p>
+
+<p>What causes the context switch is the symbol holding the lambda function. In the following code examples bold face is used for output generated by <tt>println</tt> statements:</p>
+
+<blockquote><pre>
+(context 'Foo)
+(set 'var 123)
+(define (func) 
+    (println "current context: " (context))
+    (println "var: " var))
+(context 'MAIN)
+
+(Foo:func)
+<b>current context: Foo</b>
+<b>var: 123</b>
+
+(set 'aFunc Foo:func)
+(set 'var 999)
+
+(aFunc)
+<b>current context: MAIN</b>
+<b>var: 123</b>
+</pre></blockquote>
+
+<p>Note that the call to <tt>aFunc</tt> causes the current context to be shown as <tt>MAIN</tt>, because the symbol <tt>aFunc</tt> belongs to context <tt>MAIN</tt>. In both cases <tt>var</tt> is printed as <tt>123</tt>. The symbol <tt>var</tt> was put into the <tt>Foo</tt> namespace during translation of <tt>func</tt> and will always stay there, even if a copy of the lambda function is made and assigned to a symbol in a different context.</p>
+
+<p>This context switching behaviour follows the same rules when applying or mapping functions:</p>
+
+<blockquote><pre>
+(apply 'Foo:func)
+<b>current context: Foo
+var: 123</b>
+
+(apply Foo:func)
+<b>current context: MAIN
+var: 123</b>
+</pre></blockquote>
+
+<p>The first time <tt>Foo:func</tt> is applied as a symbol &ndash; quoted, the second time the lambda function contained in <tt>Foo:func</tt> is applied directly, because <tt>apply</tt> evaluates it's first argument first.</p> 
+
+<h3>Namespaces and the default functor</h3>
+
+<p>In newLISP a symbol is a <i>default functor</i> if it has the same name as the context it belongs too, e.g. <tt>Foo:Foo</tt> is the default functor symbol in the context <tt>Foo</tt>. In newLISP when using a context symbol in the functor position, it is taken as the default functor:</p>
+
+<blockquote><pre>
+(define (double:double x) (* 2 x))
+(double 3)  &rarr; 6
+
+(set 'my-list:my-list '(a b c d e f))
+(my-list 3)  &rarr; d
+</pre></blockquote>
+
+<p>The second example combines implicit indexing with usage of a default functor.</p>
+
+<p>Default functors can be applied and mapped using <tt>apply</tt> and <tt>map</tt> like any other function or functor symbol:</p>
+
+<blockquote><pre>
+(map my-list '(3 2 1 2))  &rarr; (d c b c)
+
+(apply double '(10))  &rarr; 20
+</pre></blockquote>
+
+<p>Default functors are a convenient way in newLISP to pass lists or other big data objects by reference:</p>
+
+<blockquote><pre>
+(set 'my-list:my-list '(a b c d e f))
+
+(define (set-last ctx val) 
+	(setf (ctx -1) val))
+
+(set-last my-list 99)  &rarr; f
+
+my-list:my-list  &rarr; (a b c d e 99)
+</pre></blockquote>
+
+<p>Default functors are also a convenient way to define functions with a closed state-full
+name space:</p>
+
+<blockquote><pre>
+(context 'accumulator)
+(define (accumulator:accumulator x) 
+	(if (not value) 
+		(set 'value x)
+		(inc 'value x)))
+(context MAIN)
+
+(accumulator 10)  &rarr; 10
+(accumulator 2)  &rarr; 12
+(accumulator 3)  &rarr; 15
+</pre></blockquote>
+
+<p>Note that the symbols <tt>x</tt> and <tt>value</tt> both belong to the namespace <tt>accumulator</tt>. Because <tt>(context 'accumulator)</tt> is at the top level, the translation of following function definition for <tt>accumulator:accumulator</tt> happens inside the current namespace <tt>accumulator</tt>.</p>
+
+<p>Namespaces in newLISP can be passed by reference and can be used to create state-full lexical closures.</p>
+
+<h3>The default functor used as a pseudo hash function</h3>
+<p>A default functor containing <tt>nil</tt> and in operator position 
+will work similar to a hash function for building dictionaries with 
+associative key &rarr; value access:</p>
+
+<blockquote><pre>
+(define aHash:aHash) ; create namespace and default functor containing nil
+
+(aHash "var" 123) ; create and set a key "var" to 123
+
+(aHash "var")  &rarr; 123 ; retrieve value from key
+</pre></blockquote>
+
+<h3>References</h3>
+[1] <i>Lutz Mueller</i>, 2004-2015<br /> 
+<a href="http://newlisp.org/MemoryManagement.html">Automatic Memory Management in newLISP</a>.
+<br /><br />
+
+[2] <i>John McCarthy</i>, 1960<br />
+<a href="http://www-formal.stanford.edu/jmc/recursive.html">Recursive Functions of Symbolic Expressions and their Computation by Machine</a>.
+<br /><br />
+<center><font size="-1">Copyright &copy; 2007-2016, Lutz Mueller 
+<a href="http://newlisp.org">http://newlisp.org</a>. All rights reserved. </font></center>
+</blockquote>
+</body>
+</html>
diff --git a/doc/INSTALL b/doc/INSTALL
new file mode 100644
index 0000000..d3b6278
--- /dev/null
+++ b/doc/INSTALL
@@ -0,0 +1,396 @@
+BINARY INSTALL, BUILD, TOOLS, LOCALIZING  (last updated 2011-11-14
+-------------------------------------------------------------------
+
+CONTENTS
+
+ (1) WIN32 BINARY DISTRIBUTION INSTALLATION
+ (2) Mac OS X BINARY DISTRIBUTION INSTALLATION
+ (3) UBUNTU Linux DEBIAN DISTRIBUTION INSTALLATION
+ (4) MINIMUM INSTALL
+ (5) BUILD, TEST AND INSTALL newLISP FROM SOURCE
+ (6) COMMENTS FOR COMPILING AND LINKING
+ (7) LOCALIZATION
+ (8) UNINSTALL
+ (9) RUNNING newLISP IN A SHELL OR CONSOLE WINDOW
+(10) RUNNING THE newLISP-GS GRAPHICAL FRONTEND
+(11) INSTRUCTIONS FOR CUSTOMIZED INSTALL AND PACKAGE CREATORS
+(12) COMMENTS ABOUT LIBFFI
+
+
+(1) WIN32 BINARY DISTRIBUTION INSTALLATION
+------------------------------------------
+
+The Win32 binary distribution comes packed as a Win32 installer
+application. After downloading a file:
+
+    newlisp-xxxx-win-gs-xxx.exe
+
+double click on the downloaded file and follow instructions. xxxx and xxx 
+are the version numbers for newLISP and the newLISP-GS the GUI frontend. 
+On Win32 a ASCII version of newlisp.exe capable of ISO/IEC 8859 code pages 
+is installed. A UTF-8 capable version is available from the newlisp download 
+directory at: http://www.newlisp.org/downloads/UTF-8_win32/
+
+
+(2) Mac OS X BINARY DISTRIBUTION INSTALLATION
+---------------------------------------------
+
+After downloading double-click on the Mac OS X disk image file:
+
+    newlisp-xxxx-ppc.dmg     # for older PPC type Macs
+or
+    newlisp-xxxx-intel.dmg   # since at least end of 2007
+    
+This installs an applications icon in the Mac OS X Applications folder.
+On Mac OS X a UTF-8 capable version is installed by default. On both,
+Intel and PPC architectures Mac OS X v10.5 Leopard is minimum.
+
+
+(3) UBUNTU Linux DEBIAN DISTRIBUTION INSTALLATION
+-------------------------------------------------
+
+Double click the file:
+
+    newlisp-xxxx-x_i386.deb
+or
+    newlisp-xxxx-utf8_i386.deb
+    
+This will bring up the debian installer application.
+
+On some UBUNTU libraries libreadline and libffi may have to be installed
+when making from source:
+
+    sudo apt-get install libreadline6 libreadline6-dev  
+and
+    apt-get install libffi-dev 
+
+
+(4) MINIMUM INSTALL
+-------------------
+
+For a minumum install, only the executable file: newlisp (or newlisp.exe
+on Win32) needs to be moved to a directory in the executable path, i.e. 
+/usr/bin/newlisp on Unix. No other files are required. This installation
+is recommended for ISPs and other server installations. If modules are
+installed the environment NEWLISPDIR should be defined to point to
+the modules parent directory. If NEWLISPDIR is not defined, newLISP sets
+it to /usr/share/newlisp during startup.
+
+To reduce an exisiting UNIX install to a minimum installation, remove all 
+files in /usr/share/newlisp and /usr/share/doc/newlisp and the executable 
+files /usr/bin/newlisp-edit and /usr/bin/newlispdoc.
+
+On Mac OX X remove also the files under the Applications icon in the 
+Applications folder. On Windows remove all file except newlisp.exe in 
+C:/Program Files/newlisp.
+
+
+(5) BUILD AND INSTALL newLISP FROM SOURCE
+-----------------------------------------
+
+Un-tar/gunzip the distribution file newlisp_9.x.x.tgz :
+
+    tar xzvf newlisp_9.x.x.tgz
+
+Change the current directory in to newlisp_x.x.x/
+
+and check what OS flavor make would detect, type:
+
+    ./configure
+
+This will automatically detect the platforms Linus, MacOS X, FreeBSD,
+OpenBSD, NetBSD, SunOS/Solaris and Win32. To build on Win32 a MinGW
+installation hosted by MSYS is required. See http://mingw.org.
+
+If you agree with the platform detected by configure type:
+
+    make
+ 
+After building has finished type:
+
+    make testall
+
+or for a shorter version
+
+    make test
+
+when all tests are passed OK do a
+
+    sudo make install
+    
+or if already in superuser mode:
+
+    make install
+
+to find out all make options, use:
+
+    make help
+
+For shorter ouput, 'make test' can be used instead of 'make check'.
+Using 'make testall' or 'make checkall' more tests and a speed
+benchmark are performed.
+
+
+(6) COMMENTS FOR COMPILING AND LINKING
+--------------------------------------
+
+If skipping the ./configure step and just doing make, the
+configure script will be called automatically if no makefile_build
+can be found, or else the existing makefile_build will be used.
+
+The standard configure script assumes READLINE support, discovers 
+the default memory model (32 bit vs 64 bit) and copies one of the 
+pre-fabricated makefiles to makefile_build. The standard 
+configure forces 32-bit on MacOS X even if 64-bit is
+detected. To force compile for 64-bit either choose an appropiate
+make file manually or use configure-alt.
+
+If compiling with READLINE fails on Linux , it may be due to missing 
+readline.h and history.h include files. In this case the package 
+'libreadline5-dev' has to be installed.
+
+On some platforms the warning message "ANSI does not support long long"
+will be issued for every file compiled. This message can be discarded 
+and does not occur on newer versions of GCC. The 'long long' data type 
+is not used anywhere in the newLISP source but part of some header files 
+of the GCC installation.
+
+Most of the makefile_xxxxx can also be used this way:
+
+    make -f makefile_xxxxx
+
+but always read the contents of makefile_xxxxx first, as it sometimes
+contains specific instructions.
+
+
+configure-alt script
+--------------------
+This script can be used as an alternative to the standard configure
+script. Instead of creating a makefile_build from existing pre-
+configured makefile configure-alt does an analysis of the capabilities
+found on the target platform and then custom generates a makefile_build.
+
+Numerous options can be configured. To find all options use:
+
+    ./configure-alt --help 
+
+For questions and support for configure-alt, please contact:
+
+     Ted Walther <ted@reactor-core.org>.
+
+Note thet configure-alt uses a version-numbered directory for the 
+installation. By default it also uses /usr/local instead of /usr
+as a prefix for the bin, man, share/newlisp and share/doc/newlisp
+directories.
+
+Avoid having installs from the standard 'configure' and alternate
+'configure-alt' script on the same machine!
+
+NOTE, that newLISP can only be compiled for the IPL32 and LP64 memory
+models.
+
+configure-alt will configure a 64-bit (LP64) application by default 
+if the platform and tools are capable. The standard configure script
+will configure a makefile for 32-bit (ILP32) by default. This may 
+change in the future.
+
+Compiling and running newlisp-x.x.x/util/types.c will produce:
+
+IPL32 memory model
+------------------
+type      bytes
+---------------
+char        1
+char *      4
+void *      4
+short int   2
+int         4
+long        4
+long int    4
+long long int  8
+size_t      4
+float       4
+double      8
+long double 16
+wchar_t     4
+size_t      4
+off_t       8
+time_t      4
+
+
+LP64 memory model
+-----------------
+type      bytes
+---------------
+char        1
+char *      8
+void *      8
+short int   2
+int         4
+long        8
+long int    8
+long long int  8
+size_t      8
+float       4
+double      8
+long double 16
+wchar_t     4
+size_t      8
+off_t       8
+time_t      8
+
+
+(7) LOCALIZATION
+----------------
+
+The PCRE Regular Expressions code can be localized to your country/language 
+It comes with default character tables for English, but should work well
+for other languages when using the UTF-8 version of newLISP. For correct working of 
+other string functions in your country/language a localizable 'C' library/OS 
+may have to be used. The names of newLISP functions can be localized during 
+runtime without performance loss, (see newlisp_manual.html).
+
+There are UTF-8 versions/makefiles available in the source distribution.
+See the chapter about 'Customization, localization and UTF-8' in the manual.
+
+
+(8) UNINSTALL
+-------------
+
+On Win32 use the uninstall application from the newlisp applications
+menu.
+
+On Mac OS X double click on the uninstall script in the diskimage of
+the installer package.
+
+On UBUNTU Linux execute:
+
+    sudo dpkg -r newlisp
+
+On all other UNIX, to uninstall if installed with make install do:
+
+    sudo make uninstall
+
+or if installed with: make install_home
+
+    make uninstall_home
+    
+To manually uninstall on Win32 remove all files in c:\Program files\newlisp
+
+On Mac OS X and other UNIX remove all files in /usr/share/newlisp and
+/usr/share/doc/newlisp and the executable files /usr/bin/newlisp,
+/usr/bin/newliso-edit and /usr/bin/newlispdoc. On Mac OX X also remove
+the newLISP icon in the Applications folder.
+
+   
+(8) RUNNING newLISP IN A SHELL OR CONSOLE WINDOW
+------------------------------------------------
+
+On all platforms simply execute:
+ 
+    newlisp
+
+On Win32 the execution path of newlisp.exe was added to the environment 
+during installation. On all other platforms the newlisp binary is in 
+/usr/bin/newlisp or when using the home install in $HOME/bin
+where $HOME is the the home directory of the user taken from the environment
+variable HOME.
+
+
+(10) RUNNING THE newLISP-GS GRAPHICAL FRONTEND
+----------------------------------------------
+
+On Win32 and Mac OS X a Java based syntaxhighlighting editor is installed in
+in the Applications menus. In other UNIX execute:
+    
+    newlisp-edit
+ 
+from the command line in a terminal window.
+The editor needs a Java runtime environment JRE version 1.5 as a minimum. 
+In case it is not installed it can be obtained from:
+http://www.oracle.com/technetwork/java/javase/downloads/index.html
+
+Since Mac OS X 10.7 Lion, Java is not installed by default. Install
+Java for OS X 10.7 Lion from here: http://support.apple.com/kb/DL1421
+
+(11) INSTRUCTIONS FOR CUSTOMIZED INSTALL AND PACKAGE CREATORS
+-------------------------------------------------------------
+
+By default the configure script uses the following install directories:
+
+/usr/bin/
+/usr/share/newlisp
+/usr/share/doc/newlisp
+
+As an alternative the configure-alt script can be used. Do a:
+
+    ./configure-alt --help
+
+To see all the options available. Options for install directories, 
+readline support, UTF-8 support and memory model used are available.
+
+Like configure, configure-alt creates a makefile_build and makefile_install. 
+Both makefiles are used by Makefile when doing:
+
+    make
+    make install
+    make test
+
+or for a bigger testsuite
+
+    make testall
+
+These are the standard configuration options recommended by newlisp.org:
+
+- use ILP32 memory model as a default, use LP64 only when ILP32 is not 
+available on the platform (configure-alt will take the default offered
+on the platform)
+ 
+- use the default IPV4 support IPV6 has not been thoroughly tested yet
+although it passes the standard qa-net test script (configure-alt
+defaults to IPV4.
+
+- use readline support if possible (configure-alt uses it if available)
+
+- offer both packages, one with and one without UTF-8 support on UNIX
+installations. newlisp.org ships UTF-8 support on MAC OSX by default and 
+ships without UTF-8 support on Win32 (offering UTF-8 binaries on the
+newlisp.org website).
+
+- for a brief, one line description of the package, use:
+
+newLISP is a LISP like, general purpose scripting language
+
+- for a longer description of the package, use:
+ 
+newLISP is a scripting language for developing web applications and
+programs in general and in the domains of artificial intelligence (AI)
+and statistics.
+
+
+(12) COMMENTS ABOUT LIBFFI
+--------------------------
+
+Here some general comments for usage of libffi in newLISP:
+
+The extended ffi requiring libffi and ffi.h for compiling, was only 
+introduced a short time ago in February of 2012. Except for module/gsl.lsp 
+all other modules shipped in the distributions work with the older simple 
+form of import not requiring libffi.
+
+The configure utility will pick libffi enabled makefiles only for Windows, 
+OSX and Linux. For all other OS it will pick makefiles not requiring libffi.
+
+Ted Walther's configure-alt utility, which automatically configures the 
+memory model (32-bit or 64-bit) never configures for the new extended ffi 
+using libffi.
+
+The path for ffi.h chosen in newlisp.h, is only valid for OSX and UBUNTU 
+Linux, for all other OSs the path might be different and has to be adjusted. 
+
+In any case, libffi from http://sourceware.org/libffi/ is pretty easy to make 
+for most platforms. On Windows, Mac OSX and UBUNTU Linux it is already 
+installed by default.
+
+
+                                 +++
diff --git a/doc/LOCALIZATION b/doc/LOCALIZATION
new file mode 100644
index 0000000..f333732
--- /dev/null
+++ b/doc/LOCALIZATION
@@ -0,0 +1,41 @@
+LOCALIZATION
+============
+
+See chapter 'Customization Localization and UTF-8' in the 
+Users Manual and the usage of 'set-locale' function in the 
+Function Reference.
+
+The 'set-locale' function will not influence the behaviour of
+PCRE (Perl Compatible Regular Expressions) in newLISP, but a
+special option flag number can be set to support UTF-8 in all
+functions supporting regular expressions like: regex, find,
+replace, parse and search.
+
+To further localize the behaviour of regular expressions in newLISP
+the file 'pcre-chartables.c' must be replaced with a localized
+version. To obtain this file for your locale, follow these steps:
+
+(1) get the pcre source distribution from http://www.pcre.org
+
+(2) follow the instruction in it's README file to 'configure'
+    and  'make' it. An installation is not necessary. Just using
+    the 'configure' and 'make' steps will create a file called
+    'chartables.c' suitable for the locale on your computer
+    system. Rename this file to 'pcre-chartables.c', which it
+    replaces in the newLISP source distribution.
+
+(3) recompile newLISP
+
+newLISP will now show regular expression behaviour in functions
+like 'regex', 'find', 'replace' and 'parse' appropiate to your
+locale. The function 'set-locale' should still be used to change
+all other aspects of newLISP to your locale.
+
+newLISP can be used with multi-byte character languages when
+compiled with UTF-8 options. For some OS flavors UTF-8 enabled
+makefile are shipped in the source distribution.
+
+When compiled with UTF-8 character handling some newLISP functions
+will work on multibyte characters instead of single bytes. See
+the manual for details.
+                               +++
diff --git a/doc/License.html b/doc/License.html
new file mode 100644
index 0000000..8819a71
--- /dev/null
+++ b/doc/License.html
@@ -0,0 +1,742 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<title>GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007</title>
+<body>
+<blockquote>
+<center>
+<h2><span class="function">GNU GENERAL PUBLIC LICENSE</span></h2>
+		      <p>Version 3, 29 June 2007</p>
+</center>
+
+<p>
+ Copyright (C) 2007 Free Software Foundation, Inc. http://fsf.org/
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+</p>
+
+<center><b>Preamble</b></center>
+
+<p>
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+</p>
+<p>
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+</p>
+<p>
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+</p>
+<p>
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+</p>
+<p>
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+</p>
+<p>
+  Developers that use the GNU GPL protect your rights with two steps:
+</p>
+<p>
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+</p>
+<p>
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+</p>
+<p>
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+</p>
+<p>
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+</p>
+<p>
+  The precise terms and conditions for copying, distribution and
+modification follow.
+</p>
+<center><b>TERMS AND CONDITIONS</b></center>
+
+<p><b>0. Definitions.</b></p>
+<p>
+  "This License" refers to version 3 of the GNU General Public License.
+</p>
+<p>
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+</p>
+<p>
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+</p>
+<p>
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+</p>
+<p>
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+</p>
+<p>
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+</p>
+<p>
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+</p>
+<p>
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.</p>
+
+<p><b>1. Source Code.</b></p>
+
+<p>
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+</p>
+<p>
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+</p>
+<p>
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+</p>
+<p>
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+</p>
+<p>
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+</p>
+<p>
+  The Corresponding Source for a work in source code form is that
+same work.
+</p>
+<p>
+<b>2. Basic Permissions.</b>
+
+</p>
+<p>
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+</p>
+<p>
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+</p>
+<p>
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+</p>
+<p>
+<b>3. Protecting Users' Legal Rights From Anti-Circumvention Law.</b>
+</p>
+<p>
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+</p>
+<p>
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+</p>
+<p>
+<b>4. Conveying Verbatim Copies.</b>
+</p>
+<p>
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+</p>
+<p>
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+</p>
+<p>
+<b>5. Conveying Modified Source Versions.</b>
+</p>
+<p>
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+</p>
+<blockquote>
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+</blockquote>
+<blockquote>
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+</blockquote>
+<blockquote>
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+</blockquote>
+<blockquote>
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+</blockquote>
+<p>
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+</p>
+<p>
+<b>6. Conveying Non-Source Forms.</b>
+</p>
+<p>
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+</p>
+<blockquote>
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+</blockquote>
+<blockquote>
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+</blockquote>
+<blockquote>
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+</blockquote>
+<blockquote>
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+</blockquote>
+<blockquote>
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+</blockquote>
+<p>
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+</p>
+<p>
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+</p>
+<p>
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+</p>
+<p>
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+</p>
+<p>
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+</p>
+<p>
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+</p>
+<p>
+<b>7. Additional Terms.</b>
+</p>
+<p>
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+</p>
+<p>
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+</p>
+<p>
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+</p>
+<blockquote>
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+</blockquote>
+<blockquote>
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+</blockquote>
+<blockquote>
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+</blockquote>
+<blockquote>
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+</blockquote>
+<blockquote>
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+</blockquote>
+<blockquote>
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+</blockquote>
+<p>
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+</p>
+<p>
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+</p>
+<p>
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+</p>
+<p>
+<b>8. Termination.</b>
+</p>
+<p>
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+</p>
+<p>
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+</p>
+<p>
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+</p>
+<p>
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+</p>
+<p>
+<b>9. Acceptance Not Required for Having Copies.</b>
+</p>
+<p>
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+</p>
+<p>
+<b>10. Automatic Licensing of Downstream Recipients.</b>
+</p>
+<p>
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+</p>
+<p>
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+</p>
+<p>
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+</p>
+<p>
+<b>11. Patents.</b>
+</p>
+<p>
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+</p>
+<p>
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+</p>
+<p>
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+</p>
+<p>
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+</p>
+<p>
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+</p>
+<p>
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+</p>
+<p>
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+</p>
+<p>
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+</p>
+<p>
+<b>12. No Surrender of Others' Freedom.</b>
+</p>
+<p>
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+</p>
+<p>
+<b>13. Use with the GNU Affero General Public License.</b>
+</p>
+<p>
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+</p>
+<p>
+<b>14. Revised Versions of this License.</b>
+</p>
+<p>
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+</p>
+<p>
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+</p>
+<p>
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+</p>
+<p>
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+</p>
+<p>
+<b>15. Disclaimer of Warranty.</b>
+</p>
+<p>
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+</p>
+<p>
+<b>16. Limitation of Liability.</b>
+</p>
+<p>
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+</p>
+<p>
+<b>17. Interpretation of Sections 15 and 16.</b>
+</p>
+<p>
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+</p>
+<br/>
+<center><b>END OF TERMS AND CONDITIONS</b></center>
+</blockquote>
+
+</body>
+</html>
+
diff --git a/doc/MemoryManagement.html b/doc/MemoryManagement.html
new file mode 100644
index 0000000..da8f5c9
--- /dev/null
+++ b/doc/MemoryManagement.html
@@ -0,0 +1,444 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<title>Automatic Memory Management in newLISP</title>
+<style type="text/css" media="screen">
+<!--
+body, h4, p {
+	font-family: Lucida Sans, Helvetica, sans-serif;
+	line-height: 120%;
+	max-width: 1000px;
+	}
+
+h1, h2, h3 {
+	margin-top: 3%;
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+	color: #404040;
+    }
+
+table {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: solid;
+	border-width: 0px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+	font-size: 95%;
+    }
+    
+th {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #eeeeee;
+    font-size: 100%;
+    }
+    
+td {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+    font-size: 100%;
+    }
+    
+pre {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: dashed;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 4px;
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 90%;
+	background: #f8ffff;
+    }
+
+tt {
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 100%;
+    }
+-->
+</style>
+</head>
+
+<body text="#000000" bgcolor="#FFFFFF" link="#376590" vlink="#551A8B" alink="#ffAA28">
+
+<br/>
+<blockquote>
+<center><h2>Automatic Memory Management in newLISP</h2></center>
+<center><font size="-1">Lutz Mueller, 2004-2015. Last edit 2013-11-07<br/>
+</font></center>
+
+<center><blockquote><blockquote><i>
+ORO (One Reference Only) automatic memory management developed for newLISP is a fast 
+and resources saving alternative to classic garbage collection algorithms in dynamic, 
+interactive programming languages. This article explains how ORO memory management works</i>
+</blockquote></blockquote></center>
+
+<p>newLISP and any other interactive language system will constantly generate new memory 
+objects during expression evaluation. The new memory objects are intermediate evaluation results, 
+reassigned memory objects, or memory objects whose content was changed. If newLISP did not 
+delete some of the objects created, it would eventually run out of available memory.</p>
+
+<p>In order to understand newLISP's automatic memory management, it is necessary to first 
+review the traditional methods employed by other languages.</p>
+
+<h3>Traditional automatic memory management (Garbage Collection)</h3>
+
+<p>In most programming languages, a process registers allocated memory, and another 
+process finds and recycles the unused parts of the allocated memory pool. The recycling 
+process can be triggered by some memory allocation limit or can be scheduled to happen 
+between evaluation steps. This form of automatic memory management is called 
+<i>Garbage Collection</i>.</p>
+
+<p>Traditional garbage collection schemes developed for LISP employed one of two 
+algorithms: &sup1;</p>
+
+<p>(1) The <i>mark-and-sweep</i> algorithm registers each allocated memory object. A mark 
+phase periodically flags each object in the allocated memory pool. A named object 
+(a variable symbol) directly or indirectly references each memory object in the system. 
+The sweep phase frees the memory of the marked objects when they are no longer in use.</p>
+
+<p>(2) A <i>reference-counting</i> scheme registers each allocated memory object together 
+with a count of references to the object. This reference count gets incremented or decremented 
+during expression evaluation. Whenever an object's reference count reaches zero, the object's 
+allocated memory is freed.</p>
+
+<p>Over time, many elaborate garbage collection schemes have been attempted based on these 
+principles. The first garbage collection algorithms appeared in LISP. The inventors of 
+the Smalltalk language used more elaborate garbage collection schemes. The history of 
+Smalltalk-80 is an exciting account of the challenges of implementing memory management 
+in an interactive programming language; 
+see [Glenn Krasner, 1983: <i>Smalltalk-80, Bits of History, Words of Advice</i>]. 
+A more recent overview of garbage collection methods can be found in 
+[Richard Jones, Rafael Lins, 1996: <i>Garbage Collection, Algorithms for 
+Automatic Dynamic Memory Management</i>].</p>
+
+
+<h3>One reference only, (ORO) memory management</h3>
+
+<p>Memory management in newLISP does not rely on a garbage collection algorithm. Memory is 
+not marked or reference-counted. Instead, a decision whether to delete a newly created memory 
+object is made right after the memory object is created.</p>
+
+<p>Empirical studies of LISP have shown that most LISP cells are not shared and so can be 
+reclaimed during the evaluation process. Aside from some optimizations for part of the
+built-in functions, newLISP deletes memory new objects containing intermediate evaluation results 
+once it reaches a higher evaluation level. newLISP does this by pushing a reference to each 
+created memory object onto a result stack. When newLISP reaches a higher evaluation level, it 
+removes the last evaluation result's reference from the result stack and deletes the evaluation 
+result's memory object. This should not be confused with one-bit reference counting. ORO memory 
+management does not set bits to mark objects as <i>sticky</i>.</p>
+
+<p>newLISP follows a one reference only (ORO) rule. Every memory object not referenced by a 
+symbol is obsolete once newLISP reaches a higher evaluation level during 
+expression evaluation. Objects in newLISP (excluding symbols and contexts) are passed by value 
+copy to other user-defined functions. As a result, each newLISP object only requires one 
+reference.</p>
+
+<p>newLISP's ORO rule has advantages. It simplifies not only memory management but also 
+other aspects of the newLISP language. For example, while users of traditional LISP 
+have to distinguish between equality of copied memory objects and equality of references 
+to memory objects, newLISP users do not.</p>
+
+<p>newLISP's ORO rule forces newLISP to constantly allocate and then free LISP cells. 
+newLISP optimizes this process by allocating large chunks of cell memory from the host 
+operating system. newLISP will request LISP cells from a free cell list and then recycle 
+those cells back into that list. As a result, only a few CPU instructions (pointer assignments) 
+are needed to unlink a free cell or to re-insert a deleted cell.</p>
+
+<p>The overall effect of ORO memory management is a faster evaluation time and a smaller memory 
+and disk footprint than traditional interpreted LISP's can offer. Time spent linking and 
+unlinking memory objects is more than compensated for by the lack of processing time used in
+traditional garbage collection. ORO memory management also avoids occasional processing
+pauses seen in languages using traditional garbage collection and the tuning of garbage
+collection parameters required when running memory intensive programs.</p>
+
+<p>ORO memory management happens synchronous to other processing in the interpreter, which
+results in deterministic processing times.</p>
+
+<p>In versions before 10.1.3, newLISP employed a classic mark and sweep algorithm to 
+free un-referenced cells under error conditions. Starting version 10.1.3, this has been 
+eliminated and replaced by a proper cleanup of the result stack under error conditions.</p>
+
+<h3>Performance considerations with copying parameters</h3>
+
+<p>In theory, passing parameters to user-defined functions by value (memory copying) instead 
+by reference poses a potential disadvantage when dealing with large lists, arrays or strings.
+But in practice newLISP performs faster or as fast than other scripting languages and offers
+language facilities to pass very large memory object by reference.</p>
+
+<p>Since newLISP version 9.4.5 functions can pass list, array and string type parameters 
+as references using <i>default functor</i> namespace ids. Namespaces (called contexts 
+in newLISP) have very little overhead and can be used to wrap functions and data.
+This allows reference passing of large memory object into user-defined functions.</p>
+
+<p>Since version 10.2 FOOP (Functional Object Oriented Programming) in newLISP also passes
+the target object of a method call by reference.</p>
+
+<p>But even in instances where reference passing and other optimizations are nor present, 
+the speed of ORO memory management more than compensates for the overhead required to
+copy and delete objects.</p>
+
+<h3>Optimizations to ORO memory management &sup2;</h3>
+
+<p>Since newLISP version 10.1, all lists, arrays and strings are passed in and out of
+built-in functions by reference. All built-in functions work directly on memory
+objects returned by reference from other built-in functions. This has substantially 
+reduced the need for copying and deleting memory objects and increased the speed of 
+some built-in functions. Now only parameters into user-defined functions and return
+values passed out of user-defined functions are ORO managed.</p>
+
+<p>Since version 10.3.2, newLISP checks the result stack before copying LISP cells.
+This has reduced the amount of cells copied by about 83% and has significantly 
+increased the speed of many operations on bigger lists.</p>
+
+<h3>Memory and datatypes in newLISP</h3>
+
+<p>The memory objects of newLISP strings are allocated from and freed to the host's OS, 
+whenever newLISP recycles the cells from its allocated chunks of cell memory. This means 
+that newLISP handles cell memory more efficiently than string memory. As a result, it is 
+often better to use symbols rather than strings for efficient processing. For example, 
+when handling natural language it is more efficient to handle natural language words as 
+individual symbols in a separated name-space, then as single strings. 
+The <tt>bayes-train</tt> function in newLISP uses this method. newLISP can handle 
+millions of symbols without degrading performance.</p>
+
+<p>Programmers coming from other programming languages frequently overlook that symbols in 
+LISP can act as more than just variables or object references. The symbol is a useful data 
+type in itself, which in many cases can replace the string data type.</p>
+
+<p>Integer numbers and double floating-point numbers are stored directly in newLISP's LISP 
+cells and do not need a separate memory allocation cycle.</p>
+
+<p>For efficiency during matrix operations like matrix multiplication or inversion, newLISP 
+allocates non-cell memory objects for matrices, converts the results to LISP cells, and then 
+frees the matrix memory objects.</p>
+
+<p>newLISP allocates an array as a group of LISP cells. The LISP cells are allocated linearly. 
+As a result, array indices have faster random access to the LISP cells. Only a subset of 
+newLISP list functions can be used on arrays. Automatic memory management in newLISP handles 
+arrays in a manner similar to how it handles lists.</p>
+
+<h3>Implementing ORO memory management</h3>
+
+<p>The following pseudo code illustrates the algorithm implemented in newLISP in the context 
+of LISP expression evaluation. Only two functions and one data structure are necessary to 
+implement ORO memory management:</p>
+
+<blockquote><pre>
+function pushResultStack(evalationResult)
+
+function popResultStack() ; implies deleting
+
+array resultStack[] ; preallocated stack area
+</pre></blockquote>
+
+<p>The first two functions <tt>pushResultStack</tt> and <tt>popResultStack</tt> push or 
+pop a LISP object handle on or off a stack. <tt>pushResultStack</tt> increases the value 
+<tt>resultStackIndex</tt> while <tt>popResultStack</tt> decreases it. In newLISP every 
+object is contained in a LISP cell structure. The object handle of that structure is simply 
+the memory pointer to the cell structure. The cell itself may contain pointer addresses to 
+other memory objects like string buffers or other LISP cells linked to the original object. 
+Small objects like numbers are stored directly. In this paper function 
+<tt>popResultStack()</tt> also implies that the popped object gets deleted.</p> 
+
+<p>The two <tt>resultStack</tt> management functions described are called by newLISP's 
+<tt>evaluateExpression</tt> function: &sup3;</p>
+
+<blockquote><pre>
+function evaluateExpression(expr)
+    {
+    resultStackIndexSave = resultStackIndex
+
+    if typeOf(expr) is BOOLEAN or NUMBER or STRING
+		return(expr)
+
+    if typeOf(expr) is SYMBOL
+        return(symbolContents(expr))
+
+    if typeOf(expr) is QUOTE
+        return(quoteContents(expr))
+
+    if typeOf(expr) is LIST
+        {    
+        func = evaluateExpression(firstOf(expr))
+        args = rest(expr)
+        if typeOf(func) is BUILTIN_FUNCTION
+                result = evaluateFunc(func, args)
+        else if typeOf(func) = LAMBDA_FUNCTION
+                result = evaluateLambda(func, args)
+        }
+    }
+
+    while (resultStackIndex &gt; resultStackIndexSave)
+        deleteList(popResultStack())
+
+    pushResultStack(result)
+
+    return(result)
+    }
+</pre></blockquote>
+
+<p>The function <tt>evaluateExpression</tt> introduces the two variables 
+<tt>resultStackIndexSave</tt> and <tt>resultStackIndex</tt> and a few other functions:</p>
+
+<ul>
+<li>
+<tt>resultStackIndex</tt> is an index pointing to the top element in the 
+<tt>resultStack</tt>. The deeper the level of evaluation the higher the value of 
+<tt>resultStackIndex</tt>.<br/><br/>
+</li>
+<li>
+<tt>resultStackIndexSave</tt> serves as a temporary storage for the value of 
+<tt>resultStackIndex</tt> upon entry of the <tt>evaluateExpression(func, args)</tt> function. 
+Before exit the <tt>resultStack</tt> is popped to the saved level of <tt>resultStackIndex</tt>. 
+Popping the <tt>resultStack</tt> implies deleting the memory objects pointed to by entries in 
+the <tt>resultStack</tt>.<br/><br/>
+</li>
+<li>
+<tt>resultStack[]</tt> is a preallocated stack area for saving pointers to LISP cells 
+and indexed by <tt>resultStackIndex</tt>.<br/><br/>
+</li>
+<li>
+<tt>symbolContents(expr)</tt> and <tt>quoteContents(expr)</tt> extract contents from symbols 
+or quote-envelope cells.<br/><br/>
+</li>
+<li>
+<tt>typeOf(expr)</tt> extracts the type of an expression, which is either a <tt>BOOLEAN</tt> 
+constant like <tt>nil</tt> or <tt>true</tt> or a <tt>NUMBER</tt> or <tt>STRING</tt>, or is 
+a variable <tt>SYMBOL</tt> holding some contents, or a <tt>QUOTE</tt> serving as an envelope 
+to some other <tt>LIST</tt> expression <tt>expr</tt>.<br/><br/>
+</li>
+<li>
+<tt>evaluateFunc(func, args)</tt> is the application of a built-in function to its arguments. 
+The built-in  function is the evaluated first member of a list in <tt>expr</tt> and the 
+arguments are the <tt>rest</tt> of the list in <tt>expr</tt>. The function <tt>func</tt> is 
+extracted calling <tt>evaluateExpression(first(expr))</tt> recursively. For example if the 
+expression (<tt>expr</tt> is <tt>(foo x y)</tt> than <tt>foo</tt> is a built-in function and 
+<tt>x</tt> and <tt>y</tt> are the function arguments or parameters.<br/><br/>
+</li>
+<li>
+<tt>evaluateLambda(func, args)</tt> works similar to <tt>evaluateFunc(func, args)</tt>, applying 
+a user-defined function <tt>first(expr)</tt> to its arguments in <tt>rest(expr)</tt>. In case 
+of a user-defined function we have two types of arguments in <tt>rest(expr)</tt>, a list of local 
+parameters followed by one or more body expressions evaluated in sequence.
+</li>
+</ul>
+
+<p>Both, <tt>evaluateFunc(func, args)</tt> and <tt>evaluateLambda(func, args)</tt> will return 
+a newly created or copied LISP cell object, which may be any type of the above mentioned 
+expressions. Since version 10.0, many built-in functions processed with 
+<tt>evaluateFunc(func, args)</tt> are optimized and return references instead of a newly
+created or copied objects. Except for these optimizations, <tt>result</tt> values will always 
+be newly created LISP cell objects destined to be destroyed on the next higher evaluation level, 
+after the current <tt>evaluateExpression(expr)</tt> function execution returned.</p>
+
+<p>Both functions will recursively call <tt>evaluateExpression(expr)</tt> to evaluate their 
+arguments. As recursion deepens, the recursion level of the function increases.</p>
+
+<p>Before <tt>evaluateExpression(func, args)</tt> returns, it will pop the <tt>resultStack</tt> 
+deleting the <tt>result</tt> values from deeper level of evaluation and returned by one of 
+the two functions, either <tt>evaluateFunc</tt> or <tt>evaluateLambda</tt>.</p>
+
+<p>Any newly created <tt>result</tt> expression is destined to be destroyed later but its 
+deletion is delayed until a higher, less deep, level of evaluation is reached. This permits 
+results to be used and/or copied by calling functions.</p>
+
+<p>The following example shows the evaluation of a small user-defined LISP function 
+<tt>sum-of-squares</tt> and the creation and deletion of associated memory objects:</p>
+
+<blockquote><pre>
+(define (sum-of-squares x y)
+	(+ (* x x) (* y y)))
+
+(sum-of-squares 3 4) =&gt; 25
+</pre></blockquote>
+
+<p><tt>sum-of-squares</tt> is a user-defined <em>lambda-function</em> calling to <em>built-in</em> 
+functions <tt>+</tt> and <tt>*</tt>.</p>
+
+<p>The following trace shows the relevant steps when defining the <tt>sum-of-squares</tt> function 
+and when executing it with the arguments <tt>3</tt> and <tt>4</tt>.</p>
+
+<blockquote><pre>
+&gt; (define (sum-of-squares x y) (+ (* x x) (* y y)))
+
+level 0: evaluateExpression( (define (sum-of-squares x y) 
+ (+ (* x x) (* y y))) )
+level 1: evaluateFunc( define <6598> )
+level 1: return( (lambda (x y) (+ (* x x) (* y y))) )
+
+<b>&rarr; (lambda (x y) (+ (* x x) (* y y)))</b>
+
+&gt; (sum-of-squares 3 4)
+
+level 0: evaluateExpression( (sum-of-squares 3 4) )
+level 1:   evaluateLambda( (lambda (x y) (+ (* x x) (* y y))), (3 4) )
+level 1:   evaluateExpression( (+ (* x x) (* y y)) )
+level 2:     evaluateFunc( +, ((* x x) (* y y)) )
+level 2:     evaluateExpression( (* x x) )
+level 3:       evaluateFunc( *, (x x) )
+level 3:       pushResultStack( 9 )
+level 3:       return( 9 )
+level 2:     evaluateExpression( (* y y) )
+level 3:       evaluateFunc( *, (y y) )
+level 3:       pushResultStack( 16 )
+level 3:       return( 16 )
+level 2:     popResultStack() &rarr; 16
+level 2:     popResultStack() &rarr; 9
+level 2:     pushResultStack( 25 )
+level 2:     return( 25 )
+level 1:   return( 25 )
+
+<b>&rarr; 25</b> 
+</pre></blockquote>
+
+<p>The actual C-language implementation is optimized in some places to avoid pushing the 
+<tt>resultStack</tt> and avoid calling <tt>evaluateExpression(expr)</tt>. Only the most 
+relevant steps are shown. The function <tt>evaluateLambda(func, args)</tt> does not need 
+to evaluate its arguments <tt>3</tt> and <tt>4</tt> because they are constants, but 
+<tt>evaluateLambda(func, args)</tt> will call <tt>evaluateExpression(expr)</tt> twice to 
+evaluate the two body expressions <tt>(+ (* x x)</tt> and <tt>(+ (* x x)</tt>. Lines 
+preceded by the prompt <tt>&gt;</tt> show the command-line entry.</p>
+
+<p><tt>evaluateLambda(func, args)</tt> also saves the environment for the variable symbols 
+<tt>x</tt> and <tt>y</tt>, copies parameters into local variables and restores the old 
+environment upon exit. These actions too involve creation and deletion of memory objects. 
+Details are omitted, because they are similar to methods in other dynamic languages.</p>
+<br/>
+
+<h3>References</h3>
+&ndash; Glenn Krasner, 1983: <i>Smalltalk-80, Bits of History, Words of
+Advice</i><br/>
+Addison Wesley Publishing Company<br/>
+  <br/>
+&ndash; Richard Jones, Rafael Lins, 1996: <i>Garbage Collection, Algorithms
+for Automatic Dynamic Memory Management</i><br/>
+John Wiley &amp; Sons <br/>
+<br/>
+&sup1; <font size="-1">Reference counting and mark-and-sweep algorithms where specifically 
+developed for LISP. Other schemes like copying or generational algorithms where developed 
+for other languages like Smalltalk and later also used in LISP.</font>
+<br/><br/>
+&sup2; <font size="-1">This chapter was added in October 2008 and extended August 2011.</font>
+<br/><br/>
+&sup3; <font size="-1">This is a shortened rendition of expression evaluation 
+not including handling of default functors and implicit indexing.
+For more information on expression evaluation see: <a href="http://www.newlisp.org/ExpressionEvaluation.html">Expression evaluation, Implicit Indexing, Contexts and Default Functors in the newLISP Scripting Language</a>.
+</font>
+<br/><br/>
+<center><font size="-1">Copyright &copy; 2004-2016, Lutz Mueller 
+<a href="http://newlisp.org">http://newlisp.org</a>. All rights reserved. </font></center>
+</blockquote>
+</body>
+</html>
diff --git a/doc/README-OS2 b/doc/README-OS2
new file mode 100644
index 0000000..2c390e3
--- /dev/null
+++ b/doc/README-OS2
@@ -0,0 +1,32 @@
+Build newLISP on OS2
+
+The quickest way to compile the OS2 version is by use of the gcc environment 
+package by Paul Smedley (smedley.info). Install the GCC 335 build and folow 
+the instructions.
+
+If you want a different GCC released by i.e. Paul Smedley then install that 
+beside the gcc 335 release. It is described how to do that. You can of course 
+get gcc itself from ftp.netlabs.org too.
+
+After the "make os2" from within your newlisp-x.x.x release directory you can 
+copy manualy the newlisp.exe to a location, "make install" can be used to but 
+the "guiserver" for OS/2 does not exist as java 1.5 is not ported yet to OS/2. 
+"make uninstall" doesn't therefore work correctly either (this will be changed).
+
+The readline library should be able to compile but is not included currently
+in the makefile_os2 yet (working on it). The latest readline unix port for
+OS/2 must be obtained v5.2.  But give it a try using the configure-alt script,
+and contact Ted if it doesn't work.
+
+There are some differences when using newlisp.exe in an OS/2 enviroment,
+as you are working in a cmd.exe environment or bash. I'll try to define those.
+
+Known issues in newlisp/2:
+
+The newlisp functions 'spawn & 'share don't work, as the OS/2 gcc port doesn't 
+have yet a good alternative for mmap. 'import is under investigation as it 
+behaves strange with gcc 335.
+
+newlisp/2 is tested and built on Ecomstation Rc2.
+The port is done by norman at http://newlisp2.nodep.nl
+
diff --git a/doc/TRU64BUILD b/doc/TRU64BUILD
new file mode 100644
index 0000000..0bd9ef3
--- /dev/null
+++ b/doc/TRU64BUILD
@@ -0,0 +1,10 @@
+Building newLISP for HP's Tru64 OS
+==================================
+
+The following now will make newLISP for the tru64 OS and using the Compaq
+C compiler for the Alpha CPU:
+
+	make
+
+Please contact Peter van Eerten (peter AT gtk-server DOT org) for any 
+remaining questions.
diff --git a/doc/index.cgi b/doc/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/doc/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/doc/manual_frame.html b/doc/manual_frame.html
new file mode 100644
index 0000000..f608b6e
--- /dev/null
+++ b/doc/manual_frame.html
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head> 
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+<meta name="author" content="Lutz Mueller" />
+<meta name="keywords" content="newLISP LISP SCHEME manual reference help artificial intelligence AI NUEVATEC" />
+<meta name="description" content="newLISP Users Manual and Reference" />
+<title>newLISP Manual and Reference</title> 
+</head>
+<frameset cols="175px,*">
+   <frame  name="index" src="newlisp_index.html" noresize="noresize" frameborder="0" />
+   <frame  name="body" src="newlisp_manual.html" noresize="noresize" frameborder="0"/>
+</frameset>
+</html>
diff --git a/doc/newLISP-10.7.0-Release.html b/doc/newLISP-10.7.0-Release.html
new file mode 100644
index 0000000..73f74e0
--- /dev/null
+++ b/doc/newLISP-10.7.0-Release.html
@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<title>newLISP  v.1.7.0 Release Notes </title>
+
+<style type="text/css" media="screen">
+
+h1 {
+	font-family:Optima, Georgia, Times New Roman, Times, serif; 
+	font-size: 200%;
+	font-weight: 500;
+	color: #404040;
+	}
+
+h2, h3 {
+	font-family: Lucida Sans, Helvetica,  sans-serif;
+	color: #404040;
+	line-height: 120%;
+ 	}
+
+body, p {
+	font-family: Lucida Sans, Helvetica,  sans-serif;
+	color: #404040;
+	line-height: 120%;
+	font-size: 110%;
+	max-width: 900px;
+ 	}
+
+tt {
+	font-family: Courier;
+	color: #606060;
+	line-height: 120%;
+	}
+
+em {
+	font-family: Courier;
+	color: #606060;
+	}
+
+li {
+	margin-bottom: 15px;
+    }
+	
+
+</style>
+
+</head>
+
+<body>
+<h1>newLISP<font size=-1>&#174;</font> v.10.7.0 Stable Release
+<font color="red" size="-1">2016-01-21</font></h1>
+
+<p>This stable release adds new functionality to existing functions, 
+adds one new function and fixes bugs.</p>
+
+
+<h3>Additions and changes</h3>
+
+<ul>
+<li>The installation location prefix for OS X, Linux and other Unix like 
+platforms has been changed from <tt>/usr</tt> to <tt>/usr/local</tt> for
+installation in the <tt>/usr/local/</tt> directory. See also the file
+<tt>makefile-original-install</tt> in the main source directory.</li>
+
+<li>On Mac OS X, when starting <tt>guiserver.jar</tt> first, when it is not
+loaded by another newLISP program, <tt>guiserver.jar</tt> expects the newlisp 
+executable in <tt>/usr/local/bin/newlisp</tt>. On other UNIX the newlisp
+executable must be in the executable path of the operating system.</li>
+
+<li>On MS Windows, newLISP can now be compiled as a 64-bit executable. 
+Thanks to <i>Shigeru Kobayashi</i> for doing most of this work.</li>
+
+<li><tt>dolist</tt> now also accepts arrays.</li>
+
+<li>The <tt>net-eval</tt> function now returns the evaluation
+of the last expression passed, not the first. The possibility of
+passing more than one expression in <tt>net-eval</tt>  is not
+documented.</li>
+
+<li>The system variable <tt>ostype</tt> on MS Windows now reports
+the string <tt>"Windows"</tt>. In previous version 1.62 <tt>"Win32"</tt>
+was reported.</li>
+
+<li>The <tt>net-eval</tt> connection timeout has changed to 15 seconds 
+from 60 secconds. The processing timeout while connected can still be set 
+by the user in a <tt>net-eval</tt> parameter.</li>
+
+<li>The environment variable <tt>HTTP_AUTHORIZATION</tt> has been
+added to the variables handled in HTTP server mode.</li>
+
+<li>In <tt>date-value</tt> the date and time numbers can now be 
+given in one list instead of separate number parameters using and 
+additional syntax.</li>
+
+<li>The <tt>date-list</tt> function, when given without a parameter,
+now returns the date list for the current UTC date and time value.</li>
+
+<li>The <tt>trim</tt> function without trim character parameters will 
+now trim all white-space characters, not only spaces.</li> 
+
+<li><tt>dump</tt> now returns the number of cells dumped. Previously
+<tt>true</tt> was returned.</li>
+
+<li>A new <tt>trace</tt> syntax <tt>(trace <em>int-device</em>)</tt> writes
+all expression entries and exit results to the device given. 
+<em>int-device</em> can be the handle of an <tt>open</tt>'ed file or 
+<tt>1</tt> for <em>stdout</em>.</li>
+
+<li>The stack trace in error messages now prints the entire expression
+passed for evaluation, not only the function name.</li>
+
+<li>The <tt>tmp</tt> directory is now defined during newLISP startup. 
+For UNIX this is <tt>/tmp</tt>, for Windows it is taken from the 
+<tt>TMP</tt> environment variable or assumed as <tt>/tmp</tt> when <tt>TMP</tt>
+is not defined.  The directory is used by the built-in function <tt>share</tt> 
+and the built-in HTTPD server.</li>
+
+<li>A new newLISP library call <tt>(newlispLibConsole 1)</tt> forces console 
+output to <em>stdout</em> instead of writing to the return string of 
+<tt>newlispEvalStr</tt>. The same call also enables console input via
+<em>stdin</em>.</li>
+
+<li>In <tt>get/put/post-url</tt> the new string option <tt>"raw"</tt> inhibits 
+'Location' redirection. <tt>"raw"</tt> parameter can also be combined with the 
+<tt>"list"</tt> and <tt>"debug"</tt> options, e.g. <tt>"raw debug"</tt>.</li>
+
+<li>In <tt>get/put/post-url</tt> list mode the second string in the returned list 
+contains only the returned content. The third list member is the server HTTP 
+response line.  The fourth list member contains the status-code, which is 0 for an 
+invalid HTTP response.</li>
+
+<li>The <tt>save</tt> function now saves symbols with strings longer than 2027
+characters appending multiple partial lines delimited by quotes <tt>"..."</tt>.
+This way lines can contain escape characters which are not allowed when using
+<tt>[text]...[/text]</tt> tags as delimiters.</li>
+
+<li>When using a new second <tt>seed</tt> syntax, all randomizing functions are 
+based on a random generator independent of platforms and compilers used to built 
+newLISP. When seeding using the second syntax all random functions called subsequenly 
+like <tt>amb</tt>, <tt>normal</tt>, <tt>rand</tt>, <tt>random</tt> and <tt>randomize</tt>
+are based on this platform independent random generator. After initializing with
+the new <tt>seed</tt> syntax a subsequent call to <tt>seed</tt> without parameters
+returns the current seed state of the random generator, which can be used at a later
+time to seed the generator for the same state in a sequence.</li>
+
+<li>A new <tt>ssq</tt> function returns the Sum of SQquares (SSQ) for a list or array
+vector.</li>
+
+
+</ul>
+
+<h3>Bug fixes</h3>
+
+<ul>
+<li><tt>date-list</tt> crashed for negative values on some MS Windows versions.</li>
+
+<li>The <tt>det</tt> and <tt>mat</tt> functions now give an
+error message when passed the wrong dimensions.</li>
+
+<li>HTTP server mode now works correctly with Apache server, when the environment
+variables NEWLISPDIR and PROGRAMFILES are not defined. Default file paths
+are then assumed for these variables.</li>
+
+<li>HTTP only server mode with command-line switch <tt>-http</tt> did not 
+reject <tt>net-eval</tt> requests.</li>
+
+<li><tt>expand</tt> could crash when evaluating binding lists.</li>
+
+<li>The <tt>json-parse</tt> function now handles 64-bit numbers also in 32-bit 
+versions of newLISP.</li>
+
+<li>Response string from <tt>get- put- post-url</tt> was not zero-terminated for
+HTTP error returns.</li>
+
+<li><tt>date-value</tt> did not evaluate month, day parameters.</li>
+
+<li>PCRE options PCRE_NOTBOL, PCRE_NOTEOL and PCRE_NOTEMPTY did not work.</li>
+
+<li>Loading an empty file now returns <tt>nil</tt> instead of throwing an
+error.</li>
+
+<li>guiserver.jar version 1.65 now correctly forces updates of a <tt>gs:canvas</tt>
+in a <tt>gs:scroll-pane</tt>.
+
+</ul>
+
+
+<h3>Compatibility with previous versions</h3>
+<p>This version is fully compatible with the previous development version 1.64 .</p>
+
+<center>&part;</center>
+
+</body>
+</html>
+
diff --git a/doc/newLISPdoc.html b/doc/newLISPdoc.html
new file mode 100644
index 0000000..59903c6
--- /dev/null
+++ b/doc/newLISPdoc.html
@@ -0,0 +1,334 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<META http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>newLISPdoc</title>
+
+<style type="text/css" media="screen">
+<!--
+span.arw {
+	color:#666666;
+	font-size: 100%;
+	}
+	
+body, h4, p {
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+    max-width: 900px;
+	}
+
+h1, h2, h3 {
+	margin-top: 3%;
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+	color: #404040;
+    }
+
+pre {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+   	font-size: 100%;
+	}
+
+tt {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "C5urier New";
+	font-size: 100%;
+	}
+-->
+</style>
+</head>
+<body style="margin: 20px;" text="#222222" bgcolor="#FFFFFF" 
+			link="#376592" vlink="#551A8B" alink="#ffAA28">
+
+<center>
+<h1>newLISPdoc - the newLISP documentation program</h1>
+<font size="-1">last edited 2015-04-16</font>
+</center>
+
+<p>Comments in newLISP source files can be converted
+to HTML documentation using only a few tags in comments. The newLISPdoc system 
+is designed to use a minimum of tags and leave the tagged comments still readable.</p>
+
+<p>newLISPdoc also generates an index page for all newLISP source files
+generated.</p>
+
+<p>See here for the <a href="http://newlisp.org/syntax.cgi?code/newlispdoc.txt">source of newLISPdoc</a> .
+The program and this documentation are also part of the
+source distribution of newLISP since version 9.0. Since newLISP version 9.1 syntax
+highlighting is built into <tt>newlispdoc</tt> which is installed
+in the same directory as the main newLISP executable program. The script
+<tt>syntax.cgi</tt> is still available for web site installations, but is not
+required anymore for <tt>newlispdoc</tt>.</p>
+
+<h3>Usage</h3>
+<p>From within the directory where the modules are, execute with all module filenames 
+to process on the commandline. For example to process the files <tt>mysql.lsp</tt>, 
+<tt>odbc.lsp</tt> and <tt>sqlite3.lsp</tt> do:</p>
+
+<blockquote><pre>
+newlispdoc mysql.lsp odbc.lsp sqlite.lsp
+</pre></blockquote>
+
+<p>Or on Windows:</p>
+
+<blockquote><pre>
+newlisp newlispdoc mysql.lsp odbc.lsp sqlite.lsp
+</pre></blockquote>
+
+<p>This will generate <tt>index.html</tt>, <tt>mysql.lsp.html</tt>, <tt>odbc.lsp.html</tt>
+and <tt>sqlite.lsp.html</tt> all in the same directory, where the command was executed.
+ The page <tt>index.html</tt> contains links to all other pages.</p>
+
+<p>If the current directory contains the file <tt>newlispdoc.css</tt>, HTML output
+will be formatted accordingly. For a sample file see
+<tt>util/newlispdoc.css</tt> in the source distribution.</p>
+
+<p>The command line flag <tt>-s</tt> can be supplied to additionally
+generate syntax highlighted HTML versions of the source files and put a link
+to the highlighted version of the source file on the documentation page:</p>
+
+<blockquote><pre>
+newlispdoc -s mysql.lsp odbc.lsp sqlite.lsp
+newlispdoc -s *.lsp
+</pre></blockquote>
+
+<p>The <tt>-d</tt> flag supplies a download link to the raw source:</p>
+
+<blockquote><pre>
+newlispdoc -d *.lsp
+newlispdoc -s -d *.lsp
+</pre></blockquote>
+
+<p>One or both options can be supplied.</p>
+
+
+<p>Or on Windows:</p>
+    
+<blockquote><pre>
+newlisp newlispdoc -s mysql.lsp odbc.lsp sqlite.lsp
+</pre></blockquote>
+
+<p>Since version 1.3 of newLISPdoc a file containing URLs of source file locations
+can be specified. This allows indexing and documenting of newLISP source code distributed
+on different sites:</p>
+
+<blockquote><pre>
+newlispdoc -url file-with-urls.txt 
+newlispdoc -s -url file-with-urls.txt 
+</pre></blockquote>
+
+<p>Or on Windows:</p>
+
+<blockquote><pre>
+newlisp newlispdoc -url file-with-urls.txt 
+newlisp newlispdoc -s -url file-with-urls.txt 
+</pre></blockquote>
+
+<p><tt>http://</tt> and <tt>file://</tt> URLs can be used. Like with individual files,
+the <tt>-s</tt> switch can be specified to generate also syntax highlighted source files.
+A URL file contains one URL per line. No other information is allowed in the file. The
+following is a sample URL file:</p>
+
+<blockquote><pre>
+http://asite.com/code/afile.lsp
+http://othersite.org/somefile.lsp
+file:///usr/home/joe/program.lsp
+</pre></blockquote>
+
+<p>The last line shows a file URL from the local filesystem.</p>
+
+<p>All generated files will be written to the current directory.</p>
+
+<h3>Tags</h3>
+
+<p>The following tags start at the beginning of a line with
+2 semicolons and one space before the tag:</p>
+
+<blockquote><pre>
+;; @module one word for module name
+;; @index Title and URL for index page
+;; @description one line description of the module
+;; @location the original URL location of the source file
+;; @version one line version info
+;; @author one line for author info
+;; @syntax one line syntax pattern
+;; @param name description on one line
+;; @return description on one line
+;; @example multiline code example starting on next line
+</pre></blockquote>
+
+<p>The only required tag is either the <tt>@module</tt> tag or alternatively
+the <tt>@index</tt> tag. If neither one tag is present in the file, it will 
+not be processed. All other tags are optional. Only lines starting with ;; 
+(2 semicolons) are processed. Program comment text which should not appear 
+in the documentation should start with only one semicolon.</p>
+
+<p>The one line description of the <tt>@description</tt> tag will be put under the module
+name on the index and module doc page. This and the <tt>@location</tt> where added in
+June 2007, and are not part of the newlispdoc program in the newLISP v. 9.1 release.</p>
+
+<p>A function may have multiple <tt>@syntax</tt> tags each on consecutive lines.</p>
+
+<p>The following is the only tag, which can be embedded anywhere in
+the text. Between the tag link specification and description is exactly one
+space:</p>
+
+<blockquote><pre>
+@link link description
+</pre></blockquote>
+
+<p>Custom tags can be made up by just prepending the custom name with a <tt>@</tt>.
+The text after the custom tag will be translated as usual, e.g. it may contain
+a <tt>@link</tt> tag. Like in most other tags, text is limited to the same line.</p>
+
+<p>All words between <tt>&lt;...&gt;</tt> angle braces are displayed in italic. 
+Internally newLISPdoc uses <tt>&lt;em&gt;,&lt;/em&gt;</tt> tags for formatting. They
+should be used for parameter specs after the @param tag and in text referring
+to those parameters..</p>
+
+<p>All words between single quotes <tt>' ... '</tt> are printed in monospace.
+Internally newLISPdoc uses <tt>&lt;tt&gt;,&lt;/tt&gt;</tt> tags for formatting.</p>
+
+<p>All other lines starting with 2 semicolons contain descriptive
+text. An empty line with only 2 semicolons at the beginning
+is a break between paragraphs of text.</p>
+
+<p>Lines not starting with 2 semicolons are ignored by newLISPdoc. This
+allows doing code comments with just one semicolon.</p>
+
+<p>If more formatting is required than what is offered by newLISPdoc, the
+following simple HTML tags and their closing forms may also be used: 
+<tt>&lt;h1&gt;</tt>,<tt>&lt;h2&gt;</tt>,<tt>&lt;h3&gt;</tt>,<tt>&lt;h4&gt;</tt>,
+<tt>&lt;i&gt;</tt>,<tt>&lt;em&gt;</tt>,<tt>&lt;b&gt;</tt>,<tt>&lt;tt&gt;</tt>,<tt>&lt;p&gt;</tt>,
+<tt>&lt;br&gt;</tt>,<tt>&lt;pre&gt;</tt>,<tt>&lt;center&gt;</tt>,<tt>&lt;blockquote&gt;</tt>
+and <tt>&lt;hr&gt;</tt>.</p>
+<h3>Linking to other module collections</h3>
+<p>newLISPdoc generates and index page for all modules documented. A special tag <tt>@index</tt>
+can be used to show a link on the index page to an index of other module collections. This way 
+multilevel indices of modules can be created. To display a link to another module collection
+ on the index page, create a file containing a <tt>@index</tt> and a <tt>@description</tt> link:</p>
+
+<blockquote><pre>
+; - other-collection.txt -
+;; @index OtherCollection http://example.com/modules
+;; @description Modules from OtherCollection
+</pre></blockquote>
+
+<p>Use one or more of these files on the newLISPdoc command line as any other 
+source file:</p>
+
+<blockquote><pre>
+newlispdoc -s other-collection.txt *.lsp
+</pre></blockquote>
+
+<p>This will show the index entry for OtherCollection on the module index before listing
+all modules in <tt>*.lsp</tt>.</p>
+
+<hr />
+
+<a name="source"></a>
+<h3>Examples</h3>
+
+<p>The following is the commented source of and example program
+followed by the pages generated in HTML:</p>
+
+<blockquote><pre>
+;; @module example.lsp
+;; @author John Doe, johndoe@example.com
+;; @version 1.0
+;; 
+;; This module is an example module for the newlispdoc
+;; program, which generates automatic newLISP module
+;; documentation.
+
+
+;; @syntax (example:foo &lt;num-repeat&gt; &lt;str-message&gt;)
+;; @param &lt;num-repeat&gt; The number of times to repeat.
+;; @param &lt;str-message&gt; The message string to be printed.
+;; @return Returns the message in &lt;str-message&gt;
+;;
+;; The function 'foo' repeatedly prints a string to 
+;; standard out terminated by a line feed.
+;;
+;; @example
+;; (example:foo 5 "hello world")
+;; =&gt;
+;; "hello world"
+;; "hello world"
+;; "hello world"
+;; "hello world"
+;; "hello world"
+
+(context 'example)
+
+(define (foo n msg)
+	(dotimes (i n)
+		(println msg))
+)
+
+;; See the @link http://example.com/example.lsp source .
+</pre></blockquote>
+
+<p>Below the <tt>example.lsp.html</tt> and <tt>index.html</tt>  page generated:</p>
+
+<hr/>
+<a name="example"></a>
+<p><a href="#index">Module index</a></p><h2>Module:&nbsp;example.lsp</h2><b>Author: </b>John Doe, johndoe@example.com<br/>
+<b>Version: </b>1.0<br/>
+
+<p>
+This module is an example module for the newlispdoc
+program, which generates automatic newLISP module
+documentation.
+</p>
+
+
+<p>&nbsp;</p><center>- &sect; -</center><p>&nbsp;</p>
+<a name="example_foo"></a><h3>Syntax: (<font color=#CC0000>example:foo</font> <em>num-repeat</em> <em>str-message</em>)</h3>
+<b>parameter: </b><em>num-repeat</em> - The number of times to repeat.<br/>
+<b>parameter: </b><em>str-message</em> - The message string to be printed.<br/>
+<p><b>return: </b>Returns the message in <em>str-message</em></p>
+<p>&nbsp;</p>
+ The function <tt>foo</tt> repeatedly prints a string to 
+ standard out terminated by a line feed.
+<p>&nbsp;</p>
+<p>&nbsp;</p><b>example:</b><blockquote><pre>
+ (example:foo 5 "hello world")
+ =&gt;
+ "hello world"
+ "hello world"
+ "hello world"
+ "hello world"
+ "hello world"</pre></blockquote>
+ See the <a href="#source">source</a>.
+<p>#nbsp;</p><center>- &part; -</center><br/>
+<center><font face='Arial' size='-2' color='#444444'>
+generated with <a href="http://newlisp.org">newLISP</a>&nbsp;
+and <a href="http://newlisp.org/newLISPdoc.html">newlispdoc</a>
+</font></center>
+
+<hr />
+
+<p>Below the index page <tt>index.html</tt> which was generated. When more than one module is
+specified on the command line, the index page will show one link line for
+each module.</p>
+
+<hr />
+
+<a name="index"></a>
+<center><h2>Index</h2></center>
+<blockquote>
+<h2><a href="#example">Module:&nbsp;example.lsp</a></h2>
+<a href="#example_foo">foo</a>&nbsp; &nbsp; 
+<p>&nbsp;</p><center>- &part; -</center><br/>
+<center><font face='Arial' size='-2' color='#444444'>
+generated with <a href="http://newlisp.org">newLISP</a>&nbsp;
+and <a href="http://newlisp.org/newLISPdoc.html">newlispdoc</a>
+</font></center>
+</blockquote>
+
+<hr />
+
+</body>
+</html>
diff --git a/doc/newlisp-man.txt b/doc/newlisp-man.txt
new file mode 100644
index 0000000..342dc76
--- /dev/null
+++ b/doc/newlisp-man.txt
@@ -0,0 +1,172 @@
+newlisp(1)                  Commandline Parameters                  newlisp(1)
+
+
+
+NAME
+       newlisp - lisp like programming language
+
+SYNOPSIS
+       newlisp  [-n]  [-x  source  target]  [-h  |  -v]  [-c | -C | -http] [-t
+       microseconds] [-s stack] [-m  max-mem-megabyte]  [[-l  path-file  |  -L
+       path-file]   [-p   port-number   |   -d  port-number]]  [-w  directory]
+       [lisp-files ...] [-e programtext]
+
+DESCRIPTION
+       Invokes newLISP which first loads init.lsp if present. Then one or more
+       options  and  one  or  more  newLISP source files can be specified. The
+       options and source files are executed in the sequence they appear.  For
+       some  options is makes sense to have source files loaded first like for
+       the -p and -d options. For other options like -s and -m it  is  logical
+       to  specify  these before the source files to be loaded. If a -e switch
+       is used the programtext is evaluated and then newlisp  exits  otherwise
+       evaluation  continues  interactively  (unless  an  exit  occurs  during
+       lisp-file interpretation).
+
+OPTIONS
+       -n     Suppress loading of any  init.lsp  or  .init.lsp  initialization
+              file.
+
+       -x source target
+              Link  the  newLISP  executable with a source file to built a new
+              target executable.
+
+       -h     Display a short help text.
+
+       -v     Display a version string.
+
+       -c     Suppress the commandline prompt.
+
+       -C     Force prompt when running newLISP in pipe I/O mode for Emacs.
+
+       -http  only accept HTTP commands
+
+       -s stacksize
+              Stack size to use when starting newLISP. When no stack  size  is
+              specified the stack defaults to 1024.
+
+       -m max-mem-megabyte
+              Limits  memory  to max-cell-mem-megabyte megabytes for Lisp cell
+              memory.
+
+       lisp-files
+              Load and evaluate the specified lisp source files  in  sequence.
+              Source  files  can be specified using URLs. If an (exit) is exe-
+              cuted by one of the source files then newlisp exits and all pro-
+              cessing ceases.
+
+       -e programtext
+              Programtext  is  an expression enclosed in quotation marks which
+              is evaluated and the result printed to standard out device (STD-
+              OUT). In most UNIX system shells apostrophes can also be used to
+              delimit the expression. newLISP exits after evaluation  of  pro-
+              gramtext is complete.
+
+       -w directory
+              Directory is the start up directory for newLISP. Any file refer-
+              ence in a program will refer to this directory by default as the
+              current  directory. This can be used to define a web root direc-
+              tory when in server mode.
+
+       -l -L path-file
+              Log  network  connections  and  newLISP  I/O  to  the  file   in
+              path-file.  -l  will only log network connections or commandline
+              input or  net-eval  requests.  -L  will  additionally  log  HTTP
+              requests and newLISP output from commandline and net-eval input.
+
+       -p port-number
+              Listen for commands on a TCP/IP socket connection. In this  case
+              standard  I/O  is  redirected  to  the  port specified in the -p
+              option. Any specified lisp-files will be loaded the first time a
+              connection  is  made,  that is, before text is accepted from the
+              port connection.
+
+       -d port-number
+              Run in demon mode. As for the -p option, but  newLISP  does  not
+              exit after a closed connection and stays in memory listening for
+              a new connection.
+
+       -t microseconds-connection-timeout
+              Specifies a connection timeout when running in -p  or  -d  demon
+              mode. Server will disconnect when no further input is read after
+              accepting a client connection.
+
+       -6     Starts newLISP in IPv6 'Internet Protocol version 6' mode. With-
+              out  this  switch newLISP willl start in IPv4 mode. The protocol
+              mode can also be switched with the built-in  'net-ipv'  function
+              during runtime.
+
+EXAMPLES
+       Start interactive session
+              newlisp
+
+
+       Excute a program
+              newlisp myprog.lsp
+
+
+       Excute a remote program
+              newlisp http://newlisp.org/example.lsp
+
+
+       Add 3 and 4, 7 prints on standard output
+              newlisp -e "(+ 3 4)"
+
+
+       newLISP  is  started  as  a server (the & indicates to LINUX to run the
+       process in the background) and can be connected to with telnet by issu-
+       ing telnet localhost 1234
+              newlisp -p 1234 &
+
+
+       newLISP  is  started as a server for another newlisp process connecting
+       with the net-eval function or HTTP requests. Connection  timeout  is  3
+       seconds.
+              newlisp -c -t 3000000 -d 4711 &
+
+
+       newLISP is started as a server handling HTTP requests only. Connections
+       are logged to the file /usr/home/www/log.txt
+              newlisp -l /usr/home/www/log.txt -http -d 8080 &
+
+
+       newLISP  is started as a server handling HTTP requests and defining the
+       startup/web root directory
+              newlisp -http -d 8080 -w /usr/home/www/httpdocs &
+
+       When  accepting  HTTP  commands  a file httpd.conf can be loaded, which
+       will preprocess the path-name in the HTTP request
+              newlisp httpd.conf -http -d 8080 -w /usr/home/www/httpdocs &
+
+       If the file httpd.conf contains:
+
+       (command-event (fn (s)
+           (local (request)
+               (if (find "?" s) ; is this a query
+                   (begin
+                       (set 'request (first (parse s "?")))
+                       ; discover illegal extension in queries
+                       (if (ends-with request ".exe")
+                           (set 'request "GET /errorpage.html")
+                           (set 'request s)))
+                   (set 'request s))
+               request) ))
+
+       then  all  files  ending  in  .exe  will  translate the request in to a
+       request for  an  error  page,  else  the  original  request  string  is
+       returned.
+
+
+EXIT STATUS
+       newLISP  returns  a  zero  exit status for normal termination unless an
+       exit command specifies a code to be returned. Non zero is  returned  in
+       case of abnormal exit.
+
+AUTHOR
+       Lutz Mueller <lutz@nuevatec.com>
+
+       http://www.newlisp.org/ - the newLISP home page
+
+
+
+version 10.6.0                    April 2014                        newlisp(1)
+
diff --git a/doc/newlisp.1 b/doc/newlisp.1
new file mode 100644
index 0000000..2e0aa41
--- /dev/null
+++ b/doc/newlisp.1
@@ -0,0 +1,125 @@
+.TH newlisp 1 "April 2014" "version 10.6.0" "Commandline Parameters"
+.SH NAME
+newlisp \- lisp like programming language
+.SH SYNOPSIS
+.B newlisp
+[\-n] [\-x source target] [\-h | -v] [\-c | \-C | \-http] [\-t microseconds] [\-s stack] [\-m max\-mem\-megabyte] [[\-l path\-file | \-L path\-file] [\-p port\-number | \-d port\-number]] [\-w directory] [lisp\-files ...] [\-e programtext]
+.SH DESCRIPTION
+Invokes newLISP which first loads init.lsp if present. Then one or more options and one or more newLISP source files can be specified. The options and source files are executed in the sequence they appear. For some options is makes sense to have source files loaded first like for the \-p and \-d options. For other options like \-s and \-m it is logical to specify these before the source files to be loaded. If a \-e switch is used the programtext is evaluated and then newlisp exits otherwise evaluation continues interactively (unless an exit occurs during lisp\-file interpretation).
+.SH OPTIONS
+.TP
+\-n
+Suppress loading of any init.lsp or .init.lsp initialization file.
+.TP
+\-x source target
+Link the newLISP executable with a source file to built a new target executable.
+.TP
+\-h
+Display a short help text.
+.TP
+\-v
+Display a version string.
+.TP
+\-c
+Suppress the commandline prompt.
+.TP
+\-C
+Force prompt when running newLISP in pipe I/O mode for Emacs.
+.TP
+\-http
+only accept HTTP commands
+.TP
+\-s stacksize
+Stack size to use when starting newLISP. When no stack size is specified the stack defaults to 1024.
+.TP
+\-m max\-mem\-megabyte
+Limits memory to max\-cell\-mem\-megabyte megabytes for Lisp cell memory.
+.TP
+lisp\-files
+Load and evaluate the specified lisp source files in sequence. Source files can be specified using URLs. If an (exit) is executed by one of the source files then newlisp exits and all processing ceases.
+.TP
+\-e programtext
+Programtext is an expression enclosed in quotation marks which is evaluated and the result printed to standard out device (STDOUT). In most UNIX system shells apostrophes can also be used to delimit the expression. newLISP exits after evaluation of programtext is complete.
+.TP
+\-w directory
+Directory is the start up directory for newLISP. Any file reference in a program will refer to this directory by default as the current directory. This can be used to define a web root directory when in server mode.
+.TP
+\-l \-L path\-file
+Log network connections and newLISP I/O to the file in path\-file. \-l will only log network connections or commandline input or net\-eval requests. \-L will additionally log HTTP requests and newLISP output from commandline and net\-eval input.
+.TP
+\-p port\-number
+Listen for commands on a TCP/IP socket connection. In this case standard I/O is redirected to the port specified in the \-p option. Any specified lisp\-files will be loaded the first time a connection is made, that is, before text is accepted from the port connection.
+.TP
+\-d port\-number
+Run in demon mode. As for the \-p option, but newLISP does not exit after a closed connection and stays in memory listening for a new connection.
+.TP
+\-t microseconds-connection-timeout
+Specifies a connection timeout when running in \-p or \-d demon mode. Server will disconnect when no further input is read after accepting a client connection.
+.TP
+\-6
+Starts newLISP in IPv6 'Internet Protocol version 6' mode. Without this switch newLISP willl start in IPv4 mode. The protocol mode can also be switched with the built-in 'net-ipv' function during runtime. 
+.SH EXAMPLES
+.TP
+Start interactive session
+.B newlisp
+.PP
+.TP
+Excute a program
+.B newlisp myprog.lsp
+.PP
+.TP
+Excute a remote program
+.B newlisp http://newlisp.org/example.lsp
+.PP
+.TP
+Add 3 and 4, 7 prints on standard output
+.B newlisp
+\-e "(+ 3 4)"
+.PP
+.TP
+newLISP is started as a server (the & indicates to LINUX to run the process in the background) and can be connected to with telnet by issuing telnet localhost 1234
+.B newlisp
+\-p 1234 &
+.PP
+.TP
+newLISP is started as a server for another newlisp process connecting with the net\-eval function or HTTP requests. Connection timeout is 3 seconds.
+.B newlisp
+\-c \-t 3000000 \-d 4711 &
+.PP
+.TP
+newLISP is started as a server handling HTTP requests only. Connections are logged to the file /usr/home/www/log.txt
+.B newlisp
+\-l /usr/home/www/log.txt \-http \-d 8080 &
+.PP
+.TP
+newLISP is started as a server handling HTTP requests and defining the startup/web root directory
+.B newlisp
+\-http \-d 8080 \-w /usr/home/www/httpdocs &
+.TP
+When accepting HTTP commands a file httpd.conf can be loaded, which will preprocess the path\-name in the HTTP request
+.B newlisp
+httpd.conf \-http \-d 8080 \-w /usr/home/www/httpdocs &
+.PP
+If the file httpd.conf contains:
+
+(command-event (fn (s)
+    (local (request)
+        (if (find "?" s) ; is this a query
+            (begin
+                (set 'request (first (parse s "?")))
+                ; discover illegal extension in queries
+                (if (ends-with request ".exe") 
+                    (set 'request "GET /errorpage.html")
+                    (set 'request s)))
+            (set 'request s))
+        request)
+))
+
+then all files ending in .exe will translate the request in to a request for an error page, else the original request string is returned.
+.PP
+.SH EXIT STATUS
+newLISP returns a zero exit status for normal termination unless an exit command specifies a code to be returned. Non zero is returned in case of abnormal exit.
+.SH AUTHOR
+Lutz Mueller <lutz@nuevatec.com>
+
+http://www.newlisp.org/ \- the newLISP home page
diff --git a/doc/newlisp_index.html b/doc/newlisp_index.html
new file mode 100644
index 0000000..1195daf
--- /dev/null
+++ b/doc/newlisp_index.html
@@ -0,0 +1,583 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"/>
+   <meta name="author" content="Lutz Mueller"/>
+   <meta name="keywords" content="newLISP LISP SCHEME manual reference help artificial intelligence AI NUEVATEC"/>
+   <meta name="description" content="newLISP Users Manual and Reference Index"/>
+   <title>newLISP Manual and Reference Index</title>
+
+<style type="text/css" media="screen">
+<!--
+
+body, h1, h4, h4, h4, p {
+   font-family: Lucida Sans, Verdana, Helvetica, sanserif;
+   color: #444444;
+ }
+
+pre, tt {
+   font-family: Lucida Console, Courier;
+}
+
+-->
+</style>
+
+</head>
+<body text="#000000" bgcolor="#FFFFFF" link="#376590" vlink="#551A8B" alink="#ffAA28">
+<h4>Functions in alphabetical order</h4>
+
+<b>
+<a href="newlisp_manual.html#shell" target="body">!</a>&nbsp;
+<a href="newlisp_manual.html#arithmetic" target="body">+-*/%</a>&nbsp;
+<a href="newlisp_manual.html#abort" target="body">Ab</a>&nbsp;
+<a href="newlisp_manual.html#append" target="body">Ap</a>&nbsp;
+<a href="newlisp_manual.html#asin" target="body">As</a>&nbsp;
+<a href="newlisp_manual.html#base64-dec" target="body">Ba</a>&nbsp;
+<a href="newlisp_manual.html#callback" target="body">Ca</a>&nbsp;
+<a href="newlisp_manual.html#clean" target="body">Cl</a>&nbsp;
+<a href="newlisp_manual.html#command-event" target="body">Co</a>&nbsp;
+<a href="newlisp_manual.html#current-line" target="body">Cu</a>&nbsp;
+<a href="newlisp_manual.html#dec" target="body">De</a>&nbsp;
+<a href="newlisp_manual.html#difference" target="body">Di</a>&nbsp;
+<a href="newlisp_manual.html#do-until" target="body">Do</a>&nbsp;
+<a href="newlisp_manual.html#encrypt" target="body">En</a>&nbsp;
+<a href="newlisp_manual.html#exec" target="body">Ex</a>&nbsp;
+<a href="newlisp_manual.html#file-info" target="body">Fi</a>&nbsp;
+<a href="newlisp_manual.html#flat" target="body">Fl</a>&nbsp;
+<a href="newlisp_manual.html#gammaln" target="body">Ga</a>&nbsp;
+<a href="newlisp_manual.html#global" target="body">Gl</a>&nbsp;
+<a href="newlisp_manual.html#inc" target="body">In</a>&nbsp;
+<a href="newlisp_manual.html#lambdap" target="body">La</a>&nbsp;
+<a href="newlisp_manual.html#listp" target="body">Li</a>&nbsp;
+<a href="newlisp_manual.html#macro" target="body">Ma</a>&nbsp;
+<a href="newlisp_manual.html#mul" target="body">Mu</a>&nbsp;
+<a href="newlisp_manual.html#net-accept" target="body">Net</a>&nbsp;
+<a href="newlisp_manual.html#new" target="body">New</a>&nbsp;
+<a href="newlisp_manual.html#nth" target="body">Nt</a>&nbsp;
+<a href="newlisp_manual.html#pack" target="body">Pa</a>&nbsp;
+<a href="newlisp_manual.html#prefix" target="body">Pr</a>&nbsp;
+<a href="newlisp_manual.html#rand" target="body">Ra</a>&nbsp;
+<a href="newlisp_manual.html#read" target="body">Rea</a>&nbsp;
+<a href="newlisp_manual.html#regex" target="body">Reg</a>&nbsp;
+<a href="newlisp_manual.html#search" target="body">Sea</a>&nbsp;
+<a href="newlisp_manual.html#sequence" target="body">Seq</a>&nbsp;
+<a href="newlisp_manual.html#sleep" target="body">Sl</a>&nbsp;
+<a href="newlisp_manual.html#starts-with" target="body">St</a>&nbsp;
+<a href="newlisp_manual.html#sym" target="body">Sy</a>&nbsp;
+<a href="newlisp_manual.html#time" target="body">Ti</a>&nbsp;
+<a href="newlisp_manual.html#trace" target="body">Tr</a>&nbsp;
+<a href="newlisp_manual.html#utf8" target="body">Ut</a>&nbsp;
+<a href="newlisp_manual.html#write" target="body">Wr</a>&nbsp;
+</b>
+
+
+<h4>List processing, flow control and integer arithmetic</h4>
+
+<a href="newlisp_manual.html#arithmetic" target="body">+, -, *, /,%</a><br />
+<a href="newlisp_manual.html#inci" target="body">++</a><br />
+<a href="newlisp_manual.html#deci" target="body">--</a><br />
+<a href="newlisp_manual.html#logical" target="body">&lt;, >, =,</a><br />
+<a href="newlisp_manual.html#logical" target="body">&lt;=, >=, !=</a><br />
+<a href="newlisp_manual.html#colon" target="body">:</a><br />
+<a href="newlisp_manual.html#and" target="body">and</a><br />
+<a href="newlisp_manual.html#append" target="body">append</a><br />
+<a href="newlisp_manual.html#apply" target="body">apply</a><br />
+<a href="newlisp_manual.html#args" target="body">args</a><br />
+<a href="newlisp_manual.html#assoc" target="body">assoc</a><br />
+<a href="newlisp_manual.html#begin" target="body">begin</a><br />
+<a href="newlisp_manual.html#bind" target="body">bind</a><br />
+<a href="newlisp_manual.html#bigint" target="body">bigint</a><br />
+<a href="newlisp_manual.html#case" target="body">case</a><br />
+<a href="newlisp_manual.html#catch" target="body">catch</a><br />
+<a href="newlisp_manual.html#chop" target="body">chop</a><br />
+<a href="newlisp_manual.html#clean" target="body">clean</a><br />
+<a href="newlisp_manual.html#collect" target="body">collect</a><br />
+<a href="newlisp_manual.html#cond" target="body">cond</a><br />
+<a href="newlisp_manual.html#cons" target="body">cons</a><br />
+<a href="newlisp_manual.html#constant" target="body">constant</a><br />
+<a href="newlisp_manual.html#count" target="body">count</a><br />
+<a href="newlisp_manual.html#curry" target="body">curry</a><br />
+<a href="newlisp_manual.html#def-new" target="body">def-new</a><br />
+<a href="newlisp_manual.html#define" target="body">define</a><br />
+<a href="newlisp_manual.html#define-macro" target="body">define-macro</a><br />
+<a href="newlisp_manual.html#difference" target="body">difference</a><br />
+<a href="newlisp_manual.html#do-until" target="body">do-until</a><br />
+<a href="newlisp_manual.html#do-while" target="body">do-while</a><br />
+<a href="newlisp_manual.html#doargs" target="body">doargs</a><br />
+<a href="newlisp_manual.html#dolist" target="body">dolist</a><br />
+<a href="newlisp_manual.html#dostring" target="body">dostring</a><br />
+<a href="newlisp_manual.html#dotimes" target="body">dotimes</a><br />
+<a href="newlisp_manual.html#dotree" target="body">dotree</a><br />
+<a href="newlisp_manual.html#dup" target="body">dup</a><br />
+<a href="newlisp_manual.html#ends-with" target="body">ends-with</a><br />
+<a href="newlisp_manual.html#exists" target="body">exists</a><br />
+<a href="newlisp_manual.html#eval" target="body">eval</a><br />
+<a href="newlisp_manual.html#expand" target="body">expand</a><br />
+<a href="newlisp_manual.html#extend" target="body">extend</a><br />
+<a href="newlisp_manual.html#first" target="body">first</a><br />
+<a href="newlisp_manual.html#filter" target="body">filter</a><br />
+<a href="newlisp_manual.html#find" target="body">find</a><br />
+<a href="newlisp_manual.html#find-all" target="body">find-all</a><br />
+<a href="newlisp_manual.html#flat" target="body">flat</a><br />
+<a href="newlisp_manual.html#fn" target="body">fn</a><br />
+<a href="newlisp_manual.html#for" target="body">for</a><br />
+<a href="newlisp_manual.html#for-all" target="body">for-all</a><br />
+<a href="newlisp_manual.html#if" target="body">if</a><br />
+<!-- <a href="newlisp_manual.html#if-not" target="body">if-not</a><br /> -->
+<a href="newlisp_manual.html#index" target="body">index</a><br />
+<a href="newlisp_manual.html#intersect" target="body">intersect</a><br />
+<a href="newlisp_manual.html#lambda" target="body">lambda</a><br />
+<a href="newlisp_manual.html#lambda-macro" target="body">lambda-macro</a><br />
+<a href="newlisp_manual.html#last" target="body">last</a><br />
+<a href="newlisp_manual.html#length" target="body">length</a><br />
+<a href="newlisp_manual.html#let" target="body">let</a><br />
+<a href="newlisp_manual.html#letex" target="body">letex</a><br />
+<a href="newlisp_manual.html#letn" target="body">letn</a><br />
+<a href="newlisp_manual.html#list" target="body">list</a><br />
+<a href="newlisp_manual.html#local" target="body">local</a><br />
+<a href="newlisp_manual.html#lookup" target="body">lookup</a><br />
+<a href="newlisp_manual.html#map" target="body">map</a><br />
+<a href="newlisp_manual.html#match" target="body">match</a><br />
+<a href="newlisp_manual.html#member" target="body">member</a><br />
+<a href="newlisp_manual.html#not" target="body">not</a><br />
+<a href="newlisp_manual.html#nth" target="body">nth</a><br />
+<a href="newlisp_manual.html#or" target="body">or</a><br />
+<a href="newlisp_manual.html#pop" target="body">pop</a><br />
+<a href="newlisp_manual.html#pop-assoc" target="body">pop-assoc</a><br />
+<a href="newlisp_manual.html#push" target="body">push</a><br />
+<a href="newlisp_manual.html#quote" target="body">quote</a><br />
+<a href="newlisp_manual.html#ref" target="body">ref</a><br />
+<a href="newlisp_manual.html#ref-all" target="body">ref-all</a><br />
+<a href="newlisp_manual.html#rest" target="body">rest</a><br />
+<a href="newlisp_manual.html#replace" target="body">replace</a><br />
+<a href="newlisp_manual.html#reverse" target="body">reverse</a><br />
+<a href="newlisp_manual.html#rotate" target="body">rotate</a><br />
+<a href="newlisp_manual.html#select" target="body">select</a><br />
+<a href="newlisp_manual.html#self" target="body">self</a><br />
+<a href="newlisp_manual.html#set" target="body">set</a><br />
+<a href="newlisp_manual.html#set-ref" target="body">set-ref</a><br />
+<a href="newlisp_manual.html#set-ref-all" target="body">set-ref-all</a><br />
+<a href="newlisp_manual.html#setf" target="body">setf setq</a><br />
+<a href="newlisp_manual.html#silent" target="body">silent</a><br />
+<a href="newlisp_manual.html#slice" target="body">slice</a><br />
+<a href="newlisp_manual.html#sort" target="body">sort</a><br />
+<a href="newlisp_manual.html#starts-with" target="body">starts-with</a><br />
+<a href="newlisp_manual.html#swap" target="body">swap</a><br />
+<a href="newlisp_manual.html#unify" target="body">unify</a><br />
+<a href="newlisp_manual.html#unique" target="body">unique</a><br />
+<a href="newlisp_manual.html#union" target="body">union</a><br />
+<a href="newlisp_manual.html#unless" target="body">unless</a><br />
+<a href="newlisp_manual.html#until" target="body">until</a><br />
+<a href="newlisp_manual.html#when" target="body">when</a><br />
+<a href="newlisp_manual.html#while" target="body">while</a><br />
+
+<h4>String and conversion functions</h4>
+
+<a href="newlisp_manual.html#address" target="body">address</a><br />
+<a href="newlisp_manual.html#append" target="body">append</a><br />
+<a href="newlisp_manual.html#bigint" target="body">bigint</a><br />
+<a href="newlisp_manual.html#bits" target="body">bits</a><br />
+<a href="newlisp_manual.html#char" target="body">char</a><br />
+<a href="newlisp_manual.html#chop" target="body">chop</a><br />
+<a href="newlisp_manual.html#dup" target="body">dup</a><br />
+<a href="newlisp_manual.html#ends-with" target="body">ends-with</a><br />
+<a href="newlisp_manual.html#encrypt" target="body">encrypt</a><br />
+<a href="newlisp_manual.html#eval-string" target="body">eval-string</a><br />
+<a href="newlisp_manual.html#eval-string-js" target="body">eval-string-js</a><br />
+<a href="newlisp_manual.html#explode" target="body">explode</a><br />
+<a href="newlisp_manual.html#extend" target="body">extend</a><br />
+<a href="newlisp_manual.html#find" target="body">find</a><br />
+<a href="newlisp_manual.html#first" target="body">first</a><br />
+<a href="newlisp_manual.html#float" target="body">float</a><br />
+<a href="newlisp_manual.html#format" target="body">format</a><br />
+<a href="newlisp_manual.html#get-char" target="body">get-char</a><br />
+<a href="newlisp_manual.html#get-float" target="body">get-float</a><br />
+<a href="newlisp_manual.html#get-int" target="body">get-int</a><br />
+<a href="newlisp_manual.html#get-long" target="body">get-long</a><br />
+<a href="newlisp_manual.html#get-string" target="body">get-string</a><br />
+<a href="newlisp_manual.html#int" target="body">int</a><br />
+<a href="newlisp_manual.html#join" target="body">join</a><br />
+<a href="newlisp_manual.html#last" target="body">last</a><br />
+<a href="newlisp_manual.html#lower-case" target="body">lower-case</a><br />
+<a href="newlisp_manual.html#member" target="body">member</a><br />
+<a href="newlisp_manual.html#name" target="body">name</a><br />
+<a href="newlisp_manual.html#nth" target="body">nth</a><br />
+<a href="newlisp_manual.html#pack" target="body">pack</a><br />
+<a href="newlisp_manual.html#parse" target="body">parse</a><br />
+<a href="newlisp_manual.html#pop" target="body">pop</a><br />
+<a href="newlisp_manual.html#push" target="body">push</a><br />
+<a href="newlisp_manual.html#regex" target="body">regex</a><br />
+<a href="newlisp_manual.html#regex-comp" target="body">regex-comp</a><br />
+<a href="newlisp_manual.html#replace" target="body">replace</a><br />
+<a href="newlisp_manual.html#rest" target="body">rest</a><br />
+<a href="newlisp_manual.html#reverse" target="body">reverse</a><br />
+<a href="newlisp_manual.html#rotate" target="body">rotate</a><br />
+<a href="newlisp_manual.html#select" target="body">select</a><br />
+<a href="newlisp_manual.html#setf" target="body">setf</a><br />
+<a href="newlisp_manual.html#slice" target="body">slice</a><br />
+<a href="newlisp_manual.html#source" target="body">source</a><br/>
+<a href="newlisp_manual.html#starts-with" target="body">starts-with</a><br />
+<a href="newlisp_manual.html#string" target="body">string</a><br />
+<a href="newlisp_manual.html#sym" target="body">sym</a><br />
+<a href="newlisp_manual.html#title-case" target="body">title-case</a><br />
+<a href="newlisp_manual.html#trim" target="body">trim</a><br />
+<a href="newlisp_manual.html#unicode" target="body">unicode</a><br />
+<a href="newlisp_manual.html#unpack" target="body">unpack</a><br />
+<a href="newlisp_manual.html#upper-case" target="body">upper-case</a><br />
+<a href="newlisp_manual.html#utf8" target="body">utf8</a><br />
+<a href="newlisp_manual.html#utf8len" target="body">utf8len</a><br />
+
+<h4>Floating point math and special functions</h4>
+
+<a href="newlisp_manual.html#abs" target="body">abs</a><br />
+<a href="newlisp_manual.html#acos" target="body">acos</a><br />
+<a href="newlisp_manual.html#acosh" target="body">acosh</a><br />
+<a href="newlisp_manual.html#add" target="body">add</a><br />
+<a href="newlisp_manual.html#array" target="body">array</a><br />
+<a href="newlisp_manual.html#array-list" target="body">array-list</a><br />
+<a href="newlisp_manual.html#asin" target="body">asin</a><br />
+<a href="newlisp_manual.html#asinh" target="body">asinh</a><br />
+<a href="newlisp_manual.html#atan" target="body">atan</a><br />
+<a href="newlisp_manual.html#atanh" target="body">atanh</a><br />
+<a href="newlisp_manual.html#atan2" target="body">atan2</a><br />
+<a href="newlisp_manual.html#beta" target="body">beta</a><br />
+<a href="newlisp_manual.html#betai" target="body">betai</a><br />
+<a href="newlisp_manual.html#binomial" target="body">binomial</a><br />
+<a href="newlisp_manual.html#ceil" target="body">ceil</a><br />
+<a href="newlisp_manual.html#cos" target="body">cos</a><br />
+<a href="newlisp_manual.html#cosh" target="body">cosh</a><br />
+<a href="newlisp_manual.html#crc32" target="body">crc32</a><br />
+<a href="newlisp_manual.html#dec" target="body">dec</a><br />
+<a href="newlisp_manual.html#div" target="body">div</a><br />
+<a href="newlisp_manual.html#erf" target="body">erf</a><br />
+<a href="newlisp_manual.html#exp" target="body">exp</a><br />
+<a href="newlisp_manual.html#factor" target="body">factor</a><br />
+<a href="newlisp_manual.html#fft" target="body">fft</a><br />
+<a href="newlisp_manual.html#floor" target="body">floor</a><br />
+<a href="newlisp_manual.html#flt" target="body">flt</a><br />
+<a href="newlisp_manual.html#gammai" target="body">gammai</a><br />
+<a href="newlisp_manual.html#gammaln" target="body">gammaln</a><br />
+<a href="newlisp_manual.html#gcd" target="body">gcd</a><br />
+<a href="newlisp_manual.html#ifft" target="body">ifft</a><br />
+<a href="newlisp_manual.html#inc" target="body">inc</a><br />
+<a href="newlisp_manual.html#infp" target="body">inf?</a><br />
+<a href="newlisp_manual.html#log" target="body">log</a><br />
+<a href="newlisp_manual.html#min" target="body">min</a><br />
+<a href="newlisp_manual.html#max" target="body">max</a><br />
+<a href="newlisp_manual.html#mod" target="body">mod</a><br />
+<a href="newlisp_manual.html#mul" target="body">mul</a><br />
+<a href="newlisp_manual.html#NaNp" target="body">NaN?</a><br />
+<a href="newlisp_manual.html#pow" target="body">pow</a><br />
+<a href="newlisp_manual.html#round" target="body">round</a><br />
+<a href="newlisp_manual.html#sequence" target="body">sequence</a><br />
+<a href="newlisp_manual.html#series" target="body">series</a><br />
+<a href="newlisp_manual.html#sgn" target="body">sgn</a><br />
+<a href="newlisp_manual.html#sin" target="body">sin</a><br />
+<a href="newlisp_manual.html#sinh" target="body">sinh</a><br />
+<a href="newlisp_manual.html#sqrt" target="body">sqrt</a><br />
+<a href="newlisp_manual.html#sub" target="body">sub</a><br />
+<a href="newlisp_manual.html#tan" target="body">tan</a><br />
+<a href="newlisp_manual.html#tanh" target="body">tanh</a><br />
+
+<h4>Matrix functions</h4>
+
+<a href="newlisp_manual.html#det" target="body">det</a><br />
+<a href="newlisp_manual.html#invert" target="body">invert</a><br />
+<a href="newlisp_manual.html#mat" target="body">mat</a><br />
+<a href="newlisp_manual.html#multiply" target="body">multiply</a><br />
+<a href="newlisp_manual.html#transpose" target="body">transpose</a><br />
+
+<h4>Array functions</h4>
+
+<a href="newlisp_manual.html#append" target="body">append</a><br/>
+<a href="newlisp_manual.html#array" target="body">array</a><br/>
+<a href="newlisp_manual.html#array-list" target="body">array-list</a><br/>
+<a href="newlisp_manual.html#arrayp" target="body">array?</a><br/>
+<a href="newlisp_manual.html#det" target="body">det</a><br/>
+<a href="newlisp_manual.html#first" target="body">first</a><br/>
+<a href="newlisp_manual.html#invert" target="body">invert</a><br/>
+<a href="newlisp_manual.html#last" target="body">last</a><br/>
+<a href="newlisp_manual.html#mat" target="body">mat</a><br />
+<a href="newlisp_manual.html#multiply" target="body">multiply</a><br/>
+<a href="newlisp_manual.html#nth" target="body">nth</a><br/>
+<a href="newlisp_manual.html#rest" target="body">rest</a><br/>
+<a href="newlisp_manual.html#setf" target="body">setf</a><br />
+<a href="newlisp_manual.html#slice" target="body">slice</a><br />
+<a href="newlisp_manual.html#transpose" target="body">transpose</a><br/>
+
+<h4>Bit operators</h4>
+
+<a href="newlisp_manual.html#bit_shift" target="body">&lt;&lt;, >></a><br />
+<a href="newlisp_manual.html#bit_and" target="body">&amp;</a><br />
+<a href="newlisp_manual.html#bit_inclusive" target="body">|</a><br />
+<a href="newlisp_manual.html#bit_exclusive" target="body">^</a><br />
+<a href="newlisp_manual.html#bit_not" target="body">~</a><br />
+
+<h4>Predicates</h4>
+<a href="newlisp_manual.html#arrayp" target="body">array?</a><br />
+<a href="newlisp_manual.html#atomp" target="body">atom?</a><br />
+<a href="newlisp_manual.html#bigintp" target="body">bigint?</a><br />
+<a href="newlisp_manual.html#contextp" target="body">context?</a><br />
+<a href="newlisp_manual.html#directoryp" target="body">directory?</a><br />
+<a href="newlisp_manual.html#emptyp" target="body">empty?</a><br />
+<a href="newlisp_manual.html#evenp" target="body">even?</a><br />
+<a href="newlisp_manual.html#filep" target="body">file?</a><br />
+<a href="newlisp_manual.html#floatp" target="body">float?</a><br />
+<a href="newlisp_manual.html#globalp" target="body">global?</a><br />
+<a href="newlisp_manual.html#infp" target="body">inf?</a><br />
+<a href="newlisp_manual.html#integerp" target="body">integer?</a><br />
+<a href="newlisp_manual.html#lambdap" target="body">lambda?</a><br />
+<a href="newlisp_manual.html#legalp" target="body">legal?</a><br />
+<a href="newlisp_manual.html#listp" target="body">list?</a><br />
+<a href="newlisp_manual.html#macrop" target="body">macro?</a><br />
+<a href="newlisp_manual.html#NaNp" target="body">NaN?</a><br />
+<a href="newlisp_manual.html#nilp" target="body">nil?</a><br />
+<a href="newlisp_manual.html#nullp" target="body">null?</a><br />
+<a href="newlisp_manual.html#oddp" target="body">odd?</a><br />
+<a href="newlisp_manual.html#numberp" target="body">number?</a><br />
+<a href="newlisp_manual.html#primitivep" target="body">primitive?</a><br />
+<a href="newlisp_manual.html#protectedp" target="body">protected?</a><br />
+<a href="newlisp_manual.html#quotep" target="body">quote?</a><br />
+<a href="newlisp_manual.html#stringp" target="body">string?</a><br />
+<a href="newlisp_manual.html#symbolp" target="body">symbol?</a><br />
+<a href="newlisp_manual.html#truep" target="body">true?</a><br />
+<a href="newlisp_manual.html#zerop" target="body">zero?</a><br />
+
+<h4>Date and time functions</h4>
+ 
+<a href="newlisp_manual.html#date" target="body">date</a><br />
+<a href="newlisp_manual.html#date-list" target="body">date-list</a><br />
+<a href="newlisp_manual.html#date-parse" target="body">date-parse</a><br />
+<a href="newlisp_manual.html#date-value" target="body">date-value</a><br />
+<a href="newlisp_manual.html#now" target="body">now</a><br />
+<a href="newlisp_manual.html#time" target="body">time</a><br />
+<a href="newlisp_manual.html#time-of-day" target="body">time-of-day</a><br />
+
+<h4>Statistics, simulation and modelling</h4>
+
+<a href="newlisp_manual.html#amb" target="body">amb</a><br />
+<a href="newlisp_manual.html#bayes-query" target="body">bayes-query</a><br />
+<a href="newlisp_manual.html#bayes-train" target="body">bayes-train</a><br />
+<a href="newlisp_manual.html#corr" target="body">corr</a><br />
+<a href="newlisp_manual.html#crit-chi2" target="body">crit-chi2</a><br />
+<a href="newlisp_manual.html#crit-f" target="body">crit-f</a><br />
+<a href="newlisp_manual.html#crit-t" target="body">crit-t</a><br />
+<a href="newlisp_manual.html#crit-z" target="body">crit-z</a><br />
+<a href="newlisp_manual.html#kmeans-query" target="body">kmeans-query</a><br />
+<a href="newlisp_manual.html#kmeans-train" target="body">kmeans-train</a><br />
+<a href="newlisp_manual.html#normal" target="body">normal</a><br />
+<a href="newlisp_manual.html#prob-chi2" target="body">prob-chi2</a><br />
+<a href="newlisp_manual.html#prob-f" target="body">prob-f</a><br />
+<a href="newlisp_manual.html#prob-t" target="body">prob-t</a><br />
+<a href="newlisp_manual.html#prob-z" target="body">prob-z</a><br />
+<a href="newlisp_manual.html#rand" target="body">rand</a><br />
+<a href="newlisp_manual.html#random" target="body">random</a><br />
+<a href="newlisp_manual.html#randomize" target="body">randomize</a><br />
+<a href="newlisp_manual.html#seed" target="body">seed</a><br />
+<a href="newlisp_manual.html#stats" target="body">stats</a><br />
+<a href="newlisp_manual.html#t-test" target="body">t-test</a><br />
+
+<h4>Pattern recognition</h4>
+
+<a href="newlisp_manual.html#ends-with" target="body">ends-with</a><br />
+<a href="newlisp_manual.html#find" target="body">find</a><br />
+<a href="newlisp_manual.html#find-all" target="body">find-all</a><br />
+<a href="newlisp_manual.html#match" target="body">match</a><br />
+<a href="newlisp_manual.html#parse" target="body">parse</a><br />
+<a href="newlisp_manual.html#ref" target="body">ref</a><br />
+<a href="newlisp_manual.html#ref-all" target="body">ref-all</a><br />
+<a href="newlisp_manual.html#regex" target="body">regex</a><br />
+<a href="newlisp_manual.html#replace" target="body">replace</a><br />
+<a href="newlisp_manual.html#search" target="body">search</a><br />
+<a href="newlisp_manual.html#set-ref" target="body">set-ref</a><br />
+<a href="newlisp_manual.html#set-ref-all" target="body">set-ref-all</a><br />
+<a href="newlisp_manual.html#starts-with" target="body">starts-with</a><br />
+<a href="newlisp_manual.html#unify" target="body">unify</a><br />
+
+<h4>Financial math functions</h4>
+ 
+<a href="newlisp_manual.html#fv" target="body">fv</a><br />
+<a href="newlisp_manual.html#irr" target="body">irr</a><br />
+<a href="newlisp_manual.html#nper" target="body">nper</a><br />
+<a href="newlisp_manual.html#npv" target="body">npv</a><br />
+<a href="newlisp_manual.html#pv" target="body">pv</a><br />
+<a href="newlisp_manual.html#pmt" target="body">pmt</a><br />
+
+<h4>Input/output and file operations</h4>
+
+<a href="newlisp_manual.html#append-file" target="body">append-file</a><br />
+<a href="newlisp_manual.html#close" target="body">close</a><br />
+<a href="newlisp_manual.html#current-line" target="body">current-line</a><br />
+<a href="newlisp_manual.html#device" target="body">device</a><br />
+<a href="newlisp_manual.html#exec" target="body">exec</a><br />
+<a href="newlisp_manual.html#load" target="body">load</a><br />
+<a href="newlisp_manual.html#open" target="body">open</a><br />
+<a href="newlisp_manual.html#peek" target="body">peek</a><br />
+<a href="newlisp_manual.html#print" target="body">print</a><br />
+<a href="newlisp_manual.html#println" target="body">println</a><br />
+<a href="newlisp_manual.html#read-buffer" target="body">read</a><br />
+<a href="newlisp_manual.html#read-char" target="body">read-char</a><br />
+<a href="newlisp_manual.html#read-file" target="body">read-file</a><br />
+<a href="newlisp_manual.html#read-key" target="body">read-key</a><br />
+<a href="newlisp_manual.html#read-line" target="body">read-line</a><br />
+<a href="newlisp_manual.html#read-utf8" target="body">read-utf8</a><br />
+<a href="newlisp_manual.html#save" target="body">save</a><br />
+<a href="newlisp_manual.html#search" target="body">search</a><br />
+<a href="newlisp_manual.html#seek" target="body">seek</a><br />
+<a href="newlisp_manual.html#write" target="body">write</a><br />
+<a href="newlisp_manual.html#write-char" target="body">write-char</a><br />
+<a href="newlisp_manual.html#write-file" target="body">write-file</a><br />
+<a href="newlisp_manual.html#write-line" target="body">write-line</a><br />
+
+<h4>File and directory management</h4>
+
+<a href="newlisp_manual.html#change-dir" target="body">change-dir</a><br />
+<a href="newlisp_manual.html#copy-file" target="body">copy-file</a><br />
+<a href="newlisp_manual.html#delete-file" target="body">delete-file</a><br />
+<a href="newlisp_manual.html#directory" target="body">directory</a><br />
+<a href="newlisp_manual.html#file-info" target="body">file-info</a><br />
+<a href="newlisp_manual.html#make-dir" target="body">make-dir</a><br />
+<a href="newlisp_manual.html#real-path" target="body">real-path</a><br />
+<a href="newlisp_manual.html#remove-dir" target="body">remove-dir</a><br />
+<a href="newlisp_manual.html#rename-file" target="body">rename-file</a><br />
+
+<h4>Processes and the Cilk API</h4>
+
+<a href="newlisp_manual.html#shell" target="body">!</a><br />
+<a href="newlisp_manual.html#abort" target="body">abort</a><br />
+<a href="newlisp_manual.html#destroy" target="body">destroy</a><br />
+<a href="newlisp_manual.html#exec" target="body">exec</a><br />
+<a href="newlisp_manual.html#fork" target="body">fork</a><br />
+<a href="newlisp_manual.html#pipe" target="body">pipe</a><br />
+<a href="newlisp_manual.html#process" target="body">process</a><br />
+<a href="newlisp_manual.html#receive" target="body">receive</a><br />
+<a href="newlisp_manual.html#semaphore" target="body">semaphore</a><br />
+<a href="newlisp_manual.html#send" target="body">send</a><br />
+<a href="newlisp_manual.html#share" target="body">share</a><br />
+<a href="newlisp_manual.html#spawn" target="body">spawn</a><br />
+<a href="newlisp_manual.html#sync" target="body">sync</a><br />
+<a href="newlisp_manual.html#wait-pid" target="body">wait-pid</a><br />
+
+<h4>HTTP network API</h4>
+
+<a href="newlisp_manual.html#base64-enc" target="body">base64-enc</a><br />
+<a href="newlisp_manual.html#base64-dec" target="body">base64-dec</a><br />
+<a href="newlisp_manual.html#delete-url" target="body">delete-url</a><br />
+<a href="newlisp_manual.html#get-url" target="body">get-url</a><br />
+<a href="newlisp_manual.html#json-error" target="body">json-error</a><br />
+<a href="newlisp_manual.html#json-parse" target="body">json-parse</a><br />
+<a href="newlisp_manual.html#put-url" target="body">put-url</a><br />
+<a href="newlisp_manual.html#post-url" target="body">post-url</a><br />
+<a href="newlisp_manual.html#xfer-event" target="body">xfer-event</a><br />
+<a href="newlisp_manual.html#xml-error" target="body">xml-error</a><br />
+<a href="newlisp_manual.html#xml-parse" target="body">xml-parse</a><br />
+<a href="newlisp_manual.html#xml-type-tags" target="body">xml-type-tags</a><br />
+
+<h4>Socket TCP/IP and UDP network API</h4>
+
+<a href="newlisp_manual.html#net-accept" target="body">net-accept</a><br />
+<a href="newlisp_manual.html#net-close" target="body">net-close</a><br />
+<a href="newlisp_manual.html#net-connect" target="body">net-connect</a><br />
+<a href="newlisp_manual.html#net-error" target="body">net-error</a><br />
+<a href="newlisp_manual.html#net-eval" target="body">net-eval</a><br />
+<a href="newlisp_manual.html#net-interface" target="body">net-interface</a><br />
+<a href="newlisp_manual.html#net-ipv" target="body">net-ipv</a><br />
+<a href="newlisp_manual.html#net-listen" target="body">net-listen</a><br />
+<a href="newlisp_manual.html#net-local" target="body">net-local</a><br />
+<a href="newlisp_manual.html#net-lookup" target="body">net-lookup</a><br />
+<a href="newlisp_manual.html#net-packet" target="body">net-packet</a><br />
+<a href="newlisp_manual.html#net-peek" target="body">net-peek</a><br />
+<a href="newlisp_manual.html#net-peek" target="body">net-peek</a><br />
+<a href="newlisp_manual.html#net-ping" target="body">net-ping</a><br />
+<a href="newlisp_manual.html#net-receive" target="body">net-receive</a><br />
+<a href="newlisp_manual.html#net-receive-from" target="body">net-receive-from</a><br />
+<a href="newlisp_manual.html#net-receive-udp" target="body">net-receive-udp</a><br />
+<a href="newlisp_manual.html#net-select" target="body">net-select</a><br />
+<a href="newlisp_manual.html#net-send" target="body">net-send</a><br />
+<a href="newlisp_manual.html#net-send-to" target="body">net-send-to</a><br />
+<a href="newlisp_manual.html#net-send-udp" target="body">net-send-udp</a><br />
+<a href="newlisp_manual.html#net-service" target="body">net-service</a><br />
+<a href="newlisp_manual.html#net-sessions" target="body">net-sessions</a><br />
+
+<h4>API for newLISP in a web browser</h4>
+
+<a href="newlisp_manual.html#display-html" target="body">display-html</a><br />
+<a href="newlisp_manual.html#eval-string-js" target="body">eval-string-js</a><br />
+
+<h4>Reflection and customization</h4>
+
+<a href="newlisp_manual.html#command-event" target="body">command-event</a><br />
+<a href="newlisp_manual.html#error-event" target="body">error-event</a><br />
+<a href="newlisp_manual.html#last-error" target="body">last-error</a><br />
+<a href="newlisp_manual.html#macro" target="body">macro</a><br />
+<a href="newlisp_manual.html#ostype" target="body">ostype</a><br />
+<a href="newlisp_manual.html#prefix" target="body">prefix</a><br />
+<a href="newlisp_manual.html#prompt-event" target="body">prompt-event</a><br />
+<a href="newlisp_manual.html#read-expr" target="body">read-expr</a><br />
+<a href="newlisp_manual.html#reader-event" target="body">reader-event</a><br />
+<a href="newlisp_manual.html#set-locale" target="body">set-locale</a><br />
+<a href="newlisp_manual.html#source" target="body">source</a><br/>
+<a href="newlisp_manual.html#sys-error" target="body">sys-error</a><br />
+<a href="newlisp_manual.html#sys-info" target="body">sys-info</a><br />
+<a href="newlisp_manual.html#term" target="body">term</a><br />
+
+<h4>System functions</h4>
+
+<a href="newlisp_manual.html#systemsymbol" target="body">$</a><br />
+<a href="newlisp_manual.html#callback" target="body">callback</a><br />
+<a href="newlisp_manual.html#catch" target="body">catch</a><br />
+<a href="newlisp_manual.html#context" target="body">context</a><br />
+<a href="newlisp_manual.html#copy" target="body">copy</a><br />
+<a href="newlisp_manual.html#debug" target="body">debug</a><br />
+<a href="newlisp_manual.html#default" target="body">default</a><br />
+<a href="newlisp_manual.html#delete" target="body">delete</a><br />
+<a href="newlisp_manual.html#env" target="body">env</a><br />
+<a href="newlisp_manual.html#exit" target="body">exit</a><br />
+<a href="newlisp_manual.html#global" target="body">global</a><br />
+<a href="newlisp_manual.html#import" target="body">import</a><br />
+<a href="newlisp_manual.html#main-args" target="body">main-args</a><br />
+<a href="newlisp_manual.html#new" target="body">new</a><br />
+<a href="newlisp_manual.html#pretty-print" target="body">pretty-print</a><br />
+<a href="newlisp_manual.html#read-expr" target="body">read-expr</a><br />
+<a href="newlisp_manual.html#reset" target="body">reset</a><br />
+<a href="newlisp_manual.html#signal" target="body">signal</a><br />
+<a href="newlisp_manual.html#sleep" target="body">sleep</a><br />
+<a href="newlisp_manual.html#struct" target="body">struct</a><br />
+<a href="newlisp_manual.html#sym" target="body">sym</a><br />
+<a href="newlisp_manual.html#symbols" target="body">symbols</a><br />
+<a href="newlisp_manual.html#timer" target="body">timer</a><br />
+<a href="newlisp_manual.html#throw" target="body">throw</a><br />
+<a href="newlisp_manual.html#throw-error" target="body">throw-error</a><br />
+<a href="newlisp_manual.html#trace" target="body">trace</a><br />
+<a href="newlisp_manual.html#trace-highlight" target="body">trace-highlight</a><br />
+
+<h4>Importing libraries</h4>
+
+<a href="newlisp_manual.html#address" target="body">address</a><br />
+<a href="newlisp_manual.html#callback" target="body">callback</a><br />
+<a href="newlisp_manual.html#flt" target="body">flt</a><br />
+<a href="newlisp_manual.html#float" target="body">float</a><br />
+<a href="newlisp_manual.html#get-char" target="body">get-char</a><br />
+<a href="newlisp_manual.html#get-float" target="body">get-float</a><br />
+<a href="newlisp_manual.html#get-int" target="body">get-int</a><br />
+<a href="newlisp_manual.html#get-long" target="body">get-long</a><br />
+<a href="newlisp_manual.html#get-string" target="body">get-string</a><br />
+<a href="newlisp_manual.html#import" target="body">import</a><br />
+<a href="newlisp_manual.html#int" target="body">int</a><br />
+<a href="newlisp_manual.html#pack" target="body">pack</a><br />
+<a href="newlisp_manual.html#struct" target="body">struct</a><br />
+<a href="newlisp_manual.html#unpack" target="body">unpack</a><br />
+
+<h4>newLISP internals API</h4>
+
+<a href="newlisp_manual.html#command-event" target="body">command-event</a><br />
+<a href="newlisp_manual.html#cpymem" target="body">cpymem</a><br />
+<a href="newlisp_manual.html#dump" target="body">dump</a><br />
+<a href="newlisp_manual.html#prompt-event" target="body">prompt-event</a><br />
+<a href="newlisp_manual.html#read-expr" target="body">read-expr</a><br />
+<a href="newlisp_manual.html#reader-event" target="body">reader-event</a><br />
+
+</body>
+</html>
diff --git a/doc/newlisp_manual.html b/doc/newlisp_manual.html
new file mode 100644
index 0000000..7485672
--- /dev/null
+++ b/doc/newlisp_manual.html
@@ -0,0 +1,30353 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+   <meta name="author" content="Lutz Mueller"/>
+   <meta name="keywords" content="newLISP Lisp SCHEME programming language 
+   manual reference Artificial Intelligence AI NUEVATEC"/>
+   <meta name="description" content="newLISP User Manual and Reference"/>
+   <title>newLISP v.10.7.0 Manual and Reference</title>
+
+<style type="text/css" media="screen">
+
+.divider {
+	margin-top: 2em; 
+	margin-bottom: 1em;
+	font-family: Times New Roman, Times, serif;
+	color: #ffAA28;
+	}
+
+.title {
+	font-family:Optima, Georgia, Times New Roman, Times, serif; 
+	font-size: 500%;
+	color: #404040;
+	}
+
+span.arw {
+	color:#303030;
+	font-size: 100%;
+	font-weight: bold;
+	}
+	
+span.err {
+	color:#cc0000;
+	}
+
+span.function {
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+	color:#dd0000;
+	}
+
+span.gnu {
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+	color:#dd0000;
+	}
+
+h4	{
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+    color: #404040;
+	}
+
+b	{
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+    color: #606060;
+	font-weight: 600;
+	}
+
+
+body, h1, h2, h3 {
+	font-family: Helvetica, sans-serif;
+	color: #404040;
+	line-height: 120%;
+ 	}
+
+h1, h2, h3 {
+	font-family: Helvetica,  sans-serif;
+	color: #101010;
+	line-height: 120%;
+    font-weight: 100;
+ 	}
+
+p {
+	font-family: Helvetica Neue, Verdana, Lucida Sans, sans-serif;
+	color: #404040;
+	line-height: 120%;
+ 	}
+
+table {
+	margin: 0px;
+	margin-left: 10px;
+	border-style: solid;
+	border-color: #888888;
+	border-width: 0px;
+	padding: 0px;
+	background: #f8ffff;
+	font-size: 95%;
+    }
+    
+th {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #eeeeee;
+    font-size: 100%;
+    }
+    
+td {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+    font-size: 100%;
+    }
+    
+
+pre {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: dashed;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 4px;
+    font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+    font-size: 90%;
+	background: #f8ffff;
+    }
+
+
+tt {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+	font-size: 100%;
+	}
+
+.license {
+	margin: 30px;
+	}
+	
+</style>
+
+</head>
+<body text="#000000" bgcolor="#FFFFFF" link="#376590" vlink="#551A8B" alink="#ffAA28">
+
+<br/><br/><br/><br/><br/><br/><br/><br/><br/>
+
+
+<center>
+<span class="title">newLISP<font size='3'>&#174;</font></span>
+</center>
+
+<br/>
+
+<center>
+<b>For Mac OS X, GNU Linux, Unix and Windows</b>
+</center>
+
+<center>
+<h2>User Manual and Reference v.10.7.0</h2>
+</center>
+
+<br/><br/><br/><br/>
+<center>
+<span style="line-height:80%;">
+<font size='1'>
+<br/>Copyright &copy; 2016 Lutz Mueller&nbsp;<a href="http://www.nuevatec.com">www.nuevatec.com</a>. 
+All rights reserved.<br/><br/>
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License,<br/> Version 1.2 or any later version 
+published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts,<br/> 
+and no Back-Cover Texts. A copy of the license is included in the section entitled 
+<a href="#GNUFDL">GNU Free Documentation License</a>.<br/>
+The accompanying software is protected by the 
+<a href="#GNUGPL">GNU General Public License</a> V.3, June 2007.<br/>
+newLISP is a registered trademark of Lutz Mueller.
+
+</font>
+</span>
+</center>
+<br/><br/><br/>
+
+<center><h1>Contents</h1></center>
+
+<h3><a href="#users_manual">User Manual</a></h3>
+
+<ol>
+<li><a href="#introduction">Introduction</a></li>
+<li><a href="#deprecated">Deprecated functions and future changes</a></li>
+<li><a href="#REPL">Interactive Lisp mode</a></li>
+<li><a href="#options">Command line options</a>
+  <ul>
+  <li><a href="#cmd_help">Command line help summary</a></li>
+  <li><a href="#url_files">Specifying files as URLs</a></li>
+  <li><a href="#no_init">No loading of init.lsp</a></li>
+  <li><a href="#stack_size">Stack size</a></li>
+  <li><a href="#max_mem">Maximum memory usage</a></li>
+  <li><a href="#direct_exec">Direct execution mode</a></li>
+  <li><a href="#logging">Logging I/O</a></li>
+  <li><a href="#working_dir">Specifying the working directory</a></li>
+  <li><a href="#tcpip_server">newLISP as a TCP/IP server</a></li>
+  <li><a href="#daemon">TCP/IP daemon mode</a></li>
+  <li><a href="#prompt">Suppressing the prompt and HTTP processing</a></li>
+  <li><a href="#forcing_prompt">Forcing prompts in pipe I/O mode</a></li>
+  <li><a href="#http_mode">HTTP only server mode</a></li>
+  <li><a href="#local_domain_server">Local domain Unix socket server</a></li>
+  <li><a href="#conn_timeout">Connection timeout</a></li>
+  <li><a href="#inetd_daemon"><tt>inetd</tt> daemon mode</a></li>
+  <li><a href="#link">Linking a source file with newLISP for a new executable</a></li>
+  </ul>
+</li>
+
+<li><a href="#startup">Startup, directories, environment</a>
+  <ul>
+  <li><a href="#environment">Environment variable NEWLISPDIR</a></li>
+  <li><a href="#initialization">The initialization file <tt>init.lsp</tt></a></li>
+  <li><a href="#directories_unix">Directories on Linux, BSD, Mac OS X</a></li>
+  <li><a href="#directories_win">Directories on MS Windows</a></li>
+  </ul>
+</li>
+
+<li><a href="#shared-lib">Extending newLISP with shared libraries</a></li>
+<li><a href="#newlisp-lib">newLISP as a shared library</a></li>
+  <ul>
+  <li><a href="#newlisp-lib">newLISP as a C library</a></li>
+  <li><a href="#newlisp-js-lib">newLISP as a JavaScript library</a></li>
+  </ul>
+<li><a href="#expressions">Evaluating newLISP expressions</a>
+  <ul>
+  <li><a href="#multiline">Interactive multiline expressions</a></li>
+  <li><a href="#int_float">Integer, floating point data and operators</a></li>
+  <li><a href="#big_int">Big integer, unlimited precision arithmetic</a></li>
+  <li><a href="#eval_rules">Evaluation rules and data types</a></li>
+  </ul>
+</li>
+
+<li><a href="#lambda_expressions">Lambda expressions in newLISP</a></li>
+<li><a href="#nil_and_true"><tt>nil</tt>, <tt>true</tt>, <tt>cons</tt> and <tt>()</tt> in newLISP</a></li>
+<li><a href="#arrays">Arrays</a></li>
+<li><a href="#indexing">Indexing elements of strings, lists and arrays</a>
+  <ul>
+  <li><a href="#implicit_indexing">Implicit indexing for <tt>nth</tt></a></li>
+  <li><a href="#implicit_default">Implicit indexing and the default functor</a></li>
+  <li><a href="#implicit_rest_slice">Implicit indexing for <tt>rest</tt> and <tt>slice</tt></a></li>
+  <li><a href="#implicit_modify">Modify references in lists, arrays and strings</a></li>
+  </ul>
+</li>  
+
+<li><a href="#destructive">Destructive versus non-destructive functions</a>
+<ul>
+	<li><a href="#make_nondestructive">Make a destructive function non-destructive</a></li>
+</ul>
+</li>
+
+<li><a href="#return">Early return from functions, loops, blocks</a>
+  <ul>
+  <li><a href="#flow_catch_throw">Using <tt>catch</tt> and <tt>throw</tt></a></li>
+  <li><a href="#flow_and_or">Using <tt>and</tt> and <tt>or</tt></a></li>
+  </ul>
+</li>
+
+<li><a href="#scoping">Dynamic and lexical scoping</a></li>
+
+<li><a href="#contexts">Contexts</a>
+  <ul>
+  <li><a href="#context_rules">Symbol creation in contexts</a></li>
+  <li><a href="#creating_contexts">Creating contexts</a></li>
+  <li><a href="#scope_global">Global scope</a></li>
+  <li><a href="#protection">Symbol protection</a></li>
+  <li><a href="#overwrite">Overwriting global symbols and built-ins</a></li>
+  <li><a href="#context_vars">Variables holding contexts</a></li>
+  <li><a href="#sequence_creating">Sequence of creating contexts</a></li>
+  <li><a href="#context_modules">Contexts as programming modules</a></li>
+  <li><a href="#context_data">Contexts as data containers</a></li>
+  <li><a href="#loading_contexts">Loading and declaring contexts</a></li>
+  <li><a href="#serializing">Serializing context objects</a></li>
+  </ul>
+</li>
+
+<li><a href="#default_function">The context default functor</a>
+  <ul>
+  <li><a href="#func_memory">Functions with memory</a></li>
+  <li><a href="#hash">Hash functions and dictionaries</a></li>
+  <li><a href="#pass_big">Passing data by reference</a></li>
+  </ul>
+</li>
+
+<li><a href="#foop">Functional object-oriented programming</a>
+  <ul>
+  <li><a href="#newlisp_classes">FOOP classes and constructors</a></li>
+  <li><a href="#newlisp_objects">Objects</a></li>
+  <li><a href="#colon_operator">The colon <tt>:</tt> operator and polymorphism</a></li>
+  <li><a href="#structure_foop">Structuring a larger FOOP program</a></li>
+  </ul>
+</li>
+
+<li><a href="#multi_processing">Concurrent processing and distributed computing</a>
+	<ul>
+	<li><a href="#cilk">The Cilk API</a></li>
+	<li><a href="#distributed">Distributed network computing</a></li>
+	</ul>
+</li>
+
+<li><a href="#JSON_XML">JSON, XML, SXML and XML-RPC</a></li>
+<li><a href="#internationalization">Customization, localization and UTF-8</a>
+  <ul>
+  <li><a href="#naming">Customizing function names</a></li>
+  <li><a href="#switching">Switching the locale</a></li>
+  <li><a href="#decimal_point">Decimal point and decimal comma</a></li>
+  <li><a href="#unicode_utf8">Unicode and UTF-8 encoding</a></li>
+  <li><a href="#utf8_capable">Functions working on UTF-8 characters</a></li>
+  <li><a href="#utf8_version">Functions only available on UTF-8 enabled versions</a></li>
+  </ul>
+</li>
+
+<li><a href="#commas">Commas in parameter lists</a></li>
+</ol>
+
+<h3><a href="#function_ref">Function Reference</a></h3>
+<ol>
+<li><a href="#symbol_names">Syntax of symbol variables and numbers</a></li>
+<li><a href="#type_ids">Data types and names in the reference</a></li>
+<li><a href="#functions">Functions in groups</a>
+  <ul>
+  <li><a href="#list_processing">List processing, flow control, and integer arithmetic</a></li>
+  <li><a href="#string_operators">String and conversion functions</a></li>
+  <li><a href="#floating_point">Floating point math and special functions</a></li>
+  <li><a href="#matrices">Matrix functions</a></li>
+  <li><a href="#array-funcs">Array functions</a></li>
+  <li><a href="#bit_operators">Bit operators</a></li>
+  <li><a href="#predicates">Predicates</a></li>
+  <li><a href="#timedate">Date and time functions</a></li>
+  <li><a href="#montecarlo">Statistics, simulation and modeling functions</a></li>
+  <li><a href="#pattern">Pattern matching</a></li>
+  <li><a href="#financial">Financial math functions</a></li>
+  <li><a href="#input_output">File and I/O operations</a></li>
+  <li><a href="#processes">Processes and the Cilk API</a></li>
+  <li><a href="#directory_management">File and directory management</a></li>
+  <li><a href="#http_api">HTTP networking API</a></li>
+  <li><a href="#socket_tcpip">Socket TCP/IP, UDP and ICMP network API</a></li>
+  <li><a href="#JS">API for newLISP in a web browser</a></li>
+  <li><a href="#reflection">Reflection and customization</a></li>
+  <li><a href="#system_functions">System functions</a></li>
+  <li><a href="#importing_libraries">Importing libraries</a></li>
+  <li><a href="#internals">newLISP internals API</a></li>
+  </ul>
+</li>
+
+<li><a href="#functions_alphabetical">Functions in alphabetical order</a>
+<p>
+<b>
+<a href="newlisp_manual.html#shell">!</a>&nbsp;
+<a href="newlisp_manual.html#arithmetic">+-*/%</a>&nbsp;
+<a href="newlisp_manual.html#abort">Ab</a>&nbsp;
+<a href="newlisp_manual.html#append">Ap</a>&nbsp;
+<a href="newlisp_manual.html#asin">As</a>&nbsp;
+<a href="newlisp_manual.html#base64-dec">Ba</a>&nbsp;
+<a href="newlisp_manual.html#callback">Ca</a>&nbsp;
+<a href="newlisp_manual.html#clean">Cl</a>&nbsp;
+<a href="newlisp_manual.html#command-event">Co</a>&nbsp;
+<a href="newlisp_manual.html#current-line">Cu</a>&nbsp;
+<a href="newlisp_manual.html#dec">De</a>&nbsp;
+<a href="newlisp_manual.html#difference">Di</a>&nbsp;
+<a href="newlisp_manual.html#do-until">Do</a>&nbsp;
+<a href="newlisp_manual.html#encrypt">En</a>&nbsp;
+<br/>
+<a href="newlisp_manual.html#exec">Ex</a>&nbsp;
+<a href="newlisp_manual.html#file-info">Fi</a>&nbsp;
+<a href="newlisp_manual.html#flat">Fl</a>&nbsp;
+<a href="newlisp_manual.html#gammaln">Ga</a>&nbsp;
+<a href="newlisp_manual.html#global">Gl</a>&nbsp;
+<a href="newlisp_manual.html#inc">In</a>&nbsp;
+<a href="newlisp_manual.html#lambdap">La</a>&nbsp;
+<a href="newlisp_manual.html#listp">Li</a>&nbsp;
+<a href="newlisp_manual.html#macrop">Ma</a>&nbsp;
+<a href="newlisp_manual.html#mul">Mu</a>&nbsp;
+<a href="newlisp_manual.html#net-accept">Net</a>&nbsp;
+<a href="newlisp_manual.html#new">New</a>&nbsp;
+<a href="newlisp_manual.html#nth">Nt</a>&nbsp;
+<a href="newlisp_manual.html#pack">Pa</a>&nbsp;
+<br/>
+<a href="newlisp_manual.html#pretty-print">Pr</a>&nbsp;
+<a href="newlisp_manual.html#randomize">Ra</a>&nbsp;
+<a href="newlisp_manual.html#read">Rea</a>&nbsp;
+<a href="newlisp_manual.html#regex">Reg</a>&nbsp;
+<a href="newlisp_manual.html#search">Sea</a>&nbsp;
+<a href="newlisp_manual.html#sequence">Seq</a>&nbsp;
+<a href="newlisp_manual.html#sleep">Sl</a>&nbsp;
+<a href="newlisp_manual.html#starts-with">St</a>&nbsp;
+<a href="newlisp_manual.html#sync">Sy</a>&nbsp;
+<a href="newlisp_manual.html#time-of-day">Ti</a>&nbsp;
+<a href="newlisp_manual.html#truep">Tr</a>&nbsp;
+<a href="newlisp_manual.html#utf8">Ut</a>&nbsp;
+<a href="newlisp_manual.html#write-file">Wr</a>&nbsp;
+</b>
+</p>
+</li>  
+</ol>
+
+<h3><a href="#appendix">Appendix</a></h3>
+
+<ul>
+<li><a href="#error_codes">Error Codes</a></li>
+<li><a href="#system_symbols">System Symbols</a></li>
+<li><a href="#GNUFDL">GNU Free Documentation License</a></li>
+<li><a href="#GNUGPL">GNU General Public License</a></li>
+</ul>
+
+<br/>
+<a name="introduction"></a>
+
+<center style="font-size: 150%">
+<span class="divider">(&nbsp;<font color="#7ba9d4">&part;</font>&nbsp;)</span>
+</center>
+
+<br/><br/>
+
+<a name="users_manual"></a>
+<center><h1>newLISP User Manual</h1></center>
+
+
+<h2>1. Introduction</h2>
+
+<p>
+newLISP focuses on the core components of Lisp: <em>lists</em>, <em>symbols</em>, 
+and <em>lambda expressions</em>. To these, newLISP adds <em>arrays</em>,
+<em>implicit indexing</em> on lists and arrays, and <em>dynamic</em> and 
+<em>lexical scoping</em>. Lexical scoping is implemented using separate namespaces 
+called <em>contexts</em>.</p>
+
+<p>The result is an easier-to-learn Lisp that is even smaller than most Scheme 
+implementations, but which still has about 350 built-in functions.
+Not much over 200k in size on BSD systems, newLISP is built for high portability
+using only the most common Unix system C-libraries. It loads quickly and has 
+a small memory footprint. newLISP is as fast or faster than other popular 
+scripting languages and uses very few resources.</p>
+
+<p>Both built-in and user-defined functions, along with variables, share the 
+same global symbol tree and are manipulated by the same functions. Lambda expressions 
+and user-defined functions can be handled like any other list expression.</p>
+
+<p>newLISP is dynamically scoped inside lexically separated contexts (namespaces). 
+Contexts in newLISP are used for multiple purposes. They allow (1) partitioning of 
+programs into modules, (2) the definition of <em>Classes</em> in FOOP 
+(Functional Object Oriented Programming), (3) the definition of functions with 
+state and (4) the creation of Hash trees for associative key &rarr; value storage.</p>
+
+<p>newLISP's efficient <em>red-black</em> tree implementation can handle millions 
+of symbols in namespaces or hashes without degrading performance.</p>
+
+<p>newLISP allocates and reclaims memory automatically, without using traditional 
+asynchronous garbage collection.
+All objects &mdash; except for contexts, built-in primitives, and symbols &mdash;
+are passed by value and are referenced only once. Upon creation objects are scheduled
+for delayed deletion and Lisp cells are recycled for newly created objects.
+This results in predictable processing times without the pauses found in traditional 
+garbage collection. newLISP's unique automatic memory management makes it the fastest 
+interactive Lisp available. More than any other Lisp, it implements the 
+<em>data equals program</em> paradigm and full self reflection.</p>
+
+<p>Many of newLISP's built-in functions are polymorphic and accept a variety 
+of data types and optional parameters. This greatly reduces the number of 
+functions and syntactic forms necessary to learn and implement.
+High-level functions are available for string and list processing, financial math, 
+statistics, and Artificial Intelligence applications.</p>
+
+<p>newLISP has functions to modify, insert, or delete elements inside 
+complex <em>nested</em> lists or <em>multi-dimensional</em> array structures.</p>
+
+<p>Because strings can contain null characters in newLISP, they can be used to 
+process binary data with most string manipulating functions.</p>
+
+<p>newLISP can also be extended with a shared library interface
+to import functions that access data in foreign binary data structures.
+The distribution contains modules for importing popular C-library APIs.</p>
+
+<p>newLISP's HTTP, TCP/IP, and UDP socket interfaces make it easy to write 
+distributed networked applications. Its built-in XML interface, along with 
+its text-processing features &mdash; Perl Compatible Regular Expressions (PCRE) 
+and text-parsing functions &mdash; make newLISP a useful tool for CGI processing.
+The source distribution includes examples of HTML forms processing.
+newLISP can be run a as a CGI capable web server using its built-in http mode option.</p>
+
+<p>newLISP has built-in support for distributed processing on networks and parallel,
+concurrent processing on the same CPU with one or more processing cores.</p>
+
+<p>The source distribution can be compiled for Linux, Mac OS X/Darwin, BSDs, many 
+other Unix flavors and MS Windows. newLISP can be compiled as a 64-bit LP64 application 
+for full 64-bit memory addressing.</p>
+
+<p>Since version 10.5.7, newLISP also can be compiled to JavaScript and run in
+a <a href="http://www.newlisp.org/newlisp-js/">web browser</a>.</p>
+
+<br/>
+
+<h3>newLISP-GS</h3>
+
+<p>newLISP-GS comprises a graphical user interface (GUI) and library server. The 
+GUI front-end is written in newLISP, whereas the library server is Java based 
+and uses the standard Java runtime environment installed on all Windows and 
+Mac OS X platforms. Applications built with newLISP-GS can have the host operating 
+system's native look and feel. Interfaces to GTK, Tcl/Tk and OpenGL graphics 
+libraries are also available.</p>
+
+<p>newLISP and Java are available for most operating systems. This makes 
+newLISP-GS a platform-independent solution for writing GUI applications.</p>
+
+<p>For more information on newLISP-GS, see 
+<a href="http://newlisp.org/guiserver">newLISP-GS</a>.</p>
+
+<br/>
+
+<h3>Licensing</h3>
+
+<p>newLISP and newLISP-GS are licensed under version 3
+of the <a href="#GNUGPL">GPL (General Public License)</a>.
+The newLISP documentation as well as other documentation packaged with newLISP 
+are licensed under the <a href="#GNUFDL">GNU Free Documentation License</a>. </p>
+
+<br/>
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+
+<a name="deprecated"></a>
+<h2>2. Deprecated functions and future changes</h2>
+
+<p>Since version 10.3.0 newLISP can switch between IPv4 and IPv6 modes during
+run-time using the new <a href="#net-ipv">net-ipv</a> function. The 
+<tt>-6</tt> commandline option can be used to start newLISP in IPv6 mode. 
+After transition to IPv6 the <tt>-6</tt>
+commandline switch will be changed to <tt>-4</tt> for starting up in IPv4
+mode.</p>
+
+<p>The old writing <tt>parse-date</tt> of <a href="#date-parse">date-parse</a>
+is still recognized but deprecated since version 10.3.0. The old writing will 
+be removed in a future version.</p>
+
+<p>Since version 10.4.2 <tt>if-not</tt> is deprecated and will be removed in a
+future version.</p>
+
+<p>Since version 10.4.6 newLISP has a built-in function <a href="#json-parse">
+json-parse</a> for translating JSON data into S-expressions. The module
+file <tt>json.lsp</tt> is removed from the distribution.</p>
+
+<p>Since version 10.4.8 newLISP has built-in support for unlimited precision
+integers. This makes the GNU GMP module <tt>gmp.lsp</tt> obsolete.</p>
+
+
+<br/>
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+
+<a name="REPL"></a>
+<h2>3. Interactive Lisp mode</h2>
+<p>The best way to experience Lisp and experiment with it, is using interactive 
+mode in a terminal window or operating system command shell. Since version 10.3, 
+newLISP's read-eval-print-loop (REPL) accepts multi-line statements.</p>
+
+<p>To enter a multi-line statement hit the [enter] key on an empty line after
+the system prompt. To exit multi-line mode, hit the [enter] key again on an empty
+line. In the following example computer output is shown in bold letters:</p>
+
+<pre>
+<b>></b> 
+(define (foo x y)
+    (+ x y))
+
+<b>(lambda (x y) (+ x y))
+></b> (foo 3 4)
+<b>7
+></b> 
+</pre>
+
+<p>Note, that multi-line mode is only possible in an OS command terminal window
+or command shell. The monitor window in the Java based newLISP-GS IDE will not
+accept multi-line statements.</p>
+
+<p>Interactive Lisp mode can accept operating system shell commands. To hit
+an OS command enter the '<tt>!</tt>' character right after the prompt, immediately
+followed by the shell command:</p>
+
+<pre>
+<b>> </b>!ls *.html
+<b>CodePatterns.html		MemoryManagement.html	newLISPdoc.html
+ExpressionEvaluation.html	manual_frame.html		newlisp_index.html
+License.html			newLISP-10.3-Release.html	newlisp_manual.html
+> </b>
+</pre>
+
+<p>In the example a <tt>ls</tt> shell command is entered to show HTML files
+in the current directory. On MS Windows a <tt>dir</tt> command could be used
+in the same fashion.</p>
+
+<p>The mode can also be used to call an editor or any other program:</p>
+
+<pre>
+<b>> </b>!vi foo.lsp
+</pre>
+
+<p>The Vi editor will open to edit the program "foo.lsp". After leaving
+the editor the program could be run using a load statement:</p>
+
+<pre>
+<b>> </b>(load "foo.lsp")
+</pre>
+
+<p>The program <tt>foo.lsp</tt> is now run. This mode using '<tt>!</tt>' can
+also be used from the newLISP-GS IDE.</p>
+
+<p>When using a Unix terminal or command shell, tab-expansion for built-in newLISP
+functions can be used:</p>
+
+<pre>
+<b>> </b>(pri
+<b>print       println     primitive?  
+> (pri</b>
+</pre>
+
+<p>After entering the characters <tt> (pri </tt>  hit the [tab] key once to
+show all the built-in functions starting with the same characters. When hitting
+[tab] twice before a function name has started, all built-in function names will
+be displayed.</p>
+
+<p>On most Unix, parenthesis matching can be enabled on the commandline by
+including the following line in the file <tt>.inputrc</tt> in the home
+directory:</p>
+
+<pre>
+set blink-matching-paren on
+</pre>
+
+<p>Not all systems have a version of <tt>libreadline</tt> advanced enough for 
+this to work.</p>
+
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="options"></a>
+<h2>4. Command-line options, startup and directories</h2>
+
+<a name="cmd_help"></a>
+<h3>Command line help summary</h3>
+
+<p>When starting newLISP from the command-line several switches and options and 
+source files can be specified. Executing:</p>
+
+<pre>
+newlisp -h
+</pre>
+
+<p>in a command shell will produce the following summary of options and switches:</p>
+
+<pre>
+ -h this help
+ -n no init.lsp (must be first)
+ -x &lt;source&gt; &lt;target&gt; link
+ -v version
+ -s &lt;stacksize&gt;
+ -m &lt;max-mem-MB&gt; cell memory
+ -e &lt;quoted lisp expression&gt;
+ -l &lt;path-file&gt; log connections
+ -L &lt;path-file&gt; log all
+ -w &lt;working dir&gt;
+ -c no prompts, HTTP
+ -C force prompts
+ -t &lt;usec-server-timeout&gt;
+ -p &lt;port-no&gt;
+ -d &lt;port-no&gt; demon mode
+ -http only
+ -6 IPv6 mode
+</pre>
+
+<p>Before or after the command-line switches, files to load and execute can 
+be specified. If a newLISP executable program is followed by parameters,
+the program must finish with and <tt>(exit)</tt> statement, else newLISP 
+will take command-line parameters as additional newLISP scripts to be 
+loaded and executed.</p>
+
+<p>On Linux and other Unix systems, a <tt>newlisp</tt> <em>man page</em> 
+can be found:</p>
+
+<pre>
+man newlisp
+</pre>		
+
+<p>This will display a man page in the Linux/Unix shell.</p>
+
+<br/>
+
+<a name="url_files"></a>
+<h3>Specifying files as URLs</h3>
+
+<p>newLISP will load and execute files specified on the command-line. Files are 
+specified with either their pathname or a <tt>file://</tt> URL on the local file 
+system or with a <tt>http://</tt> URL on remote file systems running an HTTP
+server. That HTTP server can be newLISP running in HTTP server mode.</p>
+
+<pre>
+newlisp aprog.lsp bprog.lsp prog.lsp
+newlisp http://newlisp.org/example.lsp
+newlisp file:///usr/home/newlisp/demo.lsp
+</pre>
+
+<br/>
+
+<a name="no_init"></a>
+<h3>No loading of init.lsp</h3>
+
+<p>This option suppresses loading of any present initialization file <tt>init.lsp</tt> 
+or <tt>.init.lsp</tt>. In order to work, this must be the first option specified:</p>
+
+<pre>
+newlisp -n
+</pre>
+
+<p>More about <a href="#initialization">initialization files.</a></p>
+
+<br/>
+
+<a name="stack_size"></a>
+<h3>Stack size</h3>
+
+<pre>
+newlisp -s 4000
+newlisp -s 100000 aprog bprog
+newlisp -s 6000 myprog
+newlisp -s 6000 http://asite.com/example.lsp
+</pre>		
+
+<p>The above examples show starting newLISP with different stack sizes using 
+the <tt>-s</tt> option, as well as loading one or more newLISP source files
+and loading files specified by an URL. When no stack size is specified, 
+the stack defaults to 2048. Per stack position about 80 bytes of memory are
+preallocated.</p>
+
+<br/>
+
+<a name="max_mem"></a>
+<h3>Maximum memory usage</h3>
+
+<pre>
+newlisp -m 128
+</pre>		
+
+<p>This example limits newLISP cell memory to 128 megabytes. In 32-bit newLISP, 
+each Lisp cell consumes 16 bytes, so the argument <tt>128</tt> would 
+represent a maximum of 8,388,608 newLISP cells. This information is returned 
+by <a href="#sys-info">sys-info</a> as the list's second element. Although 
+Lisp cell memory is not the only memory consumed by newLISP, it is a good 
+estimate of overall dynamic memory usage.</p>
+
+<br/>
+
+<a name="direct_exec"></a>
+<h3>Direct execution mode</h3>
+
+<p>Small pieces of newLISP code can be executed directly from the command-line:</p>
+
+<pre>
+newlisp -e "(+ 3 4)"  <span class="arw">&rarr;</span> 7 ; On MS Windows and Unix
+
+newlisp -e '(append "abc" "def")'  <span class="arw">&rarr;</span> "abcdef" ; On Unix
+</pre>		
+
+<p>The expression enclosed in quotation marks is evaluated, and the result is 
+printed to standard out (STDOUT). In most Unix system shells, single quotes 
+can also be used as command string delimiters. Note that there is a space between 
+<tt>-e</tt> and the quoted command string.</p>
+
+<br/>
+
+<a name="logging"></a>
+<h3>Logging I/O</h3>
+
+<p>In any mode, newLISP can write a log when started with the <tt>-l</tt> or <tt>-L</tt> 
+option. Depending on the mode newLISP is running, different output is written to the log 
+file. Both options always must specify the  path of a log-file. The path may be a relative 
+path and can be either attached or detached to the <tt>-l</tt> or <tt>-L</tt> option. 
+If the file does not exist, it is created when the first logging output is written.</p>
+
+<pre>
+newlisp -l./logfile.txt -c
+
+newlisp -L /usr/home/www/log.txt -http -w /usr/home/www/htpdocs
+</pre>
+
+<p>The following table shows the items logged in different situations:</p>
+
+<table  width="98%" summary="logging formats">
+<tr align="left"><th>logging mode</th><th>command-line and net-eval with 
+<tt>-c</tt></th><th>HTTP server with <tt>-http</tt></th></tr>
+<tr><td><tt>newlisp -l</tt></td>
+    <td>log only input and network connections</td>
+    <td>log only network connections</td></tr>
+<tr><td><tt>newlisp -L</tt></td>
+    <td>log also newLISP output (w/o prompts)</td>
+    <td>log also HTTP requests</td></tr>
+</table><br/>
+
+<p>All logging output is written to the file specified after the <tt>-l</tt> 
+or <tt>-L</tt> option.</p>
+
+<br/>
+
+<a name="working_dir"></a>
+<h3>Specifying the working directory</h3>
+
+<p>The <tt>-w</tt> option specifies the initial working directory for newLISP 
+after startup:</p>
+
+<pre>
+newlisp -w /usr/home/newlisp
+</pre>
+
+<p>All file requests without a directory path will now be directed to the path 
+specified with the <tt>-w</tt> option.</p>
+
+<br/>
+
+<a name="prompt"></a>
+<h3>Suppressing the prompt and HTTP processing</h3>
+
+<p>The command-line prompt and initial copyright banner can be suppressed:</p>
+
+<pre>
+newlisp -c
+</pre>
+
+<p>Listen and connection messages are suppressed if logging is not enabled. 
+The <tt>-c</tt> option is useful when controlling newLISP 
+from other programs; it is mandatory when setting it up 
+as a <a href="#net-eval">net-eval</a> server.</p>
+
+<p>The <tt>-c</tt> option also enables newLISP server nodes to answer
+<tt>HTTP GET</tt>, <tt>PUT</tt>, <tt>POST</tt> and <tt>DELETE</tt> requests, 
+as well as perform CGI processing. Using the <tt>-c</tt> option,
+together with the <tt>-w</tt> and <tt>-d</tt> options,
+newLISP can serve as a standalone <tt>httpd</tt> webserver:</p>
+
+<pre>
+newlisp -c -d 8080 -w /usr/home/www
+</pre>
+
+<p>When running newLISP as a <tt>inetd</tt> or <tt>xinetd</tt> enabled
+server on Unix machines, use:</p>
+
+<pre>
+newlisp -c -w /usr/home/www
+</pre>
+
+<p>
+In <tt>-c</tt> mode, newLISP processes command-line requests as well as
+HTTP and <a href="#net-eval">net-eval</a> requests. Running
+newLISP in this mode is only recommended on a machine behind
+a firewall. This mode should not be run on machines open and accessible
+through the Internet. To suppress the processing of 
+<a href="#net-eval">net-eval</a> and command-line&ndash;like requests, use 
+the safer <tt>-http</tt> option.</p>
+
+<br/>
+
+<a name="forcing_prompt"></a>
+<h3>Forcing prompts in pipe I/O mode</h3>
+
+<p>A capital <tt>C</tt> forces prompts when running newLISP in pipe I/O mode
+inside the Emacs editor:</p>
+
+<pre>
+newlisp -C
+</pre>
+
+<p>
+To suppress console output from return values from evaluations, 
+use <a href="#silent">silent</a>.</p>
+
+<br/>
+
+<a name="tcpip_server"></a>
+<h3>newLISP as a TCP/IP server</h3>
+
+<pre>
+newlisp some.lsp -p 9090
+</pre>		
+
+<p>
+This example shows how newLISP can listen for commands on a TCP/IP socket 
+connection. In this case, standard I/O is redirected to the port specified with
+the <tt>-p</tt> option. <tt>some.lsp</tt> is an optional file loaded during 
+startup, before listening for a connection begins.</p>
+
+<p>
+The <tt>-p</tt> option is mainly used to control newLISP from another 
+application, such as a newLISP GUI front-end or a program written in another 
+language. As soon as the controlling client closes the connection, newLISP 
+will exit.</p>
+
+<p>
+A telnet application can be used to test running newLISP as a server. First 
+enter:</p>
+
+<pre>
+newlisp -p 4711 &amp;
+</pre>		
+
+<p>
+The <tt>&amp;</tt> indicates to a Unix shell to run the process in the 
+background. On Windows, start the server process without the <tt>&amp;</tt> 
+in the foreground and open a second command window for the telnet application.
+Now connect with a telnet:</p>
+
+<pre>
+telnet localhost 4711
+</pre>	
+
+<p>
+If connected, the newLISP sign-on banner and prompt appear. Instead of 
+<tt>4711</tt>, any other port number could be used.</p>
+
+<p>
+When the client application closes the connection, newLISP will exit, too.
+</p>
+
+<br/>
+
+<a name="daemon"></a>
+<h3>TCP/IP daemon mode</h3>
+
+<p>When the connection to the client is closed in <tt>-p</tt> mode, newLISP 
+exits. To avoid this, use the <tt>-d</tt> option instead of the <tt>-p</tt> 
+option:</p>
+
+<pre>
+newlisp -d 4711 &amp;
+</pre>		
+
+<p>
+This works like the <tt>-p</tt> option, but newLISP does not exit after a 
+connection closes. Instead, it stays in memory, listening for a new connection 
+and preserving its state. An <a href="#exit">exit</a> issued from a client 
+application closes the network connection, and the newLISP daemon remains 
+resident, waiting for a new connection. Any port number could be used in place 
+of <tt>4711</tt>. </p>
+
+<p>After each transaction, when a connection closes, newLISP will go through a 
+reset process, reinitialize stack and signals and go to the <tt>MAIN</tt> 
+context. Only the contents of program and variable symbols will be preserved 
+when running a stateful server.</p>
+
+<p>
+When running in <tt>-p</tt> or <tt>-d</tt> mode, the opening and closing tags 
+<tt>[cmd]</tt> and <tt>[/cmd]</tt> must be used to enclose multiline 
+statements.  They must each appear on separate lines. This makes it possible 
+to transfer larger portions of code from controlling applications. </p>
+
+<p>The following variant of the <tt>-d</tt> mode is frequently used in a 
+distributed computing environment, together with 
+<a href="#net-eval">net-eval</a> on the client side:</p>
+
+<pre>
+newlisp -c -d 4711 &amp;
+</pre>		
+
+<p>The <tt>-c</tt> spec suppresses prompts, making this mode suitable 
+for receiving requests from the <a href="#net-eval">net-eval</a> function.</p>
+
+<p>newLISP server nodes running will also answer <tt>HTTP GET</tt>, 
+<tt>PUT</tt> and <tt>DELETE</tt> requests. This can be used to retrieve and 
+store files with <a href="#get-url">get-url</a>, <a href="#put-url">put-url</a>,
+<a href="#delete-url">delete-url</a>, <a href="#read-file">read-file</a>, 
+<a href="#write-file">write-file</a> and <a href="#append-file">append-file</a>,
+or to load and save programs using <a href="#load">load</a> and 
+<a href="#save">save</a> from and to remote server nodes. See the chapters for 
+the <tt>-c</tt> and <tt>-http</tt> options for more details.</p>
+
+<br/>
+
+<a name="http_mode"></a>
+<h3>HTTP-only server mode</h3>
+<p> newLISP can be limited to HTTP processing using the <tt>-http</tt> option.
+With this mode, a secure <tt>httpd</tt> web server daemon can be configured:</p>
+
+<pre>
+newlisp -http -d 8080 -w /usr/home/www
+</pre>
+
+<p> When running newLISP as an <tt>inetd</tt> or <tt>xinetd</tt>-enabled
+server on Unix machines, use:</p>
+
+<pre>
+newlisp -http -w /usr/home/www
+</pre>
+
+<p>To further enhance security and HTTP processing, load a program during 
+startup when using this mode:</p>
+
+<pre>
+newlisp httpd-conf.lsp -http -w /usr/home/www
+</pre>
+
+<p>The file <tt>httpd-conf.lsp</tt> contains a <a href="#command-event">command-event</a>
+function configuring a user-defined function to analyze, filter and translate requests.
+See the reference for this function for a working example.</p>
+
+<p>In the HTTP modes enabled by either <tt>-c</tt> or <tt>-http</tt>, the 
+following file types are recognized, and a correctly formatted 
+<tt>Content-Type:</tt> header is sent back:</p>
+
+<table  summary="media types">
+<tr align="left"><th>file extension</th><th>media type</th></tr>
+<tr><td>.avi</td><td>video/x-msvideo</td></tr>
+<tr><td>.css</td><td>text/css</td></tr>
+<tr><td>.gif</td><td>image/gif</td></tr>
+<tr><td>.htm</td><td>text/htm</td></tr>
+<tr><td>.html</td><td>text/html</td></tr>
+<tr><td>.jpg</td><td>image/jpg</td></tr>
+<tr><td>.js</td><td>application/javascript</td></tr>
+<tr><td>.mov</td><td>video/quicktime</td></tr>
+<tr><td>.mp3</td><td>audio/mpeg</td></tr>
+<tr><td>.mpg</td><td>video/mpeg</td></tr>
+<tr><td>.pdf</td><td>application/pdf</td></tr>
+<tr><td>.png</td><td>image/png</td></tr>
+<tr><td>.wav</td><td>audio/x-wav</td></tr>
+<tr><td>.zip</td><td>application/zip</td></tr>
+<tr><td><em>any other</em></td><td>text/plain</td></tr>
+</table><br/>
+
+<p>To serve CGI, HTTP server mode needs a <tt>/tmp</tt> directory on Unix-like
+platforms or a <tt>C:\tmp</tt> directory on MS Windows. newLISP can process GET, PUT,
+POST and DELETE requests and create custom response headers. CGI files must have
+the extension <tt>.cgi</tt> and have executable permission on Unix. More 
+information about CGI processing for newLISP server modes can be found in the 
+document <a href="http://www.newlisp.org/CodePatterns.html">
+Code Patterns in newLISP</a>. </p>
+
+<p>In both server modes <tt>-c</tt> and <tt>-http</tt> the environment 
+variables DOCUMENT_ROOT, HTTP_HOST, REMOTE_ADDR, REQUEST_METHOD, 
+SERVER_SOFTWARE and QUERY_STRING are set. The variables CONTENT_TYPE, 
+CONTENT_LENGTH, HTTP_HOST, HTTP_USER_AGENT and HTTP_COOKIE are also set, if 
+present in the HTTP header sent by the client.</p>
+
+<br/>
+		
+<a name="local_domain_server"></a>
+<h3>Local domain Unix socket server</h3>
+
+<p>Instead of a port, a local domain Unix socket path can be specified in
+the <tt>-d</tt> or <tt>-p</tt> server modes.</p>
+
+<pre>
+newlisp -c -d /tmp/mysocket &amp;
+</pre>	
+
+<p>Test the server using another newLISP process:</p>
+
+<pre>
+newlisp -e '(net-eval "/tmp/mysocket" 0 "(symbols)")'
+</pre>	
+
+<p>A list of all built-in symbols will be printed to the terminal</p>
+
+<p>This mode will work together with local domain socket modes of
+<a href="#net-connect">net-connect</a>, <a href="#net-listen">net-listen</a>,
+and <a href="#net-eval">net-eval</a>. Local domain sockets opened with 
+<tt>net-connect</tt> and <tt>net-listen</tt> can be served using
+<a href="#net-accept">net-accept</a>, <a href="#net-receive">net-receive</a>,
+and <a href="#net-send">net-send</a>. Local domain socket connections
+can be monitored using <a href="#net-peek">net-peek</a> and 
+<a href="#net-select">net-select</a>.</p>
+
+<p>Local domain socket connections are much faster than normal TCP/IP network
+connections and preferred for communications between processes on
+the same local file system in distributed applications. This mode is not
+available on MS Windows.</p>
+
+<br/>
+
+<a name="conn_timeout"></a>
+<h3>Connection timeout</h3>
+
+<p>Specifies  a  connection timeout when running in <tt>-p</tt> or <tt>-d</tt> 
+demon mode. A newLISP Server will disconnect when no further input is read 
+after accepting a client connection. The timeout is specified in micro 
+seconds:</p>
+
+<pre>
+newlisp -c -t 3000000 -d 4711 &amp;
+</pre>
+
+<p>The example specifies a timeout of three seconds.</p>
+
+<br/>
+
+<a name="inetd_daemon"></a>
+<h3><tt>inetd</tt>	 daemon mode</h3>
+
+<p>
+The <tt>inetd</tt> server running on virtually all Linux/Unix OSes can function 
+as a proxy for newLISP. The server accepts TCP/IP or UDP connections and passes 
+on requests via standard I/O to newLISP. <tt>inetd</tt> starts a newLISP 
+process for each client connection. When a client disconnects, the connection 
+is closed and the newLISP process exits.</p>
+
+<p>
+<tt>inetd</tt> and newLISP together can handle multiple connections efficiently 
+because of newLISP's small memory footprint, fast executable, and short program 
+load times. When working with <a href="#net-eval">net-eval</a>, this mode is 
+preferred for efficiently handling multiple requests in a distributed computing 
+environment.</p>
+
+<p>
+Two files must be configured: <tt>services</tt> and <tt>inetd.conf</tt>. 
+Both are ASCII-editable and can usually be found at <tt>/etc/services</tt> and 
+<tt>/etc/inetd.conf</tt>.
+</p>
+
+<p>
+Put one of the following lines into <tt>inetd.conf:</tt>
+</p>
+
+<pre>
+net-eval  stream  tcp  nowait  root  /usr/bin/newlisp -c
+											 
+# as an alternative, a program can also be preloaded
+											 
+net-eval  stream  tcp  nowait  root  /usr/bin/newlisp -c myprog.lsp
+</pre>
+
+<p>
+Instead of <tt>root</tt>, another user and optional group can be specified. 
+For details, see the Unix man page for <tt>inetd</tt>.
+</p>
+
+<p>
+The following line is put into the <tt>services</tt> file:
+</p>
+
+<pre>
+net-eval        4711/tcp     # newLISP net-eval requests
+</pre>		
+
+<p>
+On Mac OS X and some Unix systems, <tt>xinetd</tt> can be used instead of 
+<tt>inetd</tt>. Save the following to a file named <tt>net-eval</tt> in the 
+<tt>/etc/xinetd.d/</tt> directory:
+</p>
+
+<pre>
+service net-eval
+{
+    socket_type = stream
+    wait = no
+    user = root
+    server = /usr/bin/newlisp
+    port = 4711
+    server_args = -c
+    only_from = localhost
+}
+</pre>		
+<p>
+For security reasons, <tt>root</tt> should be changed to a different user
+and file permissions of the www document directory adjusted accordingly.
+The <tt>only_from</tt> spec can be left out to permit remote access.
+</p>
+
+<p>
+See the man pages for <tt>xinetd</tt> and <tt>xinetd.conf</tt> 
+for other configuration options.
+</p>
+
+<p>
+After configuring the daemon, <tt>inetd</tt> or 
+<tt>xinetd</tt> must be restarted to 
+allow the new or changed configuration files to be read:
+</p>
+
+<pre>
+kill -HUP &lt;pid&gt;
+</pre>	
+<p>
+Replace <tt>&lt;pid&gt;</tt> with the process ID of the 
+running <tt>xinetd</tt> process.
+</p>
+
+<p>A number or network protocol other than 4711 or TCP can be specified.</p>
+
+<p>
+newLISP handles everything as if the input were being entered 
+on a newLISP command-line without a prompt. To test the 
+<tt>inetd</tt> setup, the <tt>telnet</tt> program can be used:
+</p>
+
+<pre>
+telnet localhost 4711
+</pre>		
+
+<p>
+newLISP expressions can now be entered, and <tt>inetd</tt> will 
+automatically handle the startup and communications of a newLISP 
+process. Multiline expressions can be entered by bracketing them 
+with <tt>[cmd]</tt> and <tt>[/cmd]</tt> tags, each on separate lines.
+</p>
+
+<p>newLISP server nodes answer <tt>HTTP GET</tt> and <tt>PUT</tt> requests. 
+This can be used to retrieve and store files 
+with <a href="#get-url">get-url</a>, <a href="#put-url">put-url</a>,
+<a href="#read-file">read-file</a>, <a href="#write-file">write-file</a>
+and <a href="#append-file">append-file</a>,
+or to load and save programs using <a href="#load">load</a> 
+and <a href="#save">save</a> from and to remote server nodes.</p>
+		
+<br/>
+
+<a name="link"></a>
+<h3>Linking a source file with newLISP for a new executable</h3>
+
+<p>Source code and the newLISP executable can be linked together to build a 
+self-contained application by using the <tt>-x</tt> command line flag.</p>
+
+<pre>
+;; uppercase.lsp - Link example
+(println (upper-case (main-args 1)))
+(exit)
+</pre>		
+
+<p>The program <tt>uppercase.lsp</tt> takes the first word on the command-line 
+and converts it to uppercase.</p>
+
+<p>To build this program as a self-contained executable,
+follow these steps:</p>
+
+<pre>
+# on OSX, Linux and other UNIX
+
+newlisp -x uppercase.lsp uppercase
+
+chmod 755 uppercase # give executable permission
+
+# on Windows the target needs .exe extension
+
+newlisp -x uppercase.lsp uppercase.exe
+</pre>		
+
+<p>newLISP will find a newLISP executable in the execution path of the
+environment and link a copy of the source code.</p>
+
+<pre>
+uppercase "convert me to uppercase"
+</pre>	
+
+<p>The console should print:</p>
+
+<pre>
+CONVERT ME TO UPPERCASE
+</pre>		
+
+<p>Note that neither one of the initialization files <tt>init.lsp</tt> nor 
+<tt>.init.lsp</tt> is loaded during startup of linked programs.</p>
+
+<br/>
+
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+
+<a name="startup"></a>
+<h2>5. Startup, directories, environment</h2>
+
+<a name="environment"></a>
+<h3>Environment variable <tt>NEWLISPDIR</tt></h3>
+<p>During startup, newLISP sets the environment variable <tt>NEWLISPDIR</tt>, 
+if it is not set already. On Linux, BSDs, Mac OS X and other Unixes the 
+variable is set to <tt>/usr/share/newlisp</tt>. On MS Windows the variable is set 
+to <tt>%PROGRAMFILES%/newlisp</tt>.</p>
+
+<p>The environment variable <tt>NEWLISPDIR</tt> is useful when loading files 
+installed with newLISP:</p>
+
+<pre>
+(load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+
+(load (append (env "NEWLISPDIR") "/modules/mysql.lsp"))
+</pre>
+
+<p>A predefined function <tt>module</tt> can be used to shorten
+the second statement loading from the <tt>modules/</tt>
+directory:</p> 
+
+<pre>
+(module "mysql.lsp")
+</pre>
+
+<br/>
+
+<a name="initialization"></a>
+<h3> The initialization file <tt>init.lsp</tt></h3>
+<p>Before loading any files specified on the command-line, and before the 
+banner and prompt are shown. newLISP tries to load a file <tt>.init.lsp</tt> 
+from the home directory of the user starting newLISP. On Mac OS X, Linux and 
+other Unix the home directory is found in the <tt>HOME</tt> environment 
+variable.  On MS Windows the directory name is contained in the <tt>USERPROFILE</tt>
+or <tt>DOCUMENT_ROOT</tt> environment variable.</p>
+
+<p>If a <tt>.init.lsp</tt> cannot be found in the home directory newLISP tries
+to load the file <tt>init.lsp</tt> from the directory found in the 
+environment variable <tt>NEWLISPDIR</tt>.</p>
+
+<p>When newLISP is run as a shared library, an initialization file is looked 
+for in the environment variable <tt>NEWLISPLIB_INIT</tt>. The full path-name 
+of the initialization file must be specified. If <tt>NEWLISPLIB_INIT</tt> is 
+not defined, no initialization file will be loaded by the library module.</p>
+
+<p> Although newLISP does not require <tt>init.lsp</tt> to run, it is 
+convenient for defining functions and system-wide variables.</p>
+
+<p>Note that neither one of the initialization files <tt>init.lsp</tt> nor 
+<tt>.init.lsp</tt> is loaded during startup of linked programs.</p>
+
+<br/>
+
+<a name="directories_unix"></a>
+<h3> Directories on Linux, BSD, Mac OS X and other Unix </h3>
+<p>
+The directory <tt>/usr/share/newlisp/modules</tt> contains modules with useful 
+functions POP3 mail, etc. The directory <tt>/usr/share/newlisp/guiserver</tt> 
+contains sample programs for writing GUI applications with newLISP-GS.
+The directory <tt>/usr/share/doc/newlisp/</tt> contains documentation in HTML 
+format.</p>
+
+<br/>
+
+<a name="directories_win"></a>
+<h3>Directories on MS Windows</h3>
+
+<p>
+On MS Windows systems, all files are installed in the default directory 
+<tt>%PROGRAMFILES%\newlisp</tt>.  <tt>PROGRAMFILES</tt> is a MS Windows environment 
+variable that resolves to <tt>C:\Program files\newlisp\</tt> in English 
+language installations. The subdirectories 
+<tt>%PROGRAMFILES%\newlisp\modules</tt> and 
+<tt>%PROGRAMFILES%\newlisp\guiserver</tt>
+contain modules for interfacing to external libraries and sample programs 
+written for newLISP-GS.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="shared-lib"></a>
+<h2>6. Extending newLISP with shared libraries</h2>
+<p>Many shared libraries on Unix and MS Windows systems can be used to
+extend newLISP's functionality. Examples are libraries for writing graphical
+user interfaces, libraries for encryption or decryption and libraries for 
+accessing databases.</p>
+
+<p>The function <a href="#import">import</a> is used to import functions from 
+external libraries. The function <a href="#callback">callback</a> is used to 
+register callback functions in external libraries. 
+Other functions like <a href="#pack">pack</a>,
+<a href="#unpack">unpack</a>, <a href="#get-char">get-char</a>, <a href="#get-string">get-string</a>,
+<a href="#get-int">get-int</a> and <a href="#get-long">get-long</a> exist
+to facilitate formatting input and output to and from imported library 
+functions. The fucntion <a href="#cpymem">cpymem</a> allows direct memory-to-memory
+copy specifying addresses.</p>
+
+<p>Most of the functions used when writing APIs for share libraries can cause
+newLISP to segfault when not used correctly. The reference documentation marks
+these functions with a <a href="#shared-lib"><font size="+1">&#x26A0;</font></a> character linking
+to this chapter.</p>
+
+<p>See also the chapter 
+<a href="http://www.newlisp.org/downloads/CodePatterns.html#toc-23">
+23. Extending newLISP</a> in the
+<a href="http://www.newlisp.org/downloads/CodePatterns.html">
+Code Patterns in newLISP</a> document.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="newlisp-lib"></a>
+<h2>7. newLISP as a shared library</h2>
+
+<h3>newLISP as C library</h3>
+
+<p>newLISP can be compiled as a shared C library. On Linux, BSDs and other Unix 
+flavors the library is called <tt>newlisp.so</tt>. On Windows it is called 
+<tt>newlisp.dll</tt> and <tt>newlisp.dylib</tt> on Mac OS X. A newLISP shared 
+library is used like any other shared library.</p>
+
+<p>The main function to import is <tt>newlispEvalStr</tt>.  Like 
+<a href="#eval-string">eval-string</a>, this function takes a string containing 
+a newLISP expression and stores the result in a string address. The result can 
+be retrieved using <a href="#get-string">get-string</a>.  The returned string 
+is formatted like output from a command-line session. It contains terminating 
+line-feed characters, but not the prompt string.</p>
+
+<p>When calling <tt>newlispEvalStr</tt>, output normally directed to the 
+console (e.g. return values or <a href="#print">print</a> statements) is 
+returned in the form of an integer string pointer. The output can be accessed 
+by passing this pointer to the <tt>get-string</tt> function. To silence the 
+output from return values, use the <a href="#silent">silent</a> function.</p>
+
+<p>To enable <em>stdio</em> on the console, import the function <tt>newlispLibConsole</tt>
+and call it with a parameter of <tt>1</tt> for enabling I/O on the console
+with <em>stdin</em> and <em>stdout</em>.</p>
+
+<p>Since v.10.3.3 callbacks can also be registered using 
+<tt>newlispCallback</tt>.  For more information read the chapter 
+<a href="http://www.newlisp.org/downloads/CodePatterns.html#toc-24">
+24. newLISP compiled as a shared library</a> in the 
+<a href="http://www.newlisp.org/downloads/CodePatterns.html">
+Code Patterns in newLISP</a> document.</p>
+
+
+<a name="newlisp-js-lib"></a>
+<h3>newLISP as a JavaScript library</h3>
+
+<p>Since version 10.5.7, newLISP can be compiled to JavaScript using the
+<a href="https://github.com/kripken/emscripten/wiki">Emscripten</a>
+toolset. The library can be used to run newLISP clientr-side in a web 
+browser, just like JavaScript or HTML. An HTML page can host both,
+newLISP code and JavaScript code together. Both languages can call
+each other. For more information see the <tt>newlisp-js-x.x.x.zip</tt>
+distribution package which contains the library <tt>newlisp-js-lib.js</tt>,
+documentaion and example applications. A small newLISP development
+environment hosted in a browser can also be accessed here:
+<a href="http://www.newlisp.org/newlisp-js/">newlisp-js</a>
+The application contains links to another example application,
+documentation and a download link for the whole package.</p>
+
+<p>newLISP compiled as a JavaScript library adds new functions linked 
+from <a href="newlisp_manual.html#JS">API for newLISP in a web browser</a>.
+</p>
+ 
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="expressions"></a>
+<h2>8. Evaluating newLISP expressions</h2>
+
+<p>The following is a short introduction to newLISP statement evaluation 
+and the role of integer and floating point arithmetic in newLISP.</p>
+
+<p>Top-level expressions are evaluated when using the 
+<a href="#load"> load</a> function or when entering expressions in console 
+mode on the command-line.</p>
+
+<br/>
+
+<a name="multiline"></a>
+<h3>Interactive multiline expressions</h3>
+
+<p>Multiline expressions can be entered by entering an empty line first. 
+Once in multiline mode, another empty line returns from entry mode 
+and evaluates the statement(s) entered (ouput in boldface):</p>
+
+<pre>
+&gt;
+(define (foo x y)
+    (+ x y))
+
+<b>(lambda (x y) (+ x y))</b>
+&gt; (foo 3 4)
+<b>7</b>
+&gt; _
+</pre>		
+
+<p>Entering multiline mode by hitting the enter key on an empty line 
+suppresses the prompt. Entering another empty line will leave the multiline 
+mode and evaluate expressions.</p>
+
+<p>As an alternativo to entering empty lines, the <tt>[cmd]</tt> and 
+<tt>[/cmd]</tt> tags are used, each entered on separate lines. This mode is 
+used by some interactive IDEs controlling newLISP and internally by the 
+<a href="#net-eval">net-eval</a> function. The <tt>[cmd]</tt> and <tt>[/cmd]</tt>
+tags must also be used in the console part of the newLISP-GS Java IDE.</p>
+
+<br/>
+
+<a name="int_float"></a>
+<h3>Integer, floating point data and operators</h3>
+
+<p>newLISP functions and operators accept integer and floating point numbers, 
+converting them into the needed format. For example, a bit-manipulating 
+operator converts a floating point number into an integer by omitting the 
+fractional part. In the same fashion, a trigonometric function will 
+internally convert an integer into a floating point number before performing 
+its calculation.</p>
+
+<p>The symbol operators 
+(<tt>+</tt> <tt>-</tt> <tt>*</tt> <tt>/</tt> <tt>%</tt> 
+<tt>$</tt> <tt>~</tt> <tt>|</tt> <tt>^</tt> <tt>&lt;&lt;</tt> 
+<tt>&gt;&gt;</tt>) return values of type integer. Functions and operators named 
+with a word instead of a symbol (e.g., <tt>add</tt> rather than <tt>+</tt>) 
+return floating point numbers. Integer operators truncate floating point 
+numbers to integers, discarding the fractional parts.</p>
+
+<p>newLISP has two types of basic arithmetic operators: integer (<tt>+</tt> 
+<tt>-</tt> <tt>*</tt> <tt>/</tt>) and floating point (<tt>add</tt> <tt>sub</tt> 
+<tt>mul</tt> <tt>div</tt>).  The arithmetic functions convert their arguments into types compatible 
+with the function's own type: integer function arguments into integers, 
+floating point function arguments into floating points. To make newLISP 
+behave more like other scripting languages, the integer operators 
+<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, and <tt>/</tt> can be redefined to 
+perform the floating point operators <tt>add</tt>, <tt>sub</tt>, 
+<tt>mul</tt>, and <tt>div</tt>:</p>
+
+<pre>
+(constant '+ add)
+(constant '- sub)
+(constant '* mul)
+(constant '/ div)
+ 
+;; or all 4 operators at once
+(constant '+ add '- sub '* mul '/ div)
+</pre>		
+
+<p>
+Now the common arithmetic operators <tt>+</tt>, <tt>-</tt>, <tt>*</tt>, 
+and <tt>/</tt> accept both integer and floating point numbers and return 
+floating point results. </p>
+
+<p>Care must be taken when <a href="#import">importing</a> from libraries 
+that use functions expecting integers. After redefining <tt>+, -, *</tt>, 
+and <tt>/</tt>, a double floating point number may be unintentionally passed 
+to an imported function instead of an integer. In this case, floating point 
+numbers can be converted into integers by using the function 
+<a href="#int">int</a>. Likewise, integers can be transformed into 
+floating point numbers using the <a href="#float">float</a> function:</p>
+
+<pre>
+(import "mylib.dll" "foo")  ; importing int foo(int x) from C
+(foo (int x))               ; passed argument as integer
+(import "mylib.dll" "bar")  ; importing C int bar(double y)
+(bar (float y))             ; force double float
+</pre>		
+
+<p>Some of the modules shipping with newLISP are written assuming the 
+default implementations of <tt>+</tt>, <tt>-</tt>, <tt>*</tt>, and <tt>/</tt>. 
+This gives imported library functions maximum speed when performing address 
+calculations.</p>
+
+<p>The newLISP preference is to leave <tt>+</tt>, <tt>-</tt>, <tt>*</tt>, and 
+<tt>/</tt> defined as integer operators and use <tt>add</tt>, <tt>sub</tt>, 
+<tt>mul</tt>, and <tt>div</tt> when explicitly required. Since version 8.9.7, 
+integer operations in newLISP are 64 bit operations, whereas 64 bit double 
+floating point numbers offer only 52 bits of resolution in the integer part 
+of the number.</p>
+		
+<br/>
+<a name="big_int"></a>
+<h3>Big integer, multiple precision arithmetic</h3>
+
+<p>The following operators, functions and predicates work on big integers:</p>
+
+<table  summary="functions working on big integers">
+<tr align="left"><th>function</th><th>description</th></tr>
+
+<tr>
+<td width="16%"><a href="#arithmetic">+ - * / ++ -- %</a></td>
+<td width="80%">arithmetic operators</td>
+</tr>
+
+<tr>
+<td><a href="#logical">&lt; &gt; = &lt;= &gt;= !=</a></td>
+<td>logical operators</td>
+</tr>
+
+<tr>
+<td><a href="#abs">abs</a></td>
+<td>returns the absolute value of a number</td>
+</tr>
+
+<tr>
+<td><a href="#gcd">gcd</a></td>
+<td>calculates the greatest common divisor of a group of integers</td>
+</tr>
+
+<tr>
+<td><a href="#evenp">even?</a></td>
+<td>checks the parity of an integer number</td>
+</tr>
+
+<tr>
+<td><a href="#oddp">odd?</a></td>
+<td>checks the parity of an integer number</td>
+</tr>
+
+<tr>
+<td><a href="#numberp">number?</a></td>
+<td>checks if an expression is a float or an integer</td>
+</tr>
+
+<tr>
+<td><a href="#zerop">zero?</a></td>
+<td>checks if an expression is 0 or 0.0</td>
+</tr>
+</table>
+
+<p>If the first argument in any of these operators and functions is a big 
+integer, the calculation performed will be in big integer mode. In the
+<a href="#function_ref">Function Reference</a> section of this manual
+these are marked with a <a href="#big_int"><font size="-1">bigint</font></a>
+suffix.</p> 
+
+<p>Literal integer values greater than 9223372036854775807
+or smaller than -9223372036854775808, or integers with an appended letter L,
+will be converted and processed in big integer mode. The function 
+<a href="#bigint">bigint</a>  can be used to convert from integer, float or string 
+format to big integer. The predicate <a href="#bigintp">bigint?</a> checks for 
+big integer type.</p>
+
+<pre>
+; first argument triggers big integer mode because it's big enough
+
+(+ 123456789012345678901234567890 12345) <span class='arw'>&rarr;</span> 123456789012345678901234580235L
+
+; first small literal put in big integer format by 
+; appending L to guarantee big integer mode
+
+(+ 12345L 123456789012345678901234567890) <span class='arw'>&rarr;</span> 123456789012345678901234580235L
+
+(setq x 1234567890123456789012345)
+(* x x) <span class='arw'>&rarr;</span> 1524157875323883675049533479957338669120562399025L
+
+; conversion from bigint to float introduces rounding errors
+
+(bigint (float (* x x))) <span class='arw'>&rarr;</span> 1524157875323883725344000000000000000000000000000L
+
+; sequence itself does not take big integers, before using
+; apply, the sequence is converted with bigint
+
+(apply * (map bigint (sequence 1 100))) ; calculate 100!
+<span class='arw'>&rarr;</span> 93326215443944152681699238856266700490715968264381
+  62146859296389521759999322991560894146397615651828
+  62536979208272237582511852109168640000000000000000
+  00000000L
+
+; only the first operand needs to be bigint for apply
+; to work. The following gives the same result
+
+(apply * (cons 1L (sequence 2 100)))
+
+; length on big integers returns the number of decimal digits
+(length (apply * (map bigint (sequence 1 100)))) 
+<span class='arw'>&rarr;</span> 158 ; decimal digits
+
+; all fibonacci numbers up to 200, only the first number 
+; needs to be formatted as big integer, the rest follows
+; automatically - when executed from the command line in 
+; a 120 char wide terminal, this shows a beautiful pattern
+
+(let (x 1L) (series x (fn (y) (+ x (swap y x))) 200))
+
+</pre>
+
+<p> When doing mixed integer / big integer arithmetic, the first
+argument should be a big integer to avoid erratic behaviour.</p>
+
+<pre>
+; because the first argument is 64-bit, no big integer arithmetic 
+; will be done, although the second argument is big integer 
+
+(+ 123 12345L)
+<span class='arw'>&rarr;</span> 12468
+
+; the second argument is recognized as a big integer
+; and overflows the capacity of a 64-bit integer
+
+(+ 123 123453456735645634565463563546)
+<span class='arw'>&rarr;</span> <span class="err">ERR: number overflows in function +</span>
+
+; now the first argument converts to big integer and the
+; whole expression evaluates in big integer mode
+
+(+ 123L 123453456735645634565463563546)
+<span class='arw'>&rarr;</span> 123453456735645634565463563669L
+</pre>
+
+<p>Under most circumstances mixing float, integers and big integers is 
+transparent. Functions automatically do conversions when needed on the 
+second argument. The overflow behavior when using normal integers and 
+floats only, has not changed from newLISP versions previous to 10.5.0.</p>
+
+<br/>
+<a name="eval_rules"></a>
+<h3>Evaluation rules and data types</h3>
+
+<p>Evaluate expressions by entering and editing them on the command-line. 
+More complicated programs can be entered using editors like Emacs and VI, 
+which have modes to show matching parentheses while typing. Load a saved 
+file back into a console session by using the <a href="#load">load</a> function.
+</p>
+<p>
+A line comment begins with a <tt>;</tt> (semicolon) or a <tt>#</tt> (number sign) 
+and extends to the end of the line. newLISP ignores this line during evaluation. 
+The <tt>#</tt> is useful when using newLISP as a scripting language in 
+Linux/Unix environments, where the <tt>#</tt> is commonly used as a line comment 
+in scripts and shells.</p>
+
+<p>When evaluation occurs from the command-line, the result is printed to the 
+console window.</p>
+
+<p>The following examples can be entered on the command-line by typing the code 
+to the left of the &nbsp;&nbsp;<span class='arw'>&rarr;</span> symbol. The 
+result that appears on the next line should match the code to the right of the 
+&nbsp;&nbsp;<span class='arw'>&rarr;</span> symbol.</p>
+
+<p><b>nil</b> and <b>true</b> are Boolean data types that 
+evaluate to themselves:</p>
+
+<pre>
+nil    <span class='arw'>&rarr;</span> nil
+true   <span class='arw'>&rarr;</span> true
+</pre>		
+
+<p><b>Integers</b>, <b>big integers</b> and <b>floating point</b> numbers evaluate to themselves:</p>
+
+<pre>
+123      <span class='arw'>&rarr;</span> 123    ; decimal integer
+0xE8     <span class='arw'>&rarr;</span> 232    ; hexadecimal prefixed by 0x
+055      <span class='arw'>&rarr;</span> 45     ; octal prefixed by 0 (zero)
+0b101010 <span class='arw'>&rarr;</span> 42     ; binary prefixed by 0b
+1.23     <span class='arw'>&rarr;</span> 1.23   ; float
+123e-3   <span class='arw'>&rarr;</span> 0.123  ; float in scientific notation
+
+123456789012345678901234567890
+<span class='arw'>&rarr;</span> 123456789012345678901234567890L ; parses to big integer
+</pre>		
+<p>
+Integers are 64-bit including the sign bit.  Valid integers 
+are numbers between -9,223,372,036,854,775,808 and
++9,223,372,036,854,775,807. Larger numbers converted from floating point 
+numbers are truncated to one of the two limits. Integers internal to newLISP, 
+which are limited to 32-bit numbers, overflow to either +2,147,483,647 or
+-2,147,483,648.</p>
+
+<p>Floating point numbers are IEEE 754 64-bit doubles.
+Unsigned numbers up to 18,446,744,073,709,551,615 can be displayed
+using special formatting characters for <a href="#format">format</a>.</p>
+
+<p>Big integers are of unlimited precision and only limited in size by memory. 
+The memory requirement of a big integer is:</p>
+
+<blockquote>
+<b><i>bytes = 4 * ceil(digits / 9) + 4.</i></b>
+</blockquote>
+
+<p>Where <i>digits</i> are decimal digits, <i>bytes</i> are 8 bits and <i>ceil</i>
+is the ceiling function rounding up to the next integer.</p>
+
+<p>
+<b>Strings</b> may contain null characters and can have different 
+delimiters. They evaluate to themselves.</p>
+
+<pre>
+"hello"             <span class='arw'>&rarr;</span>"hello"  
+"\032\032\065\032"  <span class='arw'>&rarr;</span>"  A " 
+"\x20\x20\x41\x20"  <span class='arw'>&rarr;</span>"  A "
+"\t\r\n"            <span class='arw'>&rarr;</span>"\t\r\n" 
+"\x09\x0d\x0a"      <span class='arw'>&rarr;</span>"\t\r\n"
+
+;; null characters are legal in strings:
+"\000\001\002"       <span class='arw'>&rarr;</span> "\000\001\002"
+{this "is" a string} <span class='arw'>&rarr;</span> "this \"is\" a string"
+ 
+;; use [text] tags for text longer than 2047 bytes:
+[text]this is a string, too[/text]
+<span class='arw'>&rarr;</span> "this is a string, too"
+</pre>	
+<p>Strings delimited by <tt>"</tt> (double quotes) will also process 
+the following characters escaped with a <tt>\</tt> (backslash):</p>
+
+<table  width="98%" summary="special characters in strings">
+<tr align="left"><th>character</th><th>description</th></tr>
+
+<tr><td><tt>\"</tt></td>
+<td>for a double quote inside a quoted string</td></tr>
+
+<tr><td><tt>\n</tt></td>
+<td>for a line-feed character (ASCII 10)</td></tr>
+
+<tr><td><tt>\r</tt></td>
+<td>for a return character (ASCII 13)</td></tr>
+
+<tr><td><tt>\b</tt></td>
+<td>for a backspace BS character (ASCII 8)</td></tr>
+
+<tr><td><tt>\t</tt></td>
+<td>for a TAB character (ASCII 9)</td></tr>
+
+<tr><td><tt>\f</tt></td>
+<td>for a formfeed FF character (ASCII 12)</td></tr>
+
+<tr><td><tt>\nnn</tt></td>
+<td>for a three-digit ASCII number (nnn format 
+between 000 and 255)</td></tr>
+
+<tr><td><tt>\xnn</tt></td>
+<td>for a two-digit-hex ASCII number (xnn format between x00 and xff)</td></tr> 
+
+<tr><td><tt>\unnnn</tt></td>
+<td>for a unicode character encoded in the four <tt>nnnn</tt> hexadecimal
+digits. newLISP will translate this to a UTF8 character in the UTF8 enabled 
+versions of newLISP.</td>
+</tr>
+
+<tr><td><tt>\\</tt></td><td>for the backslash character (ASCII 92) 
+itself</td></tr>
+</table><br/>
+
+<p>Quoted strings cannot exceed 2,047 characters. Longer strings should use 
+the <tt>[text]</tt> and <tt>[/text]</tt> tag delimiters.  newLISP automatically 
+uses these tags for string output longer than 2,047 characters.</p>
+
+<p>The <tt>{</tt> (left curly bracket), <tt>}</tt> (right curly bracket), 
+and <tt>[text], [/text]</tt> delimiters do not perform escape character 
+processing.</p>
+
+<p><b>Lambda and lambda-macro expressions</b> evaluate to themselves:</p>
+
+<pre>
+(lambda (x) (* x x))                   <span class='arw'>&rarr;</span> (lambda (x) (* x x))
+(lambda-macro (a b) (set (eval a) b))  <span class='arw'>&rarr;</span> (lambda-macro (a b) (set (eval a) b))
+(fn (x) (* x x))                       <span class='arw'>&rarr;</span> (lambda (x) (* x x))  ; an alternative syntax
+</pre>		
+
+<p><b>Symbols</b> evaluate to their contents:</p>
+
+<pre>
+(set 'something 123)  <span class='arw'>&rarr;</span> 123
+something             <span class='arw'>&rarr;</span> 123
+</pre>		
+
+<p><b>Contexts</b> evaluate to themselves:</p>
+
+<pre>
+(context 'CTX)  <span class='arw'>&rarr;</span> CTX
+CTX             <span class='arw'>&rarr;</span> CTX
+</pre>		
+
+<p><b>Built-in functions</b> also evaluate to themselves:</p>
+
+<pre>
+add                <span class='arw'>&rarr;</span> add &lt;B845770D&gt;
+(eval (eval add))  <span class='arw'>&rarr;</span> add &lt;B845770D&gt;
+(constant '+ add)  <span class='arw'>&rarr;</span> add &lt;B845770D&gt;
++                  <span class='arw'>&rarr;</span> add &lt;B845770D&gt;
+</pre>		
+
+<p>In the above example, the number between the &lt; &gt; (angle brackets) 
+is the hexadecimal memory address (machine-dependent) of the 
+<tt>add</tt> function. It is displayed when printing a built-in primitive.</p>
+
+<p><b>Quoted expressions</b> lose one ' (single quote) when evaluated:
+</p>
+
+<pre>
+'something  <span class='arw'>&rarr;</span> something
+''''any     <span class='arw'>&rarr;</span> '''any
+'(a b c d)  <span class='arw'>&rarr;</span> (a b c d)
+</pre>		
+
+<p>A single quote is often used to <em>protect</em> an expression 
+from evaluation (e.g., when referring to the symbol itself instead 
+of its contents or to a list representing data instead of a function).</p>
+		
+<p><b>Lists</b> are evaluated by first evaluating the first list element
+before the rest of the expression (as in Scheme). The result of the 
+evaluation is applied to the remaining elements in the list and must 
+be one of the following: a <tt>lambda</tt> expression, <tt>lambda-macro</tt> 
+expression, or <tt>primitive</tt> (built-in) function.</p>
+
+<pre>
+(+ 1 2 3 4)                  <span class='arw'>&rarr;</span> 10
+(define (double x) (+ x x))  <span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+</pre>		
+
+<p>or</p>
+
+<pre>
+(set 'double (lambda (x) (+ x x)))
+(double 20)               <span class='arw'>&rarr;</span> 40
+((lambda (x) (* x x)) 5)  <span class='arw'>&rarr;</span> 25
+</pre>		
+
+<p>For a user-defined lambda expression, newLISP evaluates the arguments from 
+left to right and binds the results to the parameters (also from left to 
+right), before using the results in the body of the expression. </p>
+
+<p>Like Scheme, newLISP evaluates the <em>functor</em> (function object) 
+part of an expression before applying the result to its arguments. For 
+example:</p>
+
+<pre>
+((if (&gt; X 10) * +) X Y)
+</pre>		
+
+<p>Depending on the value of X, this expression applies the <tt>*</tt> 
+(product) or <tt>+</tt> (sum) function to X and Y.
+</p>
+
+<p>Because their arguments are not evaluated, <tt>lambda-macro</tt> 
+expressions are useful for extending the syntax of the language. Most 
+built-in functions evaluate their arguments from left to right (as needed) 
+when executed. Some exceptions to this rule are indicated in the reference 
+section of this manual. Lisp functions that do not evaluate all or some of 
+their arguments are called <em>special forms</em>.</p>
+
+<p><b>Arrays</b> evaluate to themselves:</p>
+
+<pre>
+(set 'A (array 2 2 '(1 2 3 4))) <span class='arw'>&rarr;</span> ((1 2) (3 4))
+(eval A)                        <span class='arw'>&rarr;</span> ((1 2) (3 4))
+</pre>
+
+
+<p><b>Shell commands</b>: If an <tt>!</tt> (exclamation mark) 
+is entered as the first character on the command-line followed by a shell 
+command, the command will be executed. For example, <tt>!ls</tt> on Unix or 
+<tt>!dir</tt> on MS Windows will display a listing of the present working directory. 
+No spaces are permitted between the <tt>!</tt> and the shell command. Symbols 
+beginning with an <tt>!</tt> are still allowed inside expressions or  on the 
+command-line when preceded by a space. Note: This mode only works when running 
+in the shell and does not work when controlling newLISP from another 
+application.
+</p>
+
+<p>To exit the newLISP shell on Linux/Unix, press <tt>Ctrl-D</tt>; on MS Windows, 
+type <tt>(exit)</tt> or <tt>Ctrl-C</tt>, then the x key.
+</p>
+
+<p>Use the <a href="#exec">exec</a> function to access shell commands from 
+other applications or to pass results back to newLISP.
+</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+<a name="lambda_expressions"></a>
+<h2>9. Lambda expressions in newLISP</h2>
+
+<p>Lambda expressions in newLISP evaluate to themselves and can be treated
+just like regular lists:</p>
+
+<pre>
+(set 'double (lambda (x) (+ x x)))
+(set 'double (fn (x) (+ x x)))      ; alternative syntax
+
+(last double)  <span class='arw'>&rarr;</span> (+ x x)            ; treat lambda as a list
+</pre>		
+
+<p>Note: No <tt>'</tt> is necessary before the lambda expression because 
+lambda expressions evaluate to themselves in newLISP.</p>
+<p>
+The second line uses the keyword <tt>fn</tt>, an alternative syntax first suggested 
+by Paul Graham for his Arc language project.
+</p>
+<p>
+A lambda expression is a <em>lambda list</em>, a subtype of <em>list</em>, and its 
+arguments can associate from left to right or right to left. When using 
+<a href="#append">append</a>, for example, the arguments associate from left to right:
+</p>
+<pre>
+(append (lambda (x)) '((+ x x)))  <span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+</pre>		<p>
+<a href="#cons">cons</a>, on the other hand, associates the arguments from right to left:
+</p>
+<pre>
+(cons '(x) (lambda (+ x x)))  <span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+</pre>		<p>
+Note that the <tt>lambda</tt> keyword is not a symbol in a list, but a
+designator of a special <em>type</em> of list: the <em>lambda list</em>.
+</p>
+<pre>
+(length (lambda (x) (+ x x)))  <span class='arw'>&rarr;</span> 2
+(first (lambda (x) (+ x x)))   <span class='arw'>&rarr;</span> (x)
+</pre>		<p>
+Lambda expressions can be mapped or applied onto arguments to work as user-defined, anonymous functions:
+</p>
+<pre>
+((lambda (x) (+ x x)) 123)           <span class='arw'>&rarr;</span> 246
+(apply (lambda (x) (+ x x)) '(123))  <span class='arw'>&rarr;</span> 246
+(map (lambda (x) (+ x x)) '(1 2 3))  <span class='arw'>&rarr;</span> (2 4 6)
+</pre>		
+
+<p>A lambda expression can be assigned to a symbol, which in turn can be 
+used as a function:</p>
+
+<pre>
+(set 'double (lambda (x) (+ x x)))  <span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+(double 123)                        <span class='arw'>&rarr;</span> 246
+</pre>		
+
+<p>The <a href="#define">define</a> function is just a shorter way of
+assigning a lambda expression to a symbol:</p>
+
+<pre>
+(define (double x) (+ x x)))  <span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+(double 123)                  <span class='arw'>&rarr;</span> 246
+</pre>		
+
+<p>In the above example, the expressions inside the lambda list are still 
+accessible within <tt>double</tt>:</p>
+
+<pre>
+(set 'double (lambda (x) (+ x x)))  <span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+(last double)                       <span class='arw'>&rarr;</span> (+ x x)
+</pre>		
+
+<p>A lambda list can be manipulated as a first-class object using any function 
+that operates on lists:</p>
+
+<pre>
+(setf (nth 1 double) '(mul 2 x))     <span class='arw'>&rarr;</span> (lambda (x) (mul 2 x))
+double                           <span class='arw'>&rarr;</span> (lambda (x) (mul 2 x))
+(double 123)                     <span class='arw'>&rarr;</span> 246
+</pre>		
+
+<p>All arguments are optional when applying lambda expressions and default to <tt>nil</tt> 
+when not supplied by the user. This makes it possible to write functions with 
+multiple parameter signatures.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="nil_and_true"></a>
+<h2>10. <tt>nil</tt>, <tt>true</tt>, <tt>cons</tt>, and <tt>()</tt></h2>
+
+<p>In newLISP, <tt>nil</tt> and <tt>true</tt> represent both the symbols and the 
+Boolean values <em>false</em> and <em>true</em>. Depending on their context, 
+<tt>nil</tt> and <tt>true</tt> are treated differently. The following examples use 
+<tt>nil</tt>, but they can be applied to <tt>true</tt> by simply reversing the logic.
+</p>
+
+<p>Evaluation of <tt>nil</tt> yields a Boolean false and is treated as such inside 
+flow control  expressions such as <tt>if</tt>, <tt>unless</tt>, <tt>while</tt>, 
+<tt>until</tt>, and <tt>not</tt>. Likewise, evaluating <tt>true</tt> yields true.</p>
+
+<pre>
+(set 'lst '(nil nil nil))  <span class='arw'>&rarr;</span> (nil nil nil)
+(map symbol? lst)          <span class='arw'>&rarr;</span> (true true true)
+</pre>		
+
+<p>In the above example, <tt>nil</tt> represents a symbol. In the following example, 
+<tt>nil</tt> and <tt>true</tt> are evaluated and represent Boolean values:</p>
+
+<pre>
+(if nil "no" "yes")  <span class='arw'>&rarr;</span> "yes"
+(if true "yes" "no") <span class='arw'>&rarr;</span> "yes"
+(map not lst)        <span class='arw'>&rarr;</span> (true true true)
+</pre>		
+
+<p>In newLISP, <tt>nil</tt> and the empty list <tt>()</tt> are not the same as in 
+some other Lisps. Only in conditional expressions are they treated as a Boolean 
+false, as in <tt>and</tt>, <tt>or</tt>, <tt>if</tt>, <tt>while</tt>, 
+<tt>unless</tt>, <tt>until</tt>, and <tt>cond</tt>.</p>
+
+<p>Evaluation of <tt>(cons 'x '())</tt> yields <tt>(x)</tt>, but <tt>(cons 'x nil)</tt> 
+yields <tt>(x nil)</tt> because <tt>nil</tt> is treated as a Boolean value when 
+evaluated, not as an empty list. The <tt>cons</tt> of two atoms in newLISP 
+does not yield a dotted pair, but rather a two-element list. The predicate 
+<tt>atom?</tt> is true for <tt>nil</tt>, but false for the empty list. The empty 
+list in newLISP is only an empty list and not equal to <tt>nil</tt>.</p>
+
+<p>A list in newLISP is a newLISP cell of type list. It acts like a container for the 
+linked list of elements making up the list cell's contents. There is no 
+<em>dotted pair</em> in newLISP because the <em>cdr</em> (tail) part of a Lisp 
+cell always points to another Lisp cell and never to a basic data type, such as a 
+number or a symbol. Only the <em>car</em> (head) part may contain a basic data type. 
+Early Lisp implementations used <em>car</em> and <em>cdr</em> for the names 
+<em>head</em> and <em>tail</em>.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="arrays"></a>
+<h2>11. Arrays</h2>
+
+<p>newLISP's arrays enable fast element access within large lists. New arrays 
+can be constructed and initialized with the contents of an existing list 
+using the function <a href="#array">array</a>. Lists can be converted into 
+arrays, and vice versa. Most of the same functions used for modifying and 
+accessing lists can be applied to arrays, as well. Arrays can hold any type 
+of data or combination thereof.</p>
+
+<p>In particular, the following functions can be used for creating, accessing, 
+and modifying arrays:</p>
+
+<table  summary="functions using arrays">
+<tr align="left"><th>function</th><th>description</th></tr>
+
+<tr>
+<td width="16%"><a href="#append">append</a></td>
+<td width="80%">appends arrays</td>
+</tr>
+
+<tr>
+<td><a href="#apply">apply</a></td>
+<td>apply a function or operator to a list of arguments.</td>
+</tr>
+
+<tr>
+<td><a href="#array">array</a></td>
+<td>creates and initializes an array with up to 16 dimensions</td>
+</tr>
+
+<tr>
+<td><a href="#array-list">array-list</a></td>
+<td>converts an array into a list</td>
+</tr>
+
+<tr>
+<td><a href="#arrayp">array?</a></td>
+<td>checks if expression is an array</td>
+</tr>
+
+<tr>
+<td><a href="#corr">corr</a></td>
+<td>calculates the <em>product-moment correlation</em> coefficient</td>
+</tr>
+
+<tr>
+<td><a href="#det">det</a></td>
+<td>returns the determinant of a matrix</td>
+</tr>
+
+<tr>
+<td><a href="#dolist">dolist</a></td>
+<td>evaluates once for each element in an array vector</td>
+</tr>
+
+<tr>
+<td><a href="#first">first</a></td>
+<td>returns the first row of an array</td>
+</tr>
+
+<tr>
+<td><a href="#invert">invert</a></td>
+<td>returns the inversion of a matrix</td>
+</tr>
+
+<tr>
+<td><a href="#last">last</a></td>
+<td>returns the last row of an array</td>
+</tr>
+
+<tr>
+<td><a href="#length">length</a></td>
+<td>returns the number of rows in an array or elements in a vector</td>
+</tr>
+
+<tr>
+<td><a href="#map">map</a></td>
+<td>applies a function to vector(s) of arguments
+and returns results in a list.</td>
+</tr>
+
+<tr>
+<td><a href="#mat">mat</a></td>
+<td>perform scalar operations on matrices</td>
+</tr>
+
+<tr>
+<td><a href="#multiply">multiply</a></td>
+<td>multiplies two matrices</td>
+</tr>
+
+<tr>
+<td><a href="#nth">nth</a></td>
+<td>returns an element of and array</td>
+</tr>
+
+<tr>
+<td><a href="#rest">rest</a></td>
+<td>returns all but the first row of an array</td>
+</tr>
+
+<tr>
+<td><a href="#reverse">reverse</a></td>
+<td>reverses the elements or rows in an array</td>
+</tr>
+
+<tr>
+<td><a href="#setf">setf</a></td>
+<td>sets contents of an array reference</td>
+</tr>
+
+<tr>
+<td><a href="#slice">slice</a></td>
+<td>returns a slice of an array</td>
+</tr>
+
+<tr>
+<td><a href="#sort">sort</a></td>
+<td>sort the elements in an array</td>
+</tr>
+
+<tr>
+<td><a href="#stats">stats</a></td>
+<td>calculates some basic statistics for a data vector</td>
+</tr>
+
+<tr>
+<td><a href="#t-test">t-test</a></td>
+<td>compares means of data samples using the <em>Student's t</em> statistic</td>
+</tr>
+
+<tr>
+<td><a href="#transpose">transpose</a></td>
+<td>transposes a matrix</td>
+</tr>
+</table><br/>
+
+<p>
+newLISP represents multidimensional arrays with an array of arrays 
+(i.e., the elements of the array are themselves arrays).
+</p>
+
+<p>When used interactively, newLISP prints and displays arrays as lists, 
+with no way of distinguishing between them.</p>
+
+<p>Use the <a href="#source">source</a> or <a href="#save">save</a> 
+functions to serialize arrays (or the variables containing them). 
+The <a href="#array">array</a> statement is included as part of 
+the definition when serializing arrays.</p>
+
+<p>Like lists, negative indices can be used to enumerate the elements 
+of an array, starting from the last element.</p>
+
+<p>An out-of-bounds index will cause an error message on an array or list.</p>
+
+<p>Arrays can be non-rectangular, but they are made rectangular 
+during serialization when using <a href="#source">source</a> or <a href="#save">save</a>. 
+The <a href="#array">array</a> function always constructs arrays in rectangular form.</p>
+
+<p>The matrix functions <a href="#det">det</a>, <a href="#transpose">transpose</a>, 
+<a href="#multiply">multiply</a>, and <a href="#invert">invert</a> can be used on 
+matrices built with nested lists or arrays built with <a href="#array">array</a>.</p>
+
+<p>For more details, see <a href="#array">array</a>, <a href="#arrayp">array?</a>, 
+and <a href="#array-list">array-list</a> in the reference section of this manual.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="indexing"></a>
+<h2>12. Indexing elements of strings, lists, and arrays</h2>
+
+<p>Some functions take array, list, or string elements (characters) 
+specified by one or more <em>int-index</em> (integer index). The positive 
+indices run <tt>0, 1, &hellip;, N-2, N-1</tt>, where <tt>N</tt> is the 
+number of elements in the list. If <em>int-index</em> is negative, the sequence 
+is <tt>-N, -N+1, &hellip;, -2, -1</tt>. Adding <tt>N</tt> to the negative 
+index of an element yields the positive index. Unless a function does 
+otherwise, an index greater than <tt>N-1</tt> or less then -N causes an 
+out-of-bounds error in lists and arrays.</p>
+
+<br/>
+
+<a name="implicit_indexing"></a>
+<h3>Implicit indexing for <tt>nth</tt></h3>
+
+<p>Implicit indexing can be used instead of <a href="#nth">nth</a> to 
+retrieve the elements of a list or array or the characters of a string:</p>
+
+<pre>
+(set 'lst '(a b c (d e) (f g)))
+
+(lst 0)    <span class='arw'>&rarr;</span> a      ; same as (nth 0 lst)
+(lst 3)    <span class='arw'>&rarr;</span> (d e)
+(lst 3 1)  <span class='arw'>&rarr;</span> e      ; same as (nth '(3 1) lst)
+(lst -1)   <span class='arw'>&rarr;</span> (f g)
+
+(set 'myarray (array 3 2 (sequence 1 6)))
+
+(myarray 1)     <span class='arw'>&rarr;</span> (3 4)
+(myarray 1 0)   <span class='arw'>&rarr;</span> 3
+(myarray 0 -1)  <span class='arw'>&rarr;</span> 2
+
+; indexing ASCII strings
+("newLISP" 3)   <span class='arw'>&rarr;</span> "L"
+
+; indexing strings in UTF8 enabled versions
+ ("ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚" 3) <span class='arw'>&rarr;</span> "ไธ‹"
+</pre>		
+
+<p>Indices may also be supplied from a list. In this way, implicit 
+indexing works together with functions that take or produce index 
+vectors, such as <a href="#push">push</a>, <a href="#pop">pop</a>, 
+<a href="#ref">ref</a> and <a href="#ref-all">ref-all</a>.</p>
+
+<pre>
+(lst '(3 1))                <span class='arw'>&rarr;</span> e
+(set 'vec (ref 'e lst))     <span class='arw'>&rarr;</span> (3 1)
+(lst vec)                   <span class='arw'>&rarr;</span> e
+
+; an empty index vector yields the original list or array
+
+(lst '())  <span class='arw'>&rarr;</span> (set 'lst '(a b c (d e) (f g)))
+</pre>		
+
+<p>Note that implicit indexing is not breaking newLISP
+syntax rules but is merely an expansion of existing rules to
+other data types in the functor position of an s-expression. 
+In original Lisp, the first element in an s-expression list
+is applied as a function to the rest elements as arguments. In newLISP, a list 
+in the functor position of an s-expression assumes self-indexing functionality 
+using the index arguments following it.</p>
+
+<p>Implicit indexing is faster than the explicit forms, but the explicit forms
+may be more readable depending on context.</p>
+
+<p>Note that in the UTF-8&ndash;enabled version of newLISP, implicit indexing 
+of strings or using the <a href="#nth">nth</a> function work on character rather 
+than single-byte boundaries.</p>
+
+<br/>
+
+<a name="implicit_default"></a>
+<h3>Implicit indexing and the default functor</h3>
+
+<p>The <em>default functor</em> is a functor inside a context with the same 
+name as the context itself. See <a href="#default_function">The context 
+default function</a> chapter. A default functor can be used together with 
+implicit indexing to serve as a mechanism for referencing lists:</p>
+
+<pre>
+(set 'MyList:MyList '(a b c d e f g))
+
+(MyList 0)   <span class='arw'>&rarr;</span> a
+(MyList 3)   <span class='arw'>&rarr;</span> d
+(MyList -1)  <span class='arw'>&rarr;</span> g
+
+(3 2 MyList) <span class='arw'>&rarr;</span> (d e)
+(-3 MyList)  <span class='arw'>&rarr;</span> (e f g)
+
+(set 'aList MyList)
+
+(aList 3)  <span class='arw'>&rarr;</span> d
+</pre>		
+
+<p>In this example, <tt>aList</tt> references <tt>MyList:MyList</tt>, 
+not a copy of it. For more information about contexts, see 
+<a href="#context_vars">Variables holding contexts</a>.</p>
+
+<p>The indexed default functor can also be used with <a href="#setf">setf</a> as shown 
+in the following example:</p>
+
+<pre>
+(set 'MyList:MyList '(a b c d e f g))
+
+(setf (MyList 3) 999)   <span class='arw'>&rarr;</span> 999
+(MyList 3)              <span class='arw'>&rarr;</span> 999
+
+MyList:MyList           <span class='arw'>&rarr;</span> (a b c 999 e f g)
+</pre>
+
+<br/>
+
+<a name="implicit_rest_slice"></a>
+<h3>Implicit indexing for <tt>rest</tt> and <tt>slice</tt> </h3>
+
+<p> Implicit forms of <a href="#rest">rest</a> and <a href="#slice">slice</a> 
+can be created by prepending a list with one or two numbers for offset and length.
+If the length is negative it counts from the end of the list or string:</p>
+
+<pre>
+(set 'lst '(a b c d e f g))
+; or as array
+(set 'lst (array 7 '(a b c d e f g)))
+
+(1 lst)      <span class='arw'>&rarr;</span> (b c d e f g)
+(2 lst)      <span class='arw'>&rarr;</span> (c d e f g)
+(2 3 lst)    <span class='arw'>&rarr;</span> (c d e)
+(-3 2 lst)   <span class='arw'>&rarr;</span> (e f)
+(2 -2 lst)   <span class='arw'>&rarr;</span> (c d e)
+
+; resting and slicing is always on 8-bit char borders
+; even on UTF8 enabled versions
+
+(set 'str "abcdefg")
+
+(1 str)      <span class='arw'>&rarr;</span> "bcdefg"
+(2 str)      <span class='arw'>&rarr;</span> "cdefg"
+(2 3 str)    <span class='arw'>&rarr;</span> "cde"
+(-3 2 str)   <span class='arw'>&rarr;</span> "ef"
+(2 -2 str)   <span class='arw'>&rarr;</span> "cde"
+
+</pre>	
+
+<p>The functions <a href="#rest">rest</a>, <a href="#first">first</a>
+and <a href="#last">last</a> work on multi-byte character boundaries
+in UTF-8 enabled versions of newLISP. But the implicit indexing forms for
+slicing and resting will always work on single-byte boundaries and can be used for 
+binary content. Offset and length results from the regular expression functions 
+<a href="#find">find</a> and <a href="#regex">regex</a> are also in single-byte
+counts and can be further processed with <a href="#slice">slice</a> or it's
+implicit form.</p>
+
+<br/>
+
+<a name="implicit_modify"></a>
+<h3>Modify references in lists, arrays and strings</h3>
+
+<p>Parts in lists, arrays and strings referenced by indices can be modified using
+<a href="#setf">setf</a>:</p>
+
+<pre>
+; lists
+
+(set 'lst '(a b c d (e f g)))
+
+(lst 1) <span class='arw'>&rarr;</span> b
+
+(setf (lst 1) 'z) <span class='arw'>&rarr;</span> z
+
+lst <span class='arw'>&rarr;</span> (a z c d (e f g))
+
+(setf (lst -1) '(E F G)) <span class='arw'>&rarr;</span> (E F G)
+
+lst <span class='arw'>&rarr;</span> (a z c d (E F G))
+
+; arrays
+
+(set 'myarray (array 2 3 (sequence 1 6))) <span class='arw'>&rarr;</span> ((1 2 3) (4 5 6))
+
+(setf (myarray 1 2) 66) <span class='arw'>&rarr;</span> 66
+
+myarray <span class='arw'>&rarr;</span> ((1 2 3) (4 5 66))
+
+; strings
+
+(set 's "NewLISP")
+
+(setf (s 0) "n") <span class='arw'>&rarr;</span> "n"
+
+s <span class='arw'>&rarr;</span> "newLISP"
+</pre>
+
+
+<p>Note that only full elements or nested lists or arrays can be changed this way.
+Slices or rest parts of lists or arrays as used in implicit resting or slicing cannot
+be substituted at once using <a href="#setf">setf</a>, but would have to be substituted
+element by element. In strings only one character can be replaced at a time, but
+that character can be replaced by a multi-character string.</p> 
+
+<br/>
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+
+<a name="destructive"></a>
+<h2>13. Destructive versus nondestructive functions</h2>
+
+<p>Most of the primitives in newLISP are nondestructive (no <em>side effects</em>) 
+and leave existing objects untouched, although they may create new ones. There 
+are a few destructive functions, however, that <em>do</em> change the contents of a 
+variable, list, array, or string:</p>
+
+<table  width="98%" summary="destructive functions">
+<tr align="left"><th>function</th><th>description</th></tr>
+
+<tr>
+<td><a href="#inci">++</a></td>
+<td>increments numbers in integer mode</td>
+</tr>
+
+<tr>
+<td><a href="#deci">--</a></td>
+<td>decrements numbers in integer mode</td>
+</tr>
+
+<tr>
+<td><a href="#bind">bind</a></td>
+<td>binds variable associations in a list</td>
+</tr>
+
+<tr>
+<td><a href="#constant">constant</a></td>
+<td>sets the contents of a variable and protects it</td>
+</tr>
+
+<tr>
+<td><a href="#extend">extend</a></td>
+<td>extends a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#dec">dec</a></td>
+<td>decrements a number referenced by a variable, list or array</td>
+</tr>
+
+<tr>
+<td><a href="#define">define</a></td>
+<td>sets the contents of a variable</td>
+</tr>
+
+<tr>
+<td><a href="#define-macro">define-macro</a></td>
+<td>sets the contents of a variable</td>
+</tr>
+
+<tr>
+<td><a href="#inc">inc</a></td>
+<td>increments a number referenced by a variable, list or array</td>
+</tr>
+
+<tr>
+<td><a href="#let">let</a></td>
+<td>declares and initializes local variables</td>
+</tr>
+
+<tr>
+<td><a href="#letn">letn</a></td>
+<td>initializes local variables incrementally, like nested lets</td>
+</tr>
+
+<tr>
+<td><a href="#letex">letex</a></td>
+<td>expands local variables into an expression, then evaluates</td>
+</tr>
+
+<tr>
+<td><a href="#net-receive">net-receive</a></td>
+<td>reads into a buffer variable</td>
+</tr>
+
+<tr>
+<td><a href="#pop">pop</a></td>
+<td>pops an element from a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#pop-assoc">pop-assoc</a></td>
+<td>removes an association from an association list</td>
+</tr>
+
+<tr>
+<td><a href="#push">push</a></td>
+<td>pushes a new element onto a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#read">read</a></td>
+<td>reads into a buffer variable</td>
+</tr>
+
+<tr>
+<td><a href="#receive">receive</a></td>
+<td>receives a message from a parent or child process</td>
+</tr>
+
+<tr>
+<td><a href="#replace">replace</a></td>
+<td>replaces elements in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#reverse">reverse</a></td>
+<td>reverses a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#rotate">rotate</a></td>
+<td>rotates the elements of a list or characters of a string</td>
+</tr>
+
+<tr>
+<td><a href="#set">set</a></td>
+<td>sets the contents of a variable</td>
+</tr>
+
+<tr>
+<td><a href="#setf">setf setq</a></td>
+<td>sets the contents of a variable, list, array or string</td>
+</tr>
+
+<tr>
+<td><a href="#set-ref">set-ref</a></td>
+<td>searches for an element in a nested list and replaces it</td>
+</tr>
+
+<tr>
+<td><a href="#set-ref-all">set-ref-all</a></td>
+<td>searches for an element in a nested list and replaces all instances</td>
+</tr>
+
+<tr>
+<td><a href="#sort">sort</a></td>
+<td>sorts the elements of a list or array</td>
+</tr>
+
+<tr>
+<td><a href="#swap">swap</a></td>
+<td>swaps two elements inside a list or string</td>
+</tr>
+
+</table><br/>
+
+<br/>
+
+<a name="make_nondestructive"></a>
+<h3>Make a destructive function non-destructive</h3>
+
+<p>Some destructive functions can be made non-destructive by wrapping the target 
+object into the <a href="#copy">copy</a> function.</p>
+
+<pre>
+(set 'aList '(a b c d e f))
+
+(replace 'c (copy aList)) <span class='arw'>&rarr;</span> (a b d e f)
+
+aList <span class='arw'>&rarr;</span> (a b c d e f)
+</pre>
+
+<p>The list in <tt>aList</tt> is left unchanged.</p>
+
+<br/>
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="return"></a>
+<h2>14. Early return from functions, loops, and blocks</h2>
+
+<p>What follows are methods of interrupting the control flow inside both 
+loops and the <a href="#begin">begin</a> expression.</p>
+
+<p>The looping functions <a href="#dolist">dolist</a> and <a href="#dotimes">
+dotimes</a> can take optional conditional expressions to leave the loop
+early. <a href="#catch">catch</a> and <a href="#throw">throw</a> are a more
+general form to break out of a loop body and are also applicable to other
+forms or statement blocks.</p>
+
+<br/>
+
+<a name="flow_catch_throw"></a>
+<h3>Using <tt>catch</tt> and <tt>throw</tt></h3>
+
+<p>Because newLISP is a functional language, it uses no <tt>break</tt> or 
+<tt>return</tt> statements to exit functions or iterations. Instead, a 
+block or function can be exited at any point using the functions 
+<a href="#catch">catch</a> and <a href="#throw">throw</a>:</p>
+
+<pre>
+(define (foo x)
+    ...
+    (if condition (throw 123))
+    ...
+    456
+)
+									 
+;; if condition is true
+
+(catch (foo p))  <span class='arw'>&rarr;</span> 123
+									 
+;; if condition is not true
+									 
+(catch (foo p))  <span class='arw'>&rarr;</span> 456
+</pre>		
+
+<p>Breaking out of loops works in a similar way:</p>
+
+<pre>
+(catch
+    (dotimes (i N)
+        (if (= (foo i) 100) (throw i))))
+
+<span class='arw'>&rarr;</span> value of i when foo(i) equals 100
+</pre>		
+
+<p>The example shows how an iteration can be exited before executing <tt>N</tt> times.</p>
+
+<p>Multiple points of return can be coded using <a href="#throw">throw</a>:</p>
+
+<pre>
+(catch (begin
+    (foo1)
+    (foo2)
+    (if condition-A (throw 'x))
+    (foo3)
+    (if condition-B (throw 'y))
+    (foo4)
+    (foo5)))
+</pre>		
+
+<p>If <tt>condition-A</tt> is true, <tt>x</tt> will be returned from 
+the <tt>catch</tt> expression; if <tt>condition-B</tt> is true, the 
+value returned is <tt>y</tt>. Otherwise, the result from <tt>foo5</tt> 
+will be used as the return value.</p>
+
+<p>As an alternative to <a href="#catch">catch</a>, the <a href="#error-event">error-event</a> 
+function can be used to catch errors caused by faulty code or user-initiated exceptions.</p>
+
+<p>The <a href="#throw-error">throw-error</a> function may be used
+to throw user-defined errors.</p>
+
+<br/>
+
+<a name="flow_and_or"></a>
+<h3>Using <tt>and</tt> and <tt>or</tt></h3>
+
+<p>Using the logical functions <a href="#and">and</a> and 
+<a href="#or">or</a>, blocks of statements can be built 
+that are exited depending on the Boolean result of the enclosed functions:</p>
+
+<pre>
+(and
+    (func-a)
+    (func-b)
+    (func-c)
+    (func-d))
+</pre>		
+
+<p>The <a href="#and">and</a> expression will return as soon as one of the 
+block's functions returns <tt>nil</tt> or an <tt>()</tt> (empty list). 
+If none of the preceding functions causes an exit from the block, the 
+result of the last function is returned.</p>
+
+<p><a href="#or">or</a> can be used in a similar fashion:</p>
+
+<pre>
+(or
+    (func-a)
+    (func-b)
+    (func-c)
+    (func-d))
+</pre>		
+<p>
+The result of the <a href="#or">or</a> expression will be the first function 
+that returns a value which is <em>not</em> <tt>nil</tt> or <tt>()</tt>.
+</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="scoping"></a>
+<h2>15. Dynamic and lexical scoping</h2>
+
+<p>newLISP uses dynamic scoping <em>inside</em> contexts. A context is a lexically 
+closed namespace. In this way, parts of a newLISP program can live in different 
+namespaces taking advantage of <em>lexical scoping</em>.</p>
+
+<p>
+When the parameter symbols of a lambda expression are bound to its arguments, 
+the old bindings are pushed onto a stack. newLISP automatically restores the 
+original variable bindings when leaving the lambda function. </p>
+<p>
+The following example illustrates the <em>dynamic scoping</em> mechanism. 
+The text in bold is the output from newLISP:</p>
+
+<pre>
+&gt; (set 'x 1)
+<b>1</b>
+&gt; (define (f) x)
+<b>(lambda () x)</b>
+&gt; (f)
+<b>1</b>
+&gt; (define (g x) (f))
+<b>(lambda (x) (f))</b>
+&gt; (g 0)
+<b>0</b>
+&gt; (f)
+<b>1</b> 
+&gt; _
+</pre>	
+
+<p>The variable <tt>x</tt> is first set to <tt>1</tt>. But when <tt>(g 0)</tt> 
+is called, <tt>x</tt> is bound to <tt>0</tt> and <tt>x</tt> is reported 
+by <tt>(f)</tt> as <tt>0</tt> during execution of <tt>(g 0)</tt>. After 
+execution of <tt>(g 0)</tt>, the call to <tt>(f)</tt> will report <tt>x</tt> as <tt>1</tt> again.</p>
+
+<p>This is different from the <em>lexical scoping</em> mechanisms found in 
+languages like C or Java, where the binding of local parameters occurs inside 
+the function only. In lexically scoped languages like C, <tt>(f)</tt> would 
+always print the global bindings of the symbol <tt>x</tt> with <tt>1</tt>.
+</p>
+
+<p>Be aware that passing quoted symbols to a user-defined function causes a 
+name clash if the same variable name is used as a function parameter:</p>
+
+<pre>
+(define (inc-symbol x y) (inc (eval x) y))
+(set 'y 200)
+(inc-symbol 'y 123)  <span class='arw'>&rarr;</span> 246
+y                    <span class='arw'>&rarr;</span> 200  ; y is still 200
+</pre>		
+<p>
+Because the global <tt>y</tt> shares the same symbol as the function's second parameter, 
+<tt>inc-symbol</tt> returns 246 (123 + 123), leaving the global <tt>y</tt> unaffected. 
+Dynamic scoping's <em>variable capture</em> can be a disadvantage when passing symbol 
+references to user-defined functions. newLISP offers several methods to avoid variable
+capture.</p>
+
+<ul>
+<li>The function <a href="#args">args</a> can be used when passing symbols.</li>
+<li>One or more user-defined functions can be placed in their own namespace called 
+a <a href="#contexts">context</a>. A symbol name clash cannot occur when accessing 
+symbols and calling functions from <em>outside</em> of the defining context.</li>
+</ul>
+
+<p>
+Contexts should be used to group related functions when creating interfaces 
+or function libraries. This surrounds the functions with a lexical "fence", 
+thus avoiding variable name clashes with the calling functions.
+</p>
+<p>
+newLISP uses contexts for different forms of lexical scoping. See the 
+chapters <a href="#contexts">Contexts</a> and 
+<a href="#default_function">default functors</a> for more information.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="contexts"></a>
+<h2>16. Contexts</h2>
+
+<p>In newLISP, symbols can be separated into namespaces called <em>contexts</em>. 
+Each context has a private symbol table separate from all other contexts. Symbols 
+known in one context are unknown in others, so the same name may be used 
+in different contexts without conflict.</p>
+
+<p>Contexts are used to build modules of isolated variable and function definitions. 
+They also can be used to build dictionaries fo key values pairs. Contexts can be 
+copied and dynamically assigned to variables or passed as arguments by reference.
+Because contexts in newLISP have lexically separated namespaces, they allow programming 
+with <em>lexical scoping</em> and software object styles of programming.</p>
+
+<p>Contexts are identified by symbols that are part of the root or <tt>MAIN</tt> 
+context. Although context symbols are uppercased in this chapter, lowercase symbols 
+may also be used.</p>
+
+<p>In addition to context names, <tt>MAIN</tt> contains the symbols for built-in 
+functions and special symbols such as <tt>true</tt> and <tt>nil</tt>. The <tt>MAIN</tt> 
+context is created automatically each time newLISP is run. To see all the symbols 
+in MAIN, enter the following expression after starting newLISP:</p>
+
+<pre>
+(symbols)
+</pre>
+
+<p>To see all symbols in <tt>MAIN</tt> pointing to contexts:</p>
+
+<pre>
+(filter context? (map eval (symbols)))
+</pre>
+
+<p>To seel all context symbols in <tt>MAIN</tt> when <tt>MAIN</tt> is not the
+current context:</p>
+
+<pre>
+(filter context? (map eval (symbols MAIN)))
+</pre>
+
+<br/>
+
+<a name="context_rules"></a>
+<h3>Symbol creation in contexts</h3>
+
+<p>The following rules should simplify the process of understanding contexts by 
+identifying to which context the created symbols are being assigned.</p>
+
+<ol>
+<li>
+<p>newLISP first parses and translates each expression starting at the top
+level. All symbols are created during this phase. After the expression is 
+translated, it gets evaluated.</p>
+</li>
+
+<li>
+<p>A symbol is created when newLISP first <em>sees</em> it, while calling 
+the <a href="#load">load</a>, <a href="#sym">sym</a>, 
+or <a href="#eval-string">eval-string</a> functions. When newLISP reads 
+a source file, symbols are created <em>before</em> evaluation occurs. The
+<a href="#reader-event">reader-event</a> function can be used to inspect
+the expression after reading and translating but before evaluation. The
+<a href="#read-expr">read-expr</a> function can be used to read and translate
+newLISP source without evaluation.</p>
+</li>
+
+<li>
+<p>When an unknown symbol is encountered during code translation, 
+a search for its definition begins inside the current context. 
+Failing that, the search continues inside <tt>MAIN</tt> for a 
+built-in function, context, or global symbol. If no definition 
+is found, the symbol is created locally inside the current context.</p>
+</li>
+
+<li>
+<p>Once a symbol is created and assigned to a specific context, 
+it will belong to that context permanently or until it is deleted
+using the <a href="#delete">delete</a> function.</p>
+</li>
+
+<li>
+<p>When a user-defined function is evaluated, the context is switched 
+to the name-space which owns that symbol.</p>
+</li>
+
+<li><p>A context switch only influences symbol creation during 
+<a href="#load">load</a>, <a href="#sym">sym</a>,
+or <a href="#eval-string">eval-string</a>. 
+<a href="#load">load</a> by default loads into MAIN except
+ when context switches occur on the top level of the file loaded. 
+For better style, the context should always be specified when the functions 
+<a href="#sym">sym</a> and <a href="#eval-string">eval-string</a> 
+are used. A context switch should normally only be made on the top level of 
+a program, never inside a function.</p>
+</li>
+</ol>
+
+<br/>
+
+<a name="creating_contexts"></a>
+<h3>Creating contexts</h3>
+
+<p>Contexts can be created either by using the <a href="#context">context</a>
+function or via implicit creation. The first method is used when writing larger 
+portions of code belonging to the same context:</p>
+
+<pre>
+(context 'FOO)
+
+(set 'var 123)
+
+(define (func x y z)
+    ... )
+
+(context MAIN)
+</pre>		
+
+<p>If the context does not exist yet, the context symbol must be quoted.
+If the symbol is not quoted, newLISP assumes the symbol is a variable
+holding the symbol of the context to create. Because a context evaluates
+to itself, already existing contexts like MAIN do not require quoting.</p>
+
+<p>When newLISP reads the above code, it will read, then evaluate the first
+statement: <tt>(context 'FOO)</tt>. This causes newLISP to switch the namespace
+to FOO and the following symbols <tt>var</tt>, <tt>x</tt>, <tt>y</tt> and <tt>z</tt>
+will all be created in the FOO context when reading and evaluating the remaining
+expressions.</p>
+
+<p>A context symbol is protected against change. Once a symbol refers to a 
+context, it cannot be used for any other purpose, except when using 
+<a href="#delete">delete</a>.</p>
+
+<p>To refer to <tt>var</tt> or <tt>func</tt> from anywhere else outside the 
+FOO namespace, they need to be prefixed with the context name:</p>
+
+<pre>
+FOO:var <span class='arw'>&rarr;</span> 123
+
+(FOO:func p q r)
+</pre>	
+
+<p>Note, that in the above example only <tt>func</tt> belongs to the <tt>FOO</tt>
+name space the symbols <tt>p q r</tt> all are part of the current context
+from which the <tt>FOO:func</tt> call is made.</p>	
+
+<p>The <a href="#symbols">symbols</a> function is used to show all symbols
+belonging to a context:</p>
+
+<pre>
+(symbols FOO) <span class='arw'>&rarr;</span> (FOO:func FOO:var FOO:x FOO:y FOO:z)
+
+; or from inside the context symbols are shown without context prefix
+(context FOO) <span class='arw'>&rarr;</span> (func x y z)
+(sumbols)
+</pre>		
+
+<br/>
+
+<b>Implicitly creating contexts</b>
+
+<p>A context is implicitly created when referring to one that does not yet exist. 
+Unlike the <tt>context</tt> function, the context is not switched. The following 
+statements are all executed inside the <tt>MAIN</tt> context:</p>
+
+<pre>
+&gt; (set 'ACTX:var "hello")
+<b>"hello"</b>
+&gt; ACTX:var
+<b>"hello"</b>
+&gt; _
+</pre>		
+
+<p>Note that only the symbols prefixed with their context name will be part
+of the context:</p>
+
+<pre>
+(define (ACTX:foo x y) 
+    (+ x y))
+</pre>		
+
+<p>When above code is loaded in MAIN only <tt>foo</tt> will be part of 
+<tt>ACTX</tt>. The symbols <tt>x</tt> and <tt>y</tt> will still be part
+of <tt>MAIN</tt>. To make all locals of <tt>ACTX:foo</tt> members of
+the <tt>ACTX</tt> context, they would either have to be prefixed with
+<tt>ACTX</tt>, or the whole funtion must be preceded by a context
+switch satement at the top level:</p>
+
+<pre>
+(context 'ACTX)
+(define (foo x y)
+    (+ x y)
+(context MAIN
+
+;; above same as
+
+(define (ACTX:foo ACTX:x ACTX:y)
+    (+ ACTX:x ACTX:y))
+</pre>
+
+<br/>
+
+<b>Loading module files</b>
+<br/>
+
+<p>When loading source files on the command-line with <a href="#load">load</a>, 
+or when executing the functions <a href="#eval-string">eval-string</a> or 
+<a href="#sym">sym</a>, the <tt>context</tt> function tells the newLISP source
+code reader in which namespace to put all of the symbols and definitions:</p>
+
+<pre>
+;;; file MY_PROG.LSP
+;;
+;; everything from here on goes into GRAPH
+(context 'GRAPH)
+				 
+(define (draw-triangle x y z)
+    (&hellip;))
+
+(define (draw-circle)
+    (&hellip;))
+									 
+;; show the runtime context, which is GRAPH
+(define (foo)
+    (context))
+									 
+;; switch back to MAIN
+(context 'MAIN)
+				 
+;; end of file					
+</pre>		
+
+<p>The <tt>draw-triangle</tt> and <tt>draw-circle</tt> functions &mdash; along 
+with their <tt>x</tt>, <tt>y</tt>, and <tt>z</tt> parameters &mdash; are now 
+part of the <tt>GRAPH</tt> context. These symbols are known only to <tt>GRAPH</tt>. 
+To call these functions from another context, prefix them with <tt>GRAPH:</tt></p>
+
+<pre>
+(GRAPH:draw-triangle 1 2 3)
+(GRAPH:foo)  <span class='arw'>&rarr;</span> GRAPH										
+</pre>		
+
+<p>The last statement shows how the runtime context has changed to 
+<tt>GRAPH</tt> (function <tt>foo</tt>'s context).</p>
+
+<p>A symbol's name and context are used when comparing symbols from different 
+contexts. The <a href="#term">term</a> function can be used to extract the term 
+part from a fully qualified symbol.</p>
+
+<pre>
+;; same symbol name, but in different context
+(= 'A:val 'B:val)                    <span class='arw'>&rarr;</span> nil
+(= (term 'A:val) (term 'B:val))      <span class='arw'>&rarr;</span> true
+(= (prefix 'A:val) (prefix 'B:val))  <span class='arw'>&rarr;</span> nil
+</pre>		
+
+<p>Note: The symbols in above example are quoted with a <tt>'</tt> (single quote) 
+because we are interested in the symbol itself, not in the contents of the symbol.</p>
+
+<br/>
+
+<a name="scope_global"></a>
+<h3>Global scope</h3>
+
+<p>By default, only built-in functions and symbols like <tt>nil</tt> and
+<tt>true</tt> are visible inside contexts other than <tt>MAIN</tt>. To make a symbol 
+visible to every context, use the <a href="#global">global</a> function:</p>
+
+<pre>
+(set 'aVar 123) <span class='arw'>&rarr;</span> 123
+(global 'aVar)  <span class='arw'>&rarr;</span> aVar
+
+(context 'FOO)  <span class='arw'>&rarr;</span> FOO
+
+aVar            <span class='arw'>&rarr;</span> 123
+</pre>		
+
+<p>Without the <tt>global</tt> statement, the second <tt>aVar</tt> would have 
+returned <tt>nil</tt> instead of <tt>123</tt>. If <tt>FOO</tt> had a previously 
+defined symbol (<tt>aVar</tt> in this example) <em>that</em> symbol's value 
+&mdash; and not the global's &mdash; would be returned instead. Note that only 
+symbols from the <tt>MAIN</tt> context can be made global.</p>
+
+<p>Once it is made visible to contexts through the <a href="#global">global</a> function, 
+a symbol cannot be hidden from them again.</p>
+
+<br/>
+
+<a name="protection"></a>
+<h3>Symbol protection</h3>
+
+<p>By using the <a href="#constant">constant</a> function, symbols can be both set 
+and protected from change at the same time:</p>
+
+<pre>
+&gt; (constant 'aVar 123)  <span class='arw'>&rarr;</span> 123
+&gt; (set 'aVar 999)
+<span class='err'>ERR: symbol is protected in function set : aVar</span>
+&gt;_
+</pre>		<p>
+	A symbol needing to be both a constant and a global can be defined simultaneously:
+</p>
+<pre>
+(constant (global 'aVar) 123)
+</pre>		
+
+<p>In the current context, symbols protected by <tt>constant</tt> can be overwritten 
+by using the <tt>constant</tt> function again. This protects the symbols from 
+being overwritten by code in other contexts.</p>
+
+<br/>
+
+<a name="overwrite"></a>
+<h3>Overwriting global symbols and built-ins</h3>
+
+<p>Global and built-in function symbols can be overwritten inside a
+context by prefixing them with their <em>own</em> context symbol:</p>
+
+<pre>
+(context 'Account)
+
+(define (Account:new &hellip;)
+    (&hellip;))
+
+(context 'MAIN)
+</pre>		
+
+<p>In this example, the built-in function <a href="#new">new</a> is overwritten by 
+<tt>Account:new</tt>, a different function that is private to the <tt>Account</tt> context.
+</p>
+
+<br/>
+
+<a name="context_vars"></a>
+<h3>Variables containing contexts</h3>
+
+<p>Variables can be used to refer to contexts:</p>
+
+<pre>
+(set 'FOO:x 123)
+
+(set 'ctx FOO)    <span class='arw'>&rarr;</span> FOO
+
+ctx:x             <span class='arw'>&rarr;</span> 123
+
+(set 'ctx:x 999)  <span class='arw'>&rarr;</span> 999
+
+FOO:x             <span class='arw'>&rarr;</span> 999
+</pre>		
+
+<p>
+Context variables are useful when writing functions, which need to refer to
+different contexts during runtime or use contexts which do not exist during
+definition:</p>
+
+<pre>
+(define (update ctx val)
+    (set 'ctx:sum val)
+    (ctx:func 999)
+)
+
+(context 'FOO)
+(define (func x)
+    (println "=&gt;" x))
+(context MAIN)
+</pre>		
+
+<p>The following shows a terminal session using above definitions. The program
+output is shown in bold-face:</p>
+
+<pre>
+<b>&gt;</b> (update FOO 123)
+<b>=&gt; 999</b>
+
+<b>&gt;</b> FOO:sum
+<b>123</b>
+<b>&gt;</b>
+</pre>		
+
+<p>The same one function <tt>update</tt> can display different behavior depending
+on the context passed as first parameter. </p>
+
+<br/>
+
+<a name="sequence_creating"></a>
+<h3>Sequence of creating or loading contexts</h3>
+
+<p>The sequence in which contexts are created or loaded can lead to unexpected 
+results. Enter the following code into a file called <tt>demo</tt>:</p>
+
+<pre>
+;; demo - file for loading contexts
+(context 'FOO)
+(set 'ABC 123)
+(context MAIN)
+
+(context 'ABC)
+(set 'FOO 456)
+(context 'MAIN)
+</pre>		
+
+<p>Now load the file into the newlisp shell:</p>
+
+<pre>
+&gt; (load "demo")
+<span class='err'>ERR: symbol is protected in function set : FOO</span>
+&gt; _
+</pre>		
+
+<p>Loading the file causes an error message for <tt>FOO</tt>, but not 
+for <tt>ABC</tt>. When the first context <tt>FOO</tt> is loaded, the 
+context <tt>ABC</tt> does not exist yet, so a local variable <tt>FOO:ABC</tt> 
+gets created. When <tt>ABC</tt> loads, <tt>FOO</tt> already exists as a global 
+protected symbol and will be correctly flagged as protected.</p>
+
+<p><tt>FOO</tt> could still be used as a local variable in the <tt>ABC</tt> 
+context by explicitly prefixing it, as in <tt>ABC:FOO</tt>.</p>
+
+<br/>
+
+<a name="context_modules"></a>
+<h3>Contexts as programming modules</h3>
+
+<p>Contexts in newLISP are mainly used for partitioning source into 
+modules. Because each module lives in a different namespace, modules
+are lexically separated and the names of symbols cannot clash with
+identical names in other modules.</p>
+
+<p>The <a href="http://newlisp.org/code/modules/">modules</a>, which are
+part of the newLISP distribution, are a good example of how to put related
+ functions into a module file, and how to document modules using
+ the <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a> utility.</p> 
+
+<p>For best programming practice, a file should only contain one module and 
+the filename should be similar if not identical to the context name used:</p>
+
+<pre>
+;; file db.lsp, commonly used database functions
+
+(context 'db)
+
+;; Variables used throughout this namespace
+
+(define db:handle)
+(define db:host "http://localhost")
+
+;; Constants
+
+(constant 'Max_N 1000000)
+(constant 'Path "/usr/data/")
+
+;; Functions
+
+(define (db:open ... )
+    ... )
+
+(define (db:close ... )
+    ... )
+
+(define (db:update ... )
+    ... )
+</pre>
+
+
+<p>The example shows a good practice of predefining variables, which are global
+inside the namespace, and defining as constants the variables that will not change.</p>
+
+<p>If a file must contain more than one context, then the end of the context
+should be marked with a switch back to <tt>MAIN</tt>:</p>
+
+<pre>
+;; Multi context file multi.lsp
+
+(context 'A-ctx)
+...
+(context MAIN)
+
+(context 'B-ctx)
+...
+(context MAIN)
+
+(context 'C-ctx)
+...
+(context MAIN)
+</pre>
+
+<p>In any case <a href="#load">load</a> will always switch back to the context
+from where it was called.</p>
+
+<br/>
+
+<a name="context_data"></a>
+<h3>Contexts as data containers</h3>
+
+<p>Contexts are frequently uses as data containers, e.g. for configuration data:</p>
+
+<pre>
+;; Config.lsp - configuration setup
+
+(context 'Config)
+
+(set 'user-name "admin")
+(set 'password "secret")
+(set 'db-name "/usr/data/db.lsp")
+...
+
+;; eof
+</pre>
+
+<p>Loading the <tt>Config</tt> namespace will now load a whole variable set into
+memory at once:</p>
+
+<pre>
+(load "Config.lsp")
+
+(set 'file (open Config:db-name "read"))
+...
+...
+</pre>
+
+<p>In a similar fashion a whole data set can be saved:</p>
+
+<pre>
+(save "Config.lsp" 'Config)
+</pre>
+
+<p>Read more about this in the section <a href="#serializing">Serializing contexts</a>.</p>
+
+<br/>
+
+<a name="loading_contexts"></a>
+<h3>Loading and declaring contexts</h3>
+
+<p>Module files are loaded using the <a href="#load">load</a> function.
+If a programming project contains numerous modules that refer
+to each other, they can be pre-declared to avoid problems due to context forward 
+references that can occur before the loading of that context.</p>
+
+<pre>
+;; pre-declaring contexts, finish with Main to return
+(map context '(Utilities Config Acquisition Analysis SysLog MAIN))
+
+;; loading context module files
+(load "Utilities.lsp" "Acquisition.lsp")
+(load "http://192.168.1.34/Config.lsp") ; load module from remote location
+(load "Analysis.lsp" "SysLog.lsp")
+
+(define (run)
+    ... )
+
+(run)
+
+;; end of file </pre>
+
+<p>When pre-declaring and loading modules as shown in the example, the sequence
+of declaration or loading can be neglected. All forward references to variables
+and definitions in modules not loaded yet will be translated correctly. Wrong
+usage of a context symbol will result in an error message before that context
+is loaded.</p>
+
+<p>Modules not starting with a context switch are always loaded into <tt>MAIN</tt>
+except when the <a href="#load">load</a> statement specifies a target context
+as the last parameter. The <a href="#load">load</a> function can take <tt>URL</tt>s
+to load modules from remote locations, via <tt>HTTP</tt>.</p>
+
+<p>The current context after the <a href="#load">load</a> statement will always be 
+the same as before the <a href="#load">load</a>.</p>
+
+<br/>
+
+<a name="serializing"></a>
+<h3>Serializing contexts</h3>
+
+<p>Serialization makes a software object <em>persistent</em>
+by converting it into a character stream,
+which is then saved to a file or string in memory.
+In newLISP, anything referenced by a symbol can be serialized to a file
+by using the <a href="#save">save</a> function.
+Like other symbols, contexts are saved just by using their names:
+</p>
+
+<pre>
+(save "mycontext.lsp" 'MyCtx)              ; save MyCtx to mycontext.lsp
+
+(load "mycontext.lsp")                     ; loads MyCtx into memory
+
+(save "mycontexts.lsp" 'Ctx1 'Ctx2 'Ctx3)  ; save multiple contexts at once
+</pre>		
+
+<p>
+For details, see the functions <a href="#save">save</a> (mentioned above)
+and <a href="#source">source</a> (for serializing to a newLISP string).
+</p>
+
+<br/>		
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+
+<a name="default_function"></a>
+<h2>17. The context default functor</h2>
+
+<p>A <em>default functor</em> or <em>default function</em>
+is a symbol or user-defined function or macro
+with the same name as its namespace. When the context is used
+as the name of a function or in the functor position of an s-expression,
+newLISP executes the default function.</p>
+
+<pre>
+;; the default function
+
+(define (Foo:Foo a b c) (+ a b c))
+
+(Foo 1 2 3)  <span class='arw'>&rarr;</span> 6
+</pre>
+
+<p>If a default function is called from a context other than <tt>MAIN</tt>,
+the context must already exist or be declared with a <em>forward declaration</em>,
+which creates the context and the function symbol:</p>
+
+<pre>
+;; forward declaration of a default function
+(define Fubar:Fubar)    
+
+(context 'Foo)
+(define (Foo:Foo a b c)
+    &hellip;
+    (Fubar a b)         ; forward reference
+    (&hellip;))         ; to default function
+
+(context MAIN)
+
+;; definition of previously declared default function
+
+(context 'Fubar)
+(define (Fubar:Fubar x y)
+    (&hellip;))
+
+(context MAIN)
+</pre>		
+
+<p>Default functions work like global functions,
+but they are lexically separate from the context in which they are called.</p>
+
+<p>Like a lambda or lambda-macro function, default functions can be used 
+with <a href="#map">map</a> or <a href="#apply">apply</a>.
+</p>
+
+<br/>
+
+<a name="func_memory"></a>
+<h3>Functions with memory</h3>
+
+<p>A default function  can update the lexically isolated static variables
+contained inside its namespace:</p>
+
+<pre>
+;; a function with memory
+
+(define (Gen:Gen x)
+    (if Gen:acc
+        (inc Gen:acc x)
+        (setq Gen:acc x)))
+
+(Gen 1)  <span class='arw'>&rarr;</span> 1
+(Gen 1)  <span class='arw'>&rarr;</span> 2
+(Gen 2)  <span class='arw'>&rarr;</span> 4
+(Gen 3)  <span class='arw'>&rarr;</span> 7
+
+gen:acc  <span class='arw'>&rarr;</span> 7
+</pre>		
+
+<p>The first time the <tt>Gen</tt> function is called,
+its accumulator is set to the value of the argument.
+Each successive call increments <tt>Gen</tt>'s accumulator
+by the argument's value.</p>
+
+<p>The definition of <tt>Gen:Gen</tt> shows, how a function is put in its own namespace 
+without using the surrounding <tt>(context 'Gen)</tt> and <tt>(context MAIN)</tt> 
+statements. In that case only symbols qualified by the namespace prefix will 
+end up in the <tt>Gen</tt> context. In the above example the variable 
+<tt>x</tt> is still part of <tt>MAIN</tt>.</p>
+
+<br/>
+
+<a name="hash"></a>
+<h3>Hash functions and dictionaries</h3>
+
+<p>There are several functions that can be used to place symbols into namespace contexts. 
+When using dictionaries as simple hash-like collections of variable &rarr; value pairs, use the 
+uninitialized <a href="#default_function">default functor</a>:</p>
+
+<pre>
+(define Myhash:Myhash) ; create namespace and default functor
+
+; or as a safer alternative
+
+(new Tree 'MyHash) ; create from built-in template
+</pre>		
+
+<p>Either method can be used to make the  <tt>MyHash</tt> dictionary space and default
+functor. The second method is safer, as it will protect the default functor 
+<tt>MyHash:MyHash</tt> from change. The <em>default functor</em> in a namespace must 
+contain <tt>nil</tt> to be used as a dictionary. Creating key-value pairs and retrieving 
+a value is easy:</p>
+
+<pre>
+(Myhash "var" 123) ; create and set variable/value pair
+
+(Myhash "var")  <span class='arw'>&rarr;</span> 123 ; retrieve value
+
+; keys can be integers and will be converted to strings internally
+
+(Myhash 456 "hello")
+
+(Myhash 456)    <span class='arw'>&rarr;</span> "hello"
+</pre>		
+
+<p>Symbol variables created this way can contain spaces or other characters
+normally not allowed in newLISP symbol names:</p>
+
+<pre>
+(define Foo:Foo)
+; or to protect the default functor from change
+; (new Tree 'Foo)
+
+(Foo "John Doe" 123)         <span class='arw'>&rarr;</span> 123
+(Foo "#1234" "hello world")  <span class='arw'>&rarr;</span> "hello world"
+(Foo "var" '(a b c d))       <span class='arw'>&rarr;</span> (a b c d)
+
+(Foo "John Doe")  <span class='arw'>&rarr;</span> 123
+(Foo "#1234")     <span class='arw'>&rarr;</span> "hello world"
+(Foo "var")     <span class='arw'>&rarr;</span> (a b c d)
+</pre>		
+
+<p>An entry which doesn't exist will return <tt>nil</tt>:</p>
+
+<pre>
+(Foo "bar")    <span class='arw'>&rarr;</span> nil
+</pre>		
+
+<p>Setting an entry to <tt>nil</tt> will effectively delete it from
+the namespace.</p>
+
+<p>An association list can be generated from the contents of the namespace:</p>
+
+<pre>
+(Foo) <span class='arw'>&rarr;</span> (("#1234" "hello world") ("John Doe" 123) ("var" (a b c d)))
+</pre>		
+
+<p>Entries in the dictionary can also be created from a list:</p>
+
+<pre>
+(Foo '(("#1234" "hello world") ("John Doe" 123) ("var" (a b c d))) <span class='arw'>&rarr;</span> Foo
+</pre>		
+
+<p>The list can also be used to iterate through the sorted key -&gt; value pairs:</p>
+
+<pre>
+(dolist (item (Foo)) (println (item 0) " -&gt; " (item 1)))
+
+<b>#1234 -&gt; hello world
+John Doe -&gt; 123
+var -&gt; (a b c d)</b>
+</pre>
+
+<p>Like many built-in functions hash expressions return a reference to their content which 
+can be modified directly:</p>
+
+<pre>
+(pop (Foo "var")) <span class='arw'>&rarr;</span> a
+
+(Foo "var") <span class='arw'>&rarr;</span> (b c d)
+
+(push 'z (Foo "var")) <span class='arw'>&rarr;</span> (z b c d)
+
+(Foo "var") <span class='arw'>&rarr;</span> (z b c d)
+</pre>
+
+<p>When setting hash values the anaphoric system variable <tt>$it</tt>
+can be used to refer to the old value when setting the new:</p>
+
+<pre>
+(Foo "bar" "hello world")
+
+(Foo "bar" (upper-case $it))
+
+(Foo "bar") <span class='arw'>&rarr;</span> "HELLO WORLD"
+</pre>
+
+<p>Hash values also can be modified using <a href="#setf">setf</a>:</p>
+
+<pre>
+(Foo "bar" 123)        <span class='arw'>&rarr;</span> 123
+
+(setf (Foo "bar") 456) <span class='arw'>&rarr;</span> 456
+
+(Foo "bar")            <span class='arw'>&rarr;</span> 456
+</pre>
+
+<p>But supplying the value as a second parameter to the hash functions 
+is shorter to write and faster.</p>
+
+<p>Dictionaries can easily be saved to a file and reloaded later:</p>
+
+<pre>
+; save dictionary
+(save "Foo.lsp" 'Foo)
+
+; load dictionary
+(load "Foo.lsp")
+</pre>	
+
+<p>Internally the key strings are created and stored as symbols in the
+hash context. All key strings are prepended with an <tt>_</tt> 
+underscore character.  This protects against overwriting the default symbol and
+symbols like <tt>set</tt> and <tt>sym</tt>, which are needed when loading
+a hash namespace from disk or over <tt>HTTP</tt>. Note the following
+difference:</p>
+
+<pre>
+(Foo) <span class='arw'>&rarr;</span> (("#1234" "hello world") ("John Doe" 123) ("var" (a b c d)))
+
+(symbols Foo) <span class='arw'>&rarr;</span> (Foo:Foo Foo:_#1234 Foo:_John Doe Foo:_var)
+</pre>	
+
+<p>In the first line hash symbols are shown as strings without the preceding
+underscore characters. The second line shows the internal form of the symbols with
+prepended underscore characters.</p>
+
+
+<p>For a more detailed introduction to <em>namespaces</em>, see the chapter on
+<a href="#contexts">Contexts</a>.
+</p>
+
+<br/>
+
+<a name="pass_big"></a>
+<h3>Passing data by reference</h3>
+
+<p>A <a href="#default_function">default functor</a> can also be used to hold data. 
+If this data contains a list or string, the context name can be used as a reference to 
+the data:</p>
+
+<pre>
+;; the default functor for holding data
+
+(define Mylist:Mylist '(a b c d e f g))
+
+(Mylist 3) <span class='arw'>&rarr;</span> d 
+
+(setf (Mylist 3) 'D) <span class='arw'>&rarr;</span> D
+
+Mylist:Mylist <span class='arw'>&rarr;</span> (a b c D e f g)
+
+;; access list or string data from a default functor
+
+(first Mylist) <span class='arw'>&rarr;</span> a
+
+(reverse Mylist) <span class='arw'>&rarr;</span> (g f e D c b a)
+
+(set 'Str:Str "acdefghijklmnop") 
+
+(upper-case Str) <span class='arw'>&rarr;</span> "ACDEFGHIJKLMNOP"
+</pre>
+
+<p>Most of the time, newLISP passes parameters by <em>value copy</em>.
+This poses a potential problem when passing large lists or strings
+to user-defined functions or macros. Strings and lists, which are packed 
+in a namespace using default functors, are passed automatically by reference:
+</p>
+
+<pre>
+;; use a default functor to hold a list
+
+(set 'Mydb:Mydb (sequence 1 100000))
+
+(define (change-db obj idx value)
+    (setf (obj idx) value))
+
+; pass by context reference
+(change-db Mydb 1234 "abcdefg")
+
+(Mydb 1234)  <span class='arw'>&rarr;</span> "abcdefg"
+</pre>		
+
+<p> Any argument of a built-in function calling for either a list or a string 
+&mdash; but no other data type &mdash; can receive data passed by reference. 
+Any user-defined function can take either normal variables, or can take a context 
+name for passing a reference to the default functor containing a list or string.</p>
+
+<p>Note that on lists with less than about 100 elements or strings of less than 
+about 50000 characters, the speed difference between reference and value passing is 
+negligible. But on bigger data objects, differences in both speed and memory usage 
+between reference and value passing can be significant.</p>
+
+<p>Built-in and user-defined functions are suitable for <u>both</u> types of arguments, 
+but when passing context names, data will be passed by reference.</p>
+
+<p>Quoted symbols can also be used to pass data by reference, but this method
+has disadvantages:</p>
+
+<pre>
+(define (change-list aList) (push 999 (eval aList)))
+
+(set 'data '(1 2 3 4 5))
+
+; note the quote ' in front of data
+(change-list 'data)  <span class='arw'>&rarr;</span> (999 1 2 3 4 5)
+
+data  <span class='arw'>&rarr;</span>  (999 1 2 3 4 5)
+</pre>
+
+<p>Although this method is simple to understand and use, it poses the potential 
+problem of <em>variable capture</em> when passing the same symbol as used  
+as a function parameter:</p>
+
+<pre>
+;; pass data by symbol reference
+
+&gt; (set 'aList '(a b c d))
+(a b c d)
+&gt; (change-list 'aList)
+
+<span class='err'>ERR: list or string expected : (eval aList)
+called from user defined function change-list</span>
+&gt; 
+</pre>
+
+<p>At the beginning of the chapter it was shown how to package data 
+in a name-space using a default functor. Not only the default 
+functor but any symbol in  context can be used to hold data. The 
+disadvantage is that the calling function must have knowledge about
+the symbol being used:</p>
+
+<pre>
+;; pass data by context reference
+
+(set 'Mydb:data (sequence 1 100000))
+
+(define (change-db obj idx value)
+    (setf (obj:data idx) value))
+
+(change-db Mydb 1234 "abcdefg")
+
+(nth 1234 Mydb:data)   <span class='arw'>&rarr;</span> "abcdefg"
+; or
+(Mydb:data 1234)   <span class='arw'>&rarr;</span> "abcdefg"
+</pre>
+
+<p>
+The function receives the namespace in the variable <tt>obj</tt>,
+but it must have the knowledge that the list to access is contained
+in the <tt>data</tt> symbol of that namespace (context).</p>
+
+<br/>
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+
+<a name="foop"></a>
+<h2>18. Functional object-oriented programming</h2>
+
+<p>Functional-object oriented programming (FOOP) is based on the following 
+five principles:</p>
+
+<ul>
+<li><p>Class attributes and methods are stored in the namespace of the object class.</p></li>
+<li><p>The namespace default functor holds the object constructor method.</p></li>
+<li><p>An object is constructed using a list, the first element of which is the 
+context symbol describing the class of the object.</p></li>
+<li><p>Polymorphism is implemented using the <a href="#colon"><tt>:</tt> (colon)</a>
+operator, which selects the appropriate class from the object.</p></li>
+<li><p>A target object inside a class-method function is accessed via the <a href="#self">self</a>
+function.</p></li>
+</ul>
+
+<p>The following paragraphs are a short introduction to FOOP as designed by 
+<em>Michael Michaels</em> from <a href="http://neglook.com">neglook.com</a>.</p>
+
+
+<br/>
+
+<a name="newlisp_classes"></a>
+<h3>FOOP classes and constructors</h3>
+
+<p>Class attributes and methods are stored in the namespace of the object class. 
+No object instance data is stored in this namespace/context. Data variables in
+the class namespace only describe the class of objects as a whole but don't contain
+any object specific information. A generic FOOP object constructor can be used
+as a template for specific object constructors when creating new object classes
+with <tt>new</tt>:</p>
+
+<pre>
+; built-in generic FOOP object constructor
+(define (Class:Class) 
+    (cons (context) (args)))
+
+; create some new classes
+
+(new Class 'Rectangle)   <span class='arw'>&rarr;</span> Rectangle
+(new Class 'Circle)      <span class='arw'>&rarr;</span> Circle
+
+; create some objects using the default constructor
+
+(set 'rect (Rectangle 10 20))   <span class='arw'>&rarr;</span> (Rectangle 10 20)
+(set 'circ (Circle 10 10 20))   <span class='arw'>&rarr;</span> (Circle 10 10 20)
+
+; create a list of objects
+; building the list using the list function instead of assigning
+; a quoted list ensures that the object constructors are executed
+
+(set 'shapes (list (Circle 5 8 12) (Rectangle 4 8) (Circle 7 7 15)))
+<span class='arw'>&rarr;</span> ((Circle 5 8 12) (Rectangle 4 8) (Circle 7 7 15))
+</pre>
+
+<p>The generic FOOP constructor is already pre-defined, and FOOP
+code can start with <tt>(new Class ...)</tt> statements right away.</p>
+
+<p>As a matter of style, new classes should only be created in the MAIN context. 
+If creating a new class while in a different namespace, the new class name 
+must be prefixed with MAIN and the statement should be on the top-level:</p>
+
+<pre>
+(context 'Geometry)
+
+(new Class 'MAIN:Rectangle)
+(new Class 'MAIN:Circle)
+
+...
+</pre>
+
+<p>Creating the namespace classes using <a href="#new">new</a> reserves the class 
+name as a context in newLISP and facilitates forward references. At the same time, 
+a simple constructor is defined for the new class for instantiating new objects. 
+As a convention, it is recommended to start class names in upper-case to signal that 
+the name stands for a namespace.</p>
+
+<p>In some cases, it may be useful to overwrite the simple constructor, that was 
+created during class creation, with <tt>new</tt>:</p>
+
+<pre>
+; overwrite simple constructor 
+(define (Circle:Circle x y radius)
+    (list Circle x y radius))
+</pre>
+
+<p>A constructor can also specify defaults:</p>
+
+<pre>
+; constructor with defaults
+(define (Circle:Circle (x 10) (y 10) (radius 3))
+    (list Circle x y radius))
+
+(Circle) <span class='arw'>&rarr;</span> (Circle 10 10 3)
+</pre>
+
+<p>In many cases the constructor as created when using <tt>new</tt> is sufficient and overwriting
+it is not necessary.</p>
+
+<br/>
+
+<a name="newlisp_objects"></a>
+<h3>Objects and associations</h3>
+
+<p>FOOP represents objects as lists. The first element of the list indicates the 
+object's kind or class, while the remaining elements contain the data. The following 
+statements define two <em>objects</em> using any of the constructors defined previously:</p>
+
+<pre>
+(set 'myrect (Rectangle 5 5 10 20)) <span class='arw'>&rarr;</span> (Rectangle 5 5 10 20)
+(set 'mycircle (Circle 1 2 10)) <span class='arw'>&rarr;</span> (Circle 1 2 10)
+</pre>
+
+<p>An object created is identical to the function necessary to create it (hence FOOP). 
+Nested objects can be created in a similar manner:</p>
+
+<pre>
+; create classes
+(new Class 'Person)
+(new Class 'Address)
+(new Class 'City)
+(new Class 'Street)
+
+; create an object containing other objects
+(set 'JohnDoe (Person (Address (City "Boston") (Street 123 "Main Street"))))
+<span class='arw'>&rarr;</span> (Person (Address (City "Boston") (Street 123 "Main Street")))
+</pre>
+
+<p>Objects in FOOP not only resemble functions they also resemble associations. The
+<a href="#assoc">assoc</a> function can be used to access object data by name:</p>
+
+<pre>
+(assoc Address JohnDoe) <span class='arw'>&rarr;</span> (Address (City "Boston") (Street 123 "Main Street"))
+
+(assoc (list Address Street) JohnDoe) <span class='arw'>&rarr;</span> (Street 123 "Main Street")
+</pre>
+
+<p>In a similar manner <a href="#setf">setf</a> together with <a href="#assoc">assoc</a> 
+can be used to modify object data:</p>
+
+<pre>
+(setf (assoc (list Address Street) JohnDoe) '(Street 456 "Main Street"))
+<span class='arw'>&rarr;</span> (Street 456 "Main Street")
+</pre>
+
+<p>The street number has been changed from <tt>123</tt> to <tt>456</tt>.</p>
+
+<p>Note that in none of the <tt>assoc</tt> statements <tt>Address</tt> and <tt>Street</tt>
+need to carry quotes. The same is true in the set statement: 
+<tt>(set 'JohnDoe (Person ...))</tt> for the data part assigned. In both cases we do not 
+deal with symbols or lists of symbols but rather with contexts and FOOP objects which 
+evaluate to themselves. Quoting would not make a difference.</p>
+
+<br/>
+
+<a name="colon_operator"></a>
+<h3>The colon <tt>:</tt> operator and polymorphism</h3>
+
+<p>In newLISP, the colon character <tt>:</tt> is primarily used to
+connect the context symbol with the symbol it is qualifying. 
+Secondly, the colon function is used in FOOP to resolve a function's 
+application <em>polymorphously</em>.</p>
+
+<p>The following code defines two functions called <tt>area</tt>, 
+each belonging to a different namespace / class. Both functions could
+have been defined in different modules for better separation, but in 
+this case they are defined in the same file and without bracketing 
+<a href="#context">context</a> statements. Here, only
+the symbols <tt>rectangle:area</tt> and <tt>circle:area</tt> belong
+to different namespaces. The local parameters <tt>p</tt>, <tt>c</tt>, 
+<tt>dx</tt>, and <tt>dy</tt> are all part of <tt>MAIN</tt>,
+but this is of no concern.</p>
+
+<pre>
+;; class methods for rectangles
+
+(define (Rectangle:area)
+    (mul (self 3) (self 4)))
+
+(define (Rectangle:move dx dy)
+    (inc (self 1) dx) 
+    (inc (self 2) dy))
+
+;; class methods for circles
+
+(define (Circle:area)
+    (mul (pow (self 3) 2) (acos 0) 2))
+
+(define (Circle:move dx dy)
+    (inc (self 1) dx) 
+    (inc (self 2) dy))
+</pre>
+
+<p>By prefixing the <tt>area</tt> or <tt>move</tt> symbol with the
+<a href="#colon"><tt>:</tt> (colon)</a>, 
+we can call these functions for each class of object. Although there is no space 
+between the colon and the symbol following it, newLISP parses them as distinct entities. 
+The colon works as a function that processes parameters:</p> 
+
+<pre>
+(:area myrect) <span class='arw'>&rarr;</span> 200 ; same as (: area myrect)
+(:area mycircle) <span class='arw'>&rarr;</span> 314.1592654 ; same as (: area mycircle)
+
+;; map class methods uses curry to enclose the colon operator and class function
+
+(map (curry :area) (list myrect mycircle)) <span class='arw'>&rarr;</span> (200 314.1592654)
+
+(map (curry :area) '((Rectangle 5 5 10 20) (Circle 1 2 10))) <span class='arw'>&rarr;</span> (200 314.1592654) 
+
+
+;; objects are mutable (since v10.1.8)
+
+(:move myrect 2 3)
+(:move mycircle 4 5) 
+
+myrect    <span class='arw'>&rarr;</span> (Rectangle 7 8 10 20)
+mycircle  <span class='arw'>&rarr;</span> (Circle 5 7 10)
+</pre>
+
+<p>In this example, the correct qualified symbol (<tt>rectangle:area</tt> or 
+<tt>circle:area</tt>) is constructed and applied to the object data based on 
+the symbol following the colon and the context name (the first element of the object list).</p>
+
+<p>Note, that although the caller specifies the called target object of the call,
+the method definition does not include the object as a parameter. When writing 
+functions to modify FOOP objects, instead the function <a href="#self">self</a>
+is used to access and index the object.</p>
+
+<br/>
+<a name="structure_foop"></a>
+<h3>Structuring a larger FOOP program</h3>
+
+<p>In all the previous examples, class function methods where directly
+written into the MAIN context namespace. This works and is adequate 
+for smaller programs written by just one programmer. When writing larger 
+systems, all the methods for one class should be surrounded by 
+<a href="#context">context</a> statements to provide better isolation 
+of parameter variables used and to create an isolated location for potential
+class variables.</p>
+
+<p>Class variables could be used in this example as a container for
+lists of objects, counters or other information specific to a class
+but not to a specific object. The following code segment rewrites the 
+example from above in this fashion.</p>
+
+<p>Each context / namespace could go into an extra file with the same
+name as the class contained. Class creation, startup code and the main
+control code is in a file <tt>MAIN.lsp</tt>:</p>
+
+<pre>
+; file MAIN.lsp - declare all classes used in MAIN
+
+(new Class 'Rectangle)
+(new Class 'Circle)
+
+; start up code
+
+(load "Rectangle.lsp")
+(load "Circle.lsp")
+
+; main control code
+
+; end of file
+</pre>
+
+<p>Each class is in a separate file:</p>
+
+<pre>
+; file Rectangle.lsp - class methods for rectangles
+
+(context Rectangle)
+
+(define (Rectangle:area)
+(mul (self 3) (self 4)))
+
+(define (Rectangle:move dx dy)
+(inc (self 1) dx) 
+(inc (self 2) dy))
+
+; end of file
+</pre>
+
+<p>And the <tt>Circle</tt> class file follows:</p>
+
+<pre>
+; file Circle.lsp - class methods for circles
+
+(context Circle)
+
+(define (Circle:area)
+    (mul (pow (self 3) 2) (acos 0) 2))
+
+(define (Circle:move dx dy)
+    (inc (self 1) dx) 
+    (inc (self 2) dy))
+
+; end of file
+</pre>
+
+<p>All sets of class functions are now lexically separated
+from each other.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+
+<a name="multi_processing"></a>
+<h2>19. Concurrent processing and distributed computing</h2>
+
+<p>newLISP has high-level APIs to control multiple processes on the same
+CPU or distributed onto different computer nodes on a TCP/IP network.</p>
+
+<br/>
+
+<a name="cilk"></a>
+<h3>Cilk API</h3>
+
+<p>newLISP implements a <a href="http://supertech.csail.mit.edu/cilk/">Cilk</a>-
+like API to launch and control concurrent processes. The API can take advantage of 
+multi-core computer architectures. Only three functions, <a href="#spawn">spawn</a>, 
+<a href="#sync">sync</a> and <a href="#abort">abort</a>, are necessary to start
+multiple processes and collect the results in a synchronized fashion. The underlying
+operating system distributes processes onto different cores inside the CPU or
+executes them on the same core in parallel if there are not enough cores present.
+Note that newLISP only implements the API; optimized scheduling
+of spawned procedures is not performed as in Cilk. Functions are started in the order
+they appear in <tt>spawn</tt> statements and are distributed and scheduled onto 
+different cores in the CPU by the operating system.</p>
+
+<p>When multiple cores are present, this can increase overall processing speed
+by evaluating functions in parallel. But even when running on single core CPUs,
+the Cilk API makes concurrent processing much easier for the programmer and
+may speed up processing if subtasks include waiting for I/O or sleeping.</p>
+
+<p>Since version 10.1 <a href="#send">send</a> and <a href="#receive">receive</a>
+message functions are available for communications between parent and child 
+processes. The functions can be used in blocking and non blocking communications 
+and can transfer any kind of newLISP data or expressions. Transmitted expressions 
+can be evaluated in the recipients environment.</p>
+
+<p>Internally, newLISP uses the lower level <a href="#fork">fork</a>,
+<a href="#wait-pid">wait-pid</a>, <a href="#destroy">destroy</a>, and 
+<a href="#share">share</a> functionalities to control processes and synchronize
+the passing of computed results via a shared memory interface.</p>
+
+<p>Only on Mac OS X and other Unixes will the Cilk API parallelize tasks.
+On MS Windows, the API partly simulates the behavior on Unix but executes tasks
+sequentially. This way, code can be written that runs on all platforms.</p>
+
+<br/>
+
+<a name="distributed"></a>
+<h3>Distributed network computing</h3>
+
+<p>With only one function, <a href="#net-eval">net-eval</a>, newLISP implements
+distributed computing. Using <tt>net-eval</tt>, different tasks can be mapped
+and evaluated on different nodes running on a TCP/IP network or local domain Unix sockets
+network when running on the same computer. <tt>net-eval</tt> does all the housekeeping 
+required to connect to remote nodes, transfer functions to execute, and
+collect the results. <tt>net-eval</tt> can also use a call-back function to
+further structure consolidation of incoming results from remote nodes.</p>
+
+<p>The functions <a href="#read-file">read-file</a>, <a href="#write-file">write-file</a>,  
+<a href="#append-file">append-file</a> and <a href="#delete-file">delete-file</a> all can 
+take URLs instead of path-file names. Server side newLISP running in demon mode or an other 
+HTTP server like Apache, receive standard HTTP requests and translate them into the 
+corresponding actions on files.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+<a name="JSON_XML"></a>
+<h2>20. JSON, XML, S-XML, and XML-RPC</h2> 
+<b>JSON support</b>
+<p>JSON-encoded data can be parsed into S-expressions using the 
+<a href="#json-parse">json-parse</a> function. Error information for
+failed JSON translations can be retrieved using <a href="#json-error">json-error</a>.</p>
+
+<p>For a description of the JSON format (<u>J</u>ava<u>S</u>cript <u>O</u>bject <u>N</u>otation)
+consult <a href="http://json.org">json.org</a>.
+Examples for correct formatted JSON text can be seen at 
+<a href="http://json.org/examples.html">json.org/examples.html</a>.</p>
+
+<p>To retrieve data in nested lists resulting from JSON translation, use the
+<a href="#assoc">assoc</a>, <a href="#lookup">lookup</a> and <a href="#ref">ref</a>
+functions.</p>
+
+<p>See the description of <a href="#json-parse">json-parse</a> for a complete example
+of parsing and processing JSON data.</p>
+
+<b>XML support</b>
+<p>newLISP's built-in support for XML-encoded data or documents
+comprises three functions:
+<a href="#xml-parse">xml-parse</a>,
+<a href="#xml-type-tags">xml-type-tags</a>, and <a href="#xml-error">xml-error</a>.
+</p>
+
+<p>
+Use the <a href="#xml-parse">xml-parse</a> function
+to parse XML-encoded strings.
+When <tt>xml-parse</tt> encounters an error,
+<tt>nil</tt> is returned.
+To diagnose syntax errors caused by incorrectly formatted XML,
+use the function <a href="#xml-error">xml-error</a>.
+The <a href="#xml-type-tags">xml-type-tags</a> function can be used
+to control or suppress the appearance of XML type tags.
+These tags classify XML into one of four categories:
+text, raw string data, comments, and element data.</p>
+
+
+<b>XML source:</b>
+<pre>
+&lt;?xml version="1.0"?&gt;
+&lt;DATABASE name="example.xml"&gt;
+&lt;!--This is a database of fruits--&gt;
+&lt;FRUIT&gt;
+&lt;NAME&gt;apple&lt;/NAME&gt;
+&lt;COLOR&gt;red&lt;/COLOR&gt;
+&lt;PRICE&gt;0.80&lt;/PRICE&gt;
+&lt;/FRUIT&gt;
+&lt;/DATABASE&gt;
+</pre>		<br/>
+<b>Parsing without options:</b>
+<pre>
+(xml-parse (read-file "example.xml"))
+<span class='arw'>&rarr;</span>  (("ELEMENT" "DATABASE" (("name" "example.xml")) (("TEXT" "\r\n")
+("COMMENT" "This is a database of fruits")
+("TEXT" "\r\n        ")
+("ELEMENT" "FRUIT" () (
+	("TEXT" "\r\n\t        ")
+	("ELEMENT" "NAME" () (("TEXT" "apple")))
+	("TEXT" "\r\n\t\t")
+	("ELEMENT" "COLOR" () (("TEXT" "red")))
+	("TEXT" "\r\n\t\t")
+	("ELEMENT" "PRICE" () (("TEXT" "0.80")))
+	("TEXT" "\r\n\t")))
+("TEXT" "\r\n"))))
+</pre>		<p>
+	S-XML can be generated directly from XML
+	using <a href="#xml-type-tags">xml-type-tags</a>
+	and the special option parameters
+	of the <a href="#xml-parse">xml-parse</a> function:
+</p>
+<br/>
+<b>S-XML generation using all options:</b>
+<pre>
+(xml-type-tags nil nil nil nil)
+(xml-parse (read-file "example.xml") (+ 1 2 4 8 16))
+<span class='arw'>&rarr;</span>  ((DATABASE (@ (name "example.xml"))
+  (FRUIT (NAME "apple")
+	  (COLOR "red")
+	  (PRICE "0.80"))))
+	
+</pre>
+<p>S-XML is XML reformatted as newLISP <em>S-expressions</em>.
+The <tt>@</tt> (at symbol) denotes an XML attribute specification.</p>
+
+<p>To retrieve data in nested lists resulting from S-XML translation, use the
+<a href="#assoc">assoc</a>, <a href="#lookup">lookup</a> and <a href="#ref">ref</a>
+functions.</p>
+
+<p>See <a href="#xml-parse">xml-parse</a> in the reference section of the manual
+for details on parsing and option numbers, as well as for a longer example.</p>
+
+<br/>
+<b>XML-RPC</b>
+<br/>
+<p>
+	The remote procedure calling protocol XML-RPC uses
+	HTTP post requests as a transport and
+	XML for the encoding of method names, parameters, and parameter types.
+	XML-RPC client libraries and servers have been implemented
+	for most popular compiled and scripting languages.
+</p>
+<p>
+	For more information about XML,
+	visit <a href="http://www.xmlrpc.com/">www.xmlrpc.com</a>.
+</p>
+<p>
+	XML-RPC clients and servers are easy to write
+	using newLISP's built-in network and XML support.
+	A stateless XML-RPC server implemented as a CGI service
+	can be found in the file <tt>examples/xmlrpc.cgi</tt>. This
+	script can be used together with a web server, like Apache.
+	This XML-RPC service script implements
+	the following methods:
+</p>
+
+<table  width="98%" summary="XMPRPC methods for newLISP server">
+<tr align="left"><th>method</th><th>description</th></tr>
+<tr>
+<td><tt>system.listMethods</tt></td>
+<td>Returns a list of all method names</td>
+</tr>
+<tr>
+<td><tt>system.methodHelp</tt></td>
+<td>Returns help for a specific method</td>
+</tr>
+<tr>
+<td><tt>system.methodSignature</tt></td>
+<td>Returns a list of return/calling signatures for a specific method </td>
+</tr>
+<tr>
+<td><tt>newLISP.evalString</tt></td>
+<td>Evaluates a Base64 newLISP expression string</td></tr>
+</table><br/>
+
+<p>
+The first three methods are <em>discovery</em> methods implemented by most XML-RPC servers.
+The last one is specific to the newLISP XML-RPC server script and
+implements remote evaluation of a Base64-encoded string of newLISP source code.
+newLISP's <a href="#base64-enc">base64-enc</a> and <a href="#base64-dec">base64-dec</a> functions
+can be used to encode and decode Base64-encoded information.
+</p>
+
+<p>
+In the <tt>modules</tt> directory of the source distribution,
+the file <tt>xmlrpc-client.lsp</tt> implements a specific client interface for
+all of the above methods.</p>
+
+<pre>
+(load "xmlrpc-client.lsp")  ; load XML-RPC client routines						 
+
+(XMLRPC:newLISP.evalString
+"http://localhost:8080/xmlrpc.cgi"
+"(+ 3 4)")  <span class='arw'>&rarr;</span> "7"
+</pre>		<p>
+	In a similar fashion,
+	standard <tt>system.xxx</tt> calls can be issued.
+</p>
+<p>
+All functions return either a result if successful, or <tt>nil</tt> if a request fails.
+In case of failure, the expression <tt>(XMLRPC:error)</tt> can be evaluated
+to return an error message.</p>
+
+<p>
+For more information, please consult the header of the file <tt>modules/xmlrpc-client.lsp</tt>.
+</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="internationalization"></a>
+<h2>21. Customization, localization, and UTF-8</h2>
+
+<a name="naming"></a>
+<h3>Customizing function names</h3>
+
+<p>All built-in primitives in newLISP can be easily renamed:</p>
+
+<pre>
+(constant 'plus +)
+</pre>		<p>
+	Now, <tt>plus</tt> is functionally equivalent to <tt>+</tt>
+	and runs at the same speed.
+</p>
+<p>
+	The <a href="#constant">constant</a> function,
+	rather than the <tt>set</tt> function,
+	must be used to rename built-in primitive symbols.
+	By default, all built-in function symbols
+	are protected against accidental overwriting.
+</p>
+
+<p>
+It is possible to redefine all integer arithmetic operators to their floating
+point equivalents:
+</p>
+
+<pre>
+(constant '+ add)
+(constant '- sub)
+(constant '* mul)
+(constant '/ div)
+</pre>		
+
+<p>All operations using <tt>+</tt>, <tt>-</tt>, <tt>*</tt>, and <tt>/</tt>
+are now performed as floating point operations.</p>
+
+<p>Using the same mechanism, the names of built-in functions
+can be translated into languages other than English:</p>
+
+<pre>
+(constant 'wurzel sqrt)    ; German for 'square-root'
+
+; make the new symbol global at the same time
+(constant (global 'imprime) print)  ; Spanish for 'print'
+&hellip;
+</pre>		
+
+<p>The new symbol can be made global at the same time using <a href="#global">global</a>.</p>
+
+<br/>
+
+<a name="switching"></a>
+<h3>Switching the locale</h3>
+
+<p>newLISP can switch locales based on the platform and operating system.
+On startup, non-UTF-8 enabled newLISP attempts to set the ISO C standard 
+default POSIX locale, available for most platforms and locales.  On UTF-8
+enabled newLISP the default locale for the platform is set. The 
+<a href="#set-locale">set-locale</a> function can also be used to switch 
+to the default locale:</p>
+<pre>
+(set-locale "")
+</pre>		
+<p>
+This switches to the default locale used on your platform/operating system
+and ensures character handling (e.g., <a href="#upper-case">upper-case</a>)
+works correctly.</p>
+
+<p>Many Unix systems have
+a variety of locales available. To find out which ones are available on
+a particular Linux/Unix/BSD system, execute the following command
+in a system shell:</p>
+
+<pre>
+locale -a
+</pre>		
+
+<p>
+This command prints a list of all the locales available on your system.
+Any of these may be used as arguments to <a href="#set-locale">set-locale</a>:</p>
+
+<pre>
+(set-locale "es_US")
+</pre>		<p>
+	This would switch to a U.S. Spanish locale.
+	Accents or other characters
+	used in a U.S. Spanish environment
+	would be correctly converted.
+</p>
+<p>
+	See the manual description for more details
+	on the usage of <a href="#set-locale">set-locale</a>.
+</p>
+
+<br/>
+
+<a name="decimal_point"></a>
+<h3>Decimal point and decimal comma</h3>
+
+<p>Many countries use a comma instead of a period
+as a decimal separator in numbers.
+newLISP correctly parses numbers
+depending on the locale set:</p>
+
+<pre>
+; switch to German locale on a Linux  or OSX system
+(set-locale "de_DE") <span class='arw'>&rarr;</span> ("de_DE" ",")
+
+; newLISP source and output use a decimal comma
+(div 1,2 3)  <span class='arw'>&rarr;</span> 0,4
+</pre>		
+
+<p>The default POSIX C locale, which is set when newLISP starts up,
+uses a period as a decimal separator.</p>
+
+<p>The following countries use a <b>period as a decimal separator</b>:</p>
+
+<blockquote>Australia, Botswana, Canada (English-speaking), China, Costa Rica, 
+Dominican Republic, El Salvador, Guatemala, Honduras, Hong Kong, India, Ireland, 
+Israel, Japan, Korea (both North and South), Malaysia, Mexico, Nicaragua, 
+New Zealand, Panama, Philippines, Puerto Rico, Saudi Arabia, Singapore, Switzerland, 
+Thailand, United Kingdom, and United States.</blockquote>
+
+<p>The following countries use a <b>comma as a decimal separator</b>:</p>
+
+<blockquote>Albania, Andorra, Argentina, Austria, Belarus, Belgium, Bolivia, 
+Brazil, Bulgaria, Canada (French-speaking), Croatia, Cuba, Chile, Colombia, 
+Czech Republic, Denmark, Ecuador, Estonia, Faroes, Finland, France, Germany, 
+Greece, Greenland, Hungary, Indonesia, Iceland, Italy, Latvia, Lithuania, 
+Luxembourg, Macedonia, Moldova, Netherlands, Norway, Paraguay, Peru, Poland, 
+Portugal, Romania, Russia, Serbia, Slovakia, Slovenia, Spain, South Africa, 
+Sweden, Ukraine, Uruguay, Venezuela, and Zimbabwe.</blockquote>
+
+
+<br/>
+<a name="unicode_utf8"></a>
+<h3>Unicode and UTF-8 encoding</h3>
+
+<p>Note that for many European languages,
+the <a href="#set-locale">set-locale</a> mechanism
+is sufficient to display non-ASCII character sets,
+as long as each character is presented as <em>one</em> byte internally.
+UTF-8 encoding is only necessary for multi-byte character sets as described 
+in this chapter.</p>
+
+<p>
+	newLISP can be compiled
+	as a UTF-8&ndash;enabled application.
+	UTF-8 is a multi-byte encoding
+	of the international Unicode character set.
+	A UTF-8&ndash;enabled newLISP
+	running on an operating system with UTF-8 enabled
+	can handle any character of the installed locale.
+</p>
+<p>
+	The following steps
+	make UTF-8 work with newLISP
+	on a specific operating system and platform:
+</p>
+<p>
+	<tt>(1)</tt> Use one of the makefiles
+	ending in <tt>utf8</tt>
+	to compile newLISP as
+	a UTF-8 application.
+	If no UTF-8 makefile
+	is available for your platform,
+	the normal makefile
+	for your operating system
+	contains instructions
+	on how to change it
+	for UTF-8.
+</p>
+<p>
+	The Mac OS X binary installer contains
+	a UTF-8&ndash;enabled version by default.
+</p>
+<p>
+	<tt>(2)</tt> Enable the UTF-8 locale
+	on your operating system.
+	Check and set a UTF-8 locale
+	on Unix and Unix-like OSes
+	by using the <tt>locale</tt> command
+	or the <tt>set-locale</tt> function within newLISP.
+	On Linux, the locale can be changed by setting
+	the appropriate environment variable.
+	The following example uses <tt>bash</tt>
+	to set the U.S. locale:
+</p>
+<pre>
+export LC_CTYPE=en_US.UTF-8
+</pre>		
+<p><tt>(3)</tt> The UTF-8&ndash;enabled newLISP automatically switches to the locale found
+on the operating system.  Make sure the command shell
+is UTF-8&ndash;enabled.  The U.S. version of WinXP's <tt>notepad.exe</tt>
+can display Unicode UTF-8&ndash;encoded characters, but the command shell cannot.
+On Linux and other Unixes, the Xterm shell can be used
+when started as follows:</p>
+
+<pre>
+LC_CTYPE=en_US.UTF-8 xterm
+</pre>		<p>
+	The following procedure can now be used
+	to check for UTF-8 support.
+	After starting newLISP, type:
+</p>
+<pre>
+(println (char 937))               ; displays Greek uppercase omega
+(println (lower-case (char 937)))  ; displays lowercase omega
+</pre>		<p>
+	While the uppercase omega (&Omega;) looks
+	like a big O on two tiny legs,
+	the lowercase omega (&omega;) has
+	a shape similar to a small <tt>w</tt>
+	in the Latin alphabet.
+</p>
+<p>
+	Note: Only the output of <tt>println</tt>
+	will be displayed as a character;
+	<tt>println</tt>'s return value
+	will appear on the console
+	as a multi-byte ASCII character.
+</p>
+<p>
+	When UTF-8&ndash;enabled newLISP
+	is used on a non-UTF-8&ndash;enabled display,
+	both the output and the return value
+	will be two characters.
+	These are the two bytes necessary
+	to encode the omega character.
+</p>
+
+<br/>
+
+<a name="utf8_capable"></a>
+<h3>Functions working on UTF-8 characters</h3>
+
+<p>When UTF-8&ndash;enabled newLISP is used, the following string functions work
+on one- or multi-byte characters rather than one 8-bit byte boundaries:</p>
+
+<table  width="98%" summary="functions working on character boundaries in UTF-8">
+<tr align="left"><th>function</th><th>description</th></tr>
+
+<tr>
+<td><a href="#char">char</a></td>
+<td>translates between characters and ASCII/Unicode</td>
+</tr>
+
+<tr>
+<td><a href="#chop">chop</a></td>
+<td>chops characters from the end of a string</td>
+</tr>
+
+<tr>
+<td><a href="#date">date</a></td>
+<td>converts date number to string (when used with the third argument)</td>
+</tr>
+
+<tr>
+<td><a href="#dostring">dostring</a></td>
+<td>evaluates once for each character in a string</td>
+</tr>
+
+<tr>
+<td><a href="#explode">explode</a></td>
+<td>transforms a string into a list of characters</td>
+</tr>
+
+<tr>
+<td><a href="#first">first</a></td>
+<td>gets first element in a list (car, head) or string</td>
+</tr>
+
+<tr>
+
+<td><a href="#last">last</a></td>
+<td>returns the last element of a list or string</td>
+</tr>
+
+
+<tr>
+<td><a href="#lower-case">lower-case</a></td>
+<td>converts a string to lowercase characters</td>
+</tr>
+
+<tr>
+<td><a href="#nth">nth</a></td>
+<td>gets the <em>nth</em> element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#pop">pop</a></td>
+<td>deletes an element from a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#push">push</a></td>
+<td>inserts a new element in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#rest">rest</a></td>
+<td>gets all but the first element of a list (cdr, tail) or string</td>
+</tr>
+
+<tr>
+<td><a href="#select">select</a></td>
+<td>selects and permutes elements from a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#title-case">title-case</a></td>
+<td>converts the first character of a string to uppercase</td>
+</tr>
+
+<tr>
+<td><a href="#trim">trim</a></td>
+<td>trims a string from both sides</td>
+</tr>
+
+<tr>
+<td><a href="#upper-case">upper-case</a></td>
+<td>converts a string to uppercase characters</td>
+</tr>
+
+</table><br/>
+
+<p>All other string functions work on 8-bit bytes.  When positions are returned,
+as in <a href="#find">find</a> or <a href="#regex">regex</a>,
+they are single 8-bit byte positions rather than character positions which
+may be multi-byte.
+The <a href="#get-char">get-char</a> and <a href="#slice">slice</a> functions
+do not take multi-byte character offsets, but single-byte offsets, even
+in UTF-8 enabled versions of newLISP.
+The <a href="#reverse">reverse</a> function reverses
+a byte vector, not a character vector. The last three functions can still 
+be used to manipulate binary non-textual data in the UTF-8&ndash;enabled 
+version of newLISP. To make <a href="#slice">slice</a> and <a href="#reverse">reverse</a>
+work with UTF-8 strings, combine them with <a href="#explode">explode</a> and
+<a href="#join">join</a>.</p>
+
+<p>To enable UTF-8 in Perl Compatible Regular Expressions (PCRE)
+&mdash; used by <a href="#directory">directory</a>, <a href="#find">find</a>, 
+<a href="#member">member</a>, <a href="#parse">parse</a>, <a href="#regex">regex</a>, 
+<a href="#regex-comp">regex-comp</a> and <a href="#replace">replace</a> &mdash;
+set the option number accordingly (2048). Note that offset and lengths in 
+<a href="#regex">regex</a> results are always in single byte counts.
+See the <a href="#regex">regex</a> documentation for details.</p>
+
+<p>Use <a href="#explode">explode</a> to obtain an array
+of UTF-8 characters and to manipulate characters rather than bytes
+when a UTF-8&ndash;enabled function is unavailable:</p>
+
+<pre>
+(join (reverse (explode str)))  ; reverse UTF-8 characters
+</pre>		
+
+<p>The above string functions (often used to manipulate non-textual binary data)
+now work on character, rather than byte, boundaries,
+so care must be exercised when using the UTF-8&ndash;enabled version.
+The size of the first 127 ASCII characters &mdash;
+along with the characters in popular code pages such as ISO 8859 &mdash;
+is one byte long.  When working exclusively within these code pages,
+UTF-8&ndash;enabled newLISP is not required. 
+The <a href="#set-locale">set-locale</a> function alone
+is sufficient for localized behavior.</p>
+
+<br/>
+
+<a name="utf8_version"></a>
+<h3>Functions only available on UTF-8 enabled versions</h3>
+
+<table  width="98%" summary="functions only available on UTF-8 version">
+<tr align="left"><th>function</th><th>description</th></tr>
+
+<tr>
+<td><a href="#unicode">unicode</a></td>
+<td>converts UTF-8 or ASCII strings into USC-4 Unicode</td>
+</tr>
+
+<tr>
+<td><a href="#utf8">utf8</a></td>
+<td>converts UCS-4 Unicode strings to UTF-8</td>
+</tr>
+
+<tr>
+<td><a href="#utf8len">utf8len</a></td>
+<td>returns the number of UTF-8 characters in a string</td>
+</tr>
+
+</table><br/>
+
+<p>The first two functions are rarely used in practice,
+as most Unicode text files are already UTF-8&ndash;encoded
+(rather than UCS-4, which uses four-byte integer characters).
+Unicode can be displayed directly when using the 
+<tt>"%ls"</tt> <a href="#format">format</a> specifier.</p>
+
+<p>For further details on UTF-8 and Unicode,
+consult <a href="http://www.cl.cam.ac.uk/~mgk25/unicode.html"><em>UTF-8 and Unicode FAQ 
+for Unix/Linux</em></a> by <em>Markus Kuhn</em>.</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+
+<a name="commas"></a>
+<h2>22. Commas in parameter lists</h2>
+
+<p>
+	Some of the example programs contain functions
+	that use a comma to separate the parameters into two groups.
+	This is not a special syntax of newLISP,
+	but rather a visual trick.
+	The comma is a symbol just like any other symbol.
+	The parameters after the comma are not required
+	when calling the function;
+	they simply declare local variables in a convenient way.
+	This is possible in newLISP because parameter variables in lambda expressions
+	are local and arguments are optional:
+</p>
+<pre>
+(define (my-func a b c , x y z)
+    (set 'x &hellip;)
+(&hellip;))
+</pre>		
+<p>
+When calling this function, only <tt>a, b</tt>, and <tt>c</tt> are used as parameters.
+The others (the comma symbol, <tt>x</tt>, <tt> y</tt>, and <tt>z</tt>) are initialized 
+to <tt>nil</tt> and are local to the function.  After execution, the function's contents 
+are forgotten and the environment's symbols are restored to their previous values.
+</p>
+<p>
+	For other ways of declaring and initializing local variables,
+	see <a href="#let">let</a>, <a href="#letex">letex</a> and
+	<a href="#letn">letn</a>.
+</p>
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+
+<br/><br/><br/>
+
+
+<center style="font-size: 150%">
+<span class="divider">(&nbsp;<font color="#7ba9d4">&part;</font>&nbsp;)</span>
+</center>
+
+<a name="function_ref"></a>
+<center><h1>newLISP Function Reference</h1></center>
+
+<br/><br/>
+
+<a name="symbol_names"></a>
+<h2>1. Syntax of symbol variables and numbers</h2>
+
+<p>Source code in newLISP is parsed according to the rules outlined here. 
+When in doubt, verify the behavior of newLISP's internal parser
+by calling <a href="#parse">parse</a> without optional arguments.</p>
+
+<br/>
+
+<h3>Symbols for variable names</h3>
+<p>
+The following rules apply to the naming of symbols 
+used as variables or functions:
+</p>
+
+
+<ol>
+<li>Variable symbols should not start with any of the following characters:<br/>
+<tt># ; " ' ( )  { } . , 0 1 2 3 4 5 6 7 8 9</tt><br/><br/></li>
+
+<li>Variable symbols starting with a <tt>+</tt> or <tt>-</tt> cannot have a 
+number as the second character.<br/><br/></li>
+
+<li>Any character is allowed inside a variable name, except for:<br/>
+<tt>" ' ( ) : ,</tt> and the space character. These mark the end of a variable symbol.<br/><br/></li>
+
+<li>A symbol name starting with <tt>[</tt> (left square bracket) and ending with 
+<tt>]</tt> (right square bracket) may contain any character except the right square 
+bracket.<br/><br/></li>
+
+<li>A symbol name starting with <tt>$</tt> (dollar sign) is global. There are several of these
+symbols already <a href="#system_symbols">built into newLISP</a> and set and changed 
+internally. This type of global symbol can also be created by the user.
+</li>
+
+</ol>
+
+
+<p>
+All of the following symbols are legal variable names in newLISP:
+</p>
+
+<!-- example -->
+
+<pre>
+myvar
+A-name
+X34-zz
+[* 7 5 ()};]
+*111*
+</pre>
+
+<p>
+Sometimes it is useful to create hash-like <a href="#hash">lookup dictionaries</a>
+with keys containing characters that are illegal in newLISP variables. 
+The functions <a href="#sym">sym</a> and <a href="#context">context</a> 
+can be used to create symbols containing these characters:
+</p>
+
+<pre>
+(set (sym "(#:L*") 456)  <span class='arw'>&rarr;</span> 456 ; the symbol '(#:L*'
+
+(eval (sym "(#:L*"))  <span class='arw'>&rarr;</span> 456
+
+(set (sym 1) 123)  <span class='arw'>&rarr;</span> 123
+
+(eval (sym 1))  <span class='arw'>&rarr;</span> 123
+
+1        <span class='arw'>&rarr;</span> 1
+(+ 1 2)  <span class='arw'>&rarr;</span> 3
+</pre>
+
+
+<p>
+The last example creates the symbol <tt>1</tt> 
+containing the value <tt>123</tt>. 
+Also note that creating such a symbol does not alter newLISP's normal operations, 
+since <tt>1</tt> is still parsed as the number one.
+</p>
+
+<br/>
+
+<h3>Numbers</h3>
+
+<p>When parsing binary, hex, decimal, float and integer numbers, up to
+1000 digits are parsed when present. The rest will be read as new token(s).
+Note that IEEE 754 64-bit doubles distinguish only up to 16 significant
+digits. If more than 308 digits are present before the decimal point, the
+number will convert to <tt>inf</tt> (infinity). For big integers the 1000 
+limitation exists only when parsing source. There is no limit when a result 
+of big integers math exceeds 1000 digits.</p>
+
+<p>
+newLISP recognizes the following number formats:
+</p>
+
+<p>
+<b>Integers</b> are one or more digits long, 
+optionally preceded by a <tt>+</tt> or <tt>-</tt> sign. 
+Any other character marks the end of the integer 
+or may be part of the sequence 
+if parsed as a float (see float syntax below).
+</p>
+
+<!-- example -->
+
+<pre>
+123
++4567
+-999
+</pre>
+
+<p>
+<b>Big integers</b> can be of unlimited precision and are processed
+differently from normal 64-bi integers internally.</p>
+
+<!-- example -->
+<pre>
+123456789012345678901234567890 ; will automatically be converted to big int
+-123L                          ; appended L forces conversion
+0L
+</pre>
+
+<p>when parsing the command line or programming source, newLISP will
+recognise, integers bigger than 64-bit and convert the to big integers.
+Smaller numbers can be forced to big integer format by appending the
+letter L.</p>
+
+
+<p>
+<b>Hexadecimals</b> start with a <tt>0x</tt> (or <tt>0X</tt>),  
+followed by any combination of the hexadecimal digits: 
+<tt>0123456789abcdefABCDEF</tt>. 
+Any other character ends the hexadecimal number. Only up to 16 hexadecimal digits
+are valid and any more digits are ignored.
+</p>
+
+<!-- example -->
+
+<pre>
+0xFF    <span class='arw'>&rarr;</span>  255
+0x10ab  <span class='arw'>&rarr;</span> 4267
+0X10CC  <span class='arw'>&rarr;</span> 4300
+</pre>
+
+<p>
+<b>Binaries</b> start with a <tt>0b</tt> (or <tt>0B</tt>),
+followed by up to 64 bits coded with 1's or 0s. Any other character ends the binary number.
+Only up to 64 bits are valid and any more bits are ignored.
+</p>
+
+<!-- example -->
+
+<pre>
+0b101010   <span class='arw'>&rarr;</span>  42
+</pre>
+
+
+
+<p>
+<b>Octals</b> start with an optional <tt>+</tt> (plus) or <tt>-</tt> (minus) sign and a <tt>0</tt> (zero), 
+followed by any combination of the octal digits: <tt>01234567</tt>. 
+Any other character ends the octal number. Only up to 21 octal digits are valid
+and any more digits are ignored.
+</p>
+
+<!-- example -->
+
+<pre>
+012   <span class='arw'>&rarr;</span>  10
+010   <span class='arw'>&rarr;</span>   8
+077   <span class='arw'>&rarr;</span>  63
+-077  <span class='arw'>&rarr;</span> -63
+</pre>
+
+
+
+<p>
+<b>Floating point</b> numbers can start 
+with an optional <tt>+</tt> (plus) or <tt>-</tt> (minus) sign, 
+but they cannot be followed by a <tt>0</tt> (zero); 
+this would make them octal numbers instead of floating points. 
+A single <tt>.</tt> (decimal point) can appear anywhere within
+a floating point number, including at the beginning.
+</p>
+
+<p>Only 16 digits are siginificant and any more digits are ignored.</p>
+
+<!-- example -->
+
+<pre>
+1.23     <span class='arw'>&rarr;</span>  1.23
+-1.23    <span class='arw'>&rarr;</span> -1.23
++2.3456  <span class='arw'>&rarr;</span>  2.3456
+.506     <span class='arw'>&rarr;</span>  0.506
+</pre>
+
+
+<p>
+As described below, <b>scientific notation</b> 
+starts with a floating point number
+called the <em>significand</em> (or <em>mantissa</em>),
+followed by the letter <tt>e</tt> or <tt>E</tt> 
+and an integer <em>exponent</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+1.23e3    <span class='arw'>&rarr;</span>  1230
+-1.23E3   <span class='arw'>&rarr;</span> -1230
++2.34e-2  <span class='arw'>&rarr;</span>  0.0234
+.506E3    <span class='arw'>&rarr;</span>  506
+</pre>
+
+
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="type_ids"></a>
+<h2>2. Data types and names in the reference</h2>
+
+<p>To describe the types and names of a function's parameters, 
+the following naming convention is used throughout the reference section:</p>
+
+
+<b>syntax&#058; (format <em>str-format</em> <em>exp-data-1</em> [<em>exp-data-i</em> ... ])</b>
+
+
+
+<p>Arguments are represented by symbols formed by the argument's type and name, 
+separated by a <tt>-</tt> (hyphen). Here, <em>str-format</em> (a string) and 
+<em>exp-data-1</em> (an expression) are named "format" and "data-1", respectively.</p>
+
+<p>Arguments enclosed in brackets <tt>[</tt> and <tt>]</tt> are optional. When
+arguments are separated by a vertical <tt>|</tt> then one of them must be chosen.</p>
+
+<h3>array</h3>
+
+<p>An array (constructed with the <a href="#array">array</a> function).</p>
+
+<h3>body</h3>
+
+<p>One or more expressions for evaluation. The expressions are evaluated sequentially 
+if there is more than one.</p>
+
+
+<pre>
+1 7.8
+nil
+(+ 3 4)
+"Hi" (+ a b)(print result)
+(do-this)(do-that) 123
+</pre>
+
+
+<h3>bool</h3>
+
+<p><tt>true</tt>, <tt>nil</tt>, or an expression evaluating to one of these two.
+</p>
+
+
+<pre>
+true, nil, (&lt;= X 10)
+</pre>
+
+
+<h3>context</h3>
+
+<p>An expression evaluating to a context (namespace) or a variable symbol 
+holding a context.</p>
+
+
+<pre>
+MyContext, aCtx, TheCTX
+</pre>
+
+
+<h3>exp</h3>
+
+<p>Any data type described in this chapter.</p>
+
+<h3>func</h3>
+
+<p>
+	A symbol or an expression evaluating to 
+	an operator symbol or lambda expression.
+</p>
+
+
+<pre>
++, add, (first '(add sub)), (lambda (x) (+ x x))
+</pre>
+
+
+<h3>int</h3>
+
+<p>
+An integer or an expression evaluating to an integer. 
+Generally, if a floating point number is used 
+when an int is expected, 
+the value is truncated to an integer.
+</p>
+
+
+<pre>
+123, 5, (* X 5)
+</pre>
+
+
+<h3>list</h3>
+<p>
+	A list of elements (any type) 
+	or an expression evaluating to a list.
+</p>
+
+<pre>
+(a b c "hello" (+ 3 4))
+</pre>
+
+
+<h3>num</h3>
+<p>
+An integer, a floating point number, 
+or an expression evaluating to one of these two. 
+If an integer is passed, 
+it is converted to a floating point number.
+</p>
+
+<pre>
+1.234, (div 10 3), (sin 1)
+</pre>
+
+
+<h3>matrix</h3>
+<p>A list in which each row element is itself a list 
+or an array in which each row element is itself an array.
+All element lists or arrays (rows) are of the same length.
+Any data type can be element of a matrix, but when
+using specific matrix operations like <a href="#det">det</a>, 
+<A href="#multiply">multiply</A>, or <A href="#invert">invert</A>, 
+all numbers must be floats or integers.
+</p>
+
+<p>
+The dimensions of a matrix are defined 
+by indicating the number of rows
+and the number of column elements per row. 
+Functions working on matrices 
+ignore superfluous columns in a row. 
+For missing row elements, 
+<tt>0.0</tt> is assumed by the functions 
+<a href="#det">det</a>, <a href="#multiply">multiply</a>, 
+and <a href="#invert">invert</a>, 
+while <a href="#transpose">transpose</a> assumes <tt>nil</tt>.
+Special rules apply for <a href="#transpose">transpose</a> 
+when a whole row is not a list or an array, 
+but some other data type.
+</p>
+
+
+<pre>
+((1  2  3  4)
+(5  6  7  8)
+(9 10 11 12))        ; 3 rows 4 columns
+		   
+((1 2) (3 4) (5 6))  ; 3 rows 2 columns
+</pre>
+
+
+<h3>place</h3>
+
+<p>A place referenced by a symbol or a place defined in a list, array 
+or string by indexing with <a href="#nth">nth</a> or <a href="#indexing">implicit indexing</a>
+or a place referenced by functions like <a href="#first">first</a>, <a href="#last">last</a>,
+<a href="#assoc">assoc</a> or <a href="#lookup">lookup</a>.</p>
+
+
+<h3>str</h3>
+
+<p>A string or an expression that evaluates to a string.</p>
+
+<p>Depending on the length and processing of special characters, strings are delimited
+by either quotes <tt>""</tt>, braces <tt>{}</tt> or <tt>[text][/text]</tt> tags.</p>
+
+<p>Strings limited by either quotes <tt>""</tt> or braces <tt>{}</tt> must not exceed
+2047 characters. Longer strings should be limited by <tt>[text][/text]</tt> tags for
+unlimited text length.</p>
+
+<pre>
+"Hello", (append first-name  " Miller")
+</pre>
+
+
+<p>
+Special characters can be included in quoted strings 
+by placing a <tt>\</tt> (backslash) before the character or 
+digits to escape them:</p>
+
+<table width="98%"  summary="escaping special characters in strings">
+<tr align="left" valign="bottom"><th>character</th><th>description</th></tr>
+<tr><td><tt>\"</tt></td><td>for a double quote inside a quoted string</td></tr>
+<tr><td><tt>\n</tt></td> <td>the line-feed character (ASCII 10)</td></tr>
+<tr> <td><tt>\r</tt></td> <td>the carriage return character (ASCII 13)</td> </tr>
+<tr><td><tt>\b</tt></td><td>for a backspace BS character (ASCII 8)</td></tr>
+<tr><td><tt>\t</tt></td><td>for a TAB character (ASCII 9)</td></tr>
+<tr><td><tt>\f</tt></td><td>for a formfeed FF character (ASCII 12)</td></tr>
+<tr><td><tt>\nnn</tt></td> <td>a decimal ASCII code where nnn is between 000 and 255</td></tr>
+<tr><td><tt>\xnn</tt></td> <td>a hexadecimal code where nn is between 00 and FF</td></tr>
+<tr><td><tt>\unnnn</tt></td><td>a unicode character encoded in the four <tt>nnnn</tt> hexadecimal
+digits. When reading a quoted string, newLISP will translate 
+this to a UTF8 character in the UTF8 enabled versions of newLISP.</td></tr>
+<tr><td><tt>\\</tt></td> <td>the backslash character itself</td></tr>
+</table><br/>
+
+<p>Decimals start with a digit. Hexadecimals start with <tt>x</tt>:</p>
+
+<pre>
+"\065\066\067" <span class='arw'>&rarr;</span> "ABC"
+"\x41\x42\x43" <span class='arw'>&rarr;</span> "ABC"
+</pre>
+
+
+<p>Instead of a <tt>"</tt> (double quote), a <tt>{</tt> (left curly bracket) 
+and <tt>}</tt> (right curly bracket) can be used to delimit strings.
+This is useful when quotation marks need to occur inside strings. 
+Quoting with the curly brackets suppresses the backslash escape effect 
+for special characters. Balanced nested curly brackets may be used within 
+a string.  This aids in writing regular expressions or short sections of 
+HTML.</p>
+
+
+<pre>
+(print "&lt;A href=\"http://mysite.com\"&gt;" ) ; the cryptic way
+
+(print {&lt;A href="http://mysite.com"&gt;} )   ; the readable way
+
+
+; path names on MS Windows
+
+(set 'path "C:\\MyDir\\example.lsp")
+
+; no escaping when using braces
+
+(set 'path {C:\MyDir\example.lsp})
+
+; on MS Windows the forward slash can be used in path names
+
+(set 'path "C:/MyDir/example.lsp")
+
+; inner braces are balanced
+(regex {abc{1,2}} line) 
+
+(print [text]
+  this could be
+  a very long (&gt; 2048 characters) text,
+  i.e. HTML.
+[/text])
+</pre>
+
+
+<p>
+	The tags <tt>[text]</tt> and <tt>[/text]</tt> 
+	can be used to delimit long strings 
+	and suppress escape character translation. 
+	This is useful for delimiting long HTML passages 
+	in CGI files written in newLISP 
+	or for situations where character translation 
+	should be completely suppressed. 
+	Always use the <tt>[text]</tt> tags 
+	for strings longer than 2048 characters.
+</p>
+
+<h3>sym</h3>
+
+<p>
+	A symbol or expression evaluating to a symbol.
+</p>
+
+
+<pre>
+'xyz, (first '(+ - /)), '*, '- , someSymbol,
+</pre>
+
+
+
+<p>Most of the context symbols in this manual start with an uppercase letter 
+to distinguish them from other symbols.</p>
+
+<h3>sym-context</h3>
+<p>
+A symbol, an existing context, or an expression evaluating to a symbol 
+from which a context will be created.  If a context does not already exist, 
+many functions implicitly create them 
+(e.g., <a href="#bayes-train">bayes-train</a>, <a Href="#context">context</a>, 
+<a href="#eval-string">eval-string</a>, 
+<a href="#load">load</a>, <a href="#sym">sym</a>, and <a href="#xml-parse">xml-parse</a>).
+The context must be specified when these functions are used 
+on an existing context.  Even if a context already exists, 
+some functions may continue to take quoted symbols (e.g., <a href="#context">context</a>).
+For other functions, such as <a href="#contextp">context?</a>, the distinction is critical.
+</p>
+
+
+<br/>
+
+
+
+<br/>
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+<br/>
+
+<a name="functions"></a>
+<h2>3. Functions in groups</h2>
+
+<p>Some functions appear in more than one group.</p>
+
+<a name="list_processing"></a>
+<h3>List processing, flow control, and integer arithmetic</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="List processing, flow control and integer
+arithmetic">
+
+<tr>
+<td WIDTH="16%"><a href="#arithmetic">+, -, *, /, %</a></td>
+<td WIDTH="80%">integer arithmetic</td>
+</tr>
+
+<tr>
+<td><a href="#inci">++</a></td>
+<td>increment integer numbers</td>
+</tr>
+
+<tr>
+<td><a href="#deci">--</a></td>
+<td>decrement integer numbers</td>
+</tr>
+
+<tr>
+<td><a href="#logical">&lt;, &gt;, =</a></td>
+<td>compares any data type: less, greater, equal</td>
+</tr>
+
+<tr>
+<td><a href="#logical">&lt;=, &gt;=, !=</a></td>
+<td>compares any data type: less-equal, greater-equal, not-equal</td>
+</tr>
+
+<tr>
+<td><a href="#colon">:</a></td>
+<td>constructs a context symbol and applies it to an object</td>
+</tr>
+
+<tr>
+<td><a href="#and">and</a></td>
+<td>logical <tt>and</tt></td>
+</tr>
+
+<tr>
+<td><a href="#append">append</a></td>
+<td>appends lists ,arrays or strings to form a new list, array or string</td>
+</tr>
+
+<tr>
+<td><a href="#apply">apply</a></td>
+<td>applies a function or primitive to a list of arguments</td>
+</tr>
+
+<tr>
+<td><a href="#args">args</a></td>
+<td>retrieves the argument list of a function or macro expression</td>
+</tr>
+
+<tr>
+<td><a href="#assoc">assoc</a></td>
+<td>searches for keyword associations in a list</td>
+</tr>
+
+<tr>
+<td><a href="#begin">begin</a></td>
+<td>begins a block of functions</td>
+</tr>
+
+<tr>
+<td><a href="#bigint">bigint</a></td>
+<td>convert a number to big integer format</td>
+</tr>
+
+<tr>
+<td><a href="#bind">bind</a></td>
+<td>binds variable associations in a list</td>
+</tr>
+
+<tr>
+<td><a href="#case">case</a></td>
+<td>branches depending on contents of control variable</td>
+</tr>
+
+<tr>
+<td><a href="#catch">catch</a></td>
+<td>evaluates an expression, possibly catching errors</td>
+</tr>
+
+<tr>
+<td><a href="#chop">chop</a></td>
+<td>chops elements from the end of a list</td>
+</tr>
+
+<tr>
+<td><a href="#clean">clean</a></td>
+<td>cleans elements from a list</td>
+</tr>
+
+<tr>
+<td><a href="#collect">collect</a></td>
+<td>repeat evaluating an expression and collect results in a list</td>
+</tr>
+
+<tr>
+<td><a href="#cond">cond</a></td>
+<td>branches conditionally to expressions</td>
+</tr>
+
+<tr>
+<td><a href="#cons">cons</a></td>
+<td>prepends an element to a list, making a new list</td>
+</tr>
+
+<tr>
+<td><a href="#constant">constant</a></td>
+<td>defines a constant symbol</td>
+</tr>
+
+<tr>
+<td><a href="#count">count</a></td>
+<td>counts elements of one list that occur in another list</td>
+</tr>
+
+<tr>
+<td><a href="#curry">curry</a></td>
+<td>transforms a function f(x, y) into a function fx(y)</td>
+</tr>
+
+<tr>
+<td><a href="#define">define</a></td>
+<td>defines a new function or lambda expression</td>
+</tr>
+
+<tr>
+<td><a href="#define-macro">define-macro</a></td>
+<td>defines a macro or lambda-macro expression</td>
+</tr>
+
+<tr>
+<td><a href="#def-new">def-new</a></td>
+<td>copies a symbol to a different context (namespace)</td>
+</tr>
+
+<tr>
+<td><a href="#difference">difference</a></td>
+<td>returns the difference between two lists</td>
+</tr>
+
+<tr>
+<td><a href="#doargs">doargs</a></td>
+<td>iterates through the arguments of a function</td>
+</tr>
+
+<tr>
+<td><a href="#dolist">dolist</a></td>
+<td>evaluates once for each element in a list</td>
+</tr>
+
+<tr>
+<td><a href="#dostring">dostring</a></td>
+<td>evaluates once for each character in a string</td>
+</tr>
+
+<tr>
+<td><a href="#dotimes">dotimes</a></td>
+<td>evaluates once for each number in a range</td>
+</tr>
+
+<tr>
+<td><a href="#dotree">dotree</a></td>
+<td>iterates through the symbols of a context</td>
+</tr>
+
+<tr>
+<td><a href="#do-until">do-until</a></td>
+<td>repeats evaluation of an expression until the condition is met</td>
+</tr>
+
+<tr>
+<td><a href="#do-while">do-while</a></td>
+<td>repeats evaluation of an expression while the condition is true</td>
+</tr>
+
+<tr>
+<td><a href="#dup">dup</a></td>
+<td>duplicates a list or string a specified number of times</td>
+</tr>
+
+<tr>
+<td><a href="#ends-with">ends-with</a></td>
+<td>checks the end of a string or list against a key of the same type</td>
+</tr>
+
+<tr>
+<td><a href="#eval">eval</a></td>
+<td>evaluates an expression</td>
+
+</tr>
+<tr>
+<td><a href="#exists">exists</a></td>
+<td>checks for the existence of a condition in a list</td>
+</tr>
+
+<tr>
+<td><a href="#expand">expand</a></td>
+<td>replaces a symbol in a nested list</td>
+</tr>
+
+<tr>
+<td><a href="#explode">explode</a></td>
+<td>explodes a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#extend">extend</a></td>
+<td>extends a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#first">first</a></td>
+<td>gets the first element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#filter">filter</a></td>
+<td>filters a list</td>
+</tr>
+
+<tr>
+<td><a href="#find">find</a></td>
+<td>searches for an element in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#flat">flat</a></td>
+<td>returns the flattened list</td>
+</tr>
+
+<tr>
+<td><a href="#define">fn</a></td>
+<td>defines a new function or lambda expression</td>
+</tr>
+
+<tr>
+<td><a href="#for">for</a></td>
+<td>evaluates once for each number in a range</td>
+</tr>
+
+<tr>
+<td><a href="#for-all">for-all</a></td>
+<td>checks if all elements in a list meet a condition</td>
+</tr>
+
+<tr>
+<td><a href="#if">if</a></td>
+<td>evaluates an expression conditionally</td>
+</tr>
+
+<tr>
+<td><a href="#index">index</a></td>
+<td>filters elements from a list and returns their indices</td>
+</tr>
+
+
+<tr>
+<td><a href="#intersect">intersect</a></td>
+<td>returns the intersection of two lists</td>
+</tr>
+
+<tr>
+<td><a href="#define">lambda</a></td>
+<td>defines a new function or lambda expression</td>
+</tr>
+
+<tr>
+<td><a href="#last">last</a></td>
+<td>returns the last element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#length">length</a></td>
+<td>calculates the length of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#let">let</a></td>
+<td>declares and initializes local variables</td>
+</tr>
+
+<tr>
+<td><a href="#letex">letex</a></td>
+<td>expands local variables into an expression, then evaluates</td>
+</tr>
+
+<tr>
+<td><a href="#letn">letn</a></td>
+<td>initializes local variables incrementally, like nested lets</td>
+</tr>
+
+<tr>
+<td><a href="#list">list</a></td>
+<td>makes a list</td>
+</tr>
+
+<tr>
+<td><a href="#local">local</a></td>
+<td>declares local variables</td>
+</tr>
+
+<tr>
+<td><a href="#lookup">lookup</a></td>
+<td>looks up members in an association list</td>
+</tr>
+
+<tr>
+<td><a href="#map">map</a></td>
+<td>maps a function over members of a list, collecting the results</td>
+</tr>
+
+<tr>
+<td><a href="#match">match</a></td>
+<td>matches patterns against lists; for matching against strings, see 
+<a href="#find">find</a> and <a href="#regex">regex</a></td>
+</tr>
+
+<tr>
+<td><a href="#member">member</a></td>
+<td>finds a member of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#not">not</a></td>
+<td>logical <tt>not</tt></td>
+</tr>
+
+<tr>
+<td><a href="#nth">nth</a></td>
+<td>gets the <em>nth</em> element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#or">or</a></td>
+<td>logical <tt>or</tt></td>
+</tr>
+
+<tr>
+<td><a href="#pop">pop</a></td>
+<td>deletes and returns an element from a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#pop-assoc">pop-assoc</a></td>
+<td>removes an association from an association list</td>
+</tr>
+
+<tr>
+<td><a href="#push">push</a></td>
+<td>inserts a new element into a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#quote">quote</a></td>
+<td>quotes an expression</td>
+</tr>
+
+<tr>
+<td><a href="#ref">ref</a></td>
+<td>returns the position of an element inside a nested list</td>
+</tr>
+
+<tr>
+<td><a href="#ref-all">ref-all</a></td>
+<td>returns a list of index vectors of elements inside a nested list</td>
+</tr>
+
+<tr>
+<td><a href="#rest">rest</a></td>
+<td>returns all but the first element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#replace">replace</a></td>
+<td>replaces elements inside a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#reverse">reverse</a></td>
+<td>reverses a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#rotate">rotate</a></td>
+<td>rotates a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#select">select</a></td>
+<td>selects and permutes elements from a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#self">self</a></td>
+<td>Accesses the target object inside a FOOP method</td>
+</tr>
+
+<tr>
+<td><a href="#set">set</a></td>
+<td>sets the binding or contents of a symbol</td>
+</tr>
+
+<tr>
+<td><a href="#setf">setf setq</a></td>
+<td>sets contents of a symbol or list, array or string reference</td>
+</tr>
+
+<tr>
+<td><a href="#set-ref">set-ref</a></td>
+<td>searches for an element in a nested list and replaces it</td>
+</tr>
+
+<tr>
+<td><a href="#set-ref-all">set-ref-all</a></td>
+<td>searches for an element in a nested list and replaces all instances</td>
+</tr>
+
+<tr>
+<td><a href="#silent">silent</a></td>
+<td>works like <a href="#begin">begin</a> but suppresses console output of the return value</td>
+</tr>
+
+<tr>
+<td><a href="#slice">slice</a></td>
+<td>extracts a sublist or substring</td>
+</tr>
+
+<tr>
+<td><a href="#sort">sort</a></td>
+<td>sorts the members of a list</td>
+</tr>
+
+<tr>
+<td><a href="#starts-with">starts-with</a></td>
+<td>checks the beginning of a string or list against a key of the same type</td>
+</tr>
+
+<tr>
+<td><a href="#swap">swap</a></td>
+<td>swaps two elements inside a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#unify">unify</a></td>
+<td>unifies two expressions</td>
+</tr>
+
+<tr>
+<td><a href="#unique">unique</a></td>
+<td>returns a list without duplicates</td>
+</tr>
+
+<tr>
+<td><a href="#union">union</a></td>
+<td>returns a unique list of elements found in two or more lists.</td>
+</tr>
+
+<tr>
+<td><a href="#unless">unless</a></td>
+<td>evaluates an expression conditionally</td>
+</tr>
+
+<tr>
+<td><a href="#until">until</a></td>
+<td>repeats evaluation of an expression until the condition is met</td>
+</tr>
+
+<tr>
+<td><a href="#when">when</a></td>
+<td>evaluates a block of statements conditionally</td>
+</tr>
+
+<tr>
+<td><a href="#while">while</a></td>
+<td>repeats evaluation of an expression while the condition is true</td>
+</tr>
+</table><br/>
+
+<a name="string_operators"></a>
+<h3>String and conversion functions</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="String and conversion functions">
+
+
+<tr>
+<td WIDTH="16%"><a href="#address">address</a></td>
+<td WIDTH="84%">gets the memory address of a number or string</td>
+</tr>
+
+<tr>
+<td><a href="#bigint">bigint</a></td>
+<td>convert a number to big integer format</td>
+</tr>
+
+<tr>
+<td><a href="#bits">bits</a></td>
+<td>translates a number into binary representation</td>
+</tr>
+
+<tr>
+<td><a href="#char">char</a></td>
+<td>translates between characters and ASCII codes</td>
+</tr>
+
+<tr>
+<td><a href="#chop">chop</a></td>
+<td>chops off characters from the end of a string</td>
+</tr>
+
+<tr>
+<td><a href="#dostring">dostring</a></td>
+<td>evaluates once for each character in a string</td>
+</tr>
+
+<tr>
+<td><a href="#dup">dup</a></td>
+<td>duplicates a list or string a specified number of times</td>
+</tr>
+
+<tr>
+<td><a href="#ends-with">ends-with</a></td>
+<td>checks the end of a string or list against a key of the same type</td>
+</tr>
+
+<tr>
+<td><a href="#encrypt">encrypt</a></td>
+<td>does a one-time&ndash;pad encryption and decryption of a string</td>
+</tr>
+
+<tr>
+<td><a href="#eval-string">eval-string</a></td>
+<td>compiles, then evaluates a string</td>
+</tr>
+
+<tr>
+<td><a href="#explode">explode</a></td>
+<td>transforms a string into a list of characters</td>
+</tr>
+
+<tr>
+<td><a href="#extend">extend</a></td>
+<td>extends a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#find">find</a></td>
+<td>searches for an element in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#find-all">find-all</a></td>
+<td>returns a list of all pattern matches found in string</td>
+</tr>
+
+<tr>
+<td><a href="#first">first</a></td>
+<td>gets the first element in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#float">float</a></td>
+<td>translates a string or integer into a floating point number</td>
+</tr>
+
+<tr>
+<td><a href="#format">format</a></td>
+<td>formats numbers and strings as in the C language</td>
+</tr>
+
+<tr>
+<td><a href="#get-char">get-char</a></td>
+
+<td>gets a character from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-float">get-float</a></td>
+<td>gets a double float from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-int">get-int</a>&nbsp;&nbsp;</td>
+<td>gets a 32-bit integer from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-long">get-long</a>&nbsp;&nbsp;</td>
+<td>gets a long 64-bit integer from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-string">get-string</a></td>
+<td>gets a string from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#int">int</a></td>
+<td>translates a string or float into an integer</td>
+</tr>
+
+<tr>
+<td><a href="#join">join</a></td>
+<td>joins a list of strings</td>
+</tr>
+
+<tr>
+<td><a href="#last">last</a></td>
+<td>returns the last element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#lower-case">lower-case</a></td>
+<td>converts a string to lowercase characters</td>
+</tr>
+
+<tr>
+<td><a href="#member">member</a></td>
+<td>finds a list or string member</td>
+</tr>
+
+<tr>
+<td><a href="#name">name</a></td>
+<td>returns the name of a symbol or its context as a string</td>
+</tr>
+
+<tr>
+<td><a href="#nth">nth</a></td>
+<td>gets the <em>nth</em> element in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#pack">pack</a></td>
+<td>packs newLISP expressions into a binary structure</td>
+</tr>
+
+<tr>
+<td><a href="#parse">parse</a></td>
+<td>breaks a string into tokens</td>
+</tr>
+
+<tr>
+<td><a href="#pop">pop</a></td>
+<td>pops from a string</td>
+</tr>
+
+<tr>
+<td><a href="#push">push</a></td>
+<td>pushes onto a string</td>
+</tr>
+
+<tr>
+<td><a href="#regex">regex</a></td>
+<td>performs a Perl-compatible regular expression search</td>
+</tr>
+
+<tr>
+<td><a href="#regex-comp">regex-comp</a></td>
+<td>pre-compiles a regular expression pattern</td>
+</tr>
+
+<tr>
+<td><a href="#replace">replace</a></td>
+<td>replaces elements in a list or string</td>
+
+</tr>
+
+<tr>
+<td><a href="#rest">rest</a></td>
+<td>gets all but the first element of a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#reverse">reverse</a></td>
+<td>reverses a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#rotate">rotate</a></td>
+<td>rotates a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#select">select</a></td>
+<td>selects and permutes elements from a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#setf">setf setq</a></td>
+<td>sets contents of a string reference</td>
+</tr>
+
+<tr>
+<td><a href="#slice">slice</a></td>
+<td>extracts a substring or sublist</td>
+</tr>
+
+<tr>
+<td><a href="#source">source</a></td>
+<td>returns the source required to bind a symbol as a string</td>
+</tr>
+
+<tr>
+<td><a href="#starts-with">starts-with</a></td>
+<td>checks the start of the string or list against a key string or list</td>
+</tr>
+
+<tr>
+<td><a href="#string">string</a></td>
+<td>transforms anything into a string</td>
+</tr>
+
+<tr>
+<td><a href="#sym">sym</a></td>
+<td>translates a string into a symbol</td>
+</tr>
+
+<tr>
+<td><a href="#title-case">title-case</a></td>
+
+<td>converts the first character of a string to uppercase</td>
+</tr>
+
+<tr>
+<td><a href="#trim">trim</a></td>
+<td>trims a string on one or both sides</td>
+</tr>
+
+<tr>
+<td><a href="#unicode">unicode</a></td>
+<td>converts ASCII or UTF-8 to UCS-4 Unicode</td>
+</tr>
+
+<tr>
+<td><a href="#utf8">utf8</a></td>
+<td>converts UCS-4 Unicode to UTF-8</td>
+</tr>
+
+<tr>
+<td><a href="#utf8len">utf8len</a></td>
+<td>returns length of an UTF-8 string in UTF-8 characters</td>
+</tr>
+
+
+<tr>
+<td><a href="#unpack">unpack</a></td>
+<td>unpacks a binary structure into newLISP expressions</td>
+</tr>
+
+<tr>
+
+<td><a href="#upper-case">upper-case</a></td>
+<td>converts a string to uppercase characters</td>
+</tr>
+
+</table><br/>
+
+<a name="floating_point"></a>
+<h3>Floating point math and special functions</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Floating point math and special functions">
+
+
+<tr>
+<td WIDTH="16%"><a href="#abs">abs</a></td>
+<td WIDTH="84%">returns the absolute value of a number</td>
+</tr>
+
+<tr>
+<td><a href="#acos">acos</a></td>
+<td>calculates the arc-cosine of a number</td>
+</tr>
+
+<tr>
+<td><a href="#acosh">acosh</a></td>
+<td>calculates the inverse hyperbolic cosine of a number</td>
+</tr>
+
+<tr>
+<td><a href="#add">add</a></td>
+<td>adds floating point or integer numbers and returns a floating point number</td>
+</tr>
+
+<tr>
+<td><a href="#array">array</a></td>
+<td>creates an array</td>
+</tr>
+
+<tr>
+<td><a href="#array-list">array-list</a></td>
+<td>returns a list conversion from an array</td>
+</tr>
+
+<tr>
+<td><a href="#asin">asin</a></td>
+<td>calculates the arcsine of a number</td>
+</tr>
+
+<tr>
+<td><a href="#asinh">asinh</a></td>
+<td>calculates the inverse hyperbolic sine of a number</td>
+</tr>
+
+
+<tr>
+<td><a href="#atan">atan</a></td>
+<td>calculates the arctangent of a number</td>
+</tr>
+
+<tr>
+<td><a href="#atanh">atanh</a></td>
+<td>calculates the inverse hyperbolic tangent of a number</td>
+</tr>
+
+<tr>
+<td><a href="#atan2">atan2</a></td>
+<td>computes the principal value of the arctangent of Y / X in radians</td>
+</tr>
+
+<tr>
+<td><a href="#beta">beta</a></td>
+<td>calculates the beta function</td>
+</tr>
+
+<tr>
+<td><a href="#betai">betai</a></td>
+<td>calculates the incomplete beta function</td>
+</tr>
+
+<tr>
+<td><a href="#binomial">binomial</a></td>
+<td>calculates the binomial function</td>
+</tr>
+
+<tr>
+<td><a href="#ceil">ceil</a></td>
+
+<td>rounds up to the next integer</td>
+</tr>
+
+<tr>
+<td><a href="#cos">cos</a></td>
+<td>calculates the cosine of a number</td>
+
+</tr>
+<tr>
+<td><a href="#cosh">cosh</a></td>
+<td>calculates the hyperbolic cosine of a number</td>
+</tr>
+
+<tr>
+<td><a href="#crc32">crc32</a></td>
+<td>calculates a 32-bit CRC for a data buffer</td>
+</tr>
+
+<tr>
+<td><a href="#dec">dec</a></td>
+<td>decrements a number in a variable, list or array</td>
+</tr>
+
+<tr>
+<td><a href="#div">div</a></td>
+<td>divides floating point or integer numbers</td>
+</tr>
+
+<tr>
+<td><a href="#erf">erf</a></td>
+<td>calculates the error function of a number</td>
+</tr>
+
+<tr>
+<td><a href="#exp">exp</a></td>
+<td>calculates the exponential <em>e</em> of a number</td>
+</tr>
+
+<tr>
+<td><a href="#factor">factor</a></td>
+<td>factors a number into primes</td>
+</tr>
+
+<tr>
+<td><a href="#fft">fft</a></td>
+<td>performs a fast Fourier transform (FFT)</td>
+</tr>
+
+<tr>
+<td><a href="#floor">floor</a></td>
+<td>rounds down to the next integer</td>
+</tr>
+
+<tr>
+<td><a href="#flt">flt</a></td>
+<td>converts a number to a 32-bit integer representing a float</td>
+</tr>
+
+<tr>
+<td><a href="#gammai">gammai</a></td>
+<td>calculates the incomplete Gamma function</td>
+</tr>
+
+<tr>
+<td><a href="#gammaln">gammaln</a></td>
+<td>calculates the log Gamma function</td>
+</tr>
+
+<tr>
+<td><a href="#gcd">gcd</a></td>
+<td>calculates the greatest common divisor of a group of integers</td>
+</tr>
+
+<tr>
+<td><a href="#ifft">ifft</a></td>
+<td>performs an inverse fast Fourier transform (IFFT)</td>
+</tr>
+
+<tr>
+<td><a href="#inc">inc</a></td>
+<td>increments a number in a variable, list or array</td>
+</tr>
+
+<tr>
+<td><a href="#infp">inf?</a></td>
+<td>checks if a floating point value is infinite</td>
+</tr>
+
+<tr>
+<td><a href="#log">log</a></td>
+<td>calculates the natural or other logarithm of a number</td>
+</tr>
+
+<tr>
+<td><a href="#min">min</a></td>
+<td>finds the smallest value in a series of values</td>
+</tr>
+
+<tr>
+<td><a href="#max">max</a></td>
+<td>finds the largest value in a series of values</td>
+
+</tr>
+
+<tr>
+<td><a href="#mod">mod</a></td>
+<td>calculates the modulo of two numbers</td>
+</tr>
+
+<tr>
+<td><a href="#mul">mul</a></td>
+<td>multiplies floating point or integer numbers</td>
+</tr>
+
+<tr>
+<td><a href="#NaNp">NaN?</a></td>
+<td>checks if a float is NaN (not a number)</td>
+</tr>
+
+<tr>
+<td><a href="#round">round</a></td>
+<td>rounds a number</td>
+</tr>
+
+<tr>
+<td><a href="#pow">pow</a></td>
+<td>calculates <em>x</em> to the power of <em>y</em></td>
+</tr>
+
+<tr>
+<td><a href="#sequence">sequence</a></td>
+<td>generates a list sequence of numbers</td>
+</tr>
+
+<tr>
+<td><a href="#series">series</a></td>
+
+<td>creates a geometric sequence of numbers</td>
+</tr>
+
+<tr>
+<td><a href="#sgn">sgn</a></td>
+<td>calculates the signum function of a number</td>
+</tr>
+
+<tr>
+<td><a href="#sin">sin</a></td>
+<td>calculates the sine of a number</td>
+</tr>
+
+<tr>
+<td><a href="#sinh">sinh</a></td>
+<td>calculates the hyperbolic sine of a number</td>
+</tr>
+
+<tr>
+<td><a href="#sqrt">sqrt</a></td>
+<td>calculates the square root of a number</td>
+</tr>
+
+<tr>
+<td><a href="#ssq">ssq</a></td>
+<td>calculates the sum of squares of a vector</td>
+</tr>
+
+<tr>
+<td><a href="#sub">sub</a></td>
+<td>subtracts floating point or integer numbers</td>
+</tr>
+
+<tr>
+<td><a href="#tan">tan</a></td>
+<td>calculates the tangent of a number</td>
+</tr>
+
+<tr>
+<td><a href="#tanh">tanh</a></td>
+<td>calculates the hyperbolic tangent of a number</td>
+</tr>
+
+<tr>
+<td><a href="#uuid">uuid</a>&nbsp;</td>
+<td>returns a UUID (Universal Unique IDentifier)</td>
+</tr>
+
+</table><br/>
+
+<a name="matrices"></a>
+<h3>Matrix functions</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Matrix functions">
+
+<tr>
+<td  WIDTH="16%"><a href="#det">det</a></td>
+<td  WIDTH="84%">returns the determinant of a matrix</td>
+</tr>
+
+<tr>
+<td><a href="#invert">invert</a></td>
+<td>returns the inversion of a matrix</td>
+</tr>
+
+<tr>
+<td><a href="#mat">mat</a></td>
+<td>performs scalar operations on matrices</td>
+</tr>
+
+<tr>
+<td><a href="#multiply">multiply</a></td>
+<td>multiplies two matrices</td>
+</tr>
+
+<tr>
+<td><a href="#transpose">transpose</a>&nbsp;</td>
+<td>returns the transposition of a matrix</td>
+</tr>
+
+</table><br/>
+
+<a name="array-funcs"></a>
+<h3>Array functions</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Array functions">
+
+<tr>
+<td width="16%" ><a href="#append">append</a></td>
+<td width="84%">appends arrays</td>
+</tr>
+
+<tr>
+<td><a href="#array">array</a></td>
+<td>creates and initializes an array with up to 16 dimensions</td>
+</tr>
+
+<tr>
+<td><a href="#array-list">array-list</a></td>
+<td>converts an array into a list</td>
+</tr>
+
+<tr>
+<td><a href="#arrayp">array?</a></td>
+<td>checks if expression is an array</td>
+</tr>
+
+<tr>
+<td ><a href="#det">det</a></td>
+<td>returns the determinant of a matrix</td>
+</tr>
+
+<tr>
+<td ><a href="#first">first</a></td>
+<td>returns the first row of an array</td>
+</tr>
+
+<tr>
+<td ><a href="#invert">invert</a></td>
+<td>returns the inversion of a matrix</td>
+</tr>
+
+<tr>
+<td ><a href="#last">last</a></td>
+<td>returns the last row of an array</td>
+</tr>
+
+<tr>
+<td><a href="#mat">mat</a></td>
+<td>performs scalar operations on matrices</td>
+</tr>
+
+
+<tr>
+<td ><a href="#multiply">multiply</a></td>
+<td>multiplies two matrices</td>
+</tr>
+
+<tr>
+<td ><a href="#nth">nth</a></td>
+<td>returns an element of an array</td>
+</tr>
+
+<tr>
+<td ><a href="#rest">rest</a></td>
+<td>returns all but the first row of an array</td>
+</tr>
+
+<tr>
+<td><a href="#setf">setf</a></td>
+<td>sets contents of an array reference</td>
+</tr>
+
+<tr>
+<td ><a href="#slice">slice</a></td>
+<td>returns a slice of an array</td>
+</tr>
+
+<tr>
+<td ><a href="#transpose">transpose</a></td>
+<td>transposes a matrix</td>
+</tr>
+</table><br/>
+
+<a name="bit_operators"></a>
+<h3>Bit operators</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="bit operators">
+
+
+<tr>
+<td WIDTH="16%"><a href="#bit_shift">&lt;&lt;, &gt;&gt;</a>&nbsp;&nbsp;&nbsp;</td>
+<td WIDTH="84%">bit shift left, bit shift right</td>
+</tr>
+
+<tr>
+<td><a href="#bit_and">&amp;</a></td>
+<td>bitwise and</td>
+</tr>
+
+<tr>
+<td><a href="#bit_inclusive">|</a></td>
+<td>bitwise inclusive or</td>
+
+</tr>
+
+<tr>
+<td><a href="#bit_exclusive">^</a></td>
+<td>bitwise exclusive or</td>
+</tr>
+
+<tr>
+<td><a href="#bit_not">~</a></td>
+<td>bitwise not</td>
+</tr>
+</table><br/>
+
+<a name="predicates"></a>
+<h3>Predicates</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Predicates">
+
+<tr>
+<td width="16%"><a href="#atomp">atom?</a></td>
+<td width="84%">checks if an expression is an atom</td>
+</tr>
+
+<tr>
+<td><a href="#arrayp">array?</a></td>
+<td>checks if an expression is an array</td>
+</tr>
+
+<tr>
+<td><a href="#bigintp">bigint?</a></td>
+<td>checks if a number is a big integer</td>
+</tr>
+
+<tr>
+<td><a href="#contextp">context?</a></td>
+<td>checks if an expression is a context</td>
+</tr>
+
+<tr>
+<td><a href="#directoryp">directory?</a></td>
+<td>checks if a disk node is a directory</td>
+</tr>
+
+<tr>
+<td><a href="#emptyp">empty?</a></td>
+<td>checks if a list or string is empty</td>
+</tr>
+
+<tr>
+<td><a href="#evenp">even?</a></td>
+<td>checks the parity of an integer number</td>
+</tr>
+
+<tr>
+<td><a href="#filep">file?</a></td>
+<td>checks if a file exists</td>
+</tr>
+
+<tr>
+<td><a href="#floatp">float?</a></td>
+<td>checks if an expression is a float</td>
+</tr>
+
+<tr>
+<td><a href="#globalp">global?</a></td>
+<td>checks if a symbol is global</td>
+</tr>
+
+<tr>
+<td><a href="#infp">inf?</a></td>
+<td>checks if a floating point value is infinite</td>
+</tr>
+
+<tr>
+<td><a href="#integerp">integer?</a></td>
+<td>checks if an expression is an integer</td>
+</tr>
+
+<tr>
+<td><a href="#lambdap">lambda?</a></td>
+<td>checks if an expression is a lambda expression</td>
+</tr>
+
+<tr>
+<td><a href="#legalp">legal?</a></td>
+<td>checks if a string contains a legal symbol</td>
+</tr>
+
+<tr>
+<td><a href="#listp">list?</a></td>
+<td>checks if an expression is a list</td>
+</tr>
+
+<tr>
+<td><a href="#macrop">macro?</a></td>
+<td>checks if an expression is a lambda-macro expression</td>
+</tr>
+
+<tr>
+<td><a href="#NaNp">NaN?</a></td>
+<td>checks if a float is NaN (not a number)</td>
+</tr>
+
+<tr>
+<td><a href="#nilp">nil?</a></td>
+<td>checks if an expression is <tt>nil</tt></td>
+</tr>
+
+<tr>
+<td><a href="#nullp">null?</a></td>
+<td>checks if an expression is <tt>nil</tt>, <tt>""</tt>, <tt>()</tt>, <tt>0</tt> or <tt>0.0</tt></td>
+</tr>
+
+<tr>
+<td><a href="#numberp">number?</a></td>
+<td>checks if an expression is a float or an integer</td>
+</tr>
+
+<tr>
+<td><a href="#oddp">odd?</a></td>
+<td>checks the parity of an integer number</td>
+</tr>
+
+<tr>
+<td><a href="#protectedp">protected?</a></td>
+<td>checks if a symbol is protected</td>
+</tr>
+
+<tr>
+<td><a href="#primitivep">primitive?</a></td>
+<td>checks if an expression is a primitive</td>
+</tr>
+
+<tr>
+<td><a href="#quotep">quote?</a></td>
+<td>checks if an expression is quoted</td>
+</tr>
+
+<tr>
+<td><a href="#stringp">string?</a></td>
+<td>checks if an expression is a string</td>
+</tr>
+
+<tr>
+<td><a href="#symbolp">symbol?</a></td>
+<td>checks if an expression is a symbol</td>
+</tr>
+
+<tr>
+<td><a href="#truep">true?</a></td>
+<td>checks if an expression is not <tt>nil</tt></td>
+</tr>
+
+<tr>
+<td><a href="#zerop">zero?</a></td>
+<td>checks if an expression is <tt>0</tt> or <tt>0.0</tt></td>
+</tr>
+
+</table><br/>
+
+<a name="timedate"></a>
+<h3>Date and time functions</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Time and date functions">
+
+<tr>
+<td WIDTH="16%"><a href="#date">date</a></td>
+<td WIDTH="84%">converts a date-time value to a string</td>
+</tr>
+
+<tr>
+<td><a href="#date-list">date-list</a></td>
+<td>returns a list of year, month, day, hours, minutes, seconds from a time value in seconds</td>
+</tr>
+
+<tr>
+<td><a href="#date-parse">date-parse</a></td>
+<td>parses a date string and returns the number of seconds passed since January 1, 1970, (formerly <tt>parse-date</tt>)</td>
+</tr>
+
+<tr>
+<td><a href="#date-value">date-value</a></td>
+<td>calculates the time in seconds since January 1, 1970 for a date and time</td>
+</tr>
+
+<tr>
+<td><a href="#now">now</a></td>
+<td>returns a list of current date-time information</td>
+</tr>
+
+<tr>
+<td><a href="#time">time</a></td>
+<td>calculates the time it takes to evaluate an expression in milliseconds</td>
+</tr>
+
+<tr>
+<td><a href="#time-of-day">time-of-day</a></td>
+<td>calculates the number of milliseconds elapsed since the day started</td>
+</tr>
+
+</table><br/>
+
+<a name="montecarlo"></a>
+<h3>Statistics, simulation and modeling functions</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Statistics, simulation and modelling math functions">
+
+
+<tr>
+<td width="16%"><a href="#amb">amb</a></td>
+<td width="84%">randomly selects an argument and evaluates it</td>
+</tr>
+
+<tr>
+<td width="16%"><a href="#bayes-query">bayes-query</a></td>
+<td width="84%">calculates Bayesian probabilities for a data set</td>
+</tr>
+
+<tr>
+<td width="16%"><a href="#bayes-train">bayes-train</a></td>
+<td width="84%">counts items in lists for Bayesian or frequency analysis</td>
+</tr>
+
+<tr>
+<td><a href="#corr">corr</a></td>
+<td>calculates the <em>product-moment correlation</em> coefficient</td>
+</tr>
+
+<tr>
+<td><a href="#crit-chi2">crit-chi2</a></td>
+<td>calculates the <em>Chi&sup2;</em> statistic for a given probability</td>
+</tr>
+
+<tr>
+<td><a href="#crit-f">crit-f</a></td>
+<td>calculates the <em>F</em> statistic for a given probability</td>
+</tr>
+
+<tr>
+<td><a href="#crit-t">crit-t</a></td>
+<td>calculates the <em>Student's t</em> statistic for a given probability</td>
+</tr>
+
+<tr>
+<td><a href="#crit-z">crit-z</a></td>
+<td>calculates the normal distributed <em>Z</em> for a given probability</td>
+</tr>
+
+<tr>
+<td><a href="#kmeans-query">kmeans-query</a></td>
+<td>calculates distances to cluster centroids or other data points</td>
+</tr>
+
+<tr>
+<td><a href="#kmeans-train">kmeans-train</a></td>
+<td>partitions a data set into clusters</td>
+</tr>
+
+<tr>
+<td><a href="#normal">normal</a></td>
+<td>makes a list of normal distributed floating point numbers</td>
+</tr>
+
+<tr>
+<td><a href="#prob-chi2">prob-chi2</a></td>
+<td>calculates the tail probability of a <em>Chi&sup2;</em> distribution value</td>
+</tr>
+
+<tr>
+<td><a href="#prob-f">prob-f</a></td>
+<td>calculates the tail probability of a <em>F</em> distribution value</td>
+</tr>
+
+<tr>
+<td><a href="#prob-t">prob-t</a></td>
+<td>calculates the tail probability of a <em>Student's t</em> distribution value</td>
+</tr>
+
+<tr>
+<td><a href="#prob-z">prob-z</a></td>
+<td>calculates the cumulated probability of a <em>Z</em> distribution value</td>
+</tr>
+
+<tr>
+<td><a href="#rand">rand</a></td>
+<td>generates random numbers in a range</td>
+</tr>
+
+<tr>
+<td><a href="#random">random</a></td>
+<td>generates a list of evenly distributed floats</td>
+</tr>
+
+<tr>
+<td><a href="#randomize">randomize</a></td>
+<td>shuffles all of the elements in a list</td>
+</tr>
+
+<tr>
+<td><a href="#seed">seed</a></td>
+<td>seeds the internal random number generator</td>
+</tr>
+
+<tr>
+<td><a href="#stats">stats</a></td>
+<td>calculates some basic statistics for a data vector</td>
+</tr>
+
+<tr>
+<td><a href="#t-test">t-test</a></td>
+<td>compares means of data samples using the <em>Student's t</em> statistic</td>
+</tr>
+
+</table><br/>
+
+<a name="pattern"></a>
+<h3>Pattern matching</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Time and date functions">
+
+<tr>
+<td><a href="#ends-with">ends-with</a></td>
+<td>tests if a list or string ends with a pattern</td>
+</tr>
+
+<tr>
+<td WIDTH="16%"><a href="#find">find</a></td>
+<td WIDTH="84%">searches for a pattern in a list or string</td>
+</tr>
+
+<tr>
+<td><a href="#find-all">find-all</a></td>
+<td>finds all occurrences of a pattern in a string</td>
+</tr>
+
+<tr>
+<td><a href="#match">match</a></td>
+<td>matches list patterns</td>
+</tr>
+
+<tr>
+<td><a href="#parse">parse</a></td>
+<td>breaks a string along around patterns</td>
+</tr>
+
+<tr>
+<td><a href="#ref">ref</a></td>
+<td>returns the position of an element inside a nested list</td>
+</tr>
+
+<tr>
+<td><a href="#ref-all">ref-all</a></td>
+<td>returns a list of index vectors of elements inside a nested list</td>
+</tr>
+
+<tr>
+<td><a href="#regex">regex</a></td>
+<td>finds patterns in a string</td>
+</tr>
+
+<tr>
+<td><a href="#replace">replace</a></td>
+<td>replaces patterns in a string</td>
+</tr>
+
+<tr>
+<td><a href="#search">search</a></td>
+<td>searches for a pattern in a file</td>
+</tr>
+
+<tr>
+<td><a href="#starts-with">starts-with</a></td>
+<td>tests if a list or string starts with a pattern</td>
+</tr>
+
+<tr>
+<td><a href="#unify">unify</a></td>
+<td>performs a logical unification of patterns</td>
+</tr>
+
+</table><br/>
+
+<a name="financial"></a>
+<h3>Financial math functions</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Financial math functions">
+
+<tr>
+<td WIDTH="16%"><a href="#fv">fv</a></td>
+<td WIDTH="84%">returns the future value of an investment</td>
+</tr>
+
+<tr>
+<td><a href="#irr">irr</a></td>
+<td>calculates the internal rate of return</td>
+</tr>
+
+<tr>
+<td><a href="#nper">nper</a></td>
+<td>calculates the number of periods for an investment</td>
+</tr>
+
+<tr>
+<td><a href="#npv">npv</a></td>
+<td>calculates the net present value of an investment</td>
+</tr>
+
+<tr>
+<td><a href="#pv">pv</a></td>
+
+<td>calculates the present value of an investment</td>
+</tr>
+
+<tr>
+<td><a href="#pmt">pmt</a></td>
+<td>calculates the payment for a loan</td>
+</tr>
+
+</table><br/>
+
+<a name="input_output"></a>
+<h3>Input/output and file operations</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Input/output and file operations">
+
+
+<tr>
+<td WIDTH="16%"><a href="#append-file">append-file</a></td>
+<td WIDTH="84%">appends data to a file</td>
+</tr>
+
+<tr>
+<td><a href="#close">close</a></td>
+<td>closes a file</td>
+</tr>
+
+<tr>
+<td><a href="#current-line">current-line</a></td>
+<td>retrieves contents of last read-line buffer</td>
+</tr>
+
+<tr>
+<td><a href="#device">device</a></td>
+<td>sets or inquires about current print device</td>
+</tr>
+
+<tr>
+
+<td><a href="#exec">exec</a></td>
+<td>launches another program, then reads from or writes to it</td>
+</tr>
+
+<tr>
+<td><a href="#load">load</a></td>
+<td>loads and evaluates a file of newLISP code</td>
+</tr>
+
+<tr>
+<td><a href="#open">open</a></td>
+<td>opens a file for reading or writing</td>
+
+</tr>
+
+<tr>
+<td><a href="#peek">peek</a></td>
+<td>checks file descriptor for number of bytes ready for reading</td>
+</tr>
+
+<tr>
+<td><a href="#print">print</a></td>
+<td>prints to the console or a device</td>
+</tr>
+
+<tr>
+
+<td><a href="#println">println</a></td>
+<td>prints to the console or a device with a line-feed</td>
+</tr>
+
+<tr>
+<td><a href="#read">read</a></td>
+<td>reads binary data from a file</td>
+</tr>
+
+<tr>
+<td><a href="#read-char">read-char</a></td>
+<td>reads an 8-bit character from a file</td>
+</tr>
+
+<tr>
+<td><a href="#read-file">read-file</a></td>
+<td>reads a whole file in one operation</td>
+</tr>
+
+<tr>
+<td><a href="#read-key">read-key</a></td>
+<td>reads a keyboard key</td>
+</tr>
+
+<tr>
+<td><a href="#read-line">read-line</a></td>
+<td>reads a line from the console or file</td>
+</tr>
+
+<tr>
+<td><a href="#read-utf8">read-utf8</a></td>
+<td>reads UTF-8 character from a file</td>
+</tr>
+
+<tr>
+<td><a href="#save">save</a></td>
+<td>saves a workspace, context, or symbol to a file</td>
+</tr>
+
+<tr>
+<td><a href="#search">search</a></td>
+<td>searches a file for a string</td>
+
+</tr>
+
+<tr>
+<td><a href="#seek">seek</a></td>
+<td>sets or reads a file position</td>
+</tr>
+
+<tr>
+<td><a href="#write">write</a></td>
+<td>writes binary data to a file</td>
+</tr>
+
+<tr>
+
+<td><a href="#write-char">write-char</a></td>
+<td>writes a character to a file</td>
+</tr>
+
+<tr>
+<td><a href="#write-file">write-file</a></td>
+<td>writes a file in one operation</td>
+</tr>
+
+<tr>
+<td><a href="#write-line">write-line</a></td>
+<td>writes a line to the console or a file</td>
+</tr>
+
+</table><br/>
+
+<a name="processes"></a>
+<h3>Processes and the Cilk API</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Processes and the Cilk API">
+
+<tr>
+<td WIDTH="16%"><a href="#shell">!</a></td>
+<td WIDTH="84%">shells out to the operating system</td>
+</tr>
+
+<tr>
+<td><a href="#abort">abort</a></td>
+<td>aborts a child process started with <tt>spawn</tt></td>
+</tr>
+
+<tr>
+<td><a href="#destroy">destroy</a></td>
+<td>destroys a process created with <tt>fork</tt> or <tt>process</tt></td>
+</tr>
+
+<tr>
+<td><a href="#exec">exec</a></td>
+<td>runs a process, then reads from or writes to it</td>
+</tr>
+
+<tr>
+<td><a href="#fork">fork</a></td>
+<td>launches a newLISP child process</td>
+</tr>
+
+<tr>
+<td><a href="#pipe">pipe</a></td>
+<td>creates a pipe for interprocess communication</td>
+</tr>
+
+<tr>
+<td><a href="#process">process</a></td>
+<td>launches a child process, remapping standard I/O and standard error</td>
+</tr>
+
+<tr>
+<td><a href="#receive">receive</a></td>
+<td>receive a message from another process</td>
+</tr>
+
+<tr>
+<td><a href="#semaphore">semaphore</a></td>
+<td>creates and controls semaphores</td>
+</tr>
+
+<tr>
+<td><a href="#send">send</a></td>
+<td>send a message to another process</td>
+</tr>
+
+
+<tr>
+<td><a href="#share">share</a></td>
+<td>shares memory with other processes</td>
+</tr>
+
+<tr>
+<td><a href="#spawn">spawn</a></td>
+<td>launches a child process for Cilk process management</td>
+</tr>
+
+<tr>
+<td><a href="#sync">sync</a></td>
+<td>waits for child processes launched with <tt>spawn</tt> and collects results</td>
+</tr>
+
+<tr>
+<td><a href="#wait-pid">wait-pid</a></td>
+<td>waits for a child process to end</td>
+</tr>
+
+</table><br/>
+
+<a name="directory_management"></a>
+<h3>File and directory management</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="File and directory management">
+
+<tr>
+<td WIDTH="16%"><a href="#change-dir">change-dir</a>&nbsp;</td>
+<td WIDTH="84%">changes to a different drive and directory</td>
+</tr>
+
+<tr>
+<td><a href="#copy-file">copy-file</a></td>
+<td>copies a file</td>
+</tr>
+
+<tr>
+<td><a href="#delete-file">delete-file</a></td>
+<td>deletes a file</td>
+</tr>
+
+<tr>
+<td><a href="#directory">directory</a></td>
+<td>returns a list of directory entries</td>
+</tr>
+
+<tr>
+<td><a href="#file-info">file-info</a></td>
+<td>gets file size, date, time, and attributes</td>
+</tr>
+
+<tr>
+<td><a href="#make-dir">make-dir</a></td>
+<td>makes a new directory</td>
+</tr>
+
+<tr>
+<td><a href="#real-path">real-path</a></td>
+<td>returns the full path of the relative file path</td>
+</tr>
+
+<tr>
+<td><a href="#remove-dir">remove-dir</a></td>
+<td>removes an empty directory</td>
+</tr>
+
+<tr>
+<td><a href="#rename-file">rename-file</a></td>
+<td>renames a file or directory</td>
+</tr>
+
+</table><br/>
+
+<a name="http_api"></a>
+<h3>HTTP networking API</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="HTTP networking API">
+
+
+<tr>
+<td width="16%"><a href="#base64-enc">base64-enc</a></td>
+<td width="84%">encodes a string into BASE64 format</td>
+</tr>
+
+<tr>
+<td><a href="#base64-dec">base64-dec</a></td>
+
+<td>decodes a string from BASE64 format</td>
+</tr>
+
+<tr>
+<td><a href="#delete-url">delete-url</a></td>
+<td>deletes a file or page from the web</td>
+</tr>
+
+<tr>
+<td><a href="#get-url">get-url</a></td>
+<td>reads a file or page from the web</td>
+</tr>
+
+<tr>
+<td><a href="#json-error">json-error</a></td>
+<td>returns error information from a failed JSON translation.</td>
+</tr>
+
+<tr>
+<td><a href="#json-parse">json-parse</a></td>
+<td>parses JSON formatted data</td>
+</tr>
+
+<tr>
+<td><a href="#post-url">post-url</a></td>
+<td>posts info to a URL address</td>
+</tr>
+
+<tr>
+<td><a href="#put-url">put-url</a></td>
+<td>uploads a page to a URL address</td>
+</tr>
+
+<tr>
+<td><a href="#xfer-event">xfer-event</a></td>
+<td>registers an event handler for HTTP byte transfers</td>
+</tr>
+
+<tr>
+<td><a href="#xml-error">xml-error</a></td>
+<td>returns last XML parse error</td>
+</tr>
+
+<tr>
+<td><a href="#xml-parse">xml-parse</a></td>
+
+<td>parses an XML document</td>
+</tr>
+
+<tr>
+<td><a href="#xml-type-tags">xml-type-tags</a>&nbsp;</td>
+<td>shows or modifies XML type tags</td>
+</tr>
+
+</table><br/>
+
+<a name="socket_tcpip"></a>
+<h3>Socket TCP/IP, UDP and ICMP network API</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Socket TCP/IP and UDP network API">
+
+
+<tr>
+<td WIDTH="16%"><a href="#net-accept">net-accept</a></td>
+<td WIDTH="84%">accepts a new incoming connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-close">net-close</a></td>
+<td>closes a socket connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-connect">net-connect</a></td>
+<td>connects to a remote host</td>
+</tr>
+
+<tr>
+<td><a href="#net-error">net-error</a></td>
+<td>returns the last error</td>
+</tr>
+
+<tr>
+<td><a href="#net-eval">net-eval</a></td>
+<td>evaluates expressions on multiple remote newLISP servers</td>
+</tr>
+
+<tr>
+<td><a href="#net-interface">net-interface</a></td>
+<td>Sets the default interface IP address on multihomed computers.</td>
+</tr>
+
+<tr>
+<td><a href="#net-ipv">net-ipv</a></td>
+<td>Switches between IPv4 and IPv6 internet protocol versions.</td>
+</tr>
+
+<tr>
+<td><a href="#net-listen">net-listen</a></td>
+<td>listens for connections to a local socket</td>
+</tr>
+
+<tr>
+<td><a href="#net-local">net-local</a></td>
+<td>returns the local IP and port number for a connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-lookup">net-lookup</a></td>
+<td>returns the name for an IP number</td>
+</tr>
+
+<tr>
+<td><a href="#net-packet">net-packet</a></td>
+<td>send a custom configured IP packet over raw sockets</td>
+</tr>
+
+<tr>
+<td><a href="#net-peek">net-peek</a></td>
+<td>returns the number of characters ready to be read from a network socket</td>
+</tr>
+
+<tr>
+<td><a href="#net-peer">net-peer</a></td>
+<td>returns the remote IP and port for a net connect</td>
+</tr>
+
+
+<tr>
+<td><a href="#net-ping">net-ping</a></td>
+<td>sends a ping packet (ICMP echo request) to one or more addresses</td>
+</tr>
+
+<tr>
+<td><a href="#net-receive">net-receive</a></td>
+<td>reads data on a socket connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-receive-from">net-receive-from</a>&nbsp;</td>
+<td>reads a UDP on an open connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-receive-udp">net-receive-udp</a></td>
+<td>reads a UDP and closes the connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-select">net-select</a></td>
+
+<td>checks a socket or list of sockets for status</td>
+</tr>
+
+<tr>
+<td><a href="#net-send">net-send</a></td>
+<td>sends data on a socket connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-send-to">net-send-to</a></td>
+<td>sends a UDP on an open connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-send-udp">net-send-udp</a></td>
+<td>sends a UDP and closes the connection</td>
+</tr>
+
+<tr>
+<td><a href="#net-service">net-service</a></td>
+<td>translates a service name into a port number</td>
+</tr>
+
+<tr>
+<td><a href="#net-sessions">net-sessions</a></td>
+
+<td>returns a list of currently open connections </td>
+</tr>
+
+</table><br/>
+
+<a name="JS"></a>
+<h3>API for newLISP in a web browser</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="API for newLISP in a web browser">
+
+<tr>
+<td width="16%"><a href="#display-html">display-html</a></td>
+<td width="84%">display an HTML page in a web browser</td>
+</tr>
+
+<tr>
+<td><a href="#eval-string-js">eval-string-js</a></td>
+<td>evaluate JavaScript in the current web browser page</td>
+</tr>
+
+</table><br/>
+
+
+<a name="reflection"></a>
+<h3>Reflection and customization</h3>
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Reflection and customization">
+
+<tr>
+<td width="16%"><a href="#command-event">command-event</a></td>
+<td width="84%">pre-processes the command-line and HTTP requests</td>
+</tr>
+
+<tr>
+<td><a href="#error-event">error-event</a></td>
+<td>defines an error handler</td>
+</tr>
+
+<tr>
+<td><a href="#last-error">last-error</a></td>
+<td>report the last error number and text</td>
+</tr>
+
+<tr>
+<td><a href="#macro">macro</a></td>
+<td>create a reader expansion macro</td>
+</tr>
+
+<tr>
+<td><a href="#ostype">ostype</a></td>
+<td>contains a string describing the OS platform</td>
+</tr>
+
+<tr>
+<td><a href="#prefix">prefix</a></td>
+<td>Returns the context prefix of a symbol</td>
+</tr>
+
+<tr>
+<td><a href="#prompt-event">prompt-event</a></td>
+<td>customizes the interactive newLISP shell prompt</td>
+</tr>
+
+<tr>
+<td><a href="#read-expr">read-expr</a></td>
+<td>reads and translates s-expressions from source</td>
+</tr>
+
+<tr>
+<td><a href="#reader-event">reader-event</a></td>
+<td>preprocess expressions before evaluation event-driven</td>
+</tr>
+
+<tr>
+<td><a href="#set-locale">set-locale</a></td>
+<td>switches to a different locale</td>
+</tr>
+
+<tr>
+<td><a href="#source">source</a></td>
+<td>returns the source required to bind a symbol to a string</td>
+</tr>
+
+<tr>
+<td><a href="#sys-error">sys-error</a></td>
+<td>reports OS system error numbers</td>
+</tr>
+
+<tr>
+<td><a href="#sys-info">sys-info</a></td>
+<td>gives information about system resources</td>
+</tr>
+
+<tr>
+<td><a href="#term">term</a></td>
+<td>returns the term part of a symbol or its context as a string</td>
+</tr>
+
+</table><br/>
+
+<a name="system_functions"></a>
+<h3>System functions</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="System functions">
+
+<tr>
+<td width="16%"><a href="#systemsymbol">$</a></td>
+<td width="84%">accesses system variables $0 -&gt; $15</td>
+</tr>
+
+<tr>
+<td><a href="#callback">callback</a></td>
+<td>registers a callback function for an imported library</td>
+</tr>
+
+<tr>
+<td><a href="#catch">catch</a></td>
+<td>evaluates an expression, catching errors and early returns</td>
+</tr>
+
+<tr>
+<td><a href="#context">context</a></td>
+<td>creates or switches to a different namespace</td>
+</tr>
+
+<tr>
+<td><a href="#copy">copy</a></td>
+<td>copies the result of an evaluation</td>
+</tr>
+
+<tr>
+<td><a href="#debug">debug</a></td>
+<td>debugs a user-defined function</td>
+</tr>
+
+<tr>
+<td><a href="#delete">delete</a></td>
+<td>deletes symbols from the symbol table</td>
+</tr>
+
+<tr>
+<td><a href="#default">default</a></td>
+<td>returns the contents of a default functor from a context</td>
+</tr>
+
+<tr>
+<td><a href="#env">env</a></td>
+<td>gets or sets the operating system's environment</td>
+</tr>
+
+<tr>
+<td><a href="#exit">exit</a></td>
+<td>exits newLISP, setting the exit value</td>
+</tr>
+
+<tr>
+<td><a href="#global">global</a></td>
+<td>makes a symbol accessible outside MAIN</td>
+</tr>
+
+<tr>
+<td><a href="#import">import</a></td>
+<td>imports a function from a shared library</td>
+</tr>
+
+<tr>
+<td><a href="#main-args">main-args</a></td>
+<td>gets command-line arguments</td>
+</tr>
+
+<tr>
+<td><a href="#new">new</a></td>
+<td>creates a copy of a context</td>
+</tr>
+
+<tr>
+<td><a href="#pretty-print">pretty-print</a></td>
+<td>changes the pretty-printing characteristics</td>
+</tr>
+
+<tr>
+<td><a href="#read-expr">read-expr</a></td>
+<td>translates a string to an s-expression without evaluating it</td>
+</tr>
+
+<tr>
+<td><a href="#reset">reset</a></td>
+<td>goes to the top level</td>
+</tr>
+
+<tr>
+<td><a href="#signal">signal</a></td>
+<td>sets a signal handler</td>
+</tr>
+
+<tr>
+<td><a href="#sleep">sleep</a></td>
+<td>suspends processing for specified milliseconds</td>
+</tr>
+
+<tr>
+<td><a href="#sym">sym</a></td>
+<td>creates a symbol from a string</td>
+</tr>
+
+<tr>
+<td><a href="#symbols">symbols</a></td>
+<td>returns a list of all symbols in the system</td>
+</tr>
+
+<tr>
+<td><a href="#throw">throw</a></td>
+<td>causes a previous <a href="#catch">catch</a> to return</td>
+</tr>
+
+<tr>
+<td><a href="#throw-error">throw-error</a></td>
+<td>throws a user-defined error</td>
+</tr>
+
+<tr>
+<td><a href="#timer">timer</a></td>
+<td>starts a one-shot timer, firing an event</td>
+</tr>
+
+<tr>
+<td><a href="#trace">trace</a></td>
+<td>sets or inquires about trace mode</td>
+</tr>
+
+<tr>
+<td><a href="#trace-highlight">trace-highlight</a></td>
+<td>sets highlighting strings in trace mode</td>
+</tr>
+
+</table><br/>
+
+<a name="importing_libraries"></a>
+<h3>Importing libraries</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="Importing libraries<">
+
+
+<tr>
+<td WIDTH="16%"><a href="#address">address</a></td>
+<td WIDTH="84%">returns the memory address of a number or string</td>
+
+</tr>
+
+<tr>
+<td><a href="#callback">callback</a></td>
+<td>registers a callback function for an imported library</td>
+</tr>
+
+<tr>
+<td><a href="#flt">flt</a></td>
+<td>converts a number to a 32-bit integer representing a float</td>
+</tr>
+
+<tr>
+<td><a href="#float">float</a></td>
+<td>translates a string or integer into a floating point number</td>
+</tr>
+
+<tr>
+
+<td><a href="#get-char">get-char</a></td>
+<td>gets a character from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-float">get-float</a></td>
+<td>gets a double float from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-int">get-int</a>&nbsp;&nbsp;</td>
+<td>gets a 32-bit integer from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-long">get-long</a>&nbsp;&nbsp;</td>
+<td>gets a long 64-bit integer from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#get-string">get-string</a></td>
+<td>gets a string from a memory address</td>
+</tr>
+
+<tr>
+<td><a href="#import">import</a></td>
+<td>imports a function from a shared library</td>
+</tr>
+
+<tr>
+
+<td><a href="#int">int</a></td>
+<td>translates a string or float into an integer</td>
+</tr>
+
+<tr>
+<td><a href="#pack">pack</a></td>
+<td>packs newLISP expressions into a binary structure</td>
+</tr>
+
+<tr>
+<td><a href="#struct">struct</a></td>
+<td>Defines a data structure with C types</td>
+</tr>
+
+<tr>
+<td><a href="#unpack">unpack</a></td>
+<td>unpacks a binary structure into newLISP expressions</td>
+
+</tr>
+</table><br/>
+
+<a name="internals"></a>
+<h3>newLISP internals API</h3>
+
+
+<table border="0" cellpadding="1" width="95%" align="center" summary="newLISP internals API">
+
+<tr>
+<td width="16%"><a href="#command-event">command-event</a></td>
+<td width="84%">pre-processes the command-line and HTTP requests</td>
+</tr>
+
+<tr>
+<td><a href="#cpymem">cpymem</a></td>
+<td>copies memory between addresses</td>
+</tr>
+
+<tr>
+<td><a href="#dump">dump</a></td>
+<td>shows memory address and contents of newLISP cells</td>
+</tr>
+
+<tr>
+<td><a href="#prompt-event">prompt-event</a></td>
+<td>customizes the interactive newLISP shell prompt</td>
+</tr>
+
+<tr>
+<td><a href="#read-expr">read-expr</a></td>
+<td>reads and translates s-expressions from source</td>
+</tr>
+
+<tr>
+<td><a href="#reader-event">reader-event</a></td>
+<td>preprocess expressions before evaluation event-driven</td>
+</tr>
+
+
+</table><br/>
+
+<br/>
+
+<center>
+<span class="divider">(&nbsp;<font color="#7ba9d4">&sect;</font>&nbsp;)</span>
+</center>
+
+<br/>
+
+<a name="functions_alphabetical"></a>
+<h2>4. Functions in alphabetical order</h2>
+
+<br/>
+
+<a name="shell"></a>
+<h2><span class="function">!</span></h2>
+<h4>syntax: (! <em>str-shell-command</em> [<em>int-flags</em>])</h4>
+
+<p>Executes the command in <em>str-command</em> by shelling out to the 
+operating system and executing.  This function returns a different value
+depending on the host operating system.</p>
+
+<!-- example -->
+
+<pre>
+(! "vi")  
+(! "ls -ltr")
+</pre>
+
+<p>Use the <a href="#exec">exec</a> function to execute a shell command 
+and capture the standard output or to feed standard input. 
+The <a href="#process">process</a> function may be used to launch a 
+non-blocking child process and redirect std I/O and std error to pipes.</p>
+
+<p>On Ms Windows the optional <em>int-flags</em> parameter takes process
+creation flags as defined for the Windows <tt>CreateProcessA</tt> function
+to control various parameters of process creation. The inclusion of this
+parameter &ndash; which also can be <tt>0</tt> &ndash; forces a different 
+creation of the process without a command shell window. This parameter is 
+ignored on Unix.</p>
+
+<pre>
+; on MS Windows
+; close the console of the currently running newLISP process
+(apply (import "kernel32" "FreeConsole")) 
+
+; start another process and wait for it to finish
+(! "notepad.exe" 0)
+
+(exit)
+</pre>
+
+<p>Without the additional parameter, the <tt>!</tt> call would create a
+new command window replacing the closed one.</p>
+
+<p>Note that <tt>!</tt> (exclamation mark) can be also be used as 
+a command-line shell operator by omitting the parenthesis and space 
+after the <tt>!</tt>:</p>
+
+<!-- example -->
+
+<pre>
+<b>&gt;</b> !ls -ltr    ; executed in the newLISP shell window
+</pre>
+
+
+<p>
+	Used in this way, 
+	the <tt>!</tt> operator 
+	is not a newLISP function at all, 
+	but rather a special feature of 
+	the newLISP command shell. 
+	The <tt>!</tt> must be entered 
+	as the first character
+	on the command-line.
+</p>
+
+<br/><br/>
+
+<a name="systemsymbol"></a>
+<h2><span class="function">$</span></h2>
+<h4>syntax: ($ <em>int-idx</em>)</h4>
+
+<p>
+The functions that use regular expressions 	(<a href="#directory">directory</a>,
+<a href="#ends-with">ends-with</a>, <a href="#find">find</a>, <a href="#find-all">find-all</a>, 
+<a href="#parse">parse</a>, <a href="#regex">regex</a>, <a href="#search">search</a>, 
+<a href="#starts-with">starts-with</a> and <a href="#replace">replace</a>) 
+all bind their results to the predefined system variables <tt>$0</tt>, <tt>$1</tt>, 
+<tt>$2</tt>&ndash;<tt>$15</tt> after or during the function's execution. System variables 
+can be treated the same as any other symbol. As an alternative, the contents of these 
+variables may also be accessed by using <tt>($ 0)</tt>, <tt>($ 1)</tt>, <tt>($ 2)</tt>, 
+etc. This method allows indexed access (i.e., <tt>($ i)</tt>, where <tt>i</tt> is an integer).</p>
+
+<!-- example -->
+
+<pre>
+(set 'str  "http://newlisp.org:80")
+(find "http://(.*):(.*)" str 0)  <span class='arw'>&rarr;</span> 0
+                                 
+$0  <span class='arw'>&rarr;</span> "http://newlisp.org:80"
+$1  <span class='arw'>&rarr;</span> "newlisp.org"
+$2  <span class='arw'>&rarr;</span> "80"
+                                 
+($ 0)  <span class='arw'>&rarr;</span> "http://newlisp.org:80"
+($ 1)  <span class='arw'>&rarr;</span> "newlisp.org"
+($ 2)  <span class='arw'>&rarr;</span> "80"
+</pre>
+
+<br/><br/>
+
+<a name="arithmetic"></a>
+<h2><span class="function">+, -, *, / ,%</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (+ <em>int-1</em> [<em>int-2</em> ... ])</h4>
+
+<p>Returns the sum of all numbers in <em>int-1</em> &mdash;.</p>
+
+<h4>syntax: (- <em>int-1</em> [<em>int-2</em> ... ])</h4>
+
+<p>Subtracts <em>int-2</em> from <em>int-1</em>, then the next <em>int-i</em> 
+from the previous result. If only one argument is given, 
+its sign is reversed. </p>
+
+<h4>syntax: (* <em>int-1</em> [<em>int-2</em> ... ])</h4>
+
+<p>The product is calculated for <em>int-1</em> to <em>int-i</em>.</p>
+
+<h4>syntax: (/ <em>int-1</em> [<em>int-2</em> ... ])</h4>
+
+<p>Each result is divided successively until the end of the list is reached. 
+Division by zero causes an error.</p>
+
+<h4>syntax: (% <em>int-1</em> [<em>int-2</em> ... ])</h4>
+
+<p>Each result is divided successively by the next <em>int</em>, 
+then the rest (modulo operation) is returned. Division by zero causes an error. 
+For floating point numbers, use the <a href="#mod">mod</a> function.</p>
+
+<!-- example -->
+
+<pre>
+(+ 1 2 3 4 5)        <span class='arw'>&rarr;</span> 15
+(+ 1 2 (- 5 2) 8)    <span class='arw'>&rarr;</span> 14
+(- 10 3 2 1)         <span class='arw'>&rarr;</span> 4
+(- (* 3 4) 6 1 2)    <span class='arw'>&rarr;</span> 3
+(- 123)              <span class='arw'>&rarr;</span> -123
+(map - '(10 20 30))  <span class='arw'>&rarr;</span> (-10 -20 -30)
+(* 1 2 3)            <span class='arw'>&rarr;</span> 6
+(* 10 (- 8 2))       <span class='arw'>&rarr;</span> 60
+(/ 12 3)             <span class='arw'>&rarr;</span> 4
+(/ 120 3 20 2)       <span class='arw'>&rarr;</span> 1
+(% 10 3)             <span class='arw'>&rarr;</span> 1
+(% -10 3)            <span class='arw'>&rarr;</span> -1
+(+ 1.2 3.9)          <span class='arw'>&rarr;</span> 4
+</pre>
+
+
+<p>Floating point values in arguments to 
+<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, <tt>/</tt>, and <tt>%</tt> 
+are truncated to the integer value closest to <tt>0</tt> (zero).
+</p>
+
+<p>
+Floating point values larger or smaller than
+the maximum (<tt>9,223,372,036,854,775,807</tt>)
+or minimum (<tt>-9,223,372,036,854,775,808</tt>) integer values 
+are truncated to those values. This includes the values for
+<tt>+Inf</tt> and <tt>-Inf</tt>.
+</p>
+
+<p>
+Calculations resulting in values 
+larger than <tt>9,223,372,036,854,775,807</tt> 
+or smaller than <tt>-9,223,372,036,854,775,808</tt> 
+wrap around from positive to negative 
+or negative to positive.
+</p>
+
+<p>
+Floating point values that evaluate to <tt>NaN</tt> (Not a Number), 
+ar treated as <tt>0</tt> (zero). 
+</p>
+
+<br/><br/>
+
+<a name="inci"></a>
+<h2><span class="function">++</span>&nbsp;<a href="#destructive">!</a>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (++ <em>place</em> [<em>num</em> ... ])</h4>
+
+<p>The <tt>++</tt> operator works like <a href="#inc">inc</a>, but performs
+integer arithmetic. Without the optional argument in <em>num</em>,
+<tt>++</tt> increments the number in <em>place</em> by <tt>1</tt>.</p>
+
+<p>If floating point numbers are passed as arguments, their fractional part
+gets truncated first.</p>
+
+<p>Calculations resulting in numbers greater than 9,223,372,036,854,775,807 wrap 
+around to negative numbers.  Results smaller than -9,223,372,036,854,775,808 
+wrap around to positive numbers.</p>
+
+<p><em>place</em> is either a symbol or a place in a list structure holding a
+number, or a number returned by an expression.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 1)    
+(++ x)        <span class='arw'>&rarr;</span> 2
+(set 'x 3.8)
+(++ x)        <span class='arw'>&rarr;</span> 4
+(++ x 1.3)    <span class='arw'>&rarr;</span> 5
+(set 'lst '(1 2 3))
+(++ (lst 1) 2))  <span class='arw'>&rarr;</span> 4
+lst              <span class='arw'>&rarr;</span> (1 4 3)
+</pre>
+
+<p>If the symbol for <em>place</em> contains <tt>nil</tt>, it is treated
+as if containing <tt>0</tt>.</p>
+
+<p>See <a href="#deci">--</a> for decrementing numbers in integer mode.
+See <a href="#inc">inc</a> for incrementing numbers in floating point mode.</p>
+
+<br/><br/>
+
+<a name="deci"></a>
+<h2><span class="function">--</span>&nbsp;<a href="#destructive">!</a>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (-- <em>place</em> [<em>num</em> ... ])</h4>
+
+<p>The <tt>--</tt> operator works like <a href="#inc">dec</a>, but performs
+integer arithmetic. Without the optional argument in <em>num-2</em>,
+<tt>--</tt> decrements the number in <em>place</em> by <tt>1</tt>.</p>
+
+<p>If floating point numbers are passed as arguments, their fractional part
+gets truncated first.</p>
+
+<p>Calculations resulting in numbers greater than 9,223,372,036,854,775,807 wrap 
+around to negative numbers.  Results smaller than -9,223,372,036,854,775,808 
+wrap around to positive numbers.</p>
+
+<p><em>place</em> is either a symbol or a place in a list structure holding a
+number, or a number returned by an expression.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 1)    
+(-- x)        <span class='arw'>&rarr;</span> 0
+(set 'x 3.8)
+(-- x)        <span class='arw'>&rarr;</span> 2
+(-- x 1.3)    <span class='arw'>&rarr;</span> 1
+
+(set 'lst '(1 2 3))
+(-- (lst 1) 2))  <span class='arw'>&rarr;</span> 0
+lst              <span class='arw'>&rarr;</span> (1 0 3)
+</pre>
+
+<p>If the symbol for <em>place</em> contains <tt>nil</tt>, it is treated
+as if containing <tt>0</tt>.</p>
+
+<p>See <a href="#inci">++</a> for incrementing numbers in integer mode.
+See <a href="#dec">dec</a> for decrementing numbers in floating point mode.</p>
+
+<br/><br/>
+<a name="logical"></a>
+<h2><span class="function">&lt;, &gt;, =, &lt;=, &gt;=, !=</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (&lt; <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (&gt; <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (= <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (&lt;= <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (&gt;= <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (!= <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+Expressions are evaluated and the results are compared successively. 
+As long as the comparisons conform to the comparison operators, 
+evaluation and comparison will continue until all arguments are tested 
+and the result is <tt>true</tt>. As soon as one comparison fails, 
+<tt>nil</tt> is returned.
+</p>
+
+<p>If only one argument is supplied, all comparison operators assume <tt>0</tt> (zero)
+as a second argument. This can be used to check if a number is negative, positive, zero 
+or not zero.</p>
+
+
+<p>
+All types of expressions can be compared: 
+	atoms, numbers, symbols, and strings. 
+	List expressions can also be compared 
+	(list elements are compared recursively).
+</p>
+
+<p>
+	When comparing lists, 
+	elements at the beginning of the list 
+	are considered more significant than the elements following 
+	(similar to characters in a string). 
+	When comparing lists of different lengths but equal elements, 
+	the longer list is considered greater (see examples).
+</p>
+
+<p>
+	In mixed-type expressions, 
+	the types are compared from lowest to highest. 
+	Floats and integers are compared by first
+	converting them to the needed type, 
+	then comparing them as numbers.
+</p>
+
+<blockquote>
+<b>Atoms:</b> nil, true, integer or float, string, symbol, primitive<br/>
+<b>Lists:</b> quoted list/expression, list/expression, lambda, lambda-macro
+</blockquote>
+
+<!-- example -->
+<pre>
+(&lt; 3 5 8 9)                     <span class='arw'>&rarr;</span> true
+(&gt; 4 2 3 6)                     <span class='arw'>&rarr;</span> nil
+(&lt; "a" "c" "d")                 <span class='arw'>&rarr;</span> true
+(&gt;= duba aba)                   <span class='arw'>&rarr;</span> true
+(&lt; '(3 4) '(1 5))               <span class='arw'>&rarr;</span> nil
+(&gt; '(1 2 3) '(1 2))             <span class='arw'>&rarr;</span> true
+(= '(5 7 8) '(5 7 8))           <span class='arw'>&rarr;</span> true
+(!= 1 4 3 7 3)                  <span class='arw'>&rarr;</span> true
+(&lt; 1.2 6 "Hello" 'any '(1 2 3))           <span class='arw'>&rarr;</span> true
+(&lt; nil true)                              <span class='arw'>&rarr;</span> true
+(&lt; '(((a b))) '(((b c))))                 <span class='arw'>&rarr;</span> true
+(&lt; '((a (b c)) '(a (b d)) '(a (b (d)))))  <span class='arw'>&rarr;</span> true
+
+; with single argument compares against 0
+
+(&gt; 1)    <span class='arw'>&rarr;</span> true ; checks for positive
+(&gt; -1)   <span class='arw'>&rarr;</span> nil ; checks for negative
+(= 123)  <span class='arw'>&rarr;</span> nil ; checks for zero
+
+(map &gt; '(1 3 -4 -3 1 2))   <span class='arw'>&rarr;</span> (true true nil nil true true)
+</pre>
+
+<br/><br/>
+
+<a name="bit_shift"></a>
+<h2><span class="function">&lt;&lt;, &gt;&gt;</span></h2>
+<h4>syntax: (&lt;&lt; <em>int-1</em> <em>int-2</em> [<em>int-3</em> ... ])<br/>
+
+syntax: (&gt;&gt; <em>int-1</em> <em>int-2</em> [<em>int-3</em> ... ])<br/>
+
+syntax: (&lt;&lt; <em>int-1</em>)<br/>
+syntax: (&gt;&gt; <em>int-1</em>)</h4>
+
+<p>
+	The number <em>int-1</em> is arithmetically shifted 
+	to the left or right by the number of bits given as <em>int-2</em>, 
+	then shifted by <em>int-3</em> and so on. 
+	For example, 64-bit integers may be shifted up to 63 positions. 
+	When shifting right, 
+	the most significant bit is duplicated 
+	(<em>arithmetic shift</em>):
+</p>
+
+
+<pre>
+(&gt;&gt; 0x8000000000000000 1)  <span class='arw'>&rarr;</span> 0xC000000000000000  ; not 0x0400000000000000!
+</pre>
+
+<br/>
+<!-- example -->
+
+<pre>
+(&lt;&lt; 1 3)      <span class='arw'>&rarr;</span>  8
+(&lt;&lt; 1 2 1)    <span class='arw'>&rarr;</span>  8
+(&gt;&gt; 1024 10)  <span class='arw'>&rarr;</span>  1
+(&gt;&gt; 160 2 2)  <span class='arw'>&rarr;</span> 10
+
+(&lt;&lt; 3)        <span class='arw'>&rarr;</span>  6
+(&gt;&gt; 8)        <span class='arw'>&rarr;</span>  4
+</pre>
+
+
+<p>When <em>int-1</em> is the only argument <tt>&lt;&lt;</tt>
+and <tt>&gt;&gt;</tt> shift by one bit.
+</p>
+
+<br/><br/>
+
+<a name="bit_and"></a>
+<h2><span class="function">&amp;</span></h2>
+<h4>syntax: (&amp; <em>int-1</em> <em>int-2</em> [<em>int-3</em> ... ])</h4>
+
+<p>
+	A bitwise <tt>and</tt> operation is performed 
+	on the number in <em>int-1</em> with the number in <em>int-2</em>, 
+	then successively with <em>int-3</em>, etc.
+</p>
+
+<!-- example -->
+
+<pre>
+(&amp; 0xAABB 0x000F)  <span class='arw'>&rarr;</span> 11  ; which is 0xB
+</pre>
+
+<br/><br/>
+
+<a name="bit_inclusive"></a>
+<h2><span class="function">|</span></h2>
+<h4>syntax: (| <em>int-1</em> <em>int-2</em> [<em>int-3</em> ... ])</h4>
+
+<p>
+	A bitwise <tt>or</tt> operation is performed 
+	on the number in <em>int-1</em> with the number in <em>int-2</em>, 
+	then successively with <em>int-3</em>, etc.
+</p>
+
+<!-- example -->
+
+<pre>
+(| 0x10 0x80 2 1)  <span class='arw'>&rarr;</span> 147
+</pre>
+
+<br/><br/>
+
+<a name="bit_exclusive"></a>
+<h2><span class="function">^</span></h2>
+<h4>syntax: (^ <em>int-1</em> <em>int-2</em> [<em>int-3</em> ... ])</h4>
+
+<p>
+	A bitwise <tt>xor</tt> operation is performed 
+	on the number in <em>int-1</em> with the number in <em>int-2</em>, 
+	then successively with <em>int-3</em>, etc.
+</p>
+
+<!-- example -->
+
+<pre>
+(^ 0xAA 0x55)  <span class='arw'>&rarr;</span> 255
+</pre>
+
+<br/><br/>
+
+<a name="bit_not"></a>
+<h2><span class="function">~</span></h2>
+<h4>syntax: (~ <em>int</em>)</h4>
+
+<p>
+	A bitwise <tt>not</tt> operation is performed 
+	on the number in <em>int</em>,
+	reversing all of the bits.
+</p>
+
+<!-- example -->
+
+<pre>
+(format "%X" (~ 0xFFFFFFAA))  <span class='arw'>&rarr;</span> "55"
+(~ 0xFFFFFFFF)                <span class='arw'>&rarr;</span> 0
+</pre>
+
+<br/><br/>
+
+<a name="colon"></a>
+<h2><span class="function">:</span></h2>
+<h4>syntax: (: <em>sym-function</em> <em>list-object</em> [ ... ])</h4>
+
+<p>The colon is used not only as a syntactic separator between
+namespace prefix  and the term inside but also as an operator.
+When used as an operator, the colon <tt>:</tt> constructs a 
+context symbol from the context name in the object list and the 
+symbol following the colon. The object list in <em>list-object</em> 
+can be followed by other parameters.</p>
+
+<p>The <tt>:</tt> operator implements <em>polymorphism</em> of 
+object methods, which are part of different object classes 
+represented by contexts (namespaces). In newLISP, an object is 
+represented by a list, the first element of which is the 
+symbol (name) of its class context.
+The class context implements the functions applicable to the object. 
+No space is required between the colon and the symbol following it.</p>
+
+<!-- example -->
+
+<pre>
+(define (Rectangle:area)
+    (mul (self 3) (self 4)))
+
+(define (Circle:area)
+    (mul (pow (self 3) 2) (acos 0) 2))
+
+(define (Rectangle:move dx dy)
+    (inc (self 1) dx) 
+	(inc (self 2) dy)) 
+
+(define (Circle:move p dx dy)
+    (inc (self 1) dx) (inc (self 2) dy)) 
+
+(set 'myrect '(Rectangle 5 5 10 20)) ; x y width height
+(set 'mycircle '(Circle 1 2 10)) ; x y radius
+
+;; using the : (colon) operator to resolve to a specific context
+
+(:area myrect)     <span class='arw'>&rarr;</span> 200
+(:area mycircle)   <span class='arw'>&rarr;</span> 314.1592654
+
+;; map class methods uses curry to enclose the colon operator and class function
+
+(map (curry :area) (list myrect mycircle)) <span class='arw'>&rarr;</span> (200 314.1592654)
+
+(map (curry :area) '((Rectangle 5 5 10 20) (Circle 1 2 10))) <span class='arw'>&rarr;</span> (200 314.1592654) 
+
+;; change object attributes using a function and re-assigning
+;; to the objects name
+
+(:move myrect 2 3)       
+myrect   <span class='arw'>&rarr;</span> (Rectangle 7 8 10 20)
+
+(:move mycircle 4 5)   
+mycircle <span class='arw'>&rarr;</span> (Circle 5 7 10)
+</pre>
+
+<p>Inside the FOOP methods the <a href="#self">self</a> function is used to access
+the target object of the method.</p>
+
+<br/><br/>
+
+<a name="abort"></a>
+<h2><span class="function">abort</span></h2>
+<h4>syntax: (abort <em>int-pid</em>)<br/>
+syntax: (abort)</h4>
+
+<p>In the first form, <tt>abort</tt> aborts a specific child process of the
+current parent process giving the process id in <em>int-pid</em>. The process
+must have been started using <a href="#spawn">spawn</a>. For processes
+started using <a href="#fork">fork</a>, use <a href="#destroy">destroy</a>
+instead.</p>
+
+<p>The function <tt>abort</tt> is not available on Windows.</p>
+
+
+<!-- example -->
+
+<pre>
+(abort 2245)  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>To abort all child processes spawned from the current process use <tt>abort</tt>
+without any parameters:</p>
+
+
+<pre>
+(abort)  <span class='arw'>&rarr;</span> true ; abort all
+</pre>
+
+
+<p>The function <tt>abort</tt> is part of the Cilk API for synchronizing
+child processes and process parallelization. See the reference for the
+function <a href="#spawn">spawn</a> for a full discussion of the Cilk API.</p>
+
+<br/><br/>
+
+<a name="abs"></a>
+<h2><span class="function">abs</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (abs <em>num</em>)</h4>
+
+<p>
+	Returns the absolute value of the number in <em>num</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(abs -3.5)  <span class='arw'>&rarr;</span> 3.5
+</pre>
+
+<br/><br/>
+
+<a name="acos"></a>
+<h2><span class="function">acos</span></h2>
+<h4>syntax: (acos <em>num-radians</em>)</h4>
+
+<p>
+	The arc-cosine function is calculated 
+	from the number in <em>num-radians</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(acos 1)  <span class='arw'>&rarr;</span> 0
+(cos (acos 1)) <span class='arw'>&rarr;</span> 1
+</pre>
+
+<br/><br/>
+
+<a name="acosh"></a>
+<h2><span class="function">acosh</span></h2>
+<h4>syntax: (acosh <em>num-radians</em>)</h4>
+
+<p>Calculates the inverse hyperbolic cosine of <em>num-radians</em>, 
+the value whose hyperbolic cosine is <em>num-radians</em>. 
+If <em>num-radians</em> is less than 1, 
+<tt>acosh</tt> returns <tt>NaN</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(acosh 2)  <span class='arw'>&rarr;</span> 1.316957897
+(cosh (acosh 2)) <span class='arw'>&rarr;</span> 2
+(acosh 0.5) <span class='arw'>&rarr;</span> NaN
+</pre>
+
+<br/><br/>
+
+
+<a name="add"></a>
+<h2><span class="function">add</span></h2>
+<h4>syntax: (add <em>num-1</em> [<em>num-2</em> ... ])</h4>
+
+<p>
+	All of the numbers in <em>num-1</em>, <em>num-2</em>, and on 
+	are summed.
+	<tt>add</tt> accepts float or integer operands, 
+	but it always returns a floating point number. 
+	Any floating point calculation with <tt>NaN</tt> 
+	also returns <tt>NaN</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(add 2 3.25 9)   <span class='arw'>&rarr;</span> 14.25
+(add 1 2 3 4 5)  <span class='arw'>&rarr;</span> 15
+</pre>
+
+<br/><br/>
+
+<a name="address"></a>
+<h2><span class="function">address</span></h2>
+<h4>syntax: (address <em>int</em>)<br/>
+
+syntax: (address <em>float</em>)<br/>
+syntax: (address <em>str</em>)</h4>
+
+<p>
+	Returns the memory address of the integer in <em>int</em>, 
+	the double floating point number in <em>float</em>, 
+	or the string in <em>str</em>. 
+	This function is used for passing parameters to library functions 
+	that have been imported using the <a href="#import">import</a> function.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 's "\001\002\003\004")
+
+(get-char (+ (address s) 3))   <span class='arw'>&rarr;</span> 4
+
+(set 'x 12345) ; x is a 64-bit long int
+
+; on a big-endian CPU, i.e. PPC or SPARC 
+(get-long (address x))         <span class='arw'>&rarr;</span> 12345
+; the 32-bit int is in high 32-bit part of the long int
+(get-int (+ (address x) 4))    <span class='arw'>&rarr;</span> 12345
+
+; on a little-endian CPU, i.e. Intel i386
+; the 32-bit int is in the low 32-bit part of the long int
+(get-int (address x))          <span class='arw'>&rarr;</span> 12345
+
+; on both architectures (integers are 64 bit in newLISP)
+(set 'x 1234567890)
+(get-long (address x))         <span class='arw'>&rarr;</span>  1234567890
+
+</pre>
+
+
+<p>
+When a string is passed to C library function the address of the string is 
+used automatically, and it is not necessary to use the <tt>address</tt> 
+function in that case. As the example shows, <tt>address</tt> can be used 
+to do pointer arithmetic on the string's address.</p>
+
+<p><tt>address</tt> should only be used on persistent addresses from
+data objects referred to by a variable symbol, not from volatile intermediate
+expression objects.</p>
+
+<p>
+	See also the <a href="#get-char">get-char</a>, <a href="#get-int">get-int</a>, 
+	<a href="#get-long">get-long</a> and <a href="#get-float">get-float</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="amb"></a>
+<h2><span class="function">amb</span></h2>
+
+<h4>syntax: (amb <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+	One of the expressions <em>exp-1</em> ... <em>n</em> is selected at random, 
+	and the evaluation result is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(amb 'a 'b 'c 'd 'e)  <span class='arw'>&rarr;</span> one of: a, b, c, d, or e at random
+
+(dotimes (x 10) (print (amb 3 5 7)))  <span class='arw'>&rarr;</span> 35777535755
+</pre>
+
+
+<p>
+	Internally, newLISP uses the same function as <a href="#rand">rand</a> to pick a random number. 
+	To generate random floating point numbers, 
+	use <a href="#random">random</a>, 
+	<a href="#randomize">randomize</a>, or <a href="#normal">normal</a>. 
+	To initialize the pseudo random number generating process 
+	at a specific starting point,
+	use the <a href="#seed">seed</a> function.
+</p>
+
+<br/><br/>
+
+<a name="and"></a>
+<h2><span class="function">and</span></h2>
+<h4>syntax: (and <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+	The expressions <em>exp-1</em>, <em>exp-2</em>, <em>etc.</em> are evaluated in order,
+	returning the result of the last expression.
+	If any of the expressions yield <tt>nil</tt> or the empty list <tt>()</tt>, 
+	evaluation is terminated and <tt>nil</tt> or the empty list <tt>()</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 10)                       <span class='arw'>&rarr;</span> 10
+(and (&lt; x 100) (&gt; x 2))           <span class='arw'>&rarr;</span> true
+(and (&lt; x 100) (&gt; x 2) "passed")  <span class='arw'>&rarr;</span> "passed"
+(and '())                         <span class='arw'>&rarr;</span> ()
+(and true)                        <span class='arw'>&rarr;</span> true
+(and)                             <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="append"></a>
+<h2><span class="function">append</span></h2>
+<h4>syntax: (append <em>list-1</em> [<em>list-2</em> ... ])<br/>
+syntax: (append <em>array-1</em> [<em>array-2</em> ... ])<br/>
+syntax: (append <em>str-1</em> [<em>str-2</em> ... ])</h4>
+
+<p>In the first form, <tt>append</tt> works with lists, 
+appending <em>list-1</em> through <em>list-n</em> to form a new list. 
+The original lists are left unchanged.</p>
+
+<!-- example -->
+
+<pre>
+(append '(1 2 3) '(4 5 6) '(a b))  <span class='arw'>&rarr;</span> (1 2 3 4 5 6 a b)
+
+(set 'aList '("hello" "world"))    <span class='arw'>&rarr;</span> ("hello" "world")
+
+(append aList '("here" "I am"))    <span class='arw'>&rarr;</span> ("hello" "world" "here" "I am")
+</pre>
+
+
+<p>In the second form <tt>append</tt> works on arrays:</p>
+
+<!-- example -->
+
+<pre>
+(set 'A (array 3 2 (sequence 1 6)))
+<span class='arw'>&rarr;</span> ((1 2) (3 4) (5 6))
+(set 'B (array 2 2 (sequence 7 10)))
+<span class='arw'>&rarr;</span> ((7 8) (9 10))
+
+(append A B)
+<span class='arw'>&rarr;</span> ((1 2) (3 4) (5 6) (7 8) (9 10))
+
+(append B B B)
+<span class='arw'>&rarr;</span> ((7 8) (9 10) (7 8) (9 10) (7 8) (9 10))
+
+</pre>
+
+
+<p>
+In the third form, <tt>append</tt> works on strings.  The strings in 
+<em>str-n</em> are concatenated into a new string and returned.</p>
+
+<!-- example -->
+
+<pre>
+(set 'more " how are you")       <span class='arw'>&rarr;</span> " how are you"
+
+(append "Hello " "world," more)  <span class='arw'>&rarr;</span> "Hello world, how are you"
+</pre>
+
+
+<p>
+<tt>append</tt> is also suitable for processing binary strings containing zeroes.
+The <a href="#string">string</a> function would cut off strings at zero bytes.</p>
+
+<p>
+Linkage characters or strings can be specified using the 
+<a href="#join">join</a> function. Use the <a href="#string">string</a> 
+function to convert arguments to strings and append in one step.</p>
+
+<p>Use the functions <a href="#extend">extend</a> and <a href="#push">push</a>
+to append to an existing list or string modifying the target.</p>
+
+<br/><br/>
+
+<a name="append-file"></a>
+<h2><span class="function">append-file</span></h2>
+<h4>syntax: (append-file <em>str-filename</em> <em>str-buffer</em>)</h4>
+
+<p>
+Works similarly to <a href="#write-file">write-file</a>, but the content 
+in <em>str-buffer</em> is appended if the file in <em>str-filename</em> exists. 
+If the file does not exist, it is created (in this case, <tt>append-file</tt> 
+works identically to <a href="#write-file">write-file</a>). This function 
+returns the number of bytes written.</p>
+
+<p>On failure the function returns <tt>nil</tt>. For error information, 
+use <a href="#sys-error">sys-error</a> when used on files. When used
+on URLs <a href="#net-error">net-error</a> gives more error
+information.</p>
+
+<!-- example -->
+
+<pre>
+(write-file "myfile.txt" "ABC") 
+(append-file "myfile.txt" "DEF")
+
+(read-file "myfile.txt")  <span class='arw'>&rarr;</span> "ABCDEF"
+</pre>
+
+
+<p><tt>append-file</tt> can take a <tt>http://</tt> or <tt>file://</tt> URL
+in <em>str-file-name</em>. In case of the <tt>http://</tt>  prefix ,
+<tt>append-file</tt> works exactly like <a href="#put-url">put-url</a> with 
+<tt>"Pragma: append\r\n"</tt> in the header option and can take the same 
+additional parameters. The <tt>"Pragma: append\r\n"</tt> option is supplied 
+automatically.</p>
+
+<!-- example -->
+
+<pre>
+(append-file "http://asite.com/message.txt" "More message text.")
+</pre>
+
+
+<p>The file <tt>message.txt</tt> is appended at a remote
+location <tt>http://asite.com</tt> with the contents of 
+<em>str-buffer</em>. If the file does not yet exist, it
+will be created. In this mode, <tt>append-file</tt> can also be used
+to transfer files to remote newLISP server nodes.
+</p>
+
+
+
+<p>See also <a href="#read-file">read-file</a> and
+<a href="#write-file">write-file</a>.
+</p>
+
+<br/><br/>
+
+<a name="apply"></a>
+<h2><span class="function">apply</span></h2>
+<h4>syntax: (apply <em>func</em> <em>list</em> [<em>int-reduce</em>])<br/>
+syntax: (apply <em>func</em>)</h4>
+
+<p>Applies the contents of <em>func</em> (primitive, user-defined function, or 
+lambda expression)  to the arguments in <em>list</em>. Only functions and
+operators with standard evaluation of their arguments can be applied.</p>
+
+<p>In the second syntax <tt>apply</tt> is used on functions without any 
+arguments.</p>
+
+<!-- example -->
+
+<pre>
+(apply + '(1 2 3 4))                   <span class='arw'>&rarr;</span> 10
+(set 'aList '(3 4 5))                  <span class='arw'>&rarr;</span> (3 4 5)
+(apply * aList)                        <span class='arw'>&rarr;</span> 60
+(apply sqrt '(25))                     <span class='arw'>&rarr;</span> 5
+(apply (lambda (x y) (* x y)) '(3 4))  <span class='arw'>&rarr;</span> 12
+</pre>
+
+
+
+<p>
+	The <em>int-reduce</em> parameter can optionally contain 
+	the number of arguments taken by the function in <em>func</em>. 
+	In this case, 
+	<em>func</em> will be repeatedly applied using the previous result 
+	as the first argument and taking the other arguments required 
+	successively from <em>list</em> 
+	(in left-associative order). 
+	For example, if <tt>op</tt> takes two arguments, then:
+</p>
+
+
+<pre>
+(apply op '(1 2 3 4 5) 2)
+
+;; is equivalent to
+
+(op (op (op (op 1 2) 3) 4) 5)
+
+;; find the greatest common divisor 
+;; of two or more integers 
+;; note that newLISP already has a gcd function
+
+(define (gcd_ a b)
+    (let (r (% b a))
+        (if (= r 0) a (gcd_ r a))))
+
+(define-macro (my-gcd)
+    (apply gcd_ (map eval (args)) 2))
+
+(my-gcd 12 18 6)    <span class='arw'>&rarr;</span> 6
+(my-gcd 12 18 6 4)  <span class='arw'>&rarr;</span> 2
+</pre>
+
+
+<p>The last example shows how <tt>apply</tt>'s <em>reduce</em> functionality 
+can be used to convert a two-argument function into one that takes multiple arguments. Note, that a built-in <a href="#gcd">gcd</a> is available.</p>
+
+<p>
+<tt>apply</tt> should only be used on functions and operators that evaluate all 
+of their arguments, not on <em>special forms</em> like <a href="#dotimes">dotimes</a> 
+or <a href="#case">case</a>, which evaluate only some of their arguments. 
+Doing so will cause the function to fail.
+</p>
+
+<br/><br/>
+
+<a name="args"></a>
+<h2><span class="function">args</span></h2>
+<h4>syntax: (args)<br/>
+syntax: (args <em>int-idx-1</em> [<em>int-idx-2</em> ... ])</h4>
+
+<p>
+Accesses a list of all unbound arguments passed to the currently evaluating 
+<a href="#define">define</a>, <a href="#define-macro">define-macro</a> 
+lambda, or lambda-macro expression. Only the arguments of the current function 
+or macro that remain after local variable binding has occurred are available. 
+The <tt>args</tt> function is useful for defining functions or macros 
+with a variable number of parameters.</p>
+
+<p>
+<tt>args</tt> can be used to define hygienic macros that avoid the danger of 
+variable capture. See <a href="#define-macro">define-macro</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(define-macro (print-line)
+    (dolist (x (args))
+        (print x "\n")))
+                        
+(print-line "hello" "World")
+</pre>
+
+<p>
+	This example prints a line-feed after each argument. 
+	The macro mimics the effect of the built-in function 
+	<a href="#println">println</a>.
+</p>
+
+<p>
+	In the second syntax, 
+	<tt>args</tt> can take one or more indices (<em>int-idx-n</em>).
+</p>
+
+<!-- example -->
+
+<pre>
+(define-macro (foo)
+    (print (args 2) (args 1) (args 0)))
+
+(foo x y z) 
+<b>zyx</b> 
+
+(define (bar)
+	(args 0 2 -1))
+
+(bar '(1 2 (3 4)))  <span class='arw'>&rarr;</span> 4
+</pre>
+
+
+<p>
+	The function <tt>foo</tt> 
+	prints out the arguments in reverse order. 
+	The <tt>bar</tt> function 
+	shows <tt>args</tt> being used 
+	with multiple indices
+	to access nested lists.
+</p>
+
+<p>
+	Remember that <tt>(args)</tt> only contains the arguments 
+	not already bound to local variables 
+	of the current function or macro:
+</p>
+
+<!-- example -->
+
+<pre>
+(define (foo a b) (args))
+  
+(foo 1 2)        <span class='arw'>&rarr;</span> ()
+                 
+(foo 1 2 3 4 5)  <span class='arw'>&rarr;</span> (3 4 5)
+</pre>
+
+
+<p>
+	In the first example, 
+	an empty list is returned because 
+	the arguments are bound to the 
+	two local symbols, <tt>a</tt> and <tt>b</tt>.
+	The second example demonstrates that, 
+	after the first two arguments are bound 
+	(as in the first example), three arguments remain 
+	and are then returned by <tt>args</tt>.
+</p>
+
+<p>
+	<tt>(args)</tt> can be used as an argument 
+	to a built-in or user-defined function call, 
+	but it should not be used as an argument to another macro, 
+	in which case <tt>(args)</tt> would not be evaluated 
+	and would therefore have the wrong
+	contents in the new macro environment.
+</p>
+
+<br/><br/>
+
+<a name="array"></a>
+<h2><span class="function">array</span></h2>
+
+<h4>syntax: (array <em>int-n1</em> [<em>int-n2</em> ... ] [<em>list-init</em>])</h4>
+
+<p>Creates an array with <em>int-n1</em> elements, 
+optionally initializing it with the contents of <em>list-init</em>. 
+Up to sixteen dimensions may be specified for multidimensional arrays.</p>
+
+<p>Internally, newLISP builds multidimensional arrays by using arrays as the 
+elements of an array. newLISP arrays should be used whenever random indexing 
+into a large list becomes too slow. Not all list functions may be used on arrays. 
+For a more detailed discussion, see the chapter on <a href="#arrays">arrays</a>.</p>
+
+<!-- example -->
+
+<pre>
+(array 5)                  <span class='arw'>&rarr;</span> (nil nil nil nil nil)
+
+(array 5 (sequence 1  5))  <span class='arw'>&rarr;</span> (1 2 3 4 5)
+
+(array 10 '(1 2))          <span class='arw'>&rarr;</span> (1 2 1 2 1 2 1 2 1 2)
+</pre>
+
+
+
+<p>Arrays can be initialized with objects of any type. If fewer initializers than 
+elements are provided, the list is repeated until all elements of the array are 
+initialized.</p>
+
+
+<pre>
+
+(set 'myarray (array 3 4 (sequence 1 12)))
+<span class='arw'>&rarr;</span> ((1 2 3 4) (5 6 7 8) (9 10 11 12))
+</pre>
+
+
+<p>Arrays are modified and accessed using most of the same functions used for 
+modifying lists:</p>
+
+
+<pre>
+(setf (myarray 2 3) 99) <span class='arw'>&rarr;</span> 99)
+myarray <span class='arw'>&rarr;</span> ((1 2 3 4) (5 6 7 8) (9 10 11 99))
+
+(setf (myarray 1 1) "hello")  <span class='arw'>&rarr;</span> "hello"
+
+myarray <span class='arw'>&rarr;</span> ((1 2 3 4) (5 "hello" 7 8) (9 10 11 99))
+
+(setf (myarray 1) '(a b c d)) <span class='arw'>&rarr;</span> (a b c d)
+myarray <span class='arw'>&rarr;</span> ((1 2 3 4) (a b c d) (9 10 11 99))
+
+(nth 1 myarray)     <span class='arw'>&rarr;</span> (a b c d)  ; access a whole row
+                    
+;; use implicit indexing and slicing on arrays
+                    
+(myarray 1)     <span class='arw'>&rarr;</span> (a b c d)
+                    
+(myarray 0 -1)  <span class='arw'>&rarr;</span> 4
+
+(2 myarray)     <span class='arw'>&rarr;</span> ((9 10 11 99)) 
+
+(-3 2 myarray)  <span class='arw'>&rarr;</span> ((1 2 3 4) (a b c d)) 
+</pre>
+
+
+<p>Care must be taken to use an array when replacing a whole row.
+</p>
+
+<p>
+<a href="#array-list">array-list</a> can be used to convert arrays back into lists:
+</p>
+
+
+<pre>
+(array-list myarray)  <span class='arw'>&rarr;</span> ((1 2 3 4) (a b c d) (1 2 3 99))
+</pre>
+
+
+<p>To convert a list back into an array, apply <a href="#flat">flat</a> to the list:
+</p>
+
+
+<pre>
+(set 'aList '((1 2) (3 4)))             <span class='arw'>&rarr;</span> ((1 2) (3 4))
+
+(set 'aArray (array 2 2 (flat aList)))  <span class='arw'>&rarr;</span> ((1 2) (3 4))
+</pre>
+
+
+<p>The <a href="#arrayp">array?</a> function 
+can be used to check if an expression is an array:
+</p>
+
+
+<pre>
+(array? myarray)               <span class='arw'>&rarr;</span> true
+                               
+(array? (array-list myarray))  <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+
+<p>
+When serializing arrays using the  function <a href="#source">source</a> 
+or <a href="#save">save</a>, the generated code includes the <tt>array</tt> 
+statement necessary to create them. This way, variables containing arrays are 
+correctly serialized when saving with <a href="#save">save</a> or creating 
+source strings using <a href="#source">source</a>.</p>
+
+
+
+<pre>
+(set 'myarray (array 3 4 (sequence 1 12)))
+
+(save "array.lsp" 'myarray)
+
+;; contents of file arraylsp ;;
+
+(set 'myarray (array 3 4 (flat '(
+  (1 2 3 4) 
+  (5 6 7 8) 
+  (9 10 11 12)))))
+</pre>
+
+<br/><br/>
+
+<a name="array-list"></a>
+<h2><span class="function">array-list</span></h2>
+<h4>syntax: (array-list <em>array</em>)</h4>
+
+<p>
+	Returns a list conversion from <em>array</em>, 
+	leaving the original array unchanged:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'myarray (array 3 4 (sequence 1 12)))
+<span class='arw'>&rarr;</span> ((1 2 3 4) (5 6 7 8) (9 10 11 12))
+
+(set 'mylist (array-list myarray))
+<span class='arw'>&rarr;</span> ((1 2 3 4) (5 6 7 8) (9 10 11 12))
+
+(list (array? myarray) (list? mylist))
+<span class='arw'>&rarr;</span> (true true)
+</pre>
+
+<br/><br/>
+
+<a name="arrayp"></a>
+<h2><span class="function">array?</span></h2>
+<h4>syntax: (array? <em>exp</em>)</h4>
+
+<p>
+	Checks if <em>exp</em> is an array:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'M (array 3 4 (sequence 1 4)))   
+<span class='arw'>&rarr;</span> ((1 2 3 4) (1 2 3 4) (1 2 3 4)))
+
+
+(array? M)               <span class='arw'>&rarr;</span> true
+
+(array? (array-list M))  <span class='arw'>&rarr;</span> nil
+</pre>
+
+<br/><br/>
+
+<a name="asin"></a>
+<h2><span class="function">asin</span></h2>
+<h4>syntax: (asin <em>num-radians</em>)</h4>
+
+<p>
+	Calculates the arcsine function from the number in <em>num-radians</em> 
+	and returns the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(asin 1)  <span class='arw'>&rarr;</span> 1.570796327
+(sin (asin 1)) <span class='arw'>&rarr;</span> 1
+</pre>
+
+<br/><br/>
+
+<a name="asinh"></a>
+<h2><span class="function">asinh</span></h2>
+<h4>syntax: (asinh <em>num-radians</em>)</h4>
+
+<p>Calculates the inverse hyperbolic sine of <em>num-radians</em>, 
+the value whose hyperbolic sine is <em>num-radians</em>.</p>
+
+<!-- example -->
+
+<pre>
+(asinh 2)         <span class='arw'>&rarr;</span> 1.443635475
+(sinh (asinh 2))  <span class='arw'>&rarr;</span> 2
+</pre>
+
+<br/><br/>
+
+<a name="assoc"></a>
+<h2><span class="function">assoc</span></h2>
+<h4>syntax: (assoc <em>exp-key</em> <em>list-alist</em>)<br/>
+syntax: (assoc <em>list-exp-key</em> <em>list-alist</em>)</h4>
+
+
+<p>
+In the first syntax the value of <em>exp-key</em> is used 
+to search <em>list-alist</em> for a <em>member-list</em> 
+whose first element matches the key value. 
+If found, the <em>member-list</em> is returned;
+otherwise, the result will be <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(assoc 1 '((3 4) (1 2)))  <span class='arw'>&rarr;</span> (1 2)
+
+(set 'data '((apples 123) (bananas 123 45) (pears 7)))
+
+(assoc 'bananas data)  <span class='arw'>&rarr;</span> (bananas 123 45)
+(assoc 'oranges data)  <span class='arw'>&rarr;</span> nil
+</pre>
+
+<p>Together with <a href="#setf">setf</a> <tt>assoc</tt> can be used
+to change an association.</p>
+
+<pre>
+(setf (assoc 'pears data) '(pears 8))
+
+data  <span class='arw'>&rarr;</span> ((apples 123) (bananas 123 45) (pears 8))
+</pre>
+
+<p>In the second syntax more then one key expressions can be specified
+to search in nested, multilevel association lists:</p>
+
+<!-- example -->
+
+<pre>
+(set 'persons '(
+    (id001 (name "Anne") (address (country "USA") (city "New York")))
+    (id002 (name "Jean") (address (country "France") (city "Paris")))
+))
+
+(assoc '(id001 address) persons) <span class='arw'>&rarr;</span> (address (country "USA") (city "New York"))
+(assoc '(id001 address city) persons) <span class='arw'>&rarr;</span> (city "New York")
+</pre>
+
+
+<p>The list in <em>list-aList</em> can be a context which will be interpreted
+as its <em>default functor</em>. This way very big lists can be passed by reference
+for speedier access and less memory usage:</p>
+
+
+<pre>
+(set 'persons:persons '(
+    (id001 (name "Anne") (address (country "USA") (city "New York")))
+    (id002 (name "Jean") (address (country "France") (city "Paris")))
+))
+
+(define (get-city db id)
+    (last (assoc (list id 'address 'city) db ))
+)
+
+(get-city persons 'id001) <span class='arw'>&rarr;</span> "New York"
+</pre>
+
+
+<p>
+For making replacements in association lists, use the 
+<a href="#setf">setf</a> together with the <tt>assoc</tt> function.
+The <a href="#lookup">lookup</a> function is used to perform association lookup 
+and element extraction in one step.</p>
+
+<br/><br/>
+
+<a name="atan"></a>
+<h2><span class="function">atan</span></h2>
+<h4>syntax: (atan <em>num-radians</em>)</h4>
+
+<p>
+	The arctangent of <em>num-radians</em> 
+	is calculated and returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(atan 1)        <span class='arw'>&rarr;</span> 0.7853981634
+(tan (atan 1))  <span class='arw'>&rarr;</span> 1
+</pre>
+
+<br/><br/>
+
+<a name="atan2"></a>
+<h2><span class="function">atan2</span></h2>
+<h4>syntax: (atan2 <em>num-Y-radians</em> <em>num-X-radians</em>)</h4>
+
+<p>
+	The <tt>atan2</tt> function computes 
+	the principal value of 
+	the arctangent of Y / X in radians. 
+	It uses the signs of both arguments 
+	to determine the quadrant of
+	the return value. 
+	<tt>atan2</tt> is useful for converting 
+	Cartesian coordinates 
+	into polar coordinates.
+</p>
+
+<!-- example -->
+
+<pre>
+(atan2 1 1)                       <span class='arw'>&rarr;</span> 0.7853981634
+(div (acos 0) (atan2 1 1))        <span class='arw'>&rarr;</span> 2
+(atan2 0 -1)                      <span class='arw'>&rarr;</span> 3.141592654
+(= (atan2 1 2) (atan (div 1 2)))  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="atanh"></a>
+<h2><span class="function">atanh</span></h2>
+<h4>syntax: (atanh <em>num-radians</em>)</h4>
+
+<p>Calculates the inverse hyperbolic tangent of <em>num-radians</em>, 
+the value whose hyperbolic tangent is <em>num-radians</em>. If the 
+absolute value of <em>num-radians</em> is greater than 1, 
+<tt>atanh</tt> returns <tt>NaN</tt>; if it is equal to 1, <tt>atanh</tt> returns infinity.</p>
+
+<!-- example -->
+
+<pre>
+(atanh 0.5) <span class='arw'>&rarr;</span> 0.5493061443
+(tanh (atanh 0.5)) <span class='arw'>&rarr;</span> 0.5
+(atanh 1.1) <span class='arw'>&rarr;</span> NaN
+(atanh 1) <span class='arw'>&rarr;</span> inf
+</pre>
+
+<br/><br/>
+
+<a name="atomp"></a>
+<h2><span class="function">atom?</span></h2>
+<h4>syntax: (atom? <em>exp</em>)</h4>
+
+<p>
+	Returns <tt>true</tt> if the value of <em>exp</em> is an atom, 
+	otherwise <tt>nil</tt>.	
+	An expression is an atom if it evaluates to nil, 
+	true, an integer, a float, a string, a symbol or a primitive. 
+	Lists, lambda or lambda-macro expressions, 
+	and quoted expressions are not atoms.
+</p>
+
+<!-- example -->
+
+<pre>
+(atom? '(1 2 3))      <span class='arw'>&rarr;</span> nil
+(and (atom? 123)
+     (atom? "hello")
+     (atom? 'foo))    <span class='arw'>&rarr;</span> true
+(atom? ''foo)         <span class='arw'>&rarr;</span> nil
+</pre>
+
+<br/><br/>
+
+<a name="base64-dec"></a>
+<h2><span class="function">base64-dec</span></h2>
+<h4>syntax: (base64-dec <em>str</em>)</h4>
+
+<p>
+	The BASE64 string in <em>str</em> is decoded. 
+	Note that <em>str</em> is not verified
+	to be a valid BASE64 string. 
+	The decoded string is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(base64-dec "SGVsbG8gV29ybGQ=")  <span class='arw'>&rarr;</span> "Hello World"
+</pre>
+
+
+<p>
+	For encoding,
+	use the <a href="#base64-enc">base64-enc</a> function.
+</p>
+	
+<p> 
+	newLISP's BASE64 handling is derived from 
+	routines found in the Unix <a href="http://curl.haxx.se/">curl</a>
+    utility and conforms to the RFC 4648 standard.
+</p>
+
+<br/><br/>
+
+<a name="base64-enc"></a>
+<h2><span class="function">base64-enc</span></h2>
+<h4>syntax: (base64-enc <em>str</em> [<em>bool-flag</em>])</h4>
+
+<p>
+The string in <em>str</em> is encoded into BASE64 format. 
+This format encodes groups of 3 * 8 = 24 input bits 
+into 4 * 8 = 32 output bits, 
+where each 8-bit output group 
+represents 6 bits from the input string. 
+The 6 bits are encoded into 64 possibilities
+from the letters A&ndash;Z and a&ndash;z; 
+the numbers 0&ndash;9; 
+and the characters + (plus sign) and / (slash). 
+The = (equals sign) is used as a filler 
+in unused 3- to 4-byte translations. 
+This function is helpful for converting binary content 
+into printable characters.
+</p>
+
+<p>Without the optional <em>bool-flag</em> parameter the empty string <tt>""</tt> is
+encoded into <tt>"===="</tt>. If <em>bool-flag</em>  evaluates to <tt>true</tt>, 
+the empty string <tt>""</tt> is translated into <tt>""</tt>. Both translations
+result in <tt>""</tt> when using <a href="base64-dec">base64-dec</a>.</p>
+
+<p>
+The encoded string is returned.
+</p>
+
+<p>
+BASE64 encoding is used with many Internet protocols 
+to encode binary data for inclusion in text-based messages
+(e.g., XML-RPC).
+</p>
+
+<!-- example -->
+
+<pre>
+(base64-enc "Hello World")  <span class='arw'>&rarr;</span> "SGVsbG8gV29ybGQ="
+
+(base64-enc "")             <span class='arw'>&rarr;</span> "===="
+(base64-enc "" true)        <span class='arw'>&rarr;</span> ""
+</pre>
+
+
+<p>
+	Note that <tt>base64-enc</tt> does not insert 
+	carriage-return/line-feed pairs in longer BASE64 sequences 
+	but instead returns a pure BASE64-encoded string.
+</p>
+
+
+<p>
+	For decoding, 
+	use the <a href="#base64-dec">base64-dec</a> function.
+</p>
+	
+<p>
+	newLISP's BASE64 handling is derived from routines 
+	found in the Unix <a href="http://curl.haxx.se/">curl</a> 
+    utility and conforms to the RFC 4648 standard.
+</p>
+
+<br/><br/>
+
+<a name="bayes-query"></a>
+<h2><span class="function">bayes-query</span></h2>
+<h4>syntax: (bayes-query <em>list-L</em> <em>context-D</em> [<em>bool-chain</em> [<em>bool-probs</em>]])</h4>
+
+<p>
+Takes a list of tokens (<em>list-L</em>) and a trained dictionary (<em>context-D</em>) 
+and returns a list of the combined probabilities of the tokens in one category 
+(<em>A</em> or <em>Mc</em>) versus a category (<em>B</em>) or
+against all other categories (<em>Mi</em>).  All tokens in <em>list-L</em> 
+should occur in <em>context-D</em>. 
+When using the default <em>R.A. Fisher inverse Chi&sup2;&nbsp;</em> mode, 
+nonexistent tokens will skew results toward equal probability in all categories.
+</p>
+
+<p>
+Non-existing tokens will not have any influence on the result when using the 
+true <em>Chain Bayesian</em> mode with <em>bool-chain</em> set to <tt>true</tt>.  
+The optional last flag, <em>bool-probs</em>, indicates whether frequencies or 
+probability values are used in the data set. The <a href="#bayes-train">bayes-train</a> 
+function is typically used to generate a data set's frequencies.
+</p>
+
+<p>
+Tokens can be strings or symbols.  If strings are used, they are prepended 
+with an underscore before being looked up in <em>context-D</em>.  If 
+<a href="#bayes-train">bayes-train</a> was used to generate <em>context-D</em>'s 
+frequencies, the underscore was automatically prepended during the learning process.
+</p>
+
+<p>
+	Depending on the flag specified in <em>bool-probs</em>, 
+	<a href="#bayes-query">bayes-query</a> employs either the 
+	R. A. Fisher inverse Chi&sup2; method of compounding probabilities 
+	or the Chain Bayesian method. 
+	By default, when no flag or <tt>nil</tt> is specified in <em>bool-probs</em>,
+	the inverse Chi&sup2; method of compounding probabilities is used. 
+	When specifying <tt>true</tt> in <em>bool-probs</em>, 
+	the Chain Bayesian method is used.
+</p>
+
+<p>
+	If the inverse Chi&sup2; method is used, 
+	the total number of tokens 
+	in the different training set's categories 
+	should be equal or similar. 
+	Uneven frequencies in categories 
+	will skew the results.
+</p>
+
+<p>
+	For two categories <em>A</em> and <em>B</em>, 
+	<tt>bayes-query</tt> uses the following formula:
+</p>
+
+
+<b><em>p(A|tkn) = p(tkn|A) * p(A) / ( p(tkn|A) * p(A) + p(tkn|B) * p(B) )</em></b>
+
+   
+<p>
+	For <em>N</em> categories, the formula can be generalized to:
+</p>
+   
+
+<b><em>p(Mc|tkn) = p(tkn|Mc) * p(Mc) / sum-i-N( p(tkn|Mi) * p(Mi) )</em></b>
+ 
+
+<p>
+	The probabilities (<em>p(Mi)</em> or <em>p(A)</em>, along with <em>p(B)</em>) 
+	represent the <em>Bayesian prior probabilities</em>. 
+	<em>p(Mc|tkn)</em> and <em>p(A|tkn)</em> are the 
+	<em>posterior Bayesian</em> probabilities of a category or model.
+    This <i>naive</i> Bayes formula does nor take into account dependencies
+    between different categories. 
+</p>
+
+<p>
+	Priors are handled differently, 
+	depending on whether the R.A. Fisher inverse Chi&sup2; 
+	or the Chain Bayesian method is used. 
+	In Chain Bayesian mode, 
+	posteriors from one token calculation get the priors in the next calculation. 
+	In the default inverse Chi&sup2; method, 
+	priors are not passed on via chaining, 
+	but probabilities are compounded using the inverse Chi&sup2; method.
+</p>
+
+<p>
+	In Chain Bayes mode, 
+	tokens with zero frequency in one category 
+	will effectively put the probability of that category to 0 (zero). 
+	This also causes all posterior priors to be set to 0
+	and the category to be completely suppressed in the result. 
+	Queries resulting in zero probabilities for all categories 
+	yield <em>NaN</em> values.
+</p>
+
+<p>
+	The default inverse Chi&sup2; method 
+	is less sensitive about zero frequencies 
+	and still maintains a low probability for that token. 
+	This may be an important feature in natural language processing 
+	when using <em>Bayesian statistics</em>. 
+	Imagine that five different language <em>corpus</em> categories have been trained, 
+	but some words occurring in one category are not present in another. 
+	When the pure Chain Bayesian method is used, 
+	a sentence could never be classified into its correct category
+	because the zero-count of just one word token could effectively exclude it 
+	from the category to which it belongs.
+</p>
+
+<p>
+	On the other hand, 
+	the Chain Bayesian method offers exact results 
+	for specific proportions in the data. 
+	When using Chain Bayesian mode for natural language data,
+	all zero frequencies should be removed from the trained dictionary first.
+</p>
+
+<p>
+The return value of <tt>bayes-query</tt> is a list of probability values, 
+one for each category. Following are two examples: the first for the 
+default inverse Chi&sup2; mode, the second for a data set processed with the 
+Chain Bayesian method.
+</p>
+
+<br/>
+<h3>R.A. Fisher inverse Chi&sup2; method</h3>
+
+<p>
+	In the following example, 
+	the two data sets are books from Project Gutenberg.
+	We assume that different authors 
+	use certain words with different frequencies 
+	and want to determine if a sentence is more likely to occur in one 
+	or the other author's writing.
+	A similar method is frequently used to differentiate between spam 
+	and legitimate email.
+</p>
+
+
+<pre>
+;; from Project Gutenberg: http://www.gutenberg.org/catalog/
+;; The Adventures of Sherlock Holmes - Sir Arthur Conan Doyle
+
+(bayes-train (parse (lower-case (read-file "Doyle.txt")) 
+                    "[^a-z]+" 0) '() 'DoyleDowson)
+
+;; A Comedy of Masks - Ernest Dowson and Arthur Moore
+
+(bayes-train '() (parse (lower-case (read-file "Dowson.txt")) 
+                    "[^a-z]+" 0) 'DoyleDowson)
+
+(save "DoyleDowson.lsp" 'DoyleDowson)
+</pre>
+
+
+<p>
+	The two training sets are loaded, split into tokens, 
+	and processed by the <a href="#bayes-train">bayes-train</a> function. 
+	In the end, the <tt>DoyleDowson</tt> dictionary is saved to a file, 
+	which will be used later with the <tt>bayes-query</tt> function.
+</p>
+
+<p>
+	The following code illustrates how <tt>bayes-query</tt> is used 
+	to classify a sentence as <em>Doyle</em> or <em>Dowson</em>:
+</p>
+
+
+<pre>
+(load "DoyleDowson.lsp")
+(bayes-query (parse "he was putting the last touches to a picture") 
+    'DoyleDowson)
+<span class='arw'>&rarr;</span> (0.0359554723158327 0.964044527684167) 
+
+(bayes-query (parse "immense faculties and extraordinary powers of observation") 
+    'DoyleDowson)
+<span class='arw'>&rarr;</span> (0.983569359827141 0.0164306401728594) 
+</pre>
+
+
+<p>
+	The queries correctly identify the first sentence as a <em>Dowson</em> sentence,
+	and the second one as a <em>Doyle</em> sentence.
+</p>
+      
+<br/>
+      
+<h3>Chain Bayesian method</h3>
+
+<p>
+	The second example is frequently found 
+	in introductory literature on Bayesian statistics. 
+	It shows the Chain Bayesian method of 
+	using <tt>bayes-query</tt> on the data of a previously processed data set:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'Data:test-positive '(8 18))
+(set 'Data:test-negative '(2 72))
+(set 'Data:total '(10 90))
+</pre>
+
+   
+<p>
+	A disease occurs in 10 percent of the population. 
+	A blood test developed to detect this disease 
+	produces a false positive rate of 20 percent in the healthy population 
+	and a false negative rate of 20 percent in the sick. 
+	What is the probability of a person carrying 
+	the disease after testing positive?</p>
+
+<!-- example -->
+
+<pre>
+(bayes-query '(test-positive) Data true)
+<span class='arw'>&rarr;</span> (0.3076923077 0.6923076923)
+
+(bayes-query '(test-positive test-positive) Data true)
+<span class='arw'>&rarr;</span> (0.64 0.36)
+
+(bayes-query '(test-positive test-positive test-positive) Data true)
+<span class='arw'>&rarr;</span> (0.8767123288 0.1232876712)
+</pre>
+
+
+<p>
+	Note that the Bayesian formulas used 
+	assume statistical independence of events 
+	for the <tt>bayes-query</tt> to work correctly.
+</p>
+
+<p>
+	The example shows that a person must test positive several times 
+	before they can be confidently classified as sick.
+</p>
+
+<p>
+	Calculating the same example using the R.A. Fisher Chi&sup2; method
+	will give less-distinguished results.
+</p> 
+
+<br/>
+<h3>Specifying probabilities instead of counts</h3>
+
+<p>
+	Often, data is already available as probability values 
+	and would require additional work to reverse them into frequencies. 
+	In the last example, the data were originally defined as percentages. 
+	The additional optional <em>bool-probs</em> flag 
+	allows probabilities to be entered directly 
+	and should be used together with the Chain Bayesian mode 
+	for maximum performance:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'Data:test-positive '(0.8 0.2))
+(set 'Data:test-negative '(0.2 0.8))
+(set 'Data:total '(0.1 0.9))
+
+(bayes-query '(test-positive) Data true true)
+<span class='arw'>&rarr;</span> (0.3076923077 0.6923076923)
+
+(bayes-query '(test-positive test-positive) Data true true)
+<span class='arw'>&rarr;</span> (0.64 0.36)
+
+(bayes-query '(test-positive test-positive test-positive) Data true true)
+<span class='arw'>&rarr;</span> (0.8767123288 0.1232876712)
+</pre>
+
+
+<p>
+	As expected, the results are the same for probabilities 
+	as they are for frequencies.
+</p>
+
+<br/><br/>
+
+<a name="bayes-train"></a>
+<h2><span class="function">bayes-train</span></h2>
+<h4>syntax: (bayes-train <em>list-M1</em> [<em>list-M2</em> ... ] <em>sym-context-D</em>)</h4>
+
+<p>
+Takes one or more lists of tokens (<em>M1</em>, <em>M2&mdash;</em>) 
+from a joint set of tokens. In newLISP, tokens can be symbols or strings 
+(other data types are ignored). Tokens are placed in a common dictionary 
+in <em>sym-context-D</em>, and the frequency is counted  for each token 
+in each category <em>Mi</em>. If the context does not yet exist, 
+it must be quoted.
+</p>
+   
+<p> The <em>M</em> categories represent data models for which sequences of 
+tokens can be classified  (see <a href="#bayes-query">bayes-query</a>). 
+Each token in <em>D</em> is a content-addressable symbol 
+containing a list of the frequencies for this token within each category. 
+String tokens are prepended with an <tt>_</tt> (underscore) 
+before being converted into symbols. A symbol named <tt>total</tt> is created
+containing the total of each category. The <tt>total</tt> symbol cannot be part 
+of the symbols passed as an <em>Mi</em> category.
+</p>
+
+<p>
+The function returns a list of token frequencies found in the different categories 
+or models.
+</p>
+
+<!-- example -->
+
+<pre>
+(bayes-train '(A A B C C) '(A B B C C C) 'L)  <span class='arw'>&rarr;</span> (5 6)
+
+L:A      <span class='arw'>&rarr;</span> (2 1)
+L:B      <span class='arw'>&rarr;</span> (1 2)
+L:C      <span class='arw'>&rarr;</span> (2 3)
+L:total  <span class='arw'>&rarr;</span> (5 6)
+
+(bayes-train '("one" "two" "two" "three")
+             '("three" "one" "three") 
+             '("one" "two" "three") 'S)       
+<span class='arw'>&rarr;</span> (4 3 3)
+
+S:_one    <span class='arw'>&rarr;</span> (1 1 1)
+S:_two    <span class='arw'>&rarr;</span> (2 0 1)
+S:_three  <span class='arw'>&rarr;</span> (1 2 1)
+S:total   <span class='arw'>&rarr;</span> (4 3 3)
+</pre>
+
+
+<p>The first example shows training with two lists of symbols. The second example 
+illustrates how an <tt>_</tt> is prepended when training with strings.</p>
+
+<p><tt>bayes-train</tt> creates symbols from strings prepending an underscore
+character. This is the same way hashes are created and contexts populates with
+symbols by <tt>bayes-train</tt> can be used like hashes:</p>
+
+
+<pre>
+; use a bayes-trained context namespace like a hash dictionary
+
+(S "two")   <span class='arw'>&rarr;</span> (2 0 1)
+(S "three") <span class='arw'>&rarr;</span> (1 2 1)
+
+(S) <span class='arw'>&rarr;</span> (("one" (1 1 1)) ("three" (1 2 1)) ("two" (2 0 1)))
+</pre>
+
+
+	
+<p>
+Note that these examples are just for demonstration purposes. In reality, training 
+sets may contain thousands or millions of words, especially when training natural 
+language models. But small data sets may be used when the frequency of symbols 
+just describe already-known proportions. In this case, it may be better to describe 
+the model data set explicitly, without the <tt>bayes-train</tt> function:
+</p>
+
+
+<pre>
+(set 'Data:tested-positive '(8 18))
+(set 'Data:tested-negative '(2 72))
+(set 'Data:total '(10 90))
+</pre>
+
+
+<p>
+The last data are from a popular example used to describe the 
+<a href="#bayes-query">bayes-query</a> function in introductory papers 
+and books about <em>bayesian networks</em>.
+</p>
+
+<p>
+Training can be done in different stages by using <tt>bayes-train</tt> on an 
+existing trained context with the same number of categories. The new symbols 
+will be added, then counts and totals will be correctly updated.</p>
+
+<p>
+Training in multiple batches may be necessary on big text corpora or documents 
+that must be tokenized first. These corpora can be tokenized in small portions, 
+then fed into <tt>bayes-train</tt> in multiple stages. Categories can also be 
+singularly trained by specifying an empty list for the absent corpus:
+</p>
+
+
+<pre>
+(bayes-train shakespeare1 '() 'data)
+(bayes-train shakespeare2 '() 'data)
+(bayes-train '() hemingway1 'data)
+(bayes-train '() hemingway2 'data)
+(bayes-train shakepeare-rest hemingway-rest 'data)
+</pre>
+
+
+<p>
+<tt>bayes-train</tt> will correctly update word counts and totals.</p>
+
+<p>
+	Using <tt>bayes-train</tt> inside a context other than <tt>MAIN</tt> 
+	requires the training contexts to have been created previously within 
+	the <tt>MAIN</tt> context via the <a href="#context">context</a> function.
+</p>
+
+<p>
+	<tt>bayes-train</tt> is not only useful with the <a href="#bayes-query">bayes-query</a> function, 
+	but also as a function for counting in general.
+	For instance, the resulting frequencies 
+	could be analyzed using <a href="#prob-chi2">prob-chi2</a> 
+	against a <em>null hypothesis</em> of proportional distribution 
+	of items across categories.
+</p>
+
+<br/><br/>
+
+<a name="begin"></a>
+<h2><span class="function">begin</span></h2>
+<h4>syntax: (begin <em>body</em>)</h4>
+
+<p>
+	The <tt>begin</tt> function is used to group a block of expressions. 
+	The expressions in <em>body</em> are evaluated in sequence, and 
+	the value of the last expression in <em>body</em> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(begin
+  (print "This is a block of 2 expressions\n")
+  (print "================================"))
+</pre>
+
+
+<p>
+	Some built-in functions like <a href="#cond">cond</a>, <a href="#define">define</a>,
+	<a href="#doargs">doargs</a>, <a href="#dolist">dolist</a>, <a href="#dostring">dostring</a>, 
+    <a href="#dotimes">dotimes</a>, <a href="#when">when</a> and <a href="#while">while</a> 
+	already allow multiple expressions in their bodies,
+	but <tt>begin</tt> is often used in an <a href="#if">if</a> expression.
+</p>
+
+<p>
+	The <a href="#silent">silent</a> function works like <tt>begin</tt>, 
+	but suppresses console output on return.
+</p>
+
+<br/><br/>
+
+<a name="beta"></a>
+<h2><span class="function">beta</span></h2>
+<h4>syntax: (beta <em>cum-a</em> <em>num-b</em>)</h4>
+
+<p>
+	The <em>Beta</em> function, <tt>beta</tt>,  
+	is derived from the <em>log Gamma</em> 
+	<tt>gammaln</tt> function as follows:
+</p>
+
+<p><em><b>
+beta = exp(gammaln(a) + gammaln(b) - gammaln(a + b))
+</b></em></p>
+
+<!-- example -->
+
+<pre>
+(beta 1 2)  <span class='arw'>&rarr;</span> 0.5
+</pre>
+
+<br/><br/>
+
+<a name="betai"></a>
+<h2><span class="function">betai</span></h2>
+
+<h4>syntax: (betai <em>num-x</em> <em>num-a</em> <em>num-b</em>)</h4>
+
+<p>
+	The <em>Incomplete Beta</em> function, <tt>betai</tt>, 
+	equals the cumulative probability of the <em>Beta</em> distribution, <tt>betai</tt>, 
+	at <em>x</em> in <em>num-x</em>. 
+	The cumulative binomial distribution is defined as the probability of an event, <em>pev</em>, 
+	with probability <em>p</em> to occur <em>k</em> or more times in <em>N</em> trials:
+</p>
+
+
+<p><em><b> pev = Betai(p, k, N - k + 1) </b></em></p>
+
+<!-- example -->
+
+<pre>
+(betai 0.5 3 8)  <span class='arw'>&rarr;</span> 0.9453125
+</pre>
+
+
+<p>
+The example calculates the probability for an event 
+with a probability of 0.5 to occur 3 or more times in 10 trials (8 = 10 - 3 + 1). 
+The incomplete Beta distribution can be used to derive a variety of other functions 
+in mathematics and statistics. 
+See also the <a href="#binomial">binomial</a> function.
+</p>
+
+<br/><br/>
+
+
+<a name="bigint"></a>
+<h2><span class="function">bigint</span></h2>
+<h4>syntax: (bigint <em>number</em>)<br/>
+syntax: (bigint <em>string</em>)</h4>
+
+<p>A floating point or integer number gets converted to big integer format.
+When converting from floating point, rounding errors occur going back and forth
+between decimal and binary arithmetic.</p>
+
+<p>A string argument gets parsed to a number and converted to a big integer.</p>
+
+<!-- example -->
+
+<pre>
+(bigint 12345)          <span class='arw'>&rarr;</span> 12345L
+
+(bigint 1.234567890e30) <span class='arw'>&rarr;</span> 1234567889999999957361000000000L 
+
+(set 'num 567890)
+(bigint num)            <span class='arw'>&rarr;</span> 567890L
+
+(bigint "-54321")       <span class='arw'>&rarr;</span> -54321L
+(bigint "123.45")       <span class='arw'>&rarr;</span> 123L
+(bigint "123hello")     <span class='arw'>&rarr;</span> 123L
+</pre>
+
+<p>See also the manual chapter <a href="#big_int">Big integer, unlimited precision arithmetic</a></p>
+
+<br/><br/>
+
+<a name="bigintp"></a>
+<h2><span class="function">bigint?</span></h2>
+<h4>syntax: (bigint? <em>number</em>)</h4>
+
+<p>Check if a number is formatted as a big integer.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 12345)
+(set 'y 12345L)
+(set 'z 123456789012345678901234567890)
+(set 'p 1.2345e20)
+(set 'q (bigint p))
+
+(bigint? x)  <span class='arw'>&rarr;</span> nil
+(bigint? y)  <span class='arw'>&rarr;</span> true
+(bigint? z)  <span class='arw'>&rarr;</span> true
+(bigint? p)  <span class='arw'>&rarr;</span> nil
+(bigint? q)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<p>See also the manual chapter <a href="#big_int">Big integer, unlimited precision arithmetic</a></p>
+
+<br/><br/>
+
+<a name="bind"></a>
+
+<h2><span class="function">bind</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (bind <em>list-variable-associations</em> [<em>bool-eval</em>])</h4>
+
+<p><em>list-variable-associations</em> contains an association list of 
+symbols and their values. <tt>bind</tt> sets all symbols
+to their associated values.</p>
+
+<p>The associated values are evaluated if the <em>bool-eval</em> flag is <tt>true</tt>:</p>
+
+<pre>
+(set 'lst '((a (+ 3 4)) (b "hello")))
+
+(bind lst)         <span class='arw'>&rarr;</span> "hello"
+
+a    <span class='arw'>&rarr;</span> (+ 3 4)
+b    <span class='arw'>&rarr;</span> "hello"
+
+(bind lst true)    <span class='arw'>&rarr;</span> "hello"
+
+a    <span class='arw'>&rarr;</span> 7
+</pre>
+
+<p>The return value of bind is the value of the last association.</p>
+
+<p><tt>bind</tt> is often used to bind association lists returned
+by <a href="#unify">unify</a>.</p>
+
+<pre>
+(bind (unify '(p X Y a) '(p Y X X)))    <span class='arw'>&rarr;</span> a
+
+X    <span class='arw'>&rarr;</span> a
+Y    <span class='arw'>&rarr;</span> a
+</pre>
+
+<p>This can be used for de-structuring:</p>
+
+<pre>
+(set 'structure '((one "two") 3 (four (x y z))))
+(set 'pattern '((A B) C (D E)))
+(bind (unify pattern structure))
+
+A <span class='arw'>&rarr;</span> one
+B <span class='arw'>&rarr;</span> "two"
+C <span class='arw'>&rarr;</span> 3
+D <span class='arw'>&rarr;</span> four
+E <span class='arw'>&rarr;</span> (x y z)
+</pre>
+
+
+<p><a href="#unify">unify</a>  returns an association list and <tt>bind</tt> binds the 
+associations.</p>
+
+<br/><br/>
+
+<a name="binomial"></a>
+
+<h2><span class="function">binomial</span></h2>
+<h4>syntax: (binomial <em>int-n</em> <em>int-k</em> <em>float-p</em>)</h4>
+
+<p>
+The binomial distribution function is defined as the probability for an event 
+to occur <em>int-k</em> times in <em>int-n</em> trials if that event has a 
+probability of <em>float-p</em> and all trials are independent of one another:</p>
+
+
+<em><b>binomial = pow(p, k) * pow(1.0 - p, n - k) * n! / (k! * (n - k)!)</b></em>
+
+
+<p>
+	where <em>x!</em> is the factorial of <em>x</em> 
+	and <em>pow(x, y)</em> is <em>x</em> raised to the power of <em>y</em>.
+</p>
+
+<br/>
+
+<!-- example -->
+
+<pre>
+(binomial 10 3 0.5)  <span class='arw'>&rarr;</span> 0.1171875
+</pre>
+
+
+<p>
+	The example calculates the probability for an event 
+	with a probability of 0.5 to occur 3 times in 10 trials. 
+	For a cumulated distribution, 
+	see the <a href="#betai">betai</a> function.
+</p>
+
+<br/><br/>
+
+<a name="bits"></a>
+<h2><span class="function">bits</span></h2>
+<h4>syntax: (bits <em>int</em> [<em>bool</em>])</h4>
+
+<p>Transforms a number in <em>int</em> to a string of 1's and 0's or a 
+list, if <em>bool</em> evaluates to anything not <tt>nil</tt>.</p>
+
+<p>In string representation bits are in high to low order. In list
+presentation 1's and 0's are represented as <tt>true</tt> and <tt>nil</tt>
+and in order from the lowest to the highest bit. This allows direct
+indexing and program control switching on the result.</p>
+
+<!-- example -->
+
+<pre>
+(bits 1234)      <span class='arw'>&rarr;</span> "10011010010"
+
+(int (bits 1234) 0 2) <span class='arw'>&rarr;</span> 1234
+
+(bits 1234 true)     <span class='arw'>&rarr;</span> (nil true nil nil true nil true true nil nil true)
+
+((bits 1234 true) 0) <span class='arw'>&rarr;</span> nil ; indexing of the result
+</pre>
+
+
+<p><a href="#int">int</a> with a base of 2 is the inverse function to <tt>bits</tt>.</p>
+
+<br/><br/>
+
+<a name="callback"></a>
+<h2><span class="function"> callback </span></h2>
+<h4>syntax: (callback <em>int-index</em> <em>sym-function</em>)<br/>
+syntax: (callback <em>sym-function</em> <em>str-return-type</em> [<em>str_param_type</em> ...])<br/>
+syntax: (callback <em>sym-function</em>)</h4>
+
+<p>In the first <b>simple <tt>callback</tt> syntax</b> up to sixteen (0 to 15) <em>callback</em> 
+functions for up to eight parameters can be registered with imported libraries. 
+The <tt>callback</tt> function returns a procedure address that invokes a 
+user-defined function in <em>sym-function</em>. The following example shows 
+the usage of callback functions when importing the <a href="http://www.opengl.org">OpenGL</a> 
+graphics library:</p>
+
+<p>If more than sixteen callback functions are required, slots must be 
+reassigned to a different callback function.</p>
+
+<!-- example -->
+
+<pre>
+...
+(define (draw)
+    (glClear GL_COLOR_BUFFER_BIT )
+    (glRotated rotx 0.0 1.0 0.0)
+    (glRotated roty 1.0 0.0 0.0)
+    (glutWireTeapot 0.5)
+    (glutSwapBuffers))
+
+(define (keyboard key x y)
+    (if (= (&amp; key 0xFF) 27) (exit)) ; exit program with ESC
+    (println "key:" (&amp; key 0xFF) " x:" x  " y:" y))
+
+(define (mouse button state x y)
+    (if (= state 0)
+        (glutIdleFunc 0) ; stop rotation on button press
+        (glutIdleFunc (callback 4 'rotation)))
+    (println "button: " button " state:" state " x:" x " y:" y))
+
+(glutDisplayFunc (callback 0 'draw))
+(glutKeyboardFunc (callback 1 'keyboard))
+(glutMouseFunc (callback 2 'mouse))
+...
+</pre>
+
+
+<p>The address returned by <tt>callback</tt> is registered with the 
+<a href="http://www.opengl.org/documentation/specs/glut/spec3/spec3.html">Glut</a> library. 
+The above code is a snippet from the file <tt>opengl-demo.lsp</tt>, 
+in the <tt>examples/</tt> directory of the source distribution of newLISP
+and can also be downloaded from 
+<a href="http://www.newlisp.org/downloads/OpenGL/">newlisp.org/downloads/OpenGL</a>.</p>
+
+<p>In the second <b>extended <tt>callback</tt> syntax</b> type specifiers are used to 
+describe the functions return and parameter value types when the function is called. 
+An unlimited number of callback functions can be registered with the second syntax, and 
+return values are passed back to the calling function. The symbol in <em>sym-function</em>
+contains a newLISP defined function used as a callback function callable from a C program.</p>
+
+<p>In the third syntax <tt>callback</tt> returns a previously returned C-callable
+address for that symbol.</p>
+
+<p>While the first simple <tt>callback</tt> syntax only handles integers and pointer
+values, <tt>callback</tt> in the expanded syntax can also handle simple and double precision
+floating point numbers passed in an out of the <tt>callback</tt> function.</p>
+
+<p>Both the simple and extended syntax can be mixed inside the same program.</p>
+
+<p>The following example shows the <a href="#import">import</a> of the <tt>qsort</tt>
+C library function, which takes as one of it's arguments the address of a comparison
+function. The comparison function in this case is written in newLISP and called into
+by the imported <tt>qsort</tt> function:</p>
+
+<pre>
+; C void qsort(...) takes an integer array with number and width
+; of array elements and a pointer to the comparison function
+(import "libc.dylib" "qsort" "void" "void*" "int" "int" "void*")
+
+(set 'rlist '(2 3 1 2 4 4 3 3 0 3))
+; pack the list into an C readable 32-bit integer array
+(set 'carray (pack (dup "ld " 10) rlist))
+
+; the comparison callback function receives pointers to integers
+(define (cmp a b) 
+    (- (get-int a) (get-int b)))
+
+; generate a C callable address for cmp
+(set 'func (callback 'cmp "int" "void*" "void*"))
+
+; sort the carray
+(qsort carray 10 4 func)
+
+; unpack the sorted array into a LISP list
+(unpack (dup "ld" 10) carray)  <span class='arw'>&rarr;</span>  (0 1 2 2 3 3 3 3 4 4) 
+</pre>
+
+<p>As type specifiers the same string tags can be used as in the 
+<a href="#import">import</a> function. All pointer types are passed as numbers in and
+out of the <tt>callback</tt> function. The functions <a href="#get-char">get-char</a>,
+<a href="#get-int">get-int</a>, <a href="#get-long">get-long</a> and 
+<a href="#get-string">get-string</a> can be used to extract numbers of
+different precision from parameters. Use <a href="#pack">pack</a> and 
+<a href="#unpack">unpack</a> to extract data from binary buffers and structures.</p>
+
+<p>Note that newLISP as already a fast built-in <a href="#sort">sort</a> function.</p>
+
+<br/><br/>
+
+<a name="case"></a>
+<h2><span class="function">case</span></h2>
+<h4>syntax: (case <em>exp-switch</em> (<em>exp-1</em> <em>body-1</em>) [(<em>exp-2</em> <em>body-2</em>) ... ])</h4>
+
+<p>The result of evaluating <em>exp-switch</em> 
+is compared to each of the <em>unevaluated</em> expressions 
+<em>exp-1, exp-2,</em> &mdash;. If a match is found, the 
+corresponding expressions in <em>body</em> 
+are evaluated.  The result of the last body expression is returned 
+as the result for the entire <tt>case</tt> expression. </p>
+
+
+<!-- example -->
+
+<pre>
+(define (translate n)
+  (case n
+    (1 "one")
+    (2 "two")          
+    (3 "three")
+    (4 "four")
+    (true "Can't translate this")))
+
+(translate 3)   <span class='arw'>&rarr;</span> "three"
+(translate 10)  <span class='arw'>&rarr;</span> "Can't translate this"
+</pre>
+
+
+<p>
+	The example shows how, 
+	if no match is found, 
+	the last expression in the body of a <tt>case</tt> function
+	can be evaluated.
+</p>
+
+<br/><br/>
+
+<a name="catch"></a>
+<h2><span class="function">catch</span></h2>
+
+<h4>syntax: (catch <em>exp</em>)<br/>
+syntax: (catch <em>exp</em> <em>symbol</em>)</h4>
+
+<p>
+	In the first syntax, 
+	<tt>catch</tt> will return the result of the evaluation of <em>exp</em> 
+	or the evaluated argument of a <a href="#throw">throw</a> 
+	executed during the evaluation of <em>exp</em>:
+</p>
+
+<!-- example -->
+
+<pre>
+(catch (dotimes (x 1000) 
+  (if (= x 500) (throw x))))  <span class='arw'>&rarr;</span> 500
+</pre>
+
+
+<p>
+	This form is useful for breaking out of iteration loops 
+	and for forcing an early return 
+	from a function or expression block:
+</p>
+
+
+<pre>
+(define (foo x)
+   &hellip;
+  (if condition (throw 123))
+    &hellip;
+  456)
+
+;; if condition is true
+
+(catch (foo p))  <span class='arw'>&rarr;</span> 123
+
+;; if condition is not true
+
+(catch (foo p))  <span class='arw'>&rarr;</span> 456
+</pre>
+
+
+
+<p>
+	In the second syntax, 
+	<tt>catch</tt> evaluates the expression <em>exp</em>, 
+	stores the result in <em>symbol</em>, 
+	and returns <tt>true</tt>.  
+	If an error occurs during evaluation, 
+	<tt>catch</tt> returns <tt>nil</tt> 
+	and stores the error message in <em>symbol</em>. 
+	This form can be useful when errors are expected 
+	as a normal potential outcome of a function 
+	and are dealt with during program execution.
+</p>
+
+<!-- example -->
+
+<pre>
+(catch (func 3 4) 'result)  <span class='arw'>&rarr;</span> nil
+result  
+<span class='arw'>&rarr;</span> <span class='err'>"ERR: invalid function in function catch : (func 3 4)"</span>
+
+(constant 'func +)          <span class='arw'>&rarr;</span> + &lt;4068A6&gt;
+(catch (func 3 4) 'result)  <span class='arw'>&rarr;</span> true
+result                      <span class='arw'>&rarr;</span> 7
+</pre>
+
+
+<p>
+	When a <a href="#throw">throw</a> is executed during the evaluation of <em>exp</em>,
+	<tt>catch</tt> will return <tt>true</tt>, 
+	and the <tt>throw</tt> argument will be stored in <em>symbol</em>:
+</p>
+
+
+<pre>
+(catch (dotimes (x 100) 
+  (if (= x 50) (throw "fin"))) 'result)  <span class='arw'>&rarr;</span> true
+
+result  <span class='arw'>&rarr;</span> "fin"
+</pre>
+
+
+<p>
+	As well as being used for early returns from functions and 
+	for breaking out of iteration loops (as in the first syntax), 
+	the second syntax of <tt>catch</tt> can also be used to catch errors. 
+	The <a href="#throw-error">throw-error</a> function may be used 
+	to throw user-defined errors.
+</p>
+
+<br/><br/>
+
+<a name="ceil"></a>
+<h2><span class="function">ceil</span></h2>
+<h4>syntax: (ceil <em>number</em>)</h4>
+
+<p>
+	Returns the next highest integer above <em>number</em> 
+	as a floating point.
+</p>
+
+<!-- example -->
+
+<pre>
+(ceil -1.5)  <span class='arw'>&rarr;</span> -1
+(ceil 3.4)   <span class='arw'>&rarr;</span> 4
+</pre>
+
+
+<p>See also the <a href="#floor">floor</a> function.
+</p>
+
+<br/><br/>
+
+
+<a name="change-dir"></a>
+<h2><span class="function">change-dir</span></h2>
+<h4>syntax: (change-dir <em>str-path</em>)</h4>
+
+<p>
+	Changes the current directory to be the one given in <em>str-path</em>.
+	If successful, <tt>true</tt> is returned; otherwise <tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(change-dir "/etc")
+</pre>
+
+
+<p>
+	Makes <tt>/etc</tt> the current directory.
+</p>
+
+<br/><br/>
+
+<a name="char"></a>
+<h2><span class="function">char</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (char <em>str</em> [<em>int-index</em> [true]])<br/>
+syntax: (char <em>int</em>)</h4>
+
+<p>Given a string argument, extracts the character at <em>int-index</em> from <em>str</em>,
+returning either the ASCII value of that character or the Unicode value on UTF-8 enabled 
+versions of newLISP.</p>
+
+<p>If <em>int-index</em> is omitted, 0 (zero) is assumed. If <em>int-idx</em>
+is followed by a boolean <tt>true</tt> value, than the index treats <em>str</em> as an 8-bit  byte
+array instead of an array of multi-byte UTF-8 characters.</p>
+
+<p>The empty string returns <tt>nil</tt>. Both <tt>(char 0)</tt> and <tt>(char nil)</tt> will 
+return <tt>"\000"</tt>.</p>
+
+<p>
+See <a href="#indexing">Indexing elements of strings and lists</a>.
+</p>
+
+<p>
+Given an integer argument, 
+<tt>char</tt> returns a string containing the ASCII character 
+with value <em>int</em>.
+</p>
+
+<p>
+On UTF-8&ndash;enabled versions of newLISP, the value in <em>int</em> 
+is taken as Unicode and a UTF-8 character is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(char "ABC")          <span class='arw'>&rarr;</span> 65  ; ASCII code for "A"
+(char "ABC" 1)        <span class='arw'>&rarr;</span> 66  ; ASCII code for "B"
+(char "ABC" -1)       <span class='arw'>&rarr;</span> 67  ; ASCII code for "C"
+(char "B")            <span class='arw'>&rarr;</span> 66  ; ASCII code for "B"
+(char "ฮฉ")            <span class='arw'>&rarr;</span> 937 ; UTF-8 code for "ฮฉ"
+(char "ฮฉ" 1 true)     <span class='arw'>&rarr;</span> 169 ; byte value at offset 1
+
+(char 65)  <span class='arw'>&rarr;</span> "A"
+(char 66)  <span class='arw'>&rarr;</span> "B"
+
+(char (char 65))  <span class='arw'>&rarr;</span> 65      ; two inverse applications
+
+(map char (sequence 1 255))  ; returns current character set
+
+; The Zen of UTF-8
+(char (&amp; (char "็”Ÿ") (char "ๆญป"))) <span class='arw'>&rarr;</span> ๆ„› ; by @kosh_bot
+</pre>
+
+<br/><br/>
+
+<a name="chop"></a>
+<h2><span class="function">chop</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (chop <em>str</em> [<em>int-chars</em>])<br/>
+syntax: (chop <em>list</em> [<em>int-elements</em>])</h4>
+
+<p>
+	If the first argument evaluates to a string, 
+	<tt>chop</tt> returns a copy of <em>str</em> 
+	with the last <em>int-char</em> characters omitted.
+	If the <em>int-char</em> argument is absent, 
+	one character is omitted.
+	<tt>chop</tt> does not alter <em>str</em>.</p>
+
+
+<p>
+	If the first argument evaluates to a list, 
+	a copy of <em>list</em> is returned 
+	with <em>int-elements</em> omitted 
+	(same as for strings).
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'str "newLISP")  <span class='arw'>&rarr;</span> "newLISP"
+                      
+(chop str)    <span class='arw'>&rarr;</span> "newLIS"
+(chop str 2)  <span class='arw'>&rarr;</span> "newLI"
+                      
+str  <span class='arw'>&rarr;</span> "newLISP"
+
+(set 'lst '(a b (c d) e))
+
+(chop lst)    <span class='arw'>&rarr;</span> (a b (c d))
+(chop lst 2)  <span class='arw'>&rarr;</span> (a b)
+                      
+lst  <span class='arw'>&rarr;</span> (a b (c d) e)
+</pre>
+
+<br/><br/>
+
+<a name="clean"></a>
+<h2><span class="function">clean</span></h2>
+<h4>syntax: (clean <em>exp-predicate</em> <em>list</em>)</h4>
+
+<p>
+	The predicate <em>exp-predicate</em> is applied 
+	to each element of <em>list</em>. 
+	In the returned list, 
+	all elements for which <em>exp-predicate</em> is <tt>true</tt> 
+	are eliminated.
+</p>
+
+<p>
+	<tt>clean</tt> works like <a href="#filter">filter</a> 
+	with a negated predicate.
+</p>
+
+<!-- example -->
+
+<pre>
+(clean symbol? '(1 2 d 4 f g 5 h))   <span class='arw'>&rarr;</span> (1 2 4 5)
+
+(filter symbol? '(1 2 d 4 f g 5 h))  <span class='arw'>&rarr;</span> (d f g h)
+
+(define (big? x) (&gt; x 5))        <span class='arw'>&rarr;</span> (lambda (x) (&gt; x 5))
+
+(clean big? '(1 10 3 6 4 5 11))  <span class='arw'>&rarr;</span> (1 3 4 5)
+
+(clean &lt;= '(3 4 -6 0 2 -3 0))  <span class='arw'>&rarr;</span> (3 4 2)
+
+(clean (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+<span class='arw'>&rarr;</span>  ((b 5) (c 8))
+</pre>
+
+
+<p>
+	The predicate may be a built-in predicate 
+	or a user-defined function or lambda expression.
+</p>
+
+<p>
+	For cleaning numbers from one list 
+	using numbers from another, 
+	use <a href="#difference">difference</a> 
+	or <a href="#intersect">intersect</a> 
+	(with the list mode option).
+</p>
+
+<p>
+	See also the related function <a href="#index">index</a>, 
+	which returns the indices of the remaining elements, 
+	and <a href="#filter">filter</a>, 
+	which returns all elements for which a predicate returns true.
+</p>
+
+<br/><br/>
+
+
+<a name="close"></a>
+<h2><span class="function">close</span></h2>
+<h4>syntax: (close <em>int-file</em>)</h4>
+
+<p>
+	Closes the file specified by the file handle in <em>int-file</em>. 
+	The handle would have been obtained 
+	from a previous <a href="#open">open</a> operation. 
+	If successful, <tt>close</tt> returns <tt>true</tt>; otherwise  <tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(close (device))  <span class='arw'>&rarr;</span> true
+(close 7)         <span class='arw'>&rarr;</span> true
+(close aHandle)   <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+	Note that using <tt>close</tt> on <a href="#device">device</a> 
+	automatically resets it to 0 (zero, the screen device).
+</p>
+	
+<br/><br/>
+
+<a name="collect"></a>
+<h2><span class="function">collect</span></h2>
+<h4>syntax: (collect <em>exp</em> [<em>int-max-count</em>])</h4>
+
+<p>Evaluates the expression in <em>exp</em>  and collects the results in a list
+until evaluation of <em>exp</em> returns <tt>nil</tt>.</p>
+
+<p>Optionally a maximum count of elements can be specified in <em>int-max-count</em>.</p>
+
+<pre>
+; collect results until nil is returned
+(set 'x 0)
+(collect (if (&lt;= (inc x) 10) x)) <span class='arw'>&rarr;</span> (1 2 3 4 5 6 7 8 9 10)
+
+; collect results until nil is returned or 6 results are collected
+(set 'x 0)
+(collect (if (&lt;= (inc x) 10) x) 6) <span class='arw'>&rarr;</span> (1 2 3 4 5 6)
+</pre>
+
+<br/><br/>
+
+<a name="command-event"></a>
+<h2><span class="function">command-event</span></h2>
+<h4>syntax: (command-event <em>sym-event-handler</em> | <em>func-event-handler</em>)<br/>
+syntax: (command-event nil)</h4>
+
+<p>Specifies a user defined function for pre-processing the newLISP command-line
+before it gets evaluated. This can be used to write customized interactive
+ newLISP shells and to transform HTTP requests when running in server mode.</p>
+
+<p><tt>command-event</tt> takes either a symbol of a user-defined function or a lambda 
+function. The event-handler function must return a string or the command-line will be 
+passed untranslated to newLISP.</p>
+
+<p>To only force a prompt and disable command processing, the function should return 
+the empty string <tt>""</tt>. To reset <tt>command-event</tt>, use the second syntax.</p>
+
+<p>The following example makes the newLISP shell work like a normal Unix
+shell when the command starts with a letter. But starting the line with an open
+parenthesis or a space initiates a newLISP evaluation.</p>
+
+<!-- example -->
+
+<pre>
+(command-event (fn (s) 
+	(if (starts-with s "[a-zA-Z]" 0) (append "!" s) s)))
+</pre>
+
+
+<p>See also the related <a href="#prompt-event">prompt-event</a> which can be used
+for further customizing interactive mode by modifying the newLISP prompt.</p>
+
+<p>The following program can be used either stand-alone or included in newLISP's
+<tt>init.lsp</tt> startup file:</p>
+
+<pre>
+#!/usr/bin/newlisp
+
+; set the prompt to the current directory name
+(prompt-event (fn (ctx) (append (real-path) "&gt; ")))
+
+; pre-process the command-line
+(command-event (fn (s) 
+    (if 
+        (starts-with s "cd") 
+        (string " " (true? (change-dir (last (parse s " ")))))
+
+        (starts-with s "[a-zA-Z]" 0)
+        (append "!" s)
+
+        true s)))
+</pre> 
+
+<p>In the definition of the command-line translation function the Unix
+command <tt>cd</tt> gets a special treatment, to make sure that the directory
+is changed for newLISP process too. This way when shelling out with <tt>!</tt> and
+coming back, newLISP will maintain the changed directory.</p>
+
+<p>Command lines for newLISP must start either with a space or an opening
+parenthesis. Unix commands must start at the beginning of the line.</p>
+
+<p>When newLISP is running in server mode either using the <tt>-c</tt> or
+<tt>-http</tt> option, it receives HTTP requests similar to the following:</p>
+
+<pre>
+GET /index.html
+</pre> 
+
+<p>Or if a query is involved:</p>
+
+<pre>
+GET /index.cgi?userid=joe&amp;password=secret
+</pre> 
+
+<p>A function specified by <tt>command-event</tt> could filter and transform 
+these request lines, e.g.: discovering all queries trying to perform CGI using
+a file ending in <tt>.exe</tt>.&nbsp; Such a request would be translated into a
+request for an error page:</p>
+
+<pre>
+;; httpd-conf.lsp
+;;
+;; filter and translate HTTP requests for newLISP
+;; -c or -http server modes
+;; reject query commands using CGI with .exe files
+
+(command-event (fn (s)
+    (let (request s)
+        (when (find "?" s) ; is this a query
+            (set 'request (first (parse s "?")))
+            ; discover illegal extension in queries
+            (when (ends-with request ".exe")
+                (set 'request "GET /errorpage.html")) )
+        request)
+))
+</pre> 
+
+<p>When starting the server mode with <tt>newlisp httpd-conf.lsp -c -d80 -w ./httpdoc</tt>
+newLISP will load the definition for <tt>command-event</tt> for filtering incoming
+requests, and the query:</p>
+
+<pre>
+GET /cmd.exe?dir
+</pre> 
+
+<p>Would be translated into:</p>
+
+<pre>
+GET /errorpage.html
+</pre> 
+
+<p>The example shows a technique frequently used in the past by spammers on MS 
+Windows based, bad configured web servers to gain control over servers.</p>
+
+<p><tt>httpd-conf.lsp</tt> files can easily be debugged loading the file into an interactive
+newLISP session and entering the HTTP requests manually. newLISP will translate the command
+line and dispatch it to the built-in web server. The server output will appear in the shell
+window.</p>
+
+<p>Note, that the command line length as well as the line length in HTTP headers is limited to 512 characters for newLISP.</p>
+
+<br/><br/>
+
+<a name="cond"></a>
+<h2><span class="function">cond</span></h2>
+
+<h4>syntax: (cond (<em>exp-condition-1</em> <em>body-1</em>) [(<em>exp-condition-2</em> <em>body-2</em>) ... ])</h4>
+
+<p>
+	Like <tt>if</tt>, <tt>cond</tt> conditionally evaluates the expressions 
+	within its body. 
+	The <em>exp-condition</em>s are evaluated in turn, 
+	until some <em>exp-condition-i</em> is found 
+	that evaluates to anything other than <tt>nil</tt> 
+	or an empty list <tt>()</tt>.
+	The result of evaluating <em>body-i</em> 
+	is then returned as the result of the entire <em>cond-expression</em>. 
+	If all conditions evaluate to <tt>nil</tt> 
+	or an empty list,
+	<em>cond</em> returns the value of the last <em>cond-expression</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (classify x)
+  (cond
+    ((&lt; x 0) "negative")
+    ((&lt; x 10) "small")
+    ((&lt; x 20) "medium")
+    ((&gt;= x 30) "big")))
+
+(classify 15)   <span class='arw'>&rarr;</span> "medium"
+(classify 22)   <span class='arw'>&rarr;</span> "nil"
+(classify 100)  <span class='arw'>&rarr;</span> "big"
+(classify -10)  <span class='arw'>&rarr;</span> "negative"
+</pre>
+
+
+<p>
+	When a <em>body-n</em> is missing, 
+	the value of the last <em>cond-expression</em> evaluated 
+	is returned. 
+	If no condition evaluates to <tt>true</tt>, 
+	the value of the last conditional expression is returned
+	(i.e., <tt>nil</tt> or an empty list).
+</p>
+
+
+<pre>
+(cond ((+ 3 4)))  <span class='arw'>&rarr;</span> 7
+</pre>
+
+
+<p>
+	When used with multiple arguments, 
+	the function <a href="#if">if</a> 
+	behaves like <tt>cond</tt>, 
+	except it does not need extra parentheses 
+	to enclose the condition-body pair 
+	of expressions.
+</p>
+
+<br/><br/>
+
+<a name="cons"></a>
+<h2><span class="function">cons</span></h2>
+<h4>syntax: (cons <em>exp-1</em> <em>exp-2</em>)</h4>
+
+<p>
+	If <em>exp-2</em> evaluates to a list, 
+	then a list is returned with the result of evaluating <em>exp-1</em> 
+	inserted as the first element. 
+	If <em>exp-2 </em>evaluates to anything other than a list, 
+	the results of evaluating <em>exp-1</em> and <em>exp-2</em> 
+	are returned in a list. 
+	Note that there is no <em>dotted pair</em> in newLISP:
+	<em>cons</em>ing two atoms constructs a list, not a dotted pair.
+</p>
+
+<!-- example -->
+
+<pre>
+(cons 'a 'b)            <span class='arw'>&rarr;</span> (a b)
+(cons 'a '(b c))        <span class='arw'>&rarr;</span> (a b c)
+(cons (+ 3 4) (* 5 5))  <span class='arw'>&rarr;</span> (7 25)
+(cons '(1 2) '(3 4))    <span class='arw'>&rarr;</span> ((1 2) 3 4)
+(cons nil 1)            <span class='arw'>&rarr;</span> (nil 1)
+(cons 1 nil)            <span class='arw'>&rarr;</span> (1 nil)
+(cons 1)                <span class='arw'>&rarr;</span> (1)
+(cons)			<span class='arw'>&rarr;</span> ()
+</pre>
+
+
+<p>
+	Unlike other Lisps that return <tt>(s)</tt>
+	as the result of the expression <tt>(cons 's nil)</tt>, 
+	newLISP's <tt>cons</tt> returns <tt>(s nil)</tt>. 
+	In newLISP, <tt>nil</tt> is a Boolean value 
+	and is not equivalent to an empty list, 
+	and a newLISP cell holds only one value.
+</p>
+
+<p>
+	<tt>cons</tt> behaves like the inverse operation of <a href="#first">first</a>
+and <a href="#rest">rest</a> 
+	(or <a href="#first">first</a> and <a href="#last">last</a> if the list is a pair):
+</p>
+
+
+<pre>
+(cons (first '(a b c)) (rest '(a b c)))  <span class='arw'>&rarr;</span> (a b c)
+
+(cons (first '(x y)) (last '(x y)))      <span class='arw'>&rarr;</span> (x y)
+</pre>
+
+<br/><br/>
+
+<a name="constant"></a>
+<h2><span class="function">constant</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (constant <em>sym-1</em> <em>exp-1</em> [<em>sym-2</em> <em>exp-2</em>] ...)</h4>
+
+<p>
+	Identical to <a href="#set">set</a> in functionality,
+	<tt>constant</tt> further protects the symbols from subsequent modification. 
+	A symbol set with <tt>constant</tt> can only be modified 
+	using the <tt>constant</tt> function again.  
+	When an attempt is made to modify the contents of a symbol protected with <tt>constant</tt>, 
+	newLISP generates an error message. 
+	Only symbols from the current context can be used with <tt>constant</tt>. 
+	This prevents the overwriting of symbols 
+	that have been protected in their home context.
+	The last <em>exp-n</em> initializer is always optional.
+</p>
+
+<p>
+	Symbols initialized with <a href="#set">set</a>, <a href="#define">define</a>, 
+	or <a href="#define-macro"> define-macro</a> can still be protected by using 
+	the <tt>constant</tt> function:
+</p>
+
+<pre>
+(constant 'aVar 123)  <span class='arw'>&rarr;</span> 123
+(set 'aVar 999) 
+<span class='err'>ERR: symbol is protected in function set: aVar</span>
+
+(define (double x) (+ x x))
+
+(constant 'double)
+
+;; equivalent to
+
+(constant 'double (fn (x) (+ x x)))
+</pre>
+
+
+<p>
+	The first example defines a constant, <tt>aVar</tt>, 
+	which can only be changed by using another <tt>constant</tt> statement. 
+	The second example protects <tt>double</tt> from being changed
+	(except by <tt>constant</tt>). 
+	Because a function definition in newLISP 
+	is equivalent to an assignment of a lambda function, 
+	both steps can be collapsed into one, 
+	as shown in the last statement line. 
+	This could be an important technique 
+	for avoiding protection errors 
+	when a file is loaded multiple times.
+</p>
+
+<p>
+	The last value to be assigned can be omitted. 
+	<tt>constant</tt> returns the contents of
+	the last symbol set and protected.
+</p>
+
+<p>
+	Built-in functions can be assigned to symbols 
+	or to the names of other built-in functions, 
+	effectively redefining them as different functions.
+	There is no performance loss when renaming functions.
+</p>
+
+
+<pre>
+(constant 'squareroot sqrt)  <span class='arw'>&rarr;</span> sqrt &lt;406C2E&gt;
+(constant '+ add)            <span class='arw'>&rarr;</span> add &lt;4068A6&gt;
+</pre>
+
+
+<p>
+	<tt>squareroot</tt> will behave like <tt>sqrt</tt>. 
+	The <tt>+</tt> (plus sign) is redefined 
+	to use the mixed type floating point mode of <tt>add</tt>. 
+	The hexadecimal number displayed in the result 
+	is the binary address of the built-in function 
+	and varies on different platforms and OSes.
+</p>
+
+<br/><br/>
+
+<a name="context"></a>
+<h2><span class="function">context</span></h2>
+<h4>syntax: (context [<em>sym-context</em>])<br/>
+syntax: (context <em>sym-context</em> <em>str | sym</em> [<em>exp-value</em>])</h4>
+
+<p> In the first syntax, <tt>context</tt> is used to switch to a different context namespace. 
+Subsequent <a href="#load">load</a>s of newLISP source or functions like 
+<a href="#eval-string">eval-string</a> and <a href="#sym">sym</a> will put newly created 
+symbols and function definitions in the new context.</p>
+
+<p>If the context still needs to be created, the symbol for the new context should be specified. 
+When no argument is passed to <tt>context</tt>, then the symbol for the current context is returned. </p>
+
+<p>Because contexts evaluate to themselves, a quote is not necessary 
+to switch to a different context if that context already exists.
+</p>
+
+<!-- example -->
+
+<pre>
+(context 'GRAPH)          ; create / switch context GRAPH
+
+(define (foo-draw x y z)  ; function resides in GRAPH
+  (&hellip;))
+                                
+(set 'var 12345)
+(symbols)  <span class='arw'>&rarr;</span> (foo-draw var)  ; GRAPH has now two symbols
+
+(context MAIN)               ; switch back to MAIN (quote not required)
+
+(print GRAPH:var) <span class='arw'>&rarr;</span> 12345    ; contents of symbol in GRAPH
+
+(GRAPH:foo-draw 10 20 30)    ; execute function in GRAPH
+(set 'GRAPH:var 6789)        ; assign to a symbol in GRAPH
+</pre>
+
+
+<p>
+	If a context symbol is referred to before the context exists, 
+	the context will be created implicitly.
+</p>
+
+
+<pre>
+(set 'person:age 0)       ; no need to create context first
+(set 'person:address "")  ; useful for quickly defining data structures
+</pre>
+
+
+<p>
+	Contexts can be copied:
+</p>
+
+
+<pre>
+(new person 'JohnDoe)  <span class='arw'>&rarr;</span>  JohnDoe
+
+(set 'JohnDoe:age 99)
+</pre>
+
+
+<p>
+	Contexts can be referred to by a variable:
+</p>
+
+
+<pre>
+(set 'human JohnDoe)
+
+human:age  <span class='arw'>&rarr;</span> 99
+
+(set 'human:address "1 Main Street")
+
+JohnDoe:address  <span class='arw'>&rarr;</span> "1 Main Street"
+</pre>
+
+
+
+<p>An evaluated context (no quote) can be given as an argument:
+</p>
+
+
+<pre>
+<b>&gt;</b> (context 'FOO)
+<b>FOO</b>
+<b>FOO></b> (context MAIN)
+<b>MAIN</b>
+<b>&gt;</b> (set 'old FOO)
+FOO
+<b>&gt;</b> (context 'BAR)
+<b>BAR</b>
+<b>BAR></b> (context MAIN:old)
+<b>FOO</b>
+<b>FOO></b> 
+</pre>
+
+
+
+<p>
+	If an identifier with the same symbol already exists, 
+	it is redefined to be a context.
+</p>
+
+<p>
+	Symbols within the current context 
+	are referred to simply by their names, 
+	as are built-in functions and special symbols 
+	like <tt>nil</tt> and <tt>true</tt>. 
+	Symbols outside the current context 
+	are referenced by prefixing the symbol name 
+	with the context name and a <tt>:</tt> (colon). 
+	To quote a symbol in a different context, 
+	prefix the context name with a <tt>'</tt> (single quote).
+</p>
+
+<p>
+	Within a given context, symbols may be created 
+	with the same name as built-in functions 
+	or context symbols in MAIN.
+	This overwrites the symbols in MAIN 
+	when they are prefixed with a context:
+</p>
+
+
+<pre>
+(context 'CTX)
+(define (CTX:new var)
+    (&hellip;))
+    
+(context 'MAIN)
+</pre>
+
+
+<p><tt>CTX:new</tt> will overwrite new in MAIN.</p>
+
+<p> In the second syntax, <tt>context</tt> can be used to create symbols in a namespace.
+Note that this should not be used for creating hashes or dictionaries. For a shorter,
+more convenient method to use namespaces as hash-like dictionaries, see the chapter 
+<a href="#hash">Hash functions and dictionaries</a>.
+</p>
+
+
+<pre>
+;; create a symbol and store data in it
+(context 'Ctx "abc" 123)   <span class='arw'>&rarr;</span> 123
+(context 'Ctx 'xyz 999)    <span class='arw'>&rarr;</span> 999
+
+;; retrieve contents from  symbol
+(context 'Ctx "abc")       <span class='arw'>&rarr;</span> 123
+(context 'Ctx 'xyz)        <span class='arw'>&rarr;</span> 999
+Ctx:abc                    <span class='arw'>&rarr;</span> 123
+Ctx:xyz                    <span class='arw'>&rarr;</span> 999
+</pre>
+
+
+<p>
+The first three statements create a symbol and store a value of any data type inside. 
+The first statement also creates the context named <tt>Ctx</tt>.
+When a symbol is specified for the name, the name is taken
+from the symbol and creates a symbol with the same name
+in the context <tt>Ctx</tt>.
+</p>
+
+<p>
+Symbols can contain spaces or any other special characters 
+not typically allowed in newLISP symbols being used as variable names. 
+This second syntax of <tt>context</tt> only creates the new symbol 
+and returns the value contained in it.  It does not switch to the new namespace.
+</p>
+
+<br/><br/>
+
+<a name="contextp"></a>
+<h2><span class="function">context?</span></h2>
+
+<h4>syntax: (context? <em>exp</em>)<br/>
+syntax: (context? <em>exp</em> <em>str-sym</em>)</h4>
+
+<p>
+	In the first syntax, 
+	<em>context?</em> is a predicate that returns <tt>true</tt> 
+	only if <em>exp</em> evaluates to a context; 
+	otherwise, it returns <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(context? MAIN)  <span class='arw'>&rarr;</span> true
+(set 'x 123)
+(context? x)     <span class='arw'>&rarr;</span> nil
+
+(set 'FOO:q "hola")  <span class='arw'>&rarr;</span> "hola"
+(set 'ctx FOO)
+(context? ctx)       <span class='arw'>&rarr;</span> true  ; ctx contains context foo
+</pre>
+
+
+<p>
+	The second syntax checks for the existence of a symbol in a context. 
+	The symbol is specified by its name string in <em>str-sym</em>.
+</p>
+
+
+<pre>
+(context? FOO "q")  <span class='arw'>&rarr;</span> true
+(context? FOO "p")  <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p>
+	Use <a href="#context">context</a> to change and create namespaces 
+	and to create hash symbols in contexts.
+</p>
+
+<br/><br/>
+
+<a name="copy"></a>
+<h2><span class="function">copy</span></h2>
+<h4>syntax: (copy <em>exp</em>)<br/>
+syntax: (copy <em>int-addr</em> [<em>bool-flag</em>])</h4>
+
+<p>The first syntax makes a copy from evaluating expression in <em>exp</em>. 
+Some built-in functions are <a href="#destructice">destructive</a>, changing 
+the original contents of a list, array or string they are working on. 
+With <tt>copy</tt> their behavior can be made non-destructive.</p>
+
+<pre>
+(set 'aList '(a b c d e f))
+
+(replace 'c (copy aList)) <span class='arw'>&rarr;</span> (a b d e f)
+
+aList <span class='arw'>&rarr;</span> (a b c d e f)
+
+(set 'str "newLISP") <span class='arw'>&rarr;</span> "newLISP"
+
+(rotate (copy str)) <span class='arw'>&rarr;</span> "PnewLIS"
+
+str <span class='arw'>&rarr;</span> "newLISP" 
+</pre>
+
+<p>Using <tt>copy</tt> the functions <a href="#replace">replace</a> and
+<a href="#rotate">rotate</a> are prevented from changing the data.
+A modified version of the data is returned.</p>
+
+<p>The second syntax, marked by the <tt>true</tt> in <em>bool-flag</em>,
+copies a newLISP expression from a memory address.The following two
+expressions are equivalent:</p>
+
+<pre>
+(set 'x "hello world")
+(copy x)  <span class='arw'>&rarr;</span> "hello world"
+(copy (first (dump x)) true) <span class='arw'>&rarr;</span> "hello world"
+</pre>
+
+<p>The second syntax can be useful when interfacing with C-code generating
+newLISP expressions.</p>
+
+
+<br/><br/>
+
+<a name="copy-file"></a>
+<h2><span class="function">copy-file</span></h2>
+<h4>syntax: (copy-file <em>str-from-name</em> <em>str-to-name</em>)</h4>
+
+<p>
+	Copies a file from a path-filename given in <em>str-from-name</em> 
+	to a path-filename given in <em>str-to-name</em>. 
+	Returns <tt>true</tt> if the copy was successful or <tt>nil</tt>, 
+	if the copy was unsuccessful.
+</p>
+
+<!-- example -->
+
+<pre>
+(copy-file "/home/me/newlisp/data.lsp" "/tmp/data.lsp")
+</pre>
+
+<br/><br/>
+
+<a name="corr"></a>
+<h2><span class="function">corr</span></h2>
+<h4>syntax: (corr <em>list-vector-X</em> <em>list-vector-Y</em>)</h4>
+
+<p>Calculates the <em>Pearson</em> product-moment correlation coefficient as a measure
+of the linear relationship between the two variables in  <em>list-vector-X</em>
+and  <em>list-vector-Y</em>. Both lists must be of same length.</p>
+
+<p><tt>corr</tt> returns a list containing the following values:</p>
+
+<table>
+<tr align="left"><th>name</th><th>description</th></tr>
+<tr><td>r</td><td>Correlation coefficient</td></tr>
+<tr><td>b0</td><td>Regression coefficient offset</td></tr>
+<tr><td>b1</td><td>Regression coefficient slope</td></tr>
+<tr><td>t</td><td>t - statistic for significance testing</td></tr>
+<tr><td>df</td><td>Degrees of freedom for t</td></tr>
+<tr><td>p</td><td>Two tailed probability of t under the null hypothesis</td></tr>
+</table>
+<br />
+<!-- example -->
+
+<pre>
+(set 'study-time '(90 100 130 150 180 200 220 300 350 400))
+(set 'test-errors '(25 28 20 20 15 12 13 10 8 6))
+
+(corr study-time test-errors) <span class='arw'>&rarr;</span> (-0.926 29.241 -0.064 -6.944 8 0.0001190)
+</pre>
+
+<p>The negative correlation of <tt>-0.926</tt> between study time and test errors is 
+highly significant with a two-tailed <tt>p</tt> of about <tt>0.0001</tt> under the null hypothesis.</p>
+
+<p>The regression coefficients <tt>b0 = 29.241</tt> and <tt>b1 = -0.064</tt>
+can be used to estimate values of the Y variable (test errors) from values in X (study time)
+using the equation <tt><em><b>Y = b0 + b1 * X</b></em></tt>.</p>
+
+<br/><br/>
+
+<a name="cos"></a>
+<h2><span class="function">cos</span></h2>
+<h4>syntax: (cos <em>num-radians</em>)</h4>
+
+<p>
+	Calculates the cosine of <em>num-radians</em>
+	and returns the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(cos 1)                     <span class='arw'>&rarr;</span> 0.5403023059
+(set 'pi (mul 2 (acos 0)))  <span class='arw'>&rarr;</span> 3.141592654
+(cos pi)                    <span class='arw'>&rarr;</span> -1
+</pre>
+
+<br/><br/>
+
+<a name="cosh"></a>
+<h2><span class="function">cosh</span></h2>
+<h4>syntax: (cosh <em>num-radians</em>)</h4>
+
+<p>Calculates the hyperbolic cosine of <em>num-radians</em>. 
+The hyperbolic cosine is defined mathematically as: 
+<em>(exp (x) + exp (-x)) / 2</em>.
+An overflow to <tt>inf</tt> may occur 
+if <em>num-radians</em> is too large.</p>
+
+<!-- example -->
+
+<pre>
+(cosh 1)     <span class='arw'>&rarr;</span> 1.543080635
+(cosh 10)    <span class='arw'>&rarr;</span> 11013.23292
+(cosh 1000)  <span class='arw'>&rarr;</span> inf
+(= (cosh 1) (div (add (exp 1) (exp -1)) 2))  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="count"></a>
+<h2><span class="function">count</span></h2>
+<h4>syntax: (count <em>list-1</em> <em>list-2</em>)</h4>
+
+<p>
+	Counts elements of <em>list-1</em> in <em>list-2</em> 
+	and returns a list of those counts.
+</p>
+
+<!-- example -->
+
+<pre>
+(count '(1 2 3) '(3 2 1 4 2 3 1 1 2 2))  <span class='arw'>&rarr;</span> (3 4 2)
+(count '(z a) '(z d z b a z y a))        <span class='arw'>&rarr;</span> (3 2)
+
+(set 'lst (explode (read-file "myFile.txt")))
+(set 'letter-counts (count (unique lst) lst))
+</pre>
+
+<p>
+	The second example counts all occurrences 
+	of different letters in <tt>myFile.txt</tt>.
+</p>
+
+<p>
+	The first list in <tt>count</tt>, 
+	which specifies the items to be counted in the second list, 
+	should be unique. 
+	For items that are not unique, 
+	only the first instance will carry a count; 
+	all other instances will display <tt>0</tt> (zero).
+</p>
+
+<br/><br/>
+
+<a name="cpymem"></a>
+<h2><span class="function">cpymem</span>&nbsp; 
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (cpymem <em>int-from-address</em> <em>int-to-address</em> <em>int-bytes</em>)</h4>
+
+<p>Copies <em>int-bytes</em> of memory from <em>int-from-address</em> 
+to <em>int-to-address</em>. This function can be used for 
+direct memory writing/reading or for hacking newLISP internals
+(e.g., type bits in newLISP cells, or building functions with binary 
+executable code on the fly).</p>
+
+<p>Note that this function should only be used when familiar with newLISP internals.
+<tt>cpymem</tt> can crash the system or make it unstable if used incorrectly.</p>
+
+<!-- example -->
+
+<pre>
+(set 's "0123456789")
+
+(cpymem "xxx" (+ (address s) 5) 3)
+
+s  <span class='arw'>&rarr;</span> "01234xxx89")
+</pre>
+
+
+<p>The example copies a string directly into a string variable.</p>
+
+<p>The following example creates a new function from scratch, 
+runs a piece of binary code, and adds up two numbers. 
+This assembly language snippet shows the x86 (Intel CPU) code 
+to add up two numbers and return the result:</p>
+
+
+<pre>
+ 55       push ebp
+ 8B EC    mov  ebp, esp
+ 8B 45 08 mov  eax, [ebp+08]
+ 03 45 0C add  eax, [ebp+0c]
+ 5D       pop  ebp
+ C3       ret
+
+ ; for Win32/stdcall change last line
+ C2 08 00 ret 
+</pre>
+
+
+<p>The binary representation is attached to a new function created 
+in newLISP:</p>
+
+
+<pre>
+; set up 32-bit version of machine code
+; on Windows use 32-bit version of newLISP
+(set 'foo-code (append
+     (pack "bbbbbbbbbb" 0x55 0x8B 0xEC 0x8B 0x45 0x08 0x03 0x45 0x0C 0x5D)
+     (if (= ostype "Windows") (pack "bbb" 0xC2 0x08 0x00) (pack "b" 0xC3))))
+
+; put a function cell template into foo, protect symbol from deletion
+(constant 'foo print)
+
+; put the correct type, either 'stdcall' or 'cdecl'
+(cpymem (pack "ld" (if (= ostype "Windows") 8456 4360)) (first (dump foo)) 4)
+
+; put the address of foo-code into the new function cell
+(cpymem (pack "ld" (address foo-code)) (+ (first (dump foo)) 12) 4)
+
+; take the name address from the foo symbol, copy into function cell
+(set 'sym-name (first (unpack "lu" (+ (address 'foo) 8))))
+(cpymem (pack "ld" sym-name) (+ (first (dump foo)) 8) 4)
+
+; test the new function
+(println "3 * 4 -> " (foo 3 4))
+</pre>
+
+<p>The last example will not work on all hardware platforms and OSs.</p>
+
+<p>Use the <a href="#dump">dump</a> function to retrieve binary addresses 
+and the contents from newLISP cells.</p>
+
+
+<br/><br/>
+
+<a name="crc32"></a>
+<h2><span class="function">crc32</span></h2>
+<h4>syntax: (crc32 <em>str-data</em>)</h4>
+
+<p>
+	Calculates a running 32-bit CRC (Circular Redundancy Check) sum 
+	from the buffer in <em>str-data</em>, 
+	starting with a CRC of <tt>0xffffffff</tt> for the first byte. 
+	<tt>crc32</tt> uses an algorithm published 
+	by <a href="http://www.w3.org">www.w3.org</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(crc32 "abcdefghijklmnopqrstuvwxyz")  <span class='arw'>&rarr;</span> 1277644989
+</pre>
+
+
+<p>
+	<tt>crc32</tt> is often used to verify data integrity 
+	in unsafe data transmissions.
+</p>
+
+<br/><br/>
+
+<a name="crit-chi2"></a>
+<h2><span class="function">crit-chi2</span></h2>
+
+<h4>syntax: (crit-chi2 <em>num-probability</em> <em>int-df</em>)</h4>
+
+<p>Calculates the critical minimum <em>Chi&sup2;&nbsp;</em> for a given confidence probability 
+<em>num-probability</em> under the null hypothesis and the degrees of freedom in
+<em>int-df&nbsp;</em> for testing the significance of a statistical null hypothesis.</p>
+
+<p>Note that versions prior to 10.2.0 took <em>(1.0 - p)</em> for the probability
+instead of <em>p</em>.</p>
+
+<!-- example -->
+
+<pre>
+(crit-chi2 0.01 4)  <span class='arw'>&rarr;</span> 13.27670443
+</pre>
+
+
+<p>
+	See also the inverse function <a href="#prob-chi2">prob-chi2</a>.
+</p> 
+
+<br/><br/>
+
+<a name="crit-f"></a>
+<h2><span class="function">crit-f</span></h2>
+
+<h4>syntax: (crit-f <em>num-probability</em> <em>int-df1</em> <em>int-df2</em>)</h4>
+
+<p>Calculates the critical minimum <em>F&nbsp;</em> for a given confidence probability
+<em>num-probability</em> under the null hypothesis and the degrees of freedom 
+given in <em>int-df1</em> and <em>int-df2</em> for testing the significance of a 
+statistical null hypothesis using the <em>F-test</em>.</p>
+
+<!-- example -->
+
+<pre>
+(crit-f 0.05 10 12)  <span class='arw'>&rarr;</span> 2.753386727
+</pre>
+
+<p>
+See also the inverse function <a href="#prob-f">prob-f</a>.
+</p> 
+
+<br/><br/>
+
+<a name="crit-t"></a>
+<h2><span class="function">crit-t</span></h2>
+
+<h4>syntax: (crit-t <em>num-probability</em> <em>int-df</em>)</h4>
+
+<p>Calculates the critical minimum <em>Student's t</em> for a given confidence probability 
+<em>num-probability</em> under the null hypothesis and the degrees of freedom in
+<em>int-df&nbsp;</em> for testing the significance of a statistical null hypothesis.
+</p>
+
+<!-- example -->
+
+<pre>
+(crit-t 0.05 14)  <span class='arw'>&rarr;</span> 1.761310142
+</pre>
+
+
+<p>
+See also the inverse function <a href="#prob-t">prob-t</a>.
+</p> 
+
+<br/><br/>
+
+
+<a name="crit-z"></a>
+<h2><span class="function">crit-z</span></h2>
+<h4>syntax: (crit-z <em>num-probability</em>)</h4>
+
+<p>Calculates the critical normal distributed Z value 
+of a given cumulated probability <em>num-probability</em> 
+for testing of statistical significance and confidence intervals.</p>
+
+<!-- example -->
+
+<pre>
+(crit-z 0.999)  <span class='arw'>&rarr;</span> 3.090232372
+</pre>
+
+
+<p>
+	See also the inverse function <a href="#prob-z">prob-z</a>.
+</p> 
+
+<br/><br/>
+
+<a name="current-line"></a>
+<h2><span class="function">current-line</span></h2>
+<h4>syntax: (current-line)</h4>
+
+<p>
+	Retrieves the contents of the last 
+	<a href="#read-line">read-line</a> operation. 
+	<tt>current-line</tt>'s contents are also implicitly used 
+	when <a href="#write-line">write-line</a> 
+	is called without a string parameter.
+</p>
+
+<p>
+	The following source shows the typical code pattern 
+	for creating a Unix command-line filter:
+</p>
+
+<!-- example -->
+
+<pre>
+#!/usr/bin/newlisp
+ 
+(set 'inFile (open (main-args 2) "read"))
+(while (read-line inFile) 
+  (if (starts-with (current-line) ";;")
+    (write-line)))
+(exit)
+</pre>
+
+
+<p>
+	The program is invoked:
+</p>
+
+
+<pre>
+./filter myfile.lsp
+</pre>
+
+
+<p>
+	This displays all comment lines starting with <tt>;;</tt> 
+	from a file given as a command-line argument 
+	when invoking the script <tt>filter</tt>.
+</p>
+
+<br/><br/>
+
+<a name="curry"></a>
+
+<h2><span class="function">curry</span></h2>
+<h4>syntax: (curry <em>func</em> <em>exp</em>)</h4>
+
+<p>Transforms <em>func</em> from a function <em>f(x, y)</em> that takes 
+two arguments into a function <em>fx(y)</em> that takes a single argument. 
+<tt>curry</tt> works like a macro in that it does not evaluate its arguments. 
+Instead, they are evaluated during the application of <em>func</em>.</p>
+
+
+<!-- example -->
+
+<pre>
+(set 'f (curry + 10))  <span class='arw'>&rarr;</span> (lambda ($x) (+ 10 $x))
+
+(f 7)  <span class='arw'>&rarr;</span> 17
+
+(filter (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+<span class='arw'>&rarr;</span>  ((a 10) (a 3) (a 9))
+
+(clean (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+<span class='arw'>&rarr;</span>  ((b 5) (c 8))
+
+(map (curry list 'x) (sequence 1 5))
+<span class='arw'>&rarr;</span>  ((x 1) (x 2) (x 3) (x 4) (x 5))
+</pre>
+
+
+<p><tt>curry</tt> can be used on all functions taking two arguments.</p>
+
+<br/><br/>
+
+<a name="date"></a>
+
+<h2><span class="function">date</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (date)<br/>
+syntax: (date <em>int-secs</em> [<em>int-offset</em>])<br/>
+syntax: (date <em>int-secs</em> <em>int-offset</em> <em>str-format</em>)</h4>
+
+<p>
+The first syntax returns the local time zone's 
+current date and time as a string representation.
+If <em>int-secs</em> is out of range, <tt>nil</tt> is returned.    
+</p>
+
+<p>
+In the second syntax, <tt>date</tt> translates the number of seconds 
+in <em>int-secs</em> into its date/time string representation 
+for the local time zone. 
+The number in <em>int-secs</em> is usually retrieved from the system 
+using <a href="#date-value">date-value</a>. 
+Optionally, a time-zone offset (in minutes) can be specified 
+in <em>int-offset</em>, which is added 
+or subtracted before conversion of <em>int-sec</em> to a string.
+If <em>int-secs</em> is out of range or an invalid <em>str-format</em>
+is specified, an empty string <tt>""</tt> is returned.
+</p>
+
+
+<!-- example -->
+
+<pre>
+(date)                   <span class='arw'>&rarr;</span> "Fri Oct 29 09:56:58 2004"
+
+(date (date-value))      <span class='arw'>&rarr;</span> "Sat May 20 11:37:15 2006" 
+(date (date-value) 300)  <span class='arw'>&rarr;</span> "Sat May 20 16:37:19 2006"  ; 5 hours offset
+(date 0)                 <span class='arw'>&rarr;</span> "Wed Dec 31 16:00:00 1969"
+(date 0 (now 0 -2))      <span class='arw'>&rarr;</span> "Thu Jan  1 00:00:00 1970"  ; Unix epoch
+</pre>
+
+<p>The way the date and time are presented in a string 
+depends on the underlying operating system.</p>
+
+<p>The second example would show 1-1-1970 0:0 when in the Greenwich time zone, 
+but it displays a time lag of 8 hours when in Pacific Standard Time (PST).
+<tt>date</tt> assumes the <em>int-secs</em> given are in Coordinated Universal 
+Time (UTC; formerly Greenwich Mean Time (GMT)) and converts it according to the 
+local time-zone.</p>
+
+<p>The third syntax makes the date string fully customizable by using a format 
+specified in <em>str-format</em>.  This allows the day and month names to be 
+translated into results appropriate for the current locale:</p>
+
+<!-- example -->
+
+<pre>
+(set-locale "german") <span class='arw'>&rarr;</span> "de_DE"      
+
+; on Linux - no leading 0 on day with %-d
+(date (date-value) 0 "%A %-d. %B %Y")  <span class='arw'>&rarr;</span> "Montag  7. M&auml;rz 2005" 
+
+(set-locale "C")  ; default POSIX
+
+(date (date-value) 0 "%A %B %d %Y")    <span class='arw'>&rarr;</span> "Monday March 07 2005"
+
+; suppressing leading 0 on MS Windows using #
+(date (date-value) 0 "%a %#d %b %Y")   <span class='arw'>&rarr;</span> "Mon 7 Mar 2005" 
+
+(set-locale "german")
+
+(date (date-value) 0 "%x") <span class='arw'>&rarr;</span> "07.03.2005"   ; day month year
+
+(set-locale "C")
+
+(date (date-value) 0 "%x") <span class='arw'>&rarr;</span> "03/07/05"     ; month day year
+</pre>
+
+
+<p>The following table summarizes all format specifiers available 
+on both MS Windows and Linux/Unix platforms.  More format options are 
+available on Linux/Unix. For details, consult the manual page for 
+the C function <tt>strftime()</tt> of the individual platform's C library.
+</p>
+
+<table width="98%"  summary="date formatting">
+<tr align="left"><th>format</th><th>description</th></tr>
+<tr><td>%a</td><td>abbreviated weekday name according to the current locale</td></tr>
+
+<tr><td>%A</td><td>full weekday name according to the current locale</td></tr>
+<tr><td>%b</td><td>abbreviated month name according to the current locale</td></tr>
+<tr><td>%B</td><td>full month name according to the current locale</td></tr>
+<tr><td>%c</td><td>preferred date and time representation for the current locale</td></tr>
+<tr><td>%d</td><td>day of the month as a decimal number (range 01&ndash;31)</td></tr>
+<tr><td>%H</td><td>hour as a decimal number using a 24-hour clock (range 00&ndash;23)</td></tr>
+
+<tr><td>%I</td><td>hour as a decimal number using a 12-hour clock (range 01&ndash;12)</td></tr>
+<tr><td>%j</td><td>day of the year as a decimal number (range 001&ndash;366)</td></tr>
+<tr><td>%m</td><td>month as a decimal number (range 01&ndash;12)</td></tr>
+<tr><td>%M</td><td>minute as a decimal number</td></tr>
+<tr><td>%p</td><td>either 'am' or 'pm' according to the given time value or
+the corresponding strings for the current locale</td></tr>
+<tr><td>%S</td><td>second as a decimal number 0&ndash;61 (60 and 61 to account
+for occasional leap seconds)</td></tr>
+
+<tr><td>%U</td><td>week number of the current year as a decimal number,
+starting with the first Sunday as the first day of the first week</td></tr>
+<tr><td>%w</td><td>day of the week as a decimal, Sunday being 0</td></tr>
+<tr><td>%W</td><td>week number of the current year as a decimal number,
+starting with the first Monday as the first day of the first week</td></tr>
+<tr><td>%x</td><td>preferred date representation for the current locale
+without the time</td></tr>
+<tr><td>%X</td><td>preferred time representation for the current locale
+without the date</td></tr>
+<tr><td>%y</td><td>year as a decimal number without a century (range 00&ndash;99)</td></tr>
+
+<tr><td>%Y</td><td>year as a decimal number including the century</td></tr>
+<tr><td>%z</td><td>time zone or name or abbreviation (same as %Z on MS Windows,
+different on Unix)</td></tr>
+<tr><td>%Z</td><td>time zone or name or abbreviation (same as %z on MS Windows,
+different on Unix)</td></tr>
+<tr><td>%%</td><td>a literal '%' character</td></tr>
+</table><br/>
+
+<p>
+Leading zeroes in the display of decimal day numbers can be suppressed 
+using <tt>"%-d"</tt> on Linux and FreeBSD and using <tt>"%e"</tt> 
+on OpenBSD, SunOS/Solaris and Mac OS X.  On MS Windows use <tt>"%#d"</tt>.
+</p>
+
+<p>See also <a href="#date-value">date-value</a>, <a href="#date-list">date-list</a>,
+<a href="#date-parse">date-parse</a>, 
+<a href="#time-of-day">time-of-day</a>, 
+<a href="#time">time</a>, and <a href="#now">now</a>.
+</p>
+
+<br/><br/>
+
+<a name="date-list"></a>
+<h2><span class="function">date-list</span></h2>
+<h4>syntax: (date-list <em>int-seconds</em> [<em>int-index</em>])<br/>
+syntax: (date-list)</h4>
+
+<p>Returns a list of year, month, date, hours, minutes, seconds, day of year 
+and day of week from a time value given in seconds after January 1st, 1970 00:00:00.
+The date and time values aren given as UTC, which may differ from the local timezone.
+</p>
+<p>When no parameters are given <tt>date-list</tt> generates the list from the
+number of seconds for the current time, return of <tt>(date-value)</tt>.</p>
+
+<p>The week-day value ranges from 1 to 7 for Monday thru Sunday.</p>
+
+<pre>
+(date-list 1282479244)      <span class='arw'>&rarr;</span> (2010 8 22 12 14 4 234 1)
+(date-list 1282479244 0)    <span class='arw'>&rarr;</span> 2010 ; year
+(date-list 1282479244 -2)   <span class='arw'>&rarr;</span> 234  ; day of year
+
+(date-value (date-list 1282479244)) <span class='arw'>&rarr;</span> 1282479244
+
+(date-list 0)   <span class='arw'>&rarr;</span> (1970 1 1 0 0 0 1 4) ; Thursday 1st, Jan 1970
+</pre>
+
+<p>A second optional <em>int-index</em> parameter can be used to return
+a specific member of the list.</p>
+
+<p><tt>date-list</tt> is the inverse operation of <a href="#date-value">date-value</a>.</p>
+
+<br/><br/>
+
+<a name="date-parse"></a>
+<h2><span class="function">date-parse</span></h2>
+<h4>syntax: (date-parse <em>str-date</em> <em>str-format</em>)</h4>
+
+<p>Parses a date from a text string in <em>str-date</em>
+using a format as defined in <em>str-format</em>, which uses
+the same formatting rules found in <a href="#date">date</a>.
+The function <tt>date-parse</tt> returns the number of UTC seconds passed   
+since January 1st, 1970 UTC starting with 0 and up to 2147472000 for a date 
+of January 19th, 2038.</p> 
+
+<p>This function is not available on MS Windows platforms. The function was
+named <tt>parse-date</tt> in previous versions. The old form is deprecated.</p>
+
+<!-- example -->
+
+<pre>
+(date-parse "2007.1.3" "%Y.%m.%d")    <span class='arw'>&rarr;</span> 1167782400
+(date-parse "January 10, 07" "%B %d, %y")    <span class='arw'>&rarr;</span> 1168387200
+
+; output of date-parse as input value to date-list produces the same date 
+
+(date-list (date-parse "2010.10.18 7:00" "%Y.%m.%d %H:%M"))
+<span class='arw'>&rarr;</span> (2010 10 18 7 0 0 290 1)
+</pre>
+
+
+<p>See the <a href="#date">date</a> function for all possible format descriptors.</p>
+
+<br/><br/>
+<a name="date-value"></a>
+<h2><span class="function">date-value</span></h2>
+
+<h4>syntax: (date-value <em>int-year</em> <em>int-month</em> <em>int-day</em> [<em>int-hour</em> <em>int-min</em> <em>int-sec</em>])<br/> 
+syntax: (date-value <em>list-date-time</em>)<br/> 
+syntax: (date-value)</h4>
+
+<p>In the first syntax, <tt>date-value</tt> returns the time 
+in seconds since 1970-1-1 00:00:00 for a given date and time.  
+The parameters for the hour, minutes and seconds are optional. 
+The time is assumed to be Coordinated Universal Time (UTC), 
+not adjusted for the current time zone.</p>
+<p>In the second syntax the same data can be given in a list.
+As with the first syntax, numbers for the hour, minutes 
+and seconds are optional.</p>
+
+<p>In the third syntax, <tt>date-value</tt> returns the time value 
+in seconds for the current time.</p>
+
+<!-- example -->
+
+<pre>
+(date-value 2002 2 28)       <span class='arw'>&rarr;</span> 1014854400
+(date-value '(2002 2 28))    <span class='arw'>&rarr;</span> 1014854400
+(date-value 1970 1 1 0 0 0)  <span class='arw'>&rarr;</span> 0
+                                 
+(date (date-value (now)))    <span class='arw'>&rarr;</span> "Wed May 24 10:02:47 2006" 
+(date (date-value))          <span class='arw'>&rarr;</span> "Wed May 24 10:02:47 2006"
+(date)                       <span class='arw'>&rarr;</span> "Wed May 24 10:02:47 2006"
+</pre>
+
+
+<p>The function <a href="#date-list">date-list</a> can be used to transform 
+a <tt>date-value</tt> back into a list:</p>
+
+
+<pre>
+(date-list 1014854400)  <span class='arw'>&rarr;</span> (2002 2 28 0 0 0)
+(date-value (date-list 1014854400))  <span class='arw'>&rarr;</span> 1014854400
+</pre>
+
+
+<p>See also <a href="#date">date</a>, 
+<a href="#date-list">date-list</a>, <a href="#date-parse">date-parse</a>, 
+<a href="#time-of-day">time-of-day</a>, <a href="#time">time</a>, and 
+<a href="#now">now</a>.</p>
+
+<br/><br/>
+
+<a name="debug"></a>
+<h2><span class="function">debug</span></h2>
+<h4>syntax: (debug <em>func</em>)</h4>
+
+<p>
+Calls <a href="#trace">trace</a> and begins evaluating the user-defined 
+function in <em>func</em>. <tt>debug</tt> is a shortcut for executing 
+<tt>(trace true)</tt>, then entering the function to be debugged.</p>
+
+<!-- example -->
+
+<pre>
+;; instead of doing
+(trace true)
+(my-func a b c)
+(trace nil)
+
+;; use debug as a shortcut
+(debug (my-func a b c))
+</pre>
+
+<p>When in <tt>debug</tt> or <a href="#trace">trace</a> mode, error messages
+will be printed. The function causing the exception will return either
+<tt>0</tt> or <tt>nil</tt> and processing will continue. This way, variables 
+and the current state of the program can still be inspected while debugging.</p>
+
+<p>See also the <a href="#trace">trace</a> function.</p>
+
+<br/><br/>
+
+<a name="dec"></a>
+<h2><span class="function">dec</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (dec <em>place</em> [<em>num</em>])</h4>
+
+<p>
+The number in <em>place</em> is decremented by <tt>1.0</tt> or the optional number 
+<em>num</em> and returned.  <tt>dec</tt> performs float arithmetic and converts
+integer numbers passed into floating point type.</p>
+
+<p><em>place</em> is either a symbol or a place in a list structure holding a
+number, or a number returned by an expression.</p>
+
+<!-- example -->
+
+<pre>
+(set x 10)    <span class='arw'>&rarr;</span> 10
+(dec x)       <span class='arw'>&rarr;</span> 9
+x             <span class='arw'>&rarr;</span> 9
+(dec x 0.25)  <span class='arw'>&rarr;</span> 8.75
+x             <span class='arw'>&rarr;</span> 8.75
+</pre>
+
+
+<p>If the symbol for <em>place</em> contains <tt>nil</tt>, it is treated
+as if containing <tt>0.0</tt>:</p>
+
+
+<pre>
+z             <span class='arw'>&rarr;</span> nil
+(dec z)       <span class='arw'>&rarr;</span> -1
+
+(set z nil)
+(dec z 0.01)  <span class='arw'>&rarr;</span> -0.01
+</pre>
+
+
+<p>Places in a list structure or a number returned by another expression
+can be updated too:</p>
+
+
+<pre>
+(set 'l '(1 2 3 4))
+
+(dec (l 3) 0.1) <span class='arw'>&rarr;</span> 3.9
+
+(dec (first l)) <span class='arw'>&rarr;</span> 0
+
+l <span class='arw'>&rarr;</span> (0 2 3 3.9)
+
+(dec (+ 3 4)) <span class='arw'>&rarr;</span> 6
+</pre>
+
+<p>Use the <a href="#deci">--</a> function to decrement in integer mode.
+Use the <a href="#inc">inc</a> function to increment numbers floating point mode.</p>
+
+<br/><br/>
+
+<a name="def-new"></a>
+<h2><span class="function">def-new</span></h2>
+<h4>syntax: (def-new <em>sym-source</em> [<em>sym-target</em>])</h4>
+
+<p>
+	This function works similarly to <a href="#new">new</a>, 
+	but it only creates a copy of one symbol 
+	and its contents from the symbol in <em>sym-source</em>. 
+	When <em>sym-target</em> is not given, 
+	a symbol with the same name is created 
+	in the current context. 
+	All symbols referenced inside <em>sym-source</em> 
+	will be translated into symbol references into the current context,
+    which must not be MAIN.</p>
+<p>
+If an argument is present in <em>sym-target</em>, the copy will be made
+into a symbol and context as referenced by the symbol in <em>sym-target</em>. 
+In addition to allowing renaming of the function while copying, this also 
+enables the copy to be placed in a different context.  All symbol references 
+in <em>sym-source</em> with the same context as <em>sym-source</em> will 
+be translated into symbol references of the target context.
+</p>
+
+<p>
+	<tt>def-new</tt> returns the symbol created:
+</p>
+
+<!-- example -->
+
+<pre>
+&gt; (set 'foo:var '(foo:x foo:y))
+<b>(foo:x foo:y)</b>
+
+&gt; (def-new 'foo:var 'ct:myvar)
+<b>ct:myvar</b>
+
+&gt; ct:myvar
+<b>(ct:x ct:y)</b>
+
+&gt; (context 'K)
+
+K&gt; (def-new 'foo:var)
+<b>var</b>
+
+K&gt; var
+<b>(x y)</b>
+</pre>
+
+<p>The following example shows how a statically scoped function can
+be created by moving it its own namespace:</p>
+
+<pre>
+&gt; (set 'temp (lambda (x) (+ x x)))
+<b>(lambda (x) (+ x x))</b>
+&gt; (def-new 'temp 'double:double)
+<b>double:double</b>
+&gt; (double 10)
+<b>20</b>
+&gt; double:double
+<b>(lambda (double:x) (+ double:x double:x))</b>
+</pre>
+
+<p>The following definition of <tt>def-static</tt> can be used to
+create functions living in their own lexically protected name-space:</p>
+<pre>
+(define (def-static s body) 
+      (def-new 'body (sym s s)))
+
+(def-static 'acc (lambda (x)
+          (inc sum x)))
+
+&gt; (acc 1)
+<b>1</b>
+&gt; (acc 1)
+<b>2</b>
+&gt; (acc 8)
+<b>10</b>
+&gt;
+</pre>
+
+<p>The function <tt>def-new</tt> can also be used to configure contexts 
+or context objects in a more granular fashion than is possible 
+with <a href="#new">new</a>, which copies a whole context.</p>
+
+<br/><br/>
+
+<a name="default"></a>
+<h2><span class="function">default</span></h2>
+<h4>syntax: (default <em>context</em>)</h4>
+
+<p>Return the contents of the default functor in <em>context</em>.</p>
+
+<!-- example -->
+
+<pre>
+(define Foo:Foo 123)
+
+(default Foo) <span class='arw'>&rarr;</span> 123
+
+(setf (default Foo) 456)
+(set 'ctx Foo)
+
+(default ctx) <span class='arw'>&rarr;</span> 456
+Foo:Foo       <span class='arw'>&rarr;</span> 456
+</pre>
+
+
+<p>In many situations newLISP defaults automatically to the default functor
+when seeing a context name. In circumstances where this is not the case,
+the <tt>default</tt> function can be used.</p>
+
+<br/><br/>
+
+<a name="define"></a>
+<h2><span class="function">define</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (define (<em>sym-name</em> [<em>sym-param-1</em> ... ]) [<em>body-1</em> ... ])<br/>
+syntax: (define (<em>sym-name</em> [(<em>sym-param-1</em> <em>exp-default</em>) ... ]) [<em>body-1</em> ... ])<br/>
+syntax: (define <em>sym-name</em> <em>exp</em>)</h4>
+
+<p>
+	Defines the new function <em>sym-name</em>, 
+	with optional parameters <em>sym-param-1</em>&mdash;. 
+	<tt>define</tt> is equivalent to assigning 
+	a lambda expression to <em>sym-name</em>. 
+	When calling a defined function, 
+	all arguments are evaluated and assigned 
+	to the variables in <em>sym-param-1</em>&mdash;, 
+	then the <em>body-1&mdash;	</em> expressions are evaluated. 
+	When a function is defined, the lambda expression 
+	bound to <em>sym-name</em> is returned.
+</p>
+
+<p>
+	All parameters defined are optional. 
+	When a user-defined function is called without arguments, 
+	those parameters assume the value <tt>nil</tt>. 
+<!-- 8.9.4 -->If those parameters have a default value 
+	specified in <em>exp-default</em>,
+	they assume that value.
+</p>
+
+<p>
+	The return value of <tt>define</tt> 
+	is the assigned <em>lambda</em> expression. 
+	When calling a user-defined function, 
+	the return value is the last expression evaluated 
+	in the function body.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (area x y) (* x y))  <span class='arw'>&rarr;</span> (lambda (x y) (* x y))
+(area 2 3)                   <span class='arw'>&rarr;</span> 6
+</pre>
+
+
+<p>
+	As an alternative, <tt>area</tt> could be defined 
+	as a function without using <tt>define</tt>.
+</p>
+
+
+<pre>
+(set 'area (lambda (x y) (* x y))
+</pre>
+
+
+<p>
+	<em>lambda</em> or <em>fn</em> expressions may be used by themselves 
+	as <em>anonymous</em> functions without being defined as a symbol:
+</p>
+
+
+<pre>
+((lambda ( x y) (* x y)) 2 3)  <span class='arw'>&rarr;</span> 6
+((fn ( x y) (* x y)) 2 3)      <span class='arw'>&rarr;</span> 6
+</pre>
+
+
+<p>
+	<tt>fn</tt> is just a shorter form of writing <tt>lambda</tt>.
+</p>
+	
+<!-- 8.9.4 -->
+<p>
+	Parameters can have default values specified:
+</p>
+
+
+<pre>
+(define (foo (a 1) (b 2))
+  (list a b))
+    
+(foo)      <span class='arw'>&rarr;</span> (1 2)
+(foo 3)    <span class='arw'>&rarr;</span> (3 2)
+(foo 3 4)  <span class='arw'>&rarr;</span> (3 4)
+</pre>
+
+
+<p>
+	Expressions in <em>exp-default</em> 
+	are evaluated in the function's
+	current environment.
+</p>
+
+
+<pre>
+(define (foo (a 10) (b (div a 2))) 
+  (list a b))
+
+(foo)      <span class='arw'>&rarr;</span> (10 5)
+(foo 30)   <span class='arw'>&rarr;</span> (30 15)
+(foo 3 4)  <span class='arw'>&rarr;</span> (3 4)
+</pre>
+
+
+<p>
+	The second version of <tt>define</tt> 
+	works like the <a href="#set">set</a> function.
+</p>
+
+<!-- example -->
+
+<pre>
+(define x 123)  <span class='arw'>&rarr;</span>   123
+;; is equivalent to
+(set 'x 123)    <span class='arw'>&rarr;</span>   123
+
+(define area (lambda ( x y) (* x y)))
+;; is equivalent to
+(set 'area (lambda ( x y) (* x y)))
+;; is equivalent to
+(define (area x y) (* x y))
+</pre>
+
+
+<p>
+	Trying to redefine a protected symbol will cause an error message.
+</p>
+
+<br/><br/>
+
+<a name="define-macro"></a>
+<h2><span class="function">define-macro</span></h2>
+<h4>syntax: (define-macro (<em>sym-name</em> [<em>sym-param-1</em> ... ]) <em>body</em>)<br/>
+syntax: (define-macro (<em>sym-name</em> [(<em>sym-param-1</em> <em>exp-default</em>) ... ]) <em>body</em>)</h4>
+
+<p>Functions defined using <tt>define-macro</tt> are called <i>fexpr</i>
+in other LISPs as they don't do variable expansion. In newLISP they are still
+called macros, because they are written with the same purpose of creating
+special syntax forms with non-standard evaluation patterns of arguments. 
+Functions created using <tt>define-macro</tt> can be combined with template 
+expansion using <a href="#expand">expand</a> or <a href="#letex">letex</a>.</p>
+
+<p>Since v.10.5.8, newLISP also has expansion macros using <a href="#macro">macro</a>.</p>
+
+<p>Defines the new fexpr <em>sym-name</em>, with optional arguments <em>sym-param-1</em>. 
+<tt>define-macro</tt> is equivalent to assigning a lambda-macro expression to a symbol. 
+When a <tt>define-macro</tt> function is called, unevaluated arguments are assigned to 
+the variables in <em>sym-param-1 ...</em>. Then the <em>body</em> expressions are evaluated.  
+When evaluating the <tt>define-macro</tt> function, the lambda-macro expression is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(define-macro (my-setq p1 p2) (set p1 (eval p2))) 
+<span class='arw'>&rarr;</span> (lambda-macro (p1 p2) (set p1 (eval p2)))
+
+(my-setq x 123)  <span class='arw'>&rarr;</span> 123
+x                <span class='arw'>&rarr;</span> 123
+</pre>
+
+
+<p>New functions can be created to behave like built-in functions
+that delay the evaluation of certain arguments.  Because fexprs can 
+access the arguments inside a parameter list, they can be used to 
+create flow-control functions like those already built-in to newLISP.</p>
+
+<p>All parameters defined are optional.  When a macro is called without 
+arguments, those parameters assume the value <tt>nil</tt>. 
+If those parameters have a default value specified in <em>exp-default</em>,
+they assume that default value.</p>
+	
+
+<pre>
+(define-macro (foo (a 1) (b 2))
+  (list a b))
+    
+(foo)      <span class='arw'>&rarr;</span> (1 2)
+(foo 3)    <span class='arw'>&rarr;</span> (3 2)
+(foo 3 4)  <span class='arw'>&rarr;</span> (3 4)
+</pre>
+
+
+<p>Expressions in <em>exp-default</em> are evaluated in the function's 
+current environment.</p>
+
+
+<pre>
+(define-macro (foo (a 10) (b (div a 2))) 
+  (list a b))
+
+(foo)      <span class='arw'>&rarr;</span> (10 5)
+(foo 30)   <span class='arw'>&rarr;</span> (30 15)
+(foo 3 4)  <span class='arw'>&rarr;</span> (3 4)
+</pre>
+
+
+<p>Note that in <em>fexprs</em>, the danger exists of passing a parameter 
+with the same variable name as used in the <tt>define-macro</tt> definition. 
+In this case, the <em>fexpr's</em> internal variable would end up 
+receiving <tt>nil</tt> instead of the intended value:</p>
+
+
+<pre>
+;; not a good definition!
+
+(define-macro (my-setq x y) (set x (eval y)))  
+
+;; symbol name clash for x
+
+(my-setq x 123)  <span class='arw'>&rarr;</span> 123
+x                <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p>There are several methods that can be used 
+to avoid this problem, known as <em>variable capture</em>,
+by writing <em>hygienic</em> <tt>define-macro</tt>s:</p>
+
+<ul>
+<li>
+Put the definition into its own lexically closed namespace context. 
+If the function has the same name as the context, it can be 
+called by using the context name alone.  A function with this 
+characteristic is called a <a href="#default_function">
+<em>default function</em></a>. This is the preferred method in 
+newLISP to write <tt>define-macro</tt>s.
+</li>
+<br/>
+<li>Use <a href="#args">args</a> to access arguments passed by the 
+function.</li>
+</ul>
+
+<!-- example -->
+
+<pre>
+;; a define-macro as a lexically isolated function
+;; avoiding variable capture in passed parameters
+
+(context 'my-setq)
+
+(define-macro (my-setq:my-setq x y) (set x (eval y)))  
+
+(context MAIN)
+
+(my-setq x 123)  <span class='arw'>&rarr;</span> 123  ; no symbol clash
+x                <span class='arw'>&rarr;</span> 123
+</pre>
+
+
+<p>
+	The definition in the example is lexically isolated, 
+	and no variable capture can occur. 
+	Instead of the function being called using <tt>(my-setq:my-setq &hellip;)</tt>, 
+	it can be called with just <tt>(my-setq &hellip;)</tt> 
+	because it is a <a href="#default_function"><em>default function</em></a>.
+</p>
+
+<p>
+	The second possibility is to refer to passed parameters 
+	using <a href="#args">args</a>:
+</p>
+
+<!-- example -->
+
+<pre>
+;; avoid variable capture in macros using the args function
+
+(define-macro (my-setq) (set (args 0) (eval (args 1))))
+</pre>
+
+<p>See also the <a href="#macro">macro</a> expansion function not
+susceptible to variable capture.</p>
+
+<br/><br/>
+
+<a name="delete"></a>
+<h2><span class="function">delete</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (delete <em>symbol</em> [<em>bool</em>])<br/>
+
+syntax: (delete <em>sym-context</em> [<em>bool</em>])</h4>
+
+<p>In the first syntax deletes a symbol <em>symbol</em> and references to 
+the symbol in other expressions will be changed to <tt>nil</tt>.</p>
+
+<p>In the second syntax all symbols of the namespace referred to by 
+<em>sym-context</em> will be deleted and references to them in other
+espressions will be changed to <tt>nil</tt>. The context symbol 
+<em>sym-context</em> will be changed to a normal symbol 
+containing <tt>nil</tt>.</p>
+
+<p>When the expression in <em>bool</em> evaluates 
+to <tt>true</tt>, symbols are only deleted when they are not referenced.
+</p>
+
+<p>
+When the expression in <em>bool</em> evaluates 
+to <tt>nil</tt>, symbols will be deleted without any reference checking.
+Note that this mode should only be used, if no references to the symbol
+exist outside it's namespace. If external references exist, this mode
+can lead to system crashes, as the external reference is not set to
+<tt>nil</tt> when using this mode. This mode can be used to delete
+namespace hashes and to delete namespaces in object systems, where variables are
+strictly treated as private.</p>
+
+<p>
+Protected symbols of built-in functions and special symbols 
+like <tt>nil</tt> and <tt>true</tt> cannot be deleted.
+</p>
+
+<p>
+<tt>delete</tt> returns <tt>true</tt> if the symbol was deleted 
+successfully or <tt>nil</tt> if the symbol was not deleted.
+</p>
+
+<p>When deleting a context symbol, the first <tt>delete</tt> removes the context 
+namespace contents and demotes the context symbol to a normal mono-variable symbol. 
+A second <tt>delete</tt> will remove the symbol from the symbol table.</p>
+
+<!-- example -->
+
+<pre>
+(set 'lst '(a b aVar c d))
+
+(delete 'aVar)  ; aVar deleted, references marked nil
+
+lst  <span class='arw'>&rarr;</span> (a b nil c d)
+
+(set 'lst '(a b aVar c d))
+
+(delete 'aVar true)  
+<span class='arw'>&rarr;</span> nil ; protect aVar if referenced
+
+lst  <span class='arw'>&rarr;</span> (a b aVar c d)
+
+;; delete all symbols in a context
+(set 'foo:x 123)
+(set 'foo:y "hello")
+
+(delete 'foo)  <span class='arw'>&rarr;</span> foo:x, foo:y deleted
+</pre>
+
+
+<p>In the last example only the symbols inside context <tt>foo</tt>
+will be deleted but not the context symbol <tt>foo</tt> itself. It
+will be converted to a normal unprotected symbol and contain <tt>nil</tt>.
+</p>
+
+<p>
+Note that deleting a symbol that is part of an expression 
+which is currently executing can crash the system 
+or have other unforeseen effects.
+</p>
+
+<br/><br/>
+
+<a name="delete-file"></a>
+<h2><span class="function">delete-file</span></h2>
+<h4>syntax: (delete-file <em>str-file-name</em>)</h4>
+
+<p>Deletes a file given in <em>str-file-name</em>. 
+Returns <tt>true</tt> if the file was deleted 
+successfully.</p>
+
+<p>On failure the function returns <tt>nil</tt>. For error information, 
+use <a href="#sys-error">sys-error</a> when used on files. When used
+on URLs <a href="#net-error">net-error</a> gives more error
+information.</p>
+
+<p>The file name can be given as a URL.</p>
+
+<!-- example -->
+
+<pre>
+(delete-file "junk")
+
+(delete-file "http://asite.com/example.html")
+
+(delete-file "file://aFile.txt")
+</pre>
+
+<p>
+The first example deletes the file <tt>junk</tt> in the current directory.
+The second example shows how to use a URL to specify the file. 
+In this form, additional parameters can be given. 
+See <a href="#delete-url">delete-url</a> for details.
+</p>
+
+<br/><br/>
+
+<a name="delete-url"></a>
+<h2><span class="function">delete-url</span></h2>
+<h4>syntax: (delete-url <em>str-url</em>)</h4>
+
+<p>This function deletes the file on a remote HTTP server specified in <em>str-url</em>.
+The HTTP <tt>DELETE</tt> protocol must be enabled on the target web server, 
+or an error message string may be returned. The target file must also have  
+access permissions set accordingly. Additional parameters such as timeout and custom headers 
+are available exactly as in the <a href="#get-url">get-url</a> function.</p>
+
+<p>If <em>str-url</em> starts with <tt>file://</tt> a file on the local file system
+is deleted.</p>
+
+<p>This feature is also available when the <a href="#delete-file">delete-file</a>
+function is used and a URL is specified for the filename.</p>
+
+<!-- example -->
+
+<pre>
+(delete-url "http://www.aserver.com/somefile.txt")
+(delete-url "http://site.org:8080/page.html" 5000)
+
+; delete on the local file system
+(delete-url "file:///home/joe/somefile.txt")
+</pre>
+
+
+<p>The second example configures a timeout option of five seconds. 
+Other options such as special HTTP protocol headers 
+can be specified, as well. 
+See the <a href="#get-url">get-url</a> function for details.</p>
+
+<br/><br/>
+
+<a name="destroy"></a>
+<h2><span class="function">destroy</span></h2>
+<h4>syntax: (destroy <em>int-pid</em>)<br/>
+syntax: (destroy <em>int-pid</em> <em>int-signal</em>)</h4>
+
+<p>Destroys a process with process id in <em>int-pid</em> and returns <tt>true</tt>
+on success or <tt>nil</tt> on failure. The process id is normally obtained from a 
+previous call to <a href="#fork">fork</a> on Mac OS X and other Unix or 
+<a href="#process">process</a> on all platforms. On Unix, <tt>destroy</tt> works like 
+the system utility <em>kill</em> using the SIGKILL signal.</p>
+
+<p>CAUTION! If <em>int-pid</em> is <tt>0</tt> the signal is sent to all processes whose 
+group ID is equal to the process group ID of the sender. If <em>int-pid</em> is <tt>-1</tt> 
+all processes with the current user id will be killed, if newLISP is started with 
+super user privileges, all processes except system processes are destroyed.
+</p>
+
+<p>When specifying <em>int-signal</em>, <tt>destroy</tt> works like a Unix <tt>kill</tt> 
+command sending the specified Unix signal to the process in <em>int-pid</em>. 
+This second syntax is not available on MS Windows.</p>
+
+<!-- example -->
+
+<pre>
+(set 'pid (process "/usr/bin/bc" bcin bcout)) 
+(destroy pid)
+
+(set 'pid (fork (dotimes (i 1000) (println i) (sleep 10))))
+(sleep 100) (destroy pid)
+</pre>
+
+<br/><br/>
+
+<a name="det"></a>
+<h2><span class="function">det</span></h2>
+<h4>syntax: (det <em>matrix</em> [<em>float-pivot</em>])</h4>
+
+<p>Returns the determinant of a square matrix.  A matrix can either 
+be a nested list or an <a href="#array">array</a>.</p>
+
+<p>Optionally <tt>0.0</tt> or a very small value can be specified
+in <em>float-pivot</em>. This value substitutes pivot elements in
+the LU-decomposition algorithm, which result in zero when
+the algorithm deals with a singular matrix.</p>
+
+<!-- example -->
+
+<pre>
+(set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+(det A)  <span class='arw'>&rarr;</span> -1
+
+; treatment of singular matrices
+(det '((2 -1) (4 -2)))        <span class='arw'>&rarr;</span> nil
+(det '((2 -1) (4 -2)) 0)      <span class='arw'>&rarr;</span> -0
+(det '((2 -1) (4 -2)) 1e-20)  <span class='arw'>&rarr;</span> -4e-20
+</pre>
+
+<p>If the matrix is singular and <em>float-pivot</em> is not
+specified, <tt>nil</tt> is returned.</p>
+
+<p>See also the other matrix operations 
+<a href="#invert">invert</a>, <a href="#mat">mat</a>, 
+<a href="#multiply">multiply</a> and <a href="#transpose">transpose</a>.
+</p>
+
+<br/>
+
+<a name="device"></a>
+<h2><span class="function">device</span></h2>
+<h4>syntax: (device [<em>int-io-handle</em>])</h4>
+
+<p><em>int-io-handle</em> is an I/O device number, which is set to 0 (zero)
+for the default STD I/O pair of handles, 0 for <i>stdin</i> and 1
+for <i>stdout</i>. <em>int-io-handle</em> may also be a file handle 
+previously obtained using <a href="#open">open</a>. In this case
+both, input and output are channeled through this handle.
+When no argument is supplied, the current I/O device number is returned. 
+</p>
+
+<p>The I/O channel specified by <tt>device</tt> is used internally 
+by the functions <a href="#print">print</a>, <a href="#println">println</a>,
+<a href="#write">write</a>, <a href="#write-line">write-line</a> and
+<a href="#read-char">read-char</a>, <a href="#read-line">read-line</a>. 
+When the current I/O device is 0 or 1, <a href="#print">print</a> 
+sends output to the console window and <a href="#read-line">read-line</a> 
+accepts input from the keyboard. If the current I/O device has been set 
+by opening a file, then <a href="#print">print</a> and <a href="#read-line">read-line</a> 
+work on that file.</p>
+
+<p>Note, that on Unix like operating systems, stdin channel 0 can also be used
+for output and stdout channel 1 can also be used for reading input. This is
+not the case on Windows, where 0 is strictly for input and stdout 1 strictly
+for output.</p>
+ 
+<!-- example -->
+
+<pre>
+(device (open "myfile" "write"))  <span class='arw'>&rarr;</span> 5
+(print "This goes in myfile")     <span class='arw'>&rarr;</span> "This goes in myfile"
+(close (device))                  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>Note that using <a href="#close">close</a> on <tt>device</tt> 
+automatically resets <tt>device</tt> to 0 (zero).</p>
+
+<br/><br/>
+
+<a name="difference"></a>
+<h2><span class="function">difference</span></h2>
+<h4>syntax: (difference <em>list-A</em> <em>list-B</em>)<br/>
+syntax: (difference <em>list-A</em> <em>list-B</em> <em>bool</em>)</h4>
+
+<p>
+	In the first syntax, <tt>difference</tt> returns 
+	the <em>set</em> difference between <em>list-A</em> and <em>list-B</em>. 
+	The resulting list only has elements occurring in <em>list-A</em>, 
+	but not in <em>list-B</em>. 
+	All elements in the resulting list are unique, 
+	but <em>list-A</em> and <em>list-B</em> need not be unique. 
+	Elements in the lists can be any type of Lisp expression.
+</p>
+
+<!-- example -->
+
+<pre>
+(difference '(2 5 6 0 3 5 0 2) '(1 2 3 3 2 1))  <span class='arw'>&rarr;</span> (5 6 0)
+</pre>
+
+
+<p>
+	In the second syntax, <tt>difference</tt> works in <em>list</em> mode. 
+	<em>bool</em> specifies <tt>true</tt> 
+	or an expression not evaluating to <tt>nil</tt>. 
+	In the resulting list, all elements of <em>list-B</em> 
+	are eliminated in <em>list-A</em>, 
+	but duplicates of other elements in <em>list-A</em> are left.
+</p>
+<!-- example -->
+
+<pre>
+(difference '(2 5 6 0 3 5 0 2) '(1 2 3 3 2 1) true)  <span class='arw'>&rarr;</span> (5 6 0 5 0)
+</pre>
+
+
+
+<p>
+	See also the set functions <a href="#intersect">intersect</a>,
+	<a href="#unique">unique</a> and <a href="#union">union</a>.
+</p>
+
+<br/><br/>
+
+<a name="directory"></a>
+<h2><span class="function">directory</span></h2>
+<h4>syntax: (directory [<em>str-path</em>])<br/>
+syntax: (directory <em>str-path</em> <em>str-pattern</em> [<em>regex-option</em>])</h4>
+
+<p>
+	A list of directory entry names is returned 
+	for the directory path given in <em>str-path</em>. 
+	On failure, <tt>nil</tt> is returned. 
+	When <em>str-path</em> is omitted, 
+	the list of entries in the current directory is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(directory "/bin")
+
+(directory "c:/")
+</pre>
+
+
+<p>
+	The first example returns the directory of <tt>/bin</tt>, 
+	the second line returns a list of directory entries 
+	in the root directory of drive C:. 
+	Note that on MS Windows systems, 
+	a forward slash (<tt>/</tt>) can be included in path names. 
+	When used, a backslash (<tt>\</tt>) must be 
+	preceded by a second backslash.
+</p>
+
+<p>
+	In the second syntax, <tt>directory</tt> can take 
+	a regular expression pattern in <em>str-pattern</em>. 
+	Only filenames matching the pattern will be returned 
+	in the list of directory entries. 
+	In <em>regex-option</em>, special regular expression options 
+	can be specified; see <a href="#regex">regex</a> for details.
+</p>
+
+<!-- example -->
+
+<pre>
+(directory "." "\\.c")  <span class='arw'>&rarr;</span> ("foo.c" "bar.c")
+;; or using braces as string pattern delimiters
+(directory "." {\.c})  <span class='arw'>&rarr;</span> ("foo.c" "bar.c")
+
+; show only hidden files (starting with dot)
+(directory "." "^[.]")   <span class='arw'>&rarr;</span> ("." ".." ".profile" ".rnd" ".ssh")</pre>
+
+
+<p>
+	The regular expression forces <tt>directory</tt> 
+	to return only file names containing the string <tt>".c"</tt>.
+</p>
+
+<p>
+	Other functions that use regular expressions 
+	are <a href="#find">find</a>, <!-- 8.9.4 --><a href="#find-all">find-all</a>,
+	<a href="#parse">parse</a>, 
+	<a href="#regex">regex</a>, <a href="#replace">replace</a>, 
+	and <a href="#search">search</a>.
+</p>
+
+<br/><br/>
+
+<a name="directoryp"></a>
+<h2><span class="function">directory?</span></h2>
+<h4>syntax: (directory? <em>str-path</em>)</h4>
+
+<p>
+	Checks if <em>str-path</em> is a directory. 
+	Returns <tt>true</tt> or <tt>nil</tt> depending on the outcome.
+</p>
+
+
+<pre>
+(directory? "/etc")             <span class='arw'>&rarr;</span> true
+(directory? "/usr/bin/emacs/")  <span class='arw'>&rarr;</span> nil
+</pre>
+
+<br/><br/>
+
+<a name="display-html"></a>
+<h2><span class="function">display-html
+<a href="#JS"><font size="-1">JS</font></a></span></h2>
+<h4>syntax: (display-html <em>str-html</em>)<br/>
+syntax: (display-html <em>str-html</em> <em>bool-flag</em>)</h4>
+
+<p>Using the first syntax, the function replaces the current page in 
+the browser with the HTML page found in <em>str-html</em>.</p> 
+
+<p>If <em>bool-flag</em> evaluates to <tt>true</tt>, the page gets
+opened in a new browser tab and the current page is not affected.</p>
+
+<p>This function is only available on newLISP compiled to JavaScript.</p>
+
+<pre>
+(set 'page [text]
+&lt;html&gt;
+&lt;head&gt;
+&lt;title&gt;Hello App&lt;/title&gt;
+&lt;/head&gt;
+&lt;body&gt;
+&lt;h2&gt;Hello World&lt;/h2&gt;
+&lt;/body&gt;
+&lt;/html&gt;
+[/text])
+
+; open the page in a new browser tab
+(display-html page true) <span class='arw'>&rarr;</span> "92"
+</pre>
+
+<p>The function returns the length of the HTML document displayed as a string.
+</p>
+
+<p>See also the function <a href="#eval-string-js">eval-string-js</a> for
+evaluation of JavaScript in the current page.</p>
+
+<br/><br/>
+
+<a name="div"></a>
+<h2><span class="function">div</span></h2>
+<h4>syntax: (div <em>num-1</em> <em>num-2</em> [<em>num-3</em> ... ])<br/>
+syntax: (div <em>num-1</em>)</h4>
+
+<p>
+	Successively divides <em>num-1</em>
+	by the number in <em>num-2&mdash;</em>. 
+	<tt>div</tt> can perform mixed-type arithmetic, 
+	but it always returns floating point numbers. 
+	Any floating point calculation 
+	with <tt>NaN</tt> also returns <tt>NaN</tt>.
+</p>
+	
+
+<!-- example -->
+
+<pre>
+(div 10 3)                 <span class='arw'>&rarr;</span> 3.333333333
+(div 120 (sub 9.0 6) 100)  <span class='arw'>&rarr;</span> 0.4
+
+(div 10)                   <span class='arw'>&rarr;</span> 0.1
+</pre>
+
+
+<p>
+	When <em>num-1</em> is the only argument,
+	<tt>div</tt> calculates the inverse of <em>num-1</em>.
+</p>
+
+<br/><br/>
+
+<a name="do-until"></a>
+
+<h2><span class="function">do-until</span></h2>
+<h4>syntax: (do-until <em>exp-condition</em> [<em>body</em>])</h4>
+
+<p>
+	The expressions in <em>body</em> are evaluated 
+	before <em>exp-condition</em> is evaluated. 
+	If the evaluation of <em>exp-condition</em> is not <tt>nil</tt>, 
+	then the <tt>do-until</tt> expression is finished; 
+	otherwise, the expressions in <em>body</em> get evaluated again. 
+	Note that <tt>do-until</tt> evaluates the conditional expression 
+	<em>after</em> evaluating the body expressions, 
+	whereas <a href="#until">until</a> checks the condition 
+	<em>before</em> evaluating the body. 
+	The return value of the <tt>do-until</tt> expression 
+	is the last evaluation of the <em>body</em> expression.
+	If <em>body</em> is empty, the last result of <em>exp-condition</em>
+    is returned.
+</p>
+
+<p><tt>do-until</tt> also updates the system iterator symbol <tt>$idx</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 1)
+(do-until (&gt; x 0) (inc x))
+x  <span class='arw'>&rarr;</span> 2
+
+(set 'x 1)
+(until (&gt; x 0) (inc x))
+x  <span class='arw'>&rarr;</span> 1
+</pre>
+
+
+<p>
+	While <tt>do-until</tt> goes through the loop at least once, 
+	<a href="#until">until</a> never enters the loop.
+</p>
+
+<p>
+	See also the functions <a href="#while">while</a> 
+	and <a href="#do-while">do-while</a>.
+</p>
+
+<br/><br/>
+
+<a name="do-while"></a>
+<h2><span class="function">do-while</span></h2>
+<h4>syntax: (do-while <em>exp-condition body</em>)</h4>
+
+<p>
+	The expressions in <em>body</em> are evaluated 
+	before <em>exp-condition</em> is evaluated. 
+	If the evaluation of <em>exp-condition</em> is <tt>nil</tt>, 
+	then the <tt>do-while</tt> expression is finished; 
+	otherwise the expressions in <em>body</em> get evaluated again. 
+	Note that <tt>do-while</tt> evaluates the conditional expression 
+	<em>after</em> evaluating the body expressions, 
+	whereas <a href="#while">while</a> checks the condition 
+	<em>before</em> evaluating the body. 
+	The return value of the <tt>do-while</tt> expression 
+	is the last evaluation of the <em>body</em> expression.
+</p>
+
+<p><tt>do-while</tt> also updates the system iterator symbol <tt>$idx</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 10)
+(do-while (&lt; x 10) (inc x))
+x  <span class='arw'>&rarr;</span> 11
+
+(set 'x 10)
+(while (&lt; x 10) (inc x)) 
+x  <span class='arw'>&rarr;</span> 10
+</pre>
+
+
+<p>
+	While <tt>do-while</tt> goes through the loop at least once, 
+	<a href="#while">while</a> never enters the loop.
+</p>
+
+<p>
+	See also the functions <a href="#until">until</a> 
+	and <a  href="#do-until">do-until</a>.
+</p>
+
+<br/><br/>
+
+<a name="doargs"></a>
+<h2><span class="function">doargs</span></h2>
+<h4>syntax: (doargs (<em>sym</em> [<em>exp-break</em>])<em> body</em>)</h4>
+
+<p>Iterates through all members of the argument list 
+inside a user-defined function or macro. This function or macro can be defined using <a href="#define">define</a>, 
+<a href="#define-macro">define-macro</a>, <a href="#lambda">lambda</a>, or
+<a href="#lambda-macro">lambda-macro</a>.
+The variable in <em>sym</em> is set sequentially to all members in the argument list 
+until the list is exhausted or an optional break expression 
+(defined in <em>exp-break</em>) evaluates to <tt>true</tt> or a logical true value. 
+The <tt>doargs</tt> expression always returns the result of the last evaluation.</p>
+
+<p><tt>doargs</tt> also updates the system iterator symbol <tt>$idx</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(define (foo)
+    (doargs (i) (println i)))
+
+<b>&gt;</b> (foo 1 2 3 4)
+<b>1
+2
+3
+4</b>
+</pre>
+
+
+<p>The optional break expression causes <tt>doargs</tt> 
+to interrupt processing of the arguments:</p>
+
+
+<pre>
+(define-macro (foo)
+    (doargs (i (= i 'x)) 
+        (println i)))
+
+<b>&gt;</b> (foo a b x c d e)
+<b>a
+b
+true</b>
+</pre>
+
+
+<p>Use the <a href="#args">args</a> function to access the entire argument list at once.</p>
+
+<br/><br/>
+
+<a name="dolist"></a>
+<h2><span class="function">dolist</span></h2>
+<h4>syntax: (dolist (<em>sym</em>  <em>list</em>|<em>array</em> [<em>exp-break</em>])<em> body</em>)</h4>
+
+<p>
+	The expressions in <em>body</em> are evaluated 
+	for each element in <em>list</em> or <em>array</em>. 
+	The variable in <em>sym</em> is set to each of the elements 
+	before evaluation of the body expressions. 
+	The variable used as loop index is local 
+	and behaves according to the rules of dynamic scoping.
+</p>
+
+<p>
+	Optionally, a condition for early loop exit 
+	may be defined in <em>exp-break</em>. 
+	If the break expression evaluates to any non-<tt>nil</tt> value, 
+	the <tt>dolist</tt> loop returns with the value of <em>exp-break</em>. 
+	The break condition is tested before evaluating <em>body.</em></p>
+
+<!-- example -->
+
+<pre>
+(set 'x 123)
+(dolist (x '(a b c d e f g))  ; prints: abcdefg
+    (print x))  <span class='arw'>&rarr;</span> g          ; return value
+
+(dolist (x '(a b c d e f g) (= x 'e))  ; prints: abcd
+    (print x))
+
+;; x is local in dolist
+;; x has still its old value outside the loop
+
+x  <span class='arw'>&rarr;</span> 123  ; x has still its old value
+</pre>
+
+
+<p>
+	This example prints <tt>abcdefg</tt> in the console window. 
+	After the execution of <tt>dolist</tt>,
+	the value for <tt>x</tt> remains unchanged 
+	because the <tt>x</tt> in <tt>dolist</tt> has local scope. 
+	The return value of <tt>dolist</tt> is the result 
+	of the last evaluated expression.
+</p>
+
+<p>
+	The internal system variable <tt>$idx</tt> 
+	keeps track of the current offset 
+	into the list passed to <tt>dolist</tt>,
+	and it can be accessed during its execution:
+</p>
+
+
+<pre>
+(dolist (x '(a b d e f g))
+  (println $idx ":" x))  <span class='arw'>&rarr;</span> g
+
+<b>0:a
+1:b
+2:d
+3:e
+4:f
+5:g</b>
+</pre>
+
+
+<p>
+	The console output is shown in boldface. 
+	<tt>$idx</tt> is protected and cannot be changed by the user.
+</p>
+
+<br/><br/>
+
+<a name="dostring"></a>
+<h2><span class="function">dostring</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (dostring (<em>sym</em>  <em>string</em> [<em>exp-break</em>]) <em>body</em>)</h4>
+
+<p>
+	The expressions in <em>body</em> are evaluated 
+	for each character in <em>string</em>. 
+	The variable in <em>sym</em> is set to each ASCII or UTF-8 integer value of the characters 
+	before evaluation of the body expressions. 
+	The variable used as loop index is local 
+	and behaves according to the rules of dynamic scoping.
+</p>
+
+<p>
+	Optionally, a condition for early loop exit 
+	may be defined in <em>exp-break</em>. 
+	If the break expression evaluates to any non-<tt>nil</tt> value, 
+	the <tt>dolist</tt> loop returns with the value of <em>exp-break</em>. 
+	The break condition is tested before evaluating <em>body.</em>
+</p>
+
+<!-- example -->
+
+<pre>
+; ASCII example
+(set 'str "abcdefg")
+(dostring (c str) (println c " - " (char c)))
+
+<b>97 - a
+98 - b
+99 - c
+100 - d
+101 - e
+102 - f
+103 - g</b>
+
+; UTF8 example
+(set 'utf8str "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚")
+(dostring (c utf8str) (println c " - " (char c)))
+
+<b>25105 - ๆˆ‘
+33021 - ่ƒฝ
+21534 - ๅž
+ ...
+20307 - ไฝ“
+12290 - ใ€‚ </b>
+</pre>
+
+
+<p>
+	This example prints the value of each character
+  in the console window. In UTF-8 enabled versions of newLISP,
+  individual characters may be longer than one byte and the
+  number in the loop variable may exceed 255.
+	The return value of <tt>dostring</tt> is the result 
+	of the last evaluated expression.
+</p>
+
+<p>
+	The internal system variable <tt>$idx</tt> 
+	keeps track of the current offset 
+	into the string passed to <tt>dostring</tt>,
+	and it can be accessed during its execution.
+</p>
+
+<br/><br/>
+
+<a name="dotimes"></a>
+<h2><span class="function">dotimes</span></h2>
+<h4>syntax: (dotimes (<em>sym-var</em> <em>int-count</em> [<em>exp-break</em>]) <em>body</em>)</h4>
+
+<p>
+	The expressions in <em>body</em> are evaluated <em>int</em> times. 
+	The variable in <em>sym</em> is set from 0 (zero) to (<em>int</em> - 1) 
+	each time before evaluating the body expression(s). 
+	The variable used as the loop index is local to the <tt>dotimes</tt> 
+	expression and behaves according the rules of dynamic scoping. 
+	The loop index is of integer type. 
+	<tt>dotimes</tt> returns the result of 
+	the last expression evaluated in <em>body</em>.
+	After evaluation of the <tt>dotimes</tt>
+    statement <em>sym</em> assumes its previous
+    value.
+</p>
+
+<p>
+	Optionally, a condition for early loop exit 
+	may be defined in <em>exp-break</em>. 
+	If the break expression evaluates to any non-<tt>nil</tt> value, 
+	the <tt>dotimes</tt> loop returns with the value of <em>exp-break</em>. 
+	The break condition is tested before evaluating <em>body</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(dotimes (x 10)
+  (print x))  <span class='arw'>&rarr;</span> 9  ; return value
+</pre>
+
+
+<p>
+	This prints <tt>0123456789</tt> to the console window.
+</p>
+
+<br/><br/>
+
+<a name="dotree"></a>
+<h2><span class="function">dotree</span></h2>
+<h4>syntax: (dotree (<em>sym</em> <em>sym-context</em> [<em>bool</em>]) <em>body</em>)</h4>
+
+<p>The expressions in <em>body</em> are evaluated for all symbols in <em>sym-context</em>. 
+The symbols are accessed in a sorted order.  Before each evaluation of the body expression(s),
+the variable in <em>sym</em> is set to the next symbol from <em>sym-context</em>. 
+The variable used as the loop index is local to the <tt>dotree</tt> expression 
+and behaves according the rules of dynamic scoping.</p>
+
+<p>When the optional <em>bool</em> expression evaluates to not <tt>nil</tt>, only symbols 
+starting with an underscore character <tt>_</tt> are accessed. Symbol names starting with 
+an <tt>_</tt> underscore are used for <a href="#hash">hash keys</a> and symbols created by 
+<a href="#bayes-train">bayes-train</a>.</p>
+
+<p><tt>dotree</tt> also updates the system iterator symbol <tt>$idx</tt>.</p>
+
+<!-- example -->
+
+<pre>
+;; faster and less memory overhead
+(dotree (s SomeCTX) (print s " "))
+
+;; slower and higher memory usage
+(dolist (s (symbols SomeCTX)) (print s " "))
+</pre>
+
+
+<p>
+This example prints the names of all symbols inside SomeCTX to the console window.
+</p>
+
+<br/><br/>
+
+<a name="dump"></a>
+<h2><span class="function">dump</span></h2>
+<h4>syntax: (dump [<em>exp</em>])</h4>
+
+<p>
+	Shows the binary contents of a newLISP cell. 
+	Without an argument, this function outputs 
+	a listing of all Lisp cells to the console. 
+	When <em>exp</em> is given, 
+	it is evaluated and the contents 
+	of a Lisp cell are returned in a list.
+</p>
+
+<!-- example -->
+
+<pre>
+(dump 'a)   <span class='arw'>&rarr;</span> (9586996 5 9578692 9578692 9759280)
+
+(dump 999)  <span class='arw'>&rarr;</span> (9586996 130 9578692 9578692 999)
+</pre>
+
+
+<p>
+	The list contains the following memory addresses and information:
+</p>
+
+<table summary="dump data types">
+<tr align="left"><th>offset</th><th>description</th></tr>
+<tr><td>0</td><td>memory address of the newLISP cell</td></tr>
+<tr><td>1</td><td>cell-&gt;type: major/minor type, see newlisp.h for details</td></tr>
+<tr><td>2</td><td>cell-&gt;next: linked list ptr</td></tr>
+<tr><td>3</td><td>cell-&gt;aux:<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;string length+1 or <br/>
+&nbsp;&nbsp;&nbsp;&nbsp;low (little endian) or high (big endian) word of 64-bit integer or<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;low word of IEEE 754 double float</td></tr>
+<tr><td>4</td><td>cell-&gt;contents:<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;string/symbol address or<br/> 
+&nbsp;&nbsp;&nbsp;&nbsp;high (little endian) or low (big endian) word of 64-bit integer or<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;high word of IEEE 754 double float</td></tr>
+</table><br/>
+
+<p>
+	This function is valuable for changing type bits in cells 
+	or hacking other parts of newLISP internals. 
+	See the function <a href="#cpymem">cpymem</a> 
+	for a comprehensive example.
+</p>
+
+<br/><br/>
+
+<a name="dup"></a>
+<h2><span class="function">dup</span></h2>
+
+<h4>syntax: (dup <em>exp</em> <em>int-n</em> [<em>bool</em>])<br/>
+syntax: (dup <em>exp</em>)</h4>
+
+<p>
+	If the expression in <em>exp</em> evaluates to a string, 
+	it will be replicated <em>int-n</em> times within a string and returned. 
+	When specifying an expression evaluating 
+	to anything other than <tt>nil</tt> in <em>bool</em>, 
+	the string will not be concatenated 
+	but replicated in a list like any other data type.
+</p>
+
+<p>
+	If <em>exp</em> contains any data type other than string, 
+	the returned list will contain <em>int-n</em> evaluations of <em>exp</em>.
+</p>
+
+<p>Without the repetition parameter, <tt>dup</tt> assumes 2.</p>
+
+<!-- example -->
+
+<pre>
+(dup "A" 6)       <span class='arw'>&rarr;</span> "AAAAAA"
+(dup "A" 6 true)  <span class='arw'>&rarr;</span> ("A" "A" "A" "A" "A" "A")
+(dup "A" 0)       <span class='arw'>&rarr;</span> ""
+(dup "AB" 5)      <span class='arw'>&rarr;</span> "ABABABABAB"
+(dup 9 7)         <span class='arw'>&rarr;</span> (9 9 9 9 9 9 9)
+(dup 9 0)         <span class='arw'>&rarr;</span> ()
+(dup 'x 8)        <span class='arw'>&rarr;</span> (x x x x x x x x)
+(dup '(1 2) 3)    <span class='arw'>&rarr;</span> ((1 2) (1 2) (1 2))
+(dup "\000" 4)    <span class='arw'>&rarr;</span> "\000\000\000\000"
+
+(dup "*")         <span class='arw'>&rarr;</span> "**"
+</pre>
+
+
+<p>
+	The last example shows handling of binary information, 
+	creating a string filled with four binary zeroes.
+</p>
+
+<p>
+	See also the functions <a href="#sequence">sequence</a> 
+	and <a href="#series">series</a>.
+</p>
+
+<br/><br/>
+
+<a name="emptyp"></a>
+<h2><span class="function">empty?</span></h2>
+<h4>syntax: (empty? <em>exp</em>)<br/>
+syntax: (empty? <em>str</em>)</h4>
+
+
+<p>
+	<em>exp</em> is tested for an empty list 
+	(or <em>str</em> for an empty string). 
+	Depending on whether the argument contains elements, 
+	<tt>true</tt> or <tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'var '())
+(empty? var)         <span class='arw'>&rarr;</span> true
+(empty? '(1 2 3 4))  <span class='arw'>&rarr;</span> nil
+(empty? "hello")     <span class='arw'>&rarr;</span> nil
+(empty? "")          <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+	The first example checks a list, 
+	while the second two examples check a string.
+</p>
+
+<br/><br/>
+
+<a name="encrypt"></a>
+<h2><span class="function">encrypt</span></h2>
+<h4>syntax: (encrypt <em>str-source</em> <em>str-pad</em>)</h4>
+
+<p>
+Performs a <a href="http://en.wikipedia.org/wiki/One-time_pad">one-time pad</a> (OTP)
+encryption of <em>str-source</em> using the encryption pad in <em>str-pad</em>. 
+The longer <em>str-pad</em> is and the more random the bytes are, 
+the safer the encryption.  If the pad is as long as the source text, 
+is fully random, and is used only once, then one-time&ndash;pad encryption 
+is virtually impossible to break, since the encryption seems to contain only 
+random data.  To retrieve the original, the same function and pad 
+are applied again to the encrypted text:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'secret 
+  (encrypt "A secret message" "my secret key")) 
+<span class='arw'>&rarr;</span> ",YS\022\006\017\023\017TM\014\022\n\012\030E"
+
+(encrypt secret "my secret key")  <span class='arw'>&rarr;</span> "A secret message"
+</pre>
+
+
+<p>
+	The second example encrypts a whole file:
+</p>
+
+
+
+<pre>
+(write-file "myfile.enc" 
+  (encrypt (read-file "myfile") "29kH67*"))
+</pre>
+
+
+<br/><br/>
+
+<a name="ends-with"></a>
+<h2><span class="function">ends-with</span></h2>
+<h4>syntax: (ends-with <em>str-data</em> <em>str-key</em> [<em>num-option</em>])<br/>
+syntax: (ends-with <em>list</em> <em>exp</em>)</h4>
+
+<p>In the first syntax, <tt>ends-with</tt> tests the string in <em>str-data</em> to see if it
+ends with the string specified in <em>str-key</em>.  It returns <tt>true</tt> or <tt>nil</tt> 
+depending on the outcome. </p>
+	
+<p>If a regular expression <em>option</em> number is 
+specified, <em>str-key</em> contains a regular expression pattern. See
+<a href="#regex">regex</a> for valid numbers for <em>option</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(ends-with "newLISP" "LISP")         <span class='arw'>&rarr;</span> true
+(ends-with "newLISP" "lisp")         <span class='arw'>&rarr;</span> nil
+;; use regular expressions
+(ends-with "newLISP" "lisp|york" 1)  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+	In the second syntax, 
+	<tt>ends-with</tt> checks if a list 
+	ends with the list element in <em>exp</em>. 
+	<tt>true</tt> or <tt>nil</tt> is returned depending on outcome.
+</p>
+
+<!-- example -->
+
+<pre>
+(ends-with '(1 2 3 4 5) 5)             <span class='arw'>&rarr;</span> true
+(ends-with '(a b c d e) 'b)            <span class='arw'>&rarr;</span> nil
+(ends-with '(a b c (+ 3 4)) '(+ 3 4))  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+	The last example shows that <em>exp</em> could be a list by itself.
+</p>
+
+<p>
+	See also the <a href="#starts-with">starts-with</a> function.
+</p>
+
+<br/><br/>
+
+<a name="env"></a>
+
+<h2><span class="function">env</span></h2>
+<h4>syntax: (env)<br/>
+syntax: (env <em>var-str</em>)<br/>
+syntax: (env <em>var-str</em> <em>value-str</em>)</h4>
+
+<p>In the first syntax (without arguments), the operating system's environment is 
+retrieved as an association list in which each entry is a key-value pair of
+environment variable and value.</p>
+
+<!-- example -->
+
+<pre>
+(env)  
+<span class='arw'>&rarr;</span> (("PATH" "/bin:/usr/bin:/sbin") ("TERM" "xterm-color") ... ))
+</pre>
+
+
+<p>In the second syntax, the name of an environment variable 
+is given in <em>var-str</em>. <tt>env</tt> returns the value 
+of the variable or <tt>nil</tt> if the variable does not exist 
+in the environment.</p>
+
+<!-- example -->
+
+<pre>
+(env "PATH")  <span class='arw'>&rarr;</span> "/bin:/usr/bin:/usr/local/bin"
+</pre>
+
+
+<p>The third syntax (variable name in <em>var-str</em> 
+and value pair in <em>value-str</em>) sets or creates 
+an environment variable. If <em>value-str</em> is the 
+empty string <tt>""</tt>, then the variable is completely
+removed from the environment except when running on Solaris,
+where the variable stays with an empty string.</p>
+
+<!-- example -->
+
+<pre>
+(env "NEWLISPBIN" "/usr/bin/")  <span class='arw'>&rarr;</span> true
+(env "NEWLISPBIN")              <span class='arw'>&rarr;</span> "/usr/bin/"
+(env "NEWLISPBIN" "")           <span class='arw'>&rarr;</span> true
+(env "NEWLISPBIN")              <span class='arw'>&rarr;</span> nil
+</pre>
+
+<br/><br/>
+
+<a name="erf"></a>
+<h2><span class="function">erf</span></h2>
+<h4>syntax: (erf <em>num</em>)</h4>
+
+<p>
+	<tt>erf</tt> calculates the error function 
+	of a number in <em>num</em>. 
+	The error function is defined as:
+</p>
+
+<p><b><em>erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt</em></b></p>
+
+<!-- example -->
+
+<pre>
+(map erf (sequence 0.0 6.0 0.5))
+<span class='arw'>&rarr;</span> 
+(0 0.5204998778 0.8427007929 0.9661051465 0.995322265 0.999593048 
+ 0.9999779095 0.9999992569 0.9999999846 0.9999999998 1 1 1) 
+</pre>
+
+<br/><br/>
+
+<a name="error-event"></a>
+<h2><span class="function">error-event</span></h2>
+<h4>syntax: (error-event <em>sym-event-handler | func-event-handler</em>)<br/>
+syntax: (error-event nil)</h4>
+
+<p><em>sym-event-handler</em> contains a user-defined function for handling errors. 
+Whenever an error occurs, the system performs a <a href="#reset">reset</a> 
+and executes the user-defined error handler.  The error handler can use the 
+built-in function <a href="#last-error">last-error</a> to retrieve the number 
+and text of the error. The event handler is specified as either a quoted
+symbol or a lambda function.</p>
+
+<p>To cancel <tt>error-event</tt>, use the second syntax.</p>
+
+<!-- example -->
+
+<pre>
+(define (my-handler)    
+  (print "error # " (first (last-error)) " has occurred\n") )
+
+(error-event 'my-handler)  <span class='arw'>&rarr;</span> my-handler
+
+;; specify a function directly
+
+(error-event my-handler)  <span class='arw'>&rarr;</span> $error-event
+
+(error-event 
+  (fn () (print "error # " (first (last-error)) " has occurred\n")))
+
+(error-event exit)  <span class='arw'>&rarr;</span> $error-event
+</pre>
+
+
+<p>For a different way of handling errors, see the <a href="#catch">catch</a> function. 
+Use <a href="#throw-error">throw-error</a> to throw user-defined errors.</p>
+
+<br/><br/>
+
+<a name="eval"></a>
+<h2><span class="function">eval</span></h2>
+<h4>syntax: (eval <em>exp</em>)</h4>
+
+<p><em>eval</em> evaluates the result of evaluating <em>exp</em> in the current 
+variable environment.</p>
+
+<!-- example -->
+
+<pre>
+(set 'expr '(+ 3 4))  <span class='arw'>&rarr;</span> (+ 3 4)
+(eval expr)           <span class='arw'>&rarr;</span> 7
+(eval (list + 3 4))   <span class='arw'>&rarr;</span> 7
+(eval ''x)            <span class='arw'>&rarr;</span> x
+(set 'y 123)          
+(set 'x 'y)           
+x            <span class='arw'>&rarr;</span> y
+(eval x)     <span class='arw'>&rarr;</span> 123
+</pre>
+
+
+<p>As usual, evaluation of variables happens in the current variable environment:</p>
+
+
+<pre>
+; eval in global (top level) environment
+(set 'x 3 'y 4)
+(eval '(+ x y))          <span class='arw'>&rarr;</span> 7
+
+; eval in local environment
+(let ( (x 33) (y 44) ) 
+    (eval '(+ x y)))     <span class='arw'>&rarr;</span> 77
+
+; old environment after leaving local let environment
+(eval '(+ x y))          <span class='arw'>&rarr;</span> 7
+</pre>
+
+
+<p>
+	newLISP passes all arguments by value. 
+	Using a quoted symbol, 
+	expressions can be passed 
+	by reference through the symbol. 
+	<tt>eval</tt> can be used 
+	to access the original contents of the symbol:
+</p>
+
+
+<pre>
+(define (change-list aList) (push 999 (eval aList)))
+
+(set 'data '(1 2 3 4 5))
+
+(change-list 'data)  <span class='arw'>&rarr;</span> (999 1 2 3 4 5)
+</pre>
+
+
+<p>
+In the example, the parameter <tt>'data </tt> is quoted, 
+so <tt>push</tt> can work on the original list.
+</p>
+
+<p>
+There is a safer method to pass arguments by reference in newLISP 
+by enclosing the data inside context objects. 
+See the chapter <a href="#pass_big">Passing data by reference</a>.
+Passing references into user defined
+function using namespace ids avoids <em>variable capture</em> of
+the passed symbol, in case the symbol passed is the same used as a
+parameter in the function.</p>
+
+<br/><br/>
+
+<a name="eval-string"></a>
+<h2><span class="function">eval-string</span></h2>
+<h4>syntax: (eval-string <em>str-source</em> [<em>sym-context</em> [<em>exp-error</em> [<em>int-offset</em>]]])</h4>
+
+<p>
+The string in <em>str-source</em> is compiled into newLISP's internal format
+and then evaluated. The evaluation result is returned. If the string contains 
+more than one expression, the result of the last evaluation is returned.
+</p>
+
+<p>An optional second argument can be used to specify the context to which 
+the string should be parsed and translated.</p>
+
+<p>If an error occurs while parsing and evaluating <em>str-source</em> then
+<em>exp-error</em> will be evaluated and the result returned.</p>
+
+<p><em>int-offset</em> specifies an optional offset into <em>str-source</em>, 
+where to start evaluation.</p>
+
+<!-- example -->
+
+<pre>
+(eval-string "(+ 3 4)")  <span class='arw'>&rarr;</span> 7
+(set 'X 123)             <span class='arw'>&rarr;</span> 123
+(eval-string "X")        <span class='arw'>&rarr;</span> 123
+
+(define (repl) ; read print eval loop
+  (while true
+    (println "=&gt; " (eval-string (read-line) MAIN (last-error)))
+  )
+)
+
+(set 'a 10)
+(set 'b 20)
+(set 'foo:a 11)
+(set 'foo:b 22)
+
+(eval-string "(+ a b)")       <span class='arw'>&rarr;</span> 30
+(eval-string "(+ a b)" 'foo)  <span class='arw'>&rarr;</span> 33
+</pre>
+
+
+<p>The second example shows a simple newLISP interpreter eval loop.</p> 
+
+<p>The last example shows how to specify a target context for translation. The symbols 
+<tt>a</tt> and <tt>b</tt> now refer to symbols and their values in context <tt>foo</tt> instead of 
+<tt>MAIN</tt>.</p>
+	
+<p>See also the function <a href="#read-expr">read-expr</a> which translates a string
+without evaluating it.</p>
+
+<br/><br/>
+
+<a name="eval-string-js"></a>
+<h2><span class="function">eval-string-js
+<a href="#JS"><font size="-1">JS</font></a></span></h2>
+<h4>syntax: (eval-string-js <em>str-JavaScript-source</em>)</h4>
+<p>The function takes a program source in <em>str-JavaScript-source</em>
+and returns the result in a string.</p>
+
+<p>This function is only available on newLISP compiled to JavaScript.</p>
+
+<pre>
+(eval-string-js "window.prompt('Enter some text:', '')")
+
+; for single and double quotes inside a string passed to a
+; JavaScropt function, single and double quotes must be
+; preceded by a backslash \ and the whole string passed
+; to eval-string-js limited by [text], [/text] tags.
+
+(eval-string-js [text]alert('A double quote: \" and a single quote: \' ')[/text])
+
+(eval-string-js "6 * 7")
+</pre>
+
+<p>The first expression will pop up a dialog box to enter text. The function
+will return the text string entered. The second expression will return the
+string <tt>42</tt>.</p>
+
+<p>See also the function <a href="#display-html">display-html</a> for displaying
+an HTML page in the browser.</p>
+
+<br/><br/>
+
+<a name="evenp"></a>
+<h2><span class="function">even?</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (even? <em>int-number</em>)</h4>
+
+<p>Checks if an integer number is <em>even divisible</em> by <tt>2</tt>, without remainder. 
+When a floating point number is passed for <em>int-number</em>, it will be converted to an
+integer by cutting off its fractional part.</p>
+
+<pre>
+(even? 123)  <span class='arw'>&rarr;</span> nil
+(even? 8)    <span class='arw'>&rarr;</span> true
+(even? 8.7)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<p>Use <a href="#oddp">odd?</a> to check if an integer is not divisible by <tt>2</tt>.</p>
+
+<br/><br/>
+
+<a name="exec"></a>
+<h2><span class="function">exec</span></h2>
+<h4>syntax: (exec <em>str-process</em>)<br/>
+syntax: (exec <em>str-process</em> [<em>str-stdin</em>])</h4>
+
+<p>In the first form, <tt>exec</tt> launches a process described in <em>str-process</em>
+and returns all standard output as a list of strings 
+(one for each line in standard out (STDOUT)).  <tt>exec</tt> returns <tt>nil</tt>
+if the process could not be launched. If the process could be launched but 
+only returns and error and no valid output, the empty list will be returned.
+</p> 
+
+
+<!-- example -->
+
+<pre>
+(exec "ls *.c")  <span class='arw'>&rarr;</span> ("newlisp.c" "nl-math.c" "nl-string.c")
+</pre>
+
+
+<p>
+	The example starts a process and performs the shell command <tt>ls</tt>,
+	capturing the output in an array of strings.
+</p>
+
+<p>
+	In the second form, 
+	<tt>exec</tt> creates a process pipe, 
+	starts the process in <em>str-process</em>, 
+	and receives from <em>str-stdin</em> 
+	standard input for this process.
+	The return value is <tt>true</tt> 
+	if the process was successfully launched; 
+	otherwise it is <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(exec "cgiProc" query)
+</pre>
+
+
+<p>
+	In this example, 
+	cgiProc could be a cgi processor (e.g., Perl or newLISP) 
+	that receives and processes standard input supplied by a string 
+	contained in the variable query.
+</p>
+
+<br/><br/>
+
+<a name="exists"></a>
+<h2><span class="function">exists</span></h2>
+<h4>syntax: (exists <em>func-condition</em> <em>list</em>)</h4>
+
+<p>Successively applies <em>func-condition</em> 
+to the elements of <em>list</em> 
+and returns the first element 
+that meets the condition in <em>func-condition</em>. 
+If no element meets the condition, 
+<tt>nil</tt> is returned.</p>
+
+<!-- example -->
+
+<pre>
+(exists string? '(2 3 4 6 "hello" 7))       <span class='arw'>&rarr;</span> "hello"
+
+(exists string? '(3 4 2 -7 3 0))            <span class='arw'>&rarr;</span> nil
+
+(exists zero? '(3 4 2 -7 3 0))              <span class='arw'>&rarr;</span> 0 ; check for 0 or 0.0
+
+(exists &lt; '(3 4 2 -7 3 0))                  <span class='arw'>&rarr;</span> -7 ; check for negative
+
+(exists (fn (x) (&gt; x 3)) '(3 4 2 -7 3 0))   <span class='arw'>&rarr;</span> 4
+
+(exists (fn (x) (= x 10)) '(3 4 2 -7 3 0))  <span class='arw'>&rarr;</span> nil 
+</pre>
+
+
+<p>If <em>func-condition</em> is <tt>nil?</tt>, the result <tt>nil</tt> is ambiguous.
+In this case <a href="#index">index</a> or <a href="#find">find</a> are the better 
+method when looking for <tt>nil</tt>.</p>
+
+<p>Use the <a href="#for-all">for-all</a> function 
+to check if a condition is met for all elements in a list.</p>
+
+<br/><br/>
+
+<a name="exit"></a>
+<h2><span class="function">exit</span></h2>
+<h4>syntax: (exit [<em>int</em>])</h4>
+
+<p>
+	Exits newLISP. 
+	An optional exit code, <em>int</em>, may be supplied. 
+	This code can be tested by the host operating system. 
+	When newLISP is run in <a href="#daemon">daemon server mode</a> 
+ 	using <tt>-d</tt> as a command-line option, 
+	only the network connection is closed, 
+	while newLISP stays resident, 
+	listening for a new connection.
+</p>
+
+<!-- example -->
+
+<pre>
+(exit 5)
+</pre>
+
+<br/><br/>
+
+<a name="exp"></a>
+<h2><span class="function">exp</span></h2>
+<h4>syntax: (exp <em>num</em>)</h4>
+
+<p>The expression in <em>num</em> is evaluated, and the exponential function 
+is calculated based on the result.  <tt>exp</tt> is the inverse function of 
+<a href="#log">log</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(exp 1)        <span class='arw'>&rarr;</span> 2.718281828
+(exp (log 1))  <span class='arw'>&rarr;</span> 1
+</pre>
+
+<br/><br/>
+
+<a name="expand"></a>
+<h2><span class="function">expand</span></h2>
+
+<h4>syntax: (expand <em>exp</em> <em>sym-1</em> [<em>sym-2</em> ... ])<br/>
+syntax: (expand <em>exp</em> <em>list-assoc</em> [<em>bool</em>])<br/>
+syntax: (expand <em>exp</em>)</h4>
+
+<p>In the first syntax, one symbol in <em>sym</em> 
+(or more in <em>sym-2</em> through <em>sym-n</em>) 
+is looked up in a simple or nested expression <em>exp</em>. 
+They are then expanded to the current binding of the symbol 
+and the expanded expression is returned. The original list remains unchanged.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 2 'a '(d e))
+(set 'foo 'a)
+(expand foo 'a)               <span class='arw'>&rarr;</span> (d e)
+(expand '(a x b) 'x)           <span class='arw'>&rarr;</span> (a 2 b)
+(expand '(a x (b c x)) 'x)     <span class='arw'>&rarr;</span> (a 2 (b c 2))
+(expand '(a x (b c x)) 'x 'a)  <span class='arw'>&rarr;</span> ((d e) 2 (b c 2))
+</pre>
+
+
+<p><tt>expand</tt> is useful when composing lambda expressions 
+and doing variable expansion as in rewrite macros.</p>
+
+
+<pre>
+(define (raise-to power)
+  (expand (fn (base) (pow base power)) 'power))
+
+(define square (raise-to 2))
+(define cube (raise-to 3))
+
+(square 5)  <span class='arw'>&rarr;</span> 25
+(cube 5)    <span class='arw'>&rarr;</span> 125
+</pre>
+
+
+<p>
+	If more than one symbol is present, 
+	<tt>expand</tt> will work in an incremental fashion:
+</p>
+
+
+<pre>
+(set 'a '(b c))
+(set 'b 1)
+
+(expand '(a b c) 'a 'b)  <span class='arw'>&rarr;</span> ((1 c) 1 c) 
+</pre>
+
+
+<p>
+	Like the <a href="#apply">apply</a> function, 
+	<tt>expand</tt> <em>reduces</em> its argument list.
+</p>
+
+<h4>syntax: (expand <em>list</em> <em>list-assoc</em> [<em>bool</em>])</h4>
+
+<p>The second syntax of <tt>expand</tt> allows expansion bindings to be specified 
+on the fly, without performing a <a href="#set">set</a> on the participating variables:
+</p>
+
+<p>If the <em>bool</em> evaluates to <tt>true</tt>, the value parts in the
+association list are evaluated.</p>
+
+<!-- example -->
+
+<pre>
+(expand '(a b c) '((a 1) (b 2)))                <span class='arw'>&rarr;</span> (1 2 c)
+(expand '(a b c) '((a 1) (b 2) (c (x y z))))    <span class='arw'>&rarr;</span> (1 2 (x y z))
+(expand '(a b) '((a (+ 1 2)) (b (+ 3 4))))      <span class='arw'>&rarr;</span> ((+ 1 2) (+ 3 4))
+(expand '(a b) '((a (+ 1 2)) (b (+ 3 4))) true) <span class='arw'>&rarr;</span> (3 7)
+</pre>
+
+
+<p>
+	Note that the contents of the variables 
+	in the association list will not change. 
+	This is different from the <a href="#letex">letex</a> function, 
+	where variables are set by evaluating 
+	and assigning their association parts.
+</p>
+
+<p>
+	This form of <tt>expand</tt> is frequently used 
+	in logic programming, 
+	together with the <a href="#unify">unify</a> function.
+</p>
+
+<h4>syntax: (expand <em>list</em>)</h4>
+
+<p>
+	A third syntax is used to expand only the contents 
+	of variables starting with an uppercase character. 
+	This PROLOG mode may also be used 
+	in the context of logic programming. 
+	As in the first syntax of <tt>expand</tt>, 
+	symbols must be preset. 
+	Only uppercase variables and those bound 
+	to anything other than <tt>nil</tt> 
+	will be expanded:
+</p>
+
+
+<!-- example -->
+
+<pre>
+(set 'A 1 'Bvar 2 'C nil 'd 5 'e 6)
+(expand '(A (Bvar) C d e f))  <span class='arw'>&rarr;</span> (1 (2) C d e f)
+</pre>
+
+
+<p>
+	Only the symbols <tt>A</tt> and <tt>Bvar</tt> are expanded 
+	because they have capitalized names 
+	and non-<tt>nil</tt> contents.
+</p>
+
+<p>
+	The <em>currying</em> function in the example 
+	demonstrating the first syntax of <tt>expand</tt> 
+	can now be written even more simply 
+	using an uppercase variable:
+</p>
+
+
+<pre>
+(define (raise-to Power) 
+  (expand (fn (base) (pow base Power))))
+
+&gt; (define cube (raise-to 3))
+<b>(lambda (base) (pow base 3))</b>
+
+&gt; (cube 4)
+<b>64</b>
+
+&gt; _
+</pre>
+
+
+<p>
+	See the <a href="#letex">letex</a> function, 
+	which also provides an expansion mechanism, 
+	and the function <a href="#unify">unify</a>, 
+	which is frequently used together with <tt>expand</tt>.
+</p>
+
+<br/><br/>
+
+<a name="explode"></a>
+<h2><span class="function">explode</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (explode <em>str</em> [<em>int-chunk</em> [<em>bool</em>]])<br/>
+syntax: (explode <em>list</em> [<em>int-chunk</em> [<em>bool</em>]])</h4>
+
+<p>
+In the first syntax, 
+<tt>explode</tt> transforms the string (<em>str</em>)
+into a list of single-character strings. 
+Optionally, a chunk size can be specified in <em>int-chunk</em> 
+to break the string into multi-character chunks. 
+When specifying a value for <em>bool</em> other than <tt>nil</tt>,
+the last chunk will be omitted 
+if it does not have the full length specified 
+in <em>int-chunk</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(explode "newLISP")  <span class='arw'>&rarr;</span> ("n" "e" "w" "L" "I" "S" "P")
+
+(join (explode "keep it together"))  <span class='arw'>&rarr;</span> "keep it together"
+
+(explode "newLISP" 2)    <span class='arw'>&rarr;</span> ("ne" "wL" "IS" "P")
+
+(explode "newLISP" 3)    <span class='arw'>&rarr;</span> ("new" "LIS" "P")
+
+; omit last chunk if too short
+(explode "newLISP" 3 true)    <span class='arw'>&rarr;</span> ("new" "LIS")
+</pre>
+
+
+<p>
+Only on non UTF8&ndash; enabled versions, <tt>explode</tt> also works on binary content:
+</p>
+
+
+<pre>
+(explode "\000\001\002\003") 
+<span class='arw'>&rarr;</span> ("\000" "\001" "\002" "\003")
+</pre>
+
+<p>
+When called in UTF-8&ndash;enabled versions of newLISP, 
+<tt>explode</tt> will work on character boundaries rather than byte boundaries. 
+In UTF-8&ndash;encoded strings, characters may contain more than one byte.
+Processing will stop when a zero byte character is found.
+</p>
+
+<p>To explode binary contents on UTF-8&ndash;enabled versions of newLISP
+use <a href="#unpack">unpack</a> as shown in the following example:</p>
+
+<pre>
+(set 'str "\001\002\003\004") <span class='arw'>&rarr;</span> "\001\002\003\004"
+
+(unpack (dup "c" (length str)) str) <span class='arw'>&rarr;</span> (1 2 3 4)
+(unpack (dup "s" (length str)) str) <span class='arw'>&rarr;</span> ("\001" "\002" "\003" "\004")
+</pre>
+
+<p>
+In the second syntax, 
+<tt>explode</tt> explodes a list (<em>list</em>)
+into sublists of chunk size <em>int-chunk</em>, 
+which is 1 (one) by default.
+</p>
+
+<p>
+The following shows an example of the last chunk being omitted 
+when the value for <em>bool</em> is other than <tt>nil</tt>,
+and the chunk does not have the full length specified 
+in <em>int-chunk</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(explode '(a b c d e f g h))    <span class='arw'>&rarr;</span> ((a) (b) (c) (d) (e) (f) (g) (h))
+(explode '(a b c d e f g) 2)  <span class='arw'>&rarr;</span> ((a b) (c d) (e f) (g))
+
+; omit last chunk if too short
+(explode '(a b c d e f g) 2 true)  <span class='arw'>&rarr;</span> ((a b) (c d) (e f))
+
+(transpose (explode '(a b c d e f g h) 2)) 
+<span class='arw'>&rarr;</span> ((a c e g) (b d f h))
+</pre>
+
+
+<p>
+The <a href="#join">join</a> and <a href="#append">append</a> functions
+are inverse operations of <tt>explode</tt>.
+</p>
+
+<br/><br/>
+
+<a name="extend"></a>
+<h2><span class="function">extend</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (extend <em>list-1</em> [<em>list-2</em> ... ])<br/>
+syntax: (extend <em>string-1</em> [<em>string-2</em> ... ])</h4>
+
+<p>The list in <em>list-1</em> is extended by appending <em>list-2</em>. More
+than one list may be appended.</p>
+
+<p>The string in <em>string-1</em> is extended by appending <em>string-2</em>. More
+than one string may be appended. The string can contain binary <tt>0</tt> (zero) 
+characters.</p>
+
+<p>The first parameter can be an un-initialized variable.</p>
+
+<p>The extended list or string is returned.</p>
+
+<!-- example -->
+
+<pre>
+; extending lists
+
+(extend lst '(a b) '(c d)) <span class='arw'>&rarr;</span> (a b c d)
+(extend lst '(e f g)) <span class='arw'>&rarr;</span> (a b c d e f)
+lst <span class='arw'>&rarr;</span> (a b c d e f g)
+
+; extending strings
+
+(extend str "ab" "cd") <span class='arw'>&rarr;</span> "abcd"
+(extend str "efg") <span class='arw'>&rarr;</span> "abcdefg"
+str <span class='arw'>&rarr;</span> "abcdefg"
+
+; extending in place
+
+(set 'L '(a b "CD" (e f)))
+(extend (L 2) "E")
+L <span class='arw'>&rarr;</span> (a b "CDE" (e f))
+
+(extend (L 3) '(g))
+L <span class='arw'>&rarr;</span> (a b "CDE" (e f g))
+</pre>
+
+<p>For a non-destructive list or string extension see <a href="#append">append</a>.</p>
+
+<br/><br/>
+
+<a name="factor"></a>
+<h2><span class="function">factor</span></h2>
+<h4>syntax: (factor <em>int</em>)</h4>
+
+<p>Factors the number in <em>int</em> into its prime components. 
+When floating point numbers  are passed, they are truncated to 
+their integer part first.</p>
+
+<!-- example -->
+
+<pre>
+(factor 123456789123456789)  <span class='arw'>&rarr;</span> (3 3 7 11 13 19 3607 3803 52579)
+
+;; check correctness of factoring
+(= (apply * (factor 123456789123456789)) 123456789123456789)
+<span class='arw'>&rarr;</span> true
+
+;; factor the biggest integer
+(factor 9223372036854775807)  <span class='arw'>&rarr;</span> (7 7 73 127 337 92737 649657)
+
+;; primes.lsp - return all primes in a list, up to n 
+
+(define (primes n , p)
+  (dotimes (e n) 
+    (if (= (length (factor e)) 1) 
+      (push e p -1))) p)
+           
+(primes 20)  <span class='arw'>&rarr;</span> (2 3 5 7 11 13 17 19)         
+</pre>
+
+
+<p>
+	<tt>factor</tt> returns <tt>nil</tt> 
+	for numbers smaller than <tt>2</tt>.
+	For numbers larger than 9,223,372,036,854,775,807
+	(the largest 64-bit integer)
+	converted from floating point numbers, 
+	the largest integer is factored.
+</p>
+
+<br/><br/>
+
+<a name="fft"></a>
+<h2><span class="function">fft</span></h2>
+<h4>syntax: (fft <em>list-num</em>)</h4>
+
+<p>
+	Calculates the discrete Fourier transform 
+	on the list of complex numbers in <em>list-num</em> 
+	using the FFT method (Fast Fourier Transform). 
+	Each complex number is specified by its real part 
+	followed by its imaginary part. 
+	If only real numbers are used, 
+	the imaginary part is set to <tt>0.0</tt> (zero). 
+	When the number of elements in <em>list-num</em> 
+	is not a power of 2, 
+	<tt>fft</tt> increases the number of elements 
+	by padding the list with zeroes. 
+	When the imaginary part of a complex number is <tt>0</tt>, 
+	simple numbers can be used instead.
+</p>
+
+<!-- example -->
+
+<pre>
+(ifft (fft '((1 0) (2 0) (3 0) (4 0)))) 
+<span class='arw'>&rarr;</span> ((1 0) (2 0) (3 0) (4 0))
+
+;; when imaginary part is 0, plain numbers work too
+;; plain numbers and complex numbers can be intermixed
+
+(fft '(1 2 3 4))      <span class='arw'>&rarr;</span> ((10 0) (-2 -2) (-2 0) (-2 2))
+(fft '(1 2 (3 0) 4))  <span class='arw'>&rarr;</span> ((10 0) (-2 -2) (-2 0) (-2 2))
+</pre>
+
+
+<p>
+	The inverse operation of <tt>fft</tt> 
+	is the <a href="#ifft">ifft</a> function.
+</p>
+
+<br/><br/>
+
+<a name="file-info"></a>
+<h2><span class="function">file-info</span></h2>
+<h4>syntax: (file-info <em>str-name</em> [<em>int-index</em> [<em>bool-flag</em>]])</h4>
+
+<p>Returns a list of information about the file or directory in <em>str_name</em>. 
+The optional index specifies the list member to return.  When no <em>bool-flag</em>
+is specified or when <em>bool-flag</em> evaluates to <tt>nil</tt> information about
+the link is returned if the file is a link to an original file. If <em>bool-flag</em>
+evaluates to anything else than <tt>nil</tt>, information about the original file
+referenced by the link is returned.</p>
+
+<table   summary="file attributes">
+<tr align="left"><th>offset</th><th>contents</th></tr>
+<tr><td>0</td><td>size</td></tr>
+<tr><td>1</td><td>mode (differs with <tt>true</tt> flag)</td></tr>
+<tr><td>2</td><td>device mode</td></tr>
+<tr><td>3</td><td>user ID</td></tr>
+
+<tr><td>4</td><td>group ID</td></tr>
+<tr><td>5</td><td>access time</td></tr>
+<tr><td>6</td><td>modification time</td></tr>
+<tr><td>7</td><td>status change time</td></tr>
+</table><br/>
+
+<p>Depending on <em>bool-flag</em> set, the function reports on either
+the link (no flag or <tt>nil</tt> flag) or on the original linked file 
+(<tt>true</tt> flag).</p>
+
+<!-- example -->
+
+<pre>
+(file-info ".bashrc")   
+<span class='arw'>&rarr;</span> (124 33188 0 500 0 920951022 920951022 920953074)
+
+(file-info ".bashrc" 0)  <span class='arw'>&rarr;</span> 124
+
+(date (file-info "/etc" -1))  <span class='arw'>&rarr;</span> "Mon Mar 8 18:23:17 2005"
+</pre>
+
+
+<p> In the second example, the last status change date 
+for the directory <em>/etc</em> is retrieved.</p>
+
+<p><tt>file-info</tt> gives file statistics (size) for a linked file,
+not the link, except for the <em>mode</em> field.</p>
+
+<br/><br/>
+
+<a name="filep"></a>
+<h2><span class="function">file?</span></h2>
+
+<h4>syntax: (file? <em>str-path-name</em> [<em>bool</em>])</h4>
+
+<p>Checks for the existence of a file in <em>str-name</em>. Returns <tt>true</tt> 
+if the file exists; otherwise, it returns <tt>nil</tt>.  This function will also return 
+<tt>true</tt> for directories. If the optional <em>bool</em> value is <tt>true</tt>,
+the file must not be a directory and <em>str-path-name</em> is returned or <tt>nil</tt>
+if the file is a directory. The existence of a file does not imply anything about its 
+read or write permissions for the current user.</p>
+
+<!-- example -->
+
+<pre>
+(if (file? "afile") (set 'fileNo (open "afile" "read")))
+
+(file? "/usr/bin/newlisp" true) <span class='arw'>&rarr;</span> "/usr/bin/newlisp"
+(file? "/usr/bin/foo" true)     <span class='arw'>&rarr;</span> nil
+</pre>
+
+<br/><br/>
+
+<a name="filter"></a>
+<h2><span class="function">filter</span></h2>
+<h4>syntax: (filter <em>exp-predicate</em> <em>exp-list</em>)</h4>
+
+<p>
+	The predicate <em>exp-predicate</em> is applied 
+	to each element of the list <em>exp-list</em>. 
+	A list is returned containing the elements 
+	for which <em>exp-predicate</em> is true. 
+	<tt>filter</tt> works like <a href="#clean">clean</a>, 
+	but with a negated predicate.
+</p>
+
+<!-- example -->
+
+<pre>
+(filter symbol? '(1 2 d 4 f g 5 h))  <span class='arw'>&rarr;</span> (d f g h)
+
+(define (big? x) (&gt; x 5))  <span class='arw'>&rarr;</span> (lambda (x) (&gt; x 5))
+
+(filter big? '(1 10 3 6 4 5 11))  <span class='arw'>&rarr;</span> (10 6 11)
+
+; filter with comparison functor
+(set 'L '((a 10 2 7) (b 5) (a 8 3) (c 8) (a 9)))
+
+(filter (curry match '(a *)) L)   <span class='arw'>&rarr;</span> ((a 10 2 7) (a 8 3) (a 9))
+
+(filter (curry match '(? ?)) L)   <span class='arw'>&rarr;</span> ((b 5) (c 8) (a 9))
+
+(filter (curry match '(* 8 *)) L) <span class='arw'>&rarr;</span> ((a 8 3) (c 8))
+</pre>
+
+
+<p>
+The predicate may be a built-in predicate, a user-defined function, 
+or a lambda expression.
+</p>
+
+<p>
+For filtering a list of elements with the elements from another list, 
+use the <a href="#difference"> difference</a> function or 
+<a href="#intersect">intersect</a> (with the <em>list</em> option).
+</p>
+
+<p>
+See also the related function <a href="#index">index</a>, which returns the 
+indices of the filtered elements and <a href="#clean">clean</a>, 
+which returns all elements of a list for which a predicate is false.
+</p>
+
+<br/><br/>
+
+<a name="find"></a>
+<h2><span class="function">find</span></h2>
+<h4>syntax: (find <em>exp-key</em> <em>list</em> [<em>func-compare</em> | <em>regex-option</em>])<br/>
+syntax: (find <em>str-key</em> <em>str-data</em> [<em>regex-option</em> [<em>int-offset</em>]])</h4>
+
+
+<h3>Find an expression in a list</h3>
+
+<p>If the second argument evaluates to a <em>list</em>, then <tt>find</tt> returns 
+the index position (offset) of the element derived from evaluating <em>exp-key</em>.</p>
+
+<p>
+Optionally, an operator or user-defined function can be specified in <em>func-compare</em>. 
+If the <em>exp-key</em> is a string, a regular expression option
+can be specified with the <em>regex-option</em> parameter.</p>
+
+<p>When using regular expressions or comparison functors the system
+variable <tt>$0</tt> is set to the last element found.</p>
+
+<!-- example -->
+
+<pre>
+; find an expression in a list
+(find '(1 2) '((1 4) 5 6 (1 2) (8 9)))  <span class='arw'>&rarr;</span> 3
+
+(find "world" '("hello" "world"))       <span class='arw'>&rarr;</span> 1
+(find "hi" '("hello" "world"))          <span class='arw'>&rarr;</span> nil
+
+(find "newlisp" '("Perl" "Python" "newLISP") 1)  <span class='arw'>&rarr;</span> 2
+; same with string option
+(find "newlisp" '("Perl" "Python" "newLISP") "i")  <span class='arw'>&rarr;</span> 2
+
+; use the comparison functor
+(find 3 '(8 4 3  7 2 6) &gt;)  <span class='arw'>&rarr;</span> 4
+$0 <span class='arw'>&rarr;</span> 2
+
+(find "newlisp" '("Perl" "Python" "newLISP") 
+                 (fn (x y) (regex x y 1))) <span class='arw'>&rarr;</span> 2
+$0 <span class='arw'>&rarr;</span> "newLISP"
+
+(find 5 '((l 3) (k 5) (a 10) (z 22)) 
+         (fn (x y) (= x (last y))))  <span class='arw'>&rarr;</span> 1
+$0 <span class='arw'>&rarr;</span> (k 5)
+
+(find '(a ?) '((l 3) (k 5) (a 10) (z 22)) match)  <span class='arw'>&rarr;</span> 2
+$0 <span class='arw'>&rarr;</span> (a 10)
+
+(find '(X X) '((a b) (c d) (e e) (f g)) unify)  <span class='arw'>&rarr;</span> 2
+$0 <span class='arw'>&rarr;</span> (e e)
+
+; define the comparison functor first for better readability
+(define (has-it-as-last x y) (= x (last y)))
+
+(find 22 '((l 3) (k 5) (a 10) (z 22)) has-it-as-last)  <span class='arw'>&rarr;</span> 3
+$0 <span class='arw'>&rarr;</span> (z 22)
+</pre>
+
+
+<p>
+Using <a href="#match">match</a> and <a href="#unify">unify</a>, 
+list searches can be formulated which are as powerful 
+as regular expression searches are for strings.
+</p>
+
+<h3>Find a string in a string</h3>
+
+<p>If the second argument, <em>str-data</em>, 
+evaluates to a string, then the offset position 
+of the string <em>str-key</em> (found in the first argument, 
+<em>str-data</em>) is returned.  In this case, <tt>find</tt> 
+also works on binary <em>str-data</em>. The offset position
+returned is always based on counting single byte characters
+even when running the UTF-8 enabled version of newLISP.</p>
+
+<p>The presence of a third parameter specifies a search 
+using the regular expression pattern specified in <em>str-pattern</em>, 
+as well as an option number specified in <em>regex-option</em>
+(i.e., 1 (one) for case-insensitive search or <tt>0</tt> (zero) 
+for no special options). If <em>regex-option</em> is specified
+an optional <em>int-offset</em> argument can be specified too
+to start the search not at the beginning but at the offset given.
+In any case the position returned by <tt>find</tt> is calculated
+relative to the beginning of the string.</p>
+
+<p>To specify <em>int-offset</em> in a simple string search without regular
+expressions, specify <tt>nil</tt> for <em>regex-option</em>.</p>
+
+<p>In newLISP, regular expressions are standard 
+Perl Compatible Regular Expression (PCRE) searches. 
+Found expressions or subexpressions are returned 
+in the system variables <tt>$0</tt>, <tt>$1</tt>, <tt>$2</tt>, etc., 
+which can be used like any other symbol. 
+As an alternative, 
+the contents of these variables 
+can also be accessed 
+by using <tt>($ 0)</tt>, <tt>($ 1)</tt>, <tt>($ 2)</tt>, etc. 
+This method allows indexed access 
+(i.e., <tt>($ i)</tt>, where <tt>i</tt> is an integer).
+</p> 
+	
+<p>See <a href="#regex">regex</a> for the meaning of the  
+option numbers and more information on regular expression searching.
+</p> 
+	
+<!-- example -->
+
+<pre>
+; simple string search
+(find "world" "Hello world")  <span class='arw'>&rarr;</span> 6
+(find "WORLD" "Hello woRLd")  <span class='arw'>&rarr;</span> nil
+
+; case-insensitive regex
+
+(find "WorlD" "Hello woRLd" 1)  <span class='arw'>&rarr;</span> 6   
+; or
+(find "WorlD" "Hello woRLd" "i")  <span class='arw'>&rarr;</span> 6   
+                                
+(find "hi" "hello world")       <span class='arw'>&rarr;</span> nil
+(find "Hello" "Hello world")    <span class='arw'>&rarr;</span> 0
+
+; regex with default options
+
+(find "cat|dog" "I have a cat" 0)  <span class='arw'>&rarr;</span> 9 
+$0                                 <span class='arw'>&rarr;</span> "cat"
+(find "cat|dog" "my dog" 0)        <span class='arw'>&rarr;</span> 3
+$0                                 <span class='arw'>&rarr;</span> "dog"
+(find "cat|dog" "MY DOG" 1)        <span class='arw'>&rarr;</span> 3
+$0                                 <span class='arw'>&rarr;</span> "DOG"
+
+; use an optional offset
+(find "cat|dog" "I have a cat and a dog" 0)    <span class='arw'>&rarr;</span> 9
+(find "cat|dog" "I have a cat and a dog" 0 12) <span class='arw'>&rarr;</span> 19
+
+;; find with subexpressions in regular expression
+;; and access with system variables
+
+(set 'str  "http://nuevatec.com:80")
+
+(find "http://(.*):(.*)" str 0)  <span class='arw'>&rarr;</span> 0
+                                 
+$0  <span class='arw'>&rarr;</span> "http://nuevatec.com:80"
+$1  <span class='arw'>&rarr;</span> "nuevatec.com"
+$2  <span class='arw'>&rarr;</span> "80"
+
+;; system variables as an indexed expression (since 8.0.5)
+($ 0)  <span class='arw'>&rarr;</span> "http://nuevatec.com:80"
+($ 1)  <span class='arw'>&rarr;</span> "nuevatec.com"
+($ 2)  <span class='arw'>&rarr;</span> "80"
+</pre>
+
+
+<p>
+	For other functions using regular expressions, 
+	see <a href="#directory">directory</a>, 
+    <a href="#find-all">find-all</a>,
+	<a href="#parse">parse</a>, 
+	<a href="#regex">regex</a>, 
+	<a href="#replace">replace</a>, 
+	and <a href="#search">search</a>.
+</p>
+
+<p>
+	To find expressions in nested 
+	or multidimensional lists, 
+	use the <a href="#ref">ref</a> and <a href="#ref-all">ref-all</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="find-all"></a>
+<h2><span class="function">find-all</span></h2>
+<h4>syntax: (find-all <em>str-regex-pattern</em> <em>str-text</em> [<em>exp</em> [<em>regex-option</em>]])<br/>
+syntax: (find-all <em>list-match-pattern</em> <em>list</em> [<em>exp</em>])<br/>
+syntax: (find-all <em>exp-key</em> <em>list</em> [<em>exp</em> [<em>func-compare</em>]])</h4>
+
+<p>
+In the first syntax, <tt>find-all</tt> finds all occurrences of <em>str-regex-pattern</em> 
+in the text <em>str-text</em>, returning a list containing all matching strings. 
+The empty list <tt>()</tt> is returned if no matches are found. In the first syntax
+string searches are always done using regular expression patterns, even if no
+<em>regex-option</em> is specified. The system variable <tt>$count</tt> is updated
+with the number of matches found.</p>
+
+<p>
+Optionally, an expression can be specified to process the found string or regular subexpressions 
+before placing them into the returned list. An additional option, <em>regex-option</em>, 
+specifies special regular expression options 
+(see <a href="#regex">regex</a> for further details).
+</p>
+
+
+<!-- example -->
+
+<pre>
+(find-all {\d+} "lkjhkljh34ghfdhgfd678gfdhfgd9")
+<span class='arw'>&rarr;</span> ("34" "678" "9")
+
+$count <span class='arw'>&rarr;</span> 3
+
+(find-all {(new)(lisp)} "newLISPisNEWLISP" (append $2 $1) 1)
+<span class='arw'>&rarr;</span> ("LISPnew" "LISPNEW")
+
+(unique (sort 
+    (find-all {[a-zA-Z]+} 
+        (replace "&lt;[^&gt;]+&gt;" (get-url "http://newlisp.org") "" 0) )
+))
+<span class='arw'>&rarr;</span> ("A" "ACC" "AI" "API" "About" "All" "Amazing" "Apps"
+...
+"where" "whole" "width" "wiki" "will" "with" "work" "written")
+
+; use $count in evaluated expr
+(find-all "a" "ababab" (string $count $it)) <span class='arw'>&rarr;</span> ("1a" "2a" "3a")
+</pre>
+
+
+<p>
+The first example discovers all numbers in a text. 
+The second example shows how an optional expression in <em>exp</em> 
+can work on subexpressions found by the regular expression pattern 
+in <em>str-pattern</em>. The last example retrieves a web page, 
+cleans out all HTML tags, and then collects all words 
+into a unique and sorted list.
+</p>
+
+<p>
+Note that <tt>find-all</tt> with strings always performs a regular expression search, 
+even if the option in <em>regex-option</em> is omitted.
+</p>
+
+<p>In the second syntax, <tt>find-all</tt> searches for all list 
+<a href="#match">match</a> patterns <em>list-match-pattern</em> in 
+<em>list</em>. As in <tt>find-all</tt> for strings, an expression can 
+be specified in <em>exp</em> to process further the matched sublist found in 
+<em>list</em>. The system variable <tt>$count</tt> is updated with the number
+ of matches found.</p>
+
+<!-- example -->
+
+<pre>
+(find-all '(? 2) '((a 1) (b 2) (a 2) (c 4))) <span class='arw'>&rarr;</span> ((b 2) (a 2))
+
+(find-all '(? 2) '((a 1) (b 2) (a 2) (c 4)) (first $it)) <span class='arw'>&rarr;</span> (b a)
+
+$count <span class='arw'>&rarr;</span> 2
+</pre>
+
+
+<p><tt>find-all</tt> for list matches always uses <a href="#match">match</a> to compare when
+searching for sublists and always needs a list for the pattern expression.</p>
+
+<p>In the third syntax, <tt>find-all</tt> can specify a built-in or user-defined
+function used for comparing list elements with the key expression in <em>exp-key</em>:</p>
+
+
+<!-- example -->
+
+<pre>
+(find-all 5 '(2 7 4 5 9 2 4 9 7 4 8) $it &lt;) <span class='arw'>&rarr;</span> (7 9 9 7 8)
+
+; process the found element available in $it
+
+(find-all 5 '(2 7 4 5 9 2 4 9 7 4 8) (* 3 $it) &lt;) <span class='arw'>&rarr;</span> (21 27 27 21 24)
+; same as
+(find-all 5 '(2 7 4 5 9 2 4 9 7 4 8) (* 3 $it) (fn (x y) (&lt; x y))) <span class='arw'>&rarr;</span> (21 27 27 21 24)
+
+
+(find-all 5 '(2 7 4 5 9 2 4 9 7 4 8) ("abcdefghijk" $it) &lt;) <span class='arw'>&rarr;</span> ("h" "j" "j" "h" "i")
+
+$count <span class='arw'>&rarr;</span> 5
+
+; use $count
+(find-all 'a '(a b a b a b) (list $count $it)) <span class='arw'>&rarr;</span> ((1 a) (2 a) (3 a))
+</pre>
+
+
+<p>Any type of expression can be searched for or can be contained in the list. <tt>find-all</tt>
+in this syntax works similar to <a href="#filter">filter</a> but with the added benefit of
+being able to define a processing expression for the found element.</p>
+
+<p>If no <em>func-compare</em> is defined and <em>exp-key</em> is a list, then
+<a href="#match">match</a> will be used for comparison, as in the second syntax.</p>
+
+<br/><br/>
+
+<a name="first"></a>
+<h2><span class="function">first</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (first <em>list</em>)<br/>
+syntax: (first <em>array</em>)<br/>
+syntax: (first <em>str</em>)</h4>
+
+<p>
+Returns the first element of a list or the first character of a string.
+The operand is not changed.  This function is equivalent to <em>car</em>
+or <em>head</em> in other Lisp dialects.</p>
+
+<!-- example -->
+
+<pre>
+(first '(1 2 3 4 5))       <span class='arw'>&rarr;</span> 1
+(first '((a b) c d))       <span class='arw'>&rarr;</span> (a b)
+(set 'aList '(a b c d e))  <span class='arw'>&rarr;</span> (a b c d e)
+(first aList)              <span class='arw'>&rarr;</span> a
+aList                      <span class='arw'>&rarr;</span> (a b c d e)
+(set 'A (array 3 2 (sequence 1 6)))
+<span class='arw'>&rarr;</span>  ((1 2) (3 4) (5 6))
+(first A)                  <span class='arw'>&rarr;</span> (1 2)
+
+(first '())                <span class='arw'>&rarr;</span> <span class='err'>ERR: list is empty</span>
+</pre>
+
+
+<p>In the third syntax, the first character is returned 
+from the string in <em>str</em> as a string.</p>
+
+<!-- example -->
+
+<pre>
+(first "newLISP")         <span class='arw'>&rarr;</span> "n"
+(first (rest "newLISP"))  <span class='arw'>&rarr;</span> "e"
+</pre>
+
+
+<p>
+	Note that <a href="#first">first</a> works on character boundaries 
+	rather than byte boundaries 
+	when the UTF-8&ndash;enabled version of newLISP is used.
+	See also the functions <a href="#last">last</a> 
+	and <a href="#rest">rest</a>.
+</p>
+
+<br/><br/>
+
+<a name="flat"></a>
+<h2><span class="function">flat</span></h2>
+<h4>syntax: (flat <em>list</em> [<em>int-level</em>])</h4>
+
+<p>Returns a flattened list from a list:</p>
+
+<!-- example -->
+
+<pre>
+(set 'lst '(a (b (c d))))
+(flat lst)  <span class='arw'>&rarr;</span> (a b c d)
+
+; extract a list of index vectors of all elements
+
+(map (fn (x) (ref x lst)) (flat lst)) 
+<span class='arw'>&rarr;</span> ((0) (1 0) (1 1 0) (1 1 1))
+</pre>
+
+<p>The optional <em>int-level</em> parameter can be used to limit
+the recursion level when flattening the list:</p>
+
+<!-- example -->
+
+<pre>
+(flat '(a b (c d (e f)) (g h (i j))) )   <span class='arw'>&rarr;</span> (a b c d e f g h i j)
+
+(flat '(a b (c d (e f)) (g h (i j))) 1)  <span class='arw'>&rarr;</span> (a b c d (e f) g h (i j))
+
+(flat '(a b (c d (e f)) (g h (i j))) 2)  <span class='arw'>&rarr;</span> (a b c d e f g h i j)
+</pre>
+
+<p>If <em>int-level</em> is <tt>0</tt>, no flattening will occur.</p>
+
+<p><tt>flat</tt> can be used to iterate through nested lists.</p>
+
+
+<br/><br/>
+
+<a name="float"></a>
+<h2><span class="function">float</span></h2>
+<h4>syntax: (float <em>exp</em> [<em>exp-default</em>])</h4>
+
+<p>
+	If the expression in <em>exp</em> 
+	evaluates to a number or a string, 
+	the argument is converted to a float 
+	and returned. 
+	If <em>exp</em> cannot be converted to a float 
+	then <tt>nil</tt> or, if specified, 
+	the evaluation of <em>exp-default</em> 
+	will be returned.
+	This function is mostly used to convert strings 
+	from user input or when reading and parsing text. 
+	The string must start with a digit 
+	or the <tt>+</tt> (plus sign), <tt>-</tt> (minus sign), 
+	or <tt>.</tt> (period). 
+	If <em>exp</em> is invalid,
+	<tt>float</tt> returns <tt>nil</tt> 
+	as a default value.
+</p>
+
+<p>
+	Floats with exponents larger than 1e308 
+	or smaller than -1e308 
+	are converted to +INF or -INF, respectively. 
+	The display of +INF and -INF 
+	differs on different platforms and compilers.
+</p>
+
+<!-- example -->
+
+<pre>
+(float "1.23")       <span class='arw'>&rarr;</span> 1.23
+(float " 1.23")      <span class='arw'>&rarr;</span> 1.23
+(float ".5")         <span class='arw'>&rarr;</span> 0.50
+(float "-1.23")      <span class='arw'>&rarr;</span> -1.23
+(float "-.5")        <span class='arw'>&rarr;</span> nil
+(float "#1.23")      <span class='arw'>&rarr;</span> nil
+(float "#1.23" 0.0)  <span class='arw'>&rarr;</span> 0
+
+(float? 123)          <span class='arw'>&rarr;</span> nil
+(float? (float 123))  <span class='arw'>&rarr;</span> true
+
+(float '(a b c))    <span class='arw'>&rarr;</span> nil
+(float '(a b c) 0)  <span class='arw'>&rarr;</span> 0
+(float nil 0)       <span class='arw'>&rarr;</span> 0
+
+(float "abc" "not a number")  <span class='arw'>&rarr;</span> "not a number"
+(float "1e500")               <span class='arw'>&rarr;</span> inf
+(float "-1e500")              <span class='arw'>&rarr;</span> -inf
+
+(print "Enter a float num:")
+(set 'f-num (float (read-line)))
+</pre>
+
+
+<p>
+	Use the <a href="#int">int</a> function 
+	to parse integer numbers.
+</p>
+
+<br/><br/>
+
+<a name="floatp"></a>
+<h2><span class="function">float?</span></h2>
+<h4>syntax: (float? <em>exp</em>)</h4>
+
+<p>
+	<tt>true</tt> is returned only 
+	if <em>exp</em> evaluates to a floating point number;
+	otherwise, <tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'num 1.23)
+(float? num)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="floor"></a>
+<h2><span class="function">floor</span></h2>
+<h4>syntax: (floor <em>number</em>)</h4>
+
+<p>
+	Returns the next lowest integer below <em>number</em> 
+	as a floating point.
+</p>
+
+<!-- example -->
+
+<pre>
+(floor -1.5)  <span class='arw'>&rarr;</span> -2
+(floor 3.4)   <span class='arw'>&rarr;</span> 3
+</pre>
+
+
+<p>
+	See also the <a href="#ceil">ceil</a> function.
+</p>
+
+<br/><br/>
+
+<a name="flt"></a>
+<h2><span class="function">flt</span></h2>
+<h4>syntax: (flt <em>number</em>)</h4>
+
+<p>
+	Converts <em>number</em> to a 32-bit float 
+	represented by an integer. 
+	This function is used when passing 32-bit floats 
+	to library routines.
+	newLISP floating point numbers 
+	are 64-bit and are passed as 64-bit floats 
+	when calling imported C library routines.
+</p>
+
+
+<!-- example -->
+
+<pre>
+(flt 1.23)  <span class='arw'>&rarr;</span> 1067282596
+
+;; pass 32-bit float to C-function: foo(float value) 
+(import "mylib.so" "foo")
+(foo (flt 1.23))
+
+(get-int (pack "f" 1.23))  <span class='arw'>&rarr;</span> 1067282596
+
+(unpack "f" (pack "ld" (flt 1.2345)))  <span class='arw'>&rarr;</span> (1.234500051)
+</pre>
+
+
+<p>
+	The last two statements illustrate 
+	the inner workings of <tt>flt</tt>.
+</p>
+
+<p>
+	Use the <a href="#import">import</a> function 
+	to import libraries.
+</p>
+
+<br/><br/>
+
+<a name="fn"></a>
+<h2><span class="function">fn</span></h2> 
+<h4>syntax: (fn (<em>list-parameters</em>) <em>exp-body</em>)</h4>
+
+<p>
+<tt>fn</tt> or <tt>lambda</tt> are used to define anonymous functions, 
+which are frequently used in <a href="#map">map</a>, <a href="#sort">sort</a>, 
+and all other expressions where functions can be used as arguments.
+The <tt>fn</tt> or <tt>lambda</tt> word does not exist on its own as a symbol,
+but indicates a special list type: the <em>lambda list</em>. Together with <tt>fn-macro</tt>
+and <tt>lambda-macro</tt> these terms are recognized during source parsing. They indicate a 
+specialized type of list which can be used and applied like a function or operator. 
+</p>
+
+<p>
+Using an anonymous function eliminates the need to define a new function with 
+<a href="#define">define</a>. Instead, a function is defined on the fly:
+</p>
+
+<!-- example -->
+
+<pre>
+(map (fn (x) (+ x x)) '(1 2 3 4 5)) <span class='arw'>&rarr;</span> (2 4 6 8 10)
+
+(sort '(".." "..." "." ".....") (fn (x y) (&gt; (length x) (length y))))
+<span class='arw'>&rarr;</span> ("....." "..." ".." ".")
+</pre>
+
+
+<p>
+The example defines the function <em>fn(x)</em>, which takes an integer 
+(<em>x</em>) and doubles it.  The function is <em>mapped</em> onto a list of 
+arguments using <a href="#map">map</a>. The second example shows strings being 
+sorted by length.
+</p>
+
+<p>
+The <a href="#lambda">lambda</a> function (the longer, traditional form of writing)
+can be used in place of <tt>fn</tt>.
+</p>
+
+<br/><br/>
+
+<a name="for"></a>
+<h2><span class="function">for</span></h2>
+<h4>syntax: (for (<em>sym</em> <em>num-from</em> <em>num-to</em> [<em>num-step</em> [<em>exp-break</em>]]) <em>body</em>)</h4>
+
+<p>
+	Repeatedly evaluates the expressions in <em>body</em> 
+	for a range of values specified
+	in <em>num-from</em> and <em>num-to</em>, inclusive.  
+	A step size may be specified with <em>num-step</em>.  
+	If no step size is specified, <tt>1</tt> is assumed.
+</p>
+
+<p>
+	Optionally, a condition for early loop exit
+	may be defined in <em>exp-break</em>. 
+	If the break expression evaluates 
+	to any non-<tt>nil</tt> value, 
+	the <tt>for</tt> loop returns with 
+	the value of <em>exp-break</em>. 
+	The break condition is tested 
+	before evaluating <em>body</em>. If a
+	break condition is defined, <em>num-step</em>
+	must be defined, too.
+</p>
+
+<p>
+	The symbol <em>sym</em> 
+	is local in dynamic scope 
+	to the <tt>for</tt> expression.
+	It takes on each value successively 
+	in the specified range as an integer value 
+	if no step size is specified, or
+	as a floating point value when a step size is
+	present. After evaluation of the <tt>for</tt>
+    statement <em>sym</em> assumes its previous
+    value.
+</p>
+
+<!-- example -->
+
+<pre>
+&gt; (for (x 1 10 2) (println x))
+<b>1
+3
+5
+7
+9</b>
+
+&gt; (for (x 8 6 0.5) (println x))
+<b>8
+7.5
+7
+6.5
+6</b>
+
+&gt; (for (x 1 100 2 (&gt; (* x x) 30)) (println x))
+<b>1
+3
+5
+true</b>
+&gt; _
+</pre>
+
+
+<p>
+	The second example uses 
+	a range of numbers 
+	from highest to lowest. 
+	Note that the step size 
+	is always a positive number. 
+	In the third example, 
+	a break condition is tested.
+</p>
+
+<p>
+	Use the <a href="#sequence">sequence</a> function
+	to make a sequence of numbers.
+</p>
+
+<br/><br/>
+
+<a name="for-all"></a>
+<h2><span class="function">for-all</span></h2>
+
+<h4>syntax: (for-all <em>func-condition</em> <em>list</em>)</h4>
+
+<p>Applies the function in <em>func-condition</em> 
+to all elements in <em>list</em>.
+If all elements meet the condition in <em>func-condition</em>,
+the result is <tt>true</tt>;
+otherwise, <tt>nil</tt> is returned.</p>
+
+<!-- example -->
+
+<pre>
+(for-all number? '(2 3 4 6 7))                 <span class='arw'>&rarr;</span> true
+
+(for-all number? '(2 3 4 6 "hello" 7))         <span class='arw'>&rarr;</span> nil
+
+(for-all (fn (x) (= x 10)) '(10 10 10 10 10))  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>Use the <a href="#exists">exists</a> function
+to check if at least one element in a list 
+meets a condition.</p>
+
+<br/><br/>
+
+<a name="fork"></a>
+<h2><span class="function">fork</span></h2>
+
+<h4>syntax: (fork <em>exp</em>)</h4>
+
+<p>
+The expression in <em>exp</em> is launched as a newLISP child process-thread 
+of the platforms OS. The new process inherits the entire address space, 
+but runs independently so symbol or variable contents changed in the child process 
+will not affect the parent process or vice versa. The child process ends 
+when the evaluation of <em>exp</em> finishes.
+</p>
+
+<p>
+On success, <tt>fork</tt> returns with the child process ID; on failure, 
+<tt>nil</tt> is returned. See also the <a href="#wait-pid">wait-pid</a> function, 
+which waits for a child process to finish.
+</p>
+
+<p>
+This function is only available on Linux/Unix versions of newLISP 
+and is based on the <tt>fork()</tt> implementation of the underlying OS. </p>
+
+<p>A much simpler automated method to launch processes and collect
+results is available with <a href="#spawn">spawn</a> and the <a href="#cilk">Cilk API</a>.</p>
+
+<!-- example -->
+
+<pre>
+&gt; (set 'x 0)
+<b>0</b>
+&gt; (fork (while (&lt; x 20) (println (inc x)) (sleep 1000)))
+<b>176</b>
+
+&gt; <b>1
+2
+3
+4
+5
+6</b>
+</pre>
+
+
+<p>
+The example illustrates how the child process-thread inherits the symbol space 
+and how it is independent of the parent process. The <tt>fork</tt> statement 
+returns immediately with the process ID <tt>176</tt>. The child process increments 
+the variable <tt>x</tt> by one each second and prints it to standard out (boldface). 
+In the parent process, commands can still be entered. Type <tt>x</tt> to see that 
+the symbol <tt>x</tt> still has the value <tt>0</tt> (zero) in the parent process. 
+Although statements entered will mix with the display of the child process output, 
+they will be correctly input to the parent process.</p>
+
+<p>
+The second example illustrates how <a href="#pipe">pipe</a> can be used 
+to communicate between processes.</p>
+
+<!-- example -->
+
+<pre>
+#!/usr/bin/newlisp
+
+(define (count-down-proc x channel)
+  (while (!= x 0)
+      (write-line channel (string x))
+      (dec x)))
+
+(define (observer-proc channel)
+  (do-until (= i "1")
+    (println "process " (setq i (read-line channel)))))
+
+(map set '(in out) (pipe))
+(set 'observer (fork (observer-proc in)))
+(set 'counter (fork (count-down-proc 5 out)))
+
+; avoid zombies
+(wait-pid observer)
+(wait-pid counter)
+
+(exit)
+</pre>
+
+
+<p>The following output is generated by observer-proc</p>
+
+
+<pre>
+<b>process 5
+process 4
+process 3
+process 2
+process 1</b>
+</pre>
+
+
+<p>
+The <tt>count-down-proc</tt> writes numbers to the communication pipe, 
+where they are picked up by the <tt>observer-process</tt> and displayed.
+</p>
+
+<p>A forked process can either exit by itself or it can be destroyed using
+the <a href="#destroy">destroy</a> function.</p>
+
+
+<pre>
+(define (fork-destroy-demo)
+    (set 'pid (fork (dotimes (i 1000) (println i) (sleep 10))))
+    (sleep 50)
+    (destroy pid) 
+)
+
+&gt; (fork-destroy-demo)
+<b>0
+1
+2
+3
+4
+true</b>
+&gt; 
+</pre>
+
+
+<p>The process started by <tt>fork-destroy-demo</tt> will not finish but is
+destroyed 50 milli-seconds after start by a call to <a href="#destroy">destroy</a>.
+</p> 
+
+<p>
+Use the <a href="#semaphore">semaphore</a> function for synchronizing processes 
+and <a href="#share">share</a> for sharing memory between processes.
+</p>
+
+<p>See <a href="#spawn">spawn</a> for a much simpler and automated way to
+synchronize processes and collect results.</p>
+
+<br/><br/>
+
+<a name="format"></a>
+<h2><span class="function">format</span></h2>
+<h4>syntax: (format <em>str-format exp-data-1</em> [<em>exp-data-2</em> ... ])<br/>
+syntax: (format <em>str-format</em> <em>list-data</em>)</h4>
+
+<p>Constructs a formatted string from <em>exp-data-1</em> 
+using the format specified in the evaluation of <em>str-format</em>. 
+The format specified is identical to the format used for the <tt>printf()</tt> 
+function in the ANSI C language.  Two or more <em>exp-data</em> arguments 
+can be specified for more than one format specifier in <em>str-format</em>.</p>
+
+<p>In an alternative syntax, the data to be formatted 
+can be passed inside a list in <em>list-data</em>.</p>
+
+<p><tt>format</tt> checks for a valid format string, 
+matching data type, and the correct number of arguments. 
+Wrong formats or data types result in error messages. 
+<a href="#int">int</a>, <a href="#float">float</a>, 
+or <a href="#string">string</a> can be used 
+to ensure correct data types and to avoid error messages.</p>
+
+<p>The format string has the following general format:</p>
+
+
+<b>"%w.pf"</b>
+
+<p>The <tt>%</tt> (percent sign) starts a format specification. 
+To display a <tt>%</tt> inside a format string, double it: <tt>%%</tt></p>
+
+<p>On Linux the percent sign can be followed by a single quote <tt>%'</tt>
+to insert thousand's separators in number formats.</p>
+
+
+<p>The <tt>w</tt> represents the width field. Data is right-aligned, except when 
+preceded by a minus sign, in which case it is left-aligned. If preceded by a 
+<tt>+</tt> (plus sign), positive numbers are displayed with a <tt>+</tt>.  
+When preceded by a <tt>0</tt> (zero), the unused space is filled with leading 
+zeroes. The width field is optional and serves all data types.</p>
+
+<p>The <tt>p</tt> represents the precision number of decimals (floating point only) 
+or strings and is separated from the width field by a period. Precision is 
+optional. When using the precision field on strings, the number of characters 
+displayed is limited to the number in <tt>p</tt>.</p>
+
+<p>The <tt>f</tt> represents a type flag and is essential; 
+it cannot be omitted.</p>
+
+<p>Below are the types in <tt>f</tt>:</p>
+
+<table summary="format characters">
+<tr align="left"><th>format</th><th>description</th></tr>
+<tr><td>s</td><td>text string</td></tr>
+<tr><td>c</td><td>character (value 1 - 255)</td></tr>
+<tr><td>d</td><td>decimal (32-bit)</td></tr>
+<tr><td>u</td><td>unsigned decimal (32-bit)</td></tr>
+<tr><td>x</td><td>hexadecimal lowercase</td></tr>
+<tr><td>X</td><td>hexadecimal uppercase</td></tr>
+<tr><td>o</td><td>octal (32-bits) (not supported on all of newLISP flavors)</td></tr>
+<tr><td>f</td><td>floating point</td></tr>
+<tr><td>e</td><td>scientific floating point</td></tr>
+<tr><td>E</td><td>scientific floating point</td></tr>
+<tr><td>g</td><td>general floating point</td></tr>
+</table><br/>
+
+<p>Formatting 64-bit numbers using the 32-bit format specifiers from above table 
+will truncate and format the lower 32 bits of the number on 64-bit systerms and overflow to
+<tt>0xFFFFFFFF</tt> on 32-bit systems.</p>
+
+<p>For 32-bit and 64-bit numbers use the following format 
+strings. 64-bit numbers will be truncated to 32-bit on
+32-bit platforms:</p>
+
+<table summary="format characters">
+<tr align="left"><th>format</th><th>description</th></tr>
+<tr><td>ld</td><td>decimal (32/64-bit)</td></tr>
+<tr><td>lu</td><td>unsigned decimal (32/64-bit)</td></tr>
+<tr><td>lx</td><td>hexadecimal (32/64-bit)</td></tr>
+<tr><td>lX</td><td>hexadecimal uppercase (32/64-bit)</td></tr>
+</table><br/>
+
+<p>For 64-bit numbers use the following format strings on Unix-like 
+operating systems and on MS Windows (not supported on TRU64):</p>
+
+<table summary="format characters">
+<tr align="left"><th>format</th><th>description</th></tr>
+<tr><td>lld</td><td>decimal (64-bit)</td></tr>
+<tr><td>llu</td><td>unsigned decimal (64-bit)</td></tr>
+<tr><td>llx</td><td>hexadecimal (64-bit)</td></tr>
+<tr><td>llX</td><td>hexadecimal uppercase(64-bit)</td></tr>
+</table><br/>
+
+<p>On Windows platforms only the following characters apply 
+for 64 bit numbers:</p>
+
+<table summary="format characters">
+<tr align="left"><th>format</th><th>description</th></tr>
+<tr><td>I64d</td><td>decimal (64-bit)</td></tr>
+<tr><td>I64u</td><td>unsigned decimal (64-bit)</td></tr>
+<tr><td>I64x</td><td>hexadecimal (64-bit)</td></tr>
+<tr><td>I64X</td><td>hexadecimal uppercase(64-bit)</td></tr>
+</table><br/>
+
+<p>
+	Other text may occur between, 
+	before, or after the format specs.
+</p>
+	
+<p>Note that on Tru64 Unix the format character <tt>i</tt> can be used instead
+of <tt>d</tt>.
+</p>
+
+<br/><br/>
+
+<!-- example -->
+
+<pre>
+(format "&gt;&gt;&gt;%6.2f&lt;&lt;&lt;" 1.2345)     <span class='arw'>&rarr;</span> "&gt;&gt;&gt;  1.23&lt;&lt;&lt;"
+(format "&gt;&gt;&gt;%-6.2f&lt;&lt;&lt;" 1.2345)    <span class='arw'>&rarr;</span> "&gt;&gt;&gt;1.23  &lt;&lt;&lt;"
+(format "&gt;&gt;&gt;%+6.2f&lt;&lt;&lt;" 1.2345)    <span class='arw'>&rarr;</span> "&gt;&gt;&gt; +1.23&lt;&lt;&lt;"
+(format "&gt;&gt;&gt;%+6.2f&lt;&lt;&lt;" -1.2345)   <span class='arw'>&rarr;</span> "&gt;&gt;&gt; -1.23&lt;&lt;&lt;"
+(format "&gt;&gt;&gt;%-+6.2f&lt;&lt;&lt;" -1.2345)  <span class='arw'>&rarr;</span> "&gt;&gt;&gt;-1.23 &lt;&lt;&lt;"
+
+(format "%e" 123456789)        <span class='arw'>&rarr;</span> "1.234568e+08"
+(format "%12.10E" 123456789)   <span class='arw'>&rarr;</span> "1.2345678900E+08"
+
+(format "%10g" 1.23)   <span class='arw'>&rarr;</span> "      1.23"
+(format "%10g" 1.234)  <span class='arw'>&rarr;</span> "     1.234"
+
+(format "Result = %05d" 2)  <span class='arw'>&rarr;</span> "Result = 00002"
+
+(format "%14.2f" 12345678.12)   <span class='arw'>&rarr;</span> "   12345678.12"
+; on UNIX glibc compatible platforms only (Linux, MAC OS X 10.9) on some locales
+(format "%'14.2f" 12345678.12) <span class='arw'>&rarr;</span> " 12,345,678.12"
+
+(format "%8d" 12345)   <span class='arw'>&rarr;</span> "   12345"
+; on UNIX glibc compatible platforms only (Linux, MAC OS X 10.9) on some locales
+(format "%'8d" 12345)  <span class='arw'>&rarr;</span> "  12,345"
+
+(format "%-15s" "hello")        <span class='arw'>&rarr;</span> "hello          "
+(format "%15s %d" "hello" 123)  <span class='arw'>&rarr;</span> "          hello 123"
+(format "%5.2s" "hello")        <span class='arw'>&rarr;</span> "   he"
+(format "%-5.2s" "hello")       <span class='arw'>&rarr;</span> "he   "
+
+(format "%o" 80)    <span class='arw'>&rarr;</span> "120"
+                                
+(format "%x %X" -1 -1)  <span class='arw'>&rarr;</span> "ffffffff FFFFFFFF"
+
+; 64 bit numbers on Windows
+(format "%I64X" 123456789012345678)  <span class='arw'>&rarr;</span> "1B69B4BA630F34E"
+
+; 64 bit numbers on Unix (except TRU64)
+(format "%llX" 123456789012345678)   <span class='arw'>&rarr;</span> "1B69B4BA630F34E"
+                                
+(format "%c" 65)  <span class='arw'>&rarr;</span> "A"
+</pre>
+
+
+<p>
+	The data to be formatted 
+	can be passed inside a list:
+</p>
+
+
+<pre>
+(set 'L '("hello" 123))
+(format "%15s %d" L)  <span class='arw'>&rarr;</span> "          hello 123"
+</pre>
+
+
+<p>
+	If the format string requires it, 
+	newLISP's <tt>format</tt> will 
+	automatically convert integers 
+	into floating points 
+	or floating points into integers:
+</p>
+
+
+<pre>
+(format "%f" 123)      <span class='arw'>&rarr;</span> 123.000000
+                       
+(format "%d" 123.456)  <span class='arw'>&rarr;</span> 123
+</pre>
+
+<br/><br/>
+
+<a name="fv"></a>
+<h2><span class="function">fv</span></h2>
+<h4>syntax: (fv <em>num-rate</em> <em>num-nper</em> <em>num-pmt</em> <em>num-pv</em> [<em>int-type</em>])</h4>
+
+<p>Calculates the future value of a loan with constant payment <em>num-pmt</em> 
+and constant interest rate <em>num-rate</em> after <em>num-nper</em> period of 
+time and a beginning principal value of <em>num-pv</em>.  If payment is at the 
+end of the period, <em>int-type</em> is <tt>0</tt> (zero) or <em>int-type</em> is
+omitted; for payment at the beginning of each period, <em>int-type</em> is 1. 
+</p>
+
+<!-- example -->
+
+<pre>
+(fv (div 0.07 12) 240 775.30 -100000)  <span class='arw'>&rarr;</span> -0.5544645052
+</pre>
+
+
+<p>
+The example illustrates how a loan of $100,000 is paid down to a residual 
+of $0.55 after 240 monthly payments at a yearly interest rate of 7 percent.
+</p>
+
+<p>
+	See also the functions <a href="#irr">irr</a>, 
+	<a href="#nper">nper</a>, <a href="#npv">npv</a>, 
+	<a href="#pmt">pmt</a>, and <a href="#pv">pv</a>.
+</p>
+
+<br/><br/>
+
+<a name="gammai"></a>
+<h2><span class="function">gammai</span></h2>
+<h4>syntax: (gammai <em>num-a</em> <em>num-b</em>)</h4>
+
+<p>
+	Calculates the incomplete Gamma function 
+	of values <em>a</em> and <em>b</em> in <em>num-a</em> and <em>num-b</em>,
+	respectively.
+</p>
+
+<!-- example -->
+
+<pre>
+(gammai 4 5)  <span class='arw'>&rarr;</span> 0.7349740847
+</pre>
+
+
+<p>
+	The incomplete Gamma function is used to derive 
+	the probability of Chi&sup2; to exceed a 
+	given value for a degree of freedom, df, as follows:
+</p>
+
+<BLOCKQUOTE>
+<em><b>Q(Chi&sup2;|df) = Q(df/2, Chi&sup2;/2) = gammai(df/2, Chi&sup2;/2)</b></em>
+</BLOCKQUOTE>
+
+<p>
+	See also the <a href="#prob-chi2">prob-chi2</a> function.
+</p>
+
+<br/><br/>
+
+<a name="gammaln"></a>
+<h2><span class="function">gammaln</span></h2>
+<h4>syntax: (gammaln <em>num-x</em>)</h4>
+
+<p>
+	Calculates the log Gamma function of the value <em>x</em> in <em>num-x</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(exp (gammaln 6))  <span class='arw'>&rarr;</span> 120
+</pre>
+
+
+<p>
+	The example uses the equality of <em>n! = gamma(n + 1)</em> 
+	to calculate the factorial value of 5.
+</p>
+
+<p>
+	The log Gamma function is also related to the Beta function, 
+	which can be derived from it:
+</p>
+
+<BLOCKQUOTE>
+<em><b>Beta(z,w) = Exp(Gammaln(z) + Gammaln(w) - Gammaln(z+w))</b></em>
+
+</BLOCKQUOTE>
+
+<br/><br/>
+
+<a name="gcd"></a>
+<h2><span class="function">gcd</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (gcd <em>int-1</em> [<em>int-2</em> ... ])</h4>
+
+<p>
+Calculates the greatest common divisor 
+of a group of integers.
+The greatest common divisor of two integers 
+that are not both zero 
+is the largest integer that divides both numbers.
+<tt>gcd</tt> will calculate the greatest common divisor 
+for the first two integers in <em>int-i</em> 
+and then further reduce the argument list 
+by calculating the greatest common divisor of the result 
+and the next argument in the parameter list.
+</p>
+
+<!-- example -->
+
+<pre>
+(gcd 0)        <span class='arw'>&rarr;</span> 0
+(gcd 0 0)      <span class='arw'>&rarr;</span> 0
+(gcd 10)       <span class='arw'>&rarr;</span> 10
+(gcd 12 36)    <span class='arw'>&rarr;</span> 12
+(gcd 15 36 6)  <span class='arw'>&rarr;</span> 3 
+</pre>
+
+
+<p>
+See 
+<a href="http://en.wikipedia.org/wiki/Greatest_common_divisor">Wikipedia</a>
+for details and theory about gcd numbers in mathematics.
+</p>
+
+<br/><br/>
+
+<a name="get-char"></a>
+<h2><span class="function">get-char</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (get-char <em>int-address</em>)</h4>
+
+<p>
+Gets an 8-bit character from an address 
+specified in <em>int-address</em>. 
+This function is useful when using 
+imported shared library functions 
+with <a href="#import">import</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+char * foo(void)
+{
+char * result;
+result = "ABCDEFG";
+return(result);
+}
+</pre>
+
+
+<p>
+Consider the above C function 
+from a shared library, which returns a 
+character pointer (address to a string).
+</p>
+
+
+<pre>
+(import "mylib.so" "foo")
+(print (get-char (foo) ))       <span class='arw'>&rarr;</span>  65 ; ASCII "A"
+(print (get-char (+ (foo) 1)))  <span class='arw'>&rarr;</span>  66 ; ASCII "B"
+</pre>
+
+
+
+<p>
+Note that it is unsafe to use the <tt>get-char</tt> function 
+with an incorrect address in <em>int-address</em>. Doing so 
+could result in the system crashing or becoming unstable.
+</p>
+
+<p>
+See also the <a href="#address">address</a>, 
+<a href="#get-int">get-int</a>, 
+<a href="#get-long">get-long</a>, 
+<a href="#get-float">get-float</a>, 
+<a href="#get-string">get-string</a>, 
+<a href="#pack">pack</a>, and <a href="#unpack">unpack</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="get-float"></a>
+<h2><span class="function">get-float</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (get-float <em>int-address</em>)</h4>
+
+<p>
+Gets a 64-bit double float from an address 
+specified in <em>int-address</em>.
+This function is helpful when using 
+imported shared library functions (with <tt>import</tt>)
+that return an address pointer to a double float 
+or a pointer to a structure containing double floats.
+</p>
+
+<!-- example -->
+
+<pre>
+double float * foo(void)
+{
+double float * result;
+&hellip;
+*result = 123.456;
+return(result);
+}
+</pre>
+
+
+<p>
+The previous C function is compiled 
+into a shared library.
+</p>
+
+
+<pre>
+(import "mylib.so" "foo")
+(get-float (foo))  <span class='arw'>&rarr;</span> 123.456
+</pre>
+
+
+<p>
+<tt>foo</tt> is imported and returns a pointer 
+to a double float when called.
+Note that <tt>get-float</tt> is unsafe when used 
+with an incorrect address in <em>int-address</em> 
+and may result in the system crashing or becoming unstable.
+</p>
+
+<p>
+See also the <a href="#address">address</a>, 
+<a href="#get-int">get-int</a>, 
+<a href="#get-long">get-long</a>,
+<a href="#get-char">get-char</a>, 
+<a href="#get-string">get-string</a>,
+<a href="#pack">pack</a>, 
+and <a href="#unpack">unpack</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="get-int"></a>
+<h2><span class="function">get-int</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (get-int <em>int-address</em>)</h4>
+
+<p>
+Gets a 32-bit integer from 
+the address specified in <em>int-address</em>.
+This function is handy when using 
+imported shared library functions with <tt>import</tt>,
+a function returning an address pointer 
+to an integer, or a pointer to a structure containing integers.
+</p>
+
+<!-- example -->
+
+<pre>
+int * foo(void)
+{
+int * result;
+&hellip;
+*result = 123;
+return(result);
+}
+
+int foo-b(void)
+{
+int result;
+&hellip;
+result = 456;
+return(result);
+}
+</pre>
+
+
+<p>
+Consider the C function <tt>foo</tt> (from a shared library), 
+which returns an integer pointer (address of an integer).
+</p>
+
+
+<pre>
+(import "mylib.so" "foo")
+(get-int (foo))  <span class='arw'>&rarr;</span> 123
+(foo-b)          <span class='arw'>&rarr;</span> 456
+</pre>
+
+
+<p>
+Note that using <tt>get-int</tt> with an incorrect address 
+in <em>int-address</em> is unsafe and could result 
+in the system crashing or becoming unstable.
+</p>
+
+<p>
+See also the <a href="#address">address</a>, 
+<a href="#get-char">get-char</a>, 
+<a href="#get-float">get-float</a>, 
+<a href="#get-long">get-long</a>,
+<a href="#get-string">get-string</a>,
+<a href="#pack">pack</a>, 
+and <a href="#unpack">unpack</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="get-long"></a>
+<h2><span class="function">get-long</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (get-long <em>int-address</em>)</h4>
+
+<p>
+Gets a 64-bit integer from 
+the address specified in <em>int-address</em>.
+This function is handy when using <tt>import</tt>
+to import shared library functions, 
+a function returning an address pointer to a long integer, 
+or a pointer to a structure containing long integers.
+</p>
+
+<!-- example -->
+
+<pre>
+long long int * foo(void)
+{
+int * result;
+&hellip;
+*result = 123;
+return(result);
+}
+
+long long int foo-b(void)
+{
+int result;
+&hellip;
+result = 456;
+return(result);
+}
+</pre>
+
+
+<p>
+Consider the C function <tt>foo</tt> (from a shared library), 
+which returns an integer pointer (address of an integer).
+</p>
+
+
+<pre>
+(import "mylib.so" "foo")
+(get-int (foo))  <span class='arw'>&rarr;</span> 123
+(foo-b)          <span class='arw'>&rarr;</span> 456
+</pre>
+
+
+<p>
+Note that using <tt>get-long</tt> with an incorrect address 
+in <em>int-address</em> is unsafe and could result 
+in the system crashing or becoming unstable.
+</p>
+
+<p>
+See also the <a href="#address">address</a>, 
+<a href="#get-char">get-char</a>, 
+<a href="#get-float">get-float</a>, 
+<a href="#get-int">get-int</a>,
+<a href="#get-string">get-string</a>,
+<a href="#pack">pack</a>, 
+and <a href="#unpack">unpack</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="get-string"></a>
+<h2><span class="function">get-string</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (get-string <em>int-address</em> [<em>int-bytes</em> [<em>str-limit</em>])</h4>
+
+<p>Copies a character string from the address specified in <em>int-address</em>.
+This function is helpful when using imported shared library functions with 
+<a href="#import">import</a> and a C-function returns the address to a memory buffer.</p>
+
+<!-- example -->
+
+<pre>
+char * foo(void)
+{
+char * result;
+result = "ABCDEFG";
+return(result);
+}
+</pre>
+
+
+<p>
+Consider the above C function from a shared library, 
+which returns a character pointer (address to a string).
+</p>
+
+
+<pre>
+(import "mylib.so" "foo")
+(print (get-string (foo)))  <span class='arw'>&rarr;</span> "ABCDEFG"
+</pre>
+
+
+<p>
+When a string is passed as an argument, 
+<tt>get-string</tt> will take its address as the argument. 
+Without the optional <em>int-bytes</em> argument <tt>get-string</tt> breaks off 
+at the first first <tt>\000</tt> (null character) it encounters. This works for
+retrieving ASCII strings from raw memory addresses:</p>
+
+<!-- example -->
+
+<pre>
+(set 'buff "ABC\000\000\000DEF")  <span class='arw'>&rarr;</span> "ABC\000\000\000DEF"
+
+(length buff)  <span class='arw'>&rarr;</span> 9
+
+(get-string buff)  <span class='arw'>&rarr;</span> "ABC"
+
+(length (get-string buff))  <span class='arw'>&rarr;</span> 3
+
+; get a string from offset into a buffer
+(get-string (+ (address buff) 6)) <span class='arw'>&rarr;</span> "DEF"
+</pre>
+
+<p>When specifyung the number of bytes in the optional <em>int-bytes</em>
+parameter, reading does not stpop at the first zero byte found, but
+copies exactly <em>int-bytes</em> number of bytes from the address or string
+buffer:</p>
+
+<pre>
+(set 'buff "ABC\000\000\000DEF")  <span class='arw'>&rarr;</span> "ABC\000\000\000DEF"
+
+; without specifying the number of bytes
+; buff is equivalent to (address buff)
+(get-string buff)  <span class='arw'>&rarr;</span> "ABC"
+
+; specifying the number of bytes to get
+(get-string buff 9) <span class='arw'>&rarr;</span> "ABC\000\000\000DEF"
+</pre>
+
+<p>The addtional <em>str-limit</em> parameter can be used to limit reading
+the buffer at a certain string. If <em>int-bytes</em> are read before
+<em>str-limit</em> is found, only <em>int-bytes</em> are read:</p>
+
+<pre>
+(set 'buff "ABC\000\000EFG\000DQW") <span class='arw'>&rarr;</span> "ABC\000\000EFG\000DQW"
+
+; buff is eqivalent to (address buff)
+(get-string buff 4 "FG") <span class='arw'>&rarr;</span> "ABC\000"
+
+(get-string buff 10) <span class='arw'>&rarr;</span> "ABC\000\000EFG\000D"
+
+(get-string buff 10 "FG") <span class='arw'>&rarr;</span> "ABC\000\000E"
+</pre>
+ 
+<p>Although UTF-16 and UTF-32 encoding does not specify string termination characters,
+the sequences "\000\000" and "\000\000\000\000" are used often to terminate UTF-16
+and UTF-32 encodings. The additional optional  <em>str-limit</em> can be used to limit
+the string when reading from the buffer address:</p>
+<pre>
+(set 'utf32 (unicode "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚"))
+
+(set 'addr (address utf32)) <span class='arw'>&rarr;</span> 140592856255712
+
+; get-string automatically takes the address when a buffer is passed
+; utf32 is equivalent to (address utf32) for get-string
+
+(get-string utf32 80 "\000\000\000\000")
+<span class='arw'>&rarr;</span> "\017b\000\000??\000\000\030T\000\000\011N\ 000\000?s\
+000\000?t\000\000\f?\000\000\rN\000\000$O\000\000??\000\000SO\000\000\0020\000\000"
+</pre>
+
+<p>When using  "\000\000" or "\000\000\000\000" as limit strings, the search for these
+limits is aligned to a 2-byte or 4-byte border.</p>
+
+<p>
+See also the <a href="#get-char">get-char</a>, 
+<a href="#get-int">get-int</a>,
+<a href="#get-float">get-float</a>,
+<a href="#pack">pack</a>,
+and <a href="#unpack">unpack</a> functions.
+</p>
+
+<p>
+Note that <tt>get-string</tt> can crash the system 
+or make it unstable if the wrong address is specified.
+</p>
+
+<br/><br/>
+
+<a name="get-url"></a>
+<h2><span class="function">get-url</span></h2>
+<h4>syntax: (get-url <em>str-url</em> [<em>str-option</em>] [<em>int-timeout</em> [<em>str-header</em>]])</h4>
+
+<p>Reads a web page or file specified by the URL in <em>str-url</em> using 
+the HTTP GET protocol.  Both <tt>http://</tt> and <tt>file://</tt>
+URLs are handled.  <tt>"header"</tt> can be specified in the optional argument 
+<em>str-option</em> to retrieve only the header.  The  option <tt>"list"</tt> 
+causes header and page information to be returned as separate strings in a list
+and also includes the server status code as the third list member (since 10.6.4).
+The <tt>"raw"</tt> option (since 10.6.4), which can be used alone or combined
+with other options, suppresses header location redirection.</p>
+
+<p>A <tt>"debug"</tt> option can be specified either alone or after the
+<tt>"header"</tt> or <tt>"list"</tt> option separated by one character, 
+i.e. <tt>"header debug"</tt> or <tt>"list debug"</tt>. Including "debug" 
+outputs all outgoing information to the console window.</p>
+
+<p>The optional argument <em>int-timeout</em> can specify a value in milliseconds.
+If no data is available from the host after the specified timeout, <tt>get-url</tt> 
+returns the string <tt>ERR: timeout</tt>. When other error conditions occur, 
+<tt>get-url</tt> returns a string starting with <tt>ERR:</tt> and the description 
+of the error.</p>
+
+<p><tt>get-url</tt> handles redirection if it detects a <tt>Location:</tt> spec 
+in the received header and automatically does a second request.
+<tt>get-url</tt> also understands the <tt>Transfer-Encoding: chunked</tt> 
+format and will unpack data into an unchunked format.</p>
+
+<p><tt>get-url</tt> requests are also understood by newLISP server nodes.
+</p>
+
+<!-- example -->
+
+<pre>
+(get-url "http://www.nuevatec.com")
+(get-url "http://www.nuevatec.com" 3000)
+(get-url "http://www.nuevatec.com" "header")
+(get-url "http://www.nuevatec.com" "header" 5000)
+(get-url "http://www.nuevatec.com" "list")
+
+(get-url "file:///home/db/data.txt") ; access local file system
+
+(env "HTTP_PROXY" "http://ourproxy:8080")
+(get-url "http://www.nuevatec.com/newlisp/")
+</pre>
+
+
+<p>
+The index page from the site specified 
+in <em>str-url</em> is returned as a string.
+In the third line, 
+only the HTTP header 
+is returned in a string. 
+Lines 2 and 4 show a 
+timeout value being used.
+</p>
+
+<p> The second example shows usage of a <tt>file://</tt> URL
+to access <tt>/home/db/data.txt</tt> on the local file system.</p>
+
+<p>
+The third example illustrates 
+the use of a proxy server. 
+The proxy server's URL must be 
+in the operating system's environment. 
+As shown in the example, 
+this can be added using 
+the <a href="#env">env</a> 
+function.
+</p>
+
+<p>
+The <em>int-timeout</em> can be followed 
+by an optional custom header in <em>str-header</em>:
+</p>
+
+<h3>Custom header</h3>
+
+<p>The custom header may contain options 
+for browser cookies or other directives to the server. 
+When no <em>str-header</em> is specified, 
+newLISP sends certain header information by default. 
+After the following request:
+</p>
+
+
+<pre>
+(get-url "http://somehost.com" 5000)
+</pre>
+
+
+<p>
+newLISP will configure and send 
+the request and header below:
+</p>
+
+
+<pre>
+GET / HTTP/1.1        
+Host: somehost.com
+User-Agent: newLISP v10603
+Connection: close
+</pre>
+
+
+<p>
+As an alternative, the <em>str-header</em> 
+option could be used:
+</p>
+
+
+<pre>
+(get-url "http://somehost.com" 5000 
+"User-Agent: Mozilla/4.0\r\nCookie: name=fred\r\n")
+</pre>
+
+
+<p>
+newLISP will now send the 
+following request and header:
+</p>
+
+
+<pre>
+GET / HTTP/1.1        
+Host: somehost.com
+User-Agent: Mozilla/4.o
+Cookie: name=fred
+Connection: close
+</pre>
+
+
+<p>
+Note that when using a custom header, 
+newLISP will only supply the <tt>GET</tt> request line, 
+as well as the <tt>Host:</tt> and <tt>Connection:</tt> header entries. 
+newLISP inserts all other entries supplied in the custom header 
+between the <tt>Host:</tt> and <tt>Connection:</tt> entries. 
+Each entry must end with a carriage return 
+line-feed pair: <tt>\r\n</tt>.
+
+</p>
+
+<p>
+See an HTTP transactions reference 
+for valid header entries.
+</p>
+
+<p>
+Custom headers can also be used 
+in the <a href="#put-url">put-url</a> 
+and <a href="#post-url">post-url</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="global"></a>
+<h2><span class="function">global</span></h2>
+
+<h4>syntax: (global <em>sym-1</em> [<em>sym-2</em> ... ])</h4>
+
+<p>
+One or more symbols in <em>sym-1</em> [<em>sym-2</em> ... ] 
+can be made globally accessible from contexts other than MAIN. 
+The statement has to be executed in the MAIN context, 
+and only symbols belonging to MAIN can be made global. 
+<tt>global</tt> returns the last symbol made global.
+</p>
+
+<!-- example -->
+
+<pre>
+(global 'aVar 'x 'y 'z)  <span class='arw'>&rarr;</span> z
+
+(define (foo x) 
+(&hellip;))
+
+(constant (global 'foo))
+</pre>
+
+
+<p>
+The second example shows how <a href="#constant">constant</a> 
+and <tt>global</tt> can be combined into one statement, 
+protecting and making a previous function definition global.
+</p>
+
+<br/><br/>
+
+<a name="globalp"></a>
+<h2><span class="function">global?</span></h2>
+
+<h4>syntax: (global? <em>sym</em>)</h4>
+
+<p>Checks if symbol in <em>sym</em> is global. Built-in functions, context
+symbols, and all symbols made global using the function <a href="#global">global</a>
+are global:</p>
+
+<!-- example -->
+
+<pre>
+global? 'print)   <span class='arw'>&rarr;</span> true
+(global 'var)     <span class='arw'>&rarr;</span> var
+(global? 'var)    <span class='arw'>&rarr;</span> true
+
+(constant (global 'foo))
+
+(global? 'foo)    <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="if"></a>
+<h2><span class="function">if</span></h2>
+
+<h4>syntax: (if <em>exp-condition</em> <em>exp-1</em> [<em>exp-2</em>])<br/>
+
+syntax: (if <em>exp-cond-1</em> <em>exp-1</em>  <em>exp-cond-2</em> <em>exp-2</em> [ ... ])</h4>
+
+<p>If the value of <em>exp-condition</em> is neither <tt>nil</tt> nor an empty list, 
+the result of evaluating <em>exp-1</em> is returned; otherwise, the value of 
+<em>exp-2</em> is returned.  If <em>exp-2</em> is absent, the value of 
+<em>exp-condition</em> is returned.</p>
+
+<p><tt>if</tt> also sets the anaphoric system variable <tt>$it</tt> to the value
+of the conditional expression in <tt>if</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 50)                   <span class='arw'>&rarr;</span> 50
+(if (&lt; x 100) "small" "big")  <span class='arw'>&rarr;</span> "small"
+(set 'x 1000)                 <span class='arw'>&rarr;</span> 1000
+(if (&lt; x 100) "small" "big")  <span class='arw'>&rarr;</span> "big"
+(if (&gt; x 2000) "big")         <span class='arw'>&rarr;</span> nil
+
+; more than one statement in the true or false
+; part must be blocked with (begin ...)
+(if (= x y)
+(begin
+(some-func x)
+(some-func y))
+(begin
+(do-this x y)
+(do-that x y))
+)
+
+; if also sets the anaphoric system variable $it
+(set 'lst '(A B C))
+(if lst (println (last $it)))  <span class='arw'>&rarr;</span> C
+</pre>
+
+
+<p>
+The second form of <tt>if</tt> works similarly 
+to <a href="#cond">cond</a>, except it does not take 
+parentheses around the condition-body pair of expressions. 
+In this form, <tt>if</tt> can have 
+an unlimited number of arguments.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (classify x)
+(if
+(&lt; x 0) "negative"
+(&lt; x 10) "small"
+(&lt; x 20) "medium"
+(&gt;= x 30) "big"
+"n/a"))
+
+(classify 15)   <span class='arw'>&rarr;</span> "medium"
+(classify 100)  <span class='arw'>&rarr;</span> "big"
+(classify 22)   <span class='arw'>&rarr;</span> "n/a"
+(classify -10)  <span class='arw'>&rarr;</span> "negative"
+</pre>
+
+
+<p>The last expression, <tt>"n/a"</tt>, is optional. When this option 
+is omitted, the evaluation of <tt>(&gt;= x 30)</tt> is returned, behaving 
+exactly like a traditional <a href="#cond">cond</a> but without requiring 
+parentheses around the condition-expression pairs.</p>
+
+<p> In any case, the whole <tt>if</tt> expression 
+always returns the last expression or condition evaluated.</p>
+
+<p>
+See also the <a href="#when">when</a> and <a href="#unless">unless</a> functions.
+</p>
+
+<br/><br/>
+
+<!--
+<a name="if-not"></a>
+<h2><span class="function">if-not</span></h2>
+<h4>syntax: (if-not <em>exp-condition</em> <em>exp-1</em> [<em>exp-2</em>])</h4>
+
+<p>
+<tt>if-not</tt> is equivalent to (<a href="#if">if</a> (<a href="#not">not</a> 
+<em>exp-condition</em> <em>exp-1</em> [<em>exp-2</em>])).
+If the value of <em>exp-condition</em> is <tt>nil</tt> 
+or the empty list <tt>()</tt>, <em>exp-1</em> is evaluated;
+otherwise, the optional <em>exp-2</em> is evaluated.
+</p>	
+
+<p>Contrary to the <a href="#if">if</a> function, <tt>if-not</tt> does
+not permit multiple consequent and alternative clauses.</p>
+
+<pre>
+(set 'x 50)                       <span class='arw'>&rarr;</span> 50 
+(if-not (&lt; x 100) "big" "small")  <span class='arw'>&rarr;</span> "small"
+(set 'x 1000)                     <span class='arw'>&rarr;</span> 1000 
+(if-not (&lt; x 100) "big" "small")  <span class='arw'>&rarr;</span> "big" 
+</pre>
+
+<br/><br/>
+-->
+
+<a name="ifft"></a>
+<h2><span class="function">ifft</span></h2>
+<h4>syntax: (ifft <em>list-num</em>)</h4>
+
+<p>
+Calculates the inverse discrete Fourier transform 
+on a list of complex numbers in <em>list-num</em> 
+using the FFT method (Fast Fourier Transform). 
+Each complex number is specified by its real part, 
+followed by its imaginary part. 
+In case only real numbers are used, 
+the imaginary part is set to <tt>0.0</tt> (zero). 
+When the number of elements in <em>list-num</em> 
+is not an integer power of 2, 
+<tt>ifft</tt> increases the number of elements 
+by padding the list with zeroes. 
+When complex numbers are <tt>0</tt> in the imaginary part, 
+simple numbers can be used.
+</p>
+
+<!-- example -->
+
+<pre>
+(ifft (fft '((1 0) (2 0) (3 0) (4 0)))) 
+<span class='arw'>&rarr;</span> ((1 0) (2 0) (3 0) (4 0))
+
+;; when imaginary part is 0, plain numbers work too
+
+(ifft (fft '(1 2 3 4))) 
+<span class='arw'>&rarr;</span> ((1 0) (2 0) (3 0) (4 0))
+</pre>
+
+
+<p>
+The inverse operation of <tt>ifft</tt> 
+is the <a href="#fft">fft</a> function.
+</p>
+
+<br/><br/>
+
+<a name="import"></a>
+<h2><span class="function">import</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2>
+<h4>syntax: (import <em>str-lib-name</em> <em>str-function-name</em> ["cdecl"])<br/>
+syntax: (import <em>str-lib-name</em> <em>str-function-name</em> <em>str-return-type</em> [<em>str-param-type</em> . . .])<br/>
+syntax: (import <em>str-lib-name</em>)</h4>
+
+<p>Imports the function specified in <em>str-function-name</em> 
+from a shared library named in <em>str-lib-name</em>. Depending on the syntax used, string 
+labels for return and parameter types can be specified</p>
+
+<p>If the library in <em>str-lib-name</em> is not in the system's library path, the
+full path name should be specified.</p>
+
+<p>A function can be imported only once. A repeated import of the same function
+will simply return the same - already allocated - function address.</p>
+
+<p>Note, that the first simple syntax is available on <u>all</u> versions of newLISP, even those compiled without <em>libffi</em> support. On <em>libffi</em> enabled versions - capable of the second extended syntax -
+imported symbols are protected against change and can only be modified using
+<a href="#constant">constant</a>.</p>
+
+<p>The third syntax - on OSX, Linux and other Unix only -  allows pre-loading libraries 
+without importing functions. This is necessary when other library imports need access 
+internally to other functions from pre-loaded libraries.</p>
+
+<p>Incorrectly using <tt>import</tt> can cause a system bus error or a segfault can occur 
+and crash newLISP or leave it in an unstable state.</p>
+
+<h3>The simple <tt>import</tt> syntax</h3>
+<p>Most library functions can be imported using the simpler first syntax. 
+This form is present on <u>all</u> compile flavors of newLISP. The API expects
+all function arguments to be passed on the stack in either <em>cdecl</em> or <em>stdcall</em> 
+conventions. On 32-bit platforms, integers, pointers to strings and buffers sometimes floating 
+point values can be passed as parameters. On 64-bit platforms only 
+integers  can be passed but no floating point values. 
+As return values only 32-bit or 64-bit values and pointers are allowed. 
+No floating point numbers can be returned. Strings must be retrieved with the
+<a href="#get-string">get-string</a> helper function. Regardless of these 
+limitations, most  modules included in the distribution use 
+this simple import API.</p>
+
+<p>If pointers are returned to strings or structures the following helper functions
+can be used extract data:
+<a href="#get-char">get-char</a>, 
+<a href="#get-int">get-int</a>, 
+<a href="#get-float">get-float</a>, 
+<a href="#get-string">get-string</a>, 
+<a href="#unpack">unpack</a> </p>
+
+<p>To pass pointers for data structures the following functions help to pack data
+and calculate addresses:
+<a href="#address">address</a>, 
+<a href="#pack">pack</a>.</p>
+
+<p>To transform newLISP data types into the data types needed by the 
+imported function, use the functions 
+<a href="#float">float</a> for 64-bit double floats, 
+<a href="#flt">flt</a> for 32-bit floats, 
+and <a href="#int">int</a> for 32-bit integers. 
+By default, newLISP passes floating point numbers as 64-bit double floats, 
+integers as 32-bit integers, and strings as 32-bit integers for string 
+addresses (pointers in C). Floats can only be used with 32-bit versions
+of newLISP and libraries. To use floating point numbers in a 64-bit
+environment use the <a href="#extended_import">extended <tt>import</tt> syntax</a>. 
+</p>
+
+<!-- example -->
+
+<pre>
+;; define LIBC platform independent
+
+(define LIBC (lookup ostype '(
+("Windows" "msvcrt.dll")
+("OSX" "libc.dylib")
+
+(printf "%g %s %d %c\n" 1.23 "hello" 999 65)
+<b>1.23 hello 999 A</b>
+<span class='arw'>&rarr;</span> 17 ; return value
+
+;; import MS Windows DLLs in 32-bit versions 
+
+(import "kernel32.dll" "GetTickCount")  <span class='arw'>&rarr;</span> GetTickCount
+(import "user32.dll" "MessageBoxA")     <span class='arw'>&rarr;</span> MessageBoxA
+(GetTickCount)                          <span class='arw'>&rarr;</span> 3328896
+</pre>
+
+<p>In the first example, the string "1.23 hello 999 A" 
+is printed as a side effect, and the value 17 (number of 
+characters printed) is returned. Any C function can be imported 
+from any shared library in this way.
+</p>
+
+<p>The message box example pops up a Windows dialog box, which may be hidden 
+behind the console window.  The console prompt does not return until the 
+'OK' button is pressed in the message box.</p>
+
+<pre>
+;;this pops up a message box
+
+(MessageBoxA 0 "This is the body" "Caption" 1) 
+</pre>
+
+<p>The other examples show several imports of MS Windows DLL functions and 
+the details of passing values <em>by value</em> or <em>by reference</em>. 
+Whenever strings or numbers are passed by reference, space must be 
+reserved beforehand.</p>
+
+
+<pre>
+(import "kernel32.dll" "GetWindowsDirectoryA")
+
+;; allocating space for a string return value
+(set 'str (dup "\000" 64))  ; reserve space and initialize
+
+(GetWindowsDirectoryA str (length str))
+
+str  <span class='arw'>&rarr;</span> "C:\\WINDOWS\000\000\000 ... "
+
+;; use trim or get-string to cut of trailing binary zeros
+(get-string str)  <span class='arw'>&rarr;</span> "C:\\WINDOWS"
+(trim str)        <span class='arw'>&rarr;</span> "C:\\WINDOWS"
+
+(import "kernel32.dll" "GetComputerNameA")
+
+;; allocate memory and initialize to zeros
+(set 'str (dup "\000" 64))
+(set 'len (length str)
+
+;; call the function
+;; the length of the string is passed as address reference 
+;; string str is automatically past by address (C pointer)
+(GetComputerNameA str (address len)) 
+
+str  <span class='arw'>&rarr;</span> "LUTZ-PC\000\000 ... "
+
+(trim str)  <span class='arw'>&rarr;</span> "LUTZ-PC"
+</pre>
+
+<p><tt>import</tt> returns the address of the function, which can be 
+used to assign a different name to the imported function.</p>
+
+<pre>
+(set 'imprime (import "libc.so.6" "printf")) 
+<span class='arw'>&rarr;</span> printf@400862A0
+
+(imprime "%s %d" "hola" 123)                 
+<span class='arw'>&rarr;</span> "hola 123"
+</pre>
+
+<p>The MS Windows and Cygwin versions of newLISP uses standard call <em>stdcall</em> conventions 
+to call DLL library routines by default.  This is necessary for calling DLLs that belong 
+to the MS Windows operating system.  Most third-party DLLs are compiled for 
+C declaration <em>cdecl</em> calling conventions and may need to specify the string 
+<tt>"cdecl"</tt> as an additional last argument when importing functions. 
+newLISP compiled for Mac OS X, Linux and other Unix systems uses the 
+<em>cdecl</em> calling conventions by default and ignores any additional string.</p>
+
+<pre>
+;; force cdecl calling conventions on MS Windows
+(import "sqlite.dll" "sqlite_open" "cdecl")  <span class='arw'>&rarr;</span> sqlite_open &lt;673D4888&gt;
+</pre>
+
+<p>Imported functions may take up to fourteen arguments. Note that 
+floating point arguments take up two spaces each
+(e.g., passing five floats takes up ten of the fourteen parameters).
+</p>
+
+<a name="extended_syntax"></a>
+<a name="extended_import"></a>
+<h3>The extended <tt>import</tt> syntax</h3>
+
+<p>The extended import API works with the second syntax. It is based on the popular 
+<tt>libffi</tt> library which is pre-installed on most OS platforms. The startup banner
+of newLISP should show the word <tt>libffi</tt> indicating the running version
+of newLISP is compiled to use the extended <tt>import</tt> API. The function
+<a href="#sys-info">sys-info</a> can also be used to check for <tt>libffi</tt>-support.</p>
+
+<p>The API works with all atomic C data types for passed parameters and return values. 
+The extended API requires that parameter types are specified in the <tt>import</tt> 
+statement as string type labels. Programs written with extended import API will run 
+without change on 32-bit and 64-bit newLISP and libraries. Integers, floating point 
+values and strings can be returned without using helper functions.</p>
+
+<p>The following types can be specified for the return value in <em>str-return-type</em>
+and for function parameters in <em>str-param-type</em>:</p>
+
+<table summary="data types">
+<tr align="left"><th>label</th><th>C type for return value and arguments</th><th>newLISP return and argument type</th></tr>
+<tr><td>"void"</td><td>void</td><td><tt>nil</tt> is returned for return type</td></tr>
+<tr><td>"byte"</td><td>byte unsigned 8 bit</td><td>integer</td></tr>
+<tr><td>"char"</td><td>char signed 8 bit</td><td>integer</td></tr>
+<tr><td>"unsigned short int"</td><td>unsigned short int 16 bit</td><td>integer</td></tr>
+<tr><td>"short int"</td><td>short int signed 16 bit</td><td>integer</td></tr>
+<tr><td>"unsigned int"</td><td>unsigned int 32 bit</td><td>integer</td></tr>
+<tr><td>"int"</td><td>int signed 32 bit</td><td>integer</td></tr>
+<tr><td>"long"</td><td>long signed 32 or 64 bit depending on platform</td><td>integer</td></tr>
+<tr><td>"long long"</td><td>long long signed 64 bit</td><td>integer</td></tr>
+<tr><td>"float"</td><td>float 32 bit</td><td>IEEE-754 64 bit float cut to 32-bit precision</td></tr>
+<tr><td>"double"</td><td>double 64 bit</td><td>IEEE-754 64 bit float</td></tr>
+<tr><td>"char*"</td><td>char* 32 or 64 bit ptr depending on platform</td><td>displayable string return (zero terminated)<br/>string buffer arg (no addr. since 10.4.2)</td></tr>
+<tr><td>"void*"</td><td>void* 32 or 64 bit ptr depending on platform</td><td>integer address return<br/>either string buffer or integer address arg</td></tr>
+</table>
+
+<p>The types <tt>"char*"</tt> and <tt>"void*</tt> can be interchanged and are treated 
+identical inside <tt>libffi</tt>. Depending on the type of arguments passed and the type
+of return values, one or the other is used.</p>
+
+<p>Aggregate types can be composed using the <a href="#struct">struct</a> function and 
+can be used for arguments and return values.</p>
+
+<p>The following examples show how the extended <tt>import</tt> syntax can
+handle return values of floating point values and strings:</p>
+
+<pre>
+;; return a float value, LIBC was defined earlier
+;             name   return   arg
+(import LIBC "atof" "double" "char*")
+(atof "3.141") <span class='arw'>&rarr;</span> 3.141
+
+;; return a copied string
+;             name     return  arg-1   arg-2
+(import LIBC "strcpy" "char*" "char*" "char*")
+(set 'from "Hello World")
+
+(set 'to (dup "\000" (length from))) ; reserve memory
+(strcpy to from) <span class='arw'>&rarr;</span> "Hello World"
+</pre>
+
+<p>The <tt>char*</tt> type takes a string buffer only. The <tt>"void*</tt> type can take either
+a string buffer or a memory address number as input. When using <tt>"void*"</tt>
+as a return type the address number of the result buffer will be returned. This is
+useful when returning pointers to data structures. These pointers can then
+be used with <a href="#unpack">unpack</a> and <a href="#struct">struct</a> for destructuring. 
+In the following example the return type is changed to <tt>void*</tt>:</p>
+
+<pre>
+(import LIBC "strcpy" "void*" "char*" "char*")
+(set 'from "Hello World")
+(set 'to (dup "\000" (length from)))
+
+(strcpy to from)       <span class='arw'>&rarr;</span> 2449424
+(address to)           <span class='arw'>&rarr;</span> 2449424
+(unpack "s11" 2449424) <span class='arw'>&rarr;</span> "Hello World"
+(get-string 2449424)   <span class='arw'>&rarr;</span> "Hello World"
+to                     <span class='arw'>&rarr;</span> "Hello World"
+</pre>
+
+<p>A newLISP string is always passed by it's address reference.</p>
+
+
+<p>For a more complex example see this
+<a href="http://www.newlisp.org/syntax.cgi?code/opengl-demo-ffi-lsp.txt">OpenGL demo</a>.</p>
+
+<h3>Memory management</h3>
+
+<p>Any allocation performed by imported foreign functions has to be 
+de-allocated manually if there's no call in the imported API to do so.
+See the <a href="http://www.newlisp.org/CodePatterns.html">Code Patterns in newLISP</a>
+document for an example.</p>
+
+<p>In case of calling foreign functions with passing by reference, 
+memory for variables needs to be allocated beforehand by newLISP
+&mdash; see import of <tt>GetWindowsDirectoryA</tt> above &mdash; 
+and hence, memory needs not be deallocated manually, because it is
+managed automatically by newLISP.</p>
+
+<br/><br/>
+
+<a name="inc"></a>
+<h2><span class="function">inc</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (inc <em>place</em> [<em>num</em>])</h4>
+
+<p>
+Increments the number in <em>place</em> by <tt>1.0</tt> or by the optional 
+number <em>num</em> and returns the result. <tt>inc</tt> performs float 
+arithmetic and converts integer numbers passed into floating point type.</p>
+
+<p><em>place</em> is either a symbol or a place in a list structure holding a
+number, or a number returned by an expression.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 0)    <span class='arw'>&rarr;</span> 0
+(inc x)       <span class='arw'>&rarr;</span> 1
+x             <span class='arw'>&rarr;</span> 1
+(inc x 0.25)  <span class='arw'>&rarr;</span> 1.25
+x             <span class='arw'>&rarr;</span> 1.25
+(inc x)       <span class='arw'>&rarr;</span> 2.25
+</pre>
+
+
+<p>If a symbol  for <em>place</em> contains <tt>nil</tt>, it is treated
+as if containing  <tt>0.0</tt>:</p>
+
+
+<pre>
+z             <span class='arw'>&rarr;</span> nil
+(inc z)       <span class='arw'>&rarr;</span> 1
+
+(set 'z nil)
+(inc z 0.01)  <span class='arw'>&rarr;</span> 0.01
+</pre>
+
+
+<p>Places in a list structure or a number returned by another expression
+can be updated too:</p>
+
+
+<pre>
+(set 'l '(1 2 3 4))
+
+(inc (l 3) 0.1) <span class='arw'>&rarr;</span> 4.1
+
+(inc (first l)) <span class='arw'>&rarr;</span> 2
+
+l <span class='arw'>&rarr;</span> (2 2 3 4.1)
+
+(inc (+ 3 4)) <span class='arw'>&rarr;</span> 8
+</pre>
+
+
+<p>Use the <a href="#inci">++</a> function for incrementing numbers in
+integer mode. Use <a href="#dec">dec</a> to decrement numbers in floating point mode.</p>
+
+
+<br/><br/>
+
+<a name="index"></a>
+<h2><span class="function">index</span></h2>
+<h4>syntax: (index <em>exp-predicate</em> <em>exp-list</em>)</h4>
+
+<p>Applies the predicate <em>exp-predicate</em> to each element of the 
+list <em>exp-list</em> and returns a list containing the indices of the elements 
+for which <em>exp-predicate</em> is true.</p>
+
+<!-- example -->
+
+<pre>
+(index symbol? '(1 2 d 4 f g 5 h))  <span class='arw'>&rarr;</span> (2 4 5 7)
+
+(define (big? x) (&gt; x 5))  <span class='arw'>&rarr;</span> (lambda (x) (&gt; x 5))
+
+(index big? '(1 10 3 6 4 5 11))  <span class='arw'>&rarr;</span> (1 3 6)
+
+(select '(1 10 3 6 4 5 11) '(1 3 6)) <span class='arw'>&rarr;</span> (10 6 11) 
+</pre>
+
+
+<p>
+The predicate may be a built-in predicate, 
+a user-defined function, or a lambda expression.
+</p>
+
+<p>
+Use the <a href="#filter">filter</a> function 
+to return the elements themselves.
+</p>
+
+<br/><br/>
+
+<a name="infp"></a>
+<h2><span class="function">inf?</span></h2>
+<h4>syntax: (inf? <em>float</em>)</h4>
+
+<p>If the value in <em>float</em> is infinite the function returns
+<tt>true</tt> else <tt>nil</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(inf? (div 1 0)) <span class='arw'>&rarr;</span> true
+
+(div 0 0) <span class='arw'>&rarr;</span> NaN
+</pre>
+
+
+<p>Note that an integer division by zero e.g. <tt>(/ 1 0)</tt> will
+throw an "division by zero" error and not yield infinity. See also
+<a href="#NaNp">NaN?</a> to check if a floating point number is valid.</p>
+
+<br/><br/>
+
+<a name="int"></a>
+<h2><span class="function">int</span></h2>
+
+<h4>syntax: (int <em>exp</em> [<em>exp-default</em> [<em>int-base</em>]])</h4>
+
+<p>
+If the expression in <em>exp</em> evaluates to a number or a string, the result 
+is converted to an integer and returned.  If <em>exp</em> cannot be converted 
+to an integer, then <tt>nil</tt> or the evaluation of <em>exp-default</em> will 
+be returned.  This function is mostly used when translating strings from user 
+input or from parsing text. If <em>exp</em> evaluates to a string, the string 
+must start with a digit; one or more spaces; or the <tt>+</tt> or <tt>-</tt> sign.
+The string must begin with '<tt>0x</tt>' for hexadecimal strings or '<tt>0</tt>' 
+(zero) for octal strings.  If <em>exp</em> is invalid, <tt>int</tt> returns 
+<tt>nil</tt> as a default value if not otherwise specified.
+</p>
+
+<p>A second optional parameter can be used to force the number base 
+of conversion to a specific value.</p>
+
+<p>Integers larger than 9,223,372,036,854,775,807 are truncated to 
+9,223,372,036,854,775,807.  Integers smaller than -9,223,372,036,854,775,808 
+are truncated to -9,223,372,036,854,775,808.</p>
+
+<p>When converting from a float (as in the second form of <tt>int</tt>), 
+floating point values larger or smaller than the integer maximum or minimum 
+are also truncated. A floating point expression evaluating to <tt>NaN</tt> 
+is converted to <tt>0</tt> (zero).</p>
+
+
+<!-- example -->
+
+<pre>
+(int "123")          <span class='arw'>&rarr;</span> 123
+(int " 123")         <span class='arw'>&rarr;</span> 123
+(int "a123" 0)       <span class='arw'>&rarr;</span> 0
+(int (trim " 123"))  <span class='arw'>&rarr;</span> 123
+(int "0xFF")         <span class='arw'>&rarr;</span> 255
+(int "0b11111")      <span class='arw'>&rarr;</span> 31
+(int "055")          <span class='arw'>&rarr;</span> 45
+(int "1.567")        <span class='arw'>&rarr;</span> 1
+(int 1.567)          <span class='arw'>&rarr;</span> 1
+
+(integer? 1.00)        <span class='arw'>&rarr;</span> nil
+(integer? (int 1.00))  <span class='arw'>&rarr;</span> true
+
+(int "1111" 0 2)  <span class='arw'>&rarr;</span> 15   ; base 2 conversion
+(int "0FF" 0 16)  <span class='arw'>&rarr;</span> 255  ; base 16 conversion
+
+(int 'xyz)     <span class='arw'>&rarr;</span> nil
+(int 'xyz 0)   <span class='arw'>&rarr;</span> 0
+(int nil 123)  <span class='arw'>&rarr;</span> 123
+
+(int "abc" (throw-error "not a number"))  
+<span class='arw'>&rarr;</span> <span class='err'>ERR: user error : not a number</span>
+
+(print "Enter a num:")
+(set 'num (int (read-line)))
+
+(int (bits 12345) 0 2) <span class='arw'>&rarr;</span> 12345
+</pre>
+
+
+<p>The inverse function to <tt>int</tt> with base <tt>2</tt> is
+<a href="#bits">bits</a>.</p>
+
+<p>Use the <a href="#float">float</a> function 
+to convert arguments to floating point numbers.</p>
+
+<br/><br/>
+
+<a name="integerp"></a>
+<h2><span class="function">integer?</span></h2>
+<h4>syntax: (integer? <em>exp</em>)</h4>
+
+<p>
+Returns <tt>true</tt> only if the value 
+of <em>exp</em> is an integer; 
+otherwise, it returns <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'num 123)  <span class='arw'>&rarr;</span> 123
+(integer? num)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="intersect"></a>
+<h2><span class="function">intersect</span></h2>
+<h4>syntax: (intersect <em>list-A</em> <em>list-B</em>)<br/>
+
+syntax: (intersect <em>list-A</em> <em>list-B</em> <em>bool</em>)</h4>
+
+<p>
+In the first syntax, 
+<tt>intersect</tt> returns a list 
+containing one copy of each element 
+found both in <em>list-A</em> and <em>list-B</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(intersect '(3 0 1 3 2 3 4 2 1) '(1 4 2 5))  
+<span class='arw'>&rarr;</span> (2 4 1)
+</pre>
+
+
+<p>
+In the second syntax, 
+<tt>intersect</tt> returns a list of all elements 
+in <em>list-A</em> that are also in <em>list-B</em>, 
+without eliminating duplicates in <em>list-A</em>. 
+<em>bool</em> is an expression evaluating to <tt>true</tt> 
+or any other value not <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(intersect '(3 0 1 3 2 3 4 2 1) '(1 4 2 5) true)
+<span class='arw'>&rarr;</span> (1 2 4 2 1)
+</pre>
+
+
+<p>
+See also the set functions 
+<a href="#difference">difference</a>, <a href="#unique">unique</a>
+and <a href="#union">union</a>.
+</p>
+
+<br/><br/>
+
+<a name="invert"></a>
+<h2><span class="function">invert</span></h2>
+<h4>syntax: (invert <em>matrix</em> [<em>float-pivot</em>])</h4>
+
+<p>Returns the inversion of a two-dimensional matrix in <em>matrix</em>. 
+The matrix must be square, with the same number 
+of rows and columns, and <em>non-singular</em> (invertible). 
+Matrix inversion can be used to solve systems of linear equations 
+(e.g., multiple regression in statistics).  newLISP uses LU-decomposition of 
+the matrix to find the inverse.</p>
+
+<p>Optionally <tt>0.0</tt> or a very small value can be specified
+in <em>float-pivot</em>. This value substitutes pivot elements in
+the LU-decomposition algorithm, which result in zero when
+the algorithm deals with a singular matrix.</p>
+
+<p>The dimensions of a matrix are defined by the number of rows 
+times the number of elements in the first row.  For missing elements 
+in non-rectangular matrices, <tt>0.0</tt> (zero) is assumed.  
+A matrix can either be a nested list or an <a href="#array">array</a>.
+</p> 
+
+<!-- example -->
+
+<pre>
+(set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+(invert A)  <span class='arw'>&rarr;</span> ((10 2 9) (5 1 4) (6 1 5))
+(invert (invert A)) <span class='arw'>&rarr;</span> ((-1 1 1) (1 4 -5) (1 -2 0))
+
+; solve Ax = b for x
+(multiply (invert A) '((1) (2) (3))) <span class='arw'>&rarr;</span> ((41) (19) (23))
+
+; treatment of singular matrices
+(invert '((2 -1) (4 -2)))        <span class='arw'>&rarr;</span> nil
+(invert '((2 -1) (4 -2)) 0.0)    <span class='arw'>&rarr;</span> ((inf -inf) (inf -inf))
+(invert '((2 -1) (4 -2)) 1e-20)  <span class='arw'>&rarr;</span> ((5e+19 -2.5e+19) (1e+20 -5e+19)) 
+</pre>
+
+<p><tt>invert</tt> will return <tt>nil</tt> if the matrix is <i>singular</i> 
+and cannot be inverted, and <em>float-pivot</em> is not specified. </p>
+
+
+<p>
+All operations shown here on lists 
+can be performed on arrays, as well.
+</p>
+
+<p>
+See also the matrix functions <a href="#det">det</a>,
+<a href="#mat">mat</a>, <a href="#multiply">multiply</a>
+and <a href="#transpose">transpose</a>.
+</p>
+
+<br/><br/>
+
+<a name="irr"></a>
+<h2><span class="function">irr</span></h2>
+<h4>syntax: (irr <em>list-amounts</em> [<em>list-times</em> [<em>num-guess</em>]])</h4>
+
+<p>
+Calculates the internal rate of return 
+of a cash flow per time period. 
+The internal rate of return is the interest rate 
+that makes the present value of a cash flow equal to <tt>0.0</tt> (zero). 
+In-flowing (negative values) and out-flowing (positive values) 
+amounts are specified in  <em>list-amounts</em>. 
+If no time periods are specified in <em>list-times</em>, 
+amounts in <em>list-amounts</em> correspond to 
+consecutive time periods increasing by 1 (1, 2, 3&mdash;). 
+The algorithm used is iterative, 
+with an initial guess of 0.5 (50 percent). 
+Optionally, a different 
+initial guess can be specified. 
+The algorithm returns when a precision 
+of 0.000001 (0.0001 percent) is reached. 
+<tt>nil</tt> is returned if the algorithm 
+cannot converge after 50 iterations.
+</p>
+
+<p>
+<em>irr</em> is often used to decide 
+between different types of investments.
+</p>
+
+<!-- example -->
+
+<pre>
+(irr '(-1000 500 400 300 200 100))  
+<span class='arw'>&rarr;</span> 0.2027
+
+(npv 0.2027 '(500 400 300 200 100)) 
+<span class='arw'>&rarr;</span> 1000.033848 ; ~ 1000
+
+(irr '(-1000 500 400 300 200 100) '(0 3 4 5 6 7)) 
+<span class='arw'>&rarr;</span> 0.0998
+
+(irr '(-5000 -2000 5000 6000) '(0 3 12 18)) 
+<span class='arw'>&rarr;</span> 0.0321
+</pre>
+
+
+<p>
+If an initial investment of 1,000 
+yields 500 after the first year, 
+400 after two years, and so on, 
+finally reaching <tt>0.0</tt> (zero) after five years, 
+then that corresponds to a yearly return 
+of about 20.2 percent. 
+The next line demonstrates the relation 
+between <tt>irr</tt> and <a href="#npv">npv</a>. 
+Only 9.9 percent returns are necessary when making 
+the first withdrawal after three years.
+</p>
+
+<p>
+In the last example, securities 
+were initially purchased for 5,000, 
+then for another 2,000 three months later. 
+After a year, securities for 5,000 are sold. 
+Selling the remaining securities 
+after 18 months renders 6,000. 
+The internal rate of return is 3.2 percent per month, 
+or about 57 percent in 18 months.
+</p>
+
+<p>
+See also the <a href="#fv">fv</a>, 
+<a href="#nper">nper</a>, 
+<a href="#npv">npv</a>, 
+<a href="#pmt">pmt</a>, 
+and <a href="#pv">pv</a> functions.
+</p> 
+
+<br/><br/>
+
+<a name="json-error"></a>
+<h2><span class="function">json-error</span></h2>
+<h4>syntax: (json-error)</h4>
+
+<p>When <a href="#json-parse">json-parse</a> returns <tt>nil</tt> due
+to a failed JSON data translation, this function retrieves an error
+description and the last scan position of the parser.</p>
+
+<pre>
+; failed parse returns nil
+(json-parse [text]{"address" "http://example.com"}[/text]) <span class='arw'>&rarr;</span> nil
+
+; inspect the error information
+(json-error) <span class='arw'>&rarr;</span> ("missing : colon" 11)
+</pre>
+
+<br/><br/>
+
+<a name="json-parse"></a>
+<h2><span class="function">json-parse</span></h2>
+<h4>syntax: (json-parse <em>str-json-data</em>)</h4>
+
+<p>This function parses JSON formatted text and translates it to newLISP S-expressions.
+All data types conforming to the ECMA-262 standard are translated. The JSON values 
+<tt>false</tt> and <tt>null</tt> will be represented by the symbols <tt>false</tt> 
+and <tt>null</tt> in the symbolic newLISP expressions. Arrays in JSON will be represented 
+by lists in newLISP. The resulting lists from JSON object data can be processed using 
+<a href="#assoc">assoc</a>, <a href="#lookup">lookup</a> and <a href="#ref">ref</a>.</p>
+
+<p>For JSON attribute values not recognized or wrong JSON syntax, <tt>json-parse</tt> 
+returns <tt>nil</tt> and <a href="#json-error">json-error</a> can be used to retrieve
+the error text.</p>
+
+<p>The following example shows a nested JSON object from a file <tt>person.json</tt>:</p>
+
+<!-- example -->
+
+<pre>
+{
+"name": "John Smith",
+"age": 32,
+"employed": true,
+"address": {
+"street": "701 First Ave.",
+"city": "Sunnyvale, CA 95125",
+"country": "United States"
+},
+"children": [
+{
+    "name": "Richard",
+    "age": 7
+},
+{
+    "name": "Susan",
+    "age": 4
+},
+{
+    "name": "James",
+    "age": 3
+}
+]
+}
+</pre>
+<p>The file is read, parsed and the resulting S-expression stored in <tt>jsp</tt>:</p>
+
+<pre>
+(set 'jsp (json-parse (read-file "person.json")))
+<span class='arw'>&rarr;</span>
+( ("name" "John Smith") 
+("age" 32) 
+("employed" true) 
+("address" ( ("street" "701 First Ave.") 
+       ("city" "Sunnyvale, CA 95125") 
+       ("country" "United States")) ) 
+("children" (
+(("name" "Richard") ("age" 7)) 
+(("name" "Susan") ("age" 4)) 
+(("name" "James") ("age" 3))) )
+)
+</pre>
+
+<p>Data can be extracted using <a href="#assoc">assoc</a>, <a href="#lookup">lookup</a> 
+or <a href="#ref">ref</a>:</p>
+
+<pre>
+; the address
+(lookup "address" jsp)
+<span class='arw'>&rarr;</span> (("street" "701 First Ave.") ("city" "Sunnyvale, CA 95125") ("country" "United States"))
+
+; the city of the address
+(lookup "city" (lookup "address" jsp)) 
+<span class='arw'>&rarr;</span> "Sunnyvale, CA 95125"
+
+; a child named Susan
+(ref '(( * "Susan") *) jsp match true) 
+<span class='arw'>&rarr;</span> (("name" "Susan") ("age" 4))
+
+; all names
+(map last (ref-all '("name" *) jsp match true)) 
+<span class='arw'>&rarr;</span> ("John Smith" "Richard" "Susan" "James")
+
+; only names of children
+(map last (ref-all '("name" *) (lookup "children" jsp) match true))
+<span class='arw'>&rarr;</span>
+("Richard" "Susan" "James")
+
+; names of children other method
+(map last (map first (lookup "children" jsp)))
+<span class='arw'>&rarr;</span>
+("Richard" "Susan" "James")
+</pre>
+
+<p>Although most of the time JSON object types are parsed, all JSON data
+types can be parsed directly, without occurring as part of a JSON object.
+The following examples show parsing of a JSON array:</p>
+
+<pre>
+; parse a JSON array data type
+
+(json-parse "[1, 2, 3, 4, 5]") <span class='arw'>&rarr;</span> (1 2 3 4 5)
+</pre>
+
+<p>When the UTF-8 capable version of newLISP is used, JSON formatted Unicode
+gets translated into UTF-8:</p>
+
+<pre>
+; parse a JSON object data type ands Unicode
+; the outer {,} are newLISP string delimiters [text],[/text] tags could also be used
+; the inner {,} are JSON object delimiters
+
+(json-parse { {"greek letters" : "\u03b1\u03b2\u03b3\u03b4"} }) <span class='arw'>&rarr;</span> (("greek letters" "ฮฑฮฒฮณฮด"))
+
+; strings longer than 2047 bytes should be delimted with [text], [/text] tags
+
+(json-parse [text]{"greek letters" : "\u03b1\u03b2\u03b3\u03b4"}[/text]) <span class='arw'>&rarr;</span> (("greek letters" "ฮฑฮฒฮณฮด"))
+</pre>
+
+<p>The hex-code representation of Unicoder characters in JSON is the same as can be used in
+UTF-8 enabled newLISP.</p>
+
+<p>Because JSON objects contain <tt>{,},"</tt> characters, quotes should not be used
+to limit JSON data, or all quotes inside the JSON data would need a preceding backslash <tt>\</tt>.
+<tt>{,}</tt> braces can be used as long as braces inside the JSON data are balanced.
+The safest delimiter are <tt>[text], [/text]</tt> tags &mdash; they suppress all special processing
+of the string when read by newLISP and are suitable to delimit large data sizes greater
+2047 bytes.</p>
+
+<br/><br/>
+
+<a name="join"></a>
+<h2><span class="function">join</span></h2>
+<h4>syntax: (join <em>list-of-strings</em> [<em>str-joint</em> [<em>bool-trail-joint</em>]])</h4>
+
+<p>
+Concatenates the given   
+list of strings 
+in <em>list-of-strings</em>. 
+If <em>str-joint</em> is present, 
+it is inserted between each string in the join.
+If <em>bool-trail-joint</em> is <tt>true</tt>
+then a joint string is also appended to the last string.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'lst '("this" "is" "a" "sentence"))
+
+(join lst " ")  <span class='arw'>&rarr;</span> "this is a sentence"
+
+(join (map string (slice (now) 0 3)) "-")  <span class='arw'>&rarr;</span> "2003-11-26"
+
+(join (explode "keep it together"))  <span class='arw'>&rarr;</span> "keep it together"
+
+(join '("A" "B" "C") "-")         <span class='arw'>&rarr;</span> "A-B-C"
+(join '("A" "B" "C") "-" true)    <span class='arw'>&rarr;</span> "A-B-C-"
+</pre>
+
+
+<p>
+See also the <a href="#append">append</a>, 
+<a href="#string">string</a>, 
+and <a href="#explode">explode</a> functions, 
+which are the inverse of the <tt>join</tt> operation.
+</p>
+
+<br/><br/>
+
+<a name="kmeans-query"></a>
+<h2><span class="function">kmeans-query</span></h2>
+<h4>syntax: (kmeans-query <em>list-data</em> <em>matrix-centroids</em>)<br/>
+syntax: (kmeans-query <em>list-data</em> <em>matrix-data)</em></h4>
+
+<p>In the first usage, <tt>kmeans-query</tt> calculates the Euclidian distances
+from the data vector given in <em>list-data</em> to the centroids given in
+<em>matrix-centroids</em>. The data vector in <em>list-data</em> has <i>m</i> 
+elements. The 2-dimensional list in <em>matrix-centroids</em>, result from a previous
+<a href="#kmeans-train">kmeans-train</a> clustering, has <i>k</i> rows and <i>m</i> 
+columns for <i>k</i> centroids measuring <i>m</i> features.</p>
+
+<pre>
+; centroids from previous kmeans-train
+K:centroids <span class='arw'>&rarr;</span>
+( (6.39 7.188333333 5.935) 
+(7.925714286 3.845714286 9.198571429) 
+(2.207142857 2.881428571 0.8885714286) )
+
+(kmeans-query '(1 2 3) K:centroids) <span class='arw'>&rarr;</span>
+(8.036487279 9.475994267 2.58693657) ; distances to cluster 1, 2 and 3
+</pre>
+
+<p>The data record <tt>(1 2 3)</tt> shows the smallest distance to the 3rd
+cluster centroid and would be classified as belonging to that cluster.</p>
+
+<p>In the second application <tt>kmeans-query</tt> calculates Euclidian distances to a list
+of other data points which are not centroids. The following example
+calculates distances of the <tt>(1 2 3)</tt> data vector to all original points
+from the original <a href="#kmeans-train">kmeans-train</a> data analysis.</p>
+
+<p>The data in <em>matrix-data</em> can be either a nested list or a 2-dimensional
+array.</p>
+
+<p>This vector could be sorted for a subsequent kNN (k Nearest Neighbor)
+analysis:</p>
+
+<pre>
+(kmeans-query '(1 2 3) data) <span class='arw'>&rarr;</span>
+(10.91671196 3.190626898 9.19723328 3.014415366 9.079763213 
+6.83130295 8.533111976 9.624816881 6.444261013 2.013107051 
+3.186549858 9.475199206 9.32936761 2.874786949 7.084638311 
+10.96221237 10.50080473 3.162419959 2.423674896 9.526436899)
+
+; show distances to members in each cluster
+
+; for cluster labeled 1
+(select (kmeans-query '(1 2 3) data) (K:clusters 0)) <span class='arw'>&rarr;</span> 
+(9.079763213 6.83130295 9.624816881 6.444261013 7.084638311 10.50080473)
+
+; for cluster labeled 2
+(select (kmeans-query '(1 2 3) data) (K:clusters 1)) <span class='arw'>&rarr;</span>
+(10.91671196 9.19723328 8.533111976 9.475199206 9.32936761 10.96221237 9.526436899)
+
+; for cluster labeled 3
+(select (kmeans-query '(1 2 3) data) (K:clusters 2)) <span class='arw'>&rarr;</span>
+(3.190626898 3.014415366 2.013107051 3.186549858 2.874786949 3.162419959 2.423674896)
+</pre>
+
+<p>We see that the smallest distances are shown for the data points in
+the 3rd cluster at offset 2.</p>
+
+<p>If the numbers of elements - features - in records of <em>list-data</em> 
+is different from the number of columns in the data or centroid matrix, 
+then the smaller is taken for calculating the Euclidian distances. This 
+is useful when the last column of the data matrix does not contain feature 
+data, but labels identifying the cluster membership of a data point.</p>
+
+<br/><br/>
+
+<a name="kmeans-train"></a>
+<h2><span class="function">kmeans-train</span></h2>
+<h4>syntax: (kmeans-train <em>matrix-data</em> <em>int-k</em> <em>context</em> [<em>matrix-centroids</em>])</h4>
+
+<p>The function performs Kmeans cluster analysis on <em>matrix-data</em>. 
+All <i>n</i> data records in <em>matrix-data</em> are partitioned into a number 
+of <em>int-k</em> different groups. </p>
+
+<p>Both, the <i>n * m</i> <em>matrix-data</em> and the optional <i>k * m</i>
+<em>matrix-centroids</em> can be either nested lists or 2-dimensional arrays.</p>
+
+<p>The Kmeans algorithm tries to minimize the sum of squared inner cluster 
+distances (SSQ) from the cluster centroid. With each iteration the centroids get 
+moved closer to their final position. On some data sets, the end result can depend 
+on the starting centroid points.  The right choice of initial centroids can speed 
+up the process and avoid not wanted local minima.</p>
+
+<p>When no optional <em>matrix-centroids</em> are given, <tt>kmeans-train</tt> will 
+assign an initial random cluster membership to each data row and calculate starting 
+centroids. </p>
+
+<p><tt>kmeans-train</tt> returns a vector of total SSQs, the sum of squared inner distances
+from the centroid inside the cluster for all clusters. The Iterating algorithm stops when the
+change of SSQ from one to the next iteration is less than 1e-10.</p>
+
+<p>Other results of the analysis are stored as lists in variables of <em>context</em>.</p>
+
+<p>The following example analyses 20 data records measuring <i>m = 3</i> features 
+and tries to partition data into <i>k = 3</i> clusters. Other numbers than <i>k = 3</i> 
+could be tried. The target is a result with few clusters of high density measured by the
+average inner cluster distances.</p>
+
+<pre>
+(set 'data '(
+(6.57 4.96 11.91) 
+(2.29 4.18 1.06) 
+(8.63 2.51 8.11) 
+(1.85 1.89 0.11) 
+(7.56 7.93 5.06) 
+(3.61 7.95 5.11) 
+(7.18 3.46 8.7) 
+(8.17 6.59 7.49) 
+(5.44 5.9 5.57) 
+(2.43 2.14 1.59) 
+(2.48 2.26 0.19) 
+(8.16 3.83 8.93) 
+(8.49 5.31 7.47) 
+(3.12 3.1 1.4) 
+(6.77 6.04 3.76) 
+(7.01 4.2 11.9) 
+(6.79 8.72 8.62) 
+(1.17 4.46 1.02) 
+(2.11 2.14 0.85) 
+(9.44 2.65 7.37)))
+
+(kmeans-train data 3 'MAIN:K) <span class='arw'>&rarr;</span> 
+(439.7949357 90.7474276 85.06633163 82.74597619)
+
+; cluster membership
+K:labels <span class='arw'>&rarr;</span> (2 3 2 3 1 1 2 1 1 3 3 2 2 3 1 2 1 3 3 2)
+
+; the centroid for each cluster
+K:centroids <span class='arw'>&rarr;</span>
+( (6.39 7.188333333 5.935) 
+(7.925714286 3.845714286 9.198571429) 
+(2.207142857 2.881428571 0.8885714286) )
+</pre>
+
+<p>The returned list of SSQs shows how in each iteration the sum of inner squared
+distances decreases. The list in <tt>K:labels</tt> shows the membership fo each
+data point in the same order as in the data.</p>
+
+<p>The centroids in <tt>K:centroids</tt> can be used for later classification
+of new data records using <a href="#kmeans-query">kmeans-query</a>. When the
+number of clusters specified in <em>int-k</em> is too big, <tt>kmeans-train</tt>
+will produce unused centroids with <tt>nan</tt> or <tt>NaN</tt> data. When
+unused cluster centroids are present, the number in <em>int-k</em> should be
+reduced. </p>
+
+<p>The average inner <tt>K:deviations</tt> from cluster members to their centroid
+show how dense a cluster is packed. Formally, deviations are calculated similarly
+to Euclidian distances and to standard deviations in conventional statistics. 
+Squaring the deviations and multiplying each with their cluster size 
+(number of members in the cluster) shows the inner SSQ of each cluster:</p>
+
+<pre>
+; average inner deviations of cluster members to the centroid
+; deviation = sqrt(ssq-of-cluster / n-of-cluster)
+K:deviations  <span class='arw'>&rarr;</span> (2.457052209 2.260089397 1.240236975)
+
+; calculating inner SSQs from cluster deviations
+(map mul '(6 7 7) (map mul K:deviations K:deviations)) <span class='arw'>&rarr;</span>
+(36.22263333 35.75602857 10.76731429) ; inner SSQs
+
+; SSQ from last iteration as sum of inner SSQs
+(apply add '(36.22263333 35.75602857 10.76731429)) <span class='arw'>&rarr;</span> 82.74597619
+</pre>
+
+<p><tt>K:clusters</tt> gives indices of data records into the original data
+for each cluster. With these, individual clusters can be extracted from the
+data for further analysis:</p>
+
+<pre>
+; ceach of the result clusters with indices into the data set
+K:clusters <span class='arw'>&rarr;</span> 
+( (4 5 7 8 14 16) 
+(0 2 6 11 12 15 19) 
+(1 3 9 10 13 17 18) )
+
+; cluster of data records labeled 1 at offset 0
+(select data (K:clusters 0)) <span class='arw'>&rarr;</span>
+( (7.56 7.93 5.06) 
+(3.61 7.95 5.11) 
+(8.17 6.59 7.49) 
+(5.44 5.9 5.57) 
+(6.77 6.04 3.76) 
+(6.79 8.72 8.62) )
+
+; cluster of data records labeled 2 at offset 1
+(select data (K:clusters 1)) <span class='arw'>&rarr;</span>
+( (6.57 4.96 11.91) 
+(8.63 2.51 8.11) 
+(7.18 3.46 8.7) 
+(8.16 3.83 8.93) 
+(8.49 5.31 7.47) 
+(7.01 4.2 11.9) 
+(9.44 2.65 7.37) )
+
+; cluster of data records labeled 3 at offset 2
+(select data (K:clusters 2)) <span class='arw'>&rarr;</span>
+( (2.29 4.18 1.06) 
+(1.85 1.89 0.11) 
+(2.43 2.14 1.59) 
+(2.48 2.26 0.19) 
+(3.12 3.1 1.4) 
+(1.17 4.46 1.02) 
+(2.11 2.14 0.85) )
+</pre>
+
+
+<p>In the last example the cluster labels (from 1 to 3) are added
+to the data:</p>
+
+<pre>
+; append a cluster label to each data record
+(set 'labeled-data (transpose (push K:labels (transpose data) -1)))
+
+labeled-data: <span class='arw'>&rarr;</span>
+( (6.57 4.96 11.91 2) 
+(2.29 4.18 1.06 3) 
+(8.63 2.51 8.11 2) 
+(1.85 1.89 0.11 3) 
+(7.56 7.93 5.06 1) 
+(3.61 7.95 5.11 1) 
+... ...
+(2.11 2.14 0.85 3) 
+(9.44 2.65 7.37 2) )
+</pre>
+
+<p>The result context should be prefixed with <tt>MAIN</tt> when code is
+written in a namespace context. If the context does not exists already, it
+will be created.</p>
+
+<p>Results in <tt>K:labels</tt>, <tt>K:clusters</tt>, <tt>K:centroids</tt>
+and <tt>K:deviations</tt> will be overwritten, if already present from previous 
+runs of <tt>kmeans-train</tt>.</p>
+
+<br/><br/>
+
+
+<a name="lambda"></a>
+
+<h2><span class="function">lambda</span></h2>
+
+<p>See the description of <a href="#fn">fn</a>, which is a shorter form of writing <tt>lambda</tt>.</p>
+
+<br/><br/>
+
+<a name="lambda-macro"></a>
+
+<h2><span class="function">lambda-macro</span></h2>
+
+<p>See the description of <a href="#define-macro">define-macro</a>.</p>
+
+<br/><br/>
+
+<a name="lambdap"></a>
+<h2><span class="function">lambda?</span></h2>
+<h4>syntax: (lambda? <em>exp</em>)</h4>
+
+<p>Returns <tt>true</tt> only if the value of <em>exp</em> is a lambda expression;
+otherwise, returns <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (square x) (* x x)) <span class='arw'>&rarr;</span> (lambda (x) (* x x))
+
+square <span class='arw'>&rarr;</span> (lambda (x) (* x x))
+
+(lambda? square)  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>See <a href="#define">define</a> and <a href="#define-macro">define-macro</a> for
+more information about <em>lambda</em> expressions.
+</p>
+<br/><br/>
+
+<a name="last"></a>
+
+<h2><span class="function">last</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (last <em>list</em>)<br/>
+syntax: (last <em>array</em>)<br/>
+syntax: (last <em>str</em>)</h4>
+
+<p>Returns the last element of a list or a string.
+</p>
+
+<!-- example -->
+
+<pre>
+(last '(1 2 3 4 5))  <span class='arw'>&rarr;</span> 5
+(last '(a b (c d)))  <span class='arw'>&rarr;</span> (c d)
+
+(set 'A (array 3 2 (sequence 1 6)))
+<span class='arw'>&rarr;</span> ((1 2) (3 4) (5 6))
+(last A)             <span class='arw'>&rarr;</span> (5 6)
+
+(last '())           <span class='arw'>&rarr;</span> <span class='err'>ERR: list is empty</span>
+</pre>
+
+
+<p>In the second version the last character in the string <em>str</em> is returned as a
+string.
+</p>
+
+<!-- example -->
+
+<pre>
+(last "newLISP")  <span class='arw'>&rarr;</span> "P"
+</pre>
+
+
+<p>
+Note that <a href="#last">last</a> works on character boundaries 
+rather than byte boundaries 
+when the UTF-8&ndash;enabled version of newLISP is used.
+See also <a href="#first">first</a>, <a href="#rest">rest</a> and <a href="#nth">nth</a>.
+</p>
+
+<br/><br/>
+
+<a name="last-error"></a>
+<h2><span class="function">last-error</span></h2>
+<h4>syntax: (last-error)<br/>
+syntax: (last-error <em>int-error</em>)</h4>
+
+<p>Reports the last error generated by newLISP due to syntax errors or exhaustion of 
+some resource. For a summary of all possible errors see the chapter 
+<a href="#error_codes">Error codes</a> in the appendix.</p>
+
+<p>If no error has occurred since the newLISP session was started,
+<tt>nil</tt> is returned.</p>
+
+<p>When <em>int-error</em> is specified, a list of the number and the error 
+text is returned.</p>
+
+<!-- example -->
+
+<pre>
+(last-error)  <span class='arw'>&rarr;</span> nil
+
+(abc)
+
+<span class='err'>ERR: invalid function : (abc)</span>
+
+(last-error) <span class='arw'>&rarr;</span> (24 "ERR: invalid function : (abc)")
+
+(last-error 24) <span class='arw'>&rarr;</span> (24 "invalid function")
+(last-error 1) <span class='arw'>&rarr;</span> (1 "not enough memory")
+(last-error 12345) <span class='arw'>&rarr;</span> (12345 "Unknown error")
+</pre>
+
+
+<p>For error numbers out of range the string <tt>"Unknown error"</tt> is
+given for the error text.</p>
+
+<p>Errors can be trapped by <a href="#error-event">error-event</a> 
+and user defined error handlers.</p>
+
+<p>See also <a href="#net-error">net-error</a> for errors generated by
+networking conditions and <a href="#sys-error">sys-error</a> for errors
+generated by the operating system.</p>
+
+<br/><br/>
+
+<a name="legalp"></a>
+<h2><span class="function">legal?</span></h2>
+<h4>syntax: (legal? <em>str</em>)</h4>
+
+<p>
+The token in <em>str</em> is verified as a legal newLISP symbol. 
+Non-legal symbols can be created using the <a href="#sym">sym</a> function
+(e.g. symbols containing spaces, quotes, or other characters not normally allowed). 
+Non-legal symbols are created frequently 
+when using them for associative data access:
+</p>
+
+<!-- example -->
+
+<pre>
+(symbol? (sym "one two"))  <span class='arw'>&rarr;</span> true
+
+(legal? "one two")         <span class='arw'>&rarr;</span> nil  ; contains a space
+
+(set (sym "one two") 123)  <span class='arw'>&rarr;</span> 123
+
+(eval (sym "one two"))     <span class='arw'>&rarr;</span> 123
+</pre>
+
+
+<p>The example shows that the string <tt>"one two"</tt> does not contain a legal
+symbol although a symbol can be created from this string and treated like a
+variable.
+</p>
+
+<br/><br/>
+
+<a name="length"></a>
+<h2><span class="function">length</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (length <em>exp</em>)</h4>
+
+<p>Returns the number of elements in a list, the number of rows in
+an array and the number of bytes in a string or in a symbol name.</p>
+
+<p>Applied to a number, <tt>length</tt> returns the number of digits for 
+normal and big integers and the number of digits before the decimal 
+separator for floats.</p>
+
+<p><tt>length</tt> returns <tt>0</tt> on all other types.</p>
+
+<p>Before version 10.5.6 <tt>length</tt> returned the storage size in bytes
+for integers (4 or 8) and floats (8).</p>
+
+<!-- example -->
+
+<pre>
+; number of top level elements in a list
+(length '(a b (c d) e))         <span class='arw'>&rarr;</span> 4
+(length '())                    <span class='arw'>&rarr;</span> 0
+(set 'someList '(q w e r t y))  <span class='arw'>&rarr;</span> (q w e r t y)
+(length someList)               <span class='arw'>&rarr;</span> 6
+
+; number of top level elements in an array
+(set 'ary (array 2 4 '(0)))  <span class='arw'>&rarr;</span> ((1 2 3 4) (5 6 7 8))
+(length ary)                 <span class='arw'>&rarr;</span> 2
+
+; number of bytes in a string or byte buffer
+(length "Hello World")  <span class='arw'>&rarr;</span> 11
+(length "")             <span class='arw'>&rarr;</span> 0
+(length "\000\001\003") <span class='arw'>&rarr;</span> 3
+
+; number of bytes in a symbol name string
+(length 'someVar)  <span class='arw'>&rarr;</span> 7
+
+; number of int digits in a number
+(length 0)         <span class='arw'>&rarr;</span> 0
+(length 123)       <span class='arw'>&rarr;</span> 3
+(length 1.23)      <span class='arw'>&rarr;</span> 1
+(length 1234567890123456789012345L) <span class='arw'>&rarr;</span> 25 
+</pre>
+
+<p>Use <a href="#utf8len">utf8len</a> to calculate the number of UTF-8 characters 
+in a string.</p>
+
+<br/><br/>
+
+<a name="let"></a>
+<h2><span class="function">let</span></h2>
+<h4>syntax: (let ((<em>sym1</em> [<em>exp-init1</em>]) [(<em>sym2</em> [<em>exp-init2</em>]) ... ]) <em>body</em>)<br/>
+syntax: (let (<em>sym1</em> <em>exp-init1</em> [<em>sym2</em> <em>exp-init2</em> ... ]) <em>body</em>)</h4>
+
+<p>One or more variables <em>sym1</em>, <em>sym2</em>, ... are declared locally and
+initialized with expressions in <em>exp-init1</em>, <em>exp-init2</em>, etc.
+In the fully parenthesized first syntax, initializers are optional and assumed 
+<tt>nil</tt> if missing.</p>
+
+<p>When the local variables are initialized, the initializer expressions evaluate
+ using symbol bindings as before the <tt>let</tt> statement. To incrementally use
+symbol bindings as evaluated during the initialization of locals in <tt>let</tt>,
+use <a href="#letn">letn</a>.</p>
+
+<p>One or more expressions in <em>exp-body</em> are evaluated using the local
+definitions of <em>sym1</em>, <em>sym2</em> etc. <tt>let</tt> is useful for
+breaking up complex expressions by defining local variables close to the
+place where they are used. The second form omits the parentheses around the
+variable expression pairs but functions identically.</p>
+
+<!-- example -->
+
+<pre>
+(define (sum-sq a b)
+    (let ((x (* a a)) (y (* b b)))
+        (+ x y)))
+
+(sum-sq 3 4) <span class='arw'>&rarr;</span> 25
+
+(define (sum-sq a b)           ; alternative syntax
+    (let (x (* a a) y (* b b))
+        (+ x y)))
+</pre>
+
+
+<p>The variables <tt>x</tt> and <tt>y</tt> are initialized, then the expression
+
+<tt>(+ x y)</tt> is evaluated. The let form is just an optimized version and syntactic
+convenience for writing:
+</p>
+
+
+<pre>
+((lambda (<em>sym1</em> [<em>sym2</em> ... ]) <em>exp-body</em> ) <em>exp-init1</em> [ <em>exp-init2</em> ])
+</pre>
+
+
+<p>See also <a href="#letn">letn</a> for an incremental or nested form of
+<tt>let</tt> and local for initializing to <tt>nil</tt>. See <a href="#local">local</a>
+for automatic initialization of variables to <tt>nil</tt>.</p>
+
+<br/><br/>
+
+<a name="letex"></a>
+<h2><span class="function">letex</span></h2>
+<h4>syntax: (letex ((<em>sym1</em> [<em>exp-init1</em>]) [(<em>sym2</em> [<em>exp-init2</em>]) ... ]) <em>body</em>)<br/>
+
+syntax: (letex (<em>sym1</em> <em>exp-init1</em> [<em>sym2</em> <em>exp-init2</em> ... ]) <em>body</em>)</h4>
+
+<p>This function combines <a href="#let">let</a> and <a href="#expand">expand</a> to 
+expand local variables into an expression before evaluating it. In the fully parenthesized 
+first syntax initializers are optional and assumed <tt>nil</tt> if missing.</p>
+
+<p>Both forms provide the same functionality, but in the second form the parentheses 
+around the initializers can be omitted:
+</p>
+
+<!-- example -->
+
+<pre>
+(letex (x 1 y 2 z 3) '(x y z))    <span class='arw'>&rarr;</span> (1 2 3)
+
+(letex ( (x 1) (y '(a b c)) (z "hello") ) '(x y z)) 
+
+<span class='arw'>&rarr;</span> (1 (a b c) "hello")
+</pre>
+
+<p>Before the expression <tt>'(x y z)</tt> gets evaluated, <tt>x, y</tt> and <tt>z</tt>
+are literally replaced with the initializers from the <tt>letex</tt> initializer list.
+The final expression which gets evaluated is <tt>'(1 2 3)</tt>.
+</p>
+
+<p>In the second example a function <tt>make-adder</tt> is defined
+for making adder functions:</p>
+
+<pre>
+(define (make-adder n)
+    (letex (c n) (lambda (x) (+ x c))))
+
+(define add3 (make-adder 3)) <span class='arw'>&rarr;</span> (lambda (x) (+ x 3))
+
+(add3 10) <span class='arw'>&rarr;</span> 13
+
+; letex can expand symbols into themselves
+; the following form also works
+
+(define (make-adder n)
+     (letex (n n) (lambda (x) (+ x n))))
+
+</pre>
+
+<p><tt>letex</tt> evaluates <tt>n</tt> to the constant <tt>3</tt> and replaces <tt>c</tt>
+with it in the lambda expression. The second examples shows, how a <tt>letex</tt>
+variable can be expanded into itself.</p>
+<br/><br/>
+
+<a name="letn"></a>
+<h2><span class="function">letn</span></h2>
+<h4>syntax: (letn ((<em>sym1</em> [<em>exp-init1</em>]) [(<em>sym2</em> [<em>exp-init2</em>]) ... ]) <em>body</em>)<br/>
+syntax: (letn (<em>sym1</em> <em>exp-init1</em> [<em>sym2</em> <em>exp-init2</em> ... ]) <em>body</em>)</h4>
+
+<p><tt>letn</tt> is like a <em>nested let</em> and works similarly to <a href="#let">let</a>, 
+but will incrementally use the new symbol bindings when evaluating the initializer expressions 
+as if several <a href="#let">let</a> were nested. In the fully parenthesized first syntax, 
+initializers are optional and assumed <tt>nil</tt> if missing.</p>
+
+<p>The following comparison
+of <a href="#let">let</a> and <tt>letn</tt> show the difference:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 10)
+(let ((x 1) (y (+ x 1))) 
+(list x y))           <span class='arw'>&rarr;</span> (1 11)
+
+(letn ((x 1) (y (+ x 1))) 
+(list x y))          <span class='arw'>&rarr;</span> (1 2)
+</pre>
+
+
+<p>While in the first example using <a href="#let">let</a> the variable <tt>y</tt> is
+calculated using the binding of <tt>x</tt> before the <a href="#let">let</a> expression,
+in the second example using <tt>letn</tt> the variable <tt>y</tt> is calculated using 
+the new local binding of <tt>x</tt>.
+</p>
+
+
+<pre>
+(letn  (x 1 y x) 
+    (+ x y))     <span class='arw'>&rarr;</span>  2
+
+;; same as nested let's
+
+(let (x 1)
+    (let (y x)
+      (+ x y)))  <span class='arw'>&rarr;</span>  2
+</pre>
+
+
+<p><tt>letn</tt> works like several <em>nested</em> <a href="#let">let</a>. The parentheses
+around the initializer expressions can be omitted.
+</p>
+
+<br/><br/>
+
+<a name="list"></a>
+<h2><span class="function">list</span></h2>
+<h4>syntax: (list <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>The <em>exp</em> are evaluated and the values used to construct a new list.
+Note that arguments of array type are converted to lists.
+</p>
+
+<!-- example -->
+
+<pre>
+(list 1 2 3 4 5)                <span class='arw'>&rarr;</span> (1 2 3 4 5)
+(list 'a '(b c) (+ 3 4) '() '*) <span class='arw'>&rarr;</span> (a (b c) 7 () *)
+</pre>
+
+
+<p>See also <a href="#cons">cons</a> and <a href="#push">push</a> for other
+forms of building lists.
+</p>
+
+<br/><br/>
+
+<a name="listp"></a>
+<h2><span class="function">list?</span></h2>
+<h4>syntax: (list? <em>exp</em>)</h4>
+
+<p>Returns <tt>true</tt> only if the value of <em>exp</em> is a list; otherwise
+returns <tt>nil</tt>.  Note that lambda and lambda-macro
+expressions are also recognized as special instances of a list expression.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'var '(1 2 3 4))    <span class='arw'>&rarr;</span> (1 2 3 4)
+(list? var)              <span class='arw'>&rarr;</span> true
+
+(define (double x) (+ x x))
+
+(list? double)           <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="load"></a>
+
+<h2><span class="function">load</span></h2>
+<h4>syntax: (load <em>str-file-name-1</em> [<em>str-file-name-2</em> ... ] [<em>sym-context</em>])</h4>
+
+<p>Loads and translates newLISP from a source file specified in one or more <em>str-file-name</em> 
+and evaluates the expressions contained in the file(s). When loading is successful,
+<tt>load</tt> returns the result of the last expression in the last file evaluated. If a file 
+cannot be loaded, <tt>load</tt> throws an error.
+</p>
+
+<p>
+An optional <em>sym-context</em> can be specified, 
+which becomes the context of evaluation, 
+unless such a context switch is already present 
+in the file being loaded. 
+By default, 
+files which do not contain <a href="#context">context</a> switches 
+will be loaded into the <tt>MAIN</tt> context.
+</p>
+
+<p>The <em>str-file-name</em> specs can contain URLs. Both <tt>http://</tt> and <tt> file://</tt>
+URLs are supported.
+</p>
+
+<!-- example -->
+
+<pre>
+(load "myfile.lsp")    
+
+(load "a-file.lsp" "b-file.lsp") 
+
+(load "file.lsp" "http://mysite.org/mypro")
+
+(load "http://192.168.0.21:6000//home/test/program.lsp")
+
+(load "a-file.lsp" "b-file.lsp" 'MyCTX)
+
+(load "file:///usr/share/newlisp/mysql.lsp")
+</pre>
+
+
+<p>In case expressions evaluated during the <tt>load</tt> are changing the 
+<a href="#context">context</a>, this will not influence the programming
+module doing the <tt>load</tt>. </p>
+
+<p>The current context after the <tt>load</tt> statement will always be 
+the same as before the <tt>load</tt>.</p>
+
+<p>Normal file specs and URLs can be mixed in the same load command.</p>
+
+<p><tt>load</tt> with <tt>HTTP</tt> URLs can also be used to load code
+remotely from newLISP server nodes running on a Unix-like operating system. 
+In this mode, <tt>load</tt> will issue
+an HTTP GET request to the target URL. Note that a double backslash is required 
+when path names are specified relative to the root directory. <tt>load</tt>
+in <tt>HTTP</tt> mode will observe a 60-second timeout.</p>
+
+<p>The second to last line causes the files to be loaded into the context <tt>MyCTX</tt>.
+The quote forces the context to be created if it did not exist.
+</p>
+
+<p>The <tt>file://</tt> URL is followed by a third <tt>/</tt> for the directory spec.
+</p>
+
+<br/><br/>
+
+<a name="local"></a>
+<h2><span class="function">local</span></h2>
+<h4>syntax: (local (<em>sym-1</em> [<em>sym-2</em> ... ]) <em>body</em>)</h4>
+
+<p>
+Initializes one or more symbols 
+in <em>sym-1&mdash;</em> to <tt>nil</tt>, 
+evaluates the expressions in <em>body</em>, 
+and returns the result of the last evaluation.
+</p>
+
+<p>
+<tt>local</tt> works similarly to <a href="#let">let</a>,
+but local variables are all initialized to <tt>nil</tt>.
+</p>
+
+<p>
+<tt>local</tt> provides a simple way 
+to localize variables 
+without explicit initialization.
+</p>
+
+<br/><br/>
+
+<a name="log"></a>
+<h2><span class="function">log</span></h2>
+<h4>syntax: (log <em>num</em>)<br/>
+
+syntax: (log <em>num</em> <em>num-base</em>)</h4>
+
+<p>In the first syntax, the expression in <em>num</em> is evaluated and the natural
+logarithmic function is calculated from the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(log 1)         <span class='arw'>&rarr;</span> 0
+(log (exp 1))   <span class='arw'>&rarr;</span> 1
+</pre>
+
+
+<p>In the second syntax, an arbitrary base can be specified in <em>num-base</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(log 1024 2)             <span class='arw'>&rarr;</span> 10
+(log (exp 1) (exp 1))    <span class='arw'>&rarr;</span>  1
+</pre>
+
+
+<p>See also <a href="#exp">exp</a>, which is the inverse function to <tt>log</tt> with
+base <b><em>e</em></b> (2.718281828).</p>
+
+<br/><br/>
+
+<a name="lookup"></a>
+<h2><span class="function">lookup</span></h2>
+<h4>syntax: (lookup <em>exp-key</em> <em>list-assoc</em> [<em>int-index</em> [<em>exp-default</em>]])</h4>
+
+<p>Finds in <em>list-assoc</em> an association, the key element of which
+has the same value as <em>exp-key</em>, and returns the <em>int-index</em> element of
+association (or the last element if <em>int-index</em> is absent).</p>
+
+<p>Optionally, <em>exp-default</em> can be specified, which is returned if an association matching
+<em>exp-key</em> cannot be found. If the <em>exp-default</em> is absent and no association
+has been found, <tt>nil</tt> is returned.</p>
+
+<p>See also <a href="#indexing">Indexing elements of strings and lists</a>.
+</p>
+
+<p><tt>lookup</tt> is similar to <a href="#assoc">assoc</a> but goes one step further 
+by extracting a specific element found in the list.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'params '(
+    (name "John Doe") 
+    (age 35) 
+    (gender "M") 
+    (balance 12.34)
+))
+
+(lookup 'age params)             <span class='arw'>&rarr;</span> 35
+
+; use together with setf to modify and association list
+(setf (lookup 'age params) 42)   <span class='arw'>&rarr;</span> 42
+(lookup 'age params)             <span class='arw'>&rarr;</span> 42
+
+(set 'persons '(
+    ("John Doe" 35 "M" 12.34) 
+    ("Mickey Mouse" 65 "N" 12345678)
+))
+
+(lookup "Mickey Mouse" persons 2)    <span class='arw'>&rarr;</span> "N"
+(lookup "Mickey Mouse" persons -3)   <span class='arw'>&rarr;</span> 65
+(lookup "John Doe" persons 1)        <span class='arw'>&rarr;</span> 35 
+(lookup "John Doe" persons -2)       <span class='arw'>&rarr;</span> "M"
+
+(lookup "Jane Doe" persons 1 "N/A")  <span class='arw'>&rarr;</span> "N/A"
+</pre>
+
+<p>See also <a href="#assoc">assoc</a></p>
+
+<br/><br/>
+
+<a name="lower-case"></a>
+<h2><span class="function">lower-case</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (lower-case <em>str</em>)</h4>
+
+<p>
+Converts the characters of the string 
+in <em>str</em> to lowercase. 
+A new string is created, 
+and the original is left unaltered.
+</p> 
+
+
+<!-- example -->
+
+<pre>
+(lower-case "HELLO WORLD")  <span class='arw'>&rarr;</span> "hello world"
+(set 'Str "ABC")
+(lower-case Str)  <span class='arw'>&rarr;</span> "abc"
+Str               <span class='arw'>&rarr;</span> "ABC"
+</pre>
+
+
+<p>
+See also the <a href="#upper-case">upper-case</a> and 
+<a href="#title-case">title-case</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="macro"></a>
+<h2><span class="function">macro</span></h2>
+<h4>syntax: (macro (<em>sym-name</em> [<em>sym-param-1</em> ... ]) [<em>body-1</em> ... ])</h4>
+
+<p>The <tt>macro</tt> function is used to define expansion macros. The syntax 
+of <tt>macro</tt> is identical to the syntax of <a href="#define-macro">define-macro</a>.
+But while <tt>define-macro</tt> defines are <em>fexprs</em> functions to be evaluated 
+at run-time, <tt>macro</tt> defines a function to be used during the source loading 
+and reading process to transform certain expression call patterns into different call 
+patterns.</p>
+
+<p>Symbols defined with <tt>macro</tt> are protected from re-definition.</p>
+
+<pre>
+(macro (double X) (+ X X)) <span class='arw'>&rarr;</span> (lambda-macro (X) (expand '(+ X X)))
+
+(double 123) <span class='arw'>&rarr;</span> 246
+
+(protected? 'double) <span class='arw'>&rarr;</span> true
+</pre>
+
+<p>Internally all <tt>macro</tt> defined symbol call patterns are translated using
+the <a href="#expand">expand</a> expression during source reading. This can be shown using
+the <a href="#read-expr">read-expr</a> function:</p>
+
+<pre>
+(read-expr "(double 123)") <span class='arw'>&rarr;</span> (+ 123 123)
+</pre>
+
+<p>All variable names to be expanded must start in upper-case. Macros can be nested containing 
+other macros defined earlier. But <tt>macro</tt> definitions cannot be repeated for the same 
+symbol during the same newLISP session. To redefine a macro, e.g. for reading source with a 
+different definition of an exisiting <tt>macro</tt> definition, use the 
+<a href="#constant">constant</a> function in the following way:</p>
+
+<pre>
+; change existing macro 'double' to allow floating point parameters
+; use upper-case for variables for expansion
+
+(constant 'double (lambda-macro (X) (expand '(add X X))))
+<span class='arw'>&rarr;</span> (lambda-macro (X) (expand '(add X X)))
+
+(double 1.23) <span class='arw'>&rarr;</span> 2.46
+</pre>
+
+<p>Note, that <a href="#constant">constant</a> can be used only to re-define macros, not
+to create new macros. Internally newLISP knows that <tt>macro</tt> defined symbols
+are executed during source reading, not evaluation.</p>
+
+<p>The redefinition will only affect future read code, it will not affect
+code already load and translated by the reader routines.</p>
+
+<h3>Using <tt>map</tt> and <tt>apply</tt> with <tt>macro</tt></h3>
+
+<p>When mapping macros using <a href="#map">map</a> or <a href="#apply">apply</a>
+the expansion function is mapped:</p>
+
+<pre>
+<b>&gt;</b> (macro (double X) (+ X X))
+<b>(lambda-macro (X) (expand '(+ X X)))</b>
+
+<b>&gt;</b> (map double '(1 2 3 4 5))
+<b>((+ 1 1) (+ 2 2) (+ 3 3) (+ 4 4) (+ 5 5))
+
+&gt;</b> (map eval (map double '(1 2 3 4 5)))
+<b>(2 4 6 8 10)</b>
+
+<b>&gt;</b> (apply double '(10))
+<b>(+ 10 10)
+&gt;</b>
+</pre>
+<p>This is useful to find out how the expansion mechanism of our <tt>macro</tt>
+definition works during source load time.</p>
+
+<h3>Differences between <tt>macro</tt> and <tt>define-macro</tt> and potential problems.</h3>
+
+<p><tt>macro</tt> definitions are not susceptible to <em>variable capture</em> as 
+are fexprs made with <a href="define-macro">define-macro</a>:</p>
+
+<pre>
+(define-macro (fexpr-add A B) 
+    (+ (eval A) (eval B)))
+
+(macro (mac-add A B) 
+    (+ A B))
+
+(set 'A 11 'B 22)
+
+; variable capture when using the same symbols 
+; used as locals in define-macro for callling
+
+(fexpr-add A B) <span class='arw'>&rarr;</span>
+; or
+(fexpr-add B A) <span class='arw'>&rarr;</span>
+<span class="err">ERR: value expected : A
+called from user defined function fexpr-add</span>
+
+; no variable capture when doing the same with 
+; expansion macros
+
+(mac-add A B) <span class='arw'>&rarr;</span> 33
+
+(mac-add B A) <span class='arw'>&rarr;</span> 33
+</pre>
+
+<p>But expansion macros using <tt>macro</tt> are susceptible to unwanted double
+evaluation, just like <tt>define-macro is</tt>:</p>
+
+<pre>
+(define-macro (fexpr-double X) 
+    (+ (eval X) (eval X)))
+
+(macro (mac-double X) 
+    (+ X X))
+
+(set 'a 10)
+(fexpr-double (inc a)) <span class='arw'>&rarr;</span> 23 ; not 22 as expected
+
+(set 'a 10)
+(mac-double (inc a)) <span class='arw'>&rarr;</span> 23 ; not 22 as expected
+</pre>
+
+<p>In both cases the incoming expression <tt>(inc a)</tt> gets evaulated twice.
+This must be considered when writing both, <tt>macro</tt> or <tt>define-macro</tt>
+expressions and symbols occur more than once in the body of the definition.</p> 
+
+<br/><br/>
+
+<a name="macrop"></a>
+<h2><span class="function">macro?</span></h2>
+<h4>syntax: (macro? <em>exp</em>)</h4>
+
+<p>Returns <tt>true</tt> if <em>exp</em> evaluates to a lambda-macro expression.
+If <em>exp</em> evaluates to a symbol and the symbol contains
+a macro-expansion expression made with the <a href="#macro">macro</a> function,
+<tt>true</tt> is also returned. In all other cases <tt>nil</tt> is returned.</p>
+
+<!-- example -->
+
+<pre>
+(define-macro (mysetq lv rv) (set lv (eval rv)))
+
+(macro? mysetq)  <span class='arw'>&rarr;</span> true
+
+(macro (my-setq Lv Rv) (set 'Lv Rv)) 
+<span class='arw'>&rarr;</span> (lambda-macro (Lv Rv) (expand '(set 'Lv Rv)))
+
+; my-setq contains a lambda-macro expression
+(macro? my-setq)   <span class='arw'>&rarr;</span> true
+
+; my-setq symbol was created with macro function
+(macro? 'my-setq)   <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="main-args"></a>
+<h2><span class="function">main-args</span></h2>
+<h4>syntax: (main-args)<br/>
+
+syntax: (main-args <em>int-index</em>)</h4>
+
+<p>
+<tt>main-args</tt> returns a list 
+with several string members, 
+one for program invocation 
+and one for each of 
+the command-line arguments.
+</p>
+
+<!-- example -->
+
+<pre>
+newlisp 1 2 3
+
+&gt; (main-args)
+<b>("/usr/bin/newlisp" "1" "2" "3")</b>
+</pre>
+
+
+<p>
+After <tt>newlisp 1 2 3</tt> is executed at the command prompt, 
+<tt>main-args</tt> returns a list containing the name of 
+the invoking program and three command-line arguments.
+</p>
+
+<p>
+Optionally, <tt>main-args</tt> can take 
+an <em>int-index</em> for indexing into the list.
+Note that an index out of range will cause <tt>nil</tt>
+to be returned, not the last element of the list like
+in list-indexing.
+</p>
+
+
+<pre>
+newlisp a b c
+
+&gt; (main-args 0)   
+<b>"/usr/bin/newlisp"</b>
+&gt; (main-args -1)  
+<b>"c"</b>
+&gt; (main-args 2)   
+<b>"b"</b>
+&gt; (main-args 10)
+<b>nil</b>
+</pre>
+
+
+<p>
+Note that when newLISP is executed from a script, 
+<tt>main-args</tt> also returns the <em>name</em> 
+of the script as the second argument:
+</p>
+
+
+<pre>
+#!/usr/bin/newlisp
+# 
+# script to show the effect of 'main-args' in script file
+
+(print (main-args) "\n")
+(exit)
+
+# end of script file
+
+;; execute script in the OS shell:
+
+script 1 2 3
+
+<b>("/usr/bin/newlisp" "./script" "1" "2" "3")</b>
+</pre>
+
+
+<p>
+Try executing this script with different 
+command-line parameters.
+</p>
+
+<br/><br/>
+
+<a name="make-dir"></a>
+<h2><span class="function">make-dir</span></h2>
+<h4>syntax: (make-dir <em>str-dir-name</em> [<em>int-mode</em>])</h4>
+
+<p>
+Creates a directory as specified in <em>str-dir-name</em>, 
+with the optional access mode <em>int-mode</em>. 
+Returns <tt>true</tt> or <tt>nil</tt> 
+depending on the outcome. 
+If no access mode is specified, 
+most Unix systems default to <tt>drwxr-xr-x</tt>.
+</p>
+
+<p>
+On Unix systems, the access mode specified 
+will also be masked by the OS's <em>user-mask</em> 
+set by the system administrator. 
+The <em>user-mask</em> can be retrieved 
+on Unix systems using the command <tt>umask</tt> 
+and is usually <tt>0022</tt> (octal),
+which masks write (and creation) permission 
+for non-owners of the file.
+</p>
+
+<!-- example -->
+
+<pre>
+;; 0 (zero) in front of 750 makes it an octal number
+
+(make-dir "adir" 0750)  
+</pre>
+
+
+<p>
+This example creates a directory named <tt>adir</tt> 
+in the current directory with an access mode of 
+<tt>0750</tt> (octal 750 = <tt>drwxr-x---</tt>).
+</p>
+<br/><br/>
+
+<a name="map"></a>
+
+<h2><span class="function">map</span></h2>
+<h4>syntax: (map <em>exp-functor</em> <em>list-args-1</em> [<em>list-args-2</em> ... ])</h4>
+
+<p>Successively applies the primitive function, defined function, or lambda expression 
+<em>exp-functor</em> to the arguments specified in <em>list-args-1 list-args-2&mdash;</em>, 
+returning all results in a list. Since version 10.5.5 <em>list-args</em>
+can also be array vectors, but the returned result will always be a list.</p>
+
+<!-- example -->
+
+<pre>
+(map + '(1 2 3) '(50 60 70))  <span class='arw'>&rarr;</span> (51 62 73)
+
+(map if '(true nil true nil true) '(1 2 3 4 5) '(6 7 8 9 10))
+<span class='arw'>&rarr;</span> '(1 7 3 9 5)
+
+(map (fn (x y) (* x y)) '(3 4) '(20 10))
+<span class='arw'>&rarr;</span> (60 40)
+</pre>
+
+<p>
+The second example shows how to dynamically 
+create a function for <tt>map</tt>:
+</p>
+
+<pre>
+(define (foo op p) 
+    (append (lambda (x)) (list (list op p 'x))))
+</pre>
+
+<p>We can also use the shorter <tt>fn</tt>:</p>
+
+<pre>
+(define (foo op p) 
+    (append (fn (x)) (list (list op p 'x))))
+</pre>
+
+<p><tt>foo</tt> now works like a function-maker:</p>
+
+<pre>
+(foo 'add 2)  <span class='arw'>&rarr;</span> (lambda (x) (add 2 x))
+
+(map (foo add 2) '(1 2 3 4 5))  <span class='arw'>&rarr;</span> (3 4 5 6 7)
+
+(map (foo mul 3) '(1 2 3 4 5))  <span class='arw'>&rarr;</span> (3 6 9 12 15)
+</pre>
+
+<p>
+Note that the quote before the operand can be omitted 
+because primitives evaluate to themselves in newLISP.
+</p>
+
+<p>By incorporating <tt>map</tt> into the function definition, 
+we can do the following:</p>
+
+<pre>
+(define (list-map op p lst) 
+    (map (lambda (x) (op p x)) lst))
+
+(list-map + 2 '(1 2 3 4))  <span class='arw'>&rarr;</span> (3 4 5 6)
+
+(list-map mul 1.5 '(1 2 3 4))  <span class='arw'>&rarr;</span> (1.5 3 4.5 6)
+</pre>
+
+<p><tt>map</tt> also sets the internal list index <tt>$idx</tt>.</p>
+
+<pre>
+(map (fn (x) (list $idx x)) '(a b c)) <span class='arw'>&rarr;</span> ((0 a) (1 b) (2 c))
+</pre>
+
+<p>
+The number of arguments used is determined by the length of the first argument list. 
+Arguments missing in other argument lists cause map to stop collecting parameters
+for that level of arguments. This ensures that the nth parameter list gets converted
+to the nth column during the transposition occurring. If an argument list contains too 
+many elements, the extra ones will be ignored.
+</p>
+
+<p>
+Special forms which use parentheses as syntax cannot be mapped 
+(i.e. <a href="#case">case</a>).</p>
+
+<br/><br/>
+
+<a name="mat"></a>
+<h2><span class="function">mat</span></h2>
+<h4>syntax: (mat <em>+</em> | <em>-</em> | <em>*</em> | <em>/</em> <em>matrix-A matrix-B</em>)<br/>
+syntax: (mat <em>+</em> | <em>-</em> | <em>*</em> | <em>/</em> <em>matrix-A number</em>)</h4>
+
+<p>Using the first syntax, this function performs fast floating point 
+scalar operations on two-dimensional matrices in <em>matrix-A</em> or <em>matrix-B</em>. 
+The type of operation is specified by one of the four arithmetic operators 
+<tt>+</tt>, <tt>-</tt>, <tt>*</tt>, or <tt>/</tt>. 
+This type of arithmetic operator is typically used for integer 
+operations in newLISP. In the case of <tt>mat</tt>, however,
+all operations will be performed as floating point operations
+(<tt>add</tt>, <tt>sub</tt>, <tt>mul</tt>, <tt>div</tt>).</p>
+
+<p>Matrices in newLISP are two-dimensional lists or arrays. 
+Internally, newLISP translates lists and arrays into fast, accessible 
+C-language data objects. 
+This makes matrix operations in newLISP 
+as fast as those coded directly in C. 
+The same is true for the matrix operations 
+<a href="#multiply">multiply</a> and <a href="#invert">invert</a>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'A '((1 2 3) (4 5 6)))
+(set 'B A)
+
+(mat + A B)    <span class='arw'>&rarr;</span> ((2 4 6) (8 10 12))
+(mat - A B)    <span class='arw'>&rarr;</span> ((0 0 0) (0 0 0))
+(mat * A B)    <span class='arw'>&rarr;</span> ((1 4 9) (16 25 36))
+(mat / A B)    <span class='arw'>&rarr;</span> ((1 1 1) (1 1 1))
+
+; specify the operator in a variable
+
+(set 'op +)
+(mat op A B)    <span class='arw'>&rarr;</span> ((2 4 6) (8 10 12)) 
+</pre>
+
+
+<p>Using the second syntax, all cells in <em>matrix-A</em> 
+are operated on with a scalar in <em>number</em>:</p>
+
+
+<pre>
+(mat + A 5)    <span class='arw'>&rarr;</span> ((6 7 8) (9 10 11))
+(mat - A 2)    <span class='arw'>&rarr;</span> ((-1 0 1) (2 3 4))
+(mat * A 3)    <span class='arw'>&rarr;</span> ((3 6 9) (12 15 18))
+(mat / A 10)   <span class='arw'>&rarr;</span> ((.1 .2 .3) (.4 .5 .6))
+</pre>
+
+
+<p>See also the other matrix operations <a href="#det">det</a>, 
+<a href="#invert">invert</a>, <a href="#multiply">multiply</a>,
+and <a href="#transpose">transpose</a>.</p>
+
+<br/><br/>
+
+<a name="match"></a>
+<h2><span class="function">match</span></h2>
+<h4>syntax: (match <em>list-pattern</em> <em>list-match</em> [<em>bool</em>])</h4>
+
+<p>
+The pattern in <em>list-pattern</em> is matched 
+against the list in <em>list-match</em>, 
+and the matching expressions are returned in a list. 
+The three wildcard characters <tt>?</tt>, <tt>+</tt>, 
+and <tt>*</tt> can be used in <em>list-pattern</em>.
+</p>
+
+<p>
+Wildcard characters may be nested. 
+<tt>match</tt> returns a 
+list of matched expressions. 
+For each <tt>?</tt> (question mark), 
+a matching expression element is returned. 
+For each <tt>+</tt> (plus sign) or 
+<tt>*</tt> (asterisk), a list containing 
+the matched elements is returned. 
+If the pattern cannot be matched 
+against the list in <em>list-match</em>, 
+<tt>match</tt> returns <tt>nil</tt>.
+If no wildcard characters are present
+in the pattern an empty list is returned.
+</p>
+
+<p>Optionally, the Boolean value <tt>true</tt> (or any other expression not 
+evaluating to <tt>nil</tt>) can be supplied as a third argument.  This 
+causes <tt>match</tt> to show all elements in the returned result.</p>
+
+<p>
+<tt>match</tt> is frequently employed as a functor parameter
+in <a href="#find">find</a>, <a href="#ref">ref</a>,
+<a href="#ref-all">ref-all</a> and <a href="#replace">replace</a> and
+is internally used by <a href="#find-all">find-all</a> for lists.</p>
+
+<!-- example -->
+
+<pre>
+(match '(a ? c) '(a b c))  <span class='arw'>&rarr;</span> (b)
+
+(match '(a ? ?) '(a b c))  <span class='arw'>&rarr;</span> (b c)
+
+(match '(a ? c) '(a (x y z) c))  <span class='arw'>&rarr;</span> ((x y z))
+
+(match '(a ? c) '(a (x y z) c) true)  <span class='arw'>&rarr;</span> (a (x y z) c)
+
+(match '(a ? c) '(a x y z c))  <span class='arw'>&rarr;</span> nil
+
+
+(match '(a * c) '(a x y z c))  <span class='arw'>&rarr;</span> ((x y z))
+
+(match '(a (b c ?) x y z) '(a (b c d) x y z))  <span class='arw'>&rarr;</span> (d)
+
+(match '(a (*) x ? z) '(a (b c d) x y z))  <span class='arw'>&rarr;</span> ((b c d) y)
+
+
+(match '(+) '())  <span class='arw'>&rarr;</span> nil
+
+(match '(+) '(a))  <span class='arw'>&rarr;</span> ((a))
+
+(match '(+) '(a b))  <span class='arw'>&rarr;</span> ((a b))
+
+(match '(a (*) x ? z) '(a () x y z))  <span class='arw'>&rarr;</span> (() y)
+
+(match '(a (+) x ? z) '(a () x y z))  <span class='arw'>&rarr;</span> nil 
+</pre>
+
+
+<p>Note that the <tt>*</tt> operator tries to grab the fewest number of 
+elements possible, but <tt>match</tt> backtracks and grabs more elements 
+if a match cannot be found.</p>
+
+<p>The <tt>+</tt> operator works similarly to the <tt>*</tt> operator, 
+but it requires at least one list element.</p>
+
+<p>The following example shows how the matched expressions can be bound 
+to variables.</p>
+
+
+<pre>
+(map set '(x y) (match '(a (? c) d *) '(a (b c) d e f)))
+
+x  <span class='arw'>&rarr;</span> b
+y  <span class='arw'>&rarr;</span> (e f)
+</pre>
+
+
+<p>
+Note that <tt>match</tt> for strings has been eliminated. 
+For more powerful string matching, use <a href="#regex">regex</a>, 
+<a href="#find">find</a>, <a href="#find-all">find-all</a> 
+or <a href="#parse">parse</a>.
+</p>
+
+<p> <a href="#unify">unify</a> is another function for matching 
+expressions in a PROLOG like manner.</p>
+
+<br/><br/>
+
+<a name="max"></a>
+<h2><span class="function">max</span></h2>
+<h4>syntax: (max <em>num-1</em> [<em>num-2</em> ... ])</h4>
+
+<p>Evaluates the expressions <em>num-1</em>&mdash; and returns 
+the largest number.</p>
+
+<!-- example -->
+
+<pre>
+(max 4 6 2 3.54 7.1)  <span class='arw'>&rarr;</span> 7.1
+</pre>
+
+
+<p>
+See also the <a href="#min">min</a> function.
+</p>
+
+<br/><br/>
+
+<a name="member"></a>
+<h2><span class="function">member</span></h2>
+<h4>syntax: (member <em>exp</em> <em>list</em>)<br/>
+syntax: (member <em>str-key</em> <em>str</em> [<em>num-option</em>])</h4>
+<p>
+In the first syntax, 
+<tt>member</tt> searches 
+for the element <em>exp</em> 
+in the list <em>list</em>. 
+If the element is a member of the list, 
+a new list starting with the element found 
+and the rest of the original list 
+is constructed and returned. 
+If nothing is found, 
+<tt>nil</tt> is returned. 
+When specifying <em>num-option</em>,
+<tt>member</tt> performs a regular expression search.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'aList '(a b c d e f g h))  <span class='arw'>&rarr;</span> (a b c d e f g h)
+(member 'd aList)                <span class='arw'>&rarr;</span> (d e f g h)
+(member 55 aList)                <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p>
+In the second syntax, 
+<tt>member</tt> searches 
+for <em>str-key</em> in <em>str</em>. 
+If <em>str-key</em> is found, all of <em>str</em> 
+(starting with <em>str-key</em>) is returned. 
+<tt>nil</tt> is returned if nothing is found.
+</p>
+
+<!-- example -->
+
+<pre>
+(member "LISP" "newLISP")  <span class='arw'>&rarr;</span> "LISP"
+(member "LI" "newLISP")    <span class='arw'>&rarr;</span> "LISP"
+(member "" "newLISP")      <span class='arw'>&rarr;</span> "newLISP"
+(member "xyz" "newLISP")   <span class='arw'>&rarr;</span> nil
+(member "li" "newLISP" 1)  <span class='arw'>&rarr;</span> "LISP"
+</pre>
+
+
+<p>
+See also the related functions 
+<a href="#slice">slice</a> and 
+<a href="#find">find</a>.
+</p>
+
+<br/><br/>
+
+<a name="min"></a>
+<h2><span class="function">min</span></h2>
+<h4>syntax: (min <em>num-1</em> [<em>num-2</em> ... ])</h4>
+
+<p>
+Evaluates the expressions <em>num-1</em>&mdash; 
+and returns the smallest number.
+</p>
+
+<!-- example -->
+
+<pre>
+(min 4 6 2 3.54 7.1)  <span class='arw'>&rarr;</span> 2
+</pre>
+
+<p>
+See also the <a href="#max">max</a> function.
+</p>
+
+<br/><br/>
+
+<a name="mod"></a>
+<h2><span class="function">mod</span></h2>
+<h4>syntax: (mod <em>num-1</em> <em>num-2</em> [<em>num-3</em> ... ])<br/>
+syntax: (mod <em>num-1</em>)</h4>
+
+<p>
+Calculates the modular value of the 
+numbers in <em>num-1</em> and <em>num-2</em>. 
+<tt>mod</tt> computes the remainder 
+from the division of the numerator <em>num-i</em> 
+by the denominator <em>num-i + 1</em>. 
+Specifically, the return value is 
+<em>numerator - n * denominator</em>, 
+where <tt>n</tt> is the quotient 
+of the numerator divided by the denominator, 
+rounded towards zero to an integer. 
+The result has the same sign as 
+the numerator and its magnitude 
+is less than the magnitude 
+of the denominator.</p>
+
+<p>In the second syntax <tt>1</tt> is assumed for <em>num-2</em> and the
+result is the fractional part of <em>num-1</em>.</p>
+
+<!-- example -->
+
+<pre>
+(mod 10.5 3.3)   <span class='arw'>&rarr;</span>  0.6
+(mod -10.5 3.3)  <span class='arw'>&rarr;</span> -0.6
+(mod -10.5)      <span class='arw'>&rarr;</span> -0.5
+</pre>
+
+
+<p>
+Use the <a href="#arithmetic">%</a> (percent sign) 
+function when working with integers only.
+</p>
+
+<br/><br/>
+
+<a name="mul"></a>
+<h2><span class="function">mul</span></h2>
+<h4>syntax: (mul <em>num-1</em> <em>num-2</em> [<em>num-3</em> ... ])</h4>
+
+<p>
+Evaluates all expressions <em>num-1</em>&mdash;, 
+calculating and returning the product. 
+<tt>mul</tt> can perform mixed-type arithmetic, 
+but it always returns floating point numbers. 
+Any floating point calculation with 
+<tt>NaN</tt> also returns <tt>NaN</tt>.
+</p>
+
+<!-- example -->
+
+
+<pre>
+(mul 1 2 3 4 5 1.1)  <span class='arw'>&rarr;</span> 132
+(mul 0.5 0.5)        <span class='arw'>&rarr;</span> 0.25
+</pre>
+
+<br/><br/>
+
+<a name="multiply"></a>
+<h2><span class="function">multiply</span></h2>
+<h4>syntax: (multiply <em>matrix-A</em> <em>matrix-B</em>)</h4>
+
+<p>
+Returns the matrix multiplication of matrices 
+in <em>matrix-A</em> and <em>matrix-B</em>. 
+If <em>matrix-A</em> has the dimensions <em>n</em> by <em>m</em> 
+and <em>matrix-B</em> the dimensions <em>k</em> by <em>l</em> 
+(<em>m</em> and <em>k</em> must be equal), 
+the result is an <em>n</em> by <em>l</em> matrix. 
+<tt> multiply</tt> can perform mixed-type arithmetic, 
+but the results are always double precision floating points, 
+even if all input values are integers.
+</p>
+
+<p>
+The dimensions of a matrix are determined 
+by the number of rows and the number 
+of elements in the first row. 
+For missing elements 
+in non-rectangular matrices, 
+<tt>0.0</tt> is assumed. 
+A matrix can either be a nested list 
+or <a href="#array">array</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'A '((1 2 3) (4 5 6)))
+(set 'B '((1 2) (1 2) (1 2)))
+(multiply A B)  <span class='arw'>&rarr;</span> ((6 12) (15 30))
+
+(set 'v '(10 20 30))
+(multiply A (transpose (list v))) <span class='arw'>&rarr;</span> ((140) (320))
+</pre>
+
+<p>When multiplying a matrix with a vector of <tt>n</tt> elements, the vector
+must be transformed into <tt>n</tt> rows by <tt>1</tt> column matrix using
+ <a href="#transpose">transpose</a>.</p>
+
+<p>
+All operations shown here on lists 
+can be performed on arrays, as well.
+</p>
+
+<p>
+See also the matrix operations <a href="#det">det</a>,
+<a href="#invert">invert</a>, <a href="#mat">mat</a> 
+and <a href="#transpose">transpose</a>.
+</p>
+
+<br/><br/>
+
+<a name="name"></a>
+<h2><span class="function">name</span></h2>
+<p>This function is deprecated, use <a href="#term">term</a> instead.</p>
+
+<br/><br/>
+
+<a name="NaNp"></a>
+<h2><span class="function">NaN?</span></h2>
+<h4>syntax: (NaN? <em>float</em>)</h4>
+
+<p>
+Tests if the result of a floating point math operation is a <tt>NaN</tt>.  
+Certain floating point operations return a special IEEE 754 number format 
+called a <tt>NaN</tt> for 'Not a Number'.</p>
+
+<!-- example -->
+
+<pre>
+; floating point operation on NaN yield NaN
+(set 'x (sqrt -1))  <span class='arw'>&rarr;</span> NaN
+(NaN? x)            <span class='arw'>&rarr;</span> true
+(add x 123)         <span class='arw'>&rarr;</span> NaN
+(mul x 123)         <span class='arw'>&rarr;</span> NaN
+
+; integer operations treat NaN as zero
+(+ x 123)  <span class='arw'>&rarr;</span> 123
+(* x 123)  <span class='arw'>&rarr;</span> 0
+
+; comparisons with NaN values yield nil
+(&gt; x 0)   <span class='arw'>&rarr;</span> nil
+(&lt;= x 0)  <span class='arw'>&rarr;</span> nil
+(= x x)   <span class='arw'>&rarr;</span> nil
+
+(set 'infinity (mul 1.0e200 1.0e200)) <span class='arw'>&rarr;</span> inf
+(NaN? (sub infinity infinity)) <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+Note that all floating point arithmetic operations 
+with a <tt>NaN</tt> yield a <tt>NaN</tt>. 
+All comparisons with <tt>NaN</tt> return <tt>nil</tt>, 
+but <tt>true</tt> when comparing to itself. 
+Comparison with itself, however, 
+would result in <em>not</em> <tt>true</tt> when using ANSI C.  Integer operations 
+treat <tt>NaN</tt> as <tt>0</tt> (zero) values.</p>
+
+<p>See also <a href="#infp">inf?</a> for testing a floating point value for infinity.</p>
+
+<br/><br/>
+
+<a name="net-accept"></a>
+<h2><span class="function">net-accept</span></h2>
+<h4>syntax: (net-accept <em>int-socket</em>)</h4>
+
+<p>
+Accepts a connection on a socket 
+previously put into listening mode. 
+Returns a newly created socket handle 
+for receiving and sending data 
+on this connection.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'socket (net-listen 1234))
+(net-accept socket)
+</pre>
+
+
+<p>
+Note that for ports less than 1024, 
+newLISP must be started in superuser mode
+on Unix-like operating systems.
+</p>
+
+<p> See also the files <tt>server</tt> and <tt>client</tt> examples
+in the <tt>examples/</tt> directory of the source distribution.</p>
+
+<br/><br/>
+
+<a name="net-close"></a>
+<h2><span class="function">net-close</span></h2>
+<h4>syntax: (net-close <em>int-socket</em> [<em>true</em>])</h4>
+
+<p>
+Closes a network socket in <em>int-socket</em> that 
+was previously created by a 
+<a href="#net-connect">net-connect</a> 
+or <a href="#net-accept">net-accept</a> function. 
+Returns <tt>true</tt> on success and 
+<tt>nil</tt> on failure.
+</p>
+
+<!-- example -->
+
+<pre>
+(net-close aSock)
+</pre>
+
+
+<p>The optional <em>true</em> flag suppresses immediate shutdown
+of sockets by waiting for pending data transmissions to finish.</p>
+
+<br/><br/>
+
+<a name="net-connect"></a>
+<h2><span class="function">net-connect</span></h2>
+<h4>syntax: (net-connect <em>str-remote-host</em> <em>int-port</em> [<em>int-timeout-ms</em>])<br/>
+syntax: (net-connect <em>str-remote-host</em> <em>int-port</em> [<em>str-mode</em> [<em>int-ttl</em>]])<br/>
+syntax: (net-connect <em>str-file-path</em>)</h4>
+
+<p>In the first syntax, connects to a remote host computer specified in 
+<em>str-remote-host</em> and a port specified in <em>int-port</em>. 
+Returns a socket handle after having connected successfully; 
+otherwise, returns <tt>nil</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'socket (net-connect "example.com" 80))
+(net-send socket "GET /\r\n\r\n")
+(net-receive socket buffer 10000)
+(println buffer)
+(exit)
+</pre>
+
+<p>If successful, the <tt>net-connect</tt> function returns a socket
+number which can be used to send and receive information from the host.
+In the example a HTTP GET request is sent and subsequently a web page
+received. Note that newLISP has already a built-in function 
+<a href="#get-url">get-url</a> offering the same functionality.</p>
+
+<p>Optionally a timeout value <em>int-timeout</em> in milliseconds
+can be specified. Without a timeout value the function will wait up
+to 10 seconds for an open port. With a timeout value the function can
+be made to return on an unavailable port much earlier or later. The
+following example shows a port scanner looking for open ports:</p>
+
+<!-- example -->
+<pre>
+(set 'host (main-args 2))
+(println "Scanning: " host)
+(for (port 1 1024)
+    (if (set 'socket (net-connect host port 500))
+        (println "open port: " port " " (or (net-service port "tcp") ""))
+        (print port "\r"))
+)
+</pre>
+
+<p>The programs takes the host string from the shell command line as
+either a domain name or an IP number in dot notation then tries to 
+open each port from 1 to 1024. For each open port the port number and 
+the service description string is printed. If no description is available,
+an empty string "" is output. For closed ports the function outputs 
+numbers in the shell window staying on the same line.</p>
+
+<p>On Unix <tt>net-connect</tt> may return with <tt>nil</tt> before
+the timeout expires, when the port is not available. On MS Windows 
+<tt>net-connect</tt> will always wait for the timeout to expire before
+failing with <tt>nil</tt>.</p>
+
+<h3>UDP communications</h3>
+
+<p>In the second syntax, a third parameter, the string <tt>"udp"</tt>
+or <tt>"u"</tt> can be specified in the optional <em>str-mode</em> 
+to create a socket suited for UDP (User Datagram Protocol) communications.
+In UDP mode, <tt>net-connect</tt> does <em>not</em> try to connect 
+to the remote host, but creates the socket and binds it to the
+remote address, if an address is specified. 
+A subsequent <a href="#net-send">net-send</a> will send a UDP packet 
+containing that target address. 
+When using <a href="#net-send-to">net-send-to</a>, only one of the
+two functions <tt>net-connect</tt> or <tt>net-send-to</tt> should 
+provide a target address. The other function should specify and empty
+string <tt>""</tt> as the target address.</p>
+
+<pre>
+;; example server
+(net-listen 4096 "226.0.0.1" "udp")  <span class='arw'>&rarr;</span> 5
+(net-receive-from 5 20)
+
+;; example client I
+(net-connect "226.0.0.1" 4096 "udp") <span class='arw'>&rarr;</span> 3
+(net-send 3 "hello")
+
+;; example client II
+(net-connect "" 4096 "udp") &rarr; 3
+(net-send-to "226.0.0.1" 4096 "hello" 3)
+</pre>
+
+<p>The functions <a href="#net-receive">net-receive</a> and 
+<a href="#net-receive-from">net-receive-from</a>
+can both be used and will perform UDP communications when the <tt>"udp"</tt>
+option as been used in <tt>net-listen</tt> or <tt>net-connect</tt>. 
+<a href="#net-select">net-select</a> and <a href="#net-peek">net-peek</a> 
+can be used to check for received data in a non-blocking fashion.</p>
+
+<p><a href="#net-listen">net-listen</a> binds a specific 
+local address and port to the socket. When <tt>net-connect</tt> is used,
+the local address and port will be picked by the socket-stack 
+functions of the host OS.</p>
+
+<h3>UDP multicast communications</h3>
+
+<p>When specifying <tt>"multi"</tt> 
+or <tt>"m"</tt> as a third parameter for <em>str-mode</em>,
+a socket for UDP multicast communications 
+will be created. 
+Optionally, the fourth parameter
+<tt>int-ttl</tt> can be specified 
+as a TTL (time to live) value. 
+If no <em>int-ttl</em> value is specified, 
+a value of 3 is assumed.
+</p>
+
+<p>
+Note that specifying UDP multicast mode 
+in <tt>net-connect</tt> does not actually establish 
+a connection to the target multicast address 
+but only puts the socket into UDP multicasting mode. 
+On the receiving side, 
+use <a href="#net-listen">net-listen</a> 
+together with the UDP multicast option.
+</p>
+
+<!-- example -->
+
+<pre>
+;; example client I
+(net-connect "" 4096 "multi")  <span class='arw'>&rarr;</span> 3
+(net-send-to "226.0.0.1" 4096 "hello" 3)
+
+;; example client II
+(net-connect "226.0.0.1" 4096 "multi")  <span class='arw'>&rarr;</span> 3
+(net-send 3 "hello")
+
+;; example server
+(net-listen 4096 "226.0.0.1" "multi")  <span class='arw'>&rarr;</span> 5
+(net-receive-from 5 20)               
+<span class='arw'>&rarr;</span> ("hello" "192.168.1.94" 32769)
+</pre>
+
+
+<p>
+On the server side, <a href="#net-peek">net-peek</a> or <a href="#net-select">net-select</a>
+can be used for non-blocking communications.  In the above example, the server would block
+until a datagram is received.</p>
+
+<p>The address <tt>226.0.0.1</tt> is just one multicast address 
+in the Class D range of multicast addresses from <tt>224.0.0.0</tt> 
+to <tt>239.255.255.255</tt>.</p>
+
+<p>
+The <a href="#net-send">net-send</a> and 
+<a href="#net-receive">net-receive</a> functions
+can also be used instead of <a href="#net-send-to">net-send-to</a> 
+and <a href="#net-receive-from">net-receive-from</a>.
+</p>
+
+
+<h3>UDP broadcast communications</h3>
+
+<p>
+Specifying the string <tt>"broadcast"</tt> or <tt>"b"</tt> 
+in the third parameter, <em>str-mode</em>, causes
+UDP broadcast communications to be set up. 
+In this case, the broadcast address 
+ending in 255 is used.
+</p>
+
+<!-- example -->
+
+<pre>
+;; example client
+(net-connect "192.168.2.255" 3000 "broadcast")  <span class='arw'>&rarr;</span> 3
+(net-send 3 "hello")
+
+;; example server
+(net-listen 3000 "" "udp")  <span class='arw'>&rarr;</span> 5
+
+(net-receive 5 buff 10)
+buff  <span class='arw'>&rarr;</span> "hello"
+;; or
+(net-receive-from 5 10)
+<span class='arw'>&rarr;</span> ("hello" "192.168.2.1" 46620)
+</pre>
+
+
+<p>
+Note that on the receiving side, 
+<a href="#net-listen">net-listen</a> should be used 
+with the default address 
+specified with an <tt>""</tt> (empty string). 
+Broadcasts will not be received 
+when specifying an address. 
+As with all UDP communications, 
+<a href="#net-listen">net-listen</a> does not actually put 
+the receiving side in listen mode, 
+but rather sets up the sockets 
+for the specific UDP mode.
+</p>
+
+<p>
+The <a href="#net-select">net-select</a> 
+or <a href="#net-peek">net-peek</a> functions 
+can be used to check for 
+incoming communications 
+in a non-blocking fashion.
+</p>
+
+<h3>Local domain Unix sockets</h3>
+
+<p>In the third syntax, <tt>net-connect</tt> connects to a server on the 
+local file system via a <em>local domain Unix socket</em> named using 
+<em>str-file-path</em>.	Returns a socket handle after having connected 
+successfully; otherwise, returns <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(net-connect "/tmp/mysocket")  <span class='arw'>&rarr;</span> 3
+
+; on OS/2 use "\\socket\\" prefix
+
+(net-connect "\\socket\\mysocket")
+</pre>
+
+
+<p>A <em>local domain</em> file system socket is created and returned.
+On the server side, <em>local domain</em> sockets have been created
+using <a href="#net-listen">net-listen</a> and <a href="#net-accept">net-accept</a>.
+After the connection has been established the functions <a href="#net-select">net-select</a>,
+<a href="#net-send">net-send</a> and <a href="#net-receive">net-receive</a> can be used
+as usual for TCP/IP stream communications. This type of connection can be used as a fast
+bi-directional communications channel between processes on the same file system.
+This type of connection is not available on MS Windows platforms.</p>
+
+<br/><br/>
+
+<a name="net-error"></a>
+<h2><span class="function">net-error</span></h2>
+<h4>syntax: (net-error)<br/>
+syntax: (net-error <em>int-error</em>)</h4>
+
+<p>Retrieves the last error that occurred when calling a any of the
+following functions: <a href="#net-accept">net-accept</a>,
+<a href="#net-connect">net-connect</a>,
+<a href="#net-eval">net-eval</a>,
+<a href="#net-listen">net-listen</a>,
+<a href="#net-lookup">net-lookup</a>,
+<a href="#net-receive">net-receive</a>,
+<a href="#net-receive-udp">net-receive-udp</a>,
+<a href="#net-select">net-select</a>,
+<a href="#net-send">net-send</a>,
+<a href="#net-send-udp">net-send-udp</a>,
+and <a href="#net-service">net-service</a>. 
+Whenever one of these functions fails, it returns <tt>nil</tt> and <tt>net-error</tt>
+can be used to retrieve more information.</p>
+
+<p>Functions that communicate using sockets close the socket automatically and 
+remove it from the <a href="#net-sessions">net-sessions</a> list.</p>
+
+<p>Each successful termination of a <a href="#socket_tcpip">net-*</a> 
+function clears the error number.</p>
+
+<p>The following messages are returned:</p>
+
+<table summary="net-error">
+<tr align="left"><th>no</th><th>description</th></tr>
+<tr><td>1</td><td>Cannot open socket</td></tr>
+<tr><td>2</td><td>DNS resolution failed</td></tr>
+<tr><td>3</td><td>Not a valid service</td></tr>
+<tr><td>4</td><td>Connection failed</td></tr>
+<tr><td>5</td><td>Accept failed</td></tr>
+<tr><td>6</td><td>Connection closed</td></tr>
+<tr><td>7</td><td>Connection broken</td></tr>
+<tr><td>8</td><td>Socket send() failed</td></tr>
+<tr><td>9</td><td>Socket recv() failed</td></tr>
+<tr><td>10</td><td>Cannot bind socket</td></tr>
+<tr><td>11</td><td>Too many sockets in net-select</td></tr>
+<tr><td>12</td><td>Listen failed</td></tr>
+<tr><td>13</td><td>Badly formed IP</td></tr>
+<tr><td>14</td><td>Select failed</td></tr>
+<tr><td>15</td><td>Peek failed</td></tr>
+<tr><td>16</td><td>Not a valid socket</td></tr>
+<tr><td>17</td><td>Cannot unblock socket</td></tr>
+<tr><td>18</td><td>Operation timed out</td></tr>
+<tr><td>19</td><td>HTTP bad formed URL</td></tr>
+<tr><td>20</td><td>HTTP file operation failed</td></tr>
+<tr><td>21</td><td>HTTP transfer failed</td></tr>
+<tr><td>22</td><td>HTTP invalid response from server</td></tr>
+<tr><td>23</td><td>HTTP no response from server</td></tr>
+<tr><td>24</td><td>HTTP no content</td></tr>
+<tr><td>25</td><td>HTTP error in header</td></tr>
+<tr><td>26</td><td>HTTP error in chunked format</td></tr>
+</table><br/>
+
+<br/><br/>
+<!-- example -->
+
+<pre>
+(net-error) <span class='arw'>&rarr;</span> nil
+
+(net-connect "jhghjgkjhg" 80)  <span class='arw'>&rarr;</span>  nil
+
+(net-error)  <span class='arw'>&rarr;</span>  (2 "ERR: "DNS resolution failed") 
+</pre>
+
+<p>When <em>int-error</em> is specified the number and error text for
+that error number is returned.</p>
+
+
+<pre>
+(net-error 10) <span class='arw'>&rarr;</span> (10 "Cannot bind socket")
+</pre>
+
+
+<p>See also <a href="#last-error">last-error</a> and <a href="#sys-error">sys-error</a>.</p>
+
+<br/><br/>
+
+<a name="net-eval"></a>
+<h2><span class="function">net-eval</span></h2> 
+<h4>syntax: (net-eval <em>str-host</em> <em>int-port</em> <em>exp</em> [<em>int-timeout</em> [<em>func-handler</em>]])<br/>
+syntax: (net-eval '((<em>str-host</em> <em>int-port</em> <em>exp</em>) ... )  [<em>int-timeout</em> [<em>func-handler</em>]])</h4>
+
+<p>Can be used to evaluate source remotely on one or more newLISP servers. 
+This function handles all communications necessary to connect to the remote servers, 
+send source for evaluation, and wait and collect responses.</p>
+
+<p>The expression in <em>exp</em> will be evaluated remotely in the environment 
+of the target node. The <em>exp</em> is either a quoted expression, or it is 
+enclosed in string delimiters. For bigger expressions <tt>[text] ... [/text]</tt> 
+delimiters can be used instead of double quotes <tt>" ... "</tt>.  Only one 
+expression should be enclosed in the string. When more than one are specified,
+all will get evaluated in the target node, but only the result of the first 
+will be returned.</p>
+
+<p>The remote TCP/IP servers are started in the following way:</p>
+
+
+<pre>
+newlisp -c -d 4711 &amp;
+
+; preloading function definitions
+
+newlisp preload.lsp -c -d 12345 &amp;
+
+; logging connections
+
+newlisp -l -c -d 4711 &amp;
+
+; communicating via Uix local domain sockets
+
+newlisp -c /tmp/mysocket
+</pre>
+
+<p>The <tt>-c</tt> option is necessary to suppress newLISP emitting
+prompts.</p>
+
+<p>The <tt>-d</tt> daemon mode allows newLISP to maintain state between 
+connections.  When keeping state between connections is not desired, 
+the <a href="#inetd_daemon">inetd daemon mode</a> offers more advantages. 
+The Internet <tt>inetd</tt> or <tt>xinetd</tt> services daemon 
+will start a new newLISP process for each client connection. 
+This makes for much faster servicing of multiple connections. 
+In <tt>-d</tt> daemon mode, each new client request 
+would have to wait for the previous request to be finished. 
+See the chapter <a href="#inetd_daemon">inetd daemon mode</a> 
+on how to configure this mode correctly.</p>
+
+<p>Instead of <tt>4711</tt>, any other port number can be used. 
+Multiple nodes can be started on different hosts and with the same 
+or different port numbers.  The <tt>-l</tt> or <tt>-L</tt> logging options
+can be specified to log connections and remote commands.</p>
+
+
+<p>In the first syntax, <tt>net-eval</tt> talks to only one 
+remote newLISP server node, sending the host in <em>str-host</em>
+on port <em>int-port</em> a request to evaluate the expression 
+<em>exp</em>.  If <em>int-timeout</em> is not given, 
+<tt>net-eval</tt> will wait up to 60 seconds for a response
+after a connection is made.
+Otherwise, if the timeout in milliseconds has expired, 
+<tt>nil</tt> is returned; else, the evaluation result of <em>exp</em> 
+is returned.</p>
+
+<!-- example -->
+
+<pre>
+; the code to be evaluated is given in a quoted expression
+(net-eval "192.168.1.94" 4711 '(+ 3 4))       <span class='arw'>&rarr;</span> 7
+
+; expression as a string (only one expression should be in the string)
+(net-eval "192.168.1.94" 4711 "(+ 3 4)")      <span class='arw'>&rarr;</span> 7
+
+; with timeout
+(net-eval "192.168.1.94" 4711 '(+ 3 4) 1)     <span class='arw'>&rarr;</span> nil  ; 1ms timeout too short
+(net-error)                                   <span class='arw'>&rarr;</span> (17 "ERR: Operation timed out")
+
+(net-eval "192.168.1.94" 4711 '(+ 3 4) 1000)  <span class='arw'>&rarr;</span> 7
+
+; program contained in a variable
+(set 'prog '(+ 3 4))
+(net-eval "192.168.1.94" 4711 prog)           <span class='arw'>&rarr;</span> 7
+
+; specify a local-domain Unix socket (not available on MS Windows)
+(net-eval "/tmp/mysocket" 0 '(+ 3 4))         <span class='arw'>&rarr;</span> 7
+</pre>
+
+
+<p>The second syntax of <tt>net-eval</tt> returns a list of the results
+after all of the responses are collected or timeout occurs. Responses that 
+time out return <tt>nil</tt>.  The last example line shows how to specify
+a local-domain Unix socket specifying the socket path and a port number of 
+<tt>0</tt>.  Connection errors or errors that occur when sending information 
+to nodes are returned as a list of error numbers and descriptive error 
+strings.  See the function <a href="#net-error">net-error</a> for a list of 
+potential error messages.</p>
+
+<!-- example -->
+
+<pre>
+; two different remote nodes different IPs
+(net-eval '(
+    ("192.168.1.94" 4711 '(+ 3 4)) 
+    ("192.168.1.95" 4711 '(+ 5 6))
+    ) 5000)
+<span class='arw'>&rarr;</span> (7 11)
+
+; two persistent nodes on the same CPU different ports
+(net-eval '(
+    ("localhost" 8081 '(foo "abc")) 
+    ("localhost" 8082 '(myfunc 123)') 
+    ) 3000)
+
+; inetd or xinetd nodes on the same server and port
+; nodes are loaded on demand
+(net-eval '(
+    ("localhost" 2000 '(foo "abc")) 
+    ("localhost" 2000 '(myfunc 123))
+    ) 3000)
+</pre>
+
+
+<p>The first example shows two expressions evaluated on two different remote 
+nodes. In the second example, both nodes run on the local computer. This may 
+be useful when debugging or taking advantage of multiple CPUs on the same 
+computer.  When specifying <tt>0</tt> for the port number , <tt>net-eval</tt> 
+takes the host name as the file path to the local-domain Unix socket.</p>
+
+<p>Note that definitions of <tt>foo</tt> and <tt>myfunc</tt> must both
+exist in the target environment. This can be done using a <tt>net-eval</tt>
+sending <tt>define</tt> statements before. It also can be done by
+preloading code when starting remote nodes.</p>
+
+<p>When nodes are inetd or xinetd-controlled, several nodes may have the 
+same IP address and port number. In this case, the Unix 
+daemon inetd or xinetd will start multiple newLISP servers on demand. 
+This is useful when testing distributed programs on just one machine. 
+The last example illustrates this case. It is also useful on multi core
+CPUs, where the platform OS can distribute different processes on to different
+CPU cores.</p>
+
+<p>The source sent for evaluation can consist of entire multiline programs. 
+This way, remote nodes can be loaded with programs first, then specific 
+functions can be called.  For large program files, the functions 
+<a href="#put-url">put-url</a> or <a href="#save">save</a> (with a URL 
+file name) can be used to transfer programs. The a <tt>net-eval</tt>
+statement could load these programs.</p>
+
+<p>Optionally, a handler function can be specified. This function will be 
+repeatedly called while waiting and once for every remote evaluation completion.</p>
+
+<!-- example -->
+
+<pre>
+(define (myhandler param)
+    (if param
+        (println param))
+)
+
+(set 'Nodes '(
+    ("192.168.1.94" 4711)
+    ("192.168.1.95" 4711)
+))
+
+(set 'Progs '(
+    (+ 3 4)
+    (+ 5 6)
+))
+
+(net-eval (map (fn (n p) (list (n 0) (n 1) p)) Nodes Progs) 5000 myhandler)
+<span class='arw'>&rarr;</span>
+("192.168.1.94" 4711 7)
+("192.168.1.95" 4711 11)
+</pre>
+
+<p>The example shows how the list of node specs can be assembled from a list 
+of nodes and sources to evaluate. This may be useful when connecting to a 
+larger number of remote nodes.</p>
+
+<pre>
+(net-eval (list 
+  (list (Nodes 0 0) (Nodes 0 1) (Progs 0)) 
+  (list (Nodes 1 0) (Nodes 1 1) (Progs 1)) 
+ ) 3000 myhandler)
+</pre>
+
+<p>While waiting for input from remote hosts, <tt>myhandler</tt> will be called 
+with <tt>nil</tt> as the argument to <tt>param</tt>.  When a remote node result 
+is completely received, <tt>myhandler</tt> will be called with <tt>param</tt> 
+set to a list containing the remote host name or IP number, the port, and the 
+resulting expression. <tt>net-eval</tt> will return <tt>true</tt> before a 
+timeout or <tt>nil</tt> if the timeout was reached or exceeded.  All remote hosts 
+that exceeded the timeout limit will contain a <tt>nil</tt> in their results list.
+</p>
+
+<p>For a longer example see this program:
+<a href="http://www.newlisp.org/syntax.cgi?code/mapreduce.txt">mapreduce</a>.
+The example shows how a word counting task gets distributed to three remote
+nodes. The three nodes count words in different texts and the master node
+receives and consolidates the results.</p>
+
+<br/><br/>
+
+<a name="net-interface"></a>
+<h2><span class="function">net-interface</span></h2>
+<h4>syntax: (net-interface <em>str-ip-addr</em>)<br/>
+syntax: (net-interface)</h4>
+
+<p>Sets the default local interface address to be used for network connections.
+If not set then network functions will default to an internal default address,
+except when overwritten by an optional interface address given in 
+<a href="#net-listen">net-listen</a>.</p>
+
+<p>When no <em>str-ip-addr</em> is specified, the current default is returned.
+If the <tt>net-interface</tt> has not been used yet to specify an IP address,
+the address <tt>0.0.0.0</tt> is returned. This means that all network routines
+will use the default address preconfigured by the underlying operating system.</p>
+
+<p>This function has only usage on multihomed servers with either multiple network 
+interface hardware or otherwise supplied multiple IP numbers. On all other machines 
+network functions will automatically select the single network interface installed.</p>
+
+<p>On error the function returns <tt>nil</tt> and <a href="#net-error">net-error</a>
+can be used to report the error.</p>
+
+<!-- example -->
+
+<pre>
+(net-interface "192.168.1.95")  <span class='arw'>&rarr;</span> "192.168.1.95"
+(net-interface "localhost")     <span class='arw'>&rarr;</span> "127.0.0.1"
+</pre>
+
+
+<p>An interface address can be defined as either an IP address or a name. The
+return value is the address given in <em>str-ip-addr</em></p>
+
+<br/><br/>
+
+<a name="net-ipv"></a>
+<h2><span class="function">net-ipv</span></h2>
+<h4>syntax: (net-ipv <em>int-version</em>)<br/>
+syntax: (net-ipv)</h4>
+
+<p>Switches between IPv4 and IPv6 internet protocol versions. 
+<em>int-version</em> contains either a 4 for IPv4 or a 6 for IPv6. When no 
+parameter is given, <tt>net-ipv</tt> returns the current setting.</p>
+
+<!-- example -->
+
+<pre>
+(net-ipv)      <span class='arw'>&rarr;</span> 4
+(net-ipv 6)    <span class='arw'>&rarr;</span> 6
+</pre>
+
+<p>By default newLISP starts up in IPv4 mode. The IPv6 protocol mode can also 
+be specified from the commandline when starting newlisp:</p>
+
+<pre>
+newlisp -6
+</pre>
+
+<p>Once a socket is connected with either 
+<a href="#net-connect">net-connect</a> 
+or listened on with 
+<a href="#net-listen">net-listen</a>, the 
+<a href="#net-accept">net-accept</a>, <a href="#net-select">net-select</a>, 
+<a href="#net-send">net-send</a>, <a href="#net-receive">net-receive</a> and 
+<a href="#net-receive-from">net-receive-from</a> 
+functions automatically adjust to the address protocol used when creating the sockets.
+
+Different connections with different IPv4/6 settings can be open at the same time.</p>
+
+<p>Note, that currently <a href="#net-packet">net-packet</a> does not support IPv6 and will 
+work in IPv4 mode regardless of settings.</p>
+
+<br/><br/>
+
+<a name="net-listen"></a>
+<h2><span class="function">net-listen</span></h2>
+<h4>syntax: (net-listen <em>int-port</em> [<em>str-ip-addr</em> [<em>str-mode</em>]])<br/>
+syntax: (net-listen <em>str-file-path</em>)</h4>
+
+<p>Listens on a port specified in <em>int-port</em>.  A call to <tt>net-listen</tt>
+returns immediately with a socket number, which is then used by 
+the blocking <a href="#net-accept">net-accept</a> function 
+to wait for a connection.  As soon as a connection is accepted, 
+<a href="#net-accept">net-accept</a> returns a socket number 
+that can be used to communicate with the connecting client.</p>
+
+
+<!-- example -->
+
+<pre>
+(set 'port 1234)
+(set 'listen (net-listen port))
+(unless listen (begin
+    (print "listening failed\n")
+    (exit)))
+
+(print "Waiting for connection on: " port "\n")
+
+(set 'connection (net-accept listen))
+(if connection
+    (while (net-receive connection buff 1024 "\n")
+        (print buff)
+        (if (= buff "\r\n") (exit)))
+    (print "Could not connect\n"))
+</pre>
+
+
+<p>The example waits for a connection on port 1234, then reads incoming lines 
+until an empty line is received.  Note that listening on ports lower than 1024
+may require superuser access on Unix systems.</p>
+
+<p>On computers with more than one interface card, specifying an optional 
+interface IP address or name in <em>str-ip-addr</em> directs <tt>net-listen</tt> 
+to listen on the specified address.</p>
+
+
+<pre>
+;; listen on a specific address
+(net-listen port "192.168.1.54") 
+</pre>
+
+
+<h3>Local domain Unix sockets</h3>
+
+<p>In the second syntax, <tt>net-listen</tt> listens for a client on the 
+local file system via a <em>local domain Unix socket</em> named using 
+<em>str-file-path</em>.	If successful, returns a socket handle that can be 
+used with <a href="#net-accept">net-accept</a> to accept a client connection; 
+otherwise, returns <tt>nil</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(net-listen "/tmp/mysocket")  <span class='arw'>&rarr;</span> 5
+
+; on OS/2 use "\\socket\\" prefix
+
+(net-listen "\\socket\\mysocket")
+
+(net-accept 5)
+</pre>
+
+
+<p>A <em>local domain</em> file system socket is created and listened on.
+A client will try to connect using the same <em>str-file-path</em>.
+After a connection has been accepted the functions <a href="#net-select">net-select</a>,
+<a href="#net-send">net-send</a> and <a href="#net-receive">net-receive</a> can be used 
+as usual for TCP/IP stream communications. This type of connection can be used as a fast
+ bi-directional communications channel between processes on the same file system.
+This type of connection is not available on MS Windows platforms.</p>
+
+
+<h3>UDP communications</h3>
+
+<p>
+As a third parameter, 
+the optional string <tt>"udp"</tt> or <tt>"u"</tt> 
+can be specified in <em>str-mode</em> 
+to create a socket suited for UDP 
+(User Datagram Protocol) communications.
+A socket created in this way 
+can be used directly with 
+<a href="#net-receive-from">net-receive-from</a>
+to await incoming UDP data 
+<em>without</em> using <tt>net-accept</tt>, 
+which is only used in TCP communications. 
+The <a href="#net-receive-from">net-receive-from</a> call 
+will block until a UDP data packet is received. 
+Alternatively, <a href="#net-select">net-select</a> 
+or <a href="#net-peek">net-peek</a> can be used 
+to check for ready data in a non-blocking fashion. 
+To send data back to the address and port received 
+with <a href="#net-receive-from">net-receive-from</a>, 
+use <a href="#net-send-to">net-send-to</a>.
+</p>
+
+<p>
+Note that <a href="#net-peer">net-peer</a> will not work, 
+as UDP communications do not maintain 
+a connected socket with address information.
+</p>
+
+
+<pre>
+(net-listen 10002 "192.168.1.120" "udp") 
+
+(net-listen 10002 "" "udp") 
+</pre>
+
+
+<p>
+The first example listens on a specific network adapter, 
+while the second example listens on the default adapter. 
+Both calls return a socket number 
+that can be used in subsequent <a href="#net-receive">net-receive</a>,
+<a href="#net-receive-from">net-receive-from</a>, 
+<a href="#net-send-to">net-send-to</a>,
+<a href="#net-select">net-select</a>, 
+or <a href="#net-peek">net-peek</a> function calls.
+</p>
+
+<p>
+Both a UDP server <em>and</em> UDP client 
+can be set up using <tt>net-listen</tt> 
+with the <tt>"udp"</tt> option. 
+In this mode, <tt>net-listen</tt> 
+does not really <em>listen</em>
+as in TCP/IP communications; 
+it just binds the socket 
+to the local interface address and port.
+</p>
+
+<p>
+For a working example, see the files 
+<tt>examples/client</tt> and <tt>examples/server</tt>
+in the newLISP source distribution.
+</p>
+
+<p>
+Instead of <tt>net-listen</tt> 
+and the <tt>"udp"</tt> option,
+the functions <a href="#net-receive-udp">net-receive-udp</a>  
+and <a href="#net-send-udp">net-send-udp</a>
+can be used for short transactions 
+consisting only of one data packet.
+</p>
+
+<p>
+<tt>net-listen</tt>, <a href="#net-select">net-select</a>, 
+and <a href="#net-peek">net-peek</a> can be used 
+to facilitate non-blocking reading. 
+The listening/reading socket is not closed 
+but is used again for subsequent reads. 
+In contrast, when the 
+<a href="#net-receive-udp">net-receive-udp</a> 
+and <a href="#net-send-udp">net-send-udp</a> pair is used, 
+both sides close the sockets after sending and receiving.
+</p>
+
+
+<h3>UDP multicast communications</h3>
+
+<p>
+If the optional string <em>str-mode</em> is specified as 
+<tt>"multi"</tt> or <tt>"m"</tt>, 
+<tt>net-listen</tt> returns a socket suitable for multicasting. 
+In this case, <em>str-ip-addr</em> contains one 
+of the multicast addresses in the range <tt>224.0.0.0</tt> 
+to <tt>239.255.255.255</tt>.
+<tt>net-listen</tt> will register <em>str-ip-addr</em> 
+as an address on which to receive multicast transmissions. 
+This address should not be confused with the IP address 
+of the server host.
+</p>
+
+
+<!-- example -->
+
+<pre>
+;; example client
+
+(net-connect "226.0.0.1" 4096 "multi")  <span class='arw'>&rarr;</span> 3
+
+(net-send-to "226.0.0.1" 4096 "hello" 3)
+
+
+;; example server
+
+(net-listen 4096 "226.0.0.1" "multi")  <span class='arw'>&rarr;</span> 5
+
+(net-receive-from 5 20)               
+<span class='arw'>&rarr;</span> ("hello" "192.168.1.94" 32769)
+</pre>
+
+
+<p>On the server side, 
+<a href="#net-peek">net-peek</a> or <a href="#net-select">net-select</a>
+can be used for non-blocking communications.  In the example above, 
+the server would block until a datagram is received.</p>
+
+<p>
+The <a href="#net-send">net-send</a> 
+and <a href="#net-receive">net-receive</a> functions 
+can be used instead of <a href="#net-send-to">net-send-to</a> 
+and <a href="#net-receive-from">net-receive-from</a>.
+</p>
+
+
+<h3>Packet divert sockets and ports</h3>
+
+<p>If <em>str-mode</em> is specified as <tt>"divert"</tt> or <tt>"d"</tt>, 
+a divert socket can be created for a divert port in <em>int-port</em> on 
+BSD like platforms.  The content of IP address in <em>str-ip-addr</em> is 
+ignored and can be specified as an empty string. Only the <em>int-port</em> 
+is relevant and will be bound to the raw socket returned.</p>
+
+<p>To use the divert option in <tt>net-listen</tt>, newLISP must run in
+super-user mode. This option is only available on Unix like platforms.</p>
+
+<p>The divert socket will receive all raw packets diverted 
+to the divert port. Packets may also be written back to a divert socket, 
+in which case they re-enter OS kernel IP packet processing.</p>
+
+<p>Rules for packet diversion to the divert port must be defined using 
+either the <em>ipfw</em> BSD or <em>ipchains</em> Linux configuration
+utilities.</p>
+
+<p>The <a href="#net-receive-from">net-receive-from</a> and
+<a href="#net-send-to">net-send-to</a> functions are used to read
+and write raw packets on the divert socket created and returned by the
+<tt>net-listen</tt> statement. The same address received by
+<a href="#net-receive-from">net-receive-from</a> is used in the 
+<a href="#net-send-to">net-send-to</a> call when re-injecting the 
+packet:</p>
+
+<pre>
+; rules have been previously configured for a divert port
+(set 'divertSocket (net-listen divertPort "" "divert"))
+
+(until (net-error)
+    (set 'rlist (net-receive-from divertSocket maxBytes))
+    (set 'buffer (rlist 1))
+    ; buffer can be processed here before reinjecting
+    (net-send-to (rlist 0) divertPort buffer divertSocket)
+)
+</pre>
+
+<p>For more information see the Unix man pages for <em>divert</em>
+and the <em>ipfw</em> (BSDs) or <em>ipchains</em> (Linux) configuration 
+utilities.</p>
+
+<br/><br/>
+
+<a name="net-local"></a>
+<h2><span class="function">net-local</span></h2>
+<h4>syntax: (net-local <em>int-socket</em>)</h4>
+
+<p>Returns the IP number and port of the local computer 
+for a connection on a specific <em>int-socket</em>.</p>
+
+<!-- example -->
+
+<pre>
+(net-local 16)  <span class='arw'>&rarr;</span> ("204.179.131.73" 1689)
+</pre>
+
+<p>
+Use the <a href="#net-peer">net-peer</a> 
+function to access the remote computer's 
+IP number and port.
+</p>
+
+<br/><br/>
+
+<a name="net-lookup"></a>
+<h2><span class="function">net-lookup</span></h2>
+
+<h4>syntax: (net-lookup <em>str-ip-number</em>)<br/>
+syntax: (net-lookup <em>str-hostname</em> [<em>bool</em>])</h4>
+
+
+<p>
+Returns either a hostname string 
+from <em>str-ip-number</em> 
+in IP dot format or the IP number 
+in dot format from <em>str-hostname</em>:
+</p>
+
+<!-- example -->
+
+<pre>
+(net-lookup "209.24.120.224")    <span class='arw'>&rarr;</span> "www.nuevatec.com"
+(net-lookup "www.nuevatec.com")  <span class='arw'>&rarr;</span> "209.24.120.224"
+
+(net-lookup "216.16.84.66.sbl-xbl.spamhaus.org" true)
+<span class='arw'>&rarr;</span> "216.16.84.66"
+</pre>
+
+
+<p>
+Optionally,	a <em>bool</em> flag 
+can be specified in the second syntax. 
+If the expression in <em>bool</em> 
+evaluates to anything other than <tt>nil</tt>,
+host-by-name lookup will be forced, 
+even if the name string starts 
+with an IP number.
+</p>
+
+<br/><br/>
+
+<a name="net-packet"></a>
+<h2><span class="function">net-packet</span></h2>
+<h4>syntax: (net-packet <em>str-packet</em>)</h4>
+
+<p>The function allows custom configured network packets to be sent via
+a <em>raw sockets</em> interface. The packet in <em>str-packet</em> must
+start with an IP (Internet Protocol) header followed by either
+a TCP, UDP or ICMP header and optional data. newLISP must be run with
+super user privileges, and this function is only available on Mac OS X,
+Linux and other Unix operating systems and only for IPv4.
+Currently <tt>net-packet</tt> is IPv4 only and has been tested on
+Mac OS X, Linux and OpenBSD.</p> 
+
+<p>On success the function returns the number of bytes sent. On failure
+the function returns <tt>nil</tt> and both, <a href="#net-error">net-error</a>
+and <a href="#sys-error">sys-error</a>, should be inspected.</p>
+
+<p>When custom configured packets contain zeros in the checksum fields,
+<tt>net-packet</tt> will calculate and insert the correct checksums. 
+Already existing checksums stay untouched.</p>
+
+<p>The following example injects a UDP packet for IP number <tt>192.168.1.92</tt>.
+The IP header consists of 20 bytes ending with the target IP number. The following
+UDP header has a length of 8 bytes and is followed by the data string
+<tt>Hello World</tt>. The checksum bytes in both headers are left as 
+<tt>0x00 0x00</tt> and will be recalculated internally.</p>
+
+<!-- example -->
+
+<pre>
+; packet as generated by: (net-send-udp "192.168.1.92" 12345 "Hello World")
+
+(set 'udp-packet (pack (dup "b" 39) '(
+    0x45 0x00 0x00 0x27 0x4b 0x8f 0x00 0x00 0x40 0x11 0x00 0x00 192  168  1    95
+    192  168  1    92   0xf2 0xc8 0x30 0x39 0x00 0x13 0x00 0x00 0x48 0x65 0x6c 0x6c
+    0x6f 0x20 0x57 0x6f 0x72 0x6c 0x64)))
+
+(unless (net-packet udp-packet)
+    (println "net-error: " (net-error))
+    (println "sys-error: " (sys-error)))
+</pre>
+
+<p>The <tt>net-packet</tt> function is used when testing net security. 
+Its wrong application can upset the correct functioning of network routers and 
+other devices connected to a network. For this reason the function should only 
+be used on well isolated, private intra-nets and only by network professionals.</p>
+
+<p>For other examples of packet configuration, see the file 
+<tt>qa-specific-tests/qa-packet</tt> in the newLISP source distribution.</p>
+
+<br/><br/>
+
+<a name="net-peek"></a>
+<h2><span class="function">net-peek</span></h2>
+<h4>syntax: (net-peek <em>int-socket</em>)</h4>
+
+<p>
+Returns the number of bytes 
+ready for reading 
+on the network socket <em>int-socket</em>.
+If an error occurs 
+or the connection is closed,
+<tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'aSock (net-connect "aserver.com" 123))
+
+(while ( = (net-peek aSock) 0) 
+    (do-something-else))
+
+(net-receive aSock buff 1024)
+</pre>
+
+
+<p>
+After connecting, the program 
+waits in a while loop 
+until <tt>aSock</tt> can be read.
+</p>
+
+<p>
+Use the <a href="#peek">peek</a> function
+to check file descriptors and <tt>stdin</tt>.
+</p>
+
+<br/><br/>
+
+<a name="net-peer"></a>
+<h2><span class="function">net-peer</span></h2>
+<h4>syntax: (net-peer <em>int-socket</em>)</h4>
+
+<p>
+Returns the IP number and port number 
+of the remote computer 
+for a connection on <em>int-socket</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(net-peer 16)  <span class='arw'>&rarr;</span> ("192.100.81.100" 13)
+</pre>
+
+
+<p>
+Use the <a href="#net-local">net-local</a> function
+to access the local computer's IP number and port number.
+</p>
+
+<br/><br/>
+
+<a name="net-ping"></a>
+
+<h2><span class="function">net-ping</span></h2>
+<h4>syntax: (net-ping <em>str-address</em> [<em>int-timeout</em> [<em>int-count</em> <em>bool</em>]]])<br/>
+syntax: (net-ping <em>list-addresses</em> [<em>int-timeout</em> [<em>int-count</em> <em>bool</em>]]])</h4>
+
+<p> This function is only available on Unix-based systems 
+and must be run in superuser mode, i.e. using: <tt>sudo newlisp</tt> to
+start newLISP on Mac OS X or other BSD's, or as the root user on Linux.
+ Broadcast mode and specifying ranges with the <tt>-</tt> (hyphen) or
+<em>*</em> (star) are not available on IPv6 address mode.</p>
+
+<p>Superuser mode is not required on Mac OS X.</p>
+
+<p> In the first syntax, <tt>net-ping</tt> sends a ping 
+ICMP 64-byte echo request to the address specified in <em>str-address</em>. 
+If it is a broadcast address, the ICMP packet will be received 
+by all addresses on the subnet.  Note that for security reasons, 
+many computers do not answer ICMP broadcast ping (ICMP_ECHO) requests. 
+An optional timeout parameter can be specified in <em>int-timeout</em>.
+If no timeout is specified, a waiting time of 1000 milliseconds 
+(one second) is assumed.</p> 
+
+<p> <tt>net-ping</tt> returns either a list of lists of IP strings 
+and round-trip time in microseconds for which a response was received 
+or an empty list if no response was received.</p>
+
+<p>
+A return value of <tt>nil</tt> 
+indicates a failure. 
+Use the <a href="#net-error">net-error</a> function 
+to retrieve the error message.  If the message reads <tt>Cannot open socket</tt>, 
+it is probably because newLISP is running without root permissions. 
+newLISP can be started using:
+</p>
+
+<pre>
+sudo newlisp
+</pre>
+
+<p>
+Alternatively, newLISP can be installed 
+with the set-user-ID bit set to run 
+in superuser mode.
+</p>
+
+<!-- example -->
+
+<pre>
+(net-ping "newlisp.org")     <span class='arw'>&rarr;</span> (("66.235.209.72" 634080))
+(net-ping "127.0.0.1")       <span class='arw'>&rarr;</span> (("127.0.0.1" 115))
+(net-ping "yahoo.com" 3000)  <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p>
+In the second syntax, <tt>net-ping</tt> is run in <em>batch mode</em>. 
+Only one socket is opened in this mode, but multiple ICMP packets are sent out&mdash;one 
+each to multiple addresses specified in a list or specified by range.
+Packets are sent out as fast as possible.  In this case, multiple answers can be received.
+If the same address is specified multiple times, the receiving IP address will be flooded
+with ICMP packets.</p>
+
+<p>
+To limit the number of responses to be waited for in broadcast or batch mode,
+an additional argument indicating the maximum number of responses to receive
+can be specified in <em>int-count</em>.  Usage of this parameter can cause 
+the function to return sooner than the specified timeout. 
+When a given number of responses has been received, <tt>net-ping</tt> will return  
+before the timeout has occurred. Not specifying <em>int-count</em> or specifying <tt>0</tt>
+assumes an <em>int-count</em> equal to the number of packets sent out.</p>
+
+<p>As third optional parameter, a <tt>true</tt> value can be specified. This setting will
+return an error string instead of the response time, if the host does not answer.</p>
+
+<!-- example -->
+
+<pre>
+(net-ping '("newlisp.org" "192.168.1.255") 2000 20)
+<span class='arw'>&rarr;</span> (("66.235.209.72" 826420) ("192.168.1.1" 124) ("192.168.1.254" 210))
+
+(net-ping "192.168.1.*" 500) ; from 1 to 254
+<span class='arw'>&rarr;</span> (("192.168.1.1" 120) ("192.168.1.2" 245) ("192.168.2.3" 180) ("192.168.2.254" 234))
+
+(net-ping "192.168.1.*" 500 2) ; returns after 2 responses
+<span class='arw'>&rarr;</span> (("192.168.1.3" 115) ("192.168.1.1" 145))
+
+(net-ping "192.168.1.1-10" 1000) ; returns after 1 second
+<span class='arw'>&rarr;</span> (("192.168.1.3" 196) ("192.168.1.1" 205))
+
+(net-ping '("192.168.1.100-120" "192.168.1.124-132") 2000) ; returns after 2 seconds
+<span class='arw'>&rarr;</span> ()
+</pre>
+
+
+
+<p>
+Broadcast or batch mode&mdash;as well as normal addresses 
+and IP numbers or hostnames&mdash; can be mixed in one <tt>net-ping</tt> statement by 
+putting all of the IP specs into a list.</p> 
+
+<p>
+The second and third lines show how the batch mode of <tt>net-ping</tt> 
+can be initiated by specifying the <tt>*</tt> (asterisk) 
+as a wildcard character for the last subnet octet
+in the IP number. The fourth and fifth lines show how an IP
+range can be specified for the last subnet octet in the IP number.
+<tt>net-ping</tt> will iterate through all numbers 
+from either 1 to 254 for the star <tt>*</tt> or the range specified, 
+sending an ICMP packet to each address. 
+Note that this is different from the <em>broadcast</em> mode 
+specified with an IP octet of <tt>255</tt>. 
+While in broadcast mode, <tt>net-ping</tt> sends out only one packet, 
+which is received by multiple addresses.  Batch mode explicitly generates 
+multiple packets, one for each target address. When specifying broadcast
+mode, <em>int-count</em> should be specified, too.</p>
+
+<p>
+When sending larger lists of IPs in batch mode over one socket, 
+a longer timeout may be necessary to allow enough time for all of the packets 
+to be sent out over one socket.  If the timeout is too short, 
+the function <tt>net-ping</tt> may return an incomplete list or the empty list <tt>()</tt>.
+In this case, <a href="#net-error">net-error</a> will return a timeout error.
+On error, <tt>nil</tt> is returned and  <a href="#net-error">net-error</a>
+can be used to retrieve an error message.</p>
+
+<p>
+On some systems only lists up to a specific length can be handled 
+regardless of the timeout specified. In this case, the range should
+ be broken up into sub-ranges and used with multiple <tt>net-ping</tt>
+invocations. In any case, <tt>net-ping</tt> will send out packages 
+as quickly as possible.
+</p>
+
+<br/><br/>
+
+<a name="net-receive"></a>
+<h2><span class="function">net-receive</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (net-receive <em>int-socket</em> <em>sym-buffer</em> <em>int-max-bytes</em> [<em>wait-string</em>])</h4>
+
+<p>
+Receives data on the socket <em>int-socket</em> into a string contained in <em>sym-buffer</em>. 
+<em>sym-buffer</em> can also be a default functor specified by a context symbol 
+for reference passing in and out of user-defined functions.</p>
+
+<p> A maximum of 
+<em>int-max-bytes</em> is received. <tt>net-receive</tt> returns the number of 
+bytes read.  If there is a break in the connection, <tt>nil</tt> is returned. 
+The space reserved in <em>sym-buffer</em> is exactly the size of bytes read.</p>
+
+<p>
+Note that <tt>net-receive</tt> is a blocking call 
+and does not return until the data arrives at <em>int-socket</em>. 
+Use <a href="#net-peek">net-peek</a> 
+or <a href="#net-select">net-select</a> to find out 
+if a socket is ready for reading.
+</p>
+
+<p>
+Optionally, a <em>wait-string</em> 
+can be specified 
+as a fourth parameter. 
+<tt>net-receive</tt> then returns after 
+a character or string of characters 
+matching <em>wait-string</em>
+is received. 
+The <em>wait-string</em> will be part 
+of the data contained in <em>sym-buffer</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (gettime)
+    (set 'socket (net-connect "netcom.com" 13))
+    (net-receive socket buf 256)
+    (print buf "\n")
+    (net-close socket))
+</pre>
+
+
+<p>
+When calling <tt>gettime</tt>, 
+the program connects to port 13 
+of the server netcom.com. 
+Port 13 is a date-time service 
+on most server installations. 
+Upon connection, the server sends 
+a string containing the date and time of day.
+</p>
+
+
+<pre>
+(define (net-receive-line socket sBuff)
+    (net-receive socket sBuff 256 "\n"))
+
+(set 'bytesReceived (net-receive-line socket 'sm))
+</pre>
+
+
+<p>
+The second example defines a new function 
+<tt>net-receive-line</tt>, 
+which returns after receiving a newline character 
+(a string containing one character in this example) 
+or 256 characters. 
+The "\n" string is part of the contents of sBuff.
+</p>
+
+<p>
+Note that when the fourth parameter is specified, 
+<tt>net-receive</tt> is slower than the normal version 
+because information is read character-by-character. 
+In most situations, the speed difference can be neglected.
+</p>
+
+<br/><br/>
+
+<a name="net-receive-from"></a>
+<h2><span class="function">net-receive-from</span></h2>
+<h4>syntax: (net-receive-from <em>int-socket</em> <em>int-max-size</em>)</h4>
+
+<p>
+<tt>net-receive-from</tt> can be used to set up 
+non-blocking UDP communications. 
+The socket in <em>int-socket</em> 
+must previously have been opened 
+by either <a href="#net-listen">net-listen</a> 
+or <a href="#net-connect">net-connect</a> 
+(both using the <tt>"udp"</tt> option).
+<em>int-max-size</em> specifies 
+the maximum number of bytes that will be received. 
+On Linux/BSD, if more bytes are received, 
+those will be discarded; on MS Windows, <tt>net-receive-from</tt>
+returns <tt>nil</tt> and closes the socket.
+</p>
+
+<p>On success <tt>net-receive</tt> returns a list of the data string, remote 
+IP number and remote port used. On failure it returns <tt>nil</tt>.</p>
+
+<!-- example -->
+
+<pre>
+;; bind port 1001 and the default address
+(net-listen 1001 "" "udp")  <span class='arw'>&rarr;</span> 1980 
+
+;; optionally poll for arriving data with 100ms timeout
+(while (not (net-select 1980 "r" 100000)) (do-something ... ))
+
+(net-receive-from 1980 20)  <span class='arw'>&rarr;</span> ("hello" "192.168.0.5" 3240)
+
+;; send answer back to sender
+(net-send-to "192.168.0.5" 3240 "hello to you" 1980)
+
+(net-close 1980) ; close socket
+</pre>
+
+
+<p>The second line in this example is optional.  Without it, the 
+<tt>net-receive-from</tt> call would block until data arrives. 
+A UDP server could be set up by listening and polling several ports, 
+serving them as they receive data.</p>
+
+<p>Both, the sender and the receiver have to issue 
+<a href="#net-listen">net-listen</a> commands for UDP mode. Not for listening
+as in TCP/IP protocol communications, but to create the socket bound to
+the port and address. For a complete example see the files
+<tt>udp-server.lsp</tt> and <tt>udp-client.lsp</tt> in the 
+<tt>newlisp-x.x.x/examples/</tt> directory of the source distribution.</p>
+
+<p>
+Note that <tt>net-receive</tt> 
+could not be used in this case 
+because it does not return 
+the sender's address and port information, 
+which are required to talk back.
+In UDP communications, 
+the data packet itself 
+contains the address of the sender,
+<em>not</em> the socket over which 
+communication takes place.
+<tt>net-receive</tt> can also be used for TCP/IP communications.
+</p>
+
+<p>
+See also the <a href="#net-connect">net-connect</a> function 
+with the <tt>"udp"</tt> option and the 
+<a href="#net-send-to">net-send-to</a> function 
+for sending UDP data packets over open connections.
+</p>
+
+<p>
+For blocking short UDP transactions, 
+see the <a href="#net-send-udp">net-send-udp</a> 
+and <a href="#net-receive-udp">net-receive-udp</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="net-receive-udp"></a>
+<h2><span class="function">net-receive-udp</span></h2>
+<h4>syntax: (net-receive-udp <em>int-port</em> <em>int-maxsize</em> [<em>int-microsec</em> [<em>str-addr-if</em>]])</h4>
+
+<p>
+Receives a User Datagram Protocol (UDP) packet on port <em>int-port</em>,
+reading <em>int-maxsize</em> bytes. 
+If more than <em>int-maxsize</em> bytes are received,
+bytes over <em>int-maxsize</em> are discarded on Linux/BSD; 
+on MS Windows, <tt>net-receive-udp</tt> returns <tt>nil</tt>.
+<tt>net-receive-udp</tt> blocks until a datagram arrives 
+or the optional timeout value in <em>int-microsec</em> expires. 
+When setting up communications between datagram sender and receiver, 
+the <tt>net-receive-udp</tt> statement must be set up first.
+</p>
+
+
+<p>
+No previous setup using <tt>net-listen</tt> 
+or <tt>net-connect</tt> is necessary.
+</p>
+
+<p>
+<tt>net-receive-udp</tt> returns a list 
+containing a string of the UDP packet 
+followed by a string containing 
+the sender's IP number and the port used.
+</p>
+
+<!-- example -->
+
+<pre>
+;; wait for datagram with maximum 20 bytes 
+(net-receive-udp 10001 20) 
+
+;; or
+(net-receive-udp 10001 20 5000000)  ; wait for max 5 seconds
+		  
+;; executed on remote computer
+(net-send-udp "nuevatec.com" 1001 "Hello")  <span class='arw'>&rarr;</span> 4 
+
+;; returned from the net-receive-udp statement
+<span class='arw'>&rarr;</span> ("Hello" "128.121.96.1" 3312)  
+
+;; sending binary information
+(net-send-udp "ahost.com" 2222 (pack "c c c c" 0 1 2 3))  
+<span class='arw'>&rarr;</span> 4 
+
+;; extracting the received info
+(set 'buff (first (net-receive-udp 2222 10)))   
+
+(print (unpack "c c c c" buff))  <span class='arw'>&rarr;</span> (0 1 2 3)
+</pre>
+
+
+<p>
+See also the <a href="#net-send-udp">net-send-udp</a> 
+function for sending datagrams and 
+the <a href="#pack">pack</a> and <a href="#unpack">unpack</a> 
+functions for packing and unpacking binary information.
+</p>
+
+<p>
+To listen on a specified address 
+on computers with more than one interface card, 
+an interface IP address or name can be 
+optionally specified in <em>str-addr-if</em>. 
+When specifying <em>str-addr-if</em>, 
+a timeout must also be specified
+in <em>int-wait</em>.
+</p>
+
+<p>
+As an alternative, UDP communication 
+can be set up using <a href="#net-listen">net-listen</a>, 
+or <a href="#net-connect">net-connect</a> 
+together with the <tt>"udp"</tt> option 
+to make non-blocking data exchange possible 
+with <a href="#net-receive-from">net-receive-from</a> 
+and <a href="#net-send-to">net-send-to</a>.
+</p>
+
+<br/><br/>
+
+<a name="net-select"></a>
+<h2><span class="function">net-select</span></h2>
+<h4>syntax: (net-select <em>int-socket</em> <em>str-mode</em> <em>int-micro-seconds</em>)<br/>
+syntax: (net-select <em>list-sockets</em> <em>str-mode</em> <em>int-micro-seconds</em>)</h4>
+
+<p>
+In the first form, 
+<tt>net-select</tt> finds out about the status 
+of one socket specified in  <em>int-socket</em>. 
+Depending on <em>str-mode</em>, 
+the socket can be checked 
+if it is ready for reading or writing,
+or if the socket has an error condition. 
+A timeout value is specified in <em>int-micro-seconds</em>.
+</p>
+
+<p>
+In the second syntax, 
+<tt>net-select</tt> can check for a list of sockets 
+in <em>list-sockets</em>.
+</p>
+
+<p>
+The following value can be given for <em>str-mode</em>:
+</p>
+
+
+<tt>"read"</tt> or <tt>"r"</tt> to check if ready for reading or accepting.<br/>
+
+<tt>"write"</tt> or <tt>"w"</tt> to check if ready for writing.<br/>
+<tt>"exception"</tt> or <tt>"e"</tt> to check for an error condition.<br/>
+
+
+<p>
+Read, send, or accept operations 
+can be handled without blocking
+by using the <tt>net-select</tt> function. 
+<tt>net-select</tt> waits 
+for a socket to be ready 
+for the value given in <em>int-micro-seconds</em>, 
+then returns <tt>true</tt> or <tt>nil</tt>
+depending on the readiness of the socket.
+During the select loop, 
+other portions of the program can run. 
+On error, 
+<a href="#net-error">net-error</a> is set. 
+When <tt>-1</tt> is specified for <em>int-micro-seconds</em>, 
+<tt>net-select</tt> will never time out.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'listen-socket (net-listen 1001))
+
+;; wait for connection
+(while (not (net-select listen-socket "read" 1000))
+    (if (net-error) (print (net-error))))
+
+(set 'connection (net-accept listen-socket))
+(net-send connection "hello")
+
+;; wait for incoming message
+(while (not (net-select connection "read" 1000))
+    (do-something)) 
+
+(net-receive connection buff 1024)
+</pre>
+
+
+<p>
+When <tt>net-select</tt> is used, 
+several listen and connection sockets can be watched, 
+and multiple connections can be handled. 
+When used with a list of sockets, 
+<tt>net-select</tt> will return a list of ready sockets. 
+The following example would listen on two sockets 
+and continue accepting and servicing connections:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'listen-list '(1001 1002))
+
+; accept-connection, read-connection and write-connection
+; are user defined functions
+
+(while (not (net-error))
+    (dolist (conn (net-select listen-list "r" 1000))
+    (accept-connection conn))  ; build an accept-list
+
+    (dolist (conn (net-select accept-list "r" 1000))
+    (read-connection conn))    ; read on connected sockets
+
+    (dolist (conn (net-select accept-list "w" 1000))
+    (write-connection conn)))  ; write on connected sockets
+</pre>
+
+
+<p>
+In the second syntax, 
+a list  is returned 
+containing all the sockets 
+that passed the test;
+if timeout occurred, 
+an empty list is returned. 
+An error causes 
+<a href="#net-error">net-error</a> to be set.
+</p>
+
+<p>
+Note that supplying a nonexistent socket to <tt>net-select</tt> 
+will cause an error to be set in <a href="#net-error">net-error</a>.
+</p>
+
+<br/><br/>
+
+<a name="net-send"></a>
+<h2><span class="function">net-send</span></h2>
+<h4>syntax: (net-send <em>int-socket</em> <em>str-buffer</em> [<em>int-num-bytes</em>])</h4>
+
+<p>
+Sends the contents of <em>str-buffer</em> on the connection specified by <em>int-socket</em>. 
+If <em>int-num-bytes</em> is specified, up to <em>int-num-bytes</em> are sent. 
+If <em>int-num-bytes</em> is not specified, the entire contents will be sent.
+<tt>net-send</tt> returns the number of bytes sent or <tt>nil</tt> on failure.
+</p>
+
+<p>On failure, use <a href="#net-error">net-error</a> to get more error information.</p>
+
+<!-- example -->
+
+<pre>
+(set 'buf "hello there")
+
+(net-send sock buf)       <span class='arw'>&rarr;</span> 11
+(net-send sock buf 5)     <span class='arw'>&rarr;</span> 5
+
+(net-send sock "bye bye") <span class='arw'>&rarr;</span> 7
+</pre>
+
+
+<p>
+The first <tt>net-send</tt> sends the string <tt>"hello there"</tt>, while
+the second <tt>net-send</tt> sends only the string <tt>"hello"</tt>.
+</p>
+
+<br/><br/>
+
+<a name="net-send-to"></a>
+<h2><span class="function">net-send-to</span></h2>
+<h4>syntax: (net-send-to <em>str-remotehost</em> <em>int-remoteport</em> <em>str-buffer</em> <em>int-socket</em>)</h4>
+
+<p>Can be used for either UDP or TCP/IP communications. The socket in <em>int-socket</em> 
+must have previously been opened with a <a href="#net-connect">net-connect</a> 
+or <a href="#net-listen">net-listen</a> function. If the opening functions was used 
+with the <tt>"udp"</tt> option, <tt>net-listen</tt> or <tt>net-connect</tt>
+are not used to listen or to connect but only to create the UDP socket.
+The host in <em>str-remotehost</em> can be specified either as 
+a hostname or as an IP-number string.</p>
+
+<p>When using <tt>net-connect</tt> together with <tt>net-send-to</tt>, then 
+only one of the functions should specify the remote host. The other should leave 
+the address as an empty string.</p>
+
+<!-- example -->
+
+<pre>
+;;;;;;;;;;;;;;;;;; UDP server
+(set 'socket (net-listen 10001 "" "udp"))
+(if socket (println "server listening on port " 10001)
+       (println (net-error)))
+(while (not (net-error))
+   (set 'msg (net-receive-from socket 255))
+   (println "-&gt; " msg)
+   (net-send-to (nth 1 msg) (nth 2 msg) 
+                (upper-case (first msg)) socket))
+
+;;;;;;;;;;;;;;;;;; UDP client
+(set 'socket (net-listen 10002 "" "udp"))
+(if (not socket) (println (net-error)))
+(while (not (net-error))
+   (print "&gt; ")
+   (net-send-to "127.0.0.1" 10001 (read-line) socket)
+   (net-receive socket buff 255)
+   (println "-&gt; " buff))
+</pre>
+
+
+<p>In the examples both, the client and the server use <tt>net-listen</tt> to
+create the UDP socket for sending and receiving. The server extracts 
+the client address and port from the message received and uses it in the 
+<tt>net-send-to</tt> statement.</p>
+
+<p>See also the <a href="#net-receive-from">net-receive-from</a> function
+and the <a href="#net-listen">net-listen</a> function with the 
+<tt>"udp"</tt> option.</p>
+
+<p>For blocking short UDP transactions use <a href="#net-send-udp">net-send-udp</a> 
+and <a href="#net-receive-udp">net-receive-udp</a>.</p>
+
+<br/><br/>
+
+<a name="net-send-udp"></a>
+<h2><span class="function">net-send-udp</span></h2>
+<h4>syntax: (net-send-udp <em>str-remotehost</em> <em>int-remoteport</em> <em>str-buffer</em> [<em>bool</em>])</h4>
+
+<p>
+Sends a User Datagram Protocol (UDP) 
+to the host specified in <em>str-remotehost</em> 
+and to the port in <em>int-remoteport</em>. 
+The data sent is in <em>str-buffer</em>.
+</p>
+
+<p>The theoretical maximum data size of a UDP packet on an IPv4 system
+is 64K minus IP layer overhead, but much smaller on most Unix flavors.
+8k seems to be a safe size on Mac OS X, BSDs and Linux.</p>
+
+<p>
+No previous setup using <tt>net-connect</tt> 
+or <tt>net-listen</tt> is necessary. 
+<tt>net-send-udp</tt> returns immediately 
+with the number of bytes sent 
+and closes the socket used. 
+If no <tt>net-receive-udp</tt> statement 
+is waiting at the receiving side, 
+the datagram sent is lost. 
+When using datagram communications over insecure connections, 
+setting up a simple protocol between sender and receiver 
+is recommended for ensuring delivery. 
+UDP communication by itself 
+does not guarantee reliable delivery 
+as TCP/IP does.
+</p>
+
+<!-- example -->
+
+<pre>
+(net-send-udp "somehost.com" 3333 "Hello")  <span class='arw'>&rarr;</span> 5
+</pre>
+
+
+<p>
+<tt>net-send-udp</tt> is also suitable 
+for sending binary information 
+(e.g., the zero character or other non-visible bytes). 
+For a more comprehensive example, 
+see <a href="#net-receive-udp">net-receive-udp</a>.
+</p>
+
+<p>
+Optionally, the sending socket 
+can be put in broadcast mode 
+by specifying <tt>true</tt> 
+or any expression 
+not evaluating to <tt>nil</tt> 
+in <em>bool</em>:
+</p>
+
+
+<pre>
+(net-send-udp "192.168.1.255" 2000 "Hello" true)  <span class='arw'>&rarr;</span> 5
+</pre>
+
+
+<p>
+The UDP will be sent to all nodes 
+on the <tt>192.168.1</tt> network. 
+Note that on some operating systems, 
+sending the network mask <tt>255</tt> 
+without the <em>bool</em> <tt>true</tt> option 
+will enable broadcast mode.
+</p>
+
+<p>
+As an alternative, 
+the <a href="#net-connect">net-connect</a> function 
+using the <tt>"udp"</tt> option&mdash;together with 
+the <a href="#net-send-to">net-send-to</a> function&mdash;can 
+be used to talk to a UDP listener 
+in a non-blocking fashion.
+</p>
+
+<br/><br/>
+
+<a name="net-service"></a>
+<h2><span class="function">net-service</span></h2>
+<h4>syntax: (net-service <em>str-service</em> <em>str-protocol</em>)<br/>
+syntax: (net-service <em>int-port</em> <em>str-protocol</em>)</h4>
+
+<p>In the first syntax <tt>net-service</tt> makes a lookup in the 
+<em>services</em> database and returns the standard port number for 
+this service.</p>
+
+<p>In the second syntax a service port is supplied in <em>int-port</em>
+to look up the service name.</p>
+
+<p>Returns <tt>nil</tt> on failure.</p>
+
+<!-- example -->
+
+<pre>
+; get the port number from the name
+(net-service "ftp" "tcp")       <span class='arw'>&rarr;</span> 21
+(net-service "http" "tcp")      <span class='arw'>&rarr;</span> 80
+(net-service "net-eval" "tcp")  <span class='arw'>&rarr;</span> 4711  ; if configured
+
+; get the service name from the port number
+(net-service 22 "tcp")          <span class='arw'>&rarr;</span> "ssh"
+</pre>
+
+<br/><br/>
+
+<a name="net-sessions"></a>
+<h2><span class="function">net-sessions</span></h2>
+<h4>syntax: (net-sessions)</h4>
+
+<p>
+Returns a list of active listening and connection sockets.
+</p>
+
+<br/><br/>
+
+<a name="new"></a>
+<h2><span class="function">new</span></h2>
+<h4>syntax: (new <em>context-source</em> <em>sym-context-target</em> [<em>bool</em>])<br/>
+syntax: (new <em>context-source</em>)</h4>
+
+<p>The context <em>context-source</em> is copied to <em>sym-context-target</em>.
+If the target context does not exist, a new context with the same variable names 
+and user-defined functions as in <em>context-source</em> is created.
+If the target context already exists, then new symbols and definitions are added.
+Existing symbols are only overwritten when the expression in <em>bool</em>
+evaluates to anything other than <tt>nil</tt>; otherwise, the content of existing symbols
+will remain. This makes <em>mixins</em> of context objects possible. 
+<tt>new</tt> returns the target context, which cannot be MAIN.</p>
+
+<p>In the second syntax, the existing context in <em>context-source</em> gets 
+copied into the current context as the target context.</p>
+
+<p>All references to symbols in the originating context 
+will be translated to references in the target context.
+This way, all functions and data structures referring to symbols
+in the original context will now refer to symbols in the target context.</p>
+
+<!-- example -->
+
+<pre>
+(new CTX 'CTX-2)  <span class='arw'>&rarr;</span> CTX-2   
+
+;; force overwrite of existing symbols
+(new CTX MyCTX true)  <span class='arw'>&rarr;</span> MyCTX   
+</pre>
+
+
+<p>
+The first line in the example creates a new context 
+called <tt>CTX-2</tt> that has the exact same structure 
+as the original one. 
+Note that <tt>CTX</tt> is not quoted 
+because contexts evaluate to themselves, 
+but CTX-2 must be quoted because it does not exist yet.
+</p>
+
+<p>
+The second line merges the context <tt>CTX</tt> into <tt>MyCTX</tt>. 
+Any existing symbols of the same name in <tt>MyCTX</tt> 
+will be overwritten. 
+Because <tt>MyCTX</tt> already exists, 
+the quote before the context symbol can be omitted.
+</p>
+
+<p>
+Context symbols need not be mentioned explicitly, 
+but they can be contained in variables:
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'foo:x 123)
+(set 'bar:y 999)
+
+(set 'ctxa foo)
+(set 'ctxb bar)
+
+(new ctxa ctxb)  ; from foo to bar
+
+bar:x  <span class='arw'>&rarr;</span> 123  ; x has been added to bar
+bar:y  <span class='arw'>&rarr;</span> 999)
+</pre>
+
+
+<p>
+The example refers to contexts in variables 
+and merges context <tt>foo</tt> into <tt>bar</tt>.
+</p>
+
+
+<p>
+See also the function <a href="#def-new">def-new</a> 
+for moving and merging single functions 
+instead of entire contexts. 
+See the <a href="#context">context</a> function 
+for a more comprehensive example of <tt>new</tt>.
+</p>
+
+<br/><br/>
+
+<a name="nilp"></a>
+<h2><span class="function">nil?</span></h2>
+<h4>syntax: (nil? <em>exp</em>)</h4>
+
+<p>
+If the expression in <em>exp</em> evaluates to <tt>nil</tt>, 
+then <tt>nil?</tt> returns <tt>true</tt>; 
+otherwise, it returns <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(map nil? '(x nil  1 nil "hi" ()))
+<span class='arw'>&rarr;</span> (nil true nil true nil nil)
+
+(nil? nil)  <span class='arw'>&rarr;</span> true
+(nil? '())  <span class='arw'>&rarr;</span> nil
+
+; nil? means strictly nil
+(nil? (not '()))  <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p>
+The <tt>nil?</tt> predicate 
+is useful for distinguishing between 
+<tt>nil</tt> and the empty list <tt>()</tt>.
+</p>
+
+<p>Note that <tt>nil?</tt> means <em>strictly</em> <tt>nil</tt>
+while <tt>true?</tt> means everything not <tt>nil</tt> or the
+empty list <tt>()</tt>.</p>
+
+<br/><br/> 
+
+
+<a name="normal"></a>
+<h2><span class="function">normal</span></h2>
+<h4>syntax: (normal <em>float-mean</em> <em>float-stdev</em> <em>int-n</em>)<br/>
+syntax: (normal <em>float-mean</em> <em>float-stdev</em>)</h4>
+
+<p>
+In the first form, <tt>normal</tt> returns a list of length <em>int-n</em> 
+of random, continuously distributed floating point numbers 
+with a mean of <em>float-mean</em> 
+and a standard deviation of <em>float-stdev</em>. 
+The random generator used internally 
+can be seeded using the <a href="#seed">seed</a> function.
+</p>
+
+<!-- example -->
+
+<pre>
+(normal 10 3 10)
+<span class='arw'>&rarr;</span> (7 6.563476562 11.93945312 6.153320312 9.98828125
+7.984375 10.17871094 6.58984375 9.42578125 12.11230469)
+</pre>
+
+
+<p>
+In the second form, 
+<tt>normal</tt> returns a single 
+normal distributed floating point number:
+</p>
+
+<pre>
+(normal 1 0.2) <span class='arw'>&rarr;</span> 0.646875
+</pre>
+
+<p> When no parameters are given, <tt>normal</tt> assumes a mean of <tt>0.0</tt> 
+and a standard deviation of <tt>1.0</tt>.</p>
+
+
+<p>
+See also the <a href="#random">random</a> 
+and <a href="#rand">rand</a> functions 
+for evenly distributed numbers, 
+<a href="#amb">amb</a> for randomizing evaluation 
+in a list of expressions, 
+and <a href="#seed">seed</a> for setting a different start point 
+for pseudo random number generation.
+</p>
+
+<br/><br/>
+
+<a name="not"></a>
+<h2><span class="function">not</span></h2>
+
+<h4>syntax: (not <em>exp</em>)</h4>
+
+<p>If <em>exp</em> evaluates to <tt>nil</tt> or the empty list <tt>()</tt>, 
+then <tt>true</tt> is returned; otherwise, <tt>nil</tt> is returned.</p>
+
+<!-- example -->
+
+<pre>
+(not true)            <span class='arw'>&rarr;</span> nil
+(not nil)             <span class='arw'>&rarr;</span> true
+(not '())             <span class='arw'>&rarr;</span> true
+(not (&lt; 1 10))        <span class='arw'>&rarr;</span> nil
+(not (not (&lt; 1 10)))  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="now"></a>
+<h2><span class="function">now</span></h2>
+<h4>syntax: (now [<em>int-minutes-offset</em> [<em>int-index</em>]])</h4>
+
+<p>Returns information about the current date and time 
+as a list of integers.  An optional time-zone offset 
+can be specified in minutes in <em>int-minutes-offset</em>. 
+This causes the time to be shifted forward or backward in time,
+before being split into separate date values.</p>
+
+<p>An optional list-index in <em>int-index</em> makes <tt>now</tt>
+return a specific member in the result list.</p>
+
+<!-- example -->
+
+<pre>
+(now)       <span class='arw'>&rarr;</span> (2002 2 27 18 21 30 140000 57 3 -300 0)
+(now 0 -2)  <span class='arw'>&rarr;</span> -300 ; minutes west of GMT
+
+
+(date-value (now))  <span class='arw'>&rarr;</span> 1014834090
+</pre>
+
+
+<p>The numbers represent the following date-time fields:</p>
+
+<table  width="98%" summary="date formatting">
+<tr align="left"><th>format</th><th>description</th></tr>
+
+<tr><td>year</td><td>Gregorian calendar</td></tr>
+<tr><td>month</td><td>               (1&ndash;12)</td></tr>
+<tr><td>day</td><td>                 (1&ndash;31)</td></tr>
+<tr><td>hour</td><td>                (0&ndash;23) UTC</td></tr>
+<tr><td>minute</td><td>              (0&ndash;59)</td></tr>
+<tr><td>second</td><td>              (0&ndash;59)</td></tr>
+<tr><td>microsecond</td><td>         (0&ndash;999999) 
+		OS-specific, millisecond resolution</td></tr>
+		
+<tr><td>day of current year</td><td>Jan 1st is 1</td></tr>
+<tr><td>day of current week</td><td> (1&ndash;7) starting Monday</td></tr>
+<tr><td>time zone offset in minutes</td><td> west of GMT</td></tr>
+<tr><td>daylight savings time type </td><td> (0&ndash;6) on Linux/Unix
+		or bias in minutes on MS Windows</td></tr>
+</table><br/>
+
+<p>The second example returns the Coordinated Universal Time (UTC) 
+time value of seconds after January 1, 1970.</p>
+
+<p>Ranging from 0 to 23, hours are given in UTC and are not adjusted for 
+the local time zone.  The resolution of the <tt>microseconds</tt> field 
+depends on the operating system and platform.  On some platforms, 
+the last three digits of the <tt>microseconds</tt> field are always 
+<tt>0</tt> (zero).</p>
+
+<p>The "day of the week" field starts with 1 on Monday conforming to the 
+ISO 8601 international standard for date and time representation.</p>
+
+<p>On some platforms, the daylight savings time flag is not active and 
+returns <tt>0</tt> (zero) even during daylight savings time (dst).</p>
+
+<p>Depending on the geographical area, the daylight savings time type
+(dst) has a different value from 1 to 6:</p>
+
+<table  width="35%" summary="date formatting">
+<tr align="left"><th>type</th><th>area</th></tr>
+<tr><td>0</td><td>not on dst</td></tr>
+<tr><td>1</td><td>USA style dst</td></tr>
+<tr><td>2</td><td>Australian style dst</td></tr>
+<tr><td>3</td><td>Western European dst</td></tr>
+<tr><td>4</td><td>Middle European dst</td></tr>
+<tr><td>5</td><td>Eastern European dst</td></tr>
+<tr><td>6</td><td>Canada dst</td></tr>
+</table>
+
+
+<p>See also the <a href="#date">date</a>, 
+<a href="#date-list">date-list</a>, 
+<a href="#date-parse">date-parse</a>, 
+<a href="#date-value">date-value</a>, 
+<a href="#time">time</a>, and <a href="#time-of-day">time-of-day</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="nper"></a>
+<h2><span class="function">nper</span></h2>
+<h4>syntax: (nper <em>num-interest</em> <em>num-pmt</em> <em>num-pv</em> 
+[<em>num-fv</em> [<em>int-type</em>]])</h4>
+
+<p>Calculates the number of payments required to pay a loan of <em>num-pv</em> 
+with a constant interest rate of <em>num-interest</em> and payment <em>num-pmt</em>.
+If payment is at the end of the period, <em>int-type</em> is <tt>0</tt> (zero) 
+or <em>int-type</em> is omitted; for payment at the beginning of each period, 
+<em>int-type</em> is 1.</p>
+
+<!-- example -->
+
+<pre>
+(nper (div 0.07 12) 775.30 -100000)  <span class='arw'>&rarr;</span> 239.9992828
+</pre>
+
+
+<p>
+The example calculates the number of monthly payments required to pay a loan of 
+$100,000 at a yearly interest rate of 7 percent with payments of $775.30.
+</p>
+
+<p>
+See also the <a href="#fv">fv</a>,
+<a href="#irr">irr</a>,
+<a href="#npv">npv</a>,
+<a href="#pmt">pmt</a>,
+and <a href="#pv">pv</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="npv"></a>
+<h2><span class="function">npv</span></h2>
+<h4>syntax: (npv <em>num-interest</em> <em>list-values</em>)</h4>
+
+<p>
+Calculates the net present value of an investment with a fixed interest rate 
+<em>num-interest</em> and a series of future payments and income in <em>list-values</em>.
+Payments are represented by negative values in <em>list-values</em>,
+while income is represented by positive values in <em>list-values</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(npv 0.1 '(1000 1000 1000)) 
+<span class='arw'>&rarr;</span> 2486.851991
+
+(npv 0.1 '(-2486.851991 1000 1000 1000)) 
+<span class='arw'>&rarr;</span> -1.434386832e-08  ; ~ 0.0 (zero)
+</pre>
+
+
+<p>
+In the example,
+an initial investment of $2,481.85 would allow for an income of $1,000 after the end of the first,
+second,
+and third years.
+</p>
+
+<p>
+See also the <a href="#fv">fv</a>,
+<a href="#irr">irr</a>,
+<a href="#nper">nper</a>,
+<a href="#pmt">pmt</a>,
+and <a href="#pv">pv</a> functions.
+</p> 
+
+<br/><br/>
+
+<a name="nth"></a>
+<h2><span class="function">nth</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (nth <em>int-index</em> <em>list</em>)<br/>
+syntax: (nth <em>int-index</em> <em>array</em>)<br/>
+syntax: (nth <em>int-index</em> <em>str</em>)<br/><br/>
+
+syntax: (nth <em>list-indices</em> <em>list</em>)<br/>
+syntax: (nth <em>list-indices</em> <em>array</em>)</h4>
+
+<p>
+In the first syntax group <tt>nth</tt> uses <em>int-index</em> an index into the 
+<em>list</em>, <em>array</em> or <em>str</em> found and returning the element found 
+at that index. See also <a href="#indexing">Indexing elements of strings and lists</a>.</p>
+
+<p>Multiple indices may be specified to recursively access elements in nested lists
+or arrays. If there are more indices than nesting levels, the extra indices are ignored. 
+When multiple indices are used, they must be put in a list as shown in the second
+syntax group.</p>
+
+<!-- example -->
+
+<pre>
+(set 'L '(a b c))
+(nth 0 L)    <span class='arw'>&rarr;</span> a
+; or simply
+(L 0) <span class='arw'>&rarr;</span> a
+
+(set 'names '(john martha robert alex)) 
+<span class='arw'>&rarr;</span> (john martha robert alex)
+
+(nth 2 names)    <span class='arw'>&rarr;</span> robert
+; or simply
+(names 2)        <span class='arw'>&rarr;</span> robert
+
+(names -1)       <span class='arw'>&rarr;</span> alex
+
+
+; multiple indices
+(set 'persons '((john 30) (martha 120) ((john doe) 17)))
+
+(persons 1 1)           <span class='arw'>&rarr;</span> 120
+
+(nth '(2 0 1) persons)  <span class='arw'>&rarr;</span> doe
+
+; or simply
+(persons 2 0 1)        <span class='arw'>&rarr;</span> doe
+
+; multiple indices in a vector
+(set 'v '(2 0 1))
+(persons v)       <span class='arw'>&rarr;</span> doe
+(nth v persons)   <span class='arw'>&rarr;</span> doe
+
+; negative indices
+(persons -2 0)    <span class='arw'>&rarr;</span> martha
+
+; out-of-bounds indices cause error
+(persons 10)  <span class='arw'>&rarr;</span> <span class='err'>ERR: list index out of bounds</span>
+(person -5)   <span class='arw'>&rarr;</span> <span class='err'>ERR: list index out of bounds</span>
+</pre>
+
+
+<p>The list <tt>L</tt> can be the context of the default functor <tt>L:L</tt>. 
+This allows lists passed by reference:</p>
+
+<pre>
+(set 'L:L '(a b c d e f g))
+
+(define (second ctx)
+	(nth 1 ctx))
+
+(reverse L) <span class='arw'>&rarr;</span> (g f e d c b a)
+L:L <span class='arw'>&rarr;</span> (g f e d c b a)
+
+;; passing the list in L:L by reference
+(second L)   <span class='arw'>&rarr;</span> b
+
+;; passing the list in L:L by value
+(second L:L) <span class='arw'>&rarr;</span> b
+</pre>
+
+<p>Reference passing is faster and uses less memory in big lists and should
+be used on lists with more than a few hundred items.</p>
+
+<p>Note that the <i>implicit indexing</i> version of <tt>nth</tt> is not breaking newLISP
+syntax rules but should be understood as a logical expansion of newLISP syntax rules to
+other data types than built-in functions or lambda expressions. A list in the functor
+position of an s-expression assumes self-indexing functionality using the index
+arguments following.</p>
+
+<p>
+The implicit indexed syntax forms are faster but the other form with an explicit
+<tt>nth</tt> may be more readable in some situations.
+</p>
+
+<p><tt>nth</tt> works on <a href="#array">arrays</a> just like it does on lists:</p>
+
+<!-- example -->
+
+<pre>
+(set 'aArray (array 2 3 '(a b c d e f))) 
+<span class='arw'>&rarr;</span> ((a b c) (d e f))
+(nth 1 aArray)      <span class='arw'>&rarr;</span>  (d e f)
+(aArray 1)          <span class='arw'>&rarr;</span>  (d e f)
+
+(nth '(1 0) aArray)    <span class='arw'>&rarr;</span> d
+(aArray 1 0)           <span class='arw'>&rarr;</span> d
+(aArray '(1 0))        <span class='arw'>&rarr;</span> d
+
+(set 'vec '(1 0))
+(aArray vec)           <span class='arw'>&rarr;</span> d
+</pre>
+
+
+<p>
+In the String version, <tt>nth</tt> returns the character found at the position 
+<em>int-index</em> in <em>str</em> and returns it as a string.</p>
+
+<!-- example -->
+
+<pre>
+(nth  0 "newLISP")   <span class='arw'>&rarr;</span> "n"
+
+("newLISP" 0)        <span class='arw'>&rarr;</span> "n"
+
+("newLISP" -1)       <span class='arw'>&rarr;</span> "P"
+</pre>
+
+
+<p>Note that <a href="#nth">nth</a> works on character boundaries rather than byte 
+boundaries when using the UTF-8&ndash;enabled version of newLISP. To access ASCII and
+binary string buffers on single byte boundaries use <a href="#slice">slice</a>.</p>
+
+<p>See also <a href="#setf">setf</a> for modifying multidimensional lists and arrays and
+<a href="#push">push</a> and <a href="#pop">pop</a> for modifying lists.</p>
+
+<br/><br/>
+
+<a name="nullp"></a>
+<h2><span class="function">null?</span></h2>
+<h4>syntax: (null? <em>exp</em>)</h4>
+
+<p>
+Checks if an expression evaluates to <tt>nil</tt>,
+the empty list <tt>()</tt>,
+the empty string <tt>""</tt>,
+<tt>NaN</tt> (not a number),
+or <tt>0</tt> (zero),
+in which case it returns <tt>true</tt>.
+In all other cases,
+<tt>null?</tt> returns <tt>nil</tt>.
+The predicate <tt>null?</tt> is useful in conjunction with the functions 
+<a href="#filter">filter</a> or <a href="#clean">clean</a> to check the outcome of other newLISP operations.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x (sqrt -1)) <span class='arw'>&rarr;</span> NaN ; or nan on UNIX
+(null? x) <span class='arw'>&rarr;</span> true
+
+(map null? '(1 0 0.0 2 "hello" "" (a b c) () true))
+<span class='arw'>&rarr;</span> (nil true true nil nil true nil true nil) 
+
+(filter null? '(1 0 2 0.0 "hello" "" (a b c) () nil true)) 
+<span class='arw'>&rarr;</span> (0 0 "" () nil)
+
+(clean null? '(1 0 2 0.0 "hello" "" (a b c) () nil true))
+<span class='arw'>&rarr;</span> (1 2 "hello" (a b c) true)
+</pre>
+
+<p>
+See also the predicates <a href="#emptyp">empty?</a>,
+<a href="#nilp">nil?</a>
+and <a href="#zerop">zero?</a>.
+</p>
+
+<br/><br/>
+
+<a name="numberp"></a>
+<h2><span class="function">number?</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (number? <em>exp</em>)</h4>
+
+<p>
+<tt>true</tt> is returned only if <em>exp</em> evaluates to a floating point number or an integer;
+otherwise,
+<tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 1.23)
+(set 'y 456)
+(number? x)      <span class='arw'>&rarr;</span> true
+(number? y)      <span class='arw'>&rarr;</span> true
+(number? "678")  <span class='arw'>&rarr;</span> nil  
+</pre>
+
+
+<p>
+See the functions <a href="#floatp">float?</a> and <a href="#integerp">integer?</a> to test for a specific number type.
+</p>
+
+<br/><br/>
+
+<a name="oddp"></a>
+<h2><span class="function">odd?</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (odd? <em>int-number</em>)</h4>
+
+<p>Checks the parity of an integer number. If the number is not <em>even divisible</em> by <tt>2</tt>, 
+it has <em>odd</em> parity.  When a floating point number is passed for <em>int-number</em>, 
+it will be converted first to an integer by cutting off its fractional part.</p>
+
+<pre>
+(odd? 123)  <span class='arw'>&rarr;</span> true
+(odd? 8)    <span class='arw'>&rarr;</span> nil
+(odd? 8.7)  <span class='arw'>&rarr;</span> nil
+</pre>
+
+<p>Use <a href="#evenp">even?</a> to check if an integer is even, divisible by <tt>2</tt>.</p>
+
+<br/><br/>
+
+<a name="open"></a>
+<h2><span class="function">open</span></h2>
+
+<h4>syntax: (open <em>str-path-file</em> <em>str-access-mode</em> [<em>str-option</em>])</h4>
+
+<p>
+The <em>str-path-file</em> is a file name,
+and <em>str-access-mode</em> is a string specifying the file access mode.
+<tt>open</tt> returns an integer,
+which is a file handle to be used on subsequent read or write operations on the file.
+On failure,
+<tt>open</tt> returns <tt>nil</tt>.
+The access mode <tt>"write"</tt> creates the file if it doesn't exist,
+or it truncates an existing file to <tt>0</tt> (zero) bytes in length.
+</p>
+
+<p>
+The following strings are legal access modes:
+</p>
+
+
+<tt>"read"</tt> or <tt>"r"</tt> for read only access<br/>
+<tt>"write"</tt> or <tt>"w"</tt> for write only access<br/>
+<tt>"update"</tt> or <tt>"u"</tt> for read/write access<br/>
+<tt>"append"</tt> or <tt>"a"</tt> for append read/write access<br/>
+
+<br/>
+
+<!-- example -->
+
+<pre>
+(device (open "newfile.data" "write"))  <span class='arw'>&rarr;</span> 5
+(print "hello world\n")  <span class='arw'>&rarr;</span> "hello world"
+(close (device))         <span class='arw'>&rarr;</span> 5
+
+(set 'aFile (open "newfile.data" "read"))
+(seek aFile 6)
+(set 'inChar (read-char aFile))
+(print inChar "\n")
+(close aFile)
+</pre>
+
+
+<p>
+The first example uses <tt>open</tt> to set the device for <a href="#print">print</a> 
+and writes the word <tt>"hello world"</tt> into the file <tt>newfile.data</tt>.
+The second example reads a byte value at offset 6 in the same file (the ASCII value 
+of <tt>'w'</tt> is 119). Note that using <tt>close</tt> on <a href="#device">(device)</a> 
+automatically resets <a href="#device">device</a> to <tt>0</tt> (zero).
+</p>
+
+<p>
+As an additional <em>str-option</em>,
+<tt>"non-block"</tt> or <tt>"n"</tt> can be specified after the <tt>"read"</tt> or <tt>"write"</tt> option.
+Only available on Unix systems,
+non-blocking mode can be useful when opening <em>named pipes</em> but is not required to perform I/O on named pipes.
+</p>
+
+<br/><br/>
+
+<a name="or"></a>
+<h2><span class="function">or</span></h2>
+
+<h4>syntax: (or <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+Evaluates expressions <em>exp-x</em> from left to right until finding a result 
+that does not evaluate to <tt>nil</tt> or the empty list <tt>()</tt>.
+The result is the return value of the <tt>or</tt> expression.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 10)
+(or (&gt; x 100) (= x 10))          <span class='arw'>&rarr;</span> true
+(or "hello" (&gt; x 100) (= x 10))  <span class='arw'>&rarr;</span> "hello"
+(or '())                         <span class='arw'>&rarr;</span> ()
+(or true)                        <span class='arw'>&rarr;</span> true
+(or)                             <span class='arw'>&rarr;</span> nil
+</pre>
+
+<br/><br/>
+
+<a name="ostype"></a>
+<h2><span class="function">ostype</span></h2>
+<h4>syntax: ostype</h4>
+
+<p><tt>ostype</tt> is a built-in system constant 
+containing the name of the operating system 
+newLISP is running on.</p>
+
+<!-- example -->
+
+<pre>
+ostype  <span class='arw'>&rarr;</span> "Windows"
+</pre>
+
+
+<p>One of the following strings is returned: 
+<tt>"Linux", "BSD", "OSX", "Tru64Unix", "Solaris", "SunOS", "Windows", "Cygwin", or "OS/2"</tt>.
+</p>
+
+
+<p><tt>ostype</tt> can be used to write platform-independent code:</p>
+
+<pre>
+(if 
+    (= ostype "Linux") (import "libz.so")
+    (= ostype "BSD") (import "libz.so")
+    (= ostype "OSX") (import "libz.dylib")
+    ...
+    (println "cannot import libz on this platform")
+)
+</pre>
+
+
+<p>Use <a href="#sys-info">sys-info</a> to learn more
+about the current flavor of newLISP running.</p>
+
+<p>For a table of other built-in system variables and symbols see the
+chapter <a href="#system_symbols">System Symbols and Constants</a> in the
+appendix.</p>
+
+<br/><br/>
+
+<a name="pack"></a>
+<h2><span class="function">pack</span></h2>
+<h4>syntax: (pack <em>str-format</em> <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (pack <em>str-format</em> <em>list</em>)<br/><br/>
+syntax: (pack <em>struct</em> <em>exp-1</em> [<em>exp-2</em> ... ])<br/>
+syntax: (pack <em>struct</em> <em>list</em>)</h4>
+
+<p>When the first parameter is a string, <tt>pack</tt> packs one or more expressions 
+(<em>exp-1</em> to <em>exp-n</em>) into a binary format specified in the format 
+string <em>str-format</em>, and returning the binary structure in a string buffer.
+The symmetrical <a href="#unpack">unpack</a> function is used 
+for unpacking. The expression arguments can also be given in a <em>list</em>.
+<tt>pack</tt> and <tt>unpack</tt> are useful when reading and writing binary files 
+(see <a href="#read">read</a> and <a href="#write">write</a>) 
+or when unpacking binary structures from return values of imported C functions 
+using <tt>import</tt>.</p>
+
+<p>When the first parameter is the symbol of a <a href="#struct">struct</a>
+definition, <tt>pack</tt> uses the format as specified in <em>struct</em>. 
+While <tt>pack</tt> with <em>str-format</em> literally packs as specified,
+<tt>pack</tt> with <em>struct</em> will insert structure aligning pad-bytes
+depending on data type, order of elements and CPU architecture.
+Refer to the description of the <a href="#struct">struct</a> function for more detail.</p>
+
+<p>The following characters are used in <em>str-format</em>:</p>
+
+<table  summary="format characters">
+<tr align="left"><th>format</th><th>description</th></tr>
+
+<tr>
+<td WIDTH="20%"><tt>c </tt></td>
+
+<td WIDTH="80%">a signed 8-bit number</td>
+</tr>
+
+<tr>
+<td><tt>b </tt></td>
+<td>an unsigned 8-bit number</td>
+</tr>
+
+<tr>
+<td><tt>d </tt></td>
+<td>a signed 16-bit short number</td>
+</tr>
+
+<tr>
+<td><tt>u </tt></td>
+<td>an unsigned 16-bit short number</td>
+</tr>
+
+<tr>
+<td><tt>ld</tt></td>
+<td>a signed 32-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>lu</tt></td>
+<td>an unsigned 32-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>Ld</tt></td>
+<td>a signed 64-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>Lu</tt></td>
+<td>an unsigned 64-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>f </tt></td>
+<td>a float in 32-bit representation</td>
+</tr>
+
+<tr>
+<td><tt>lf</tt></td>
+<td>a double float in 64-bit representation</td>
+</tr>
+
+<tr>
+<td><tt>sn</tt></td>
+<td>a string of <em>n</em> null padded ASCII characters</td>
+</tr>
+
+<tr>
+<td><tt>nn</tt></td>
+<td><em>n</em> null characters</td>
+</tr>
+
+<tr>
+<td><tt>&gt;</tt></td>
+
+<td>switch to big endian byte order</td>
+</tr>
+
+<tr>
+<td><tt>&lt;</tt></td>
+<td>switch to little endian byte order</td>
+</tr>
+
+</table><br/>
+
+<p>
+<tt>pack</tt> will convert all floats into integers 
+when passed to <tt>b</tt>, <tt>c</tt>, <tt>d</tt>, <tt>ld</tt>,
+or <tt>lu</tt> formats.
+It will also convert integers into floats
+when passing them to <tt>f</tt> and <tt>lf</tt> formats.
+</p>
+
+<!-- example -->
+
+<pre>
+(pack "c c c" 65 66 67)  <span class='arw'>&rarr;</span> "ABC"
+(unpack "c c c" "ABC")   <span class='arw'>&rarr;</span> (65 66 67)
+
+(pack "c c c" 0 1 2)             <span class='arw'>&rarr;</span> "\000\001\002"
+(unpack "c c c" "\000\001\002")  <span class='arw'>&rarr;</span> (0 1 2)
+
+(set 's (pack "c d u" 10 12345 56789))
+(unpack "c d u" s)  <span class='arw'>&rarr;</span> (10 12345 56789)
+
+(set 's (pack "s10 f" "result" 1.23))
+(unpack "s10 f" s)
+<span class='arw'>&rarr;</span> ("result\000\000\000\000" 1.230000019)
+
+(pack "n10") <span class='arw'>&rarr;</span> "\000\000\000\000\000\000\000\000\000\000"
+
+(set 's (pack "s3 lf" "result" 1.23))
+(unpack "s3 f" s)  <span class='arw'>&rarr;</span> ("res" 1.23)
+
+(set 's (pack "c n7 c" 11 22))
+(unpack "c n7 c" s)  <span class='arw'>&rarr;</span> (11 22))
+
+(unpack "b" (pack "b" -1.0))  <span class='arw'>&rarr;</span> (255)
+(unpack "f" (pack "f" 123))   <span class='arw'>&rarr;</span> (123)
+</pre>
+
+
+<p>
+The last two statements show 
+how floating point numbers are converted 
+into integers when required by the format specification.
+</p>
+
+<p>The expressions to pack can also be given in a list:</p>
+
+
+<pre>
+(set 'lst '("A" "B" "C"))
+(set 'adr (pack "lululu" lst))
+(map get-string (unpack "lululu" adr))    <span class='arw'>&rarr;</span> ("A" "B" "C")
+</pre>
+
+
+<p>Note that the list should be referenced directly in <tt>pack</tt>,
+so the pointers passed by <tt>adr</tt> are valid. <tt>adr</tt> would be written 
+as <tt>char * adr[]</tt> in the C-programming language and represents a 32-bit pointer to an
+array of 32-bit string pointers.
+</p>
+
+<p>
+The <tt>&gt;</tt> and <tt>&lt;</tt> specifiers 
+can be used to switch between <em>little endian</em> 
+and <em>big endian</em> byte order 
+when packing or unpacking:
+</p>
+
+
+<pre>
+(pack "d" 1)   <span class='arw'>&rarr;</span> "\001\000"  ;; on little endian CPU
+(pack "&gt;d" 1)  <span class='arw'>&rarr;</span> "\000\001"  ;; force big endian
+
+(pack "ld" 1)   <span class='arw'>&rarr;</span> "\001\000\000\000" ;; on little endian CPU
+(pack "&lt;ld" 1)  <span class='arw'>&rarr;</span> "\000\000\000\001" ;; force big endian
+
+(pack "&gt;u &lt;u" 1 1) <span class='arw'>&rarr;</span> "\000\001\001\000" ;; switch twice
+</pre>
+
+
+<p>
+Switching the byte order will affect all number formats with 16-,
+32-,
+or 64-bit sizes.
+</p>
+
+<p>
+The pack and unpack format need not be the same:
+</p>
+
+
+<pre>
+(set 's (pack "s3" "ABC"))
+(unpack "c c c" s)  <span class='arw'>&rarr;</span> (65 66 67)
+</pre>
+
+
+<p>
+The examples show spaces between the format specifiers.
+These are not required but can be used to improve readability.
+</p> 
+
+<p>
+See also the <a href="#address">address</a>,
+<a href="#get-int">get-int</a>,
+<a href="#get-long">get-long</a>,
+<a href="#get-char">get-char</a>,
+<a href="#get-string">get-string</a>,
+and <a href="#unpack">unpack</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="parse"></a>
+
+<h2><span class="function">parse</span></h2>
+<h4>syntax: (parse <em>str-data</em> [<em>str-break</em>  [<em>regex-option</em>]])</h4>
+
+<p>
+Breaks the string that results from evaluating <em>str-data</em> into string tokens,
+which are then returned in a list.
+When no <em>str-break</em> is given,
+<tt>parse</tt> tokenizes according to newLISP's internal parsing rules.
+A string may be specified in <em>str-break</em> for tokenizing only at the occurrence of a string.
+If an <em>regex-option</em> number or string is specified,
+a regular expression pattern may be used in <em>str-break</em>.
+</p>
+
+<p>
+When <em>str-break</em> is not specified,
+the maximum token size is 2048 for quoted strings and 256 for identifiers.
+In this case,
+newLISP uses the same faster tokenizer it uses for parsing newLISP source.
+If <em>str-break</em> is specified,
+there is no limitation on the length of tokens.
+A different algorithm is used that splits the source string <em>str-data</em> at the string in <em>str-break</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+; no break string specified
+(parse "hello how are you")     <span class='arw'>&rarr;</span> ("hello" "how" "are" "you")
+
+; strings break after spaces, parentheses, commas, colons and numbers. 
+; Spaces and the colon are swollowed
+(parse "weight is 10lbs")       <span class='arw'>&rarr;</span>
+(parse "one:two:three" ":")     <span class='arw'>&rarr;</span> ("one" "two" "three")
+
+;; specifying a break string
+(parse "one--two--three" "--")  <span class='arw'>&rarr;</span> ("one" "two" "three")
+
+; a regex option causes regex parsing
+(parse "one-two--three---four" "-+" 0) 
+<span class='arw'>&rarr;</span> ("one" "two" "three" "four")
+
+(parse "hello regular   expression 1, 2, 3" {,\s*|\s+} 0)
+<span class='arw'>&rarr;</span> ("hello" "regular" "expression" "1" "2" "3")
+</pre>
+
+
+<p>The last two examples show a regular expression as the break string 
+with the default option <tt>0</tt> (zero).  Instead of 
+<tt>{</tt> and <tt>}</tt> (left and right curly brackets), double 
+quotes can be used to limit the pattern.  In this case, double 
+backslashes must be used inside the pattern.  The last pattern could 
+be used for parsing CSV (Comma Separated Values) files.  For the regular expression option 
+numbers, see <a href="#regex">regex</a>.</p>
+
+<p>
+<tt>parse</tt> will return empty fields 
+around separators 
+as empty strings:
+</p>
+
+
+<pre>
+; empty fields around separators returned as empty strings
+(parse "1,2,3," ",") <span class='arw'>&rarr;</span> ("1" "2" "3" "")
+(parse "1,,,4" ",")  <span class='arw'>&rarr;</span> ("1" "" "" "4")
+(parse "," ",")      <span class='arw'>&rarr;</span> ("" "")
+
+(parse "")      <span class='arw'>&rarr;</span> ()
+(parse "" " ")  <span class='arw'>&rarr;</span> ()
+</pre>
+
+
+<p>
+This behavior is needed 
+when parsing records 
+with empty fields.
+</p>
+
+<p>
+Parsing an empty string 
+will always result 
+in an empty list.
+</p>
+
+<p>
+Use the <a href="#regex">regex</a> function 
+to break strings up 
+and the <a href="#directory">directory</a>, 
+<a href="#find">find</a>, 
+<a href="#find-all">find-all</a>,
+<a href="#regex">regex</a>, 
+<a href="#replace">replace</a>, 
+and <a href="#search">search</a> functions 
+for using regular expressions.
+</p>
+
+<br/><br/>
+
+
+<a name="peek"></a>
+<h2><span class="function">peek</span></h2>
+<h4>syntax: (peek <em>int-handle</em>)</h4>
+
+<p>
+Returns the number of bytes ready to be read on a file descriptor;
+otherwise,
+it returns <tt>nil</tt> if the file descriptor is invalid.
+<tt>peek</tt> can also be used to check <tt>stdin</tt>.
+This function is only available on Unix-like operating systems.
+</p>
+
+<!-- example -->
+
+<pre>
+(peek 0)  ; check # of bytes ready on stdin
+</pre>
+
+
+<p>
+Use the <a href="#net-peek">net-peek</a> function 
+to check for network sockets, 
+or for the number of available bytes on them. 
+On Unix systems, 
+<a href="#net-peek">net-peek</a> can be used 
+to check file descriptors. 
+The difference is that 
+<a href="#net-peek">net-peek</a> also sets 
+<a href="#net-error">net-error</a>.
+</p>
+
+<br/><br/>
+
+<a name="pipe"></a>
+<h2><span class="function">pipe</span></h2>
+<h4>syntax: (pipe)</h4>
+
+<p>
+Creates an inter-process communications pipe and returns the 
+<tt>read</tt> and <tt>write</tt> handles to it within a list.
+</p>
+
+<!-- example -->
+
+<pre>
+(pipe)  <span class='arw'>&rarr;</span> (3 4)  ; 3 for read, 4 for writing
+</pre>
+
+
+<p>
+The pipe handles can be passed to a child process launched via 
+   <a href="#process"> process</a> or to <a href="#fork">fork</a> for inter-process communications.
+</p>
+
+<p>
+Note that the pipe does not block when being written to,
+but it does block reading until bytes are available.
+A <a href="#read-line">read-line</a> blocks until a newline character is received.
+A <a href="#read">read</a> blocks when fewer characters than 
+specified are available from a pipe that has not had the writing end closed by all processes.
+</p>
+
+<p>
+More than one pipe can be opened if required.
+</p>
+
+<p>
+newLISP can also use <em>named pipes</em>.
+See the <a href="#open">open</a> function for further information.
+</p>
+
+<br/><br/>
+
+<a name="pmt"></a>
+<h2><span class="function">pmt</span></h2>
+
+<b>syntax: (pmt <em>num-interest</em> <em>num-periods</em> <em>num-principal</em> 
+[<em>num-future-value</em> [<em>int-type</em>]])</b>
+
+<p>
+Calculates the payment for a loan based on a constant interest of <em>num-interest</em> 
+and constant payments over <em>num-periods</em> of time.
+<em>num-future-value</em> is the value of the loan at the end (typically <tt>0.0</tt>).
+If payment is at the end of the period, <em>int-type</em> is <tt>0</tt> (zero) 
+or <em>int-type</em> is omitted; for payment at the beginning of each period, 
+<em>int-type</em> is 1.</p>
+
+
+<!-- example -->
+
+<pre>
+(pmt (div 0.07 12) 240 100000)  <span class='arw'>&rarr;</span> -775.2989356
+</pre>
+
+
+<p>
+The above example calculates a payment of $775.30 for a loan of $100,000 at a yearly interest rate of 7 percent.
+It is calculated monthly and paid over 20 years (20 * 12 = 240 monthly periods).
+This illustrates the typical way payment is calculated for mortgages.
+</p>
+
+<p>
+See also the <a href="#fv">fv</a>,
+<a href="#irr">irr</a>,
+<a href="#nper">nper</a>,
+<a href="#npv">npv</a>,
+and <a href="#pv">pv</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="pop"></a>
+<h2><span class="function">pop</span>&nbsp;<a href="#destructive">!</a>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (pop <em>list</em> [<em>int-index-1</em> [<em>int-index-2</em> ... ]])<br/>
+syntax: (pop <em>list</em> [<em>list-indexes</em>])<br/><br/>
+
+syntax: (pop <em>str</em> [<em>int-index</em> [<em>int-length</em>]])</h4>
+
+<p>Using <tt>pop</tt>, elements can be removed from lists and characters from strings.</p>
+
+<p>
+In the first syntax, <tt>pop</tt> extracts an element from the list found 
+by evaluating <em>list</em>.
+If a second parameter is present,
+the element at <em>int-index</em> is extracted and returned.
+See also <a href="#indexing">Indexing elements of strings and lists</a>.
+</p>
+
+<p>
+In the second version,
+indices are specified in the list <em>list-indexes</em>.
+This way,
+<tt>pop</tt> works easily together with <a href="#ref">ref</a>
+and <a href="#ref-all">ref-all</a>,
+which return lists of indices.
+</p> 
+
+<p>
+<tt>pop</tt> changes the contents of the target list.
+The popped element is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'pList '((f g) a b c "hello" d e 10))
+
+(pop pList)  <span class='arw'>&rarr;</span> (f g)
+(pop pList)  <span class='arw'>&rarr;</span> a
+pList        <span class='arw'>&rarr;</span> (b c "hello" d e 10)
+
+(pop pList 3)    <span class='arw'>&rarr;</span> d
+(pop pList -1)   <span class='arw'>&rarr;</span> 10
+pList            <span class='arw'>&rarr;</span> (b c "hello" e)
+
+(pop pList -1)  <span class='arw'>&rarr;</span> e
+pList           <span class='arw'>&rarr;</span> (b c "hello")
+
+(pop pList -2)  <span class='arw'>&rarr;</span> c
+pList           <span class='arw'>&rarr;</span> (b "hello")
+
+(set 'pList '(a 2 (x y (p q) z)))
+
+(pop pList -1 2 0)  <span class='arw'>&rarr;</span> p
+
+;; use indices in a list
+(set 'pList '(a b (c d () e)))
+
+(push 'x pList '(2 2 0))  
+<span class='arw'>&rarr;</span> (a b (c d (x) e))
+
+pList
+<span class='arw'>&rarr;</span> (a b (c d (x) e))
+
+(ref 'x pList)  <span class='arw'>&rarr;</span> (2 2 0)
+
+(pop pList '(2 2 0))  <span class='arw'>&rarr;</span> x
+</pre>
+
+
+<p><tt>pop</tt> can also be used on strings with one index:</p>
+
+<!-- example -->
+
+<pre>
+;; use pop on strings
+
+(set 'str "newLISP")
+
+(pop str -4 4)  <span class='arw'>&rarr;</span> "LISP"
+
+str  <span class='arw'>&rarr;</span> "new"
+
+(pop str 1)  <span class='arw'>&rarr;</span> "e"
+
+str  <span class='arw'>&rarr;</span> "nw"
+
+(set 'str "x")
+
+(pop str)  <span class='arw'>&rarr;</span> "x"
+(pop str)  <span class='arw'>&rarr;</span> ""
+</pre>
+
+
+<p>Popping an empty string will return an empty string.</p>
+
+<p>
+See also the <a href="#push">push</a> function, the inverse operation to <tt>pop</tt>.
+</p>
+
+<br/><br/>
+
+<a name="pop-assoc"></a>
+<h2><span class="function">pop-assoc</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (pop-assoc <em>exp-key</em> <em>list-assoc</em>)<br/>
+syntax: (pop-assoc <em>list-keys</em> <em>list-assoc</em>)</h4>
+
+<p>Removes an association referred to by the key in <em>exp-key</em> from the association 
+list in <em>list-assoc</em> and returns the popped expression.</p>
+
+<!-- example -->
+
+<pre>
+;; simple associations
+
+(set 'L '((a 1) (b 2) (c 3)))
+(pop-assoc 'b L) <span class='arw'>&rarr;</span> (b 2)
+L <span class='arw'>&rarr;</span> ((a 1) (c 3))
+
+;; nested associations
+
+(set 'L '((a (b 1) (c (d 2)))))
+(pop-assoc 'a L) <span class='arw'>&rarr;</span> (a (b 1) (c (d 2)))
+L <span class='arw'>&rarr;</span> ()
+
+(set 'L '((a (b 1) (c (d 2)))))
+(pop-assoc '(a b) L)  <span class='arw'>&rarr;</span> (b 1)
+L <span class='arw'>&rarr;</span>  ((a (c (d 2))))
+
+(set 'L '((a (b 1) (c (d 2)))))
+(pop-assoc '(a c) L)  <span class='arw'>&rarr;</span> (c (d 2))
+L <span class='arw'>&rarr;</span> ((a (b 1))))
+</pre>
+
+
+<p>See also <a href="#assoc">assoc</a> for retrieving associations and <a href="#setf">setf</a> 
+for modifying association lists.</p>
+
+<br/><br/>
+
+<a name="post-url"></a>
+<h2><span class="function">post-url</span></h2>
+<h4>syntax: (post-url <em>str-url</em> <em>str-content</em> [<em>str-content-type</em> [<em>str-option</em>] [<em>int-timeout</em> [ <em>str-header</em>]]])</h4>
+
+<p>
+Sends an HTTP POST request to the URL in <em>str-url</em>.
+POST requests are used to post information collected from web entry forms to a web site.
+Most of the time,
+the function <tt>post-url</tt> mimics what a web browser would do when sending information 
+collected in an HTML form to a server,
+but it can also be used to upload files (see an HTTP reference).
+The function returns the page returned from the server in a string.
+</p>
+
+<p>
+When <tt>post-url</tt> encounters an error,
+it returns a string description of the error beginning with <tt>ERR:</tt>.
+</p>
+
+<p>
+The last parameter,
+<em>int-timeout</em>,
+is for an optional timeout value,
+which is specified in milliseconds.
+When no response from the host is received before the timeout has expired,
+the string <tt>ERR:
+timeout</tt> is returned. 
+</p>
+<!-- example -->
+
+<pre>
+;; specify content type
+(post-url "http://somesite.com/form.pl" 
+          "name=johnDoe&amp;city=New%20York" 
+          "application/x-www-form-urlencoded")
+
+;; specify content type and timeout
+(post-url "http://somesite.com/form.pl" 
+          "name=johnDoe&amp;city=New%20York" 
+          "application/x-www-form-urlencoded" 8000)
+
+;; assumes default content type and no timeout
+(post-url "http://somesite.com/form.pl"
+          "name=johnDoe&amp;city=New%20York" 
+</pre>
+
+
+<p>
+The above example uploads a user name and city using a special format called 
+<tt>application/x-www-form-urlencoded</tt>.
+<tt>post-url</tt> can be used to post other content types such as files or binary data.
+See an HTTP reference for other content-type specifications and data encoding formats.
+When the content-type parameter is omitted,
+<tt>post-url</tt> assumes <tt>application/x-www-form-urlencoded</tt> as the default content type.
+</p>
+
+<h3>Additional parameters</h3>
+<p>
+When <em>str-content-type</em> is specified, the optional <em>str-option</em> 
+can take the same options as <a href="#get-url">get-url</a> for the returned 
+content.  If the <em>int-timeout</em> option is specified, the custom header 
+option <em>str-header</em> can be specified, as well. See the function 
+<a href="#get-url">get-url</a> for details on all options.
+</p>
+
+<p>
+See also the <a href="#get-url">get-url</a> and <a href="#put-url">put-url</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="pow"></a>
+<h2><span class="function">pow</span></h2>
+<h4>syntax: (pow <em>num-1</em> <em>num-2 </em> [<em>num-3</em> ... ])<br/>
+syntax: (pow <em>num-1</em>)</h4>
+
+<p>
+Calculates <em>num-1</em> to the power of <em>num-2</em> and so forth.
+</p>
+
+<!-- example -->
+
+<pre>
+(pow 100 2)      <span class='arw'>&rarr;</span> 10000
+(pow 100 0.5)    <span class='arw'>&rarr;</span> 10
+(pow 100 0.5 3)  <span class='arw'>&rarr;</span> 1000
+
+(pow 3)  <span class='arw'>&rarr;</span> 9
+</pre>
+
+
+<p>
+When <em>num-1</em> is the only argument,
+<tt>pow</tt> assumes 2 for the exponent.
+</p>
+
+<br/><br/>
+
+<a name="prefix"></a>
+<h2><span class="function">prefix</span></h2>
+<h4>syntax: (prefix <em>sym</em>)</h4>
+
+<p>Returns the context of a symbol in <em>sym</em>:</p>
+
+
+<!-- example -->
+
+<pre>
+(setf s 'Foo:bar)      <span class='arw'>&rarr;</span> Foo:bar
+(prefix s)             <span class='arw'>&rarr;</span> Foo
+(context? (prefix s))  <span class='arw'>&rarr;</span> true
+
+(term s)                         <span class='arw'>&rarr;</span> "bar"
+(= s (sym (term s) (prefix s)))  <span class='arw'>&rarr;</span> true
+
+<b>&gt;</b>(context (prefix s))   ; switches to context Foo
+<b>Foo</b>
+<b>Foo&gt;</b>
+</pre>
+
+<p>See also <a href="#term">term</a> to extract the term part of
+a symbol.</p>
+
+<br/><br/>
+
+<a name="pretty-print"></a>
+
+<h2><span class="function">pretty-print</span></h2>
+<h4>syntax: (pretty-print [<em>int-length</em> [<em>str-tab</em> [<em>str-fp-format</em>]])</h4>
+
+<p>
+Reformats expressions for <a href="#print">print</a>,
+<a href="#save">save</a>,
+or <a href="#source">source</a> and when printing in an interactive console.
+The first parameter, <em>int-length</em>, specifies the maximum line length,
+and <em>str-tab</em> specifies the string used to indent lines. The third
+parameter <em>str-fp-format</em> describes the default format for printing
+floating point numbers.  All parameters are optional.  <tt>pretty-print</tt> 
+returns the current settings or the new settings when parameters are specified.
+</p>
+
+<!-- example -->
+
+<pre>
+(pretty-print)  <span class='arw'>&rarr;</span> (80 " " "&#037;1.15g")  ; default setting
+
+(pretty-print 90 "\t")  <span class='arw'>&rarr;</span> (90 "\t" "&#037;1.15g")
+
+(pretty-print 100)  <span class='arw'>&rarr;</span> (100 "\t" "&#037;1.15g") 
+
+(sin 1)    <span class='arw'>&rarr;</span> 0.841470984807897 
+(pretty-print 80 " " "&#37;1.3f")
+(sin 1)    <span class='arw'>&rarr;</span> 0.841
+
+(set 'x 0.0)
+x   <span class='arw'>&rarr;</span> 0.000
+</pre>
+
+
+<p>
+The first example reports the default settings of 80 for the maximum line length and a 
+<tt>space</tt> character for indenting. The second example changes the line length to 
+90 and the indent to a TAB character. The third example changes the line length only.
+The last example changes the default format for floating point numbers. This is useful
+when printing unformatted floating point numbers without fractional parts, and these 
+numbers should still be recognizable as floating point numbers. Without the custom
+format, <tt>x</tt> would be printed as <tt>0</tt> indistinguishable from floating
+point number. All situations where unformatted floating point numbers are printed,
+are affected.</p>
+
+<p>
+Note that <tt>pretty-print</tt> cannot be used to prevent line breaks from being printed.
+To completely suppress pretty printing, use the function <a href="#string">string</a> 
+to convert the expression to a raw unformatted string as follows:</p>
+
+<!-- example -->
+
+<pre>
+;; print without formatting
+
+(print (string my-expression))	
+</pre>
+
+<br/><br/>
+
+<a name="primitivep"></a>
+<h2><span class="function">primitive?</span></h2>
+<h4>syntax: (primitive? <em>exp</em>)</h4>
+
+<p>
+Evaluates and tests if <em>exp</em> is a primitive symbol and returns
+<tt>true</tt> or <tt>nil</tt> depending on the result. All built-in
+functions and functions created using <a href="#import">import</a>
+are primitives.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'var define)
+(primitive? var)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="print"></a>
+<h2><span class="function">print</span></h2>
+<h4>syntax: (print <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+Evaluates and prints <em>exp-1</em>&mdash;
+to the current I/O device,
+which defaults to the console window.
+See the built-in function <a href="#device">device</a> for details on how to specify a different I/O device.
+</p>
+
+<p>
+List expressions are indented by the nesting levels of their opening parentheses.
+</p>
+
+<p>
+Several special characters may be included in strings encoded with the escape character <tt>\</tt>:
+</p>
+ 
+<table  summary="escape characters in print">
+<tr align="left" valign="bottom"><th>character</th><th>description</th></tr>
+
+<tr>
+<td><tt>\n</tt></td>
+<td>the line-feed character (ASCII 10)</td>
+
+</tr>
+
+<tr>
+<td><tt>\r</tt></td>
+<td>the carriage-return character (ASCII 13)</td>
+</tr>
+
+<tr>
+<td><tt>\t</tt></td>
+<td>the tab character (ASCII 9)</td>
+</tr>
+
+<tr>
+
+<td><tt>\nnn</tt></td>
+<td>where <tt>nnn</tt> is a decimal ASCII code between 000 and 255</td>
+</tr>
+
+<tr>
+<td><tt>\xnn</tt></td>
+<td>where <tt>nn</tt> is a hexadecimal ASCII code between 00 and FF</td>
+</tr>
+
+</table><br/>
+
+<br/>
+<!-- example -->
+
+<pre>
+(print (set 'res (+ 1 2 3))) 
+(print "the result is" res "\n")
+
+"\065\066\067"  <span class='arw'>&rarr;</span> "ABC"
+</pre>
+
+
+<p>
+	To finish printing with a line-feed,
+	use <a href="#println">println</a>.
+</p>
+
+<br/><br/>
+
+<a name="println"></a>
+<h2><span class="function">println</span></h2>
+<h4>syntax: (println <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+	Evaluates and prints <em>exp-1</em>&mdash;
+	to the current I/O device,
+	which defaults to the console window.
+	A line-feed is printed at the end.
+	See the built-in function <a href="#device">device</a> for details on how to specify a different I/O device.
+	<tt>println</tt> works exactly like <a href="#print">print</a> but emits a line-feed character at the end.
+</p>
+
+<p>
+	See also the <a href="#write-line">write-line</a> and <a href="#print">print</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="prob-chi2"></a>
+<h2><span class="function">prob-chi2</span></h2>
+<h4>syntax: (prob-chi2 <em>num-chi2</em> <em>int-df</em>)</h4>
+
+<p>Returns the probability of an observed <em>Chi&sup2;</em> statistic in <em>num-chi2</em> 
+with <em>num-df</em> degrees of freedom to be equal or greater under the null hypothesis.
+<tt>prob-chi2</tt> is derived from the incomplete Gamma function <a HREF="#gammai">gammai</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(prob-chi2 10 6)  <span class='arw'>&rarr;</span> 0.1246520195
+</pre>
+
+
+<p>
+	See also the inverse function <a href="#crit-chi2">crit-chi2</a>.
+</p> 
+
+<br/><br/>
+
+<a name="prob-f"></a>
+<h2><span class="function">prob-f</span></h2>
+<h4>syntax: (prob-f <em>num-f</em> <em>int-df1</em> <em>int-df2</em>)</h4>
+
+<p>Returns the probability of an observed <em>F</em> statistic in <em>num-f</em> 
+with <em>int-df1</em> and <em>int-df2</em> degrees of freedom to be equal or greater 
+under the null hypothesis.</p>
+
+<!-- example -->
+
+<pre>
+(prob-f 2.75 10 12)  <span class='arw'>&rarr;</span> 0.0501990804
+</pre>
+
+
+<p>
+See also the inverse function <a href="#crit-f">crit-f</a>.
+</p> 
+
+<br/><br/>
+
+<a name="prob-t"></a>
+<h2><span class="function">prob-t</span></h2>
+<h4>syntax: (prob-t <em>num-t</em> <em>int-df1</em>)</h4>
+
+<p>Returns the probability of an observed <em>Student's t</em> statistic in <em>num-t</em> 
+with <em>int-df</em> degrees of freedom to be equal or greater 
+under the null hypothesis.</p>
+
+<!-- example -->
+
+<pre>
+(prob-t 1.76 14)  <span class='arw'>&rarr;</span> 0.05011454551
+</pre>
+
+
+<p>
+See also the inverse function <a href="#crit-t">crit-t</a>.
+</p> 
+
+<br/><br/>
+
+<a name="prob-z"></a>
+<h2><span class="function">prob-z</span></h2>
+<h4>syntax: (prob-z <em>num-z</em>)</h4>
+
+<p>
+	Returns the probability of <em>num-z</em>,
+	not to exceed the observed value where <em>num-z</em> is a normal distributed 
+	value with a mean of <tt>0.0</tt> and a standard deviation of <tt>1.0</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(prob-z 0.0)  <span class='arw'>&rarr;</span> 0.5
+</pre>
+
+
+
+<p>
+	See also the inverse function <a href="#crit-z">crit-z</a>.
+</p> 
+
+<br/><br/>
+
+<a name="process"></a>
+<h2><span class="function">process</span></h2>
+<h4>syntax: (process <em>str-command</em>)<br/>
+syntax: (process <em>str-command</em> <em>int-pipe-in</em> <em>int-pipe-out</em> [<em>int-win-option</em>])<br/>
+syntax: (process <em>str-command</em> <em>int-pipe-in</em> <em>int-pipe-out</em> [<em>int-unix-pipe-error</em>])</h4>
+
+<p>
+In the first syntax,
+<tt>process</tt> launches a  process specified in <em>str-command</em> and immediately 
+returns with a process ID or <tt>nil</tt> if a process could not be created. This 
+process will execute the program specified or immediately die if <em>str-command</em> could not be executed.
+</p>
+
+<p>On Mac OS X and other Unixes, the application or script must be specified with its full path-name.
+The new process inherits the OS environment from the parent process.</p>
+
+<p>Command line arguments are parsed out at spaces. Arguments containing spaces must be delimited using
+single quotes on Mac OS X and other Unixes. On MS Windows, double quotes are used. The process id returned
+can be used to destroy the running process using <a href="#destroy">destroy</a>, if the process does
+not exit by itself.</p>
+
+<!-- example -->
+
+<pre>
+(process "c:/WINDOWS/system32/notepad.exe")  <span class='arw'>&rarr;</span> 1894 ; Windows
+; or when in executable path
+(process "notepad.exe")                      <span class='arw'>&rarr;</span> 1894 ; Windows
+
+
+; find out the path of the program to start using exec, 
+; if the path is not known
+
+(process (first (exec "which xclock")))  <span class='arw'>&rarr;</span> 22607 ; on Unix
+</pre>
+
+
+<p>If the path of the executable is unknown, <tt>exec</tt> together with the Unix <tt>which</tt>
+command can be used to start a program. The pid returned can be used to <a href="#destroy">destroy</a>
+the process.</p>
+
+<p>In the second syntax,
+standard input and output of the created process can be redirected to pipe handles.
+When remapping standard I/O of the launched application to a pipe,
+it is possible to communicate with the other application via <a href="#write-line">write-line</a> 
+and <a href="#read-line">read-line</a>  or <a href="#write">write</a> and 
+<a href="#read">read</a> statements:</p>
+
+<!-- example -->
+
+<pre>
+;; Linux/Unix
+;; create pipes
+(map set '(myin bcout) (pipe))
+(map set '(bcin myout) (pipe))   
+
+;; launch Unix 'bc' calculator application
+(process "/usr/bin/bc" bcin bcout) <span class='arw'>&rarr;</span> 7916
+
+(write-line myout "3 + 4")  ; bc expects a line-feed
+
+(read-line myin)  <span class='arw'>&rarr;</span> "7"
+
+
+;; bc can use bignums with arbitrary precision
+
+(write-line myout "123456789012345 * 123456789012345")
+
+(read-line myin)  <span class='arw'>&rarr;</span> "15241578753238669120562399025"
+
+;; destroy the process
+(destroy 7916)
+
+;; MS Windows
+(map set '(myin cmdout) (pipe))
+(map set '(cmdin myout) (pipe))
+
+(process "c:/Program Files/newlisp/newlisp.exe -c" cmdin cmdout)
+<span class='arw'>&rarr;</span> 1284
+
+(write-line myout "(+ 3 4)")
+
+(read-line myin) <span class='arw'>&rarr;</span> "7"
+
+;; destroy the process
+(destroy 1284)
+</pre>
+
+
+<p>On MS Windows versions of newLISP, a fourth optional parameter of <em>int-win-option</em> 
+can be specified to control the display status of the application.
+This option defaults to <tt>1</tt> for showing the application's window,
+<tt>0</tt> for hiding it, and <tt>2</tt> for showing it minimized on the Windows 
+launch bar.</p>
+
+<p>On both MS Windows and Linux/Unix systems, standard error will be redirected to 
+standard out by default. On Linux/Unix, an optional pipe handle for standard 
+error output can be defined in <em>int-unix-pipe-error</em>.</p>
+
+<p>The function <a href="#peek">peek</a> can be used to check for information 
+on the pipe handles:</p>
+
+
+<pre>
+;; create pipes
+(map set '(myin bcout) (pipe))
+(map set '(bcin myout) (pipe))   
+(map set '(errin errout) (pipe))   
+
+;; launch Unix 'bc' calculator application
+(process "bc" bcin bcout errout)
+
+(write myout command)
+
+;; wait for bc sending result or error info
+(while (and (= (peek myin) 0)
+            (= (peek errin) 0)) (sleep 10))
+
+(if (&gt; (peek errin) 0)
+	(println (read-line errin)))
+	
+(if (&gt; (peek myin) 0)
+	(println (read-line myin)))
+</pre>
+
+
+<p>
+	 Not all interactive console applications 
+   can have their standard I/O channels remapped.
+	Sometimes only one channel,
+	<em>in</em> or <em>out</em>,
+	can be remapped.
+	In this case,
+	specify <tt>0</tt> (zero) for the unused channel.
+	The following statement uses only the launched application's output:
+</p>
+
+
+<pre>
+(process "app" 0 appout)
+</pre>
+
+
+<p>
+	Normally,
+	two pipes are used:
+	one for communications to the child process and the other one for communications from the child process.
+</p>
+
+<p>
+See also the <a href="#pipe">pipe</a> and <a href="#share">share</a> functions for inter-process 
+communications and the <a href="#semaphore">semaphore</a> function for synchronization of several processes.
+See the <a href="#fork">fork</a> and <a href="#spawn">spawn</a> functions for other ways of starting 
+newLISP processes. Both are only available on Mac OS X, Linux and other Unix like operating systems.
+</p>
+
+<br/><br/>
+
+<a name="prompt-event"></a>
+<h2><span class="function">prompt-event</span></h2>
+<h4>syntax: (prompt-event <em>sym-event-handler</em> | <em>func-event-handler</em>)<br/>
+syntax: (prompt-event nil)</h4>
+
+<p>Refines the prompt as shown in the interactive newLISP shell.
+The <em>sym-event-handler</em> or <em>func-event-handler</em>
+is either a symbol of a user-defined function or a lambda expression:</p>
+
+<p>To reset <tt>prompt-event</tt> to the original state, use the second syntax.</p>
+
+<pre>
+<b>></b> (prompt-event (fn (ctx) (string ctx ":" (real-path) "$ ")))
+<b>$prompt-event</b>
+<b>MAIN:/Users/newlisp$</b> (+ 3 4)
+<b>7</b>
+<b>MAIN:/Users/newlisp$</b>
+</pre>
+
+<p>The current context before calling the <tt>prompt-event</tt> code is passed as a 
+parameter to the function. Computer output is shown in bold.</p>
+
+<p>The example redefines the <tt>&gt;</tt> prompt to be the current context followed
+by a colon <tt>:</tt>, followed by the directory name, followed by the dollar symbol. 
+Together with the <a href="#command-event">command-event</a> function this can be 
+used to create fully customized shells or custom command interpreters.</p>
+
+<p>The function in <tt>prompt-event</tt> must return a string of 63 characters maximum. 
+Not returning a string will leave the prompt unchanged.</p>
+
+<br/><br/>
+
+<a name="protectedp"></a>
+<h2><span class="function">protected?</span></h2>
+
+<h4>syntax: (protected? <em>sym</em>)</h4>
+
+<p>Checks if a symbol in <em>sym</em> is protected. Protected symbols are built-in
+functions, context symbols, and all symbols made constant using the <a href="#constant">constant</a>
+function:</p>
+
+
+<pre>
+(protected? 'println)    <span class='arw'>&rarr;</span> true
+(constant 'aVar 123)
+(protected? 'aVar)       <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="push"></a>
+<h2><span class="function">push</span>&nbsp;<a href="#destructive">!</a>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (push <em>exp</em> <em>list</em> [<em>int-index-1</em> [<em>int-index-2</em> ... ]])<br/>
+syntax: (push <em>exp</em> <em>list</em> [<em>list-indexes</em>])<br/><br/>
+
+syntax: (push <em>str-1</em> <em>str-2</em> [<em>int-index</em>])</h4>
+
+<p>
+Inserts the value of <em>exp</em> into the list <em>list</em>.
+If <em>int-index</em> is present, the element is inserted at that index.
+If the index is absent, the element is inserted at index <tt>0</tt> (zero),
+the first element. <tt>push</tt> is a destructive operation that changes the 
+contents of the target list.</p>
+
+<p>The list changed is returned as a reference on which other built-in
+functions can work. See also <a href="#indexing">Indexing elements of 
+strings and lists</a>.</p>
+
+<p>
+If more than one <em>int-index</em> is present, the indices are used to 
+access a nested list structure. Improper indices (those not matching list 
+elements) are discarded.</p>
+
+<p>
+The second version takes a list of <em>list-indexes</em> but is otherwise 
+identical to the first. In this way, <tt>push</tt> works easily together 
+with <a href="#ref">ref</a> and <a href="#ref-all">ref-all</a>,
+which return lists of indices.
+</p>
+
+<p>
+If <em>list</em> does not contain a list, <em>list</em> must contain a 
+<tt>nil</tt> and will be initialized to the empty list.
+</p>
+
+<p>
+Repeatedly using <tt>push</tt> to the end of a list using <tt>-1</tt> as 
+the <em>int-index</em> is optimized and as fast as pushing 
+to the front of a list with no index at all. This can be used to efficiently 
+grow a list.
+</p>
+
+<!-- example -->
+
+<pre>
+; inserting in front
+(set 'pList '(b c))  <span class='arw'>&rarr;</span> (b c)
+(push 'a pList)      <span class='arw'>&rarr;</span> (a b c)
+pList                <span class='arw'>&rarr;</span> (a b c)
+
+; insert at index
+(push "hello" pList 2)  <span class='arw'>&rarr;</span> (a b "hello" c)
+
+; optimized appending at the end
+(push 'z pList -1)  <span class='arw'>&rarr;</span> (a b "hello" c z)
+
+; inserting lists in lists
+(push '(f g) pList)  <span class='arw'>&rarr;</span> ((f g) a b "hello" c z)
+
+; inserting at negative index
+(push 'x pList -3)  <span class='arw'>&rarr;</span> ((f g) a b "hello" x c z)
+
+; using multiple indices
+(push 'h pList 0 -1)  <span class='arw'>&rarr;</span> ((f g h) a b "hello" x c z)
+
+; use indices in a list
+(set 'pList '(a b (c d () e)))
+
+(push 'x pList '(2 2 0))  <span class='arw'>&rarr;</span> (a b (c d (x) e))
+
+(ref 'x pList)   <span class='arw'>&rarr;</span> (2 2 0)
+
+(pop pList '(2 2 0))  <span class='arw'>&rarr;</span> x
+
+; the target list is a place reference
+(set 'lst '((a 1) (b 2) (c 3) (d)))
+
+(push 4 (assoc 'd lst) -1) <span class='arw'>&rarr;</span> (d 4)
+
+lst <span class='arw'>&rarr;</span> ((a 1) (b 2) (c 3) (d 4))
+
+
+; push on un-initialized symbol
+aVar  <span class='arw'>&rarr;</span> nil 
+
+(push 999 aVar)  <span class='arw'>&rarr;</span> (999)
+
+aVar  <span class='arw'>&rarr;</span> (999)
+</pre>
+
+
+<p><tt>push</tt> and pop can be combined to model a queue:</p>
+
+<pre>
+; pop and push a as a queue
+(set 'Q '(a b c d e))
+
+(pop (push 'f Q -1)) <span class='arw'>&rarr;</span> a
+(pop (push 'g Q -1)) <span class='arw'>&rarr;</span> b
+
+Q <span class='arw'>&rarr;</span>  (c d e f g)
+</pre>
+
+
+<p>Because <tt>push</tt> returns a reference to the modified list,
+<tt>pop</tt> can work on it directly.</p>
+
+<p>In the third syntax <tt>push</tt> can be used to change strings. When
+<em>int-index</em> is used, it refers to character positions rather than 
+byte positions. UTF-8 characters may be multi-byte characters.</p>
+
+<pre>
+;; push on strings
+
+(set 'str "abcdefg")
+
+(push "hijk" str -1)  <span class='arw'>&rarr;</span> "abcdefghijk"
+str                   <span class='arw'>&rarr;</span> "abcdefghijk"
+
+(push "123" str)  <span class='arw'>&rarr;</span> "123abcdefghijk"
+(push "4" str 3)  <span class='arw'>&rarr;</span> "1234abcdefghijk"
+
+(set 'str "\u03b1\u03b2\u03b3")  <span class='arw'>&rarr;</span>  "ฮฑฮฒฮณ"
+
+(push "*" str 1)  <span class='arw'>&rarr;</span>  "ฮฑ*ฮฒฮณ"
+
+;; push on a string reference
+
+(set 'lst '("abc" "xyz"))
+
+(push x (lst 0)) <span class='arw'>&rarr;</span> "xabc"
+
+lst <span class='arw'>&rarr;</span> ("xabc" "xyz")
+</pre>
+
+<p>See also the <a href="#pop">pop</a> function, which is the inverse operation to <tt>push</tt>.
+</p>
+
+<br/><br/>
+
+<a name="put-url"></a>
+<h2><span class="function">put-url</span></h2>
+<h4>syntax: (put-url <em>str-url</em> <em>str-content</em> [<em>str-option</em>] [<em>int-timeout</em> [<em>str-header</em>]])</h4>
+
+<p>
+	The HTTP PUT protocol is used to transfer information in <em>str-content</em> 
+	to a file specified in <em>str-url</em>. The lesser-known HTTP PUT mode is 
+	frequently used for transferring web pages from HTML editors to Web servers.
+	In order to use PUT mode, the web server's software must be configured correctly.
+	On the Apache web server,
+	use the <tt>'Script PUT'</tt> directive in the section where directory access rights are configured.
+</p>
+
+<p>If <em>str-url</em> starts with <tt>file://</tt> then <em>str-content</em> is written
+to the local file system.</p>
+
+<p>
+	Optionally,
+	an <em>int-timeout</em> value can be specified in milliseconds as the last parameter.
+	<tt>put-url</tt> will return <tt>ERR:
+	timeout</tt> when the host gives no response and the timeout expires.
+	On other error conditions,
+	<tt>put-url</tt> returns a string starting with <tt>ERR:</tt> and the description of the error.
+</p>
+
+<p>
+	<tt>put-url</tt> requests are also understood by newLISP server nodes.
+</p>
+
+<!-- example -->
+
+<pre>
+(put-url "http://asite.com/myFile.txt" "Hi there")
+(put-url "http://asite.com/myFile.txt" "Hi there" 2000)
+
+(put-url "http://asite.com/webpage.html" 
+    (read-file "webpage.html"))
+
+; write /home/joe/newfile.txt on the local file system
+(puts-url "file:///home/joe/newfile.txt" "Hello World!")
+</pre>
+
+
+<p>
+	The first example creates a file called <tt>myFile.txt</tt> on the target server
+	and stores the text string <tt>'Hi there'</tt> in it.
+	In the second example,
+	the local file <tt>webpage.html</tt> is transferred to <tt>asite.com</tt>.
+</p>
+
+<p>
+	On an Apache web server,
+	the following could be configured in <tt>httpd.conf</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+&lt;directory /www/htdocs&gt;
+Options All
+Script PUT /cgi-bin/put.cgi
+&lt;/directory&gt;
+</pre>
+
+
+<p>
+	 The script <tt>put.cgi</tt> would contain code to receive content from the web server via STDIN.
+	The following is a working <tt>put.cgi</tt> written in newLISP for the Apache web server:
+</p>
+
+<!-- example -->
+<pre>
+#!/usr/home/johndoe/bin/newlisp
+#
+#
+# get PUT method data from CGI STDIN 
+# and write data to a file specified
+# int the PUT request
+# 
+#
+
+
+(print "Content-Type: text/html\n\n")
+
+(set 'cnt 0)
+(set 'result "")
+
+(if (= "PUT" (env "REQUEST_METHOD"))
+    (begin
+      (set 'len (int (env "CONTENT_LENGTH")))
+
+      (while (&lt; cnt len)
+          (set 'n (read (device) buffer len))
+          (if (not n) 
+            (set 'cnt len) 
+            (begin 
+              (inc cnt n)
+              (write result buffer))))
+              
+      (set 'path (append 
+              "/usr/home/johndoe" 
+              (env "PATH_TRANSLATED")))
+
+      (write-file path result)
+    )
+)
+
+(exit)
+</pre>
+
+
+<p>
+	Note that the script appends ".txt" to the path to avoid the CGI execution of uploaded malicious scripts.
+	Note also that the two lines where the file path is composed may work differently in your web server environment.
+	Check environment variables passed by your web server for composition of the right file path.
+</p>
+
+<p>
+	<tt>put-url</tt> returns content returned by the <tt>put.cgi</tt> script.
+</p>
+
+<h3>Additional parameters</h3>
+<p>
+In <em>str-option</em> can take the same options as <a href="#get-url">get-url</a>
+for the returned content. If the <em>int-timeout</em> option is specified, the 
+custom header option <em>str-header</em> can be specified, as well. See the 
+function <a href="#get-url">get-url</a> for details on all options.
+</p>
+
+<p>
+See also the functions <a href="#get-url">get-url</a> and <a href="#post-url">post-url</a>,
+which can be used to upload files when formatting form data as <tt>multipart/form-data</tt>.
+</p>
+
+<br/><br/>
+
+<a name="pv"></a>
+<h2><span class="function">pv</span></h2>
+<h4>syntax: (pv <em>num-int</em> <em>num-nper</em> <em>num-pmt</em> 
+[<em>num-fv</em> [<em>int-type</em>]])</h4>
+
+<p>Calculates the present value of a loan with the constant interest rate 
+<em>num-interest</em> and the constant payment <em>num-pmt</em> after 
+<em>num-nper</em> number of payments. The future value <em>num-fv</em> 
+is assumed to be <tt>0.0</tt> if omitted. If payment is at the end of the 
+period, <em>int-type</em> is <tt>0</tt> (zero) or <em>int-type</em> is omitted; 
+for payment at the beginning of each period, <em>int-type</em> is 1.</p>
+
+<!-- example -->
+
+<pre>
+(pv (div 0.07 12) 240 775.30)  <span class='arw'>&rarr;</span> -100000.1373
+</pre>
+
+<p>
+	In the example,
+	a loan that would be paid off (future value = <tt>0.0</tt>) in 240 payments of $775.30 at a 
+	constant interest rate of 7 percent per year would start out at $100,000.14.
+</p>
+
+<p>
+	See also the <a href="#fv">fv</a>,
+	<a href="#irr">irr</a>,
+	<a href="#nper">nper</a>,
+	<a href="#npv">npv</a>,
+	and <a href="#pmt">pmt</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="quote"></a>
+<h2><span class="function">quote</span></h2>
+<h4>syntax: (quote <em>exp</em>)</h4>
+
+<p>Returns <em>exp</em> without evaluating it. The same effect can be obtained by 
+prepending a <tt>'</tt> (single quote) to <em>exp</em>. The function <tt>quote</tt> 
+is resolved during runtime, the prepended <tt>'</tt> quote is translated into a 
+protective envelope (quote cell) during code translation.</p>
+
+<!-- example -->
+
+<pre>
+(quote x)         <span class='arw'>&rarr;</span> x
+(quote 123)       <span class='arw'>&rarr;</span> 123
+(quote (a b c))   <span class='arw'>&rarr;</span> (a b c)
+(= (quote x) 'x)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="quotep"></a>
+<h2><span class="function">quote?</span></h2>
+<h4>syntax: (quote? <em>exp</em>)</h4>
+
+<p>
+	 Evaluates and tests whether <em>exp</em> is quoted.
+	Returns <tt>true</tt> or <tt>nil</tt> depending on the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'var ''x)  <span class='arw'>&rarr;</span> 'x
+(quote? var)    <span class='arw'>&rarr;</span> true
+</pre>
+
+<p>
+	 Note that in the <tt>set</tt> statement,
+	<tt> ''x</tt> is quoted twice because the first quote 
+  is lost during the evaluation of the <tt>set</tt> assignment.
+</p>
+
+<br/><br/>
+
+<a name="rand"></a>
+<h2><span class="function">rand</span></h2>
+<h4>syntax: (rand <em>int-range</em> [<em>int-N</em>])</h4>
+
+<p>
+	Evaluates the expression in <em>int-range</em> 
+	and generates a random number in the range of 
+	<tt>0</tt> (zero) to (<em>int-range</em> - 1). 
+	When <tt>0</tt> (zero) is passed, 
+	the internal random generator 
+	is initialized using 
+	the current value returned by 
+	the C <tt>time()</tt> function. 
+	Optionally, a second parameter 
+	can be specified to return 
+	a list of length <em>int-N</em> 
+	of random numbers.
+</p>
+
+<!-- example -->
+
+<pre>
+(dotimes (x 100) (print (rand 2))) =&gt;
+11100000110100111100111101 ... 10111101011101111101001100001000
+
+(rand 3 100)  <span class='arw'>&rarr;</span> (2 0 1 1 2 0 &hellip;)
+</pre>
+
+
+<p>
+	The first line in the example 
+	prints equally distributed <tt>0</tt>'s and <tt>1</tt>'s, 
+	while the second line produces a list 
+	of 100 integers with 
+	<tt>0</tt>, <tt>1</tt>, and <tt>2</tt> equally distributed. 
+	Use the <a href="#random">random</a> 
+	and <a href="#normal">normal</a> functions
+	to generate floating point
+	random numbers, 
+	and use <a href="#seed">seed</a> to vary 
+	the initial seed 
+	for random number generation.
+</p>
+
+<br/><br/>
+
+<a name="random"></a>
+<h2><span class="function">random</span></h2>
+<h4>syntax: (random <em>float-offset</em> <em>float-scale</em> <em>int-n</em>)<br/>
+syntax: (random <em>float-offset</em> <em>float-scale</em>)</h4>
+
+<p>
+	In the first form, 
+	<tt>random</tt> returns a list of <em>int-n</em> 
+	evenly distributed floating point numbers 
+	scaled (multiplied) by <em>float-scale</em>, 
+	with an added offset of <em>float-offset</em>. 
+	The starting point of the internal random generator 
+	can be seeded using <a href="#seed">seed</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(random 0 1 10)
+<span class='arw'>&rarr;</span> (0.10898973 0.69823783 0.56434872 0.041507289 0.16516733
+    0.81540917 0.68553784 0.76471068 0.82314585 0.95924564)
+</pre>
+
+
+<p>
+	When used in the second form, 
+	<tt>random</tt> returns a single 
+	evenly distributed number:
+</p>
+
+
+<pre>
+(random 10 5)  <span class='arw'>&rarr;</span> 11.0971
+</pre>
+
+<p> When no parameters are given, <tt>random</tt> assumes a mean of <tt>0.0</tt> 
+and a standard deviation of <tt>1.0</tt>.</p>
+
+<p>
+	See also the <a href="#normal">normal</a> 
+	and <a href="#rand">rand</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="randomize"></a>
+<h2><span class="function">randomize</span></h2>
+<h4>syntax: (randomize <em>list</em> [<em>bool</em>])</h4>
+
+<p>
+	Rearranges the order of elements in <em>list</em> 
+	into a random order.
+</p>
+
+<!-- example -->
+
+<pre>
+(randomize '(a b c d e f g))  <span class='arw'>&rarr;</span> (b a c g d e f)
+(randomize (sequence 1 5))    <span class='arw'>&rarr;</span> (3 5 4 1 2)
+</pre>
+
+
+<p>
+	<tt>randomize</tt> will always return 
+	a sequence different from the previous one 
+	without the optional <em>bool</em> flag. 
+	This may require the function to calculate 
+	several sets of reordered elements, 
+	which in turn may lead to different processing times 
+	with different invocations of the function 
+	on the same input list length. 
+	To allow for the output to be equal 
+	to the input, <tt>true</tt> 
+	or any expression evaluating to 
+	not <tt>nil</tt> 
+	must be specified in <em>bool</em>.
+</p>
+
+<p>
+	<tt>randomize</tt> uses 
+	an internal <em>pseudo random sequence</em> generator 
+	that returns the same series of results 
+	each time newLISP is started. 
+	Use the <a href="#seed">seed</a> function to 
+	change this sequence.
+</p> 
+
+<br/><br/>
+
+<a name="read-buffer"></a>
+<a name="read"></a>
+<h2><span class="function">read</span>&nbsp;<a href="#destructive">!</a></h2>
+
+<h4>syntax: (read <em>int-file</em> <em>sym-buffer</em> <em>int-size</em> [<em>str-wait</em>])</h4>
+
+<p>
+Reads a maximum of <em>int-size</em> bytes from a file specified in <em>int-file</em> 
+into a buffer in <em>sym-buffer</em>.  Any data referenced by the symbol <em>sym-buffer</em> 
+prior to the reading is deleted.  The handle in <em>int-file</em> is obtained from a 
+previous <a href="#open">open</a> statement. The symbol <em>sym-buffer</em> contains 
+data of type string after the read operation.  <em>sym-buffer</em> can also be a default 
+functor specified by a context symbol for reference passing in and out of user-defined 
+functions.</p>
+
+<p><tt>read</tt> is a shorter writing of <tt>read-buffer</tt>. The longer
+form still works but is deprecated and should be avoided in new code.</p>
+
+<p>
+	Optionally, 
+	a string to be waited for 
+	can be specified in <em>str-wait</em>. 
+	<tt>read</tt> will read 
+	a maximum amount of bytes 
+	specified in <em>int-size</em> 
+	or return earlier 
+	if <em>str-wait</em> was found 
+	in the data. 
+	The wait-string is part
+	of the returned data and must
+    not contain binary <tt>0</tt> (zero)
+    characters.
+</p>
+
+<p>
+	Returns the number of bytes read or <tt>nil</tt> 
+	when the wait-string was not found. 
+	In any case, 
+	the bytes read are put into the buffer 
+	pointed to by <em>sym-buffer</em>, 
+	and the file pointer of the file read 
+	is moved forward. 
+	If no new bytes have been read, 
+	<em>sym-buffer</em> will contain <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'handle (open "aFile.ext" "read"))
+(read handle buff 200)
+</pre>
+
+
+<p>
+	Reads 200 bytes into the symbol <tt>buff</tt> 
+	from the file <tt>aFile.ext</tt>.
+</p>
+
+
+<pre>
+(read handle buff 1000 "password:")
+</pre>
+
+
+<p>
+	Reads 1000 bytes or until 
+	the string <tt>password:</tt> is encountered. 
+	The string <tt>password:</tt> 
+	will be part of the data returned.
+</p>
+
+<p>
+	See also the <a href="#write">write</a> function.
+</p>
+
+<br/><br/>
+
+<a name="read-char"></a>
+<h2><span class="function">read-char</span></h2>
+
+<h4>syntax: (read-char [<em>int-file</em>])</h4>
+
+<p>
+Reads a byte from a file specified by the file handle in <em>int-file</em> 
+or from the current I/O device - e.g. <em>stdin</em> - when no file handle is specified.
+The file handle is obtained from a previous <a href="#open">open</a> operation. 
+Each <tt>read-char</tt> advances the file pointer by one byte. 
+Once the end of the file is reached, <tt>nil</tt> is returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (slow-file-copy from-file to-file)
+    (set 'in-file (open from-file "read"))
+    (set 'out-file (open to-file "write"))
+    (while (set 'chr (read-char in-file))
+        (write-char out-file chr))
+    (close in-file)
+    (close out-file)
+    "finished")
+</pre>
+
+
+<p>
+	Use <a href="#read-line">read-line</a> 
+	and <a href="#device">device</a> to read 
+	whole text lines at a time. 
+	Note that newLISP supplies 
+	a fast built-in function 
+	called <a href="#copy-file">copy-file</a> 
+	for copying files.
+</p>
+
+<p>
+	See also the <a href="#write-char">write-char</a> function.
+</p>
+
+<br/><br/>
+
+<a name="read-expr"></a>
+<h2><span class="function">read-expr</span></h2>
+<h4>syntax: (read-expr <em>str-source</em> [<em>sym-context</em> [<em>exp-error</em> [<em>int-offset</em>]]])</h4>
+
+<p><tt>read-expr</tt> parses the first expressions it finds in <em>str-source</em> and 
+returns the translated expression without evaluating it. An optional context in 
+<em>sym-context</em> specifies a namespace for the translated expression.</p>
+
+<p>After a call to <tt>read-expr</tt> the system variable <tt>$count</tt> contains the 
+number of characters scanned.</p>
+
+<p>If an error occurs when translating <em>str-source</em> the expression in
+<em>exp-error</em> is evaluated and the result returned.</p>
+
+<p><em>int-offset</em> specifies an optional offset into <em>str-source</em> where
+processing should start. When calling <tt>read-expr</tt> repeatedly this number
+can be updated using <tt>$count</tt>, the number of characters processed.</p>
+
+<!-- example -->
+
+<pre>
+(set 'code "; a statement\n(define (double x) (+ x x))")
+
+(read-expr code) <span class='arw'>&rarr;</span> (define (double x) (+ x x))
+
+$count <span class='arw'>&rarr;</span> 41
+
+</pre>
+
+
+<p><tt>read-expr</tt> behaves similar to <a href="#eval-string">eval-string</a>
+but without the evaluation step:</p>
+
+
+<pre>
+(read-expr "(+ 3 4)")    <span class='arw'>&rarr;</span> (+ 3 4)
+
+(eval-string "(+ 3 4)")  <span class='arw'>&rarr;</span> 7
+</pre>
+
+
+<p>Using <tt>read-expr</tt> a customized code reader can be programmed
+preprocessing expressions before evaluation.</p>
+
+<p>See also <a href="#reader-event">reader-event</a> for preprocessing
+expressions event-driven.</p>
+
+<br/><br/>
+
+<a name="read-file"></a>
+<h2><span class="function">read-file</span></h2>
+<h4>syntax: (read-file <em>str-file-name</em>)</h4>
+
+<p>Reads a file in <em>str-file-name</em> in one swoop and returns a string buffer 
+containing the data.</p>
+
+<p>On failure the function returns <tt>nil</tt>. For error information, 
+use <a href="#sys-error">sys-error</a> when used on files. When used
+on URLs <a href="#net-error">net-error</a> gives more error
+information.</p>
+
+<!-- example -->
+
+<pre>
+(write-file "myfile.enc" 
+    (encrypt (read-file "/home/lisp/myFile") "secret"))
+</pre>
+
+
+<p>
+The file <tt>myfile</tt> is read, then encrypted using the password <tt>"secret"</tt> 
+before being written back into a new file titled <tt>"myfile.enc"</tt> 
+in the current directory.</p>
+
+<p>
+<tt>read-file</tt> can take an <tt>http://</tt> 
+or <tt>file://</tt> URL in <em>str-file-name</em>. 
+When the prefix is <tt>http://</tt>, <tt>read-file</tt> works exactly like 
+<a href="#get-url">get-url</a> and can take the same additional parameters.</p>
+
+<!-- example -->
+
+<pre>
+(read-file "http://asite.com/somefile.tgz" 10000)
+</pre>
+
+
+<p>
+	The file <tt>somefile.tgz</tt> is retrieved from 
+	the remote location <tt>http://asite.com</tt>. 
+	The file transfer will time out after 10 seconds 
+	if it is not finished. 
+	In this mode, <tt>read-file</tt> can also be used 
+	to transfer files from remote newLISP server nodes.</p>
+
+<p>See also the <a href="#write-file">write-file</a> and 
+<a href="#append-file">append-file</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="read-key"></a>
+<h2><span class="function">read-key</span></h2>
+<h4>syntax: (read-key)</h4>
+
+<p>
+Reads a key from the keyboard and returns an integer value. 
+For navigation keys, more than one <tt>read-key</tt> call 
+must be made. For keys representing ASCII characters, 
+the return value is the same on all OSes, except for navigation keys 
+and other control sequences like function keys, in which case the return 
+values may vary on different OSes and configurations.
+</p>
+
+
+<!-- example -->
+
+<pre>
+(read-key)  <span class='arw'>&rarr;</span> 97  ; after hitting the A key
+(read-key)  <span class='arw'>&rarr;</span> 65  ; after hitting the shifted A key
+(read-key)  <span class='arw'>&rarr;</span> 10  ; after hitting [enter] on Linux
+(read-key)  <span class='arw'>&rarr;</span> 13  ; after hitting [enter] on Windows
+
+(while (!= (set 'c (read-key)) 1) (println c))
+</pre>
+
+
+<p>
+The last example can be used to check return sequences 
+from navigation and function keys. To break out of the loop, 
+press <tt>Ctrl-A</tt>.
+</p>
+
+<p>Note that <tt>read-key</tt> will only work when newLISP is running in a
+Unix shell or Windows command shell. It will not work in the Java based newLISP-GS 
+or Tcl/Tk based newLISP-Tk frontend. It will also not work when executed by 
+newLISP Unix shared library or newLISP MS Windows DLL (Dynamic Link Library).</p>
+
+<br/><br/>
+
+<a name="read-line"></a>
+
+<h2><span class="function">read-line</span></h2>
+<h4>syntax: (read-line [<em>int-file</em>])</h4>
+
+<p>
+	Reads from the current I/O device a string 
+	delimited by a line-feed character (ASCII 10). 
+	There is no limit 
+	to the length of the string 
+	that can be read. 
+	The line-feed character is not part of the returned string. 
+	The line always breaks on a line-feed, 
+	which is then swallowed. 
+	A line breaks on a carriage return (ASCII 13) 
+	only if followed by a line-feed, 
+	in which case both characters are discarded. 
+	A carriage return alone only breaks and is swallowed 
+	if it is the last character in the stream.
+</p>
+
+<p>
+	By default, 
+	the current <a href="#device">device</a> 
+	is the keyboard (<a href="#device">device</a> <tt>0</tt>). 
+	Use the built-in function <a href="#device">device</a> 
+	to specify a different I/O device (e.g., a file). 
+	Optionally, 
+	a file handle can be specified 
+	in the <em>int-file</em> obtained 
+	from a previous <a href="#open">open</a> statement.
+</p>
+
+<p>
+	The last buffer contents 
+	from a read-line operation 
+	can be retrieved using <a href="#current-line">current-line</a>.
+</p>
+
+<p>When <tt>read-line</tt> is reading from a file or from <em>stdin</em>
+in a CGI program or pipe, it will return <tt>nil</tt> when input is exhausted.</p>
+
+<p>When using <tt>read-line</tt> on <em>stdin</em>, line length is limited
+to 2048 characters and performance is much faster.</p>
+
+<!-- example -->
+
+<pre>
+(print "Enter a num:")
+(set 'num (int (read-line)))
+
+(set 'in-file (open "afile.dat" "read"))
+(while (read-line in-file)
+        (write-line))   
+(close in-file)
+</pre>
+
+
+<p>
+	The first example reads input from the keyboard 
+	and converts it to a number. 
+	In the second example, 
+	a file is read line-by-line 
+	and displayed on the screen. 
+	The <tt>write-line</tt> statement 
+	takes advantage of the fact 
+	that the result from the last 
+	<tt>read-line</tt> operation 
+	is stored in a system internal buffer. 
+	When <a href="#write-line">write-line</a> 
+	is used without argument, 
+	it writes the contents 
+	of the last <tt>read-line</tt> buffer 
+	to the screen.
+</p>
+
+<p>
+	See also the <a href="#current-line">current-line</a> function
+	for retrieving this buffer.
+</p>
+
+<br/><br/>
+
+<a name="read-utf8"></a>
+<h2><span class="function">read-utf8</span></h2>
+
+<h4>syntax: (read-utf8 <em>int-file</em>)</h4>
+
+<p>Reads an UTF-8 character from a file specified by the file handle in <em>int-file</em>. 
+The file handle is obtained from a previous <a href="#open">open</a> operation. 
+Each <tt>read-utf8</tt> advances the file pointer by the number of bytes contained
+in the UTF-8 character.  Once the end of the file is reached, <tt>nil</tt> is returned. </p>
+
+<p>The function returns an integer value which can be converted to a displayable UTF-8
+character string using the <a href="#char">char</a> function.</p>
+
+<!-- example -->
+<pre>
+(set 'fle (open "utf8text.txt" "read"))
+(while (setq chr (read-utf8 fle))
+	(print (char chr)))
+</pre>
+
+
+<p>The example reads a file containing UTF-8 encoded text and displays it to the
+terminal screen.</p>
+
+<br/><br/>
+
+
+<a name="reader-event"></a>
+<h2><span class="function">reader-event</span></h2>
+<h4>syntax: (reader-event [<em>sym-event-handler | func-event-handler</em>])<br/>
+syntax: (reader-event nil)</h4>
+
+<p>An event handler can be specified to hook between newLISP's reader, 
+translation and evaluation process. The function specified in 
+<em>sym-event-handler</em> or <em>func-event-handler</em> gets called after 
+newLISP translates an expression and before evaluating it. The event handler can do 
+transformation on the expression before it gets evaluated.</p>
+
+<p>Specifying <tt>nil</tt> for the event will reset it to the initial default state.</p>
+
+<p>The following one-liner <tt>reader-event</tt> could be used to enhance
+the interactive shell with a tracer:</p>
+
+<!-- example -->
+<pre>
+<b>&gt;</b>(reader-event (lambda (ex) (print " =&gt; " ex)))
+$reader-event
+<b>&gt; (+ 1 2 3)
+ =&gt; (+ 1 2 3)
+6
+&gt;</b>
+</pre>
+
+<p>The expression intercepted passes through unchanged, but output
+is enhanced.</p>
+
+<p>The reader event function will be called after each reading of an s-expression
+by the <a href="#load">load</a> or <a href="#eval-string">eval-string</a> function.</p>
+
+<p>In versions previous to 10.5.8 <tt>reader-event</tt> was used to define a 
+<tt>macro</tt> expansion function in the module file <tt>macro.lsp</tt>. Starting 
+version 10.5.8, newLISP has <a href="#macro">macro</a> as a built-in function 
+behaving the same, but much faster when loading files and reading source.</p>
+
+<br/><br/>
+
+<a name="real-path"></a>
+<h2><span class="function">real-path</span></h2>
+<h4>syntax: (real-path [<em>str-path</em>])<br/>
+syntax: (real-path <em>str-exec-name</em> true)
+</h4>
+
+<p>
+In the first syntax <tt>real-path</tt> returns the full path from the relative 
+file path given in <em>str-path</em>. If a path is not given, <tt>"."</tt> 
+(the current directory) is assumed.</p>
+
+<!-- example -->
+
+<pre>
+(real-path)  <span class='arw'>&rarr;</span> "/usr/home/fred"  ; current directory
+(real-path "./somefile.txt")
+<span class='arw'>&rarr;</span> "/usr/home/fred/somefile.txt"
+</pre>
+
+<p>In the second syntax <tt>real-path</tt> returns the full path for an 
+executable found given in <em>str-exe-name</em>. This syntax relies on an 
+environment variable PATH defined on UNIX and Windows systems.</p>
+
+<pre>
+(real-path "make" true) <span class='arw'>&rarr;</span> "/usr/bin/make"
+</pre>
+
+<p>The output length is limited by the OS's maximum allowed path length. 
+If <tt>real-path</tt> fails (e.g., because of a nonexistent path), 
+<tt>nil</tt> is returned.</p>
+
+<br/><br/>
+
+<a name="receive"></a>
+<h2><span class="function">receive</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (receive <em>int-pid</em> <em>sym-message</em>)<br/>
+syntax: (receive)</h4>
+
+<p>In the first syntax, the function is used for message exchange between 
+child processes launched with <a href="#spawn">spawn</a> and their parent 
+process. The message received replaces the contents in <em>sym-message.</em></p>
+
+<p>The function reads one message from the receiver queue of <em>int-pid</em>
+for each invocation. When the queue is empty, <tt>nil</tt> is returned.</p>
+
+<!-- example -->
+
+<pre>
+; sending process
+(send spid "hello")  <span class='arw'>&rarr;</span> true
+
+; receiving process
+(receive pid msg)    <span class='arw'>&rarr;</span> true
+msg                  <span class='arw'>&rarr;</span> "hello"
+</pre>
+
+<p>To make <tt>receive</tt> blocking and wait for arriving messages,
+use the following form:</p>
+
+<pre>
+; wait until a message can be read
+(until (receive pid msg))
+</pre>
+
+<p>The function will loop until a message can be read from the queue.</p>
+
+<p>In the second syntax, the function returns a list of all child processes
+with pending messages for the parent process:</p>
+
+<!-- example -->
+<pre>
+; read pending messages from child processes
+(dolist (pid (receive))
+    (receive pid msg)
+    (println "received message: " msg " from:" pid)
+)
+</pre>
+
+<p>The list of child process IDs returned by <tt>(receive)</tt> only
+contains PIDs of processes which have unread messages in their 
+send queues. The <tt>(receive pid msg)</tt> statement now can
+be issued non-blocking, because it always is guaranteed to find
+a pending message in a child's message queue.</p>
+
+<p>The <tt>receive</tt> function is not available on MS Windows.</p>
+
+<p>For a more detailed discussion of this function and examples, see the
+<a href="#send">send</a> function.</p>
+
+<br/><br/>
+
+<a name="ref"></a>
+<h2><span class="function">ref</span></h2>
+<h4>syntax: (ref <em>exp-key</em> <em>list</em> [<em>func-compare</em> [true]])</h4>
+
+<p><tt>ref</tt> searches for the key expression <em>exp-key</em> in <em>list</em> and 
+returns a list of integer indices or an empty list if <em>exp-key</em> cannot be 
+found.  <tt>ref</tt> can work together with <a href="#push">push</a> and 
+<a href="pop">pop</a>, both of which can also take lists of indices.</p>
+
+<p>By default, <tt>ref</tt> checks if expressions are equal. With <em>func-compare</em>, 
+more complex comparison functions can be used. The comparison function can be a 
+previously defined function. Note that this function always takes two arguments,
+even if only the second argument is used inside the function.</p>
+
+<p>When the optional <tt>true</tt> parameter is present, the element found
+is returned instead of the index vector.</p>
+
+<!-- example -->
+
+<pre>
+; get index vectors for list elements
+
+(set 'pList '(a b (c d (x) e)))
+
+(ref 'x pList)    <span class='arw'>&rarr;</span> (2 2 0)
+
+(ref '(x) pList)   <span class='arw'>&rarr;</span> (2 2)
+
+; the key expression is in a variable
+
+(set 'p '(c d (x) e))
+
+(ref p pList)   <span class='arw'>&rarr;</span> (2)
+
+; indexing using the vector returned from ref
+
+(set 'v (ref '(x) pList)) <span class='arw'>&rarr;</span> (2 2)
+
+(pList v) <span class='arw'>&rarr;</span> (x)
+
+; if nothing is found, nil is returned
+
+(ref 'foo plist)  <span class='arw'>&rarr;</span> nil
+
+; not specifying a comparison functor assumes =
+
+(set 'L '(a b (c d (e) f)))
+
+(ref 'e L)      <span class='arw'>&rarr;</span> (2 2 0)
+(ref 'e L =)    <span class='arw'>&rarr;</span> (2 2 0)
+
+; a is the first symbol where e is greater
+
+(ref 'e L &gt;)  <span class='arw'>&rarr;</span> (0)
+
+; return the element instead of the index
+
+(ref 'e L &gt; true)  <span class='arw'>&rarr;</span> a
+
+; use an anonymous comparison function
+
+(ref 'e L (fn (x y) (or (= x y) (= y 'd))))      <span class='arw'>&rarr;</span> (2 1)
+
+(ref 'e L (fn (x y) (or (= x y) (= y 'd))) true) <span class='arw'>&rarr;</span> d
+</pre>
+
+
+<p>
+The following example shows the use of 
+<a href="#match">match</a> and <a href="#unify">unify</a> 
+to formulate searches that are as powerful as regular expressions are 
+for strings:
+</p>
+
+
+<pre>
+(set 'L '((l 3) (a 12) (k 5) (a 10) (z 22)))
+
+; use match as a comparison function
+
+(ref '(a ?) L match) <span class='arw'>&rarr;</span> (1)
+
+; use unify as a comparison function
+
+(set 'L '( ((a b) (c d)) ((e e) (f g)) ))
+
+(ref '(X X) L unify)      <span class='arw'>&rarr;</span> (1 0)
+
+(ref '(X g) L unify)      <span class='arw'>&rarr;</span> (1 1)
+
+(ref '(X g) L unify true) <span class='arw'>&rarr;</span> (f g)
+</pre>
+
+
+<p> The <tt>'(X X)</tt> pattern with <a href="#unify">unify</a> searches for a list pair 
+where the two elements are equal.  The <tt>unify</tt> pattern <tt>'(X g)</tt>
+searches for a list pair with the symbol <tt>g</tt> as the second member.
+The patterns are quoted to protect them from evaluation.</p>
+
+<p>Pass the list as a default functor:</p>
+
+<pre>
+(set 'C:C '(a b (c d) e f))
+
+(ref 'd C)  <span class='arw'>&rarr;</span> (2 1)
+</pre>
+
+<p>This is suitable when passing lists by reference using a context. See also
+the chapter <a href="#pass_big">Passing data by reference</a>.</p>
+
+<p> See also the <a href="#ref-all">ref-all</a> function, which searches for all occurrences
+of a key expression in a nested list. </p>
+
+<br/><br/>
+
+<a name="ref-all"></a>
+<h2><span class="function">ref-all</span></h2>
+<h4>syntax: (ref-all <em>exp-key</em> <em>list</em> [<em>func-compare</em> [true]])</h4>
+
+<p> Works similarly to <a href="#ref">ref</a>, but returns a list of all index vectors found 
+for <em>exp-key</em> in <em>list</em>. </p>
+
+<p>When the optional <tt>true</tt> parameter is present, the elements found
+is returned of the index vectors.</p>
+
+<p>By default, <tt>ref-all</tt> checks if expressions are equal. 
+With <em>func-compare</em>, more complex comparison functions can be used.
+</p>
+
+<p>The system variable <tt>$count</tt> counts the number of elements found.</p>
+
+<!-- example -->
+
+<pre>
+(set 'L '(a b c (d a f (a h a)) (k a (m n a) (x))))
+
+(ref-all 'a L) <span class='arw'>&rarr;</span> ((0) (3 1) (3 3 0) (3 3 2) (4 1) (4 2 2))
+$count <span class='arw'>&rarr;</span> 6
+
+; the index vector returned by ref-all can be used to index the list
+
+(L '(3 1)) <span class='arw'>&rarr;</span> a
+
+; mapped implicit indexing of L 
+
+(map 'L (ref-all 'a L)) <span class='arw'>&rarr;</span> (a a a a a a)
+
+; with comparison operator
+
+(set 'L '(a b c (d f (h l a)) (k a (m n) (x))))
+
+; not specifying a comparison functor assumes =
+
+(ref-all 'c L)       <span class='arw'>&rarr;</span> ((2))
+(ref-all 'c L =)     <span class='arw'>&rarr;</span> ((2))
+
+; look for all elements where c is greater
+
+(ref-all 'c L &gt;)       <span class='arw'>&rarr;</span> ((0) (1) (3 2 2) (4 1))
+(ref-all 'c L &gt; true)  <span class='arw'>&rarr;</span> (a b a a)
+
+
+; use an anonymous function to compare
+
+(ref-all 'a L (fn (x y) (or (= x y) (= y 'k))))  
+<span class='arw'>&rarr;</span> ((0) (3 2 2) (4 0) (4 1))
+
+; the key is nil because the comparison function only looks at the second argument
+
+(ref-all nil L (fn (x y) (&gt; (length y) 2)))      
+<span class='arw'>&rarr;</span> ((3) (3 2) (4))
+
+; define the comparison functions first
+
+(define (is-long? x y) (&gt; (length y) 2)) ; the x gets occupied by 'nil
+
+(ref-all nil L is-long?)    <span class='arw'>&rarr;</span>  ((3) (3 2) (4))
+
+(define (is-it-or-d x y) (or (= x y) (= y 'd)))
+
+(set 'L '(a b (c d (e) f)) )
+
+(ref-all 'e L is-it-or-d)  <span class='arw'>&rarr;</span> ((2 1) (2 2 0))
+</pre>
+
+
+<p>
+The comparison function can be a previously defined function. 
+Note that the comparison function always takes two arguments, 
+even if only the second argument is used 
+inside the function (as in the example using <tt>is-long?</tt>).
+</p>
+
+<p>
+Using the <a href="#match">match</a> and <a href="#unify">unify</a> functions, list 
+searches can be formulated that are as powerful as regular expression searches are 
+for strings.
+</p>
+
+
+<pre>
+(set 'L '((l 3) (a 12) (k 5) (a 10) (z 22)) )
+
+; look for all pairs staring with the symbol a
+
+(ref-all '(a ?) L match)      <span class='arw'>&rarr;</span> ((1) (3))
+(ref-all '(a ?) L match true) <span class='arw'>&rarr;</span> ((a 12) (a 10))
+
+; look for all pairs where elements are equal
+
+(set 'L '( ((a b) (c d)) ((e e) (f g)) ((z) (z))))
+
+(ref-all '(X X) L unify)      <span class='arw'>&rarr;</span> ((1 0) (2))
+(ref-all '(X X) L unify true) <span class='arw'>&rarr;</span> ((e e) ((z) (z)))
+
+; look for all pairs where the second element is the symbol g
+
+(set 'L '( ((x y z) g) ((a b) (c d)) ((e e) (f g)) ))
+
+(ref-all '(X g) L unify)      <span class='arw'>&rarr;</span> ((0) (2 1))
+(ref-all '(X g) L unify true) <span class='arw'>&rarr;</span> (((x y z) g) (f g))
+</pre>
+
+<p> See also the <a href="#ref">ref</a> function. </p>
+
+<br/><br/>
+
+<a name="regex"></a>
+
+<h2><span class="function">regex</span></h2>
+<h4>syntax: (regex <em>str-pattern</em> <em>str-text</em> [<em>regex-option</em> [<em>int-offset</em>]])</h4>
+
+<p>Performs a Perl Compatible Regular Expression (PCRE) search 
+on <em>str-text</em> with the pattern specified in <em>str-pattern</em>. 
+The same regular expression pattern matching 
+is also supported in the functions <a href="#directory">directory</a>, 
+<a href="#find">find</a>, <a href="#find-all">find-all</a>, 
+<a href="#parse">parse</a>, <a href="#replace">replace</a>, 
+and <a href="#search">search</a> when using these functions on strings.
+</p>
+
+<p>
+<tt>regex</tt> returns a list with the matched strings and substrings 
+and the beginning and length of each string inside the text. 
+If no match is found, it returns <tt>nil</tt>.
+The offset numbers can be used for subsequent processing.
+</p>
+
+<p>Additionally a <em>regex-option</em> can be specified to control certain
+regular expression options explained later. Options can be given either by
+numbers or letters in a string.</p>
+
+<p>The additional <em>int-offset</em>
+parameter tells <tt>regex</tt> to start searching for a match not at the
+beginning of the string but at an offset.</p>
+
+<p>When no <em>regex-option</em> is present, the offset and length numbers in 
+the <tt>regex</tt> results are given based bytes even when running the UTF-8 
+enabled version of newLISP. When specifying the PCRE_UTF8 option in <em>regex-option</em>
+only offset and length are reported in UTF8 characters.</p>
+
+<p>
+<tt>regex</tt> also sets the variables <tt>$0, $1,</tt> 
+and <tt>$2&mdash;</tt> 
+to the expression and subexpressions found. 
+Just like any other symbol in newLISP, 
+these variables or their equivalent expressions 
+<tt>($ 0), ($ 1),</tt> and <tt>($ 2)&mdash;</tt> can be used in other 
+newLISP expressions for further processing.
+</p>
+
+<p>Functions using regular expressions will not reset the <tt>$0, $1 ... $15</tt> 
+variables to <tt>nil</tt> when no match is found.</p>
+
+<!-- example -->
+
+<pre>
+(regex "b+" "aaaabbbaaaa")  <span class='arw'>&rarr;</span> ("bbb" 4 3)
+
+; case-insensitive search option 1
+(regex "b+" "AAAABBBAAAA" 1)  <span class='arw'>&rarr;</span> ("BBB" 4 3) 
+; same option given as a string
+(regex "b+" "AAAABBBAAAA" "i")  <span class='arw'>&rarr;</span> ("BBB" 4 3) 
+
+(regex "[bB]+" "AAAABbBAAAA" )  <span class='arw'>&rarr;</span> ("BbB" 4 3)
+
+(regex "http://(.*):(.*)" "http://nuevatec.com:80") 
+<span class='arw'>&rarr;</span> ("http://nuevatec.com:80" 0 22 "nuevatec.com" 7 12 "80" 20 2)
+
+$0  <span class='arw'>&rarr;</span> "http://nuevatec.com:80"
+$1  <span class='arw'>&rarr;</span> "nuevatec.com"
+$2  <span class='arw'>&rarr;</span> "80"
+
+(dotimes (i 3) (println ($ i)))
+<b>http://nuevatec.com:80
+nuevatec.com
+80</b>
+<span class='arw'>&rarr;</span> "80"
+</pre>
+
+
+<p>
+	The second example shows the usage of extra options,
+	while the third example demonstrates more complex parsing of two subexpressions
+	that were marked by parentheses in the search pattern.
+	In the last example,
+	the expression and subexpressions are retrieved using the system variables 
+	<tt>$0</tt> to <tt>$2</tt> or their equivalent expression <tt>($ 0)</tt> to <tt>($ 2)</tt>.
+</p>
+
+<p>
+	When <tt>""</tt> (quotes) are used 
+	to delimit strings 
+	that include literal backslashes, 
+	the backslash must be doubled in the regular expression pattern.
+	As an alternative, <tt>{ }</tt> (curly brackets) 
+	or <tt>[text]</tt> and <tt>[/text]</tt> (text tags) 
+	can be used to delimit text strings.
+	In these cases, no extra backslashes are required.
+</p>
+
+<p>
+	Characters escaped by a backslash in newLISP 
+	(e.g., the quote <tt>\"</tt> or <tt>\n</tt>) 
+	need not to be doubled in a regular expression pattern, 
+	which itself is delimited by quotes.
+</p>
+
+
+<pre>
+;; double backslash for parentheses and other special char in regex
+(regex "\\(abc\\)" "xyz(abc)xyz")  <span class='arw'>&rarr;</span> ("(abc)" 3 5)  
+;; double backslash for backslash (special char in regex)
+(regex "\\d{1,3}" "qwerty567asdfg")  <span class='arw'>&rarr;</span> ("567" 6 3)
+
+;; one backslash for quotes (special char in newLISP)
+(regex "\"" "abc\"def")  <span class='arw'>&rarr;</span> ("\"" 3 1)     
+
+;; brackets as delimiters
+(regex {\(abc\)} "xyz(abc)xyz")  <span class='arw'>&rarr;</span> ("(abc)" 3 5)  
+
+;; brackets as delimiters and quote in pattern
+(regex {"} "abc\"def")  <span class='arw'>&rarr;</span> ("\"" 3 1)     
+
+;; text tags as delimiters, good for multiline text in CGI
+(regex [text]\(abc\)[/text] "xyz(abc)xyz")  <span class='arw'>&rarr;</span> ("(abc)" 3 5)  
+(regex [text]"[/text] "abc\"def")           <span class='arw'>&rarr;</span> ("\"" 3 1) 
+</pre>
+
+
+<p>
+	When curly brackets or text tags 
+	are used to delimit the pattern string 
+	instead of quotes, 
+	a simple backslash is sufficient. 
+	The pattern and string are then passed in raw form 
+	to the regular expression routines.
+	When curly brackets are used inside a pattern 
+	itself delimited by curly brackets,
+	the inner brackets must be balanced, as follows:
+</p>
+
+
+<pre>
+;; brackets inside brackets are balanced
+(regex {\d{1,3}} "qwerty567asdfg")  <span class='arw'>&rarr;</span> ("567" 6 3) 
+</pre>
+
+
+
+<p>
+The following constants can be used for <em>regex-option</em>.
+Several options can be combined using a binary or <tt>|</tt> (pipe) operator. 
+E.g. <tt>(| 1 4)</tt> would combine options <tt>1</tt> and <tt>4</tt> or <tt>"is"</tt>
+when using letters for the two options.</p>
+
+<p>The last two options are specific for newLISP. The REPLACE_ONCE option is only 
+to be used in <a href="#replace">replace</a>; it can be combined with other PCRE options.</p>
+
+<p>Multiple options can be combined using a <tt>+</tt> (plus) or <tt>|</tt> (or) operator,
+e.g.: <tt>(| PCRE_CASELESS PCRE_DOTALL)</tt> or <tt>"is"</tt> when using letters as options.
+</p>
+
+<table width="98%" summary="regex options">
+<tr align="left"><th>PCRE name</th><th>no</th><th>description</th></tr>
+<tr><td>PCRE_CASELESS</td><td>1 or i</td><td>treat uppercase like lowercase</td></tr>
+<tr><td>PCRE_MULTILINE</td><td>2 or m</td><td>limit search at a newline like Perl's /m</td></tr>
+<tr><td>PCRE_DOTALL</td><td>4 or s</td><td>. (dot) also matches newline</td></tr>
+<tr><td>PCRE_EXTENDED</td><td>8 or x</td><td>ignore whitespace except inside char class</td></tr>
+<tr><td>PCRE_ANCHORED</td><td>16 or A</td><td>anchor at the start</td></tr>
+<tr><td>PCRE_DOLLAR_ENDONLY</td><td>32 or D</td><td>$ matches at end of string, not before newline</td></tr>
+<tr><td>PCRE_EXTRA</td><td>64</td><td>additional functionality currently not used</td></tr>
+<tr><td>PCRE_NOTBOL</td><td>128</td><td>first ch, not start of line; ^ shouldn't match</td></tr>
+<tr><td>PCRE_NOTEOL</td><td>256</td><td>last char, not end of line; $ shouldn't match</td></tr>
+<tr><td>PCRE_UNGREEDY</td><td>512i or U</td><td>invert greediness of quantifiers</td></tr>
+<tr><td>PCRE_NOTEMPTY</td><td>1024</td><td>empty string considered invalid</td></tr>
+<tr><td>PCRE_UTF8</td><td>2048 or u</td><td>pattern and strings as UTF-8 characters</td></tr>
+<tr><td>REPLACE_ONCE</td><td>0x8000</td><td>replace only one occurrence only for use in <a href="#replace">replace</a></td></tr>
+<tr><td>PRECOMPILED</td><td>0x10000 or p</td><td>pattern is pre-compiled, can only be combined with RREPLACE_ONCE 0x8000</td></tr>
+</table><br/>
+
+<p>The settings of the PCRE_CASELESS, PCRE_MULTILINE, PCRE_DOTALL, and PCRE_EXTENDED 
+options can be changed from within the pattern by a sequence of option letters enclosed 
+between "(?" and ")". The option letters are:</p>
+
+<table summary="regex inline options">
+<tr><td>i</td><td>for PCRE_CASELESS</td></tr>
+<tr><td>m</td><td>for PCRE_MULTILINE</td></tr>
+<tr><td>s</td><td>for PCRE_DOTALL</td></tr>
+<tr><td>x</td><td>for PCRE_EXTENDED</td></tr>
+</table><br/>
+
+<p> Note that regular expression syntax is very complex 
+and feature-rich with many special characters and forms.
+Please consult a book or the PCRE manual pages for more detail.
+Most PERL books or introductions to Linux or Unix 
+also contain chapters about regular expressions.
+See also <a href="http://www.pcre.org">http://www.pcre.org</a> 
+for further references and manual pages.  </p>
+
+<p>Regular expression patterns can be precompiled for higher speed when using 
+changing repetitive patterns with <a href="#regex-comp">regex-comp</a>.</p>
+
+<br/><br/>
+
+<a name="regex-comp"></a>
+<h2><span class="function">regex-comp</span></h2>
+<h4>syntax: (regex-comp <em>str-pattern</em> [<em>int-option</em>])</h4>
+
+<p>newLISP automatically compiles regular expression patterns and caches 
+the last compilation to speed up repetitive pattern searches. If patterns
+change from one to the next, but are repeated over and over again, then 
+the caching of the last pattern is not sufficient. <tt>regex-comp</tt>
+can be used to pre-compile repetitive patterns to speed up regular 
+expression searches:</p>
+
+
+<!-- example -->
+
+<pre>
+; slower without pre-compilation
+
+(dolist (line page)
+	(replace pattern-str1 line repl1 0)
+	(replace pattern-str2 line repl2 512)
+)
+
+; fast with pre-compilation and option 0x10000
+
+(set 'p1 (regex-comp pattern-str1))
+(set 'p2 (regex-comp pattern-str2 512))
+
+(dolist (line page)
+	(replace p1 line repl1 0x10000)
+	(replace p2 line repl2 0x10000)
+)
+</pre>
+
+
+<p>When using pre-compiled patterns in any of the functions using regular
+expressions, the option number is set to <tt>0x10000</tt> to signal
+that pre-compiled patterns are used. Normal pattern options are specified
+ during pre-compilation with <tt>regex-comp</tt> . The <tt>0x10000</tt> option 
+can only be combined with <tt>0x8000</tt>, the option used to specify that only 
+one replacement should be made when using <a href="#replace">replace</a>.</p>
+
+<p>The function <a href="#ends-with">ends-with</a> should not be used with compiled 
+patterns, as it tries to append to an un-compiled pattern internally.</p>
+
+<br/><br/>
+
+<a name="remove-dir"></a>
+<h2><span class="function">remove-dir</span></h2>
+<h4>syntax: (remove-dir <em>str-path</em>)</h4>
+
+<p>
+	Removes the directory
+	whose path name is specified in <em>str-path</em>.
+	The directory must be empty for <tt>remove-dir</tt> to succeed.
+	Returns <tt>nil</tt> on failure.
+</p>
+
+<!-- example -->
+
+<pre>
+(remove-dir "temp")
+</pre>
+
+
+<p>
+	Removes the directory <tt>temp</tt> 
+	in the current directory.
+</p>
+
+<br/><br/>
+
+<a name="rename-file"></a>
+<h2><span class="function">rename-file</span></h2>
+<h4>syntax: (rename-file <em>str-path-old</em> <em>str-path-new</em>)</h4>
+
+<p>
+Renames a file or directory entry given in the path name <em>str-path-old</em> 
+to the name given in <em>str-path-new</em>. Returns <tt>nil</tt> or <tt>true</tt> 
+depending on the operation's success.
+</p>
+
+<!-- example -->
+
+<pre>
+(rename-file "data.lisp" "data.backup")
+</pre>
+
+<br/><br/>
+
+<a name="replace"></a>
+<h2><span class="function">replace</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (replace <em>exp-key</em> <em>list</em> <em>exp-replacement</em> [<em>func-compare</em>])<br/>
+syntax: (replace <em>exp-key</em> <em>list</em>)<br/><br/>
+
+syntax: (replace <em>str-key</em> <em>str-data</em> <em>exp-replacement</em>)<br/>
+syntax: (replace <em>str-pattern</em> <em>str-data</em> <em>exp-replacement</em> <em>regex-option</em>)</h4>
+
+<h3>List replacement</h3>
+
+<p>If the second argument is a list, <tt>replace</tt> replaces all elements in
+the list <em>list</em> that are equal to the expression in <em>exp-key</em>. The 
+element is replaced with <em>exp-replacement</em>. If <em>exp-replacement</em>
+is missing, all instances of <em>exp-key</em> will be deleted from <em>list</em>.
+</p>
+
+<p>Note that <tt>replace</tt> is 
+destructive. It changes the list passed to it and returns the changed list. The 
+number of replacements made is contained in the system variable <tt>$count</tt> 
+when the function returns. During executions of the replacement expression, the 
+anaphoric system variable <tt>$it</tt> is set to the expression to be replaced.
+</p>
+
+<p>Optionally, <em>func-compare</em> can specify a comparison operator 
+or user-defined function. By default, <em>func-compare</em> is the <tt>=</tt> 
+(equals sign).</p>
+
+<!-- example -->
+
+<pre>
+;; list replacement
+
+(set 'aList '(a b c d e a b c d))
+
+(replace 'b aList 'B)  <span class='arw'>&rarr;</span> (a B c d e a B c d)
+aList  <span class='arw'>&rarr;</span> (a B c d e a B c d)
+$count <span class='arw'>&rarr;</span> 2  ; number of replacements
+
+;; list replacement with special compare functor/function
+
+; replace all numbers where 10 &lt; number
+(set 'L '(1 4 22 5 6 89 2 3 24))
+
+(replace 10 L 10 &lt;) <span class='arw'>&rarr;</span> (1 4 10 5 6 10 2 3 10)
+$count <span class='arw'>&rarr;</span> 3
+
+; same as:
+
+(replace 10 L 10 (fn (x y) (&lt; x y))) <span class='arw'>&rarr;</span> (1 4 10 5 6 10 2 3 10)
+
+; change name-string to symbol, x is ignored as nil
+
+(set 'AL '((john 5 6 4) ("mary" 3 4 7) (bob 4 2 7 9) ("jane" 3)))
+
+(replace nil AL (cons (sym ($it 0)) (rest $it)) 
+                (fn (x y) (string? (y 0)))) ; parameter x = nil not used
+<span class='arw'>&rarr;</span> ((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3))
+
+; use $count in the replacement expression
+(replace 'a '(a b a b a b) (list $count $it) =) <span class='arw'>&rarr;</span>  ((1 a) b (2 a) b (3 a) b)
+</pre>
+
+
+<p>
+Using the <a href="#match">match</a> and <a href="#unify">unify</a> functions,
+list searches can be formulated that are as powerful as regular expression string 
+searches:</p>
+
+
+<pre>
+; calculate the sum in all associations with 'mary
+
+(set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+
+(replace '(mary *)  AL (list 'mary (apply + (rest $it))) match)
+<span class='arw'>&rarr;</span> ((john 5 6 4) (mary 14) (bob 4 2 7 9) (jane 3))
+$count <span class='arw'>&rarr;</span> 1
+
+; make sum in all expressions
+
+(set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+
+(replace '(*) AL (list ($it 0) (apply + (rest $it))) match)
+<span class='arw'>&rarr;</span> ((john 15) (mary 14) (bob 22) (jane 3))
+$count <span class='arw'>&rarr;</span> 4
+
+; using unify, replace only if elements are equal
+(replace '(X X) '((3 10) (2 5) (4 4) (6 7) (8 8)) (list ($it 0) 'double ($it 1)) unify)
+<span class='arw'>&rarr;</span> ((3 10) (2 5) (4 double 4) (6 7) (8 double 8))
+ </pre>
+
+
+<h3>List removal</h3>
+<p>
+The last form of <tt>replace</tt> has only two arguments: the expression <em>exp</em> 
+and <em>list</em>. This form removes all <em>exp</em>s found in <em>list</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+;; removing elements from a list
+
+(set 'lst '(a b a a c d a f g))
+(replace 'a lst)  <span class='arw'>&rarr;</span> (b c d f g)
+lst               <span class='arw'>&rarr;</span> (b c d f g)
+
+$count <span class='arw'>&rarr;</span> 4
+</pre>
+
+
+<h3>String replacement without regular expression</h3>
+
+<p>If all arguments are strings, <tt>replace</tt> replaces all occurrences 
+of <em>str-key</em> in <em>str-data</em> with the evaluated 
+<em>exp-replacement</em>, returning the changed string. The expression in 
+<em>exp-replacement</em> is evaluated for every replacement. The number of 
+replacements made is contained in the system variable <tt>$count</tt>. This 
+form of <tt>replace</tt> can also process binary <tt>0</tt>s (zeros).</p>
+
+<!-- example -->
+
+<pre>
+;; string replacement
+(set 'str "this isa sentence")
+(replace "isa" str "is a")  <span class='arw'>&rarr;</span> "this is a sentence"
+
+$count <span class='arw'>&rarr;</span> 1
+</pre>
+
+
+<h3>Regular expression replacement</h3>
+<p>
+The presence of a fourth parameter indicates that a regular expression search 
+should be performed with a regular expression pattern specified in <em>str-pattern</em> 
+and an option number specified in <em>regex-option</em> (e.g., <tt>1</tt> (one) or "i" for 
+case-insensitive searching or <tt>0</tt> (zero) for a standard Perl Compatible Regular 
+Expression (PCRE) search without options). See <a href="#regex">regex</a> above for details.
+</p>
+
+<p>
+By default, <tt>replace</tt> replaces all occurrences of a search string even if a 
+beginning-of-line specification is included in the search pattern. 
+After each replace, a new search is started at a new position in <em>str-data</em>.
+Setting the option bit to <tt>0x8000</tt> in <em>regex-option</em> will force 
+<tt>replace</tt> to replace only the first occurrence. The changed string is returned.
+</p>
+
+<p>
+<tt>replace</tt> with regular expressions also sets the internal variables 
+<tt>$0, $1,</tt> and <tt>$2&mdash;</tt> with the contents of the expressions 
+and subexpressions found. The anaphoric system variable <tt>$it</tt> is set to
+the same value as <tt>$0</tt>. These can be used to perform replacements 
+that depend on the content found during replacement. The symbols <tt>$it, $0, $1,</tt> 
+and <tt>$2&mdash;</tt> can be used in expressions just like any other symbols.
+If the replacement expression evaluates to something other than a string,
+no replacement is made. As an alternative, the contents of these variables can 
+also be accessed by using <tt>($ 0), ($ 1), ($ 2),</tt> and so forth.
+This method allows indexed access (e.g., <tt>($ i)</tt>,
+where <tt>i</tt> is an integer).
+</p>
+
+<p>After all replacements are made, the number of replacements 
+is contained in the system variable <tt>$count</tt>.</p>
+
+<!-- example -->
+
+<pre>
+;; using the option parameter to employ regular expressions
+
+(set 'str "ZZZZZxZZZZyy")     <span class='arw'>&rarr;</span> "ZZZZZxZZZZyy"
+(replace "x|y" str "PP" 0)    <span class='arw'>&rarr;</span> "ZZZZZPPZZZZPPPP"
+str                           <span class='arw'>&rarr;</span> "ZZZZZPPZZZZPPPP"
+
+;; using system variables for dynamic replacement
+
+(set 'str "---axb---ayb---")
+(replace "(a)(.)(b)" str (append $3 $2 $1) 0) 
+<span class='arw'>&rarr;</span> "---bxa---bya---"
+
+str  <span class='arw'>&rarr;</span> "---bxa---bya---"
+
+;; using the 'replace once' option bit 0x8000
+
+(replace "a" "aaa" "X" 0)  <span class='arw'>&rarr;</span> "XXX"
+
+(replace "a" "aaa" "X" 0x8000)  <span class='arw'>&rarr;</span> "Xaa"
+
+;; URL translation of hex codes with dynamic replacement
+
+(set 'str "xxx%41xxx%42")
+(replace "%([0-9A-F][0-9A-F])" str 
+               (char (int (append "0x" $1))) 1)
+
+str    <span class='arw'>&rarr;</span> "xxxAxxxB"
+
+$count <span class='arw'>&rarr;</span> 2
+</pre>
+
+
+<p>
+The <a href="#setf">setf</a> function together with <a href="#nth">nth</a>,
+<a href="#first">first</a> or <a href="#last">last</a> can also
+be used to change elements in a list.</p>
+
+<p>
+	See <a href="#directory">directory</a>,
+	<a href="#find">find</a>,
+	<a href="#find-all">find-all</a>,
+	<a href="#parse">parse</a>,
+	<a href="#regex">regex</a>, 
+	and <a href="#search">search</a> 
+	for other functions using regular expressions.
+</p>
+
+<br/><br/>
+
+<a name="reset"></a>
+<h2><span class="function">reset</span></h2>
+<h4>syntax: (reset)<br/>
+syntax: (reset true)<br/>
+syntax: (reset <em>int-max-cells</em>)</h4>
+
+<p>
+In the first syntax, <tt>reset</tt> returns to the top level of evaluation,
+switches the <a href="#trace">trace</a> mode off, and switches to the MAIN 
+context/namespace. <tt>reset</tt> restores the top-level variable environment 
+using the saved variable environments on the stack. It also throws an error 
+"user reset - no error" which can be reported with user defined error handlers.
+Since version 10.5.5 <tt>reset</tt> also interrupts command line parameter
+processing.</p>
+
+<p><tt>reset</tt> walks through the entire cell space, 
+which may take a few seconds in a heavily loaded system.</p>
+
+<p><tt>reset</tt> occurs automatically after an error condition.</p>
+
+<p>In the second syntax, <tt>reset</tt> will stop the current process 
+and start a new clean newLISP process with the same command-line parameters.
+This mode will only work when newLISP was started using its full path-name, 
+e.g. <tt>/usr/bin/newlisp</tt> instead of only <tt>newlisp</tt>. This mode is 
+not available on MS Windows.</p>
+
+<p>In the third syntax. <tt>reset</tt> will change the maximum cell count allowed
+in the system. This number is also reported as the second number in the list 
+by <a href="#sys-info">sys-info</a>. On 64-bit newLISP one lisp cell occupies
+32 bytes, or 16 bytes on the 32-bit version. This does not include
+string memory, which may be pointed to by cells.</p>
+
+<p>The minimum cell count is 4095, trying to specify less will set it to 4095.
+The program will exit when trying to allocate more.</p>
+
+<pre>
+(sys-info)  <span class='arw'>&rarr;</span> (437 576460752303423488 409 1 0 2048 0 60391 10602 1411)
+
+; allocate about 1 Mbyte of cell memory on 64-bit newlisp
+(reset 32768) <span class='arw'>&rarr;</span> true
+
+(sys-info)  <span class='arw'>&rarr;</span> (437 32768 409 1 0 2048 0 60392 10602 1411)
+</pre>
+
+<p>Resetting the maximum cell count will not restart the system and can be done at any point
+in a program. Cell memory is allocated in blocks of 4095 cells, which is also initial 
+minimum configuration.</p>
+
+<br/><br/>
+
+<a name="rest"></a>
+<h2><span class="function">rest</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+
+<h4>syntax: (rest <em>list</em>)<br/>
+syntax: (rest <em>array</em>)<br/>
+syntax: (rest <em>str</em>)</h4>
+
+<p>Returns all of the items in a list or a string, except for the first.
+<tt>rest</tt> is equivalent to <em>cdr</em> or <em>tail</em> in other Lisp dialects.
+</p>
+
+<!-- example -->
+
+<pre>
+(rest '(1 2 3 4))            <span class='arw'>&rarr;</span> (2 3 4)
+(rest '((a b) c d))          <span class='arw'>&rarr;</span> (c d)
+(set 'aList '(a b c d e))    <span class='arw'>&rarr;</span> (a b c d e)
+(rest aList)                 <span class='arw'>&rarr;</span> (b c d e)
+(first (rest aList))         <span class='arw'>&rarr;</span> b
+(rest (rest aList))          <span class='arw'>&rarr;</span> (d e)
+(rest (first '((a b) c d)))  <span class='arw'>&rarr;</span> (b)
+
+(set 'A (array 2 3 (sequence 1 6)))
+<span class='arw'>&rarr;</span> ((1 2) (3 4) (5 6))
+
+(rest A)  <span class='arw'>&rarr;</span> ((3 4) (5 6))
+
+(rest '()) <span class='arw'>&rarr;</span> ()
+</pre>
+
+
+<p>
+In the second version, <tt>rest</tt> returns all but the first character 
+of the string <em>str</em> in a string.
+</p>
+
+<!-- example -->
+
+<pre>
+(rest "newLISP")          <span class='arw'>&rarr;</span> "ewLISP"
+(first (rest "newLISP"))  <span class='arw'>&rarr;</span> "e"
+</pre>
+
+
+<p>
+See also the <a href="#first">first</a> and <a href="#last">last</a> functions.
+</p>
+
+<p>
+Note that an <em>implicit rest</em> is available for lists.
+See the chapter <a href="#implicit_rest_slice">Implicit rest and slice</a>.
+</p>
+
+<p>Note that <a href="#rest">rest</a> works on character boundaries rather 
+than byte boundaries when the UTF-8&ndash;enabled version of newLISP is used.</p>
+
+<br/><br/>
+
+<a name="reverse"></a>
+<h2><span class="function">reverse</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (reverse <em>list</em>)<br/>
+syntax: (reverse <em>array</em>)<br/>
+syntax: (reverse <em>string</em>)</h4>
+
+<p>In the first and second form, <tt>reverse</tt> reverses and returns the 
+<em>list</em> or <em>array</em>. Note that <tt>reverse</tt> is destructive 
+and changes the original list or array.</p>
+
+<!-- example -->
+
+<pre>
+; reverse a list
+(set 'l '(a b c d e f))
+
+(reverse l)  <span class='arw'>&rarr;</span> (f e d c b a)
+l            <span class='arw'>&rarr;</span> (f e d c b a)
+i
+; reverse an array
+(set 'a (array 3 2 '(1 2 3 4 5 6))) <span class='arw'>&rarr;</span> ((1 2) (3 4) (5 6))
+
+(reverse a)                         <span class='arw'>&rarr;</span> ((5 6) (3 4) (1 2))
+a                                   <span class='arw'>&rarr;</span> ((5 6) (3 4) (1 2))
+</pre>
+
+
+<p>In the third form, <tt>reverse</tt> is used to reverse the order 
+of characters in a string.</p>
+
+<!-- example -->
+
+<pre>
+; reverse byte character string
+
+(set 'str "newLISP")
+
+(reverse str)  <span class='arw'>&rarr;</span> "PSILwen"
+str            <span class='arw'>&rarr;</span> "PSILwen"
+
+; reverse a multibyte character UTF-8 string, explode is UTF-8 sensitive
+
+(join (reverse (explode "ฮ‘ฮ’ฮ“ฮ”ฮ•ฮ–ฮ—ฮ˜")))  <span class='arw'>&rarr;</span> "ฮ˜ฮ—ฮ–ฮ•ฮ”ฮ“ฮ’ฮ‘"
+</pre>
+
+<p>See also the <a href="#sort">sort</a> function.</p>
+
+<br/><br/>
+
+<a name="rotate"></a>
+<h2><span class="function">rotate</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (rotate <em>list</em> [<em>int-count</em>])<br/>
+syntax: (rotate <em>str</em> [<em>int-count</em>])</h4>
+
+<p>Rotates and returns the <em>list</em> or string in <em>str</em>.
+A count can be optionally specified in <em>int-count</em> 
+to rotate more than one position.  If <em>int-count</em> is positive, 
+the rotation is to the right; if <em>int-count</em> is negative, 
+the rotation is to the left.  If no <em>int-count</em> is specified, 
+<tt>rotate</tt> rotates 1 to the right.  <tt>rotate</tt> is a destructive function 
+that changes the contents of the original list or string.</p>
+
+<!-- example -->
+
+<pre>
+(set 'l '(1 2 3 4 5 6 7 8 9))
+
+(rotate l)    <span class='arw'>&rarr;</span> (9 1 2 3 4 5 6 7 8)
+(rotate l 2)  <span class='arw'>&rarr;</span> (7 8 9 1 2 3 4 5 6)
+
+l  <span class='arw'>&rarr;</span> (7 8 9 1 2 3 4 5 6)
+
+(rotate l -3)  <span class='arw'>&rarr;</span> (1 2 3 4 5 6 7 8 9)
+
+; rotate a byte character string
+
+(set 'str "newLISP")
+
+(rotate str)     <span class='arw'>&rarr;</span> "PnewLIS"
+(rotate str 3)   <span class='arw'>&rarr;</span> "LISPnew"
+(rotate str -4)  <span class='arw'>&rarr;</span> "newLISP"
+
+; rotate a multibyte character UTF-8 string on character boundaries
+
+(join (rotate (explode "ฮ‘ฮ’ฮ“ฮ”ฮ•ฮ–ฮ—ฮ˜")))  <span class='arw'>&rarr;</span> "ฮ˜ฮ‘ฮ’ฮ“ฮ”ฮ•ฮ–ฮ—"
+</pre>
+
+
+<p>When working on a string, <tt>rotate</tt> works on byte boundaries 
+rather than character boundaries.</p>
+
+<br/><br/>
+
+<a name="round"></a>
+<h2><span class="function">round</span></h2>
+<h4>syntax: (round <em>number</em> [<em>int-digits</em>])</h4>
+
+<p>Rounds the number in <em>number</em> 
+to the number of digits given in <em>int-digits</em>. 
+When decimals are being rounded, <em>int-digits</em> is negative. 
+It is positive when the integer part of a number is being rounded.</p>
+
+<p>If <em>int-digits</em> is omitted, the function rounds to <tt>0</tt> decimal
+digits.</p>
+
+<!-- example -->
+
+<pre>
+(round 123.49 2)    <span class='arw'>&rarr;</span> 100
+(round 123.49 1)    <span class='arw'>&rarr;</span> 120
+(round 123.49 0)    <span class='arw'>&rarr;</span> 123
+(round 123.49)      <span class='arw'>&rarr;</span> 123
+(round 123.49 -1)   <span class='arw'>&rarr;</span> 123.5
+(round 123.49 -2)   <span class='arw'>&rarr;</span> 123.49
+</pre>
+
+
+<p>Note that rounding for display purposes is better accomplished using 
+<a href="#format">format</a>.</p>
+
+<br/><br/>
+
+<a name="save"></a>
+<h2><span class="function">save</span></h2>
+<h4>syntax: (save <em>str-file</em>)<br/>
+syntax: (save <em>str-file</em> <em>sym-1</em> [<em>sym-2</em> ... ])</h4>
+
+<p>
+	In the first syntax, 
+	the <tt>save</tt> function writes 
+	the contents of the newLISP workspace 
+	(in textual form) to the file <em>str-file</em>.
+	<tt>save</tt> is the inverse function of <tt>load</tt>. 
+	Using <tt>load</tt> on files 
+	created with <tt>save</tt> causes 
+	newLISP to return to the same state 
+	as when <tt>save</tt> was originally invoked.
+	System symbols starting with the <tt>$</tt> character 
+	(e.g., <tt>$0</tt> from regular expressions 
+	or <tt>$main-args</tt> from the command-line), symbols of built-in
+	functions and symbols containing <tt>nil</tt> are not saved.
+</p>
+
+<p>
+	In the second syntax, 
+	symbols can be supplied as arguments.
+	If <em>sym-n</em> is supplied, 
+	only the definition of that symbol is saved.
+	If <em>sym-n</em> evaluates to a context,
+	all symbols in that context are saved.
+	More than one symbol can be specified,
+	and symbols and context symbols can be mixed.
+	When contexts are saved,
+	system variables and symbols starting with the <tt>$</tt> character 
+	are not saved.
+	Specifying system symbols explicitly 
+	causes them to be saved.
+</p>
+
+<p>
+	Each symbol is saved 
+	by means of a <a href="#set">set</a> statement or&mdash;if 
+	the symbol contains a lambda or lambda-macro function&mdash;by 
+	means of <a href="#define">define</a> 
+	or <a href="#define-macro">define-macro</a> statements.
+</p>
+
+<p>
+	<tt>save</tt> returns <tt>true</tt> on completion.
+</p>
+
+<!-- example -->
+
+<pre>
+(save "save.lsp")
+
+(save "/home/myself/myfunc.LSP" 'my-func) 
+(save "file:///home/myself/myfunc.LSP" 'my-func) 
+
+(save "http://asite.com:8080//home/myself/myfunc.LSP" 'my-func)
+
+(save "mycontext.lsp" 'mycontext) 
+
+;; multiple args
+(save "stuff.lsp" 'aContext 'myFunc '$main-args 'Acontext)
+</pre>
+
+
+<p>
+	Because all context symbols are part of the context <tt>MAIN</tt>,
+	saving <tt>MAIN</tt> saves all contexts.
+</p>
+
+<p>
+	Saving to a URL 
+	will cause an HTTP PUT request to be sent to the URL.
+	In this mode, 
+	<tt>save</tt> can also be used 
+	to push program source 
+	to remote newLISP server nodes.
+	Note that a double backslash is required 
+	when path names are specified 
+	relative to the root directory.
+	<tt>save</tt> in <tt>HTTP</tt>  mode will 
+	observe a 60-second timeout.</p>
+
+<p>
+	Symbols made using <a href="#sym">sym</a>
+	that are incompatible with the normal syntax rules for symbols
+	are serialized using a <a href="#sym">sym</a> statement 
+	instead of a <a href="#set">set</a> statement.
+</p>
+
+<p>
+	<tt>save</tt> serializes contexts and symbols 
+	as if the current context is <tt>MAIN</tt>.
+	Regardless of the current context,
+	<tt>save</tt> will always generate the same output.
+</p>
+
+<p>
+	See also the functions <a href="#load">load</a> 
+	(the inverse operation of <tt>save</tt>) 
+	and <a href="#source">source</a>,
+	which saves symbols and contexts to a string 
+	instead of a file.
+</p>
+
+<br/><br/>
+
+<a name="search"></a>
+<h2><span class="function">search</span></h2>
+<h4>syntax: (search <em>int-file</em> <em>str-search</em> [<em>bool-flag</em> [<em>regex-option</em>]])</h4>
+
+<p>
+Searches a file specified by its handle in <em>int-file</em> for a string in <em>str-search</em>.
+<em>int-file</em> can be obtained from a previous <a href="#open">open</a> file.  After the search, 
+the file pointer is positioned at the beginning  or the end of the searched string or at the end 
+of the file if nothing is found.</p>
+
+<p> By default, the file pointer is positioned at the beginning
+of the searched string. If <em>bool-flag</em> evaluates to <tt>true</tt>,
+then the file pointer is positioned at the end of the searched string.</p>
+
+<p> In <em>regex-option</em>,  the options flags can be specified to perform 
+a PCRE regular expression search.  See the function <a href="#regex">regex</a> for details.
+If <em>regex-option</em> is not specified a faster, plain string search is performed.
+<tt>search</tt> returns the new file position or <tt>nil</tt> if nothing is found.
+</p>
+
+<p> When using the regular expression options flag, patterns found are stored in the system variables 
+<tt>$0</tt> to <tt>$15</tt>.  </p>
+
+<!-- example -->
+
+<pre>
+(set 'file (open "init.lsp" "read"))
+(search file "define")
+(print (read-line file) "\n")
+(close file)
+
+(set 'file (open "program.c" "r"))
+(while (search file "#define (.*)" true 0) (println $1))
+(close file)
+</pre>
+
+
+<p> The file <tt>init.lsp</tt> is opened and searched for the string <tt>define</tt> and the
+line in which the string occurs is printed. </p>
+
+<p>The second example looks for all lines in the file <tt>program.c</tt> which start with
+the string <tt>#define</tt> and prints the rest of the line after the string "#define ".</p>
+
+<p>
+	For other functions using regular expressions, 
+	see <a href="#directory">directory</a>,
+	<a href="#find">find</a>,
+	<a href="#find-all">find-all</a>, 
+	<a href="#parse">parse</a>,
+	<a href="#regex">regex</a>, 
+	and <a href="#replace">replace</a>.
+</p>
+
+<br/><br/>
+
+<a name="seed"></a>
+<h2><span class="function">seed</span></h2>
+<h4>syntax: (seed <em>int-seed</em>)<br/>
+syntax: (seed <em>int-seed</em> <tt>true</tt> [<em>int-pre-N</em>])<br/>
+syntax: (seed)</h4>
+
+<p>Seeds the internal random generator that generates numbers for <a href="#amb">amb</a>,
+<a href="#normal">normal</a>, <a href="#rand">rand</a>, and <a href="#random">random</a> 
+with the number specified in <em>int-seed</em>.  Note that the first syntax uses a 
+random generator based on the C-library function <em>rand()</em>.  All randomizing functions 
+in newLISP are based on this function.</p>
+
+<p>When using the second syntax, all randomizing functions are based on a random generator
+independent of platforms and compilers used to built newLISP. When seeding with the second
+syntax all random functions called subsequenly like 
+<a href="#amb">amb</a>, <a href="#normal">normal</a>, <a href="#rand">rand</a>,
+<a href="#random">random</a> and <a href="#randomize">randomize</a> are based on this
+platform independent random generator.</p>
+
+<p>The optional <em>int-pre-N</em> specifies the number of random numbers to be pre-
+fetched as part of the seeding and initialization procedure. When this parameter is
+ommitted <tt>seed</tt> assumes <tt>50</tt>.</p>
+
+<p>Note that the maximum value for <em>int-seed</em> is limited to 16 or 32 bits, 
+depending on the operating system used.  Internally, only the 32 least significant 
+bits are passed to the random seed function of the OS.</p>
+
+<!-- example -->
+
+<pre>
+(seed 12345)
+
+(seed (time-of-day))
+</pre>
+
+
+<p>After using <tt>seed</tt> with the same number, the random generator starts 
+the same sequence of numbers.  This facilitates debugging 
+when randomized data are involved.  Using <tt>seed</tt>, 
+the same random sequences can be generated over and over again.</p>
+
+<p>The second example is useful for guaranteeing 
+a different seed any time the program starts.</p>
+
+<p>The following example shows usage of the internal seed state in the built-in
+random generator:</p>
+
+<pre>
+&gt; (seed 123 true) ; use the true parameter
+123
+&gt; (random)
+0.2788576787704871
+&gt; (random)
+0.7610070955758016
+&gt; (random)
+0.2462553424976092
+&gt; (random)
+0.8135413573186572
+&gt; (set 'state (seed)) ; save current state
+1747066761
+&gt; (random)
+0.1895924546707387
+&gt; (random)
+0.4803856511043318
+&gt; (seed state true 0) ; seed with saved state
+1747066761
+&gt; (random)            ; produces old sequence
+0.1895924546707387       
+&gt; (random)
+0.4803856511043318      
+&gt; 
+</pre>
+
+<p>In the last syntax <tt>seed</tt> returns the current seed state.</p>
+
+<br/><br/>
+
+<a name="self"></a>
+<h2><span class="function">self</span></h2>
+<h4>syntax: (self [<em>int-index</em> ... ])</h4>
+
+<p>The function <tt>self</tt> accesses the target object of a FOOP method.
+One or more <em>int-index</em> are used to access the object members.
+<tt>self</tt> is set by the <a href="#colon">:&nbsp;colon</a> operator.</p>
+
+<p>Objects referenced with <tt>self</tt> are mutable:</p>
+
+<!-- example -->
+
+<pre>
+(new Class 'Circle)
+
+(define (Circle:move dx dy)
+	(inc (self 1) dx) 
+	(inc (self 2) dy))
+
+(set 'aCircle (Circle 1 2 3))
+(:move aCircle 10 20)
+
+aCircle <span class='arw'>&rarr;</span> (Circle 11 22 3)
+
+; objects can be anonymous
+(set 'circles '((Circle 1 2 3) (Circle 4 5 6)))
+
+(:move (circles 0) 10 20)
+(:move (circles 1) 10 20)
+
+circles <span class='arw'>&rarr;</span> ((Circle 11 22 3) (Circle 14 25 6))
+</pre>
+
+<p>See also the chapter about programming with FOOP: 
+<a href="#foop">Functional object-oriented programming</a></p>
+
+<br/><br/>
+
+<a name="seek"></a>
+<h2><span class="function">seek</span></h2>
+<h4>syntax: (seek <em>int-file</em> [<em>int-position</em>])</h4>
+
+<p>
+Sets the file pointer to the new position <em>int-position</em> in the file 
+specified by <em>int-file</em>.The new position is expressed as an offset from 
+the beginning of the file, <tt>0</tt> (zero) meaning the beginning of the file.
+If no <em>int-position</em> is specified, <tt>seek</tt> returns the current 
+position in the file. If <em>int-file</em> is <tt>0</tt> (zero), 
+on BSD, <tt>seek</tt> will return the number of characters printed to STDOUT, 
+and on Linux and MS Windows, it will return <tt>-1</tt>. On failure, <tt>seek</tt> 
+returns <tt>nil</tt>. When <em>int-position</em> is set to <tt>-1</tt>, 
+<tt>seek</tt> sets the file pointer to the end of the file.</p>
+
+<p><tt>seek</tt> can set the file position past the current end of the file. Subsequent
+writing to this position will extend the file and fill unused positions with zero's.
+The blocks of zeros are not actually allocated on disk, so the file takes up less
+space and is called a <em>sparse file</em>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'file (open "myfile" "read"))  <span class='arw'>&rarr;</span> 5 
+(seek file 100)                     <span class='arw'>&rarr;</span> 100
+(seek file)                         <span class='arw'>&rarr;</span> 100
+
+(open "newlisp_manual.html" "read")
+(seek file -1)  ; seek to EOF
+<span class='arw'>&rarr;</span> 593816     
+
+(set 'fle (open "large-file" "read") 
+(seek file 30000000000)  <span class='arw'>&rarr;</span> 30000000000
+</pre>
+
+
+<p>
+	newLISP supports file position numbers up to 
+	9,223,372,036,854,775,807.
+</p>
+
+<br/><br/>
+
+<a name="select"></a>
+<h2><span class="function">select</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+
+<h4>syntax: (select <em>list</em> <em>list-selection</em>)<br/>
+syntax: (select <em>list</em> [<em>int-index_i</em> ... ])<br/><br/>
+
+syntax: (select <em>string</em> <em>list-selection</em>)<br/>
+
+syntax: (select <em>string</em> [<em>int-index_i</em> ... ])</h4>
+
+<p>
+	In the first two forms,
+	<tt>select</tt> picks one or more elements 
+	from <em>list</em> using one or more indices 
+	specified in <em>list-selection</em> or the <em>int-index_i</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'lst '(a b c d e f g))
+
+(select lst '(0 3 2 5 3))  <span class='arw'>&rarr;</span> (a d c f d)
+
+(select lst '(-2 -1 0))  <span class='arw'>&rarr;</span> (f g a)
+
+(select lst -2 -1 0)  <span class='arw'>&rarr;</span> (f g a)
+</pre>
+
+
+<p>
+	In the second two forms,
+	<tt>select</tt> picks one or more characters 
+	from <em>string</em> 
+	using one or more indices specified in <em>list-selection</em> 
+	or the <em>int-index_i</em>.
+</p> 
+
+<!-- example -->
+
+<pre>
+(set 'str "abcdefg") 
+
+(select str '(0 3 2 5 3))  <span class='arw'>&rarr;</span> "adcfd"
+
+(select str '(-2 -1 0))  <span class='arw'>&rarr;</span> "fga"
+
+(select str -2 -1 0)  <span class='arw'>&rarr;</span> "fga"
+</pre>
+
+
+<p>
+	Selected elements can be repeated and do not have to appear in order,
+	although this speeds up processing.
+	The order in <em>list-selection</em> or <em>int-index_i</em> 
+	can be changed to rearrange elements.
+</p>
+
+<br/><br/>
+
+
+
+<br/><br/>
+
+<a name="semaphore"></a>
+<h2><span class="function">semaphore</span></h2>
+
+<h4>syntax: (semaphore)<br/>
+syntax: (semaphore <em>int-id</em>)<br/>
+syntax: (semaphore <em>int-id</em> <em>int-wait</em>)<br/>
+syntax: (semaphore <em>int-id</em> <em>int-signal</em>)<br/>
+
+syntax: (semaphore <em>int-id</em> <em>0</em>)</h4>
+
+<p>A semaphore is an interprocess synchronization object 
+that maintains a count between <tt>0</tt> (zero) and some maximum value.
+Useful in controlling access to a shared resource, 
+a semaphore is set to signaled when its count is greater than zero 
+and to non-signaled when its count is zero.</p>
+
+<p>A semaphore is created using the first syntax.  This returns 
+the semaphore ID, an integer used subsequently as <em>int-id</em> 
+when the <em>semaphore</em> function is called.  Initially, the 
+semaphore has a value of zero, which represents the non-signaled state.
+</p>
+
+<p>
+If calling <tt>semaphore</tt> with a negative value in <em>int-wait</em> 
+causes it to be decremented below zero,
+the function call will block until another process
+signals the semaphore with a positive value in <em>int-signal</em>.
+Calls to the semaphore with <em>int-wait</em> or <em>int-signal</em>
+effectively try to increment or decrement the semaphore value 
+by a positive or negative value specified in <em>int-signal</em> 
+or <em>int-wait</em>.
+Because the value of a semaphore must never fall below zero,
+the function call will block when this is attempted
+(i.e., a semaphore with a value of zero 
+will block until another process
+increases the value with a positive <em>int-signal</em>).
+</p>
+
+<p>The second syntax is used to inquire about the value of a semaphore
+ by calling <tt>semaphore</tt> with the <em>int-id</em> only.
+This form is not available on MS Windows.</p>
+
+<p>Supplying <tt>0</tt> (zero) as the last argument will release system 
+resources for the semaphore, which then becomes unavailable.
+Any pending waits on this semaphore in other child processes 
+will be released.</p>
+
+<p>On MS Windows, only parent and child processes can share a semaphore.
+On Linux/Unix, independent processes can share a semaphore.</p>
+
+<p>On failure the <tt>semaphore</tt> function returns <tt>nil</tt>.
+<a href="#sys-error">sys-error</a> can be used to retrieve the error
+number and text from the underlying operating system.</p>
+
+<p>The following code examples summarize the different syntax forms:</p>
+
+<!-- example -->
+
+<pre>
+;; init semaphores 
+(semaphore) 
+
+;; assign a semaphore to sid 
+(set 'sid (semaphore))
+
+;; inquire the state of a semaphore (not on Windows OS)
+(semaphore sid)
+
+;; put sid semaphore in wait state (-1) 
+(semaphore sid -1) 
+
+;; run sid semaphore previously put in wait (always 1) 
+(semaphore sid 1) 
+
+;; run sid semaphore with X times a skip (backward or forward) on the function 
+(semaphore sid X) 
+
+;; release sid semaphore system-wide (always 0) 
+(semaphore sid 0) 
+</pre>
+
+
+<p>The following example shows semaphores controlling a child process:</p> 
+
+<!-- example -->
+
+<pre>
+;; counter process output in bold
+
+(define (counter n)
+	(println "counter started")
+	(dotimes (x n)
+		(semaphore sid -1)
+		(println x)))
+
+;; hit extra &lt;enter&gt; to make the prompt come back
+;; after output to the console from the counter process
+
+&gt; (set 'sid (semaphore))
+
+&gt; (semaphore sid)
+<b>0</b>
+
+&gt; (fork (counter 100))
+
+<b>counter started</b>
+&gt; (semaphore sid 1)
+<b>0</b>
+&gt; (semaphore sid 3)
+<b>1</b>
+<b>2</b>
+<b>3</b>
+&gt; (semaphore sid 2)
+<b>4</b>
+
+<b>5</b>
+&gt; _
+</pre>
+
+
+<p>
+	After the semaphore is acquired in <tt>sid</tt>, 
+	it has a value of <tt>0</tt>
+	(the non-signaled state).
+	When starting the process <tt>counter</tt>,
+	the semaphore will block after the initial start message 
+	and will wait in the semaphore call.
+	The <tt>-1</tt> is trying to decrement the semaphore,
+	which is not possible because its value is already zero.
+	In the interactive, main parent process,
+	the semaphore is signaled by raising its value by <tt>1</tt>.
+	This unblocks the semaphore call in the <tt>counter</tt> process,
+	which can now decrement the semaphore from <tt>1</tt> to <tt>0</tt> 
+	and execute the <tt>print</tt> statement.
+	When the semaphore call is reached again,
+	it will block because the semaphore is already in the wait 
+	(<tt>0</tt>) state.
+</p>
+
+<p>
+	Subsequent calls to <tt>semaphore</tt> 
+	with numbers greater than <tt>1</tt> 
+	give the <tt>counter</tt> process an opportunity 
+	to decrement the semaphore several times before blocking.
+</p>
+
+<p>
+	More than one process can participate in controlling the semaphore, 
+	just as more than one semaphore can be created.
+	The maximum number of semaphores is controlled 
+	by a system-wide kernel setting on Unix-like operating systems.
+</p>
+
+<p>Use the <a href="#fork">fork</a> function to start a new process 
+and the <a href="#share">share</a> function to share information between 
+processes. For a more comprehensive example of using <tt>semaphore</tt> 
+to synchronize processes, see the file <tt>prodcons.lsp</tt> example 
+in the <tt>examples</tt> directory in the source distribution, 
+as well as the examples and modules distributed with newLISP.</p>
+
+<br/><br/>
+
+<a name="send"></a>
+<h2><span class="function">send</span></h2>
+<h4>syntax: (send <em>int-pid</em> <em>exp</em>)<br/>
+syntax: (send)</h4>
+
+<p>The <tt>send</tt> function enables communication between
+parent and child processes started with <a href="#spawn">spawn</a>.
+Parent processes can send and receive messages to and from
+their child processes and child processes can send and receive
+messages to and from their parent process. A proxy technique &ndash; shown further
+down &ndash; is  employed to communicate between child process
+peers. <tt>send</tt> and <a href="#receive">receive</a> do not require 
+locks or semaphores. They work on dual send and receive message queues.
+</p>
+
+<p>Processes started using <a href="#fork">fork</a> or 
+<a href="#process">process</a> can not use <tt>send</tt> and <tt>receive</tt>
+message functions. Instead they should use either <a href="#share">share</a> 
+with <a href="#semaphore">semaphore</a> or <a href="#pipe">pipe</a> to 
+communicate.</p>
+
+<p>The <tt>send</tt> function is not available on MS Windows.</p>
+
+<p>In the first syntax <tt>send</tt> is used to send a message 
+from a parent to a child process or a child to a parent process.</p>
+
+<p>The second syntax is only used by parent processes to get a list
+of all child processes ready to accept message from the parent in their 
+receive queues. If a child's receive queue is full, it will not be part of
+the list returned by the <tt>(send)</tt> statement.</p>
+
+<p>The content of a message may be any newLISP expression either
+atomic or list expressions: boolean constants <tt>nil</tt> and <tt>true</tt>,
+integers, floating point numbers or strings, or any list expression 
+in valid newLISP syntax. The size of a message is unlimited.</p>
+
+
+<p>The <em>exp</em> parameter specifies the data to be sent
+to the recipient in <em>int-pid</em>. The recipient can be either a
+spawned child process of the current process or the parent
+process. If a message queue is full, it can be read from the receiving
+end, but a <tt>send</tt> issued on the other side of the queue will
+fail and return <tt>nil</tt>.</p>
+
+
+<pre>
+; child process dispatching message to parent
+
+(set 'ppid (sys-info -4)) ; get parent pid
+
+(send ppid "hello") ; send message
+</pre>
+
+<p>The targeted recipient of the message is the parent process:</p>
+
+<pre>
+; parent process receiving message from child
+
+(receive child-pid msg) <span class='arw'>&rarr;</span> true
+msg                     <span class='arw'>&rarr;</span> "hello"
+</pre>
+
+
+<p>When the <tt>send</tt> queue is full, <tt>send</tt> will return
+<tt>nil</tt> until enough message content is read on the receiving side
+of the queue and the queue is ready to accept new messages from 
+<tt>send</tt> statements.</p>
+
+<p>Using the <a href="#until">until</a> looping function, the
+message statements can be repeated until they return a value
+not <tt>nil</tt>. This way, non-blocking <tt>send</tt> and <tt>receive</tt> 
+can be made blocking until they succeed:</p>
+
+<pre>
+; blocking sender
+(until (send pid msg)) ; true after message is queued up
+
+; blocking receiver
+(until (receive pid msg)) ; true after message could be read
+</pre>
+
+<p>The sender statement blocks until the message could be deposited
+in the recipients queue.</p>
+
+<p>The <tt>receive</tt> statement blocks until a new message can
+be fetched from the queue.</p>
+
+<p>As the <tt>until</tt> statements in this example lack body expressions,
+the last value of the evaluated conditional expression is the return
+value of the <tt>until</tt> loop.</p>
+
+<h3>Blocking message exchange</h3>
+
+<p>The following code shows how a recipient can listen for incoming
+messages, and in turn how a sender can retry to deposit a message
+into a queue. The example shows 5 child processes constantly delivering 
+status data to a parent process which will display the data.
+After three data sets have been read, the parent will abort all
+child processes and exit:</p>
+
+<!-- example -->
+
+<pre>
+#!/usr/bin/newlisp
+
+; child process transmits random numbers
+(define (child-process)
+    (set 'ppid (sys-info -4)) ; get parent pid
+    (while true
+        (until (send ppid (rand 100))))
+)
+
+; parent starts 5  child processes, listens and displays
+; the true flag is specified to enable send/receive
+
+(dotimes (i 5) (spawn 'result (child-process) true))
+
+(for (i 1 3)
+    (dolist (cpid (sync)) ; iterate thru pending child PIDs
+        (until (receive cpid msg))
+        (print "pid:" cpid "-&gt;" (format "%-2d  " msg)))
+    (println)
+)
+
+(abort) ; cancel child-processes
+(exit)
+</pre>
+
+
+<p>Running above example produces the following output:</p>
+
+<pre><b>pid:53181->47  pid:53180->61  pid:53179->75  pid:53178->39  pid:53177->3   
+pid:53181->59  pid:53180->12  pid:53179->20  pid:53178->77  pid:53177->47  
+pid:53181->6   pid:53180->56  pid:53179->96  pid:53178->78  pid:53177->18
+</b></pre>
+
+<p>The <tt>(sync)</tt> expression returns a list of all child PIDs,
+and <tt>(until (receive cpid msg))</tt> is used to force a wait
+until status messages are received for each of the child processes.</p>
+
+<p>A timeout mechanism could be part of an <tt>until</tt> or <tt>while</tt>
+loop to stop waiting after certain time has expired.</p>
+
+<p>The examples show messages flowing from a child processes to
+a parent process, in the same fashion messages could flow
+into the other direction from parent to child processes. In that
+case the parent process would use <tt>(send)</tt> to obtain a
+list of child processes with place in their message queues.</p>
+
+<h3>Messages containing code for evaluation</h3>
+
+<p>The most powerful feature of the message functions is the ability
+to send any newLISP expression, which then can be evaluated by the recipient. 
+The recipient uses <a href="#eval">eval</a> to evaluate the received
+expression. Symbols contained in the expression are evaluated in the
+receivers environment.</p>
+
+<p>The following example shows how a parent process acts like a message 
+proxy. The parent receives messages from a child process A and routes them 
+to a second child process with ID B. In effect this implements messages 
+between child process peers. The implementation relies on the fact that 
+the recipient can evaluate expressions contained in messages received.
+These expressions can be any valid newLISP statements:</p>
+
+<!-- example -->
+<pre>
+#!/usr/bin/newlisp
+
+; sender child process of the message
+(set 'A (spawn 'result 
+    (begin
+        (dotimes (i 3)
+            (set 'ppid (sys-info -4))
+            /* the statement in msg will be evaluated in the proxy */
+            (set 'msg '(until (send B (string "greetings from " A))))
+            (until (send ppid msg)))
+        (until (send ppid '(begin 
+            (sleep 100) ; make sure all else is printed
+            (println "parent exiting ...\n")
+            (set 'finished true))))) true)) 
+
+; receiver child process of the message
+(set 'B (spawn 'result 
+    (begin
+        (set 'ppid (sys-info -4))
+        (while true
+            (until (receive ppid msg))
+            (println msg)
+            (unless (= msg (string "greetings from " A))
+                (println "ERROR in proxy message: " msg)))) true))
+
+(until finished (if (receive A msg) (eval msg))) ; proxy loop
+
+(abort)
+(exit)
+</pre>
+
+<p>Child process <tt>A</tt> sends three messages to <tt>B</tt>.
+As this cannot be done directly <tt>A</tt>  sends <tt>send</tt>
+statements to the parent for evaluation. The statement:</p>
+
+<pre>
+(until (send pidB (string "greetings from " A)))
+</pre>
+
+<p>will be evaluated in the environment of the parent process. Even so the 
+variables <tt>A</tt> and <tt>B</tt> are bound to <tt>nil</tt> in 
+the sender process <tt>A</tt>, in the parent process they will be
+bound to the correct process ID numbers.</p>
+
+<p>After sending the three messages, the statement:</p>
+
+<pre>
+(set 'finished true)
+</pre>
+
+<p>is sent to the parent process. Once evaluated, it will cause the <tt>until</tt>
+loop to finish.</p>
+
+<p>For more details on <tt>send</tt> and <tt>receive</tt> and more examples 
+see the <a href="http://www.newlisp.org/CodePatterns.html">Code Patterns</a>
+document.</p>
+
+<br/><br/>
+
+<a name="sequence"></a>
+<h2><span class="function">sequence</span></h2>
+<h4>syntax: (sequence <em>num-start</em> <em>num-end</em> [<em>num-step</em>])</h4>
+
+<p>
+	Generates a sequence of numbers 
+	from <em>num-start</em> to <em>num-end</em> 
+	with an optional step size of <em>num-step</em>.
+	When <em>num-step</em> is omitted,
+	the value <tt>1</tt> (one) is assumed.
+	The generated numbers are of type integer 
+	(when no optional step size is specified) 
+	or floating point 
+	(when the optional step size is present).
+</p>
+
+<!-- example -->
+
+<pre>
+(sequence 10 5)     <span class='arw'>&rarr;</span> (10 9 8 7 6 5)
+(sequence 0 1 0.2)  <span class='arw'>&rarr;</span> (0 0.2 0.4 0.6 0.8 1)
+(sequence 2 0 0.3)  <span class='arw'>&rarr;</span> (2 1.7 1.4 1.1 0.8 0.5 0.2)
+</pre>
+
+
+<p>
+	Note that the step size must be a positive number,
+	even if sequencing from a higher to a lower number.
+</p>
+
+<p>
+	Use the <a href="#series">series</a> function
+	to generate geometric sequences.
+</p>
+
+<br/><br/>
+
+<a name="series"></a>
+<h2><span class="function">series</span></h2>
+
+<h4>syntax: (series <em>num-start</em> <em>num-factor</em> <em>num-count</em>)<br/>
+syntax: (series <em>exp-start</em> <em>func</em> <em>num-count</em>)</h4>
+
+<p>In the first syntax, <tt>series</tt> creates a geometric sequence with <em>num-count</em> 
+elements starting with the element in <em>num-start</em>. Each subsequent element 
+is multiplied by <em>num-factor</em>. The generated numbers are always floating point 
+numbers.</p>
+
+<p>When <em>num-count</em> is less than <tt>1</tt>, then <tt>series</tt>
+returns an empty list.</p>
+
+<!-- example -->
+
+<pre>
+(series 2 2 5)     <span class='arw'>&rarr;</span> (2 4 8 16 32)
+(series 1 1.2 6)   <span class='arw'>&rarr;</span> (1 1.2 1.44 1.728 2.0736 2.48832)
+(series 10 0.9 4)  <span class='arw'>&rarr;</span> (10 9 8.1 7.29)
+(series 0 0 10)    <span class='arw'>&rarr;</span> (0 0 0 0 0 0 0 0 0 0)
+(series 99 1 5)    <span class='arw'>&rarr;</span> (99 99 99 99 99)
+</pre>
+
+
+<p>In the second syntax, <tt>series</tt> uses a function specified in <em>func</em>
+to transform the previous expression in to the next expression:</p>
+
+
+<!-- example -->
+
+<pre>
+; embed the function Phi: f(x) = 1 / (1 + x)
+; see also http://en.wikipedia.org/wiki/Golden_ratio
+
+(series 1 (fn (x) (div (add 1 x))) 20)  <span class='arw'>&rarr;</span>
+
+(1 0.5 0.6666666 0.6 0.625 0.6153846 0.619047 0.6176470 0.6181818 
+ 0.6179775 0.6180555 0.6180257 0.6180371 0.6180327 0.6180344 
+ 0.6180338 0.6180340 0.6180339 0.6180339 0.6180339)
+
+; pre-define the function
+
+(define (oscillate x) 
+  (if (&lt; x) 
+    (+ (- x) 1) 
+    (- (+ x 1)))
+)
+
+(series 1 oscillate 20)  <span class='arw'>&rarr;</span> 
+
+(1 -2 3 -4 5 -6 7 -8 9 -10 11 -12 13 -14 15 -16 17 -18 19 -20)
+
+; any data type is accepted as a start expression
+
+(series "a" (fn (c) (char (inc (char c)))) 5) <span class='arw'>&rarr;</span> ("a" "b" "c" "d" "e")
+
+; dependency of the two previous values in this fibonacci generator
+
+(let (x 1) (series x (fn (y) (+ x (swap y x))) 10))  <span class='arw'>&rarr;</span>
+
+(1 2 3 5 8 13 21 34 55 89)
+ 
+</pre>
+
+
+<p>The first example shows a series converging to the <em>golden ratio, &phi;</em>
+(for any starting value). The second example shows how <em>func</em> can be defined
+previously for better readability of the <tt>series</tt> statement.</p>
+
+<p>The <tt>series</tt> function also updates the internal list <tt>$idx</tt>
+index value, which can be used inside <em>func</em>.</p>
+
+
+<p>Use the <a href="#sequence">sequence</a> function to generate arithmetic sequences.
+</p>
+
+<br/><br/>
+
+<a name="set"></a>
+<h2><span class="function">set</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (set <em>sym-1</em> <em>exp-1</em> [<em>sym-2</em> <em>exp-2</em> ... ])</h4>
+
+<p>Evaluates both arguments and then assigns the result of <em>exp</em> 
+to the symbol found in <em>sym</em>. The <tt>set</tt> expression 
+returns the result of the assignment. The assignment is performed by copying 
+the contents of the right side into the symbol. The old contents of the symbol 
+are deleted. An error message results when trying to change the contents 
+of the symbols <tt>nil</tt>, <tt>true</tt>, or a context symbol.
+<tt>set</tt> can take multiple argument pairs.</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 123)     <span class='arw'>&rarr;</span> 123
+(set 'x 'y)      <span class='arw'>&rarr;</span> y
+(set x "hello")  <span class='arw'>&rarr;</span> "hello"
+
+y  <span class='arw'>&rarr;</span> "hello"
+
+(set 'alist '(1 2 3))  <span class='arw'>&rarr;</span> (1 2 3)
+
+
+(set 'x 1 'y "hello")  <span class='arw'>&rarr;</span> "hello"  ; multiple arguments
+
+x  <span class='arw'>&rarr;</span> 1
+y  <span class='arw'>&rarr;</span> "hello"
+</pre>
+
+
+<p>The symbol for assignment could be the result from another newLISP expression.
+Expressions can refer to variables in the <tt>set</tt> expression.</p>
+
+<pre>
+(set 'lst '(x y z))  <span class='arw'>&rarr;</span> (x y z)
+
+(set (first lst) 123)  <span class='arw'>&rarr;</span> 123
+
+x  <span class='arw'>&rarr;</span> 123
+
+(set 'a 10 'b (+ a a))
+
+a   <span class='arw'>&rarr;</span> 10,  b   <span class='arw'>&rarr;</span> 20
+</pre>
+
+
+<p>
+Symbols can be set to lambda or lambda-macro expressions.
+This operation is equivalent to using <a href="#define">define</a> 
+or <a href="#define-macro">define-macro</a>.</p>
+
+
+<pre>
+(set 'double (lambda (x) (+ x x)))
+<span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+</pre>
+
+
+<p>is equivalent to:</p>
+
+
+<pre>
+(define (double x) (+ x x))
+<span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+</pre>
+
+
+<p>is equivalent to:</p>
+
+
+<pre>
+(define double (lambda (x) (+ x x)))
+<span class='arw'>&rarr;</span> (lambda (x) (+ x x))
+</pre>
+
+
+<p>
+Use the <a href="#constant">constant</a> function (which works like <tt>set</tt>)
+to protect the symbol from subsequent alteration. Using the <a href="#setq">setq</a> 
+or <a href="#setf">setf</a> function eliminates the need to quote the variable symbol.
+</p>
+
+<br/><br/>
+
+<a name="set-locale"></a>
+<h2><span class="function">set-locale</span></h2>
+<h4>syntax: (set-locale [<em>str-locale</em> [<em>int-category</em>]])</h4>
+
+<p>Reports or switches to a different locale on your operating system or platform.
+When used without arguments, <em>set-locale</em> reports 
+the current locale being used. When <em>str-locale</em> is specified, 
+<em>set-locale</em> switches to the locale with all category options turned on 
+(<tt>LC_ALL</tt>). Placing an empty string in <em>str-locale</em> 
+switches to the default locale used on the current platform.</p>
+
+<p><tt>set-locale</tt> returns either the current locale string and decimal 
+point string in a list  or <tt>nil</tt> if the requested change could not 
+be performed.</p>
+
+<!-- example -->
+
+<pre>
+; report current locale
+
+(set-locale)     
+
+; set default locale of your platform and country
+; return value shown when executing on German MS-Windows
+
+(set-locale "")    <span class='arw'>&rarr;</span> ("German_Germany.1252" ",")
+(add 1,234 1,234)  <span class='arw'>&rarr;</span> 2,468
+</pre>
+
+<p>By default, newLISP &ndash; if not enabled for UTF-8 &ndash; starts up with the POSIX C 
+default locale. This guarantees that newLISP's behavior will be identical on any 
+platform locale. On UTF-8 enabled versions of newLISP the locale of
+the current platform is chosen.</p>
+
+<pre>
+; after non-UTF-8 newLISP start up
+
+(set-locale)  <span class='arw'>&rarr;</span> ("C" ".")
+</pre>
+
+<p>In <em>int-category</em> integer numbers may be specified as <em>category options</em> 
+for fine-tuning certain aspects of the locale, such as number display, date display, 
+and so forth. The options valid on your platform can be found in the C include file 
+<tt>locale.h</tt> and may be different on each platform. When no <em>int-category</em>
+is specified, <tt>LC_ALL</tt> is used to turn on all options for that locale.</p>
+
+<table>
+<tr align="left"><th>Category</th><th>Mac OS X, BSDs<br/>&amp; MS Windows</th></tr>
+<tr><td>LC_ALL</td><td>0</td></tr>
+<tr><td>LC_COLLATE</td><td>1</td></tr>
+<tr><td>LC_CTYPE</td><td>2</td></tr>
+<tr><td>LC_MONETARY</td><td>3</td></tr>
+<tr><td>LC_NUMERIC</td><td>4</td></tr>
+<tr><td>LC_TIME</td><td>5</td></tr>
+</table>
+<br/>
+
+<p>The default C locale uses the decimal dot, but most others use a decimal comma.</p>
+
+<pre>
+; with the current locale "en_US.UTF-8", only change the decimal separator 
+; to German locale comma on  Mac OS X. LC_NUMERIC is 4 on most platforms 
+
+(set-locale) <span class='arw'>&rarr;</span> ("en_US.UTF-8" ".") 
+(set-locale "de_DE.UTF-8" 4) <span class='arw'>&rarr;</span> ("de_DE.UTF-8" ",") 
+
+; mixed locale shows country setting for each category, 4 has changed
+(set-locale) <span class='arw'>&rarr;</span> ("en_US.UTF-8/en_US.UTF-8/en_US.UTF-8/de_DE.UTF-8/en_US.UTF-8/en_US.UTF-8" ",")
+</pre>
+
+<p>Note that using <tt>set-locale</tt> does not change the behavior 
+of regular expressions in newLISP. To localize the behavior of PCRE 
+(Perl Compatible Regular Expressions), newLISP must be compiled 
+with different character tables. See the file, LOCALIZATION, 
+in the newLISP source distribution for details.</p>
+
+<p>
+	See also the chapter <a href="#switching">Switching the locale</a>.
+</p>
+
+<br/><br/>
+
+<a name="set-ref"></a>
+<h2><span class="function">set-ref</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (set-ref <em>exp-key</em> <em>list</em> <em>exp-replacement</em> [<em>func-compare</em>])</h4>
+
+
+<p>Searches for <em>exp-key</em> in <em>list</em> and replaces the found element with 
+<em>exp-replacement</em>. The <em>list</em> can be nested. The system variables 
+<tt>$it</tt> contains the expression found and can be used in 
+<em>exp-replacement</em>. The function returns the new modified <em>list</em>.</p>
+
+
+<!-- example -->
+
+<pre>
+(set 'data '(fruits (apples 123 44) (oranges 1 5 3)))
+
+(set-ref 'apples data 'Apples)  <span class='arw'>&rarr;</span> (fruits (Apples 123 44) (oranges 1 5 3))
+
+data <span class='arw'>&rarr;</span> (fruits (Apples 123 44) (oranges 1 5 3)))
+</pre>
+
+
+<p><tt>data</tt> could be the context identifier of a default function for passing lists by reference:</p>
+
+
+<pre>
+(set 'db:db '(fruits (apples 123 44) (oranges 1 5 3)))
+
+(define (update ct key value)
+	(set-ref key ct value))
+
+(update db 'apples 'Apples)    <span class='arw'>&rarr;</span> (fruits (Apples 123 44) (oranges 1 5 3))
+(update db 'oranges 'Oranges)  <span class='arw'>&rarr;</span> (fruits (Apples 123 44) (Oranges 1 5 3))
+
+db:db <span class='arw'>&rarr;</span> (fruits (Apples 123 44) (Oranges 1 5 3))
+</pre>
+
+
+<p>For examples on how to use <em>func-compare</em> see 
+<a href="#set-ref-all">set-ref-all</a></p>
+
+<p>For changing all occurrences of an element in a list use 
+<a href="#set-ref-all">set-ref-all</a>.</p>
+
+<br/><br/>
+
+<a name="set-ref-all"></a>
+<h2><span class="function">set-ref-all</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (set-ref-all <em>exp-key</em> <em>list</em>  <em>exp-replacement</em> [<em>func-compare</em>])</h4>
+
+<p>Searches for <em>exp-key</em> in <em>list</em> and replaces each instance of the found element 
+with <em>exp-replacement</em>. The <em>list</em> can be nested. The system variable <tt>$it</tt> 
+contains the expression found and can be used in <em>exp-replacement</em>.
+The system variable <tt>$count</tt> contains the number of replacements made.
+The function returns the new modified <em>list</em>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'data '((monday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))))
+
+(set-ref-all 'apples data "Apples")
+ <span class='arw'>&rarr;</span> ((monday ("Apples" 20 30) (oranges 2 4 9)) (tuesday ("Apples" 5) (oranges 32 1)))
+
+$count <span class='arw'>&rarr;</span> 2
+</pre>
+
+
+<p>Using the default functor in the <tt>(<em>list</em> <em>key</em>)</tt> pattern allows the
+list to be passed by reference to a user-defined function containing a <tt>set-ref-all</tt>
+statement. This would result in less memory usage and higher speeds in when doing replacements
+in large lists:</p>
+
+
+<pre>
+(set 'db:db '((monday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))))
+
+(define (foo ctx)
+	(set-ref-all 'apples ctx "Apples")
+)
+
+(foo db) 
+ <span class='arw'>&rarr;</span> ((monday ("Apples" 20 30) (oranges 2 4 9)) (tuesday ("Apples" 5) (oranges 32 1)))
+</pre>
+
+
+<p>When evaluating <tt>(foo db)</tt>, the list in <tt>db:db</tt> will be passed
+by reference and <tt>set-ref-all</tt> will make the changes on the original, not on
+a copy of <tt>db:db</tt>.</p>
+
+<p>Like with <a href="#find">find</a>, <a href="#replace">replace</a>, 
+<a href="#ref">ref</a> and <a href="#ref-all">ref-all</a>, 
+complex searches can be expressed using 
+<a href="#match">match</a> or <a href="#unify">unify</a> in <em>func-compare</em>:</p>
+
+
+<pre>
+(set 'data '((monday (apples 20 30) (oranges 2 4 9)) (tuesday (apples 5) (oranges 32 1))))
+
+(set-ref-all '(oranges *) data (list (first $it) (apply + (rest $it))) match)
+    <span class='arw'>&rarr;</span> ( ... (oranges 15) ... (oranges 33) ... ) 
+</pre>
+
+
+<p>The example sums all numbers found in records starting with 
+the symbol <tt>oranges</tt>. The found items appear in <tt>$it</tt></p>
+
+<p>See also <a href="#set-ref">set-ref</a> which replaces only the first element found.</p>
+
+<br/><br/>
+
+<a name="setq"></a> <a name="setf"></a>
+<h2><span class="function">setq setf</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (setq <em>place-1</em> <em>exp-1</em> [<em>place-2</em> <em>exp-2</em> ... ])</h4>
+
+<p>
+<tt>setq</tt> and <tt>setf</tt> work alike in newLISP and set the contents
+of a symbol, list, array or string or of a list, array or string place reference. Like 
+<a href="#set">set</a>, <tt>setq</tt> and <tt>setf</tt> can take multiple argument pairs. 
+Although both <tt>setq</tt> and <tt>setf</tt> point to the same built-in function internally, 
+throughout this manual <tt>setq</tt> is used when setting a symbol reference and <tt>setf</tt> 
+is used when setting list or array references.</p>
+
+<!-- example -->
+
+<pre>
+(setq x 123)  <span class='arw'>&rarr;</span> 123
+
+; multiple arguments
+
+(setq x 1 y 2 z 3)  <span class='arw'>&rarr;</span> 3 
+
+x  <span class='arw'>&rarr;</span> 1
+y  <span class='arw'>&rarr;</span> 2
+z  <span class='arw'>&rarr;</span> 3
+
+; with nth or implicit indices
+(setq L '(a b (c d) e f g))
+
+(setf (L 1) 'B)      <span class='arw'>&rarr;</span> B
+; or the same
+(setf (nth 1 L) 'B)
+L                    <span class='arw'>&rarr;</span> (a B (c d) e f g)
+
+(setf (L 2 0) 'C)    <span class='arw'>&rarr;</span> C
+L                    <span class='arw'>&rarr;</span> (a B (C d) e f g)
+
+(setf (L 2) 'X)   
+L                    <span class='arw'>&rarr;</span> (A B X e f g)
+
+; with assoc
+(setq L '((a 1) (b 2)))
+(setf (assoc 'b L) '(b 3)) <span class='arw'>&rarr;</span> (b 3)
+L                          <span class='arw'>&rarr;</span> ((a 1) (b 3))
+
+; with lookup
+(setf (lookup 'b L) 30) <span class='arw'>&rarr;</span> 30
+L                       <span class='arw'>&rarr;</span> ((a 1) (b 30))
+
+; several list accessors can be nested
+(setq L '((a 1) (b 2)))
+
+(push 'b (setf (assoc 'b l) '(b 4))) 'b) <span class='arw'>&rarr;</span> b
+L                                        <span class='arw'>&rarr;</span>((a 1) (b b 4)))
+
+; on strings
+(set 's "NewISP")
+
+(setf (s 0) "n") <span class='arw'>&rarr;</span> "n"
+s <span class='arw'>&rarr;</span> "newISP"
+
+(setf (s 3) "LI") <span class='arw'>&rarr;</span> "LI"
+s <span class='arw'>&rarr;</span> "newLISP"
+</pre>
+
+
+<p>Often the new value set is dependent on the old value. <tt>setf</tt> can
+use the anaphoric system variable <tt>$it</tt> to refer to the old
+value inside the <tt>setf</tt> expression:</p>
+
+
+<pre>
+(setq L '((apples 4) (oranges 1))) 
+
+(setf (L 1 1) (+ $it 1)) <span class='arw'>&rarr;</span> 2
+
+L                        <span class='arw'>&rarr;</span> ((apples 4) (oranges 2))
+
+(set 's "NewLISP")
+
+(setf (s 0) (lower-case $it)) <span class='arw'>&rarr;</span> "n")
+
+s <span class='arw'>&rarr;</span> "newLISP"
+</pre>
+
+<br/><br/>
+
+<a name="sgn"></a>
+
+<h2><span class="function">sgn</span></h2>
+<h4>syntax: (sgn <em>num</em>)<br/>
+syntax: (sgn <em>num</em> <em>exp-1</em> [<em>exp-2</em> [<em>exp-3</em>]])</h4>
+
+<p>
+In the first syntax,
+the <tt>sgn</tt> function is a logical function 
+that extracts the sign of a real number 
+according to the following rules:
+</p>
+<p>
+<b><em>
+x &gt; <tt>0</tt> : sgn(x) = 1<br/>
+x &lt; <tt>0</tt> : sgn(x) = -1<br/>
+x = <tt>0</tt> : sgn(x) = <tt>0</tt>
+</em></b>
+</p>
+
+<!-- example -->
+
+<pre>
+(sgn -3.5)  <span class='arw'>&rarr;</span> -1
+(sgn 0)     <span class='arw'>&rarr;</span> 0
+(sgn 123)   <span class='arw'>&rarr;</span> 1
+</pre>
+
+<p>In the second syntax, the result of evaluating 
+one of the optional expressions 
+<em>exp-1</em>, <em>exp-2</em>, or <em>exp-3</em> is returned, 
+instead of <tt>-1</tt>, <tt>0</tt>, or <tt>1</tt>. 
+If <em>exp-n</em> is missing for the case triggered,
+then <tt>nil</tt> is returned.</p>
+
+<!-- example -->
+
+<pre>
+(sgn x -1 0 1)         ; works like (sgn x)
+(sgn x -1 1 1)         ; -1 for negative x all others 1
+(sgn x nil true true)  ; nil for negative else true
+(sgn x (abs x) 0)      ; (abs x) for x &lt; 0, 0 for x = 0, else nil
+</pre>
+
+
+<p>
+Any expression or constant can be used for 
+<em>exp-1</em>, <em>exp-2</em>, or <em>exp-3</em>.
+</p>
+
+<br/><br/>
+
+<a name="share"></a>
+<h2><span class="function">share</span></h2>
+<h4>syntax: (share)<br/>
+syntax: (share <em>int-address-or-handle</em>)<br/>
+syntax: (share <em>int-address-or-handle</em> <em>exp-value</em>)<br/><br/>
+syntax: (share <em>nil</em> <em>int-address</em>)</h4>
+
+<p>
+Accesses shared memory 
+for communicating between 
+several newLISP processes.
+When called without arguments, 
+ <tt>share</tt> requests a page of shared memory 
+from the operating system. 
+This returns a memory address on Linux/Unix 
+and a handle on MS Windows, 
+which can then be 
+assigned to a variable 
+for later reference.
+This function is not available on OS/2.
+</p>
+
+<p>To set the contents of shared memory, use the third syntax of <tt>share</tt>. 
+Supply a shared memory address on Linux/Unix or a handle on MS Windows in 
+<em>int-address-or-handle</em>, along with an integer, float, string 
+expression or any other expression (since v.10.1.0) supplied
+in <em>exp-value</em>.  Using this syntax, the value supplied in <em>exp-value</em> 
+is also the return value.</p>
+
+<p>To access the contents of shared memory, 
+use the second syntax of <tt>share</tt>, 
+supplying only the shared memory address or handle.
+The return value will be any constant or expression (since v.10.1.0)
+written previously into the memory.
+If the memory has not been previously set to a value, 
+<tt>nil</tt> will be returned.</p>
+
+<p>Only available on Unix-like operating systems, 
+the last syntax unmaps a shared memory address.
+Note that using a shared address after unmapping it 
+will crash the system.</p>
+
+<p>Memory can be shared between parent and child processes,
+but not between independent processes.</p>
+
+<p>Since 10.1.0 size of share objects can exceed the shared memory pagesize
+of the operating system. For objects bigger than the pagesize, newLISP internally
+uses files for sharing. This requires a <tt>/tmp</tt> directory on Unix-like
+operating system. On MS Windows systems the environment variable <tt>TEMP</tt>
+must be set.</p>
+
+<!-- example -->
+
+<pre>
+(set 'mem (share))
+
+(share mem 123)  <span class='arw'>&rarr;</span> 123
+(share mem)      <span class='arw'>&rarr;</span> 123
+
+(share mem "hello world") <span class='arw'>&rarr;</span> "hello world"
+(share mem)               <span class='arw'>&rarr;</span> "hello world"
+
+(share mem true)  <span class='arw'>&rarr;</span> true
+(share mem)       <span class='arw'>&rarr;</span> true
+
+(share mem '(+ 1 2 3 4))  <span class='arw'>&rarr;</span> (+ 1 2 3 4)
+(share mem)               <span class='arw'>&rarr;</span> (+ 1 2 3 4)
+
+; expressions received can be evaluated (since v.10.1.0)
+(eval (share mem))        <span class='arw'>&rarr;</span> 10 
+
+(share nil mem)   <span class='arw'>&rarr;</span> true  ; unmap only on Unix
+</pre>
+
+
+<p>Expression read from shared memory and evaluated, will be evaluated
+in the recipient's process environment.</p>
+
+<p>Note that shared memory access between different processes 
+should be synchronized using a <a href="#semaphore">semaphore</a>.
+Simultaneous access to shared memory can crash the running process.</p>
+
+<p>For a more comprehensive example of using shared memory in a multi process 
+Linux/Unix application, see the file <tt>example/prodcons.lsp</tt> in the
+newLISP source distribution.</p>
+
+<br/><br/>
+
+<a name="signal"></a>
+<h2><span class="function">signal</span></h2>
+<h4>syntax: (signal <em>int-signal</em> <em>sym-event-handler</em> | <em>func-event-handler</em>)<br/>
+syntax: (signal <em>int-signal</em> "ignore" | "default" | "reset")<br/>
+syntax: (signal <em>int-signal</em>)</h4>
+
+<p>
+Sets a user-defined handler in <em>sym-event-handler</em> for a signal specified in <em>int-signal</em>
+or sets to a function expression in <em>func-event-handler</em>.</p>
+
+<p>A parameter following <em>int-signal</em> is not evaluated.</p>
+
+<p>If no signal handler is specified any of the string constants <tt>"ignore"</tt>,
+<tt>"default"</tt> or <tt>"reset"</tt> can be specified in either lower or upper case
+or simply using the first letter of the option string. When signal setup with any
+of these three options has been successful, <tt>true</tt> is returned.</p>
+
+<p>Using <tt>"ignore"</tt> will make newLISP ignore the signal. Using <tt>"default"</tt>
+will set the handler to the default handler of the underlying platform OS. The <tt>"reset"</tt>
+option will restore the handler to newLISP startup state.</p>
+
+<p>On startup, newLISP either specifies an empty newLISP handler or a Ctrl-C handler for 
+<tt>SIGINT</tt> and a <tt>waitpipd(-1, 0, WNOHANG)</tt> C-call for <tt>SIGCHLD</tt>.
+</p>
+
+<p>Different signals are available on different OS platforms and Linux/Unix flavors.
+The numbers to specify in <em>int-signal</em> also differ from platform-to-platform.
+Valid values can normally be extracted from a file found in <tt>/usr/include/sys/signal.h</tt> 
+or <tt>/usr/include/signal.h</tt>.</p>
+
+<p>Some signals make newLISP exit even after a user-defined handler 
+has been specified and executed (e.g., signal SIGKILL).
+This behavior may also be different on different platforms.</p>
+
+<!-- example -->
+
+<pre>
+(constant 'SIGINT 2)
+(define (ctrlC-handler) (println "ctrl-C has been pressed"))
+
+(signal SIGINT 'ctrlC-handler)
+
+; now press ctrl-C
+; the following line will appear
+; this will only work in an interactive terminal window
+; and will not work in the newLISP-GS editor
+
+ctrl-C has been pressed
+
+; reset treatment of signal 2 to startup conditions
+
+(signal SIGINT "reset")
+</pre>
+
+
+<p> On MS Windows, the above example would execute the handler before exiting newLISP.
+On most Linux/Unix systems, newLISP would stay loaded and the prompt would appear 
+after hitting the [enter] key.</p>
+
+<p> Instead of specifying a symbol containing the signal handler,
+a function can be specified directly.  The signal number is passed as a parameter:
+</p>
+
+
+<pre>
+(signal SIGINT exit)  <span class='arw'>&rarr;</span> $signal-2
+
+(signal SIGINT (fn (s) (println "signal " s " occurred")))
+</pre>
+
+
+<p> Note that the signal SIGKILL (9 on most platforms) will always terminate the 
+application regardless of an existing signal handler.</p>
+
+<p>The signal could have been sent from another shell on the same computer:</p>
+
+
+<pre>
+kill -s SIGINT 2035
+</pre>
+
+
+<p>In this example, <tt>2035</tt> is the process ID of the running newLISP.</p>
+
+<p>The signal could also have been sent from another newLISP application using 
+the function <a href="#destroy">destroy</a>:</p>
+
+
+<pre>
+(destroy 2035) <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>If newLISP receives a signal while evaluating another function,
+it will still accept the signal and the handler function will be executed:</p>
+
+
+<pre>
+; only on Mac OSX, BSDs and Linux, not on Windows
+(constant 'SIGINT 2)
+(define (ctrlC-handler) (println "ctrl-C has been pressed"))
+
+(signal SIGINT 'ctrlC-handler)
+;; or
+(signal SIGINT ctrlC-handler)
+
+
+(while true (sleep 300) (println "busy"))
+
+;; generates following output
+busy
+busy
+busy
+ctrl-C has been pressed
+busy
+busy
+&hellip;
+</pre>
+
+
+<p>Specifying only a signal number will return either the name of 
+the currently defined handler function or <tt>nil</tt>.
+</p>
+
+<p>The user-defined signal handler can pass the signal number as a parameter.</p>
+
+
+<pre>
+(define (signal-handler sig)
+	(println "received signal: " sig))
+
+;; set all signals from 1 to 8 to the same handler	
+(for (s 1 8) 
+	(signal s 'signal-handler))
+</pre>
+
+
+<p>In this example, all signals from 1 to 8 are set to the same handler.</p>
+
+<br/><br/>
+
+<a name="silent"></a>
+<h2><span class="function">silent</span></h2>
+
+<h4>syntax: (silent [<em>exp-1</em> [<em>exp-2</em> ... ]])</h4>
+
+<p>
+	Evaluates one or more expressions in <em>exp-1</em>&mdash;.
+	<tt>silent</tt> is similar to <a href="#begin">begin</a>,
+	but it suppresses console output 
+	of the return value 
+	and the following prompt.
+	It is often used 
+	when communicating from 
+	a remote application with newLISP 
+	(e.g., GUI front-ends 
+	or other applications controlling newLISP), 
+	and the return value is of no interest.
+</p>
+
+<p>
+	Silent mode is reset when returning to a prompt.
+	This way, 
+	it can also be used without arguments 
+	in a batch of expressions.
+	When in interactive mode, 
+	hit [enter] twice after a statement 
+	using <tt>silent</tt> 
+	to get the prompt back.
+</p>
+
+
+<!-- example -->
+
+<pre>
+(silent (my-func))  ; same as next
+
+(silent) (my-func)  ; same effect as previous
+</pre>
+
+<br/><br/>
+
+<a name="sin"></a>
+<h2><span class="function">sin</span></h2>
+<h4>syntax: (sin <em>num-radians</em>)</h4>
+
+<p>
+	Calculates the sine function 
+	from <em>num-radians</em> 
+	and returns the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(sin 1)                     <span class='arw'>&rarr;</span> 0.8414709838
+(set 'pi (mul 2 (acos 0)))  <span class='arw'>&rarr;</span> 3.141592654
+(sin (div pi 2))            <span class='arw'>&rarr;</span> 1
+</pre>
+
+<br/><br/>
+
+<a name="sinh"></a>
+<h2><span class="function">sinh</span></h2>
+<h4>syntax: (sinh <em>num-radians</em>)</h4>
+
+<p>Calculates the hyperbolic sine of <em>num-radians</em>. 
+The hyperbolic sine is defined mathematically as: <em>(exp (x) - exp (-x)) / 2</em>.
+An overflow to <tt>inf</tt> may occur if <em>num-radians</em> is too large.</p>
+
+<!-- example -->
+
+<pre>
+(sinh 1)     <span class='arw'>&rarr;</span> 1.175201194
+(sinh 10)    <span class='arw'>&rarr;</span> 11013.23287
+(sinh 1000)  <span class='arw'>&rarr;</span> inf
+(sub (tanh 1) (div (sinh 1) (cosh 1))) <span class='arw'>&rarr;</span> 0
+</pre>
+
+<br/><br/>
+
+<a name="sleep"></a>
+<h2><span class="function">sleep</span></h2>
+
+<h4>syntax: (sleep <em>num-milliseconds</em>)</h4>
+
+<p>Gives up CPU time to other processes for the amount of 
+milliseconds specified in <em>num-milli-seconds</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(sleep 1000)  ; sleeps 1 second
+(sleep 0.5)   ; sleeps 500 micro seconds
+</pre>
+
+
+<p>On some platforms, <tt>sleep</tt> is only available with a resolution 
+of one second. In this case, the parameter <em>int-milli-seconds</em> 
+will be rounded to the nearest full second.</p>
+
+<p>A <tt>sleep</tt> may be cut short by a finishing child process started
+with <a href="#fork">fork</a> or <a href="#spawn">spawn</a>.</p>
+
+<br/><br/>
+
+<a name="slice"></a>
+<h2><span class="function">slice</span></h2>
+
+<h4>syntax: (slice <em>list</em> <em>int-index</em> [<em>int-length</em>])<br/>
+syntax: (slice <em>array</em> <em>int-index</em> [<em>int-length</em>])<br/>
+syntax: (slice <em>str</em> <em>int-index</em> [<em>int-length</em>])</h4>
+
+<p>In the first form, <tt>slice</tt> copies a sublist 
+from a <em>list</em>.  The original list is left unchanged.
+The sublist extracted starts at index <em>int-index</em> 
+and has a length of <em>int-length</em>.  If <em>int-length</em> is negative,
+<tt>slice</tt> will take the parameter as offset counting from the end and copy 
+up to that offset.  If the parameter is omitted, 
+<tt>slice</tt> copies all of the elements to the end of the list.</p>
+
+<p>
+	See also <a href="#indexing">Indexing elements of strings and lists</a>.
+</p>
+
+<!-- example -->
+
+<pre>
+(slice '(a b c d e f) 3 2)   <span class='arw'>&rarr;</span> (d e)
+(slice '(a b c d e f) 2 -2)  <span class='arw'>&rarr;</span> (c d)
+(slice '(a b c d e f) 2)     <span class='arw'>&rarr;</span> (c d e f)
+(slice '(a b c d e f) -4 3)  <span class='arw'>&rarr;</span> (c d e)
+
+(set 'A (array 3 2 (sequence 1 6))) <span class='arw'>&rarr;</span> ((1 2) (3 4) (5 6))
+(slice A 1 2) <span class='arw'>&rarr;</span> ((3 4) (5 6))
+</pre>
+
+
+<p>
+In the second form, a part of the string in <em>str</em> 
+is extracted.  <em>int-index</em> contains the start index
+and <em>int-length</em> contains the length of the substring.
+If <em>int-length</em> is not specified, everything to the end of the string is extracted.
+<tt>slice</tt> also works on string buffers containing binary data like <tt>0</tt>'s (zeroes). 
+It operates on byte boundaries rather than character boundaries.
+See also <a href="#indexing">Indexing elements of strings and lists</a>.</p>
+
+<p>Note that <tt>slice</tt> always works on single 8-bit byte boundaries for
+offset and length numbers, even when running the UTF-8 enabled version of newLISP.</p>
+
+<!-- example -->
+
+<pre>
+(slice "Hello World" 6 2)  <span class='arw'>&rarr;</span> "Wo"
+(slice "Hello World" 0 5)  <span class='arw'>&rarr;</span> "Hello"
+(slice "Hello World" 6)    <span class='arw'>&rarr;</span> "World"
+(slice "newLISP" -4 2)     <span class='arw'>&rarr;</span> "LI"
+
+; UTF-8 strings are converted to a list, then joined again
+
+(join (slice (explode "ฮฉฮจฮงฮฆฮฅฮคฮฃฮฃฮกฮ ฮŸฮžฮฮœฮ›ฮšฮ™ฮ˜ฮ—ฮ–ฮ•ฮ”ฮ“ฮ’ฮ‘") 3 5))  <span class='arw'>&rarr;</span> "ฮฆฮฅฮคฮฃฮฃ" 
+</pre>
+
+
+<p>
+	Note that an <em>implicit slice</em> 
+	is available for lists.
+	See the chapter <a href="#implicit_rest_slice">Implicit rest and slice</a>.
+</p>
+
+<p>
+	Be aware that <a href="#slice">slice</a> 
+	always works on byte boundaries 
+	rather than character boundaries 
+	in the UTF-8&ndash;enabled version of newLISP.
+	As a result, 
+	<a href="#slice">slice</a> can be used 
+	to manipulate binary content.
+</p>
+
+<br/><br/>
+
+<a name="sort"></a>
+<h2><span class="function">sort</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (sort <em>list</em> [<em>func-compare</em>])<br/>
+syntax: (sort <em>array</em> [<em>func-compare</em>])</h4>
+
+<p>All members in <em>list</em> or <em>array</em> are sorted in ascending order.
+Anything may be sorted, regardless of the types.
+When members are themselves lists or arrays, each element 
+is recursively compared.  If two expressions 
+of different types are compared, the lower type is sorted 
+before the higher type in the following order:
+</p>
+
+<pre>
+Atoms: nil, true, integer or float, string, symbol, primitive
+Lists: quoted expression, list, lambda, lambda-macro
+</pre>
+
+<p>The <tt>sort</tt> is destructive, changing the order of the elements in the
+original list or array and returning the sorted list or array. It is a stable
+binary merge-sort with approximately <em>O(n log2 n)</em> performance
+preserving the order of adjacent elements which are equal. When  
+<em>func-compare</em> is used it must work with either <tt>&lt;=</tt> or
+<tt>&gt;=</tt> operators to be stable.</p>
+
+<p>An optional comparison operator, user-defined function, 
+or anonymous function can be supplied. The functor or operator 
+can be given with or without a preceding quote.</p>
+
+<!-- example -->
+
+<pre>
+(sort '(v f r t h n m j))     <span class='arw'>&rarr;</span> (f h j m n r t v)
+(sort '((3 4) (2 1) (1 10)))  <span class='arw'>&rarr;</span> ((1 10) (2 1) (3 4))
+(sort '((3 4) "hi" 2.8 8 b))  <span class='arw'>&rarr;</span> (2.8 8 "hi" b (3 4))
+
+(set 's '(k a l s))
+(sort s)  <span class='arw'>&rarr;</span> (a k l s)  
+
+(sort '(v f r t h n m j) &gt;) <span class='arw'>&rarr;</span> (v t r n m j h f)
+
+(sort s &lt;)  <span class='arw'>&rarr;</span> (a k l s)
+(sort s &gt;)  <span class='arw'>&rarr;</span> (s l k a)  
+s           <span class='arw'>&rarr;</span> (s l k a)
+
+;; define a comparison function
+(define (comp x y) 
+    (&gt;= (last x) (last y)))
+    
+(set 'db '((a 3) (g 2) (c 5)))
+
+(sort db comp)  <span class='arw'>&rarr;</span>  ((c 5) (a 3) (g 2))
+
+;; use an anonymous function
+(sort db (fn (x y) (&gt;= (last x) (last y))))
+</pre>
+
+<br/><br/>
+
+<a name="source"></a>
+<h2><span class="function">source</span></h2>
+<h4>syntax: (source)<br/>
+syntax: (source <em>sym-1</em> [<em>sym-2</em> ... ])</h4>
+
+<p>
+	Works almost identically to <a href="#save">save</a>,
+	except symbols and contexts get serialized to a string 
+	instead of being written to a file.
+	Multiple variable symbols,
+	definitions, and contexts 
+	can be specified.
+	If no argument is given,
+	<tt>source</tt> serializes the entire 
+	newLISP workspace.
+	When context symbols are serialized,
+	any symbols contained within that context 
+	will be serialized, as well.
+	Symbols containing <tt>nil</tt> 
+	are not serialized.
+	System symbols beginning with the <tt>$</tt> (dollar sign) character 
+	are only serialized when mentioned explicitly.
+</p>
+
+<p>
+	Symbols not belonging to the current context
+	are written out with their context prefix.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (double x) (+ x x))
+
+(source 'double)  <span class='arw'>&rarr;</span> "(define (double x)\n  (+ x x))\n\n"
+</pre>
+
+
+<p>
+	As with <a href="#save">save</a>,
+	the formatting of line breaks 
+	and leading spaces or tabs 
+	can be controlled using the 
+	<a href="#pretty-print">pretty-print</a> function.
+</p>
+
+<br/><br/>
+
+<a name="spawn"></a>
+<h2><span class="function">spawn</span></h2>
+<h4>syntax: (spawn <em>sym</em> <em>exp</em> [true])</h4>
+
+<p>Launches the evaluation of <em>exp</em> as a child process and immediately
+returns. The symbol in <em>sym</em> is quoted and receives the result of the 
+evaluation when the function <a href="#sync">sync</a> is executed. <tt>spawn</tt>
+is used to start parallel evaluation of expressions in concurrent processes.
+If newLISP is running on a multi-core CPU, the underlying operating system 
+will distribute spawned processes onto different cores, thereby evaluating 
+expressions in parallel and speeding up overall processing.</p>
+
+<p>The optional <tt>true</tt> parameter must be set if <a href="#send">send</a>
+or <a href="#receive">receive</a> is used to communicated with the child
+process spawned.</p>
+
+<p>The function <tt>spawn</tt> is not available on MS Windows.</p>
+
+<p>After successfully starting a child process,  the <tt>spawn</tt> expression
+returns the process id of the forked process. The following examples shows
+how the calculation of a range of prime numbers can be split up in four sub ranges to
+speed up the calculation of the whole range:</p>
+
+<!-- example -->
+
+<pre>
+; calculate primes in a range
+(define (primes from to)
+  (local (plist)
+      (for (i from to)
+          (if (= 1 (length (factor i)))
+              (push i plist -1)))
+      plist))
+
+; start child processes
+(set 'start (time-of-day))
+
+(spawn 'p1 (primes 1 1000000))
+(spawn 'p2 (primes 1000001 2000000))
+(spawn 'p3 (primes 2000001 3000000))
+(spawn 'p4 (primes 3000001 4000000))
+
+; wait for a maximum of 60 seconds for all tasks to finish
+(sync 60000) ; returns true if all finished in time
+; p1, p2, p3 and p4 now each contain a lists of primes
+
+(println "time spawn: " (- (time-of-day) start))
+(println "time simple: " (time  (primes 1 4000000)))
+
+(exit)
+</pre>
+
+
+<p>On a 1.83 Intel Core 2 Duo processor, the above example will finish
+after about 13 seconds. Calculating all primes using <tt>(primes 1 4000000)</tt>
+would take about 20 seconds.</p>
+
+<p>The <a href="#sync">sync</a> function will wait for all child processes
+to finish and receive the evaluation results in the symbols <tt>p1</tt> to
+<tt>p4</tt>. When all results are collected, <tt>sync</tt>
+will stop waiting and return <tt>true</tt>. When the time specified was
+insufficient , <tt>sync</tt> will return <tt>nil</tt> and  another 
+<tt>sync</tt> statement could be given to further wait and collect results. 
+A short timeout time can be used to do other processing during waiting:</p>
+
+
+<pre>
+(spawn 'p1 (primes 1 1000000))
+(spawn 'p2 (primes 1000001 2000000))
+(spawn 'p3 (primes 2000001 3000000))
+(spawn 'p4 (primes 3000001 4000000))
+
+; print a dot after each 2 seconds of waiting
+(until (sync 2000) (println "."))
+</pre>
+
+
+<p><tt>sync</tt> when used without any parameters, will not wait but immediately
+return a list of pending child processes. For the <tt>primes</tt> example, the following
+<tt>sync</tt> expression could be used to watch the progress:</p>
+
+
+<pre>
+(spawn 'p1 (primes 1 1000000))
+(spawn 'p2 (primes 1000001 2000000))
+(spawn 'p3 (primes 2000001 3000000))
+(spawn 'p4 (primes 3000001 4000000))
+
+; show a list of pending process ids after each three-tenths of a second
+(until (sync 300) (println (sync)))
+</pre>
+
+
+<p>A parameter of <tt>-1</tt> tells <tt>sync</tt> to wait for a very long time
+(~ 1193 hours). A better solution would be to wait for a maximum time, 
+then <a href="#abort">abort</a>  all pending child processes:</p>
+
+
+<pre>
+(spawn 'p1 (primes 1 1000000))
+(spawn 'p2 (primes 1000001 2000000))
+(spawn 'p3 (primes 2000001 3000000))
+(spawn 'p4 (primes 3000001 4000000))
+
+; wait for one minute, then abort and
+; report unfinished PIDs
+
+(if (not (sync 60000))
+    (begin
+        (println "aborting unfinished: " (sync))
+        (abort))
+    (println "all finished successfully")
+)
+</pre>
+
+
+<p>The three functions <tt>spawn</tt>, <tt>sync</tt> and <tt>abort</tt>
+are part of the <a href="http://supertech.csail.mit.edu/cilk/">Cilk</a> API.
+The original implementation also does sophisticated scheduling and allocation
+of threaded tasks to multiple CPU cores. The newLISP implementation of the Cilk API
+lets the operating system of the underlying platform handle process management.
+Internally, the API is implemented using the Unix libc functions <tt>fork()</tt>,
+<tt>waitpid()</tt> and <tt>kill()</tt>. Intercommunications between processes
+and child processes is done using the <a href="#send">send</a> and 
+<a href="#receive">receive</a> functions.</p>
+
+<p><tt>spawn</tt> can be called recursively from spawned subtasks:</p>
+
+
+<pre>
+(define (fibo n)
+  (local (f1 f2)
+    (if(&lt; n 2) 1
+       (begin
+          (spawn 'f1 (fibo (- n 1)))
+          (spawn 'f2 (fibo (- n 2)))
+          (sync 10000)
+          (+ f1 f2)))))
+
+(fibo 7)  <span class='arw'>&rarr;</span> 21
+</pre>
+
+
+<p>With <tt>(fibo 7)</tt> 41 processes will be generated. Although the above
+code shows the working of the Cilk API in a recursive application, 
+it would not be practical, as the overhead required to spawn subtasks 
+is much higher than the time saved through parallelization.</p>
+
+<p>Since version 10.1 a <a href="#send">send</a> and <a href="#receive">receive</a>
+message functions are available for communications between parent and child processes. 
+Using these functions any data or expression of any size can be transferred. 
+Additionally messaged expressions can be evaluated in the recipient's environment.</p>
+
+<p><a href="#fork">fork</a> and <a href="#process">process</a> are other functions
+to start newLISP processes.</p>
+
+<br/><br/>
+
+<a name="sqrt"></a>
+<h2><span class="function">sqrt</span></h2>
+<h4>syntax: (sqrt <em>num</em>)</h4>
+
+<p>
+	Calculates the square root from 
+	the expression in <em>num</em> 
+	and returns the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(sqrt 10)  <span class='arw'>&rarr;</span> 3.16227766
+(sqrt 25)  <span class='arw'>&rarr;</span> 5
+</pre>
+
+<br/><br/>
+
+<a name="ssq"></a>
+<h2><span class="function">ssq</span></h2>
+<h4>syntax: (ssq <em>list-vector | array-vector</em>)</h4>
+
+<p>Calculates the sum of squares of numbers in a vector in 
+<em>list-vector</em> or <em>array-vector</em>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'vector (sequence 1 10))
+(ssq vector) <span class='arw'>&rarr;</span> 385
+
+(set 'vector (array 10 (sequence 1 10)))
+(ssq vector) <span class='arw'>&rarr;</span> 385
+</pre>
+
+<br/><br/>
+
+<a name="starts-with"></a>
+<h2><span class="function">starts-with</span></h2>
+<h4>syntax: (starts-with <em>str</em> <em> str-key</em> [<em>num-option</em>])<br/>
+syntax: (starts-with <em>list</em> [<em>exp</em>])</h4>
+
+<p>In the first version, <tt>starts-with</tt> checks if the string <em>str</em> 
+starts with a key string in <em>str-key</em> and returns <tt>true</tt> or <tt>nil</tt> 
+depending on the outcome.</p>
+
+<p>If a regular expression number is specified in <em>num-option</em>,
+<em>str-key</em> contains a regular expression pattern.
+See <a href="#regex">regex</a> for valid <em>option</em> numbers. </p>
+
+<!-- example -->
+
+<pre>
+(starts-with "this is useful" "this")        <span class='arw'>&rarr;</span> true
+(starts-with "this is useful" "THIS")        <span class='arw'>&rarr;</span> nil
+
+;; use regular expressions
+(starts-with "this is useful" "THIS" 1)      <span class='arw'>&rarr;</span> true
+(starts-with "this is useful" "this|that" 0) <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>In the second version, <tt>starts-with</tt> checks to see if a list 
+starts with the list element in <em>exp</em>.  <tt>true</tt> or <tt>nil</tt> 
+is returned depending on outcome.</p>
+
+<!-- example -->
+
+<pre>
+(starts-with '(1 2 3 4 5) 1)             <span class='arw'>&rarr;</span> true
+(starts-with '(a b c d e) 'b)            <span class='arw'>&rarr;</span> nil
+(starts-with '((+ 3 4) b c d) '(+ 3 4))  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+
+<p>
+	See also the <a href="#ends-with">ends-with</a> function.
+</p>
+
+<br/><br/>
+
+<a name="stats"></a>
+<h2><span class="function">stats</span></h2>
+<h4>syntax: (stats <em>list-vector</em>)</h4>
+
+<p>The functions calculates statistical values of central tendency and distribution moments
+of values in <em>list-vector</em>. The following values are returned by <tt>stats</tt>
+in a list:</p>
+
+<table>
+<tr align="left"><th>name</th><th>description</th></tr>
+<tr><td>N</td><td>Number of values</td></tr>
+<tr><td>mean</td><td>Mean of values</td></tr>
+<tr><td>avdev</td><td>Average deviation from mean value</td></tr>
+<tr><td>sdev</td><td>Standard deviation (population estimate)</td></tr>
+<tr><td>var</td><td>Variance (population estimate)</td></tr>
+<tr><td>skew</td><td>Skew of distribution</td></tr>
+<tr><td>kurt</td><td>Kurtosis of distribution</td></tr>
+</table>
+<br/>
+
+<!-- example -->
+
+<p>The following example uses the list output from the <tt>stats</tt> expression as an
+argument for the <a href="#format">format</a> statement:</p>
+
+<pre>
+(set 'data '(90 100 130 150 180 200 220 300 350 400))
+
+(println (format [text]
+    N        = %5d
+    mean     = %8.2f
+    avdev    = %8.2f
+    sdev     = %8.2f
+    var      = %8.2f
+    skew     = %8.2f
+    kurt     = %8.2f
+[/text] (stats data)))
+
+; outputs the following
+
+    N        =    10
+    mean     =   212.00
+    avdev    =    84.40
+    sdev     =   106.12
+    var      = 11262.22
+    skew     =     0.49
+    kurtosis =    -1.34
+
+</pre>
+
+
+<br/><br/>
+
+<a name="string"></a>
+<h2><span class="function">string</span></h2>
+<h4>syntax: (string <em>exp-1</em> [<em>exp-2</em> ... ])</h4>
+
+<p>
+	Translates into a string anything that results 
+	from evaluating <em>exp-1</em>&mdash;.
+	If more than one expression is specified, 
+	the resulting strings are concatenated.
+</p>
+
+<!-- example -->
+
+<pre>
+(string 'hello)          <span class='arw'>&rarr;</span> "hello"
+(string 1234)            <span class='arw'>&rarr;</span> "1234"
+(string '(+ 3 4))        <span class='arw'>&rarr;</span> "(+ 3 4)"
+(string (+ 3 4) 8)       <span class='arw'>&rarr;</span> "78"
+(string 'hello " " 123)  <span class='arw'>&rarr;</span> "hello 123"
+</pre>
+
+
+<p>
+	If a buffer passed to <tt>string</tt> 
+	contains <tt>\000</tt>,
+	only the string up to the first terminating zero will be copied:
+</p>
+
+
+<pre>
+(set 'buff "ABC\000\000\000")  <span class='arw'>&rarr;</span> "ABC\000\000\000"
+
+(length buff)  <span class='arw'>&rarr;</span> 6
+
+(string buff)  <span class='arw'>&rarr;</span> "ABC"
+
+(length (string buff))  <span class='arw'>&rarr;</span> 3
+</pre>
+
+
+<p>
+	Use the <a href="#append">append</a> 
+	and <a href="#join">join</a> 
+	(allows the joining string 
+	to be specified) functions 
+	to concatenate strings containing zero bytes.
+	Use the <a href="#source">source</a> function 
+	to convert a lambda expression 
+	into its newLISP source string representation.
+</p>
+
+<br/><br/>
+
+<a name="stringp"></a>
+<h2><span class="function">string?</span></h2>
+<h4>syntax: (string? <em>exp</em>)</h4>
+
+<p>
+	Evaluates <em>exp</em> and tests 
+	to see if it is a string.
+	Returns <tt>true</tt> or <tt>nil</tt>
+	depending on the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'var "hello")
+(string? var)  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="struct"></a>
+<h2><span class="function">struct</span></h2>
+<h4>syntax: (struct <em>symbol</em> [<em>str-data-type</em> ... ])</h4>
+
+<p>The <tt>struct</tt> function can be used to define aggregate data types for 
+usage with the extended syntax of <a href="#import">import</a>,
+<a href="#pack">pack</a> and <a href="#unpack">unpack</a>, available on all
+versions of newLISP compiled with <i>libffi</i>. This allows importing
+functions which take C-language <em>struct</em> data types or pointers to these
+aggregate data types.</p>
+
+<p>The following example illustrates the usage of <tt>struct</tt> together with
+the C data functions <tt>localtime</tt> and <tt>asctime</tt>. The <tt>localtime</tt>
+functions works similar to the built-in <a href="#now">now</a> function. The
+<tt>asctime</tt> function takes the numerical data output by <tt>localtime</tt>
+and formats these to readable text.</p>
+
+<pre>
+/* The C function prototypes for the functions to import */
+
+struct tm * localtime(const time_t *clock);
+
+char * asctime(const struct tm *timeptr);
+
+/* the tm struct aggregating different time related values */
+
+struct tm {
+    int tm_sec;      /* seconds after the minute [0-60] */
+    int tm_min;      /* minutes after the hour [0-59] */
+    int tm_hour;     /* hours since midnight [0-23] */
+    int tm_mday;     /* day of the month [1-31] */
+    int tm_mon;      /* months since January [0-11] */
+    int tm_year;     /* years since 1900 */
+    int tm_wday;     /* days since Sunday [0-6] */
+    int tm_yday;     /* days since January 1 [0-365] */
+    int tm_isdst;    /* Daylight Savings Time flag */
+    long tm_gmtoff;  /* offset from CUT in seconds */   /*** not on Windows ***/
+    char *tm_zone;   /* timezone abbreviation */        /*** not on Windows ***/
+};
+</pre>
+
+<p>Function import and definition of the structure data type in newLISP:</p>
+
+<pre>
+;; for pointers to structs always use void*
+;; as a library use msvcrt.dll on Windows or libc.so on Unix.
+;; The tm struct type is configured for Mac OSX and Linux.
+;; On other OS the tm structure may be different
+ 
+(import "libc.dylib" "asctime" "char*" "void*")
+(import "libc.dylib" "localtime" "void*" "void*")
+
+; definition of the struct
+(struct 'tm "int" "int" "int" "int" "int" "int" "int" "int" "int" "long" "char*")
+
+
+;; use import and struct
+
+; todays date number (seconds after 1970 also called Unix epoch time)
+(set 'today (date-value))  <span class='arw'>&rarr;</span> 1324134913
+
+;; the time value is passed by it's address
+;; localtime retirns a pointer to a tm struct
+
+(set 'ptr (localtime (address today))) <span class='arw'>&rarr;</span> 2896219696
+
+; unpack the tm struct  (7:15:13 on the 17th etc.)
+(unpack tm ptr) <span class='arw'>&rarr;</span> (13 15 7 17 11 111 6 350 0 -28800 "PST")
+
+; transform to readable form
+(asctime ptr) <span class='arw'>&rarr;</span> "Sat Dec 17 07:15:13 2011\n"
+
+; all in one statement does actually not use struct, pointers are passed directly
+(asctime (localtime (address today))) <span class='arw'>&rarr;</span> "Sat Dec 17 07:15:13 2011"
+
+; same as the built-in date function
+(date today) <span class='arw'>&rarr;</span> "Sat Dec 17 07:15:13 2011"
+</pre>
+
+<p>Care must be taken to pass valid addresses to pointer parameters in imported functions
+or when passing address pointers to <a href="#unpack">unpack</a>. Invalid address pointers
+can crash newLISP or make it unstable.</p>
+
+<p><tt>struct</tt> definitions can be nested:</p>
+
+<pre>
+; the pair aggregate type
+(struct 'pair "char" "char") <span class='arw'>&rarr;</span> pair
+
+; nested struct type
+(struct 'comp "pair" "int")  <span class='arw'>&rarr;</span> comp
+
+; pack data using the extended pack syntax
+; note the insertion of structure alignment bytes after the pair
+(pack comp (pack pair 1 2) 3) <span class='arw'>&rarr;</span> "\001\002\000\000\003\000\000\000"
+
+; unpack reverses the process
+(unpack comp "\001\002\000\000\003\000\000\000") <span class='arw'>&rarr;</span> ((1 2) 3)
+</pre>
+
+<p>Nested structures are unpacked recursively.</p>
+
+<br/><br/>
+
+
+<a name="sub"></a>
+<h2><span class="function">sub</span></h2>
+<h4>syntax: (sub <em>num-1</em> [<em>num-2</em> ... ])</h4>
+
+<p>
+	Successively subtracts
+	the expressions in <em>num-1</em>,
+	<em>num-2</em>&mdash;.
+	<tt>sub</tt> performs mixed-type arithmetic 
+	and handles integers or floating points,
+	but it will always return 
+	a floating point number.
+	If only one argument is supplied,
+	its sign is reversed.
+	Any floating point calculation 
+	with <tt>NaN</tt> also returns <tt>NaN</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(sub 10 8 0.25)  <span class='arw'>&rarr;</span> 1.75
+(sub 123)        <span class='arw'>&rarr;</span> -123
+</pre>
+
+<br/><br/>
+
+<a name="swap"></a>
+<h2><span class="function">swap</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (swap <em>place-1</em> <em>place-2</em>)</h4>
+
+<p>The contents of the two places <em>place-1 and place-2</em> 
+are swapped. A <em>place</em> can be the contents of an unquoted symbol or any
+list or array references expressed with <a href="#nth">nth</a>, 
+ <a href="#first">first</a>, <a href="#lst">last</a> or implicit
+ <a href="#indexing">indexing</a> or places referenced by <a href="#assoc">assoc</a>
+or <a href="#lookup">lookup</a>.</p>
+
+<p><tt>swap</tt> is a destructive operation that changes the contents of the 
+lists, arrays, or symbols involved.</p>
+
+<!-- example -->
+
+<pre>
+(set 'lst '(a b c d e f))
+
+(swap (first lst) (last lst)) <span class='arw'>&rarr;</span> a
+lst                           <span class='arw'>&rarr;</span> (f b c d e a)
+
+(set 'lst-b '(x y z))
+
+(swap (lst 0) (lst-b -1)) <span class='arw'>&rarr;</span> f
+lst                       <span class='arw'>&rarr;</span> (z b c d e a)
+lst-b                     <span class='arw'>&rarr;</span> (x y f)
+
+(set 'A (array 2 3 (sequence 1 6)) <span class='arw'>&rarr;</span> ((1 2 3) (4 5 6))
+
+(swap (A 0) (A 1)) <span class='arw'>&rarr;</span> (1 2 3)
+A                  <span class='arw'>&rarr;</span> ((4 5 6) (1 2 3))
+
+(set 'x 1 'y 2)
+
+(swap x y)  <span class='arw'>&rarr;</span> 1
+x  <span class='arw'>&rarr;</span> 2
+y  <span class='arw'>&rarr;</span> 1
+
+(set 'lst '((a 1 2 3) (b 10 20 30)))
+(swap (lookup 'a lst -1) (lookup 'b lst 1))
+lst <span class='arw'>&rarr;</span> ((a 1 2 10) (b 3 20 30))
+
+(swap (assoc 'a lst) (assoc 'b lst))
+lst <span class='arw'>&rarr;</span>  ((b 3 20 30) (a 1 2 10))
+</pre>
+
+
+<p>Any two places can be swept in the same or different objects.</p>
+
+<br/><br/>
+
+<a name="sym"></a>
+<h2><span class="function">sym</span></h2>
+<h4>syntax: (sym <em>string</em> [<em>sym-context</em> [<em>nil-flag</em>]])<br/>
+syntax: (sym <em>number</em> [<em>sym-context</em> [<em>nil-flag</em>]])<br/>
+syntax: (sym <em>symbol</em> [<em>sym-context</em> [<em>nil-flag</em>]])</h4>
+
+<p>
+	Translates the first argument in <em>string</em>, 
+	<em>number</em>, or <em>symbol</em> 
+	into a symbol and returns it.
+	If the optional context is not specified 
+	in <em>sym-context</em>, 
+	the current context is used 
+	when doing symbol lookup or creation.
+	Symbols will be created 
+	if they do not already exist.
+	When the context does not exist
+	and the context is specified by a quoted symbol, 
+	the symbol also gets created.
+	If the context specification is unquoted, 
+	the context is the specified name 
+	or the context specification is a variable 
+	containing the context.
+</p>
+
+<p>
+	<tt>sym</tt> can create symbols within the symbol table
+	that are not legal symbols in newLISP source code
+	(e.g., numbers or names containing special characters
+	such as parentheses, colons, etc.).
+	This makes <tt>sym</tt> usable 
+	as a function for associative memory access, 
+	much like <em>hash table</em> access 
+	in other scripting languages. 
+</p>
+
+<p>
+	As a third optional argument,
+	<tt>nil</tt> can be specified 
+	to suppress symbol creation 
+	if the symbol is not found.
+	In this case,
+	<tt>sym</tt> returns <tt>nil</tt> 
+	if the symbol looked up does not exist.
+	Using this last form,
+	<tt>sym</tt> can be used 
+	to check for the existence 
+	of a symbol.
+</p>
+
+<!-- example -->
+
+<pre>
+(sym "some")           <span class='arw'>&rarr;</span> some
+(set (sym "var") 345)  <span class='arw'>&rarr;</span> 345
+var                    <span class='arw'>&rarr;</span> 345
+(sym "aSym" 'MyCTX)    <span class='arw'>&rarr;</span> MyCTX:aSym
+(sym "aSym" MyCTX)     <span class='arw'>&rarr;</span> MyCTX:aSym  ; unquoted context
+
+(sym "foo" MyCTX nil)  <span class='arw'>&rarr;</span> nil  ; 'foo does not exist
+(sym "foo" MyCTX)      <span class='arw'>&rarr;</span> foo  ; 'foo is created
+(sym "foo" MyCTX nil)  <span class='arw'>&rarr;</span> foo  ; foo now exists
+</pre>
+
+
+<p>
+	Because the function <tt>sym</tt> 
+	returns the symbol looked up or created,
+	expressions with <tt>sym</tt> can be embedded 
+	directly in other expressions 
+	that use symbols as arguments.
+	The following example shows 
+	the use of <tt>sym</tt> 
+	as a hash-like function 
+	for associative memory access, 
+	as well as symbol configurations 
+	that are not legal newLISP symbols:
+</p>
+
+<!-- example -->
+
+<pre>
+;; using sym for simulating hash tables
+
+(set (sym "John Doe" 'MyDB) 1.234)
+(set (sym "(" 'MyDB) "parenthesis open")
+(set (sym 12 'MyDB) "twelve")
+
+(eval (sym "John Doe" 'MyDB))  <span class='arw'>&rarr;</span> 1.234
+(eval (sym "(" 'MyDB))         <span class='arw'>&rarr;</span> "parenthesis open"
+(eval (sym 12 'MyDB))          <span class='arw'>&rarr;</span> "twelve"
+
+;; delete a symbol from a symbol table or hash
+(delete (sym "John Doe" 'MyDB))  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+	The last statement shows 
+	how a symbol can be eliminated 
+	using <a href="#delete">delete</a>.
+</p>
+
+<p>
+	The third syntax allows symbols to be used 
+	instead of strings for the symbol name 
+	in the target context.
+	In this case,
+	<tt>sym</tt> will extract the name from the symbol 
+	and use it as the name string 
+	for the symbol in the target context:
+</p>
+
+<!-- example -->
+
+<pre>
+(sym 'myVar 'FOO)  <span class='arw'>&rarr;</span> FOO:myVar
+
+(define-macro (def-context)
+  (dolist (s (rest (args)))
+    (sym s (first (args)))))
+
+(def-context foo x y z)
+
+(symbols foo)  <span class='arw'>&rarr;</span> (foo:x foo:y foo:z)
+</pre>
+
+
+<p>The <tt>def-context</tt> macro shows how this could be used 
+to create a macro that creates contexts and their variables 
+in a dynamic fashion.</p>
+
+<p> A syntax of the <a href="#context">context</a> function can also be used to 
+create, set and evaluate symbols.
+</p>
+
+<br/><br/>
+
+<a name="symbolp"></a>
+<h2><span class="function">symbol?</span></h2>
+<h4>syntax: (symbol? <em>exp</em>)</h4>
+
+<p>
+	Evaluates the <em>exp</em> expression 
+	and returns <tt>true</tt> if the value is a symbol;
+	otherwise, it returns <tt>nil</tt>.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'x 'y)  <span class='arw'>&rarr;</span> y
+
+(symbol? x)  <span class='arw'>&rarr;</span> true 
+
+(symbol? 123)  <span class='arw'>&rarr;</span> nil
+
+(symbol? (first '(var x y z)))  <span class='arw'>&rarr;</span> true
+</pre>
+
+
+<p>
+	The first statement sets the contents of <tt>x</tt> 
+	to the symbol <tt>y</tt>.
+	The second statement then checks the contents of <tt>x</tt>.
+	The last example checks the first element of a list.
+</p>
+
+<br/><br/>
+
+<a name="symbols"></a>
+<h2><span class="function">symbols</span></h2>
+<h4>syntax: (symbols [<em>context</em>])</h4>
+
+<p>
+	Returns a sorted list of all symbols 
+	in the current context 
+	when called without an argument.
+	If a context symbol is specified, 
+	symbols defined in that context are returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(symbols)       ; list of all symbols in current context
+(symbols 'CTX)  ; list of symbols in context CTX
+(symbols CTX)   ; omitting the quote
+(set 'ct CTX)   ; assigning context to a variable
+(symbols ct)    ; list of symbols in context CTX
+</pre>
+
+
+<p>
+	The quote can be omitted 
+	because contexts evaluate to themselves.
+</p>
+
+<br/><br/>
+
+<a name="sync"></a>
+<h2><span class="function">sync</span></h2>
+<h4>syntax: (sync <em>int-timeout</em> [<em>func-inlet</em>])<br/>
+syntax: (sync)</h4>
+
+<p>When <em>int-timeout</em> in milliseconds is specified, <tt>sync</tt> waits 
+for child processes launched with <a href="#spawn">spawn</a> to finish. 
+Whenever a child process finishes, <tt>sync</tt> assigns the evaluation result 
+of the spawned subtask to the symbol specified in the spawn statement.
+The <tt>sync</tt> returns <tt>true</tt> if all child processes have been processed 
+or <tt>nil</tt> if the timeout value has been reached and more child processes
+are pending.</p>
+
+<p>If <tt>sync</tt> additionally is given with an optional user-defined <em>inlet</em> 
+function in <em>func-inlet</em>, this function  will be called with the child process-id
+as argument whenever a spawned child process returns. <em>func-inlet</em> can contain 
+either a lambda expression or a symbol which defines a function.</p>
+
+<p>Without any parameter, <tt>sync</tt> returns a list of pending child process
+PIDs (process identifiers), for which results have not been processed yet.</p>
+
+<p>The function <tt>sync</tt> is not available on MS Windows.</p>
+
+<!-- example -->
+
+<pre>
+; wait for 10 seconds and process finished child processes
+(sync 10000) 
+
+; wait for the maximum time (~ 1193 hours)
+(sync -1) 
+
+(define (report pid)
+    (println "process: " pid " has returned"))
+
+; call the report function, when a child returns
+(sync 10000 report) ; wait for 10 seconds max
+
+; return a list of pending child processes
+(sync)         <span class='arw'>&rarr;</span> (245 246 247 248)
+
+; wait and do something else
+(until (true? (sync 10 report) )
+    (println (time-of-day)))
+
+</pre>
+
+
+<p>When <tt>sync</tt> is given with a timeout parameter, it will block
+until timeout or until all child processes have returned, whichever
+comes earlier. When no parameter is specified or a function is specified,
+<tt>sync</tt> returns immediately.</p>
+
+
+<p>The function <tt>sync</tt> is part of the Cilk API for synchronizing
+child processes and process parallelization. See the reference for the
+function <a href="#spawn">spawn</a> for a full discussion of the Cilk API.</p>
+
+<br/><br/>
+
+
+<a name="sys-error"></a>
+<h2><span class="function">sys-error</span></h2>
+<h4>syntax: (sys-error)<br/>
+syntax: (sys-error <em>int-error</em>)<br/>
+syntax: (sys-error <tt>0</tt>)</h4>
+
+<p>Reports the last error generated by the underlying OS 
+which newLISP is running on.  The error reported 
+may differ on the platforms newLISP has been compiled for.
+Consult the platform's C library information. The error is
+reported as a list of error number and error text.</p>
+
+<p>If no error has occurred or the system error number has
+been reset, <tt>nil</tt> is returned.</p>
+
+<p>When <em>int-error</em> is greater <tt>0</tt> (zero) a
+list of the number and the error text is returned.</p>
+
+<p>To reset the error specify <tt>0</tt> as the error number.</p>
+
+<p>Whenever a function in newLISP within the system resources area
+returns <tt>nil</tt>, <tt>sys-error</tt> can be checked 
+for the underlying reason. For file operations, 
+<tt>sys-error</tt> may be set for nonexistent files 
+or wrong permissions when accessing the resource.
+Another cause of error could be the exhaustion of certain system 
+resources like file handles or semaphores.</p>
+
+<!-- example -->
+
+<pre>
+;; trying to open a nonexistent file
+(open "xyz" "r")  <span class='arw'>&rarr;</span> nil
+
+(sys-error)       <span class='arw'>&rarr;</span> (2 "No such file or directory")
+
+;; reset errno
+(sys-error 0)     <span class='arw'>&rarr;</span> (0 "Unknown error: 0")
+(sys-error)       <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p>See also <a href="#last-error">last-error</a> and <a href="#net-error">net-error</a>.</p>
+
+<br/><br/>
+
+<a name="sys-info"></a>
+<h2><span class="function">sys-info</span></h2>
+<h4>syntax: (sys-info [<em>int-idx</em>])</h4>
+
+<p>Calling <tt>sys-info</tt> without <em>int-idx</em> returns a list of internal 
+resource statistics. Ten integers report the following status:</p>
+
+<table width="98%" summary="sys-info offsets">
+<tr align="left"><th>offset</th><th>description</th></tr>
+<tr><td>0</td><td>Number of Lisp cells</td></tr>
+<tr><td>1</td><td>Maximum number of Lisp cells constant</td></tr>
+<tr><td>2</td><td>Number of symbols</td></tr>
+<tr><td>3</td><td>Evaluation/recursion level</td></tr>
+<tr><td>4</td><td>Environment stack level</td></tr>
+<tr><td>5</td><td>Maximum call stack constant</td></tr>
+<tr><td>6</td><td>Pid of the parent process or 0</td></tr>
+<tr><td>7</td><td>Pid of running newLISP process</td></tr>
+<tr><td>8</td><td>Version number as an integer constant</td></tr>
+<tr><td>9</td><td>Operating system constant:<br/>
+linux=1, bsd=2, osx=3, solaris=4,  windows=6, os/2=7, cygwin=8, tru64 unix=9, aix=10, android=11
+<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;bit 11 will be set for ffilib (extended import/callback API) versions (add 1024)<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;bit 10 will be set for IPv6 versions (add 512)<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;bit 9 will be set for 64-bit (changeable at runtime) versions (add 256)<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;bit 8 will be set for UTF-8 versions (add 128)<br/>
+&nbsp;&nbsp;&nbsp;&nbsp;bit 7 will be added for library versions (add 64)</td></tr>
+</table><br/>
+
+<p>The numbers from <tt>0</tt> to <tt>9</tt> indicate the optional offset 
+in the returned list.</p>
+
+<p>It is recommended to use offsets 0 to 5 to address
+up and including "Maximum call stack constant" and to use
+negative offsets -1 to -4 to access the last four
+entries in the system info list. Future new entries will be inserted
+after offset 5. This way older source code does not need to change.</p>
+
+<p> When using <em>int-idx</em>, one element of the list will be returned.
+</p>
+
+<!-- example -->
+
+<pre>
+(sys-info)     <span class='arw'>&rarr;</span> (429 268435456 402 1 0 2048 0 19453 10406 1155)
+(sys-info 3)   <span class='arw'>&rarr;</span> 1 
+(sys-info -2)  <span class='arw'>&rarr;</span> 10406 ;; version 10.4.6
+</pre>
+
+
+<p>The number for the maximum of Lisp cells can be changed via the <tt>-m</tt> 
+command-line switch. For each megabyte of Lisp cell memory, 
+64k memory cells can be allocated. The maximum call stack depth 
+can be changed using the <tt>-s</tt> command-line switch. </p>
+
+<br/><br/>
+
+<a name="t-test"></a>
+<h2><span class="function">t-test</span></h2>
+<h4>syntax: (t-test <em>list-vector</em> <em>number-value</em>)<br/>
+syntax: (t-test <em>list-vector-A</em> <em>list-vector-B</em> [<tt>true</tt>])<br/>
+syntax: (t-test <em>list-vector-A</em> <em>list-vector-B</em> <em>float-probability</em>)</h4>
+
+<p>In the <b>first syntax</b> the function uses a one sample <em>Student's t</em> 
+test to compare the mean value of <em>list-vector</em> to the value in 
+<em>number-value</em>:</p>
+
+<!-- example -->
+<pre>
+; one sample t-test
+(t-test '(3 5 4 2 5 7 4 3) 2.5)
+<span class='arw'>&rarr;</span> '(4.125 2.5 1.552 0.549 2.960 7 0.021)
+</pre>
+
+<p>The following data are returned in a list:</p>
+
+<table>
+<tr align="left"><th>name</th><th>description</th></tr>
+<tr><td>mean</td><td>mean of data in vector</td></tr>
+<tr><td>value</td><td>value to compare</td></tr>
+<tr><td>sdev</td><td>standard deviation in data vector</td></tr>
+<tr><td>mean-error</td><td>standard error of mean</td></tr>
+<tr><td>t</td><td>t between mean and value</td></tr>
+<tr><td>df</td><td>degrees of freedom</td></tr>
+<tr><td>p</td><td>two tailed probability of t under the null hypothesis</td></tr>
+</table>
+
+<p>In above example the difference of the mean value <tt>4.125</tt> from <tt>2.5</tt> is
+moderately significant. With a probability <tt>p = 0.021 (2.1%)</tt> the null hypothesis
+that the mean is not significantly different, can be rejected.</p>
+
+<p>In the <b>second syntax</b>, the function performs a t-test using the 
+<em>Student's t</em> statistic for comparing the means values in <em>list-vector-A</em> 
+and <em>list-vector-B</em>. If the <tt>true</tt> flag is not used, both vectors 
+in A and B can be of different length and groups represented by A and B are 
+not related.</p>
+
+<p>When the optional flag is set to <tt>true</tt>, measurements were taken
+from the same group twice, e.g. before and after a procedure.</p>
+
+<p>The following results are returned in a list:</p>
+
+<table>
+<tr align="left"><th>name</th><th>description</th></tr>
+<tr><td>mean-a</td><td>mean of group A</td></tr>
+<tr><td>mean-b</td><td>mean of group B</td></tr>
+<tr><td>sdev-a</td><td>standard deviation in group A</td></tr>
+<tr><td>sdev-b</td><td>standard deviation in group B</td></tr>
+<tr><td>t</td><td>t between mean values</td></tr>
+<tr><td>df</td><td>degrees of freedom</td></tr>
+<tr><td>p</td><td>two tailed probability of t under the null hypothesis</td></tr>
+</table>
+
+<p>The first example studies the effect of different sleep length
+before a test on the SCAT (Sam's Cognitive Ability Test):</p>
+
+<!-- example -->
+<pre>
+; SCAT (Sam's Cognitive Ability Test) 
+; two independent sample t-test
+(set 'hours-sleep-8 '(5 7 5 3 5 3 3 9))
+(set 'hours-sleep-4 '(8 1 4 6 6 4 1 2))
+
+(t-test hours-sleep-8 hours-sleep-4)
+ <span class='arw'>&rarr;</span> (5 4 2.138 2.563 0.847 14 0.411)
+</pre>
+
+<p>The duration of sleeps before the SCAT does not have a significant
+effect with a probability value of <tt>0.411</tt>.</p>
+
+<p>In the second example, the same group of people get tested twice,
+before and after a treatment with Prozac depression medication:</p>
+
+<!-- example -->
+<pre>
+; Effect of an antidepressant on a group of depressed people
+; two related samples t-test
+(set 'mood-pre '(3 0 6 7 4 3 2 1 4))
+(set 'mood-post '(5 1 5 7 10 9 7 11 8))
+
+(t-test mood-pre mood-post true)
+<span class='arw'>&rarr;</span> (3.333 7 2.236 3.041 -3.143 8 0.0137)
+</pre>
+
+<p>The effect of the antidepressant treatment is moderately significant with a 
+<tt>p</tt> of <tt>0.0137</tt>.</p>
+
+<p>In the <b>third syntax</b>, a form of the <em>Student's t</em> called <em>Welch's t-test</em>
+is performed. This method is used when the variances observed in both
+samples are significantly different. The threshold can be set using the 
+<em>float-probability</em> parameter. When this parameter is used the <tt>t-test</tt>
+function will perform a F-test to compare the variances in the two data samples.
+If the probability of the found <em>F-ratio</em> is below the <em>float-probability</em> 
+parameter, the <em>Welch's t-test</em> method will be used. Specifying this value
+as <tt>1.0</tt> effectively forces a <em>Welch's t-test</em>:</p>
+
+<!-- example -->
+<pre>
+; two independent sample t-test using the Welch method
+(t-test '(10 4 7 1 1 6 1 8 2 4) '(4 6 9 4 6 8 9 3) 1.0)
+<span class='arw'>&rarr;</span> (4.4 6.125 3.239 2.357 -1.307 15 0.211) 
+
+; two independent sample t-test using the normal method
+(t-test '(10 4 7 1 1 6 1 8 2 4) '(4 6 9 4 6 8 9 3))
+<span class='arw'>&rarr;</span> (4.4 6.125 3.239 2.357 -1.260 16 0.226)
+</pre>
+
+<p>There is no significant difference between the means of the two samples.
+The <em>Welch</em> method of the t-test is slightly more sensitive in this
+case than using the normal t-test method.</p>
+
+<p>Smaller values than <tt>1.0</tt> would trigger the <em>Welch's t-test</em>
+method only when the significance of variance difference in the samples reaches
+certain value.</p>
+
+<br/><br/>
+
+<a name="tan"></a>
+<h2><span class="function">tan</span></h2>
+<h4>syntax: (tan <em>num-radians</em>)</h4>
+
+<p>
+	Calculates the tangent function from <em>num-radians</em> 
+	and returns the result.
+</p>
+
+<!-- example -->
+
+<pre>
+(tan 1)                     <span class='arw'>&rarr;</span> 1.557407725
+(set 'pi (mul 2 (asin 1)))  <span class='arw'>&rarr;</span> 3.141592654
+(tan (div pi 4))            <span class='arw'>&rarr;</span> 1
+</pre>
+
+<br/><br/>
+
+<a name="tanh"></a>
+<h2><span class="function">tanh</span></h2>
+<h4>syntax: (tanh <em>num-radians</em>)</h4>
+
+<p>Calculates the hyperbolic tangent of <em>num-radians</em>. 
+The hyperbolic tangent is defined mathematically as: <em>sinh (x) / cosh (x)</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(tanh 1)     <span class='arw'>&rarr;</span> 0.761594156
+(tanh 10)    <span class='arw'>&rarr;</span> 0.9999999959
+(tanh 1000)  <span class='arw'>&rarr;</span> 1
+(= (tanh 1) (div (sinh 1) (cosh 1)))  <span class='arw'>&rarr;</span> true
+</pre>
+
+<br/><br/>
+
+<a name="term"></a>
+<h2><span class="function">term</span></h2>
+<h4>syntax: (term <em>symbol</em>)</h4>
+
+<p>Returns as a string, the term part of a <em>symbol</em> without the context prefix.</p>
+
+<!-- example -->
+
+<pre>
+(set 'ACTX:var 123)
+(set 'sm 'ACTX:var)
+(string sm)     <span class='arw'>&rarr;</span> "ACTX:var"
+(term sm)      <span class='arw'>&rarr;</span> "var"
+
+(set 's 'foo:bar)
+(= s (sym (term s) (prefix s)))
+</pre>
+
+<p>See also <a href="#prefix">prefix</a> to extract the namespace or
+context prefix from a symbol.</p>
+
+<br/><br/>
+
+<a name="throw"></a>
+<h2><span class="function">throw</span></h2>
+<h4>syntax: (throw <em>exp</em>)</h4>
+
+<p>
+	Works together with 
+	the <a href="#catch">catch</a> function.
+	<tt>throw</tt> forces the return of a previous <tt>catch</tt> statement 
+	and puts the <em>exp</em> into the result symbol of <tt>catch</tt>.
+</p>
+
+
+<!-- example -->
+
+<pre>
+(define (throw-test)
+    (dotimes (x 1000) 
+        (if (= x 500) (throw "interrupted"))))
+
+(catch (throw-test) 'result)  <span class='arw'>&rarr;</span> true
+
+result  <span class='arw'>&rarr;</span> "interrupted"
+
+(catch (throw-test))  <span class='arw'>&rarr;</span> "interrupted"
+</pre>
+
+
+<p>
+	The last example shows a shorter form of <a href="#catch">catch</a>,
+	which returns the <tt>throw</tt> result directly.
+</p>
+
+<p>
+	<tt>throw</tt> is useful for breaking out of a loop 
+	or for early return from user-defined functions 
+	or expression blocks.
+	In the following example,
+	the <tt>begin</tt> block will return <tt>X</tt> 
+	if <tt>(foo X)</tt> is <tt>true</tt>; 
+	else <tt>Y</tt> will be returned:
+</p>
+
+
+<pre>
+(catch (begin
+    &hellip;
+    (if (foo X) (throw X) Y)
+    &hellip;
+))
+</pre>
+
+
+<p>
+	<tt>throw</tt> will <em>not</em> cause an error exception.
+	Use <a href="#throw-error">throw-error</a>
+	to throw user error exceptions.
+</p> 
+
+<br/><br/>
+
+<a name="throw-error"></a>
+<h2><span class="function">throw-error</span></h2>
+<h4>syntax: (throw-error <em>exp</em>)</h4>
+
+<p>
+	Causes a user-defined error exception 
+	with text provided by evaluating <em>exp</em>.
+</p>
+
+<!-- example -->
+
+<pre>
+(define (foo x y)
+    (if (= x 0) (throw-error "first argument cannot be 0"))
+    (+ x y))
+
+(foo 1 2)  <span class='arw'>&rarr;</span> 3
+
+(foo 0 2)  ; causes a user error exception
+<span class='err'>ERR: user error : first argument cannot be 0
+called from user-defined function foo</span>
+</pre>
+
+
+<p>
+	The user error can be handled 
+	like any other error exception 
+	using user-defined error handlers 
+	and the <a href="#error-event">error-event</a> function, 
+	or the form of <a href="#catch">catch</a> 
+	that can capture error exceptions.
+</p>
+
+<br/><br/>
+
+<a name="time"></a>
+<h2><span class="function">time</span></h2>
+<h4>syntax: (time <em>exp</em> [<em>int-count</em>)</h4>
+
+<p>Evaluates the expression in <em>exp</em> and returns the time spent 
+on evaluation in floating point milliseconds. Depending on the platform
+decimals of milliseconds are shown or not shown.</p>
+
+<!-- example -->
+
+<pre>
+(time (myprog x y z))  <span class='arw'>&rarr;</span> 450.340
+
+(time (myprog x y z) 10)  <span class='arw'>&rarr;</span> 4420.021
+</pre>
+
+
+<p>In first the example, 450 milliseconds elapsed 
+while evaluating <tt>(myprog x y z)</tt>.  The second example 
+returns the time for ten evaluations of  <tt>(myprog x y z)</tt>.
+See also <a href="#date">date</a>,
+<a href="#date-value">date-value</a>,
+<a href="#time-of-day">time-of-day</a>, 
+and <a href="#now">now</a>.</p>
+
+<br/><br/>
+
+<a name="time-of-day"></a>
+<h2><span class="function">time-of-day</span></h2>
+
+<h4>syntax: (time-of-day)</h4>
+
+<p>Returns the time in milliseconds since the start of the current day. 
+</p>
+
+<p>See also the <a href="#date">date</a>,
+<a href="#date-value">date-value</a>,
+<a href="#time">time</a>, 
+and <a href="#now">now</a> functions.</p>
+
+<br/><br/>
+
+<a name="timer"></a>
+<h2><span class="function">timer</span></h2>
+<h4>syntax: (timer <em>sym-event-handler | func-event-handler</em> <em>num-seconds</em> [<em>int-option</em>])<br/>
+syntax: (timer <em>sym-event-handler | func-event-handler</em>)<br/>
+syntax: (timer)</h4>
+
+<p>Starts a one-shot timer firing off the Unix signal <tt>SIGALRM</tt>, <tt>SIGVTALRM</tt>, 
+or <tt>SIGPROF</tt> after the time in seconds (specified in <em>num-seconds</em>) 
+has elapsed. When the timer fires, it calls the user-defined function 
+in <em>sym-</em> or <em>func-event-handler</em>.
+</p>
+
+<p>On Linux/Unix, an optional <tt>0</tt>, <tt>1</tt>, or <tt>2</tt> can 
+be specified to control how the timer counts.  With default option 
+<tt>0</tt>, real time is measured.  Option <tt>1</tt> measures the time 
+the CPU spends processing in the process owning the timer.
+Option <tt>2</tt> is a combination of both called <em>profiling time</em>.
+See the Unix man page <tt>setitimer()</tt> for details.
+</p>
+
+<p>The event handler can start the timer again to achieve a 
+continuous flow of events.  Starting with version 8.5.9,
+seconds can be defined as floating point numbers with a fractional 
+part (e.g., <tt>0.25</tt> for 250 milliseconds).</p>
+
+<p>Defining <tt>0</tt> (zero) as time shuts the running timer down 
+and prevents it from firing.</p>
+
+<p>
+When called with <em>sym-</em> or <em>func-event-handler</em>, 
+<tt>timer</tt> returns the elapsed time of the timer in progress.
+This can be used to program time lines or schedules.</p>
+
+<p>
+<tt>timer</tt> called without arguments returns the symbol of the current 
+event handler.</p> 
+
+
+<!-- example -->
+
+<pre>
+(define (ticker) 
+    (println (date)) (timer 'ticker 1.0))
+
+&gt; (ticker)
+<b>Tue Apr 12 20:44:48 2005</b>	; first execution of ticker
+<span class='arw'>&rarr;</span> ticker			      ; return value from ticker
+
+&gt; <b>Tue Apr 12 20:44:49 2005</b>	; first timer event
+<b>Tue Apr 12 20:44:50 2005</b>	; second timer event ...
+<b>Tue Apr 12 20:44:51 2005
+Tue Apr 12 20:44:52 2005</b>
+</pre>
+
+
+<p>
+	The example shows an event handler, <tt>ticker</tt>,
+	which starts the timer again after each event.
+</p>
+
+<p>
+	Note that a timer cannot interrupt an 
+	ongoing built-in function.
+	The timer interrupt gets registered by newLISP,
+	but a timer handler cannot run 
+	until one expression is evaluated 
+	and the next one starts.
+	To interrupt an ongoing I/O operation with <tt>timer</tt>,
+	use the following pattern, 
+	which calls <a href="#net-select">net-select</a> 
+	to test if a socket is ready for reading:
+</p>
+
+<!-- example -->
+
+<pre>
+define (interrupt)
+    (set 'timeout true))
+        
+(set 'listen (net-listen 30001))
+(set 'socket (net-accept listen))
+        
+(timer 'interrupt 10)
+;; or specifying the function directly
+(timer (fn () (set 'timeout true)) 10)
+        
+(until (or timeout done)
+    (if (net-select socket "read" 100000)
+        (begin
+            (net-receive socket buffer 1024)
+            (set 'done true)))
+)
+                                                                                
+(if timeout
+    (println "timeout")
+    (println buffer))
+                                                                              
+(exit)
+</pre>
+
+
+<p>
+	In this example,
+	the <tt>until</tt> loop will run 
+	until something can be read from <tt>socket</tt>, 
+	or until ten seconds have passed 
+	and the <tt>timeout</tt> variable is set.
+</p>
+
+<br/><br/>
+
+<a name="title-case"></a>
+<h2><span class="function">title-case</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (title-case <em>str</em> <em>[bool]</em>)</h4>
+
+<p>
+	Returns a copy of the string in <em>str</em> 
+	with the first character converted to uppercase.
+	When the optional <em>bool</em> parameter 
+	evaluates to any value other than <tt>nil</tt>,
+	the rest of the string is converted to lowercase.
+</p>
+
+<!-- example -->
+
+<pre>
+(title-case "hello")       <span class='arw'>&rarr;</span> "Hello"
+(title-case "hELLO" true)  <span class='arw'>&rarr;</span> "Hello"
+(title-case "hELLO")       <span class='arw'>&rarr;</span> "HELLO"
+</pre>
+
+
+<p>
+	See also the <a href="#lower-case">lower-case</a> 
+	and <a href="#upper-case">upper-case</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="trace"></a>
+<h2><span class="function">trace</span></h2>
+
+<h4>syntax: (trace <em>int-device</em>)<br/>
+syntax: (trace <em>true</em>)<br/>
+syntax: (trace <em>nil</em>)<br/>
+syntax: (trace)</h4>
+
+<p>In the first syntax the parameter is an integer of a device like an opened file.
+Output is continuously written to that device. If <em>int-device</em> is 
+<tt>1</tt> output is written to <i>stdout</i>. </p> 
+
+<pre>
+; write all entries and exits from expressions to trace.txt
+(trace (open "trace.txt")) 
+
+; write all entries and exits from expressions to trace.txt
+(foo x y)                  
+(bar x)              
+      
+; close the trace.txt file
+(trace nil)
+</pre>
+
+<p>In the second syntax debugger mode is switched on when the 
+parameter evaluates true. When in debugging mode newLISP will stop
+after each entry and exit from an expression and wait for user input.
+Highlighting is done by bracketing the expression between two # 
+(number sign) characters.  This can be changed to a different character 
+using <a href="#trace-highlight">trace-highlight</a>.:</p>
+
+<pre>
+[-&gt; 2] s|tep n|ext c|ont q|uit &gt;
+</pre>
+
+<p>
+At the prompt, an <tt>s</tt>, <tt>n</tt>, <tt>c</tt>, 
+or <tt>q</tt> can be entered to step into or 
+merely execute the next expression.  Any expression can be entered 
+at the prompt for evaluation.  Entering the name of a variable,
+for example, would evaluate to its contents.
+In this way, a variable's contents can be checked during debugging
+or set to different values.
+</p>
+
+<!-- example -->
+
+<pre>
+;; switches newLISP into debugging mode
+(trace true)  <span class='arw'>&rarr;</span> true 
+
+;; the debugger will show each step
+(my-func a b c)
+
+;; switched newLISP out of debugging mode
+(trace nil)  <span class='arw'>&rarr;</span> nil 
+</pre>
+
+<p>To set break points where newLISP should interrupt 
+normal execution and go into debugging mode,
+put <tt>(trace true)</tt> statements into the newLISP 
+code where execution should switch on the debugger.</p>
+
+<p>Use the <a href="#debug">debug</a> function as a shortcut 
+for the above example:</p>
+
+<pre>
+(debug (my-func a b c))
+</pre>
+
+
+<p>In the third syntax <tt>(trace nil)</tt> closes debugger mode or 
+the trace file opened.</p>
+
+<p>In the last syntax <tt>(trace)</tt> returns the current mode.</p>
+
+<br/><br/>
+
+<a name="trace-highlight"></a>
+<h2><span class="function">trace-highlight</span></h2>
+<h4>syntax: (trace-highlight <em>str-pre</em> <em>str-post</em> [<em>str-header</em> <em>str-footer</em>])</h4>
+
+<p>Sets the characters or string of characters used to enclose expressions 
+during <a href="#trace">trace</a>.  By default, 
+the # (number sign) is used to enclose the expression highlighted 
+in <a href="#trace">trace</a> mode.  This can be changed to different characters 
+or strings of up to seven characters.  If the console window accepts terminal 
+control characters, this can be used to display the expression in a different 
+color, bold, reverse, and so forth.</p>
+
+<p>Two more strings can optionally be specified for <em>str-header and str-footer</em>,
+which control the separator and prompt. A maximum of 15 characters is allowed 
+for the header and 31 for the footer.</p>
+
+<!-- example -->
+
+<pre>
+;; active expressions are enclosed in &gt;&gt; and &lt;&lt;
+
+(trace-highlight "&gt;&gt;" "&lt;&lt;") 
+             
+;; 'bright' color on a VT100 or similar terminal window
+
+(trace-highlight "\027[1m" "\027[0m")   
+</pre>
+
+
+<p>
+The first example replaces the default <tt>#</tt> (number sign) 
+with a <tt>&gt;&gt;</tt> and <tt>&lt;&lt;</tt>. The second example works 
+on most Linux shells.  It may not, however, work in console windows 
+under MS Windows or CYGWIN, depending on the configuration of the terminal.</p>
+
+<br/><br/>
+
+<a name="transpose"></a>
+<h2><span class="function">transpose</span></h2>
+<h4>syntax: (transpose <em>matrix</em>)</h4>
+
+<p>Transposes a <em>matrix</em> by reversing the rows and columns.
+Any kind of list-matrix can be transposed. Matrices are made rectangular 
+by filling in <tt>nil</tt> for missing elements, omitting elements where 
+appropriate, or expanding atoms in rows into lists.
+Matrix dimensions are calculated using the number of rows in the original 
+matrix for columns and the number of elements in the first row 
+as number of rows for the transposed matrix.</p>
+
+<p>The matrix to transpose can contain any data-type.</p>
+
+<p>The dimensions of a matrix are defined by the number of rows 
+and the number of elements in the first row.  A matrix can either be a 
+nested list or an <a href="#array">array</a>.</p>
+
+<!-- example -->
+
+<pre>
+(set 'A '((1 2 3) (4 5 6)))
+(transpose A)                      <span class='arw'>&rarr;</span> ((1 4) (2 5) (3 6))
+(transpose (list (sequence 1 5)))  <span class='arw'>&rarr;</span> ((1) (2) (3) (4) (5))
+
+; any data type is allowed in the matrix
+(transpose '((a b) (c d) (e f)))   <span class='arw'>&rarr;</span> ((a c e) (b d f))
+
+; arrays can be transposed too
+(set 'A (array 2 3 (sequence 1 6)))
+(set 'M (transpose A)) 
+M <span class='arw'>&rarr;</span> ((1 4) (2 5) (3 6))
+</pre>
+
+
+<p>The number of columns in a matrix is defined by the number of elements 
+in the first row of the matrix.  If other rows have fewer elements, 
+<tt>transpose</tt> will assume <tt>nil</tt> for those missing elements.
+Superfluous elements in a row will be ignored.</p>
+
+
+<pre>
+(set 'A '((1 2 3) (4 5) (7 8 9)))
+
+(transpose A)  <span class='arw'>&rarr;</span> ((1 4 7) (2 5 8) (3 nil 9))
+</pre>
+
+
+<p>If a row is any other data type besides a list,
+the transposition treats it like an entire row of elements 
+of that data type:</p>
+
+
+<pre>
+(set 'A '((1 2 3) X (7 8 9)))
+
+(transpose A)  <span class='arw'>&rarr;</span> ((1 X 7) (2 X 8) (3 X 9))
+</pre>
+
+
+<p>All operations shown here on lists can also be performed on arrays.
+</p>
+
+<p>
+	See also the matrix operations 
+	<a href="#det">det</a>, <a href="#invert">invert</a>,
+    <a href="#mat">mat</a> and <a href="#multiply">multiply</a>.
+</p>
+
+<br/><br/>
+
+<a name="trim"></a>
+<h2><span class="function">trim</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (trim <em>str</em>)<br/>
+syntax: (trim <em>str</em> <em>str-char</em>)<br/>
+syntax: (trim <em>str</em> <em>str-left-char</em> <em>str-right-char</em>)</h4>
+
+<p>Using the first syntax, all white-space characters are trimmed from both
+sides of <em>str</em>.</p>
+
+<p>The second syntax trims the string <em>str</em> from both sides, 
+stripping the leading and trailing characters as given 
+in <em>str-char</em>. If <em>str-char</em> contains no character,
+the space character is assumed. <tt>trim</tt> returns the new string.
+</p>
+
+<p>The third syntax can either trim different characters from both sides 
+or trim only one side if an empty string is specified 
+for the other.  </p>
+
+<!-- example -->
+
+<pre>
+(trim "   hello \n ")            <span class='arw'>&rarr;</span> "hello"
+(trim "   h e l l o   ")         <span class='arw'>&rarr;</span> "h e l l o")
+(trim "----hello-----" "-")      <span class='arw'>&rarr;</span> "hello"
+(trim "00012340" "0" "")         <span class='arw'>&rarr;</span> "12340"
+(trim "1234000" "" "0")          <span class='arw'>&rarr;</span> "1234"
+(trim "----hello=====" "-" "=")  <span class='arw'>&rarr;</span> "hello"
+</pre>
+
+<p>For more complex cases <a href="#replace">replace</a> can be used. When
+possible, the much faster <tt>trim</tt> is preferred.</p>
+
+<br/><br/>
+
+<a name="truep"></a>
+<h2><span class="function">true?</span></h2>
+<h4>syntax: (true? <em>exp</em>)</h4>
+
+<p>If the expression in <em>exp</em> 
+evaluates to anything other than <tt>nil</tt>
+or the empty list <tt>()</tt>, 
+<tt>true?</tt> returns <tt>true</tt>; 
+otherwise, it returns <tt>nil</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(map true? '(x 1 "hi" (a b c) nil ()))
+<span class='arw'>&rarr;</span> (true true true true nil nil)
+(true? nil)  <span class='arw'>&rarr;</span> nil
+(true? '())  <span class='arw'>&rarr;</span> nil
+</pre>
+
+
+<p><tt>true?</tt> behaves like <a href="#if">if</a>
+and rejects the empty list <tt>()</tt>.</p>
+
+<br/><br/> 
+
+
+<a name="unicode"></a>
+<h2><span class="function">unicode</span></h2>
+
+<h4>syntax: (unicode <em>str-utf8</em>)</h4>
+
+<p>Converts ASCII/UTF-8 character strings in <em>str</em> 
+to UCS-4&ndash;encoded Unicode of 4-byte integers per character.
+The string is terminated with a 4-byte integer <tt>0</tt>.
+This function is only available on UTF-8&ndash;enabled versions 
+of newLISP.</p>
+
+<!-- example -->
+
+<pre>
+(unicode "new") 
+<span class='arw'>&rarr;</span> "n\000\000\000e\000\000\000w\000\000\000\000\000\000\000"
+
+(utf8 (unicode "new"))  <span class='arw'>&rarr;</span> "new"
+</pre>
+
+
+<p>On <em>big endian</em> CPU architectures, the byte order will 
+be reversed from high to low. The <tt>unicode</tt> and 
+<a href="#utf8">utf8</a> functions are the inverse of each other.
+These functions are only necessary if UCS-4 Unicode is in use.
+Most systems use UTF-8 encoding only.</p>
+
+<br/><br/>
+
+<a name="unify"></a>
+<h2><span class="function">unify</span></h2>
+<h4>syntax: (unify <em>exp-1</em> <em>exp-2</em> [<em>list-env</em>])</h4>
+
+<p>Evaluates and matches <em>exp-1</em> and <em>exp-2</em>.
+Expressions match if they are equal or if one of the expressions is 
+an unbound variable (which would then be bound to the other expression).
+If expressions are lists, they are matched by comparing subexpressions.
+Unbound variables start with an uppercase character 
+to distinguish them from symbols.  <tt>unify</tt> returns <tt>nil</tt> 
+when the unification process fails,
+or it returns a list of variable associations on success.
+When no variables were bound, but the match is still successful,
+<tt>unify</tt> returns an empty list.
+newLISP uses a modified <em>J. Alan Robinson</em> unification algorithm
+with correctly applied <em>occurs check</em>. 
+See also <em>Peter Norvig</em>'s paper about a common 
+<a href="http://norvig.com/unify-bug.pdf">unification algorithm bug</a>, which 
+is not present in this implementation.
+</p>
+
+<p>Since version 10.4.0 the underscore symbol <tt>_</tt> (ASCII 95) matches any atom,
+list or unbound variable and never binds.</p>
+
+<p>
+    Like <a href="#match">match</a>, <tt>unify</tt> is frequently 
+    employed as a parameter functor in <a href="#find">find</a>,
+    <a href="#ref">ref</a>,  <a href="#ref-all">ref-all</a> and 
+    <a href="#replace">replace</a>.
+</p>
+
+
+<!-- example -->
+
+<pre>
+(unify 'A 'A)  <span class='arw'>&rarr;</span> ()  ; tautology
+
+(unify 'A 123)  <span class='arw'>&rarr;</span> ((A 123))  ; A bound to 123
+
+(unify '(A B) '(x y))  <span class='arw'>&rarr;</span> ((A x) (B y))  ; A bound to x, B bound to y
+
+(unify '(A B) '(B abc))  <span class='arw'>&rarr;</span> ((A abc) (B abc))  ; B is alias for A
+
+(unify 'abc 'xyz)  <span class='arw'>&rarr;</span> nil  ; fails because symbols are different
+
+(unify '(A A) '(123 456))  <span class='arw'>&rarr;</span> nil  ; fails because A cannot be bound to different values
+
+(unify '(f A) '(f B))  <span class='arw'>&rarr;</span> ((A B))  ; A and B are aliases
+
+(unify '(f A) '(g B))  <span class='arw'>&rarr;</span> nil  ; fails because heads of terms are different
+
+(unify '(f A) '(f A B))  <span class='arw'>&rarr;</span> nil  ; fails because terms are of different arity
+
+(unify '(f (g A)) '(f B))  <span class='arw'>&rarr;</span> ((B (g A)))  ; B bound to (g A)
+
+(unify '(f (g A) A) '(f B xyz))  <span class='arw'>&rarr;</span> ((B (g xyz)) (A xyz))  ; B bound to (g xyz) A to xyz
+
+(unify '(f A) 'A)  <span class='arw'>&rarr;</span> nil  ; fails because of infinite unification (f(f(f &hellip;)))
+
+(unify '(A xyz A) '(abc X X))  <span class='arw'>&rarr;</span>  nil ; indirect alias A to X doesn't match bound terms
+
+(unify '(p X Y a) '(p Y X X))  <span class='arw'>&rarr;</span> '((Y a) (X a)))  ; X alias Y and binding to 'a
+
+(unify '(q (p X Y) (p Y X)) '(q Z Z))  <span class='arw'>&rarr;</span> ((Y X) (Z (p X X)))  ; indirect alias
+
+(unify '(A b _) '(x G z)) <span class='arw'>&rarr;</span> ((A x) (G b)) ; _ matches atom z 
+
+(unify '(A b c _) '(x G _ z)) <span class='arw'>&rarr;</span> ((A x) (G b)) ; _ never binds, matches c and z
+
+(unify '(A b _) '(x G (x y z))) <span class='arw'>&rarr;</span> ((A x) (G b)) ; _ matches list (x y z)
+
+;; some examples taken from <a href="http://en.wikipedia.org/wiki/Unification_(computer_science)">http://en.wikipedia.org/wiki/Unification_(computer_science)</a>
+</pre>
+
+
+<p>
+	<tt>unify</tt> can take an optional binding 
+	or association list in <em>list-env</em>.
+	This is useful when chaining <tt>unify</tt> expressions 
+	and the results of previous <tt>unify</tt> bindings 
+	must be included:
+</p>
+
+<!-- example -->
+
+<pre>
+(unify '(f X) '(f 123))  <span class='arw'>&rarr;</span> ((X 123))
+
+(unify '(A B) '(X A) '((X 123)))
+<span class='arw'>&rarr;</span> ((X 123) (A 123) (B 123))
+</pre>
+
+
+<p>
+	In the previous example,
+	<tt>X</tt> was bound to <tt>123</tt> earlier 
+	and is included in the second statement 
+	to pre-bind <tt>X</tt>.
+</p> 
+
+
+<h3>Use <tt>unify</tt> with <tt>expand</tt></h3>
+
+<p>
+	Note that variables are not actually bound 
+	as a newLISP assignment. Rather,
+	an association list is returned 
+	showing the logical binding.
+	A special syntax of <a href="#expand">expand</a> 
+	can be used to actually replace bound variables 
+	with their terms:
+</p>
+
+
+<pre>
+(set 'bindings (unify '(f (g A) A) '(f B xyz)))
+<span class='arw'>&rarr;</span> ((B (g xyz)) (A xyz))
+
+(expand '(f (g A) A) bindings)  <span class='arw'>&rarr;</span> (f (g xyz) xyz)
+
+; or in one statement
+(expand '(f (g A) A) (unify '(f (g A) A) '(f B xyz)))
+<span class='arw'>&rarr;</span> (f (g xyz) xyz)
+</pre>
+
+ 
+<h3>Use <tt>unify</tt> with <tt>bind</tt> for de-structuring</h3>
+
+<p>The function <a href="#bind">bind</a> can be used to set unified
+variables:</p>
+
+<pre>
+(bind (unify '(f (g A) A) '(f B xyz)))
+
+A <span class='arw'>&rarr;</span> xyz 
+B <span class='arw'>&rarr;</span> (g xyz)
+</pre>
+
+<p>This can be used for de-structuring:</p>
+
+<pre>
+(set 'structure '((one "two") 3 (four (x y z))))
+(set 'pattern '((A B) C (D E)))
+(bind (unify pattern structure))
+
+A <span class='arw'>&rarr;</span> one
+B <span class='arw'>&rarr;</span> "two"
+C <span class='arw'>&rarr;</span> 3
+D <span class='arw'>&rarr;</span> four
+E <span class='arw'>&rarr;</span> (x y z)
+</pre>
+
+<p><tt>unify</tt> returns an association list and <tt>bind</tt> binds the associations.</p>
+
+<h3>Model propositional logic with <tt>unify</tt></h3>
+
+<p>
+	The following example shows how propositional logic 
+	can be modeled using <tt>unify</tt> 
+	and <a href="#expand">expand</a>:
+</p>
+
+
+<pre>
+; if somebody is human, he is mortal -&gt; (X human) :- (X mortal)
+; socrates is human -&gt; (socrates human)
+; is socrates mortal? -&gt; ?  (socrates mortal)
+
+(expand '(X mortal) 
+         (unify '(X human) '(socrates human))) 
+<span class='arw'>&rarr;</span> (socrates mortal)
+</pre>
+
+
+<p>
+	The following is a more complex example 
+	showing a small, working PROLOG (Programming in Logic) 
+	implementation.
+</p>
+
+
+<pre>
+;; a small PROLOG implementation
+
+(set 'facts '(
+    (socrates philosopher)
+    (socrates greek)
+    (socrates human)
+    (einstein german)
+    (einstein (studied physics))
+    (einstein human)
+))
+
+(set 'rules '(
+    ((X mortal) &lt;- (X human))
+    ((X (knows physics)) &lt;- (X physicist))
+    ((X physicist) &lt;- (X (studied physics)))
+))
+
+
+(define (query trm)
+    (or  (when (find trm facts) true) (catch (prove-rule trm))))
+
+(define (prove-rule trm)
+    (dolist (r rules)
+        (when (list? (set 'e (unify trm (first r))))
+            (when (query (expand (last r) e))
+                (throw true))))
+    nil
+)
+
+; try it
+
+&gt; (query '(socrates human))
+<b>true</b>
+&gt; (query '(socrates (knows physics)))
+<b>nil</b>
+&gt; (query '(einstein (knows physics)))
+<b>true</b>
+</pre>
+
+
+<p>
+	The program handles a database of <tt>facts</tt> 
+	and a database of simple 
+	<em>A is a fact if B is a fact</em> <tt>rules</tt>.
+	A fact is proven true 
+	if it either can be found in the <tt>facts</tt> database 
+	or if it can be proven using a rule.
+	Rules can be nested:
+	for example, to prove that somebody <tt>(knows physics)</tt>, 
+	it must be proved true that somebody is a <tt>physicist</tt>.
+	But somebody is only a physicist 
+	if that person <tt>studied physics</tt>.
+	The <tt>&lt;-</tt> symbol 
+	separating the left and right terms of the rules 
+	is not required 
+	and is only added to make the rules database 
+	more readable.
+</p>
+
+<p>
+	This implementation does not handle multiple terms 
+	in the right premise part of the rules,
+	but it does handle backtracking of the <tt>rules</tt> database 
+	to try out different matches.
+	It does not handle backtracking 
+	in multiple premises of the rule.
+	For example,
+	if in the following rule <tt>A if B and C and D</tt>, 
+	the premises <tt>B</tt> and <tt>C</tt> succeed 
+	and <tt>D</tt> fails,
+	a backtracking mechanism might need to go back 
+	and reunify the <tt>B</tt> or <tt>A</tt> terms 
+	with different facts or rules 
+	to make <tt>D</tt> succeed.
+</p>
+
+<p>
+	The above algorithm could be written differently 
+	by omitting <a href="#expand">expand</a> 
+	from the definition of <tt>prove-rule</tt>
+	and by passing the environment, <tt>e</tt>,
+	as an argument to the <tt>unify</tt> and <tt>query</tt> functions.
+</p>
+
+<p>
+	A <em>learning</em> of proven facts 
+	can be implemented by appending them 
+	to the <tt>facts</tt> database 
+	once they are proven.
+	This would speed up subsequent queries.
+</p>
+
+<p>
+	Larger PROLOG implementations 
+	also allow the evaluation of terms in rules. 
+	This makes it possible to implement functions
+	for doing other work 
+	while processing rule terms.
+	<tt>prove-rule</tt> could accomplish this testing 
+	for the symbol <tt>eval</tt> in each rule term.
+</p>
+
+<br/><br/>
+
+<a name="union"></a>
+<h2><span class="function">union</span></h2>
+<h4>syntax: (union <em>list-1</em> <em>list-2</em> [<em>list-3</em> ... ])</h4>
+
+<p><tt>union</tt> returns a unique collection list of distinct elements found in two 
+or more lists.</p>
+
+<pre>
+(union '(1 3 1 4 4 3) '(2 1 5 6 4))  <span class='arw'>&rarr;</span>  (1 3 4 2 5 6)
+</pre>
+
+<p>Like the other set functions <a href="#difference">difference</a>, 
+<a href="#intersect">intersect</a> and <a href="#unique">unique</a>,
+<tt>union</tt> maintains the order of elements as found in the original
+lists.</p>
+
+<br/><br/>
+
+<a name="unique"></a>
+<h2><span class="function">unique</span></h2>
+<h4>syntax: (unique <em>list</em>)</h4>
+
+<p>
+	Returns a unique version of <em>list</em> 
+	with all duplicates removed.
+</p>
+
+<!-- example -->
+
+<pre>
+(unique '(2 3 4 4 6 7 8 7))  <span class='arw'>&rarr;</span> (2 3 4 6 7 8)
+</pre>
+
+
+<p>
+	Note that the list does not need to be sorted,
+	but a sorted list makes <tt>unique</tt> perform faster.
+</p>
+
+<p>
+	Other <em>set</em> functions are <a href="#difference">difference</a>,
+	<a href="#intersect">intersect</a> and <a href="#union">union</a>.
+</p>
+
+<br/><br/>
+
+<a name="unless"></a>
+<h2><span class="function">unless</span></h2>
+<h4>syntax: (unless <em>exp-condition</em> <em>body</em>)</h4>
+
+<p>The statements in <em>body</em> are only evaluated if <em>exp-condition</em>
+evaluates to <tt>nil</tt> or the empty list <tt>()</tt>. The result
+of the last expression in <em>body</em> is returned or <tt>nil</tt> or the empty
+list <tt>()</tt> if <em>body</em> was not executed.</p>
+
+<p>Because <tt>unless</tt> does not have an <em>else</em> condition as in
+<a href="#if">if</a>, <!-- or <a href="#if-not">if-not</a> -->the statements in <em>body</em> need 
+not to be grouped with <a href="#begin">begin</a>:</p>
+
+<pre>
+(unless (starts-with (read-line) "quit")
+	(process (current-line))
+	...
+	(finish)
+)	
+</pre>
+
+<p>See also the function <a href="#when">when</a>.</p>
+
+<br/><br/>
+
+<a name="unpack"></a> 
+
+<h2><span class="function">unpack</span>&nbsp;
+<a href="#shared-lib"><font size="+2">&#x26A0;</font></a></h2> 
+
+<h4>syntax: (unpack <em>str-format</em> <em>str-addr-packed</em>)<br/>
+syntax: (unpack <em>str-format</em> <em>num-addr-packed</em>)<br/><br/>
+syntax: (unpack <em>struct</em> <em>num-addr-packed</em>)<br/> 
+syntax: (unpack <em>struct</em> <em>str-addr-packed</em>)</h4> 
+
+<p>When the first parameter is a string, <tt>unpack</tt> unpacks a binary structure 
+in <em>str-addr-packed</em> or pointed to by <em>num-addr-packed</em> into newLISP 
+variables using the format in <em>str-format</em>. <tt>unpack</tt> is the reverse 
+operation of <tt>pack</tt>.  Using <em>num-addr-packed</em> facilitates the unpacking 
+of structures returned from imported, shared library functions.</p>
+
+<p>If the number specified in <em>num-addr-packed</em> is not a valid memory 
+address, a system bus error or segfault can occur and crash newLISP or leave 
+it in an unstable state.</p>
+
+<p>When the first parameter is the symbol of a <a href="#struct">struct</a> definition, 
+<tt>unpack</tt> uses the format as specified in <em>struct</em>. 
+While <tt>unpack</tt> with <em>str-format</em> literally unpacks as specified,
+<tt>unpack</tt> with <em>struct</em> will skip structure aligning pad-bytes
+depending on data type, order of elements and CPU architecture.
+Refer to the description of the <a href="#struct">struct</a> function for more detail.</p>
+
+<p>When unpacking structures containing <tt>NULL</tt> pointers, an error will be
+thrown when <tt>unpack</tt> tries to convert the pointer to a string. If <tt>NULL</tt>
+pointers are to be expected, <tt>void*</tt> should be used in the structure definition.</p>
+
+<p>The following characters may define a format:</p>
+ 
+<table width="98%" summary="format chracters in pack">
+
+<tr align="left" valign="bottom"><th>format</th><th>description</th></tr>
+
+<tr>
+<td><tt>c </tt></td>
+<td>a signed 8-bit number</td>
+</tr>
+
+<tr>
+<td><tt>b </tt></td>
+<td>an unsigned 8-bit number</td>
+</tr>
+
+<tr>
+<td><tt>d </tt></td>
+<td>a signed 16-bit short number</td>
+</tr>
+
+<tr>
+<td><tt>u </tt></td>
+<td>an unsigned 16-bit short number</td>
+</tr>
+
+<tr>
+<td><tt>ld</tt></td>
+<td>a signed 32-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>lu</tt></td>
+<td>an unsigned 32-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>Ld</tt></td>
+<td>a signed 64-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>Lu</tt></td>
+<td>an unsigned 64-bit long number</td>
+</tr>
+
+<tr>
+<td><tt>f </tt></td>
+<td>a float in 32-bit representation</td>
+
+</tr>
+
+<tr>
+<td><tt>lf</tt></td>
+<td>a double float in 64-bit representation</td>
+</tr>
+
+<tr>
+<td><tt>sn</tt></td>
+<td>a string of <em>n</em> null padded ASCII characters</td>
+</tr>
+
+<tr>
+
+<td><tt>nn</tt></td>
+<td><em>n</em> null characters</td>
+</tr>
+
+<tr>
+<td><tt>&gt;</tt></td>
+<td>switches to big endian byte order</td>
+</tr>
+
+<tr>
+<td><tt>&lt;</tt></td>
+<td>switches to little endian byte order</td>
+</tr>
+
+</table><br/>
+
+<br/>
+<!-- example -->
+
+<pre>
+(pack "c c c" 65 66 67)  <span class='arw'>&rarr;</span> "ABC"
+(unpack "c c c" "ABC")   <span class='arw'>&rarr;</span> (65 66 67)
+
+(set 's (pack "c d u" 10 12345 56789))
+(unpack "c d u" s)  <span class='arw'>&rarr;</span> (10 12345 56789)
+
+(set 's (pack "s10 f" "result" 1.23))
+(unpack "s10 f" s)  <span class='arw'>&rarr;</span> ("result\000\000\000\000" 1.230000019)
+
+(set 's (pack "s3 lf" "result" 1.23))
+(unpack "s3 f" s)  <span class='arw'>&rarr;</span> ("res" 1.23)
+
+(set 's (pack "c n7 c" 11 22))
+(unpack "c n7 c" s)  <span class='arw'>&rarr;</span> (11 22))
+</pre>
+
+
+<p>
+	The <tt>&gt;</tt> and <tt>&lt;</tt> specifiers 
+	can be used to switch between 
+	<em>little endian</em> and <em>big endian</em> byte order 
+	when packing or unpacking:
+</p>
+
+
+
+<pre>
+;; on a little endian system (e.g., Intel CPUs)
+(set 'buff (pack "d" 1))  <span class='arw'>&rarr;</span> "\001\000" 
+
+(unpack "d" buff)   <span class='arw'>&rarr;</span> (1)
+(unpack "&gt;d" buff)  <span class='arw'>&rarr;</span> (256)
+</pre>
+
+
+
+<p>
+	Switching the byte order 
+	will affect all number formats 
+	with 16-, 32-, or 64-bit sizes.
+</p>
+
+
+<p>
+	The <tt>pack</tt> and <tt>unpack</tt> format 
+	need not be the same,
+	as in the following example:
+</p>
+
+
+<pre>
+(set 's (pack "s3" "ABC"))
+(unpack "c c c" s)  <span class='arw'>&rarr;</span> (65 66 67)
+</pre>
+
+
+<p>
+	The examples show spaces between the format specifiers.
+	Although not required, they can improve readability.
+</p>
+
+<p>
+If the buffer's size at a memory address 
+is smaller than the formatting string specifies, 
+some formatting characters may be left unused.</p>
+
+<p>
+	See also the <a href="#address">address</a>,
+	<a href="#get-int">get-int</a>,
+	<a href="#get-long">get-long</a>,
+	<a href="#get-char">get-char</a>,
+	<a href="#get-string">get-string</a>, 
+	and <a href="#pack">pack</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="until"></a>
+<h2><span class="function">until</span></h2>
+<h4>syntax: (until <em>exp-condition</em> [<em>body</em>])</h4>
+
+<p> Evaluates the condition in <em>exp-condition</em>.
+If the result is <tt>nil</tt> or the empty list <tt>()</tt>, 
+the expressions in <em>body</em> are evaluated.
+Evaluation is repeated until the exp-condition results in a value 
+other than <tt>nil</tt> or the empty list.
+The result of the last expression evaluated in <em>body</em>
+is the return value of the <tt>until</tt> expression. If
+<em>body</em> is empty, the result of last <em>exp-condition</em>
+is returned. <tt>until</tt> works like 
+(<a href="#while">while</a> (<a href="#not">not</a> &hellip;)).
+</p>
+
+<p><tt>until</tt> also updates the system iterator symbol <tt>$idx</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(device (open "somefile.txt" "read"))
+(set 'line-count 0)
+(until (not (read-line)) (inc line-count))
+(close (device))
+(print "the file has " line-count " lines\n")
+</pre>
+
+
+<p>
+	Use the <a href="#do-until">do-until</a> function 
+	to test the condition <em>after</em> evaluation 
+	of the body expressions.
+</p>
+
+<br/><br/>
+
+<a name="upper-case"></a>
+<h2><span class="function">upper-case</span>&nbsp;<font size="-1"><a href="#utf8_capable">utf8</a></font></h2>
+<h4>syntax: (upper-case <em>str</em>)</h4>
+
+<p>Returns a copy of the string in <em>str</em> converted to uppercase.
+International characters are converted correctly.</p>
+
+<!-- example -->
+
+<pre>
+(upper-case "hello world")  <span class='arw'>&rarr;</span> "HELLO WORLD"
+</pre>
+
+
+<p>
+	See also the <a href="#lower-case">lower-case</a> 
+	and <a href="#title-case">title-case</a> functions.
+</p>
+
+<br/><br/>
+
+<a name="utf8"></a>
+<h2><span class="function">utf8</span></h2>
+<h4>syntax: (utf8 <em>str-unicode</em>)</h4>
+
+<p>Converts a UCS-4, 4-byte, Unicode-encoded string (<em>str</em>)
+into UTF-8.  This function is only available on UTF-8&ndash;enabled 
+versions of newLISP.</p>
+
+<!-- example -->
+
+<pre>
+(unicode "new") 
+<span class='arw'>&rarr;</span> "n\000\000\000e\000\000\000w\000\000\000\000\000\000\000"
+
+(utf8 (unicode "new"))  <span class='arw'>&rarr;</span> "new"
+</pre>
+
+
+<p>The <tt>utf8</tt> function can also be used 
+to test for the presence of UTF-8&ndash;enabled newLISP:</p>
+
+
+<pre>
+(if utf8 (do-utf8-version-of-code) (do-ascii-version-of-code))
+</pre>
+
+
+<p>
+On <em>big endian</em> CPU architectures, the byte order will be reversed 
+from highest to lowest. The <tt>utf8</tt> and <a href="#unicode">unicode</a> 
+functions are the inverse of each other. These functions are only necessary 
+if UCS-4 Unicode is in use. Most systems use UTF-8 Unicode encoding only.
+</p>
+
+<br/><br/>
+
+<a name="utf8len"></a>
+<h2><span class="function">utf8len</span></h2>
+<h4>syntax: (utf8len <em>str</em>)</h4>
+
+<p>Returns the number of characters in a UTF-8&ndash;encoded string. 
+UTF-8 characters can be encoded in more than one 8-bit byte. 
+<tt>utf8len</tt> returns the number of UTF-8 characters in a string. 
+This function is only available on UTF-8&ndash;enabled versions of newLISP.</p>
+
+<!-- example -->
+
+<pre>
+(utf8len "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚")    <span class='arw'>&rarr;</span> 12
+(length "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚")      <span class='arw'>&rarr;</span> 36
+</pre>
+
+
+<p>See also the <a href="#unicode">unicode</a> and <a href="#utf8">utf8</a> functions.
+Above Chinese text from <a href="http://www.columbia.edu/kermit/utf8.html">UTF-8 Sampler</a>.</p>
+
+<br/><br/>
+
+<a name="uuid"></a>
+<h2><span class="function">uuid</span></h2>
+<h4>syntax: (uuid [<em>str-node</em>])</h4>
+
+<p>
+	Constructs and returns
+	a UUID (Universally Unique IDentifier).
+	Without a node spec in <em>str-node</em>, 
+	a type 4 UUID random generated byte number 
+	is returned.
+	When the optional <em>str-node</em> parameter is used, 
+	a type 1 UUID is returned.
+	The string in <em>str-node</em> 
+	specifies a valid MAC (Media Access Code) 
+	from a network adapter installed on the node
+	or a random node ID.
+	When a random node ID is specified,
+	the least significant bit of the first node byte 
+	should be set to 1 
+	to avoid clashes with real MAC identifiers.
+	UUIDs of type 1 with node ID 
+	are generated from a timestamp and other data.
+	See <a href="http://www.ietf.org/rfc/rfc4122.txt">RFC 4122</a> 
+	for details on UUID generation.
+</p>
+
+<!-- example -->
+
+<pre>
+;; type 4 UUID for any system
+
+(uuid)  <span class='arw'>&rarr;</span> "493AAD61-266F-48A9-B99A-33941BEE3607"
+
+;; type 1 UUID preferred for distributed systems
+
+;; configure node ID for ether 00:14:51:0a:e0:bc
+(set 'id (pack "cccccc" 0x00 0x14 0x51 0x0a 0xe0 0xbc))
+
+(uuid  id)  <span class='arw'>&rarr;</span> "0749161C-2EC2-11DB-BBB2-0014510AE0BC"
+</pre>
+
+
+<p>
+	Each invocation of the <tt>uuid</tt> function 
+	will yield a new unique UUID.
+	The UUIDs are generated without system-wide 
+	shared stable store (see RFC 4122).
+	If the system generating the UUIDs 
+	is distributed over several nodes, 
+	then type 1 generation should be used 
+	with a different node ID on each node.
+	For several processes on the same node, 
+	valid UUIDs are guaranteed 
+	even if requested at the same time.
+	This is because the process ID 
+	of the generating newLISP process 
+	is part of the seed 
+	for the random number generator.
+	When type 4 IDs are used on a distributed system, 
+	two identical UUID's are still highly unlikely 
+	and impossible for type 1 IDs 
+	if real MAC addresses are used.
+</p>
+
+<br/><br/>
+
+<a name="wait-pid"></a>
+<h2><span class="function">wait-pid</span></h2>
+<h4>syntax: (wait-pid <em>int-pid</em> [<em>int-options</em> | <tt>nil</tt>])</h4>
+
+<p>
+Waits for a child process specified in <em>int-pid</em> to end.  The child process was 
+previously started with <a href="#process">process</a> or <a href="#fork">fork</a>.
+When the child process specified in <em>int-pid</em> ends, a list of pid and status value is 
+returned.  The status value describes the reason for termination of the child process.
+The interpretation of the returned status value differs between Linux and other flavors 
+of Unix.  Consult the Linux/Unix man pages for the <tt>waitpid</tt> command (without the hyphen 
+used in newLISP) for further information.
+</p>
+
+<p>
+When <tt>-1</tt> is specified for <em>int-pid</em>, 
+pid and  status information of any child process started by the parent are returned.
+When <tt>0</tt> is specified, <tt>wait-pid</tt> only watches child processes in the 
+same process group as the calling process.  Any other negative value for <em>int-pid</em> 
+reports child processes in the same process group as specified with a negative sign 
+in <em>int-pid</em>.
+</p>
+
+<p>
+An option can be specified in <em>int-option</em>.  See Linux/Unix documentation 
+for details on integer values for <em>int-options</em>. As an alternative, <tt>nil</tt>
+can be specified. This option causes <tt>wait-pid</tt> to be non-blocking, returning 
+right away with a <tt>0</tt> in the pid of the list returned. This option used together with
+ an <em>int-pid</em> parameter of <tt>-1</tt> can be used to continuously loop and act 
+on returned child processes.</p>
+
+<p>
+This function is only available on Mac OS X, Linux and other Unix-like operating systems.
+</p>
+
+<!-- example -->
+<pre>
+(set 'pid (fork (my-process))) <span class='arw'>&rarr;</span> 8596
+
+(set 'ret (wait-pid pid))  <span class='arw'>&rarr;</span> (8596 0) ; child has exited
+
+(println "process: " pid " has finished with status: " (last ret))
+</pre>
+
+<p>
+	The process <tt>my-process</tt> is started, 
+	then the main program blocks 
+	in the <tt>wait-pid</tt> call 
+	until <tt>my-process</tt> has finished.
+</p>
+
+<br/><br/>
+
+<a name="when"></a>
+<h2><span class="function">when</span></h2>
+<h4>syntax: (when <em>exp-condition</em> <em>body</em>)</h4>
+
+<p>The statements in <em>body</em> are only evaluated if <em>exp-condition</em>
+evaluates to anything not <tt>nil</tt> and not the empty list <tt>()</tt>. The result
+of the last expression in <em>body</em> is returned or <tt>nil</tt> or the empty
+list <tt>()</tt> if <em>body</em> was not executed.</p>
+
+<p>Because <tt>when</tt> does not have an <em>else</em> condition as in
+<a href="#if">if</a>, the statements in <em>body</em> need not to be grouped with
+<a href="#begin">begin</a>:</p>
+
+<!-- example -->
+<pre>
+(when (read-line)
+	(set 'result (analyze (current-line)))
+	(report result)
+	(finish)
+)	
+</pre>
+
+<p>See also the function <a href="#unless">unless</a> working like 
+<tt>(when (not ...) ...)</tt>.</p>
+
+<br/><br/>
+
+<a name="while"></a>
+<h2><span class="function">while</span></h2>
+<h4>syntax: (while <em>exp-condition</em> <em>body</em>)</h4>
+
+<p> Evaluates the condition in <em>exp-condition</em>.
+If the result is not <tt>nil</tt> or the empty list <tt>()</tt>, 
+the expressions in <em>body</em> are evaluated.
+Evaluation is repeated until an <em>exp-condition</em> results 
+in <tt>nil</tt> or the empty list <tt>()</tt>.
+The result of the body's last evaluated expression
+is the return value of the <tt>while</tt> expression.
+</p>
+
+<p><tt>while</tt> also updates the system iterator symbol <tt>$idx</tt>.</p>
+
+<!-- example -->
+
+<pre>
+(device (open "somefile.txt" "read"))
+(set 'line-count 0)
+(while (read-line) (inc line-count))
+(close (device))
+(print "the file has " line-count " lines\n")
+</pre>
+
+
+<p>
+Use the <a href="#do-while">do-while</a> function to evaluate the condition 
+<em>after</em> evaluating the body of expressions.
+</p>
+
+<br/><br/>
+
+<a name="write-buffer"></a>
+<a name="write"></a>
+
+<h2><span class="function">write</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (write)<br/>
+syntax: (write <em>int-file</em> <em>str-buffer</em> [<em>int-size</em>])<br/>
+syntax: (write <em>str</em> <em>str-buffer</em> [<em>int-size</em>])</h4>
+
+
+<p>In the second syntax <tt>write</tt> writes <em>int-size</em> bytes 
+from a buffer in <em>str-buffer</em> to a file specified in <em>int-file</em>, 
+previously obtained from a file <tt>open</tt> operation. If <em>int-size</em> 
+is not specified, all data in <em>sym-buffer</em> or <em>str-buffer</em> is written.
+<tt>write</tt> returns the number of bytes written or <tt>nil</tt> on failure.</p>
+
+<p>If all parameters are omitted, <tt>write</tt> writes the contents from the
+last <a href="#read-line">read-line</a> to standard out (STDOUT).</p>
+
+<p><tt>write</tt> is a shorter writing of <tt>write-buffer</tt>. The longer
+form still works but is deprecated and should be avoided in new code.</p>
+
+<!-- example -->
+
+<pre>
+(set 'handle (open "myfile.ext" "write"))
+(write handle data 100)   
+(write handle "a quick message\n")
+</pre>
+
+<p>The code in the example writes 100 bytes to the file <tt>myfile.ext</tt> 
+from the contents in <tt>data</tt>.</p>
+
+<p>In the third syntax, <tt>write</tt> can be used for destructive
+string appending:</p>
+
+<pre>
+(set 'str "")
+(write str "hello world")
+
+str   <span class='arw'>&rarr;</span> "hello world"
+</pre>
+
+<p>See also the <a href="#read">read</a> function.</p>
+
+<br/><br/>
+
+<a name="write-char"></a>
+<h2><span class="function">write-char</span></h2>
+<h4>syntax: (write-char <em>int-file</em> <em>int-byte1</em> [<em>int-byte2</em> ... ])</h4>
+
+<p>
+Writes a byte specified in <em>int-byte</em> to a file specified by the file 
+handle in <em>int-file</em>. The file handle is obtained from a previous 
+<tt>open</tt> operation. Each <tt>write-char</tt> advances the file pointer 
+by one 8-bit byte.</p>
+
+<p><tt>write-char</tt> returns the number of bytes written.</p>
+
+<!-- example -->
+
+<pre>
+(define (slow-file-copy from-file to-file)
+    (set 'in-file (open from-file "read"))
+    (set 'out-file (open to-file "write"))
+    (while (set 'chr (read-char in-file))
+        (write-char out-file chr))
+     (close in-file)
+    (close out-file)
+    "finished")
+</pre>
+
+
+<p>
+Use the <a href="#print">print</a> 
+and <a href="#device">device</a> functions 
+to write larger portions of data at a time.
+Note that newLISP already supplies a faster 
+built-in function called 
+<a href="#copy-file">copy-file</a>.
+</p>
+
+<p>
+	See also the <a href="#read-char">read-char</a> function.
+</p>
+
+<br/><br/>
+
+<a name="write-file"></a>
+<h2><span class="function">write-file</span></h2>
+<h4>syntax: (write-file <em>str-file-name</em> <em>str-buffer</em>)</h4>
+
+<p>Writes a file in <em>str-file-name</em> with contents in <em>str-buffer</em> 
+in one swoop and returns the number of bytes written.</p>
+
+<p>On failure the function returns <tt>nil</tt>. For error information, 
+use <a href="#sys-error">sys-error</a> when used on files. When used
+on URLs <a href="#net-error">net-error</a> gives more error
+information.</p>
+
+<!-- example -->
+
+<pre>
+(write-file "myfile.enc"
+    (encrypt (read-file "/home/lisp/myFile") "secret"))
+</pre>
+
+
+<p>The file <tt>myfile</tt> is read, <a href="#encrypt">encrypted</a> using the 
+password <tt>secret</tt>, and written back into the new file <tt>myfile.enc</tt>
+in the current directory.</p>
+
+<p>
+<tt>write-file</tt> can take an <tt>http://</tt> or <tt>file://</tt> URL 
+in <em>str-file-name</em>. When the prefix <tt>http://</tt> is used, 
+<tt>write-file</tt> works exactly like <a href="#put-url">put-url</a> 
+and can take the same additional parameters:</p>
+
+<!-- example -->
+
+<pre>
+(write-file "http://asite.com/message.txt" "This is a message" )
+</pre>
+
+
+<p>The file <tt>message.txt</tt> is created and written at a remote location, 
+<tt>http://asite.com</tt>, with the contents of <em>str-buffer</em>.
+In this mode, <tt>write-file</tt> can also be used to transfer files 
+to remote newLISP server nodes.</p>
+
+<p>See also the <a href="#append-file">append-file</a> 
+and <a href="#read-file">read-file</a> functions.</p>
+
+<br/><br/>
+
+<a name="write-line"></a>
+<h2><span class="function">write-line</span>&nbsp;<a href="#destructive">!</a></h2>
+<h4>syntax: (write-line [<em>int-file</em> [<em>str</em>]])<br/>
+syntax: (write-line <em>str-out</em> [<em>str</em>]])</h4>
+
+<p>The string in <em>str</em> and the line termination character(s) 
+are written to the device specified in <em>int-file</em>.
+When the string argument is omitted <tt>write-line</tt> writes the 
+contents of the last <a href="#read-line">read-line</a> to <em>int-file</em>
+If the first argument is omitted too then it writes to  to standard out 
+(STDOUT) or to whatever device is set by <a href="#device">device</a>.</p> 
+
+<p>In the second syntax lines are appended to a string in <em>str-out</em>.</p>
+
+<p><tt>write-line</tt> returns the number of bytes written.</p>
+
+<!-- example -->
+
+<pre>
+(set 'out-file (open "myfile" "write"))
+(write-line out-file "hello there")
+(close out-file)
+
+(set 'myFile (open "init.lsp" "read")
+(while (read-line myFile) (write-line))
+
+(set 'str "")
+(write-line str "hello")
+(write-line str "world")
+
+str  <span class='arw'>&rarr;</span>  "hello\nworld\n"
+</pre>
+
+
+<p>
+The first example opens/creates a file, writes a line to it, 
+and closes the file. The second example shows the usage of <tt>write-line</tt> 
+without arguments. The contents of <tt>init.lsp</tt> are written to the console 
+screen.</p>
+
+<p>See also the function <a href="#write">write</a> for writing
+to a device without the line-terminating character.</p>
+
+<br/><br/>
+
+<a name="xfer-event"></a>
+<h2><span class="function">xfer-event</span></h2>
+<h4>syntax: (xfer-event <em>sym-event-handler</em> | <em>func-event-handler</em>)
+syntax: (xfer-event nil)</h4>
+
+<p>Registers a function in symbol <em>sym-event-handler</em> or in lambda function 
+<em>func-event-handler</em>
+to monitor HTTP byte transfers initiated by <a href="#get-url">get-url</a>,
+<a href="#post-url">post-url</a> or <a href="#put-url">put-url</a> or initiated
+by file functions which can take URLs like <a href="#load">load</a>,
+<a href="#save">save</a>, <a href="#read-file">read-file</a>,
+<a href="#write-file">write-file</a> and <a href="#append-file">append-file</a>.
+</p>
+
+<p>E.g. whenever a block of data requested with <a href="#get-url">get-url</a>
+arrives, the function in <em>sym</em> or <em>func</em> will be called with
+the number of bytes transferred. Likewise when sending data with
+<a href="#post-url">post-url</a> or any of the other data sending 
+functions, <em>sym</em> or <em>func</em> will be called with the number of
+bytes transferred for each block of data transferred.</p>
+
+<p>Specifying <tt>nil</tt> for the event will reset it to the initial default state.</p>
+
+<!-- example -->
+
+<pre>
+(xfer-event (fn (n) (println "-&gt;" n)))
+(length (get-url "http://newlisp.org"))
+<b>
+-&gt;73
+-&gt;799
+-&gt;1452
+-&gt;351
+-&gt;1093
+-&gt;352
+-&gt;211
+-&gt;885
+-&gt;564
+-&gt;884
+-&gt;561
+-&gt;75
+-&gt;812
+-&gt;638
+-&gt;1452
+-&gt;801
+-&gt;5
+-&gt;927
+11935
+</b>
+</pre>
+
+
+<p>The computer output is shown in bold. Whenever a block of data is received
+its byte size is printed. Instead of defining the handler
+function directory with a lambda function in <em>func</em>, a symbol
+containing a function definition could have been used:</p>
+
+
+<pre>
+(define (report n) (println "-&gt;" n))
+(xfer-event 'report)
+</pre>
+
+
+<p> This can be used to monitor the progress of longer
+lasting byte transfers in HTTP uploads or downloads.</p>
+
+<br/><br/>
+
+<a name="xml-error"></a>
+<h2><span class="function">xml-error</span></h2>
+<h4>syntax: (xml-error)</h4>
+
+<p>
+	Returns a list of error information 
+	from the last <a href="#xml-parse">xml-parse</a> operation; 
+	otherwise, returns <tt>nil</tt>
+	if no error occurred.
+	The first element contains text 
+	describing the error, 
+	and the second element is a number indicating 
+	the last scan position in the source XML text, 
+	starting at <tt>0</tt> (zero).
+</p>
+
+<!-- example -->
+
+<pre>
+(xml-parse "&lt;atag&gt;hello&lt;/atag&gt;&lt;fin")  <span class='arw'>&rarr;</span> nil
+
+(xml-error)  <span class='arw'>&rarr;</span> ("expected closing tag: &gt;" 18)
+</pre>
+
+<br/><br/>
+
+<a name="xml-parse"></a>
+<h2><span class="function">xml-parse</span></h2>
+<h4>syntax: (xml-parse <em>string-xml</em> [<em>int-options</em> [<em>sym-context</em> [<em>func-callback</em>]]])</h4>
+
+<p>
+Parses a string containing XML 1.0 compliant, <em>well-formed</em> XML.
+<tt>xml-parse</tt> does not perform DTD validation. 
+It skips DTDs (Document Type Declarations) and processing instructions.
+Nodes of type ELEMENT, TEXT, CDATA, and COMMENT are parsed, and 
+a newLISP list structure is returned.  When an element node does not have 
+attributes or child nodes, it instead contains an empty list.
+Attributes are returned as association lists, 
+which can be accessed using <a href="#assoc">assoc</a>.
+When <tt>xml-parse</tt> fails due to malformed XML, <tt>nil</tt> is returned 
+and <a href="#xml-error">xml-error</a> can be used to access error information.
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'xml 
+  "&lt;person name='John Doe' tel='555-1212'&gt;nice guy&lt;/person&gt;")
+
+(xml-parse xml) 
+<span class='arw'>&rarr;</span> (("ELEMENT" "person" 
+    (("name" "John Doe") 
+     ("tel" "555-1212"))
+    (("TEXT" "nice guy"))))
+</pre>
+
+
+<h3>Modifying the translation process.</h3>
+<p>
+Optionally, the <em>int-options</em> parameter can be specified 
+to suppress whitespace, empty attribute lists, and comments.
+It can also be used to transform tags from strings into symbols.
+Another function, <a href="#xml-type-tags">xml-type-tags</a>, 
+serves for translating the XML tags.
+The following option numbers can be used:
+</p>
+
+<table  summary="option numbers for xml-parse">
+<tr align="left" valign="bottom"><th>option</th><th>description</th></tr>
+<tr><td>1</td><td>suppress whitespace text tags</td></tr>
+<tr><td>2</td><td>suppress empty attribute lists</td></tr>
+<tr><td>4</td><td>suppress comment tags</td></tr>
+<tr><td>8</td><td>translate string tags into symbols</td></tr>
+
+<tr><td>16</td><td>add SXML (S-expression XML) attribute tags (@ ...)</td></tr>
+</table><br/>
+
+<p>
+Options can be combined by adding the numbers
+(e.g., <tt>3</tt> would combine the options 
+for suppressing whitespace text tags/info 
+and empty attribute lists).
+</p>
+ 
+<p>
+The following examples show how the different options can be used:
+</p>
+<br/>
+<b>XML source:</b>
+
+
+<pre>
+&lt;?xml version="1.0" ?&gt;
+&lt;DATABASE name="example.xml"&gt;
+&lt;!--This is a database of fruits--&gt;
+    &lt;FRUIT&gt;
+        &lt;NAME&gt;apple&lt;/NAME&gt;
+        &lt;COLOR&gt;red&lt;/COLOR&gt;
+        &lt;PRICE&gt;0.80&lt;/PRICE&gt;
+    &lt;/FRUIT&gt;
+
+    &lt;FRUIT&gt;
+        &lt;NAME&gt;orange&lt;/NAME&gt;
+        &lt;COLOR&gt;orange&lt;/COLOR&gt;
+        &lt;PRICE&gt;1.00&lt;/PRICE&gt;
+    &lt;/FRUIT&gt;
+
+    &lt;FRUIT&gt;
+       &lt;NAME&gt;banana&lt;/NAME&gt;
+       &lt;COLOR&gt;yellow&lt;/COLOR&gt;
+       &lt;PRICE&gt;0.60&lt;/PRICE&gt;
+    &lt;/FRUIT&gt;
+&lt;/DATABASE&gt;
+</pre>
+
+
+<h3>Parsing without any options:</h3>
+
+
+<pre>
+(xml-parse (read-file "example.xml"))
+<span class='arw'>&rarr;</span> (("ELEMENT" "DATABASE" (("name" "example.xml")) (("TEXT" "\r\n\t") 
+    ("COMMENT" "This is a database of fruits") 
+    ("TEXT" "\r\n\t") 
+    ("ELEMENT" "FRUIT" () (("TEXT" "\r\n\t\t") ("ELEMENT" "NAME" () 
+       (("TEXT" "apple"))) 
+      ("TEXT" "\r\n\t\t") 
+      ("ELEMENT" "COLOR" () (("TEXT" "red"))) 
+      ("TEXT" "\r\n\t\t") 
+      ("ELEMENT" "PRICE" () (("TEXT" "0.80"))) 
+      ("TEXT" "\r\n\t"))) 
+    ("TEXT" "\r\n\r\n\t") 
+    ("ELEMENT" "FRUIT" () (("TEXT" "\r\n\t\t") ("ELEMENT" "NAME" () 
+       (("TEXT" "orange"))) 
+      ("TEXT" "\r\n\t\t") 
+      ("ELEMENT" "COLOR" () (("TEXT" "orange"))) 
+      ("TEXT" "\r\n\t\t") 
+      ("ELEMENT" "PRICE" () (("TEXT" "1.00"))) 
+      ("TEXT" "\r\n\t"))) 
+    ("TEXT" "\r\n\r\n\t") 
+    ("ELEMENT" "FRUIT" () (("TEXT" "\r\n\t\t") ("ELEMENT" "NAME" () 
+       (("TEXT" "banana"))) 
+      ("TEXT" "\r\n\t\t") 
+      ("ELEMENT" "COLOR" () (("TEXT" "yellow"))) 
+      ("TEXT" "\r\n\t\t") 
+      ("ELEMENT" "PRICE" () (("TEXT" "0.60"))) 
+      ("TEXT" "\r\n\t"))) 
+    ("TEXT" "\r\n"))))
+</pre>
+
+
+<p>
+The <tt>TEXT</tt> elements containing only whitespace make the output very confusing.
+As the database in <tt>example.xml</tt> only contains data,
+we can suppress whitespace, empty attribute lists and comments with 
+option <tt>(+ 1 2 4)</tt>:</p>
+
+<h3>Filtering whitespace TEXT, COMMENT tags, and empty attribute lists:</h3>
+
+
+<pre>
+(xml-parse (read-file "example.xml") (+ 1 2 4))
+<span class='arw'>&rarr;</span> (("ELEMENT" "DATABASE" (("name" "example.xml")) ( 
+     ("ELEMENT" "FRUIT" (
+       ("ELEMENT" "NAME" (("TEXT" "apple"))) 
+       ("ELEMENT" "COLOR" (("TEXT" "red"))) 
+       ("ELEMENT" "PRICE" (("TEXT" "0.80"))))) 
+     ("ELEMENT" "FRUIT" (
+       ("ELEMENT" "NAME" (("TEXT" "orange"))) 
+       ("ELEMENT" "COLOR" (("TEXT" "orange"))) 
+       ("ELEMENT" "PRICE" (("TEXT" "1.00"))))) 
+     ("ELEMENT" "FRUIT" (
+       ("ELEMENT" "NAME" (("TEXT" "banana"))) 
+       ("ELEMENT" "COLOR" (("TEXT" "yellow"))) 
+       ("ELEMENT" "PRICE" (("TEXT" "0.60"))))))))
+</pre>
+
+
+<p>
+The resulting output looks much more readable, but it can still be improved 
+by using symbols instead of strings for the tags "FRUIT", "NAME", "COLOR", and "PRICE",
+as well as by suppressing the XML type tags "ELEMENT" and "TEXT" completely 
+using the <a href="#xml-type-tags">xml-type-tags</a> directive.
+</p>
+
+<h3>Suppressing XML type tags with <a href="#xml-type-tags">xml-type-tags</a> 
+and translating string tags into symbol tags:</h3>
+
+
+<pre>
+;; suppress all XML type tags for TEXT and ELEMENT
+;; instead of "CDATA", use cdata and instead of "COMMENT", use !--
+
+(xml-type-tags nil 'cdata '!-- nil) 
+
+;; turn on all options for suppressing whitespace and empty
+;; attributes, translate tags to symbols
+
+(xml-parse (read-file "example.xml") (+ 1 2 8))
+<span class='arw'>&rarr;</span> ((DATABASE (("name" "example.xml")) 
+     (!-- "This is a database of fruits") 
+     (FRUIT (NAME "apple") (COLOR "red") (PRICE "0.80")) 
+     (FRUIT (NAME "orange") (COLOR "orange") (PRICE "1.00")) 
+     (FRUIT (NAME "banana") (COLOR "yellow") (PRICE "0.60"))))
+</pre>
+
+
+<p>
+When tags are translated into symbols by using option <tt>8</tt>, 
+a context can be specified in <em>sym-context</em>. 
+If no context is specified, all symbols will be created inside the current context.
+</p>
+
+
+<pre>
+(xml-type-tags nil nil nil nil)
+(xml-parse "&lt;msg&gt;Hello World&lt;/msg&gt;" (+ 1 2 4 8 16) 'CTX)
+<span class='arw'>&rarr;</span> ((CTX:msg "Hello World"))
+</pre>
+
+
+<p>
+Specifying <tt>nil</tt> for the XML type tags TEXT and ELEMENT 
+makes them disappear.  At the same time, 
+parentheses of the child node list are removed so that 
+child nodes now appear as members of the list, 
+starting with the tag symbol translated from the string tags 
+"FRUIT", "NAME", etcetera.
+</p>
+
+<h3>Parsing into SXML (S-expressions XML) format:</h3>
+<p>
+Using <a href="#xml-type-tags">xml-type-tags</a> to suppress 
+all XML-type tags&mdash;along with the option numbers 
+<tt>1</tt>, <tt>2</tt>, <tt>4</tt>, <tt>8</tt>, and <tt>16</tt>&mdash;SXML 
+formatted output can be generated:
+</p>
+
+
+<pre>
+(xml-type-tags nil nil nil nil)
+(xml-parse (read-file "example.xml") (+ 1 2 4 8 16))
+<span class='arw'>&rarr;</span> ((DATABASE (@ (name "example.xml")) 
+    (FRUIT (NAME "apple") (COLOR "red") (PRICE "0.80")) 
+    (FRUIT (NAME "orange") (COLOR "orange") (PRICE "1.00")) 
+    (FRUIT (NAME "banana") (COLOR "yellow") (PRICE "0.60"))))
+</pre>
+
+<p>If the original XML tags contain a namespace part separated by a <tt>:</tt>,
+that colon will be translated into a <tt>.</tt> dot in the resulting newLISP
+symbol.</p>
+
+
+<p>
+Note that using option number <tt>16</tt> 
+causes an <tt>@</tt> (at symbol) to be added to attribute lists.
+</p>
+
+<p>
+See also the <a href="#xml-type-tags">xml-type-tags</a> function 
+for further information on XML parsing.
+</p>
+
+<h3>Parsing into a specified context</h3>
+
+<p>When parsing XML expressions, XML tags are translated into newLISP symbols,
+when option 8 is specified.  The <i>sym-context</i> option specifies the target 
+context for the symbol creation:</p>
+
+<pre>
+(xml-type-tags nil nil nil nil)
+(xml-parse (read-file "example.xml") (+ 1 2 4 8 16) 'CTX)
+<span class='arw'>&rarr;</span>((CTX:DATABASE (@ (CTX:name "example.xml")) 
+    (CTX:FRUIT (CTX:NAME "apple") (CTX:COLOR "red") (CTX:PRICE "0.80")) 
+    (CTX:FRUIT (CTX:NAME "orange") (CTX:COLOR "orange") (CTX:PRICE "1.00")) 
+    (CTX:FRUIT (CTX:NAME "banana") (CTX:COLOR "yellow") (CTX:PRICE "0.60"))))
+</pre>
+
+<p>If the context does not exist, it will be created. If it exists, the quote can 
+be omitted or the context can be referred to by a variable.</p>
+
+<h3>Using a call back function</h3>
+<p>Normally, <tt>xml-parse</tt> will not return until all parsing has finished.
+Using the <em>func-callback</em> option, <tt>xml-parse</tt> will call back after
+each tag closing with the generated S-expression and a start position and
+length in the source XML:</p>
+
+
+<pre>
+;; demo callback feature
+(define (xml-callback s-expr start size)
+    (if (or (= (s-expr 0) 'NAME) (= (s-expr 0) 'COLOR) (= (s-expr 0) 'PRICE))
+        (begin
+            (print "parsed expression:" s-expr)
+            (println ", source:" (start size example-xml))
+        )
+    )
+)
+
+(xml-type-tags nil 'cdata '!-- nil)
+(xml-parse  (read-file "example.xml") (+ 1 2 8) MAIN xml-callback)
+</pre>
+
+
+<p>The following output will be generated by the callback function <tt>xml-callback</tt>:</p>
+
+<pre>
+parsed expression:(NAME "apple"), source:&lt;NAME&gt;apple&lt;/NAME&gt;
+parsed expression:(COLOR "red"), source:&lt;COLOR&gt;red&lt;/COLOR&gt;
+parsed expression:(PRICE "0.80"), source:&lt;PRICE&gt;0.80&lt;/PRICE&gt;
+parsed expression:(NAME "orange"), source:&lt;NAME&gt;orange&lt;/NAME&gt;
+parsed expression:(COLOR "orange"), source:&lt;COLOR&gt;orange&lt;/COLOR&gt;
+parsed expression:(PRICE "1.00"), source:&lt;PRICE&gt;1.00&lt;/PRICE&gt;
+parsed expression:(NAME "banana"), source:&lt;NAME&gt;banana&lt;/NAME&gt;
+parsed expression:(COLOR "yellow"), source:&lt;COLOR&gt;yellow&lt;/COLOR&gt;
+parsed expression:(PRICE "0.60"), source:&lt;PRICE&gt;0.60&lt;/PRICE&gt;
+</pre>
+
+
+<p>The example callback handler function filters the tags of interest and processes
+them as they occur.</p>
+
+<br/><br/>
+
+<a name="xml-type-tags"></a>
+<h2><span class="function">xml-type-tags</span></h2>
+
+<h4>syntax: (xml-type-tags [<em>exp-text-tag</em> <em>exp-cdata-tag</em> <em>exp-comment-tag</em> <em>exp-element-tags</em>])</h4>
+
+<p>
+Can suppress completely or replace the XML type tags 
+"TEXT", "CDATA", "COMMENT", and "ELEMENT" with something else specified 
+in the parameters.
+</p>
+
+<p>
+Note that <tt>xml-type-tags</tt> only suppresses or translates the tags themselves 
+but does not suppress or modify the tagged information.  The latter would be done 
+using option numbers in <a href="#xml-parse">xml-parse</a>.
+</p>
+
+<p>
+Using <tt>xml-type-tags</tt> without arguments 
+returns the current type tags:
+</p>
+
+<!-- example -->
+
+<pre>
+(xml-type-tags)  <span class='arw'>&rarr;</span> ("TEXT" "CDATA" "COMMENT" "ELEMENT")
+
+(xml-type-tags nil 'cdata '!-- nil)
+</pre>
+
+
+<p>
+The first example just shows the currently used type tags.
+The second example specifies suppression of the "TEXT" and "ELEMENT" tags 
+and shows <tt>cdata</tt> and <tt>!--</tt> instead of 
+"CDATA" and "COMMENT".
+</p>
+
+<br/><br/>
+
+<a name="zerop"></a>
+<h2><span class="function">zero?</span>&nbsp;
+<a href="#big_int"><font size="-1">bigint</font></a></h2>
+<h4>syntax: (zero? <em>exp</em>)</h4>
+
+<p>
+Checks the evaluation of <em>exp</em> to see if it equals <tt>0</tt> (zero).
+</p>
+
+<!-- example -->
+
+<pre>
+(set 'value 1.2)
+(set 'var 0)
+(zero? value)  <span class='arw'>&rarr;</span> nil
+(zero? var)    <span class='arw'>&rarr;</span> true
+
+(map zero? '(0 0.0 3.4 4))  <span class='arw'>&rarr;</span> (true true nil nil)
+
+(map zero? '(nil true 0 0.0 "" ()))  <span class='arw'>&rarr;</span> (nil nil true true nil nil)
+</pre>
+
+
+<p>
+	<tt>zero?</tt> will return <tt>nil</tt> 
+	on data types other than numbers.
+</p>
+
+<br/><br/>
+
+<center style="font-size: 150%">
+<span class="divider">(&nbsp;<font color="#7ba9d4">&part;</font>&nbsp;)</span>
+</center>
+
+<br/><br/>
+
+<hr/>
+
+<br/><br/>
+
+<a name="appendix"></a>
+<center><h2>newLISP APPENDIX</h2></center>
+
+<a name="error_codes"></a>
+<h2>Error codes</h2>
+
+<table summary="Error codes">
+<tr align="left"><th>description</th><th>no</th></tr>
+<tr><td>not enough memory</td><td>1</td></tr>
+<tr><td>environment stack overflow</td><td>2</td></tr>
+<tr><td>call stack overflow</td><td>3</td></tr>
+<tr><td>problem accessing file</td><td>4</td></tr>
+<tr><td>not an expression</td><td>5</td></tr>
+<tr><td>missing parenthesis</td><td>6</td></tr>
+<tr><td>string token too long</td><td>7</td></tr>
+<tr><td>missing argument</td><td>8</td></tr>
+<tr><td>number or string expected</td><td>9</td></tr>
+<tr><td>value expected</td><td>10</td></tr>
+<tr><td>string expected</td><td>11</td></tr>
+<tr><td>symbol expected</td><td>12</td></tr>
+<tr><td>context expected</td><td>13</td></tr>
+<tr><td>symbol or context expected</td><td>14</td></tr>
+<tr><td>list expected</td><td>15</td></tr>
+<tr><td>list or array expected</td><td>16</td></tr>
+<tr><td>list or symbol expected</td><td>17</td></tr>
+<tr><td>list or string expected</td><td>18</td></tr>
+<tr><td>list or number expected</td><td>19</td></tr>
+<tr><td>array expected</td><td>20</td></tr>
+<tr><td>array, list or string expected</td><td>21</td></tr>
+<tr><td>lambda expected</td><td>22</td></tr>
+<tr><td>lambda-macro expected</td><td>23</td></tr>
+<tr><td>invalid function</td><td>24</td></tr>
+<tr><td>invalid lambda expression</td><td>25</td></tr>
+<tr><td>invalid macro expression</td><td>26</td></tr>
+<tr><td>invalid let parameter list</td><td>27</td></tr>
+<tr><td>problem saving file</td><td>28</td></tr>
+<tr><td>division by zero</td><td>29</td></tr>
+<tr><td>matrix expected</td><td>30</td></tr>
+<tr><td>wrong dimensions</td><td>31</td></tr>
+<tr><td>matrix is singular</td><td>32</td></tr>
+<tr><td>syntax in regular expression</td><td>33</td></tr>
+<tr><td>throw without catch</td><td>34</td></tr>
+<tr><td>problem loading library</td><td>35</td></tr>
+<tr><td>import function not found</td><td>36</td></tr>
+<tr><td>symbol is protected</td><td>37</td></tr>
+<tr><td>error number too high</td><td>38</td></tr>
+<tr><td>regular expression</td><td>39</td></tr>
+<tr><td>missing end of text [/text]</td><td>40</td></tr>
+<tr><td>mismatch in number of arguments</td><td>41</td></tr>
+<tr><td>problem in format string</td><td>42</td></tr>
+<tr><td>data type and format don't match</td><td>43</td></tr>
+<tr><td>invalid parameter</td><td>44</td></tr>
+<tr><td>invalid parameter: 0.0</td><td>45</td></tr>
+<tr><td>invalid parameter: NaN</td><td>46</td></tr>
+<tr><td>invalid UTF8 string</td><td>47</td></tr>
+<tr><td>illegal parameter type</td><td>48</td></tr>
+<tr><td>symbol not in MAIN context</td><td>49</td></tr>
+<tr><td>symbol not in current context</td><td>50</td></tr>
+<tr><td>target cannot be MAIN</td><td>51</td></tr>
+<tr><td>list index out of bounds</td><td>52</td></tr>
+<tr><td>array index out of bounds</td><td>53</td></tr>
+<tr><td>string index out of bounds</td><td>54</td></tr>
+<tr><td>nesting level too deep</td><td>55</td></tr>
+<tr><td>list reference changed</td><td>56</td></tr>
+<tr><td>invalid syntax</td><td>57</td></tr>
+<tr><td>user error</td><td>58</td></tr>
+<tr><td>user reset -</td><td>59</td></tr>
+<tr><td>received SIGINT -</td><td>60</td></tr>
+<tr><td>function is not reentrant</td><td>61</td></tr>
+<tr><td>local symbol is protected</td><td>62</td></tr>
+<tr><td>no reference found</td><td>63</td></tr>
+<tr><td>list is empty</td><td>64</td></tr>
+<tr><td>I/O error</td><td>65</td></tr>
+<tr><td>working directory not found</td><td>66</td></tr>
+<tr><td>invalid PID</td><td>67</td></tr>
+<tr><td>cannot open socket pair</td><td>68</td></tr>
+<tr><td>cannot fork process</td><td>69</td></tr>
+<tr><td>no comm channel found</td><td>70</td></tr>
+
+<tr><td>ffi preparation failed</td><td>71</td></tr>
+<tr><td>invalid ffi type</td><td>72</td></tr>
+<tr><td>ffi struct expected</td><td>73</td></tr>
+
+<tr><td>bigint type not applicable</td><td>74</td></tr>
+<tr><td>not a number or infinite</td><td>75</td></tr>
+<tr><td>cannot convert NULL to string</td><td>76</td></tr>
+</table><br/>
+
+<br/><br/><br/>
+
+<a name="tcpip_error_codes"></a>
+<h2>TCP/IP and UDP Error Codes</h2>
+
+<table summary="tcp/ip error codes">
+<tr align="left"><th>no</th><th>description</th></tr>
+<tr><td>1</td><td>Cannot open socket</td></tr>
+<tr><td>2</td><td>DNS resolution failed</td></tr>
+<tr><td>3</td><td>Not a valid service</td></tr>
+<tr><td>4</td><td>Connection failed</td></tr>
+<tr><td>5</td><td>Accept failed</td></tr>
+<tr><td>6</td><td>Connection closed</td></tr>
+<tr><td>7</td><td>Connection broken</td></tr>
+<tr><td>8</td><td>Socket send() failed</td></tr>
+<tr><td>9</td><td>Socket recv() failed</td></tr>
+<tr><td>10</td><td>Cannot bind socket</td></tr>
+<tr><td>11</td><td>Too many sockets in net-select</td></tr>
+<tr><td>12</td><td>Listen failed</td></tr>
+<tr><td>13</td><td>Badly formed IP</td></tr>
+<tr><td>14</td><td>Select failed</td></tr>
+<tr><td>15</td><td>Peek failed</td></tr>
+<tr><td>16</td><td>Not a valid socket</td></tr>
+<tr><td>17</td><td>Cannot unblock socket</td></tr>
+<tr><td>18</td><td>Operation timed out</td></tr>
+<tr><td>19</td><td>HTTP bad formed URL</td></tr>
+<tr><td>20</td><td>HTTP file operation failed</td></tr>
+<tr><td>21</td><td>HTTP transfer failed</td></tr>
+<tr><td>22</td><td>HTTP invalid response from server</td></tr>
+<tr><td>23</td><td>HTTP no response from server</td></tr>
+<tr><td>24</td><td>HTTP document empty</td></tr>
+<tr><td>25</td><td>HTTP error in header</td></tr>
+<tr><td>26</td><td>HTTP error in chunked format</td></tr>
+</table><br/>
+
+<br/><br/><br/>
+
+<a name="system_symbols"></a>
+<h2>System Symbols and Constants</h2>
+
+<h3>Variables changed by the system</h3>
+
+<p>newLISP maintains several internal symbol variables. All of them are global
+and can be used by the programmer. Some have write protection, others
+are user settable. Some will change when used in a sub-expression of the
+enclosing expression using it. Others are safe when using reentrant in nested 
+functions or expressions.</p>
+
+<p>All symbols starting with the <tt>$</tt> character will not be serialized
+when using the <a href="#save">save</a> or <a href="#source">source</a> functions.
+</p>
+
+<table width="98%" summary="system vars">
+<tr><th>&nbsp;variable&nbsp;name</th><th>purpose</th><th>&nbsp;protected&nbsp;</th><th>&nbsp;reentrant&nbsp;</th></tr>
+<tr><td><tt>&nbsp;$0 - $15</tt></td><td>Used primarily in regular expressions. <tt>$0</tt>
+is also used to record the last state or count of execution of some functions.</td>
+<td>&nbsp;no</td><td>&nbsp;no</td></tr>
+
+<tr><td><tt>&nbsp;$args</tt></td><td>Contains the list parameters not bound to local
+variables. Normally the function <a href="#args">args</a> is used to retrieve
+the contents of this variable.</td><td>&nbsp;yes</td><td>&nbsp;yes</td></tr>
+
+<tr><td><tt>&nbsp;$count</tt></td><td>The count of elements matching when using
+<a href="#find-all">find-all</a>, <a href="#replace">replace</a>,
+<a href="#ref-all">ref-all</a> and <a href="#set-ref-all">set-ref-all</a> or the 
+count of characters processed by <a href="#read-expr">read-expr</a>.</td>
+<td>&nbsp;yes</td><td>&nbsp;no</td></tr>
+
+<tr><td><tt>&nbsp;$idx</tt></td><td>The function <a href="#dolist">dolist</a>
+maintains this as a list index or offset. The functions 
+<a href="#map">map</a>, <a href="#series">series</a>,
+<a href="#while">while</a>, <a href="#until">until</a>,
+<a href="#do-while">do-while</a> and <a href="#do-until">do-until</a>
+maintain this variable as an iteration counter starting with 0 (zero) for
+the first iteration.</td>
+<td>&nbsp;yes</td><td>&nbsp;yes</td></tr>
+
+<tr><td><tt>&nbsp;$it</tt></td><td>The <em>anaphoric</em> <tt>$it</tt> refers to the
+result inside an executing expression, i.e. in self referential assignments. 
+<tt>$it</tt> is only available inside the function expression setting it, and
+is set to <tt>nil</tt> on exit of that expression. The following functions use it:
+<a href="#if">if</a>,
+<a href="#hash">hashes</a>, <a href="#find-all">find-all</a>,
+<a href="#replace">replace</a>, <a href="#set-ref">set-ref</a>, 
+<a href="#set-ref-all">set-ref-all</a> and <a href="#setf">setf setq</a>.</td>
+<td>&nbsp;yes</td><td>&nbsp;no</td></tr>
+
+<tr><td><tt>&nbsp;$main-args</tt></td><td>Contains the list of command line arguments
+passed by the OS to newLISP when it was started. Normally the function
+<a href="#main-args">main-args</a> is used to retrieve the contents.</td>
+<td>&nbsp;yes</td><td>&nbsp;n/a</td></tr>
+
+</table><br/>
+
+<h3>Predefined variables and functions.</h3>
+
+<p>These are preset symbol constants. Two of them are used as namespace templates,
+one two write platform independent code.</p> 
+
+<table  width="98%" summary="preset vars">
+<tr><th>name</th><th>purpose</th><th>&nbsp;protected&nbsp;</th><th>&nbsp;reentrant&nbsp;</th></tr>
+
+<tr><td><tt>&nbsp;Class</tt></td><td>Is the predefined general FOOP class constructor
+which can be used together with <tt>new</tt> to create new FOOP classes, e.g:
+<tt>(new Class 'Rectangle)</tt> would create a class and object constructor for
+a user class <tt>Rectangle</tt>. See the 
+<a href="#newlisp_classes">FOOP classes and constructors</a> chapter in the users 
+manual for details.</td>
+<td>&nbsp;no</td><td>&nbsp;n/a</td></tr>
+
+<tr><td><tt>&nbsp;ostype</tt></td><td>Contains a string identifying the OS-Platform
+for which the running newLISP version has been compiled. See the reference section for 
+<a href="#ostype">details</a></td>
+<td>&nbsp;yes</td><td>&nbsp;n/a</td></tr>
+
+<tr><td><tt>&nbsp;Tree</tt></td><td>Is a predefined namespace to serve as a hash like
+dictionary. Instead of writing <tt>(define Foo:Foo)</tt> to create a <tt>Foo</tt>
+dictionary, the expression <tt>(new Tree 'Foo)</tt> can be used as well. See the chapter
+<a href="#hash">Hash functions and dictionaries</a> foe details.</td>
+<td>&nbsp;no</td><td>&nbsp;n/a</td></tr>
+
+<tr><td><tt>&nbsp;module</tt></td><td>Is a predefined function to load modules. 
+Instead of using <tt>load</tt> together with the <tt>NEWLISPDIR</tt> environment 
+variable, the <tt>module</tt> function loads automatically from 
+<tt>$NEWLISPDIR/modules/</tt>.</td>
+<td>&nbsp;no</td><td>&nbsp;n/a</td></tr>
+
+</table><br/>
+
+<p>The symbols <tt>Class</tt>, <tt>Tree</tt> and <tt>module</tt> are predefined as follows:</p>
+
+<pre>
+; built-in template for FOOP constructors
+; usage: (new Class 'MyClass)
+(define (Class:Class) 
+    (cons (context) (args)))
+
+; built-in template for hashes
+; usage: (new Tree 'MyHash)
+(context 'Tree) 
+  (constant 'Tree:Tree) 
+(context MAIN)"
+
+; load modules from standard path
+; usage (module "mymodule.lsp")
+(define (module $x)
+  (load (append (env "NEWLISPDIR") "/modules/" $x)))
+
+(global 'module)
+</pre>
+
+<p>These symbols are not protected and can be redefined by the user.
+The <tt>$x</tt> variable is built-in and protected against deletion.
+This <tt>$x</tt> variable is also used in <a href="#curry">curry</a> expressions.</p>
+
+<br/><br/>
+
+<center style="font-size: 150%">
+<span class="divider">(&nbsp;<font color="#7ba9d4">&part;</font>&nbsp;)</span>
+</center>
+<br/><br/>
+
+<hr/>
+
+
+<div class="license">
+<a name="GNUFDL"></a>
+<center>
+<h2><span class="gnu">GNU Free Documentation License</span></h2>
+<p>Version 1.2, November 2002</p>
+
+<p>
+Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
+59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+</p>
+</center>
+
+<br/><br/>
+
+<h4>0. PREAMBLE</h4>
+
+<p>The purpose of this License is to make a manual, textbook, or other
+functional and useful document "free" in the sense of freedom: to
+assure everyone the effective freedom to copy and redistribute it,
+with or without modifying it, either commercially or noncommercially.
+Secondarily, this License preserves for the author and publisher a way
+to get credit for their work, while not being considered responsible
+for modifications made by others.
+</p>
+<p>This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense. It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+</p>
+<p>We have designed this License in order to use it for manuals for
+free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does. But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book. We recommend this License
+principally for works whose purpose is instruction or reference.
+</p>
+<h4>1. APPLICABILITY AND DEFINITIONS</h4>
+<p>This License applies to any manual or other work, in any medium,
+that
+contains a notice placed by the copyright holder saying it can be
+distributed under the terms of this License. Such a notice grants a
+world-wide, royalty-free license, unlimited in duration, to use that
+work under the conditions stated herein. The "Document", below,
+refers to any such manual or work. Any member of the public is a
+licensee, and is addressed as "you". You accept the license if you
+copy, modify or distribute the work in a way requiring permission
+under copyright law.
+</p>
+<p>A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+</p>
+<p>A "Secondary Section" is a named appendix or a front-matter section
+of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject. (Thus, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.) The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+</p>
+<p>The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License. If a
+section does not fit the above definition of Secondary then it is not
+allowed to be designated as Invariant. The Document may contain zero
+Invariant Sections. If the Document does not identify any Invariant
+Sections then there are none.
+</p>
+<p>The "Cover Texts" are certain short passages of text that are
+listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License. A Front-Cover Text may
+be at most 5 words, and a Back-Cover Text may be at most 25 words.
+</p>
+<p>A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, that is suitable for revising the document
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters. A copy made in an otherwise Transparent file
+format whose markup, or absence of markup, has been arranged to thwart
+or discourage subsequent modification by readers is not Transparent.
+An image format is not Transparent if used for any substantial amount
+of text. A copy that is not "Transparent" is called "Opaque".
+</p>
+<p>Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML, PostScript or PDF designed for human modification. Examples of
+transparent image formats include PNG, XCF and JPG. Opaque formats
+include proprietary formats that can be read and edited only by
+proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML, PostScript or PDF produced by some word
+processors for output purposes only.
+</p>
+<p>The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page. For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+</p>
+<p>A section "Entitled XYZ" means a named subunit of the Document whose
+title either is precisely XYZ or contains XYZ in parentheses following
+text that translates XYZ in another language. (Here XYZ stands for a
+specific section name mentioned below, such as "Acknowledgements",
+"Dedications", "Endorsements", or "History".) To "Preserve the Title"
+of such a section when you modify the Document means that it remains a
+section "Entitled XYZ" according to this definition.
+</p>
+<p>The Document may include Warranty Disclaimers next to the notice
+which
+states that this License applies to the Document. These Warranty
+Disclaimers are considered to be included by reference in this
+License, but only as regards disclaiming warranties: any other
+implication that these Warranty Disclaimers may have is void and has
+no effect on the meaning of this License.
+</p>
+<h4>2. VERBATIM COPYING</h4>
+<p>You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License. You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute. However, you may accept
+compensation in exchange for copies. If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+</p>
+<p>You may also lend copies, under the same conditions stated above,
+and
+you may publicly display copies.
+</p>
+<h4>3. COPYING IN QUANTITY</h4>
+<p>If you publish printed copies (or copies in media that commonly have
+printed covers) of the Document, numbering more than 100, and the
+Document's license notice requires Cover Texts, you must enclose the
+copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover. Both covers must also clearly and legibly identify
+you as the publisher of these copies. The front cover must present
+the full title with all words of the title equally prominent and
+visible. You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+</p>
+<p>If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+</p>
+<p>If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a computer-network location from which the general network-using
+public has access to download using public-standard network protocols
+a complete Transparent copy of the Document, free of added material.
+If you use the latter option, you must take reasonably prudent steps,
+when you begin distribution of Opaque copies in quantity, to ensure
+that this Transparent copy will remain thus accessible at the stated
+location until at least one year after the last time you distribute an
+Opaque copy (directly or through your agents or retailers) of that
+edition to the public.
+</p>
+<p>It is requested, but not required, that you contact the authors of
+the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+</p>
+<h4>4. MODIFICATIONS</h4>
+<p>You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it. In addition, you must do these things in the Modified Version:
+</p>
+<blockquote>
+  <p><b>A.</b> Use in the Title Page (and on the covers, if
+any) a title distinct from that of the Document, and from those of
+previous versions (which should, if there were any, be listed in the
+History section of the Document). You may use the same title as a
+previous version if the original publisher of that version gives
+permission.</p>
+  <p><b>B.</b> List on the Title Page, as authors, one or
+more persons or entities responsible for authorship of the
+modifications in the Modified Version, together with at least five of
+the principal authors of the Document (all of its principal authors, if
+it has fewer than five), unless they release you from this requirement.</p>
+  <p><b>C.</b> State on the Title page the name of the
+publisher of the Modified Version, as the publisher.</p>
+  <p><b>D.</b> Preserve all the copyright notices of the
+Document.</p>
+  <p><b>E.</b> Add an appropriate copyright notice for your
+modifications adjacent to the other copyright notices.</p>
+  <p><b>F.</b> Include, immediately after the copyright
+notices, a license notice giving the public permission to use the
+Modified Version under the terms of this License, in the form shown in
+the Addendum below.</p>
+  <p><b>G.</b> Preserve in that license notice the full
+lists of Invariant Sections and required Cover Texts given in the
+Document's license notice.</p>
+  <p><b>H.</b> Include an unaltered copy of this License.</p>
+  <p><b>I.</b> Preserve the section Entitled "History",
+Preserve its Title, and add to it an item stating at least the title,
+year, new authors, and publisher of the Modified Version as given on
+the Title Page. If there is no section Entitled "History" in the
+Document, create one stating the title, year, authors, and publisher of
+the Document as given on its Title Page, then add an item describing
+the Modified Version as stated in the previous sentence.</p>
+  <p><b>J.</b> Preserve the network location, if any, given
+in the Document for public access to a Transparent copy of the
+Document, and likewise the network locations given in the Document for
+previous versions it was based on. These may be placed in the "History"
+section. You may omit a network location for a work that was published
+at least four years before the Document itself, or if the original
+publisher of the version it refers to gives permission.</p>
+  <p><b>K.</b> For any section Entitled "Acknowledgements"
+or "Dedications", Preserve the Title of the section, and preserve in
+the section all the substance and tone of each of the contributor
+acknowledgements and/or dedications given therein.</p>
+  <p><b>L.</b> Preserve all the Invariant Sections of the
+Document, unaltered in their text and in their titles. Section numbers
+or the equivalent are not considered part of the section titles.</p>
+  <p><b>M.</b> Delete any section Entitled "Endorsements".
+Such a section may not be included in the Modified Version.</p>
+  <p><b>N.</b> Do not retitle any existing section to be
+Entitled "Endorsements" or to conflict in title with any Invariant
+Section.</p>
+  <p><b>O.</b> Preserve any Warranty Disclaimers.</p>
+</blockquote>
+<p>
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant. To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+</p>
+<p>You may add a section Entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+</p>
+<p>You may add a passage of up to five words as a Front-Cover Text, and
+a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version. Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity. If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+</p>
+<p>The author(s) and publisher(s) of the Document do not by this
+License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+</p>
+<h4>5. COMBINING DOCUMENTS</h4>
+<p>You may combine the Document with other documents released under
+this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice, and that you preserve all their Warranty Disclaimers.
+</p>
+<p>The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy. If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+</p>
+<p>In the combination, you must combine any sections Entitled "History"
+in the various original documents, forming one section Entitled
+"History"; likewise combine any sections Entitled "Acknowledgements",
+and any sections Entitled "Dedications". You must delete all sections
+Entitled "Endorsements."
+</p>
+<h4>6. COLLECTIONS OF DOCUMENTS</h4>
+<p>You may make a collection consisting of the Document and other
+documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+</p>
+<p>You may extract a single document from such a collection, and
+distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+</p>
+<h4>7. AGGREGATION WITH INDEPENDENT WORKS</h4>
+<p>A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, is called an "aggregate" if the copyright
+resulting from the compilation is not used to limit the legal rights
+of the compilation's users beyond what the individual works permit.
+When the Document is included in an aggregate, this License does not
+apply to the other works in the aggregate which are not themselves
+derivative works of the Document.
+</p>
+<p>If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one half of
+the entire aggregate, the Document's Cover Texts may be placed on
+covers that bracket the Document within the aggregate, or the
+electronic equivalent of covers if the Document is in electronic form.
+Otherwise they must appear on printed covers that bracket the whole
+aggregate.
+</p>
+<h4>8. TRANSLATION</h4>
+<p>Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections. You may include a
+translation of this License, and all the license notices in the
+Document, and any Warranty Disclaimers, provided that you also include
+the original English version of this License and the original versions
+of those notices and disclaimers. In case of a disagreement between
+the translation and the original version of this License or a notice
+or disclaimer, the original version will prevail.
+</p>
+<p>If a section in the Document is Entitled "Acknowledgements",
+"Dedications", or "History", the requirement (section 4) to Preserve
+its Title (section 1) will typically require changing the actual
+title.
+</p>
+<h4>9. TERMINATION</h4>
+<p>You may not copy, modify, sublicense, or distribute the Document
+except
+as expressly provided for under this License. Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License. However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+</p>
+<h4>10. FUTURE REVISIONS OF THIS LICENSE</h4>
+<p>The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns. See
+http://www.gnu.org/copyleft/.
+</p>
+<p>Each version of the License is given a distinguishing version
+number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation. If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+</p>
+<br/><br/>
+
+<hr/>
+
+<br/><br/>
+
+<br/><br/>
+
+<a name="GNUGPL"></a>
+<center>
+<h2><span class="gnu">GNU GENERAL PUBLIC LICENSE</span></h2>
+		      <p>Version 3, 29 June 2007</p>
+</center>
+
+<p>
+ Copyright (C) 2007 Free Software Foundation, Inc. http://fsf.org/
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+</p>
+
+<center><h4>Preamble</h4></center>
+
+<p>
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+</p>
+<p>
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+</p>
+<p>
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+</p>
+<p>
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+</p>
+<p>
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+</p>
+<p>
+  Developers that use the GNU GPL protect your rights with two steps:
+</p>
+<p>
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+</p>
+<p>
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+</p>
+<p>
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+</p>
+<p>
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+</p>
+<p>
+  The precise terms and conditions for copying, distribution and
+modification follow.
+</p>
+<center><h4>TERMS AND CONDITIONS</h4></center>
+
+<h4>0. Definitions.</h4>
+<p>
+  "This License" refers to version 3 of the GNU General Public License.
+</p>
+<p>
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+</p>
+<p>
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+</p>
+<p>
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+</p>
+<p>
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+</p>
+<p>
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+</p>
+<p>
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+</p>
+<p>
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.</p>
+
+<h4>1. Source Code.</h4>
+
+<p>
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+</p>
+<p>
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+</p>
+<p>
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+</p>
+<p>
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+</p>
+<p>
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+</p>
+<p>
+  The Corresponding Source for a work in source code form is that
+same work.
+</p>
+<h4>2. Basic Permissions.</h4>
+<p>
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+</p>
+<p>
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+</p>
+<p>
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+</p>
+<h4>3. Protecting Users' Legal Rights From Anti-Circumvention Law.</h4>
+<p>
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+</p>
+<p>
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+</p>
+<h4>4. Conveying Verbatim Copies.</h4>
+<p>
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+</p>
+<p>
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+</p>
+<h4>5. Conveying Modified Source Versions.</h4>
+<p>
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+</p>
+<blockquote>
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+</blockquote>
+<blockquote>
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+</blockquote>
+<blockquote>
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+</blockquote>
+<blockquote>
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+</blockquote>
+<p>
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+</p>
+<h4>6. Conveying Non-Source Forms.</h4>
+<p>
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+</p>
+<blockquote>
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+</blockquote>
+<blockquote>
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+</blockquote>
+<blockquote>
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+</blockquote>
+<blockquote>
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+</blockquote>
+<blockquote>
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+</blockquote>
+<p>
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+</p>
+<p>
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+</p>
+<p>
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+</p>
+<p>
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+</p>
+<p>
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+</p>
+<p>
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+</p>
+<h4>7. Additional Terms.</h4>
+<p>
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+</p>
+<p>
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+</p>
+<p>
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+</p>
+<blockquote>
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+</blockquote>
+<blockquote>
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+</blockquote>
+<blockquote>
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+</blockquote>
+<blockquote>
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+</blockquote>
+<blockquote>
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+</blockquote>
+<blockquote>
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+</blockquote>
+<p>
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+</p>
+<p>
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+</p>
+<p>
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+</p>
+<h4>8. Termination.</h4>
+<p>
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+</p>
+<p>
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+</p>
+<p>
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+</p>
+<p>
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+</p>
+<h4>9. Acceptance Not Required for Having Copies.</h4>
+<p>
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+</p>
+<h4>10. Automatic Licensing of Downstream Recipients.</h4>
+<p>
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+</p>
+<p>
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+</p>
+<p>
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+</p>
+<h4>11. Patents.</h4>
+<p>
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+</p>
+<p>
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+</p>
+<p>
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+</p>
+<p>
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+</p>
+<p>
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+</p>
+<p>
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+</p>
+<p>
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+</p>
+<p>
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+</p>
+<h4>12. No Surrender of Others' Freedom.</h4>
+<p>
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+</p>
+<h4>13. Use with the GNU Affero General Public License.</h4>
+<p>
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+</p>
+<h4>14. Revised Versions of this License.</h4>
+<p>
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+</p>
+<p>
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+</p>
+<p>
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+</p>
+<p>
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+</p>
+<h4>15. Disclaimer of Warranty.</h4>
+<p>
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+</p>
+<h4>16. Limitation of Liability.</h4>
+<p>
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+</p>
+<h4>17. Interpretation of Sections 15 and 16.</h4>
+<p>
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+</p>
+<br/>
+<center><h4>END OF TERMS AND CONDITIONS</h4></center>
+</div>
+<br/><br/>
+<center style="font-size: 150%">
+<span class="divider">(&nbsp;<font color="#7ba9d4">&part;</font>&nbsp;)</span>
+</center>
+<br/><br/>
+
+</body>
+</html>
+
diff --git a/doc/newlispdoc-man.txt b/doc/newlispdoc-man.txt
new file mode 100644
index 0000000..d99a313
--- /dev/null
+++ b/doc/newlispdoc-man.txt
@@ -0,0 +1,74 @@
+newlispdoc(1)               Commandline Parameters               newlispdoc(1)
+
+
+
+NAME
+       newlispdoc - generate documentation from newLISP source comments
+
+SYNOPSIS
+       newlispdoc [-s] [-d] lisp-file1 [lisp-file2 ...]
+
+       newlispdoc [-s] [-d] [-url] urls-file
+
+DESCRIPTION
+       newlispdoc is a commandline utility written in newLISP to generate HTML
+       documentation from comments written in newLISP  source  files.  Consult
+       /usr/share/doc/newlisp/newLISPdoc.html  for  a  detailed description on
+       how to write comments usable for  newlispdoc.  The  newlispdoc  command
+       should  be  executed from inside the directory where the newLISP source
+       files can be found. The generated documetation files  will  have  .html
+       added  to the name of the source file. An index.html page is generated,
+       which is listing for each file links to all the  documented  functions.
+       If  the  current directory contains the file newlispdoc.css, it will be
+       used for formatting HTML output. For a sample  see  util/newlispdoc.css
+       in the source distribution.
+
+OPTIONS
+       -s     this  option  causes  newlispdoc to also generate a syntax high-
+              lighted HTML file of the source. A link to  this  file  will  be
+              present  in  the  HTML documentation of this file. The generated
+              file will have the added extension .src.html.
+
+       -d     also generate a link to the raw unformatted sourcefile.
+
+       lisp-file
+              is a commented newLISP source file from  which  a  documentation
+              file will be generated.
+
+       -url   this  option  is used to retrieve newLISP source files for docu-
+              mentation from remote locations.
+
+       urls-file
+              is a file containing urls of newLISP source files, one  url  per
+              line.
+
+EXAMPLES
+       Generate all documentation form files in the current directory.
+              newlispdoc afile.lsp bfile.lsp
+
+
+       Generate  documentation  and  syntax highlighted HTML versions from all
+       lisp files in the current directory and also supply a download link.
+              newlispdoc -s -d *.lsp
+
+       Retrieve  source  files  for  documentation from remote locations. Each
+       file is specified on one line in urls.txt with its http:// address.
+              newlispdoc -s -url urls.txt
+
+EXIT STATUS
+       newlispdoc returns a zero exit status for normal exit or writes a usage
+       message if not enough paramneters are supplied.
+
+AUTHOR
+       Lutz Mueller <lutz@nuevatec.com>
+
+SEE ALSO
+       newlisp(1) - newlisp man page
+
+       http://www.newlisp.org/ -  the newLISP home page
+
+
+
+
+version 3.1                        July 2011                     newlispdoc(1)
+
diff --git a/doc/newlispdoc.1 b/doc/newlispdoc.1
new file mode 100644
index 0000000..369af7b
--- /dev/null
+++ b/doc/newlispdoc.1
@@ -0,0 +1,51 @@
+.TH newlispdoc 1 "July 2011" "version 3.4" "Commandline Parameters"
+.SH NAME
+.B newlispdoc
+\- generate documentation from newLISP source comments
+.SH SYNOPSIS
+.B newlispdoc 
+[\-s] [\-d] lisp\-file1 [lisp\-file2 ...]
+
+.B newlispdoc
+[\-s] [\-d] [\-url] urls-file
+.SH DESCRIPTION
+newlispdoc is a commandline utility written in newLISP to generate HTML documentation from comments written in newLISP source files. Consult /usr/share/doc/newlisp/newLISPdoc.html for a detailed description on how to write comments usable for newlispdoc. The newlispdoc command should be executed from inside the directory where the newLISP source files can be found. The generated documetation files will have .html added to the name of the source file. An index.html page is generated, which is listing for each file links to all the documented functions. If the current directory contains the file newlispdoc.css, it will be used for formatting HTML output. For a sample see util/newlispdoc.css in the source distribution.
+.SH OPTIONS
+.TP
+\-s
+this option causes newlispdoc to also generate a syntax highlighted HTML file of the source. A link to this file will be present in the HTML documentation of this file. The generated file will have the added extension .src.html.
+.TP
+\-d
+also generate a link to the raw unformatted sourcefile.
+.TP
+lisp\-file
+is a commented newLISP source file from which a documentation file will be generated.
+.TP
+\-url
+this option is used to retrieve newLISP source files for documentation from remote locations.
+.TP
+urls-file
+is a file containing urls of newLISP source files, one url per line.
+.SH EXAMPLES
+.TP
+Generate all documentation form files in the current directory.
+.B newlispdoc
+afile.lsp bfile.lsp
+.PP
+.TP
+Generate documentation and syntax highlighted HTML versions from all lisp files in the current directory and also supply a download link.
+.B newlispdoc
+\-s -d *.lsp
+.TP
+Retrieve source files for documentation from remote locations. Each file is specified on one line in urls.txt with its http:// address.
+.B newlispdoc
+\-s \-url urls.txt
+.SH EXIT STATUS
+newlispdoc returns a zero exit status for normal exit or writes a usage message if not enough paramneters are supplied.
+.SH AUTHOR
+Lutz Mueller <lutz@nuevatec.com>
+.SH SEE ALSO
+newlisp(1) \- newlisp man page
+
+http://www.newlisp.org/ \-  the newLISP home page
+
diff --git a/examples/README.txt b/examples/README.txt
new file mode 100755
index 0000000..deda265
--- /dev/null
+++ b/examples/README.txt
@@ -0,0 +1,25 @@
+README.txt .................... this file
+async ......................... demo aysnchronous HTTP get-url requests
+client ........................ demo for TCP networking client
+env.cgi ....................... httpd server CGI file to show environment
+finger ........................ demo for using TCP finger port
+form.cgi ...................... demo for HTML form CGI
+form.html ..................... used by form.cgi
+httpd-conf.lsp ................ configuration file for newLISP httpd mode
+newLISP-Excel-Import.xls ...... demo how to import newLISP in MS Excel
+observer ...................... demo for forking processes
+opengl-demo-ffi.lsp ........... OpenGL demo for extended FFI
+opengl-demo.lsp ............... OpenGL demo for simple FFI
+prodcons.lsp .................. demo for producer/consumer messageing
+query ......................... demo for spawning parallel processes
+scan .......................... TCP port scanner
+server ........................ demo TCP server, run before TCP client
+sniff ......................... TCP port sniffer
+tcltk.lsp ..................... Tcl/Tk graphics demo
+udp-client.lsp ................ demo for UDP client
+udp-server.lsp ................ demo for UDP server
+upload.cgi .................... CGI for uploading a file (works on Apache and newLISP httpd)
+upload.html ................... used for upload.cgi
+win32demo.lsp ................. demo for importing Win32 SDK GUI functions
+xmlrpc.cgi .................... demo for xmlrpc CGI
+
diff --git a/examples/async b/examples/async
new file mode 100755
index 0000000..5029886
--- /dev/null
+++ b/examples/async
@@ -0,0 +1,23 @@
+#!/usr/bin/env newlisp
+
+; demo use spawn and sync for
+; aysnchronous HTTP get-url requests
+
+(set 'start (time-of-day))
+
+; callback routine when page is finished
+(define (page-ready pid) 
+	(println "pid:" pid) 
+    (println "received: " (length page) " bytes"))
+
+; start fetching page, will return immediately
+(spawn 'page (get-url "http://www.yahoo.com")) 
+
+; specify call back, wait and do something else
+(until (true? (sync 100 page-ready) )
+	(println  (- (time-of-day) start) " ms"))
+
+; all done
+(exit)
+
+
diff --git a/examples/callback b/examples/callback
new file mode 100755
index 0000000..9e7dc2f
--- /dev/null
+++ b/examples/callback
@@ -0,0 +1,31 @@
+#!/usr/bin/newlisp
+
+; path-name of the library depending on platform
+; on Mac OSX use newlisp.dylib
+(set 'LIBRARY (if (= ostype "Windows") "newlisp.dll" "./newlisp.so"))
+
+; import functions from the newLISP shared library
+(import LIBRARY "newlispEvalStr")
+(import LIBRARY "newlispCallback")
+
+; set calltype platform specific
+(set 'CALLTYPE (if (= ostype "Windows") "stdcall" "cdecl"))
+
+; the callback function
+(define (callme p1 p2 p3 result)
+    (println "p1 => " p1 " p2 => " p2 " p3 => " p3)
+    result)
+
+; register the callback with newLISP library
+(newlispCallback "callme" (callback 0 'callme) CALLTYPE)
+
+; the callback returns a string
+(println (get-string (newlispEvalStr
+    {(get-string (callme 123 456 789 "hello world"))})))
+
+; the callback returns a number
+(println (get-string (newlispEvalStr
+    {(callme 123 456 789 99999)})))
+
+
+(exit)
diff --git a/examples/client b/examples/client
new file mode 100755
index 0000000..435cd95
--- /dev/null
+++ b/examples/client
@@ -0,0 +1,38 @@
+#!/usr/bin/env newlisp
+
+;;  client for  client/server demo
+;;
+;;  USAGE: client hostName
+;;
+;; 'hostName' contains a string with the name or IP number
+;; of the computer running the server application
+;;
+;; The client prompts for input and sends it to the
+;; server which sends it back converted to uppercase
+;;
+;; The server has to be started first in a different
+;; terminal window or on a different computer.
+;;
+;; v 1.3
+;; v 1.4 change net-receive for v 10.0
+;;
+
+(define (net-client-receive socket , buf)
+  (net-receive socket buf 256)
+  (print "\n" buf "\ninput or 'quit' to exit:")
+  (if (= buf "bye bye!") (exit))
+  (net-send socket (read-line)))
+
+(define (client host-computer)
+  (set 'socket (net-connect host-computer 1111))
+  (if (not socket) 
+    (print "could not connect, is the server started?\n") 
+    (while true (net-client-receive socket))))
+
+(if (not (main-args 2)) 
+  (begin 
+    (print "USAGE: client hostName\n")
+    (exit)))
+
+(client (main-args 2))
+(exit)
diff --git a/examples/env.cgi b/examples/env.cgi
new file mode 100755
index 0000000..52335b9
--- /dev/null
+++ b/examples/env.cgi
@@ -0,0 +1,25 @@
+#!/usr/bin/env newlisp
+#
+
+;;
+;; prints the environment
+;;
+(print "Content-Type: text/html\r\n\r\n")
+(print "<html>")
+
+(print [text]
+<A HREF="http://newlisp.org">Home</A>&nbsp;|
+<A HREF="http:syntax.cgi?environment.txt">Source</A> 
+[/text])
+
+(println "<h2>" (date) "</h2>")
+(println "<table border=1>")
+(dolist (e (sort (env)))
+  (if (and (!= (e 0) "HTTP_COOKIE") (!= (e 0) "UNIQUE_ID"))
+      (println "<tr><td>" (e 0) "</td><td>" (e 1) "</td></tr>\n")
+    )
+)
+(print "<h4>CGI by newLISP v" (sys-info -2)" on " ostype "<h4>")
+(println "</html>")
+(exit)
+
diff --git a/examples/finger b/examples/finger
new file mode 100755
index 0000000..c0d47dd
--- /dev/null
+++ b/examples/finger
@@ -0,0 +1,36 @@
+#!/usr/bin/env newlisp
+#
+# v 1.1 changes for changed 'main-args'
+# v 1.2 eliminated 'net-cleanup'
+# v 1.3 replaced concat with append
+# v 1.4 direct string form of net-send, eplace name with user
+# v 1.5 change net-receive for 10.0
+#
+
+(define (finger nameSite , socket buffer user site)
+	  (map set '(user site) (parse nameSite "@"))
+	  (set 'socket (net-connect site 79))
+	  (if (not socket)
+	  	(begin
+			(print "Could not connect\n")
+			(exit)))
+	  (if (not (net-send socket (append user "\r\n")))
+	  	(print "no connection\n")
+		(net-finger-receive socket)))
+		
+(define (net-finger-receive socket , str)
+	(if (not (net-receive socket str 512)) 
+		(print "Receive failed\n")
+	(print "\n" str "\n"))
+	(if socket (net-close socket)))
+
+(set 'params (main-args))
+(if (< (length params) 3) 
+  (begin 
+    (print "USAGE: finger name@host\n")
+    (exit)))
+(finger (nth 2 params))
+(exit)
+
+;eof;
+
diff --git a/examples/form.cgi b/examples/form.cgi
new file mode 100755
index 0000000..3a5d11f
--- /dev/null
+++ b/examples/form.cgi
@@ -0,0 +1,40 @@
+#!/usr/bin/env newlisp
+#
+# Demo of CGI 1.1 interface 
+#
+# version 1.2  changed for newlisp v.10.0
+# version 1.2a comments added
+#
+# get form data from CGI STDIN parse and
+# write back to the client browser
+#
+# 
+#
+
+
+(print "Content-Type: text/html\r\n\r\n")
+(println "<h3>Post or Get Variables</h3>\n")
+
+;; Try to read POST data. For an alternative
+;; method using CONTENT_LENGTH and CONTEN_TYPE
+;; see the module cgi.lsp from the distribution
+(set 'input (read-line))
+(if (not input) (set 'input (env "QUERY_STRING")))
+(if input (begin
+    (set 'vars (parse input "&"))
+    (dolist (elmnt vars) 
+	(replace "+" elmnt " ")
+	(println elmnt"<br>"))
+    (println "<p>")))
+
+#
+# command line arguments
+(print "<h3>Command line</h3>\n" (main-args) "<p>\n")
+
+#
+# print environment variables
+(println "<h3>Environment Variables</h3>")
+(dolist (e (env)) (print (e 0) "=" (e 1) "<br>"))
+(println)
+
+(exit)
diff --git a/examples/form.html b/examples/form.html
new file mode 100644
index 0000000..ccc154d
--- /dev/null
+++ b/examples/form.html
@@ -0,0 +1,36 @@
+<html>
+<head><title>A form to check newLISP CGI</title></head>
+<body>
+<h3>A test form for checking out the POST method in HTTP.</h3>
+<p>Change "localhost" in the action statement to the correct hostname, if trying this remotely.</p>
+<form action="/form.cgi" method="POST">
+Name (text entry field) <input type="text" name="name"> <p>
+Check Me (checkbox)
+<p><input type="checkbox" name="checkMe"></p>
+<p>
+Select me (radio buttons)<br>
+<input type="radio" name=color value="Red">red<BR>
+<input type="radio" name=color value="Green">green<BR>
+<input type="radio" name=color value="Blue">blue<BR>
+</p>
+<p>
+Choose one (select)
+<select name="chooseOne">
+<option> First
+<option> Second
+<option> Third
+<option> Fourth
+</select>
+</p>
+<p>
+<p>Enter text (textarea)</p>
+<textarea name=textField rows=4 cols=40>
+</textarea>
+</p>
+<p>
+Submit It (submit) <input type="submit" value="Go">
+</p>
+</form>
+Source of CGI script: <a href="form-cgi.txt">form.cgi</a>
+</body>
+</html>
diff --git a/examples/httpd-conf.lsp b/examples/httpd-conf.lsp
new file mode 100644
index 0000000..298ddad
--- /dev/null
+++ b/examples/httpd-conf.lsp
@@ -0,0 +1,17 @@
+; httpd-conf.lsp
+;;
+; filter and translate HTTP request for newLISP
+;; -c or -http server modes
+;; reject query commands using CGI with .exe files
+
+(command-event (fn (s)
+    (let (request s)
+		(when (find "?" s) ; is this a query
+			(set 'request (first (parse s "?")))
+			; discover illegal extension in queries
+			(when (ends-with request ".exe")
+				(set 'request "GET /errorpage.html")) )
+		request)
+))
+
+; eof
diff --git a/examples/index.cgi b/examples/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/examples/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/examples/newLISP-Excel-Import.xls b/examples/newLISP-Excel-Import.xls
new file mode 100755
index 0000000..effd54b
Binary files /dev/null and b/examples/newLISP-Excel-Import.xls differ
diff --git a/examples/observer b/examples/observer
new file mode 100755
index 0000000..d08d1e4
--- /dev/null
+++ b/examples/observer
@@ -0,0 +1,22 @@
+#!/usr/bin/env newlisp
+
+(define (count-down-proc x channel)
+  (while (!= x 0)
+      (write-line channel (string x))
+      (dec x)))
+
+(define (observer-proc channel)
+  (do-until (= i "1")
+    (println "process " (setq i (read-line channel)))))
+
+(map set '(in out) (pipe))
+(set 'observer (fork (observer-proc in)))
+(set 'counter (fork (count-down-proc 5 out)))
+
+; avoid zombies
+(wait-pid observer)
+(wait-pid counter)
+
+(exit)
+
+
diff --git a/examples/opengl-demo-ffi.lsp b/examples/opengl-demo-ffi.lsp
new file mode 100644
index 0000000..d858937
--- /dev/null
+++ b/examples/opengl-demo-ffi.lsp
@@ -0,0 +1,187 @@
+#!/usr/bin/env newlisp 
+# OpenGL and GLUT demo - opengl-demo-ffi.lsp
+# Using extended import and callback API based on libffi
+# tested on Windows and OS X 32/64-bit (Intel) minimum version newLISP 10.3.10
+
+# verson 2.1 December 2011 - remade with extended FFI for 32 and 64-bit
+# verson 2.2 February 2012 - check if newLISP compiled for extended FFI
+# verson 2.3 April 2015 - changed ostype to Windows from Win32
+# this version works on both, 32-bit and 64-bit newLISP
+# on a Mac OSX standard install everything neede for 32-bit or 64-bit
+# is included. On Windows XP and Windows 7, glut32.dll must be added. 
+# on Linux opengl.so, libglut.so and libffi.so must be added, most
+# Linux seem to include libffi.so already. See also the C version:
+# http://graphics.stanford.edu/courses/cs248-01/OpenGLHelpSession/code_example.html
+
+#
+# for a complete function reference for OpenGL look here:
+#     http://www.opengl.org/documentation/
+#
+# for descriptions and refence to GLU see here:
+#     http://www.opengl.org/resources/libraries/glut/
+#
+# Calling patterns for OpenGL functions:
+# Functions are described in the manual with the following types:
+#
+# All the following integer types are passed as is or with (int ...):
+# GLenum GLboolean GLbitfield GLbyte GLshort GLint GLsizei GLubyte GLushort GLuint
+# and types ending in: 3b, si, 3s
+#
+# The following double float types are passed as is or with (float ...):
+# GLdouble GLclampd
+# and types ending in: 3d
+#
+# The following are small float types
+# GLfloat GLclampf
+# and all types ending 3f:
+# 
+# Note! on Windows 7 glut32.dll should be installed c:/Windows/SysWOW64/ not system32
+
+(set 'is-64-bit (= 0x100 (& 0x100 (sys-info -1))))
+(set 'has-ffi (= 1024 (& 1024 (sys-info -1))))
+
+(unless has-ffi
+    (println "need newLISP compiled for extended FFI")
+    (exit))
+
+(if 
+  (= ostype "OSX") ;; drawings will be visible only on x86 based OS X
+  (begin
+    (set 'GL_LIB "/System/Library/Frameworks/OpenGL.Framework/Libraries/libGL.dylib")
+    (set 'GLUT_LIB "/System/Library/Frameworks/GLUT.Framework/GLUT")
+  )
+  (find ostype '("Windows", "Cygwin"))
+  (begin
+    (set 'GL_LIB "opengl32.dll") ; works dfor both 32 and 64 bit
+    (set 'GLUT_LIB (if is-64-bit "glut64.dll" "glut32.dll")))
+  (= ostype "Linux") ;; not tested
+  (begin
+    (set 'GL_LIB "libGL.so")
+    (set 'GLUT_LIB "libglut.so"))
+)
+
+(import GL_LIB "glClear" "void" "int")
+(import GL_LIB "glClearColor" "void" "float" "float" "float" "float")
+(import GL_LIB "glEnable" "void" "int")
+(import GL_LIB "glHint" "void" "int" "int")
+(import GL_LIB "glColor3d" "void" "double" "double" "double")
+(import GL_LIB "glBegin" "void" "int")
+(import GL_LIB "glEnd" "void" "void")
+(import GL_LIB "glVertex3d" "void" "double" "double" "double")
+(import GL_LIB "glFlush" "void")
+(import GL_LIB "glFinish" "void")
+(import GL_LIB "glRotated" "void" "double" "double" "double" "double")
+(import GL_LIB "glLineWidth" "void" "float")
+
+(import GLUT_LIB "glutInit" "void" "void*" "void*")
+(import GLUT_LIB "glutDisplayFunc" "void" "void*")
+(import GLUT_LIB "glutInitWindowSize" "void" "int" "int")
+(import GLUT_LIB "glutInitDisplayMode" "void" "int")
+(import GLUT_LIB "glutInitWindowPosition" "void" "int" "int")
+(import GLUT_LIB "glutDisplayFunc" "void" "void*")
+(import GLUT_LIB "glutKeyboardFunc" "void" "void*")
+(import GLUT_LIB "glutMouseFunc" "void" "void*")
+(import GLUT_LIB "glutJoystickFunc" "void" "void*" "int")
+(import GLUT_LIB "glutMotionFunc" "void" "void*")
+(import GLUT_LIB "glutIdleFunc" "void" "void*")
+(import GLUT_LIB "glutCreateWindow" "int" "char*")
+(import GLUT_LIB "glutCreateSubWindow" "int" "int" "int" "int" "int" "int")
+(import GLUT_LIB "glutMainLoop" "void")
+(import GLUT_LIB "glutSwapBuffers" "void")
+(import GLUT_LIB "glutPostRedisplay" "void")
+
+(import GLUT_LIB "glutSolidCube" "void" "double")
+(import GLUT_LIB "glutSolidTeapot" "void" "double")
+(import GLUT_LIB "glutWireCube" "void" "double")
+(import GLUT_LIB "glutWireTeapot" "void" "double")
+
+(constant 'GL_COLOR_BUFFER_BIT 0x00004000)
+(constant 'GL_TRIANGLES 0x0004)
+(constant 'GL_BLEND 0x0BE2)
+(constant 'GL_LINE_SMOOTH 0x0B20)
+(constant 'GL_DONT_CARE 0x1100)
+(constant 'GL_LINE_SMOOTH_HINT 0x0C52)
+
+(constant 'GLUT_DOUBLE 0x0002)
+(constant 'GLUT_SINGLE 0x0000)
+(constant 'GLUT_RGB 0x0000)
+(constant 'GLUT_RGBA 0x0000)
+
+(set 'argc 0)
+(set 'argv1 "")
+(set 'argv (pack "lu" argv1))
+(set 'rotx 0.0)
+(set 'roty 0.0)
+(set 'PI (atan2 0 -1))
+
+(define (draw) 
+	(glClear GL_COLOR_BUFFER_BIT)
+	(glRotated rotx 0.0 1.0 0.0)
+	(glRotated roty 1.0 0.0 0.0)
+	(glutWireTeapot 0.5)
+	(glutSwapBuffers)
+)
+
+(define (drawObject)
+	(glClear GL_COLOR_BUFFER_BIT )
+	(glColor3d 1.0 0.85 0.35)
+	(glRotated rotx 0.0 1.0 0.0)
+	(glRotated roty 1.0 0.0 0.0)
+	(glBegin GL_TRIANGLES)
+	(glVertex3d 0.0 0.6 0.0)
+	(glVertex3d -0.2 -0.3 0.0)
+	(glVertex3d 0.2 -0.3 0.0)
+	(glEnd)
+	(glutSwapBuffers)
+)
+
+(define (rotation)
+	(set 'rotx (mod (sub rotx .01) PI))
+	(set 'roty (mod (sub roty .012) PI))
+	(sleep 10)
+	(glutPostRedisplay)
+)
+
+(define (keyboard key x y)
+	(if (= key 27) (exit)) 
+	(println "key:" (& key 0xFF) " x:" x  " y:" y))
+
+(define (mouse button state x y)
+	(if (= state 0)
+		(glutIdleFunc 0) ; auto-motion off on button press
+		(glutIdleFunc (callback 'rotation))) ; auto-motion on
+	(println "mouse button: " button " state:" state " x:" x " y:" y))
+
+(define (joystick button x y z)
+	(println "joystick button: " button " x: " x " y: " y " z: " z))
+
+(define (motion x y)
+	(set 'rotx (mul (div 200 x) PI))
+	(set 'roty (mul (div 150 y) PI))
+	(glutPostRedisplay)
+	(println "x:" x  " y:" y))
+
+(glutInit (address argc) (address argv))
+(glutInitDisplayMode (| GLUT_RGB GLUT_DOUBLE ))
+(glutInitWindowSize 800 600)
+(glutInitWindowPosition 80 80)
+(set 'id (glutCreateWindow "OpenGL and newLISP - drag mouse - ESC to exit"))
+
+(glClearColor 0.5  0.3  0.3 0.0)
+(glColor3d 1.0 0.85 0.35)
+
+(glutDisplayFunc (callback 'draw "void"))
+;(glutDisplayFunc (callback 0 'drawObject))
+(glutKeyboardFunc (callback 'keyboard "void" "byte" "int" "int"))
+(glutMouseFunc (callback 'mouse "void" "int" "int" "int" "int"))
+(glutMotionFunc (callback 'motion "void" "int" "int"))
+(glutIdleFunc (callback 'rotation "void"))
+(glutJoystickFunc (callback 'joystick "void" "int" "int" "int" "int") 50)
+(glutMainLoop)
+
+;; eof
+
+;(glEnable GL_BLEND)
+;(glEnable GL_LINE_SMOOTH) ; turn on antialiasing
+;(glHint GL_LINE_SMOOTH_HINT GL_DONT_CARE)
+;(glLineWidth 3)
diff --git a/examples/opengl-demo.lsp b/examples/opengl-demo.lsp
new file mode 100644
index 0000000..bd0ed17
--- /dev/null
+++ b/examples/opengl-demo.lsp
@@ -0,0 +1,197 @@
+#!/usr/bin/env newlisp 
+# OpenGL and GLUT demo - opengl-demo.lsp
+# using simple import and callback API
+# tested on Windows and OS X (Intel) 32-bit only!
+
+# version 1.2, July 2009 - make drawObject working with motion
+
+# this version runs only on 32-bit newLISP and libraries
+# for 64-bit newlisp use http://www.newlisp.org/downloads/OpenGL/opengl-demo-ffi-lsp.txt, 
+# which runs both 32/64 versions of newLISP. For this extended ffi version newLISP 10.4.0 
+# or later is required. The extended ffi interface is present in all binary distributions 
+# (Windows, OSX, Ubuntu)
+
+# WIn32
+# opengl32.dll - should be already on you WindowsXP installation or at www.opengl.org  
+# glut32.dll -  available here: http://www.opengl.org/resources/libraries/glut/
+# Note! on Windows 7 glut32.dll should be installed c:/Windows/SysWOW64/ not system32
+# 
+# Linux/UNIX - not tested
+# libGLU.so - should be on your Linux/UNIX installation or at www.opengl.org
+# glut-3.7.so - already on your system or at:
+#     http://www.opengl.org/resources/libraries/glut/
+#
+# Mac OS X - works well on Intel based Mac OS X, will not work on PPC
+# nothing needs to be installed on Mac OX X 10.4 and later
+# libGL.dylib - in /System/Library/Frameworks/OpenGL.Framework
+# GLUT - in /System/Library/Frameworks/GLUT.Framework
+#
+# for a complete function reference for OpenGL look here:
+#     http://www.opengl.org/documentation/
+#
+# for descriptions and refence to GLU see here:
+#     http://www.opengl.org/resources/libraries/glut/
+#
+# Calling patterns for OpenGL functions:
+# Functions are described in the manual with the following types:
+#
+# All the following integer types are passed as is or with (int ...):
+# GLenum GLboolean GLbitfield GLbyte GLshort GLint GLsizei GLubyte GLushort GLuint
+# and types ending in: 3b, si, 3s
+#
+# The following double float types are passed as is or with (float ...):
+# GLdouble GLclampd
+# and types ending in: 3d
+#
+# The following small float types are must with (flt ...) conversion:
+# GLfloat GLclampf
+# and all types ending 3f:
+# 
+
+(when (= 256 (& 256 (last (sys-info)))) ; if it is 64 bit version
+	(println "This file can run only on the 32-bit version of newLISP")
+	(println "Use opengl-demo-ffi.lsp, which runs on both, 32-bit and 64-bit")
+	(exit))
+
+(if 
+  (= ostype "OSX") ;; drawings will be visible only on x86 based OS X
+  (begin
+    (set 'GL_LIB "/System/Library/Frameworks/OpenGL.Framework/Libraries/libGL.dylib")
+    (set 'GLUT_LIB "/System/Library/Frameworks/GLUT.Framework/GLUT")
+  )
+  (find ostype '("Windows", "Cygwin"))
+  (begin
+    (set 'GL_LIB "opengl32.dll")
+    (set 'GLUT_LIB "glut32.dll"))
+  (= ostype "Linux") ;; not tested
+  (begin
+    (set 'GL_LIB "libGL.so")
+    (set 'GLUT_LIB "libglut.so"))
+)
+
+(import GL_LIB "glClear")
+(import GL_LIB "glClearColor")
+(import GL_LIB "glEnable")
+(import GL_LIB "glHint")
+(import GL_LIB "glColor3d")
+(import GL_LIB "glBegin")
+(import GL_LIB "glEnd")
+(import GL_LIB "glVertex3d")
+(import GL_LIB "glFlush")
+(import GL_LIB "glFinish")
+(import GL_LIB "glRotated")
+(import GL_LIB "glLineWidth")
+
+(import GLUT_LIB "glutInit")
+(import GLUT_LIB "glutDisplayFunc")
+(import GLUT_LIB "glutInitWindowSize")
+(import GLUT_LIB "glutInitDisplayMode")
+(import GLUT_LIB "glutInitWindowPosition")
+(import GLUT_LIB "glutDisplayFunc")
+(import GLUT_LIB "glutKeyboardFunc")
+(import GLUT_LIB "glutMouseFunc")
+(import GLUT_LIB "glutJoystickFunc")
+(import GLUT_LIB "glutMotionFunc")
+(import GLUT_LIB "glutIdleFunc")
+(import GLUT_LIB "glutCreateWindow")
+(import GLUT_LIB "glutCreateSubWindow")
+(import GLUT_LIB "glutMainLoop")
+(import GLUT_LIB "glutSwapBuffers")
+(import GLUT_LIB "glutPostRedisplay")
+
+(import GLUT_LIB "glutSolidCube")
+(import GLUT_LIB "glutSolidTeapot")
+(import GLUT_LIB "glutWireCube")
+(import GLUT_LIB "glutWireTeapot")
+
+(constant 'GL_COLOR_BUFFER_BIT 0x00004000)
+(constant 'GL_TRIANGLES 0x0004)
+(constant 'GL_BLEND 0x0BE2)
+(constant 'GL_LINE_SMOOTH 0x0B20)
+(constant 'GL_DONT_CARE 0x1100)
+(constant 'GL_LINE_SMOOTH_HINT 0x0C52)
+
+(constant 'GLUT_DOUBLE 0x0002)
+(constant 'GLUT_SINGLE 0x0000)
+(constant 'GLUT_RGB 0x0000)
+(constant 'GLUT_RGBA 0x0000)
+
+(set 'argc 0)
+(set 'argv1 "")
+(set 'argv (pack "lu" argv1))
+(set 'rotx 0.0)
+(set 'roty 0.0)
+(set 'PI (mul (acos 0) 2))
+
+(define (draw) 
+	(glClear GL_COLOR_BUFFER_BIT )
+	(glRotated rotx 0.0 1.0 0.0)
+	(glRotated roty 1.0 0.0 0.0)
+	(glutWireTeapot 0.5)
+	(glutSwapBuffers)
+)
+
+(define (drawObject)
+	(glClear GL_COLOR_BUFFER_BIT )
+	(glColor3d 1.0 0.85 0.35)
+	(glRotated rotx 0.0 1.0 0.0)
+	(glRotated roty 1.0 0.0 0.0)
+	(glBegin GL_TRIANGLES)
+	(glVertex3d 0.0 0.6 0.0)
+	(glVertex3d -0.2 -0.3 0.0)
+	(glVertex3d 0.2 -0.3 0.0)
+	(glEnd)
+	(glutSwapBuffers)
+)
+
+(define (rotation)
+	(set 'rotx (mod (sub rotx .01) PI))
+	(set 'roty (mod (sub roty .012) PI))
+	(sleep 10)
+	(glutPostRedisplay)
+)
+
+(define (keyboard key x y)
+	(if (= (& key 0xFF) 27) (exit)) ; 0xFF mask necessary in Windows
+	(println "key:" (& key 0xFF) " x:" x  " y:" y))
+
+(define (mouse button state x y)
+	(if (= state 0)
+		(glutIdleFunc 0) ; auto-motion off on button press
+		(glutIdleFunc (callback 4 'rotation))) ; auto-motion on
+	(println "mouse button: " button " state:" state " x:" x " y:" y))
+
+(define (joystick button x y z)
+	(println "joystick button: " button " x: " x " y: " y " z: " z))
+
+(define (motion x y)
+	(set 'rotx (mul (div 200 x) PI))
+	(set 'roty (mul (div 150 y) PI))
+	(glutPostRedisplay)
+	(println "x:" x  " y:" y)
+    (reset))
+
+(glutInit (address argc) (address argv))
+(glutInitDisplayMode (| GLUT_RGB GLUT_DOUBLE ))
+(glutInitWindowSize 800 600)
+(glutInitWindowPosition 80 80)
+(set 'id (glutCreateWindow "OpenGL and newLISP - drag mouse - ESC to exit"))
+
+(glClearColor (flt 0.5) (flt 0.3) (flt 0.3) (flt 0.0))
+(glColor3d 1.0 0.85 0.35)
+
+(glutDisplayFunc (callback 0 'draw))
+;(glutDisplayFunc (callback 0 'drawObject))
+(glutKeyboardFunc (callback 1 'keyboard))
+(glutMouseFunc (callback 2 'mouse))
+(glutMotionFunc (callback 3 'motion))
+(glutIdleFunc (callback 4 'rotation))
+(glutJoystickFunc (callback 5 'joystick) 50)
+(glutMainLoop)
+
+;; eof
+
+;(glEnable GL_BLEND)
+;(glEnable GL_LINE_SMOOTH) ; turn on antialiasing
+;(glHint GL_LINE_SMOOTH_HINT GL_DONT_CARE)
+;(glLineWidth 3)
diff --git a/examples/prodcons.lsp b/examples/prodcons.lsp
new file mode 100644
index 0000000..4c86b54
--- /dev/null
+++ b/examples/prodcons.lsp
@@ -0,0 +1,53 @@
+#!/usr/bin/env newlisp
+
+# prodcons.lsp -  Producer/consumer
+#
+# this program only runs on Linux/UNIX
+#
+# usage of 'fork', 'wait-pid', 'semaphore' and 'share'
+
+(when (= ostype "Windows")
+		(println "this will not run on Windows")
+		(exit))
+
+(constant 'wait -1 'sig 1 'release 0)
+
+(define (consumer n)
+	(set 'i 0)
+	(while (< i n)
+		(semaphore cons-sem wait)
+		(print (set 'i (share data)) "\r")
+		(semaphore prod-sem sig))  
+	(exit))
+		
+(define (producer n)
+	(for (i 1 n)
+		(semaphore prod-sem wait)
+		(print "-> " (share data i) " ->  ")
+		(semaphore cons-sem sig))   
+	(exit))
+
+
+(define (run n)
+	(set 'data (share))	
+	(share data 0)
+
+	(set 'prod-sem (semaphore)) ; get semaphores
+	(set 'cons-sem (semaphore))
+
+	(set 'prod-pid (fork (producer n))) ; start threads
+	(set 'cons-pid (fork (consumer n)))
+	(semaphore prod-sem sig) ; get producer started
+
+	(wait-pid prod-pid) ; wait for threads to finish
+	(wait-pid cons-pid) ; 
+	(semaphore cons-sem release) ; release semaphores
+	(semaphore prod-sem release))
+
+(set 'N (or (int (main-args -1)) 100000))
+(set 'duration (time (run N)))
+
+(println (div duration N) " ms per exchange")
+
+(exit)
+
diff --git a/examples/query b/examples/query
new file mode 100755
index 0000000..179b7db
--- /dev/null
+++ b/examples/query
@@ -0,0 +1,143 @@
+#!/usr/bin/env newlisp
+
+; Retrieves a page with 20 links via Google containing 
+; the search word, then spawns 20 child processes, each
+; retrieving one page from a link. All pages are then 
+; HTML-cleaned, tokenized and words are counted using
+; bayes-train.
+
+; USAGE: query <search-word>
+
+; or rename to query.cgi and run on a web server
+; using the following query.html:
+
+; NOTE!!! Google changes the formatting of links (see LINK_REGEX) once
+; in a while and then the whole thing breaks! 
+
+
+;<html> 
+;<head><title>Query</title></head> 
+;<body><font face="Verdana">
+;<p>Parallel processing support on newLISP using 'spawn'</p>
+;<form name="query" action="query.cgi" method="POST"> 
+;Input a search word:&nbsp;<input type="text" name="query" size="48"> 
+;&nbsp;<input type="submit" value="Submit" name="submit"> 
+;</form> 
+;</font></body></html> 
+
+(set 'cgi-mode nil)
+;(set 'cgi-mode true) ; run as CGI get question from query.html
+
+(when cgi-mode 
+    (module "cgi.lsp")
+    (print "Content-Type: text/html\n\n"))
+
+;; globals and constants in this namespace
+(set 'LINK_REGEX {q=(http://[^>& ]+)&})
+(set 'START_TIME 0)
+(set 'SITES '())
+(set 'CONTENT "")
+(constant 'BRK (if cgi-mode "<br>" ""))
+
+(define (url-decode str)
+  (replace "%([0-9A-F][0-9A-F])" str (char (int $1 0 16)) 1))
+
+(define (url-encode str)  
+  (replace {([^a-zA-Z0-9])} str (format "%%%2X" (char $1)) 0))
+
+(define (clean-html text)
+	(replace "<script.*?</script>" text "" 4)
+	(replace "<style.*?</style>" text "" 4)
+	(replace "<head.*?</head>" text "" 4)
+	(replace "<[^>]*>" text " " 0)
+	(replace "." text " . ")
+	(replace "," text " , ")
+	(replace "!" text " ! ")
+	(replace "?" text " ? ")
+	(replace "\n" text " ")
+	(replace "\r" text "")
+	(replace "\t" text " ")
+	(replace " +" text " " 4)
+	; this should be a list of all ISO 8859-1 Symbols
+	; see http://www.w3schools.com/tags/ref_entities.asp
+	; HTML entities should be replaced with UTF-8
+	(replace "&nbsp;" text " ")
+	(replace "&mdash;" text " - ")
+	(replace "&ndash;" text " - ")
+	(replace "&quot;" text "'")
+	(replace "&amp;" text "&")
+	;(replace "&lrm;" text (char 8206))
+	;(replace {\&#(\d+);} text (char (int $1)) 0)
+)
+
+(if cgi-mode
+    (set 'question (CGI:get "query"))
+    (set 'question (last (parse (main-args -1) "/"))) ; default is 'query'
+)
+        
+
+(set 'page (get-url 
+	(string "http://www.google.com/search?q=" (url-encode question)
+			"&num=22&ie=UTF-8&oe=UTF-8")))
+
+(set 'links (find-all LINK_REGEX page $1))
+
+(when cgi-mode
+    (println {<html><font face="Verdana"><head>})
+    (println {<META http-equiv="Content-Type" CONTENT="text/html; charset=utf-8" />})
+    (println {</head><body>}))
+
+(println "query term: " (url-decode question) BRK)
+(set 'START_TIME (time-of-day))
+
+######################### this is, where all the pages are retrieved #################
+; spawn a childprocess for each link
+(dolist (lnk (0 20 links))
+	(set 'pid (spawn 'page (get-url lnk 4000)))
+	(push (list pid lnk) SITES -1))
+
+; this gets executed whenever a page has been retrieved
+(define (page-ready-event pid)
+    (let (link (0 80 (lookup pid SITES)))
+        (set 'link (url-decode link))
+        (println (inc cnt) " pid:" pid " " (- (time-of-day) START_TIME) " ms " link BRK)
+        (push (lower-case (clean-html page)) CONTENT -1)
+        (inc xferred (length page)))
+)
+
+; start waiting for pages
+(println "waiting: ..." BRK BRK)
+(unless (sync 10000  page-ready-event)
+	(println BRK "timeout" BRK))
+#####################################################################################
+
+(println BRK "bytes transferred: " xferred BRK)
+(println "total time: " (- (time-of-day) START_TIME) " ms" BRK)
+
+######################### all the counting is done here using bayes-train ###########
+(catch (load "Lex") 'result)
+(println "training: " (time (bayes-train (find-all {[a-zA-Z]+} CONTENT) 'Lex)) " ms" BRK)
+(println "total words processed: " (Lex:total 0) BRK)
+(println BRK)
+#####################################################################################
+
+; sort by frequency and print in four columns
+(set 'items (sort (Lex) (fn (x y) (> (x 1 0) (y 1 0)))))
+(set 'items (transpose (explode items (ceil (div (length items) 4)))))
+
+(when cgi-mode (println "<pre>"))
+(dolist (line items)
+    (dolist (item line)
+        (if (and item (< (length (item 0)) 19)) 
+            (print (format "%-18s %5d, " (item 0) (item 1 0)))
+            (print (format "%-18s      , " " ")))) ; nil
+    (println))
+		
+(when cgi-mode
+    (println "</pre>")
+    (println "</body></font></html>"))
+
+; if accumulating results over various queries
+;(save "Lex" 'Lex)
+(exit)
+
diff --git a/examples/scan b/examples/scan
new file mode 100755
index 0000000..d23a951
--- /dev/null
+++ b/examples/scan
@@ -0,0 +1,48 @@
+#!/usr/bin/env newlisp
+
+; - scan - v.1.0 port scanner in newLISP
+; much faster on Mac OSX, LINUX and other UNIX than on Windows
+; as on UNIX net-connect can return on failure before the timeout
+; has exspired. On Windows net-connect will wait out the timeout
+; if it cannot connect.
+;
+; Example:
+;
+
+(when (< (sys-info -2) 10204)
+	(println "newLISP v.10.2.4 or later required")
+	(exit))
+
+(set 'host (main-args 2))
+(unless host (println [text]
+- newLISP scan v1.1, a simple portscanner
+
+USAGE: scan <host-ip-or-name> [<timeout-msec> [<from-port> [<to-port>]]]
+
+EXAMPLES:
+   scan localhost 200 1 1024
+   scan example.com
+   scan 192.168.1.92 300 20
+
+Default for <timeout-msec> is 1000 milli seconds
+Defaults for <from-port> and <to-port> are 1 to 1024
+[/text])
+	(exit))
+
+(set 'timeout (or (int (main-args 3)) 1000))
+(set 'from-port (or (int (main-args 4)) 1))
+(set 'to-port (or (int (main-args 5)) 1024))
+
+(println "scanning: " host)
+(for (port from-port to-port)
+	(if (set 'socket (net-connect host port timeout))
+		(begin
+			(println "open port: " port " " (or (net-service port "tcp") ""))
+			(net-close socket))
+		(print port "\r"))
+)
+(println)
+(exit)
+
+;; eof
+
diff --git a/examples/server b/examples/server
new file mode 100755
index 0000000..1bbba15
--- /dev/null
+++ b/examples/server
@@ -0,0 +1,42 @@
+#!/usr/bin/env newlisp
+
+;; server for client/server demo
+;;
+;; USAGE: server
+;;
+;; Start the client programm in a different
+;; terminal window or on a different computer
+;; See the 'client' file for more info.
+;;
+;; v 1.1
+;; v 1.2 change net-receive for 10.0
+;;
+
+(define (net-server-accept listenSocket)
+  (while online 
+    (set 'connect (net-accept listenSocket)) 
+	(net-send connect "Connected!\n")
+	(while (net-server-receive connect))))
+
+(define (net-server-receive socket , str)
+  (net-receive socket str 256)
+  (print "received:" str "\n")
+  (if (= str "quit") 
+   (begin 
+    (net-send socket "bye bye!") 
+    (net-close socket) nil) 
+   (net-send socket (upper-case str))))
+
+(define (server)
+  (if (not (set 'socket (net-listen 1111))) 
+   (print "Listen failed:\n" (net-error)) 
+   (begin
+	(set 'online true)
+   	(print "\nServer started\n")
+	(net-server-accept socket)
+	)))
+
+(server)
+
+; eof ;
+
diff --git a/examples/sniff b/examples/sniff
new file mode 100755
index 0000000..5948a5b
--- /dev/null
+++ b/examples/sniff
@@ -0,0 +1,283 @@
+#!/usr/bin/env newlisp
+
+; sniff  v.1.23 - net work packet snifffer
+; 2010-March-26 added out-commented callback method
+; 2010-April-10 documentation
+; 2010-April-27 added 'packet' output format for whole packet
+;               added output of unknown packets
+; 2010-April-29 help text improvements
+; 2010-May-29 added library path for OpenBSD 4.6 
+; 2013-Sep-22 change stats to pstats (stats is function since 10.4.2)
+;
+; See also http://www.tcpdump.org/pcap.htm
+; tested on Mac OS X 10.6 and UBUNTU 9.4 and Win32
+; for a Win32 library goto http://www.winpcap.org/
+; first version L.M.in March 2010
+;
+; This script must be run with super user prigileges.
+
+(unless (main-args 2) 
+	(println [text]
+- sniff - network packet sniffer, version 1.21, April 2010
+
+USAGE UNIX: 
+    sudo sniff <device> [<filter> [<count> [hex | ascii | packet]]] 
+
+USAGE Win32:
+    newlisp sniff <device> [<filter> [<count> [hex | ascii | packet]]]   
+
+The program must run in super user or administrator mode. On Unix the 
+sudo utility can be used, and the OS will ask for the root password.
+
+EXAMPLES: 
+    sniff eth01 'tcp port 80' 100 hex
+    sniff en1 ip 100 packet           <-- best all purpose format
+    sniff eth0 'ip host 10.1.2.3'
+    sniff en0
+    sniff ""
+    
+Use an empty string "" or '' for <device> to let sniff find out a device.
+This works well on Windows but frequently does not work on UNIX, where
+it is better to use the ifconfig utility to find a connected device. 
+
+The 'hex' option dumps data in HEX and ASCII, the 'ascii' option only in 
+ASCII format. Both options only dump the data part of the packet after the 
+TCP, UDP or frst 8 bytees of the ICMP header. The 'packet' option dumps
+the whole packet starting with the IP header and in HEX and ASCII format. 
+
+Default <filter> expression is 'ip' for all protocols. The protocol ids:
+tcp, udp and icmp are supported. Default packet <count> is 10 and 
+default output mode is no output.
+[/text])
+	(exit)
+)
+
+; import pcap library
+
+(set 'bit-64 (= 256 (& (sys-info -1) 256)))
+
+(set 'files '(
+	"/usr/lib/libpcap.dylib"   ; Mac OS X 10.6
+	"/usr/lib/libpcap.so.0.8"  ; UBUNTU 9.04
+	"/usr/lib/libpcap.so.1.0.0"; UBUNTU 9.04
+	"/usr/lib/libpcap.so.6.0"  ; OpenBSD 4.8
+	"c:/windows/system32/wpcap.dll" ; Win32 XP
+))
+
+(set 'libpcap (files (or
+			(find true (map file? files))
+			(throw-error "cannot find  pcap packet capture library"))))
+
+; import library functions
+(import libpcap "pcap_lookupdev")
+(import libpcap "pcap_lookupnet")
+(import libpcap "pcap_open_live")
+(import libpcap "pcap_compile")
+(import libpcap "pcap_setfilter")
+(import libpcap "pcap_next")
+(import libpcap "pcap_loop")
+(import libpcap "pcap_stats")
+
+; allocate ptr varables used in library API
+(set 'errbuf (dup "\000" 256)) ; for error message
+(set 'fp (dup "\000" 8)) ; sizeof pointer (32 and 64 bit)
+(set 'net "\000\000\000\000") ; IP number of sniffing device
+(set 'mask "\000\000\000\000") ; net mask of sniffing device
+(set 'header (dup "\000" 24)) ; space for packet header (32 and 64 bit)
+(set 'protocols '((6 TCP) (17 UDP) (1 ICMP) (0 IP)))
+
+; constants
+(constant 'PCAP_BUFFSIZE 1518)
+(constant 'PROMISCUOUS 1)
+(constant 'SIZE_ETHER 14) 
+
+; get device
+(set 'dev (main-args 2))
+(when (= dev "")
+	(set 'dev (pcap_lookupdev errbuf)))
+
+(when (zero? dev)
+	(println errbuf)
+	(println "must exit")
+	(exit 1))
+
+(when (= (pcap_lookupnet dev net mask errbuf) -1)
+	(println (get-string errbuf))
+	(println "must exit")
+	(exit 1))
+
+; get filter expression
+(if (main-args 3)
+	(set 'filter-exp (lower-case (main-args 3)))
+	(set 'filter-exp "ip")) ; default is all packets
+
+; get packet count
+(set 'packet-count (int (main-args 4) 10)) ; default 10
+
+; get output options
+(set 'out-opt (or (main-args 5) "none"))	
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(set 'handle (pcap_open_live dev PCAP_BUFFSIZE PROMISCUOUS 1000 errbuf))
+(when (= handle 0)
+	(println (get-string errbuf))
+	(println "must exit")
+	(exit 2))
+
+(when (= (pcap_compile handle fp filter-exp 0 net) -1)
+	(println "could not compile filter:" filter-exp)
+	(println "must exit")
+	(exit 3))
+
+(when (= (pcap_setfilter handle fp) -1)
+	(println "could not install filter:" filter-exp)
+	(println "must exit")
+	(exit 4))
+
+; transform ip number to n.n.n.n
+(define (ip-to-ascii ip)
+	(join (map string (unpack "bbbb" (pack ">lu" ip))) "."))
+	
+; tansform mac address to n:n::n:n:n:n
+(define (eth-to-ascii host)
+	(join (map (fn (x) (format "%02x" x)) (unpack "bbbbbb" host) ) ":"))
+
+; packet handler, called when packet arrives
+(define (report-packet header packet)
+
+	(if bit-64
+		(map set '(tm usec dummy caplen len)  (unpack "Lu lu lu lu lu" header))
+		(map set '(tm usec caplen len)  (unpack "lu lu lu lu" header)))
+	(println "time: " (date tm 0 "%H:%M:%S.") usec " captured:" caplen " wire:" len)
+
+	; get pcap header
+	(map set '(dhost shost type)  (unpack "s6 s6 d" packet))
+	(println "from ether addr: " (eth-to-ascii shost) 
+			" to: " (eth-to-ascii dhost))
+
+	; IP header at p + SIZE_ETHER: sniff_ip
+	(map set '(vhl tos ip-len id off ttl proto sum src dest) 
+		(unpack "> b b u u u b b u lu lu" (+ packet SIZE_ETHER)))
+	(set 'IP_HL (& vhl 0x0f))
+	(set 'IP_V (>> vhl 4))
+
+	(when (or (< IP_HL 5) (< ip-len (* IP_HL 4)))
+		(println "ERROR malformed IP datagram")
+		(throw true))
+
+	(set 'protocol (lookup proto protocols))
+
+	(if ; with multiple <condition> <body> terms
+	; TCP header: sniff_tcp
+	(= protocol 'TCP) ; TCP 6
+	(begin
+		(map set '(sport dport seq ack offx2) 
+			(unpack "> u u lu lu b" (+ packet SIZE_ETHER (* IP_HL 4))))
+		(set 'TH_OFF  (>> (& offx2 0xf0) 4)) ; * 4 -> offset
+		(when (< TH_OFF 5)
+			(println "ERROR malformed TCP segment")
+			(throw true))
+
+		(println protocol " from ip addr: " (ip-to-ascii src) " port:" sport
+                 " to: " (ip-to-ascii dest) " port:" dport)
+	)
+
+	(= protocol 'UDP) ; UDP 17
+	(begin
+		(map set '(sport dport ulen sum) 
+			(unpack "> u u u u" (+ packet SIZE_ETHER (* IP_HL 4))))
+		(set 'TH_OFF 2) ; 2*4=8 bytes of UDP header length
+
+		(println protocol " from " (ip-to-ascii src) " port:" sport
+                 " to " (ip-to-ascii dest) " port:" dport)
+	)
+
+	(= protocol 'ICMP) ; ICMP 1
+	(begin
+		(map set '(type code cksum other) 
+			(unpack "> b b u lu" (+ packet SIZE_ETHER (* IP_HL 4))))
+		(set 'TH_OFF 2) ; 2*4=8 bytes of ICMP header length
+		(println protocol 
+			" from: " (ip-to-ascii src) " to: " (ip-to-ascii dest)) 
+		(println "type: " type " code: " code  " checksum: " cksum)
+	)
+
+	true ; catch all other
+	(begin
+		(set 'TH_OFF 0)
+		(print "Protocol: " proto
+			" from: " (ip-to-ascii src) " to: " (ip-to-ascii dest)) )
+	) ; end if
+
+	; dump payload
+	;(set 'ip-len (min len (- caplen SIZE_ETHER)))
+	(set 'payload-len (- ip-len (* IP_HL 4) (* TH_OFF 4)))
+	(print "packet total len w/o ether-header:" ip-len)
+	(println ", payload length:" payload-len)
+
+	(when (and (zero? payload-len) (!= out-opt "packet"))
+		(throw true))
+
+	(if (= out-opt "packet")
+		(set 'data (unpack (dup "b" ip-len) 
+			(+ packet SIZE_ETHER )))
+		(set 'data (unpack (dup "b" payload-len) 
+			(+ packet SIZE_ETHER (* IP_HL 4) (* TH_OFF 4))))
+	)
+
+	; dump data as hex and ascii
+	(when (or (= out-opt "hex") (= out-opt "packet"))
+		(set 'addr 0)
+		(dolist (line (explode data 16) )
+			(print (format "%05d " addr))
+			(println (format "%-48s" (join (map (fn (b) (format "%02x " b)) line))) " "
+				(join (map (fn (c) (if (or (< c 32) (> c 126)) "." (char c))) line)))
+		(inc addr 16))
+	)
+
+	; dump ascii only
+	(when (= out-opt "ascii")
+		(dolist (line (explode data 64) )
+			(println (join (map (fn (c) (if (or (< c 32) (> c 126)) "." (char c))) line)))
+		)
+	)
+
+	true
+)
+
+(set 'counter 0)
+(println "device: " (get-string dev))
+
+; Method using pcap_next and newLISP controlling
+; this method leves more time in newLISP to do 
+; stuff in the while loop.
+(while (< counter packet-count)
+	(set 'capture '())
+	(set 'packet (pcap_next handle header))
+	(unless (= packet 0)
+		(print "\n--- " (inc counter) "---  ")
+		(catch (report-packet header packet ))
+))
+
+; Alternative method using callback with pcap_loop
+; and pcap library controlling. This leaves less
+; time for newLISP as the waiting for new packets
+; happens inside libpcap
+;(define (callback-handler params header packet)
+;	(unless (= packet 0)
+;		(print "\n--- " (inc counter) "---  ")
+;		(catch (report-packet header packet ))
+;))
+;(pcap_loop handle 20 (callback 0 'callback-handler) 0)
+
+
+; report pcap status
+(set 'pstats (dup "\000" 8))
+(pcap_stats handle pstats)
+(map set '(received dropped) (unpack "lu lu" pstats))
+(println "\npackages dropped: " dropped)
+
+(exit)
+
+; eof
diff --git a/examples/tcltk.lsp b/examples/tcltk.lsp
new file mode 100644
index 0000000..ea5a73c
--- /dev/null
+++ b/examples/tcltk.lsp
@@ -0,0 +1,46 @@
+#!/usr/bin/env newlisp
+;
+; demo how to write Tcl/Tk GUIs controlled from newLISP
+;
+;  a Tcl/Tk installation is required
+;  the example has been tested on Mac OS X and Unix
+;
+
+; setup communications
+(map set '(myin tcout) (pipe))
+(map set '(tcin myout) (pipe))
+(println "wait ...")
+(process "/usr/bin/wish" tcin tcout)
+
+; make GUI
+(write-buffer myout 
+[text]
+wm geometry . 250x90
+wm title . "Tcl/Tk and newLISP"
+
+button .one -text {red}
+button .two -text {green}
+button .three -text {blue}
+label .colorlabel -width 25
+
+grid .one .two .three -padx 8 -row 0
+grid .colorlabel -column 0 -columnspan 3 -pady 6
+
+.one config -command {puts {(call-back "red")}}
+.two config -command {puts {(call-back "green")}}
+.three config -command {puts {(call-back "blue")}}
+
+bind . <Destroy> {puts {(exit)}}
+[/text])
+
+(define (call-back color)
+	(write-line myout (append ".colorlabel config -background " color))
+)
+
+
+; run event loop
+(while (read-line myin)
+	(eval-string (current-line))
+)
+
+;; eof
diff --git a/examples/udp-client.lsp b/examples/udp-client.lsp
new file mode 100644
index 0000000..5d312a1
--- /dev/null
+++ b/examples/udp-client.lsp
@@ -0,0 +1,23 @@
+#!/usr/bin/env newlisp
+
+; Demo client for non-blocking UDP communications
+;
+; Start the server program udp-server.lsp first.
+;
+; Note, that net-listen in UDP mode only binds the socket
+; to the local address, it does not 'listen' as in TCP/IP.
+; v.1.0
+; v.1.1 change net-receive for 10.0
+
+(set 'socket (net-listen 10002 "" "udp"))
+(if (not socket) (println (net-error)))
+(while (not (net-error))
+	(print "enter something -> ")
+	(net-send-to  "127.0.0.1" 10001 (read-line) socket)
+	(net-receive socket buff 255)
+	(println "=> " buff))
+
+(exit)
+
+; eof
+
diff --git a/examples/udp-server.lsp b/examples/udp-server.lsp
new file mode 100644
index 0000000..5af1694
--- /dev/null
+++ b/examples/udp-server.lsp
@@ -0,0 +1,27 @@
+#!/usr/bin/env newlisp
+
+; demo server for non-blocking UDP communications
+;
+; Start this program then start the client udp-client.lsp
+;
+; Note, that net-listen in UDP mode only binds the socket
+; to the local address, it does not 'listen' as in TCP/IP.
+;
+; On Windows the received string for the remote host also contains
+; the port separated by a colon and must parsed out. On UNIX this
+; is not necessary.
+; v.1.0
+; v.1.1 made it work for Windows parseing out the host label
+
+
+(set 'socket (net-listen 10001 "localhost" "udp"))
+(if socket (println "server listening on port " 10001)
+           (println (net-error)))
+(while (not (net-error))
+	(set 'msg (net-receive-from socket 255))
+	(println "->" msg)
+	(net-send-to 
+		(first (parse (nth 1 msg) ":")) (nth 2 msg) (upper-case (first msg)) socket))
+(exit)
+;; eof
+
diff --git a/examples/upload.cgi b/examples/upload.cgi
new file mode 100755
index 0000000..98eaf93
--- /dev/null
+++ b/examples/upload.cgi
@@ -0,0 +1,66 @@
+#!/usr/bin/env newlisp
+#
+# upload.cgi - process uploads from POST multipart/form-data
+#
+# version 1.7
+#
+# works on Apache server 1.2 and after and newLISP server 10.3.0 and after
+# works on newLISP CGI with 10.1 and after
+
+; make compatible with older versions of newLISP
+(when (< (sys-info -2) 10110)
+    (constant (global 'write) write-buffer))
+
+(define (process-upload,
+		; locals
+		len type infile outfile boundary
+		disposition filename start end size
+		bytesread buffer)
+
+	(print "Content-Type: text/html\n\n")
+
+	; check for valid request header
+	(set 'len (int (env "CONTENT_LENGTH") 0))
+	(set 'type (env "CONTENT_TYPE"))
+	(if (not (find ".*multipart/form-data;.*boundary=.*" type 1))
+	      (throw-error "wrong upload format, multipart/form-data content-type not found"))
+
+	; read data into intermediate file
+	(set 'infile (open "upload-file" "write"))
+	(while (read-buffer (device) buffer 1024)
+	    (write infile buffer))
+	(close infile)
+	; get filename and boundaries
+	(set 'infile (open "upload-file" "read"))
+	(set 'boundary (read-line infile)) ; get boundary string
+	(set 'disposition (read-line infile))
+
+	(if (not (find ".*filename=\"(.*)\".*" disposition 1))
+		(throw-error "wrong upload format, did not find filename"))
+	(if (= "" (set 'filename $1))
+		(throw-error "need file name")
+		(set 'filename (last (parse filename "/|\\\\" 0))))
+
+	; read from intermedeate file into permanent file
+	(while (!= "" (read-line infile)))
+	(set 'start (seek infile))
+	(set 'end (search infile boundary))
+	(if (not end)
+		(throw-error "wrong upload format, did not find boundary string")
+		(set 'size (- end start 2)))
+
+	(set 'outfile (open filename "write"))
+	(seek infile start)
+	(while (> size 0)
+	    (set 'bytesread (read-buffer infile buffer (min 1024 size)))
+	    (write outfile buffer bytesread)
+	    (dec size bytesread))
+	(close infile)
+	(close outfile)
+	(delete-file "upload-file"))
+
+(if (not (catch (process-upload) 'result))
+	(print "<h2>" (first (parse result "\\r\\n|\\n" 0)) "</h2>")
+	(print {<h2>file uploaded, click <a href="upload.html">continue</a></h2>}))
+
+(exit)
diff --git a/examples/upload.html b/examples/upload.html
new file mode 100644
index 0000000..5ddfa80
--- /dev/null
+++ b/examples/upload.html
@@ -0,0 +1,14 @@
+<html>
+<head><TITLE>File Upload</TITLE></head>
+
+<body>
+
+<h2>Upload File</font></h2>
+<form name="FileUpload" action="upload.cgi" 
+                        method="POST" enctype="multipart/form-data">
+<input type="file" name="uploaded_data" size="40">
+<input type="submit" value="Upload" name="submit">
+</form>
+
+</body>
+</html>
diff --git a/examples/win32demo.lsp b/examples/win32demo.lsp
new file mode 100644
index 0000000..cb02325
--- /dev/null
+++ b/examples/win32demo.lsp
@@ -0,0 +1,83 @@
+;; @module win32demo.lsp
+;; @description Event loop demo
+;; @author Cyril Slobin
+;; @location http://slobin.pp.ru/newlisp/win32demo.lsp
+;; @version $Id: win32demo.lsp,v 1.4 2010/06/10 02:14:08 slobin Exp $
+
+; see also: http://slobin.livejournal.com/339071.html ; added by LM
+
+(println "win32demo")
+
+(define (import-list library flist)
+    (dolist (fname flist) (import library (string fname))))
+
+(define-macro (@setq %var %value)
+    (set %var (eval %value))
+    (println %var " " (eval %var)))
+
+(import-list "kernel32" '(GetModuleHandleA GetConsoleWindow))
+(import-list "user32" '(PostQuitMessage DefWindowProcA))
+(import-list "user32" '(LoadCursorA RegisterClassA CreateWindowExA))
+(import-list "user32" '(ShowWindow UpdateWindow))
+(import-list "user32" '(GetMessageA TranslateMessage DispatchMessageA))
+
+(setq WM_CREATE 1 WM_DESTROY 2 WM_CHAR 0x102 WM_LBUTTONDOWN 0x201)
+(setq IDC_ARROW 0x7F00 CS_VREDRAW 1 CS_HREDRAW 2 COLOR_WINDOW 5)
+(setq WS_OVERLAPPEDWINDOW 0xCF0000 HWND_MESSAGE -3 SW_SHOWDEFAULT 10)
+
+(@setq hinstance (GetModuleHandleA 0))
+(@setq hconsole (GetConsoleWindow))
+(@setq cursor (LoadCursorA 0 IDC_ARROW))
+
+(define (window-callback-function hwnd message wparam lparam)
+    (cond
+        ((= message WM_CREATE) (println "created") 0)
+        ((= message WM_LBUTTONDOWN) (println "click!") 0)
+        ((= message WM_CHAR) (println (format "char %c" wparam)) 0)
+        ((= message WM_DESTROY) (println "destroyed") (PostQuitMessage 0) 0)
+        (true (DefWindowProcA hwnd message wparam lparam))))
+
+(setq wndproc (callback 0 'window-callback-function))
+(setq classname "newlisp class")
+
+(setq wc (pack (dup "ld" 10)
+            (| CS_HREDRAW CS_VREDRAW)   ; style
+            wndproc                     ; lpfnWndProc
+            0                           ; cbClsExtra
+            0                           ; cbWndExtra
+            hinstance                   ; hInstance
+            0                           ; hIcon
+            cursor                      ; hCursor
+            (+ COLOR_WINDOW 1)          ; hbrBackground
+            0                           ; lpszMenuName
+            classname                   ; lpszClassName
+         ))
+
+(@setq hwc (RegisterClassA wc))
+(@setq hwnd (CreateWindowExA
+                0                       ; dwExStyle
+                "newlisp class"         ; lpClassName
+                "newlisp window"        ; lpWindowName
+                WS_OVERLAPPEDWINDOW     ; dwStyle
+                80 60 640 480           ; x y w h
+                0                       ; hwndParent
+                0                       ; hMenu
+                hinstance               ; hInstance
+                0                       ; hParam
+           ))
+
+; hconsole and HWND_MESSAGE are other useful values for hwndParent
+
+(ShowWindow hwnd SW_SHOWDEFAULT)
+(UpdateWindow hwnd)
+
+(setq msg (pack "n28"))
+
+(until (member (GetMessageA msg hwnd 0 0) '(0 -1))
+    (TranslateMessage msg)
+    (DispatchMessageA msg))
+
+(println "the end")
+
+(exit)
+
diff --git a/examples/xmlrpc.cgi b/examples/xmlrpc.cgi
new file mode 100755
index 0000000..d4efec2
--- /dev/null
+++ b/examples/xmlrpc.cgi
@@ -0,0 +1,227 @@
+#!/usr/bin/env newlisp
+#
+# xmlrpc.cgi - CGI script to handle XML-RPC requests
+#
+# This is similar to xmlrpc-server, but stateless as a new
+# newLISP process is invoked everytime this script is executed.
+# For a XML-RPC server maintaining state run xmlrpc-server.
+#
+# v.1.0 - 2005-01-14  Lutz Mueller
+#
+# v.1.1 - 2005-03-20
+#	method name for newLISP.evalString was listed wrong
+# v.1.2 - 2010-02-09
+#	method name for newLISP.evalString was listed wrong
+# v.1.3  - 2010-10-07
+#	replaced obsolete 'error-text' with 'last-error'
+# v.1.4  - 2012-03-16 bugfixes, thanks Kosh
+#
+# supports the following methods:
+#
+#    Method                   Return     Parameter
+#    ------                   ------     ---------
+#    system.listMethods       string     n/a
+#    system.methodHelp        string     string
+#    system.methodSignature   array      string
+#    newLISP.evalString       base64     base64
+#
+#
+
+(set 'version "1.4")
+
+# formatting templates for responses
+
+(set 'normal-response
+[text]<?xml version="1.0"?>
+<methodResponse>
+   <params>
+      <param>
+         <value>%s</value>
+       </param>
+    </params>
+</methodResponse>
+[/text])
+
+(set 'fault-response
+[text]<?xml version="1.0"?>
+<methodResponse>
+   <fault>
+      <value>
+         <struct>
+            <member>
+               <name>faultCode</name>
+               <value><int>%d</int></value>
+               </member>
+            <member>
+               <name>faultString</name>
+               <value><string>%s</string></value>
+            </member>
+         </struct>
+      </value>
+   </fault>
+</methodResponse>
+[/text])
+
+
+# event handler called when newLISP receives a request
+
+(define (process-post request)
+    (if (not (catch (handle request) 'page))
+	(set 'page (format fault-response 0 page)))
+    (print
+            "Content-Type: text/xml\r\n"
+            "Content-Length: " (length page) "\r\n\r\n"
+            page))
+
+
+(define (handle input, XML contentlength methodName params)
+    (set 'XML "")
+    (xml-type-tags nil nil nil nil)
+    (if (not (set 'XML (xml-parse input (+ 1 2 4 8 16))))
+        (begin
+            (if (not (xml-error)) 
+                (error 3 "No XML or XML is empty")
+		(error 4 (append "XML error: " 
+                                 (first (xml-error))))))
+
+        (set 'XML (first XML)))
+
+    ; get methodName and parameter section
+    (set 'm (match '(methodCall (methodName *) *) XML))
+    (if (not m)
+        (error 5 "Invalid XML-RPC format"))
+
+    (set 'methodName (first (first m)))
+    (set 'params (last m))
+
+    (case methodName
+        ("newLISP.evalString" (newLISP.evalString params))
+        ("system.listMethods" (system.listMethods))
+        ("system.methodHelp" (system.methodHelp params))
+        ("system.methodSignature" (system.methodSignature params))
+        (true (error 6 "Method name not known")))
+)
+
+(define (error no msg)
+    (throw (format fault-response no 
+        (append "newLISP XML-RPC v." version " - " msg))))
+
+
+######################### remote callable methods ##############################
+
+(define (system.listMethods)
+[text]<?xml version="1.0"?>
+<methodResponse>
+   <params>
+      <param><value><array><data>
+         <value><string>system.listMethods</string></value>
+         <value><string>system.methodHelp</string></value>
+         <value><string>system.methodSignature</string></value>
+         <value><string>newLISP.evalString</string></value>
+      </data></array></value></param>
+    </params>
+</methodResponse>
+[/text])
+    
+
+(define (system.methodHelp params, methodName)
+    (set 'methodName (params 0 1 1 1 1))
+    (case methodName
+        ("system.listMethods" (format normal-response "Lists all methods implemented."))
+        ("system.methodHelp" (format normal-response "Documents a method."))
+        ("system.methodSignature" (format normal-response "Shows the signatures of a method."))
+        ("newLISP.evalString" (format normal-response "Evaluate a base64 encoded string."))
+        (true (error 7 "Method name in system.methodHelp not known")))
+)
+
+(define (system.methodSignature params)
+    (set 'methodName (params 0 1 1 1 1))
+    (case methodName
+        ("system.listMethods" (format normal-response 
+"<array>
+  <data>
+   <value>
+    <array>
+     <data>
+      <value>array</value>
+     </data>
+    </array>
+   </value>
+ </data>
+</array>"))
+
+        ("system.methodHelp" (format normal-response 
+"<array>
+  <data>
+   <value>
+    <array>
+     <data>
+      <value>string</value>
+      <value>string</value>
+     </data>
+    </array>
+   </value>
+ </data>
+</array>"))
+
+	("system.methodSignature" (format normal-response 
+"<array>
+  <data>
+   <value>
+    <array>
+     <data>
+      <value>array</value>
+      <value>string</value>
+     </data>
+    </array>
+   </value>
+ </data>
+</array>"))
+
+	("newLISP.evalString" (format normal-response 
+"<array>
+  <data>
+   <value>
+    <array>
+     <data>
+      <value>base64</value>
+      <value>base64</value>
+     </data>
+    </array>
+   </value>
+ </data>
+</array>"))
+
+        (true (error 7 "Method name in system.methodSignature not known")))
+)
+
+(define (newLISP.evalString params, m, result)
+    (set 'm (match '((params (param (value (base64 *))))) params))
+    (if (not m) 
+        (error 8 "Invalid format for method newLISP.evalString")
+        (set 'result 
+            (string (eval-string (base64-dec (first (first m))) MAIN (last (last-error)))))
+    (format normal-response 
+        (append "<base64>" (base64-enc result) "</base64>")) )
+)
+     
+
+########################### MAIN ENTRY POINT #######################
+
+(set 'input (read-line))
+
+(if (not input)
+    (print
+        "Content-type: text/html\r\n\r\n"
+        "<h2>newLISP XML-RPC v." version 
+        ": not a valid XML-RPC request</h2>")
+    (begin
+        (while (read-line) (write input (current-line)))
+        (process-post input))
+)
+
+
+(exit)
+
+
+# eof
diff --git a/guiserver/CHANGES b/guiserver/CHANGES
new file mode 100644
index 0000000..541e8ac
--- /dev/null
+++ b/guiserver/CHANGES
@@ -0,0 +1,985 @@
+0.2
+    documentation corrections regarding default layout of frame and dialog
+
+    switchable look-and-feel with (gs:set-look-and-feel <str-spec>)
+    now on Windows the Windows look and feel is chosen correctly by default
+
+    speedup of interpreter 
+
+0.3
+  suppressed nullpointer error when using gs:set-look-and-feel
+
+	supppress Java error messages on Windows when shuttng down program
+
+  gs:label now can take optional width height has last parameters
+  before ann extra gs:set-size statement was necessary
+
+  width and height specified in gs:button did not work, does now
+	(note that for all other buttons/check-box an extra gs:set-size
+  must still be used to change the size, it will not be added as
+  optional parameters, as it is almost never used)
+
+	now image-button can take pressed icon path after the normal path
+	(gs:image-button 'TheButton "/local/run32.png" "/local/run32p.png")
+
+  now gs:set-color working on frames and dialogs too
+
+  font-demo.lsp showing the fonts built-in on all platforms
+
+  new gs:text-pane for HTML and RTF (future version) formatted text
+  see html-demo.lsp for a demo.
+
+0.4 
+  allow multiple re-starts from same newlisp process, this works together
+  with (gs:listen true)
+
+  parenthesis matching in text-pane and tab-size working on text-pane,
+	will only work on "text/plain" flavore of text-pane
+
+  console.lsp now remembers last directory in file dialogs save/load
+
+	console.lsp now has list boxes for browsing contexts and variables
+
+  changed split-pane syntax adding divider size, leaving out width/height
+  which can be set with extra set-size if required
+
+  combo-box and list-box life update now works and updates the screen 
+  correctly 
+
+  new gs:clear-list empties out a combo-box or list-box
+	eliminated redundant 'action' parameter on message-dialog
+
+  new confirm-dialog similar to message-dialog but 'yes', 'no' and optional 
+  'cancel' button and fires an event.
+
+0.5
+    gs:set-size now works on frames
+
+    new gs:remove-from removes one or more components from a container
+
+    new gs:select-text, gs:cut-text, gs:copy-text  and gs:paste-text
+    with suport for system clipboard, new gs:insert-text
+   
+    gs:set-background/set-color now can take a list for the r g b
+    color components
+
+    list-box now also fires event on key-entering a selection, previously only
+    on mouse-double-click
+
+    avoid Java "index out of bound messages" in parenthesis matching
+
+    restructured text-area and text-pane event:
+    (define (action-handler id code dot mark) ...)
+
+        id = name of text widget
+        code = code of character
+        dot = caret position
+        mark = selection position
+ 
+    if there is no selection then dot and mark are equal
+    if only the caret was moved then code is 65535 (16bit -1)
+
+    working logic for highlighting of cut/copy save/saveAs buttons and
+    related menu items in console.lsp
+
+    working logic of maintaining directories and filenames in commonly
+    established fashion between file operations
+
+    NOTE, console.lsp has been little tested, do not use in production,
+    no confirmation dialogs yet for overwiting files, save before new, etc.
+
+		NOTE that console.lsp is broken on Windwos because iof filepath issues
+    and CR-LF issues in parenhesis matching
+
+    many documentain fixes
+
+0.6
+    gs:set-font working on combo-box and list-box
+
+    parenthesis matching in text-pane working now on Windows too
+
+    file operations working in console.lsp on Windows
+
+    confirm dialog for new button in console when edit buffer is touched
+
+    eliminated crashes with bigger results in output area of console
+
+    context stays selected in console
+
+    console new button action will not reset current directory for file operations
+
+    request-focus now works on text-area and text-pane
+
+    eliminate Java error messages on listboxes
+
+    new gs:select-list-item selects a list box or combo box item
+
+    documentation changes for border-layout and others
+    fixed many documantatin formatting problems
+ 
+0.7
+    because of a change in gs:listen in v. 0.6 all error messages from
+    guiserver where suppresses, which made debugging difficult. Some applications
+    running in guiserver v.0.6 may fail now because error messages are enabled
+    again. E.g. misspelled or missing action handlers would cause no harm
+    in v.0.6, but will let exit an application with an error message in v.0.7.
+
+    gs:window creates a wimndow without any border and system bar. On MacOX X
+    when setting the background in such a window to 
+        (gs:set-background 'thewindow 0 0 0 0)
+    totally transparent, the window will be invisible and widgets ppaced on it
+    seem to float on the desktop (e.g. text from labels)
+
+    the second to- parameter in gs:select-text is now optional and the function
+    will select all text from the from- position to the end of the text.
+
+0.8
+	text-panes and text-areas did not scroll after ading to tab, fixed
+	added action event to gs:tabbed-pane
+    (gs:tabbed-pane <sym-id> <sym-action> <str-orientation> 
+		[<sym-widget> <sym-tab-title> ...])
+	the event reports: tabbed-pane-id tab-id tab-title.
+
+	console.lsp project renamed to  newlisp-console.lsp instead, which is a
+	multi tab lisp editor with run button and console window
+
+	in scrollable text-pane and text-area after gs:set-text will scroll
+	to the beginning, after gs:append-text will scroll to end
+
+	can use gs:set-text in the tabs of a gs:tabbed-pane	
+
+	can use gs:set-icon in the tabs of a gs:tabbed-pane
+
+	more demos: frameless-demo.lsp and clipboard-demo.lsp
+
+0.9
+    Several functions to retrieve system properties:
+    gs:get-version - gets the GUI server version number
+    gs:get-screen - gets width, height and resolution of the screen
+    gs:get-fonts - gets all fonts on the current system
+
+    The following system variables can be used after a property function has
+    been call once:
+    gs:version - the version number
+    gs:screen - list of screen parameters
+    gs:fonts - list of all fonts
+    Once a function has been callled onlyt the variables should be used
+    for efficiency
+
+    two new demos: properties-demo.lsp, allfonts-demo.lsp
+
+    increased possible text size for events from 100K to 1000M 
+    (mainly for editor)
+
+    for do-nothing buttons or or other widgets specify 'gs:no-action as 
+    action-handler
+
+0.93 First 2D canvas and mouse stuff
+   gs:set-select now working for toggle-button, radio-butoon, check-box
+
+   gs:mouse-clicked, gs:mouse-dragged, gs:mouse-moved, gs:mouse-pressed
+   and gs:mouse-released
+
+   new demos mouse-demo.lsp shapes-demo.lsp animation-demo.lsp
+
+   gs:draw-line, gs:draw-rect, gs:draw-circle
+   gs:fill-rect, gs:fill-circle (raound-rect and ellipse in next version)
+
+   gs:paint (gs:stroke for line width in next version)
+
+   gs:delete-tag to delete a tagged group of shapes
+   gs:moce-tag to move  a tagged group of shapes
+
+0.94
+   fixed message box in newlisp-edit.lsp when no c:\temp on Windows
+
+   gs:paint renamed to gs:set-paint
+
+   last gs:set-paint now gets correctly taken when now color is specified in
+   shapes or text
+ 
+   now different fonts on same canvas don't overwrite previous
+
+   documentation for draw-text had syntax in reverse
+   all graphics functions now sorted into all other Functions
+   spellchecked documentation 
+
+   lines are now movable too  
+
+   gs:set-canvas - onlye used for switching between muliple canvases
+   gs:set-translation - move coordinate origin
+   gs:set-scale - scales up or down
+   gs:set-stroke - sets drawing line width and optional cap, join and miter limit
+   gs:draw-arc - draw an arc outline
+   gs:fill-arc - paints a filled arc
+
+   new stroke-demo.lsp - shows lines and outlimes with different strokes and round
+   line ends
+
+   GUI-server signon message now contains version number. Note that in the future
+   newLISP binary installers for Mac OS X and Win32 icons will be placed in the
+   Mac OX X application folder and Win32 desktop for the newlisp-edit.lsp application.
+   Then the signon and connection messages will be unvisible. They are more thought
+   as a debugging aid duwing development.
+
+   On Mac OS X and UNIX applications can be started this way to close the terminal/shell
+   window:
+        newlisp newlisp-edit.lsp & exit
+   this places the GUI-server process into the background and closes the termonal/shell
+
+0.95
+   fixed newlisp-edit.lsp temporal directory detection (again, thanks Sleeper)
+
+   gs:move-tag did not distinguish between tags, fixed
+
+   gs:set-select can take multiple id, flag pairs, fixed
+
+   gs:split-pane divider width in split-pane did not work, fixed
+
+   new gs:draw-ellipse - draws an elllipse outline
+   new gs:fill-ellipse - fills an elllipse
+
+   new gs:set-translation of the canvas origin coordinates
+   new gs:set-rotation set the rotation of the canvas
+
+   all tag transforms below add to the affine transform matrix
+   already in the canvas 
+
+   new gs:hide-tag - hides objects of a tag group
+   new gs:scale-tag - scales an object up or down
+   new gs:translate-tag - translates the coordinate origin of a tag group
+   new gs:show-tag - shows objects of a tag group
+   new gs:rotate-tag - function for rotating objects
+   new gs:shear-tag - function for shearing objects
+
+   like gs:move-tag all other functions work on any shape, text
+   or image. 
+
+   shaped-demo.lsp modified to show funtioning of gs:hide-tag and gs:show-tag
+   via selecting or de-selecting shapes with check boxes
+
+   gs:mouse-wheel - register mouse wheel events
+
+   mouse-demo.lsp - modified to show mouse wheel events
+  
+   animaton-demo.lsp - modified to show the mouse wheel move text up/down
+
+   new rotation-demo.lsp to show rotating objects 
+   new image-demo - shows image zzomin, turning and squashing
+   new textrot-demo - shows text rotation
+
+   gs:draw-text has optional angle parameter (but can also be titled
+   using gs:rotate-tag, see sample program text-rotation.lsp)
+
+   all tag operations have optional flag to turn of screen update
+   this is recommended when using several tag commands in a batch
+   to do only one screen update at the end using gs:update
+   the default for this flag is 'true' for doing the update.
+
+   On all other systems except Mac OS X, double buffering is tried for
+   flicker free performance when animating graphics on systems other than
+   the Mac. The performance of this depends on the graphics cards used.
+   Performance was execellent on 2 Windows system I tried, one of them
+   4 years old.
+
+0.96
+   gs:scale-tag, gs:translate-tag and gs:rotate-tag add to the affine transform matrix
+   already in the canvas (it was wrongly stated before that gs:translate-tag
+   if not accumulative, but it is like all others)
+
+   Corrections in the doc about the behaviour of gs:set-translation, gs:set-scale
+   and gs:set-rotation. Again: they are all absolute, while tag operations are
+   accumulative.
+
+   rotation-demo.lsp and image-demo.lsp have been changed using gs:translate-tag
+   instead the global canvas gs:set-translation. This makes it possible to
+   rotate or scale several tags at the same time, using gs:translate-tag
+   to supply each tag group its own center (set to 0,0). This leads also
+   to better readable code. All object cooridnates to rotate or zoom are
+   best defined in reference to a 0,0 center point and then moved to their
+   pace with gs:translate-tag. See also description of gs:scale-tag in documentation.
+
+   net gs:get-font-metrics - returns width and height of a string to display
+   new gs:draw-round-rect - draw a rectangle with round corners
+   new gs:full-round-rect - fill a rectangle with round corners
+   new gs:draw-polygon - draws a polygon with 3 to N points
+   new gs:fill-polygon - fill a polygon with 3 to N points
+   new gs:set-cursor - set one of 14 cursor shapes
+
+   new cursor-demo.lsp tot show different cursor shapes
+
+0.97
+   gs:mouse-dragged fired invalid events when not defined but gs:mouse-clicked
+   was defined.
+
+   gs:mouse-pressed, gs:mouse-released and gs:mouse-clicked now take an optional
+   'true' parameter. This makes events carry a list of tags, which have been
+   affected by one of the above mouse actions. This can be used to implement
+   object dragging (see the new drag-demo.lsp) it also opens the possibility
+   of creating self-drawn custom controls on a canvas because clicks can be
+   detected on tags. The code mouse-demo.lsp has been simplified to detect
+   tags to delete by using the tag list in the mouse-clicked event.
+
+   events generated by gs:mouse-pressed, gs:mouse-released, gs:mouse-clicked
+   and gs:mouse-dragged besides the new tags spec also carry a number for
+   modifier keys, e.g. pressing ctrl or shift while clicking the mouse.
+   See the modified moused-demo.lsp.
+
+   gs:text-pane and gs:text-area now can register gs:mous-clicked events
+   in the newlisp-edit.lsp app a popup  has been implemented as a right click
+   (or ctrl-click for one-button mouse) to popup an edit menu.
+
+   new drag-demo.lsp
+
+   Point detection is implemented for closed shapes, images and text. Precise
+   deletection is done for images, text, polygons and rectangles, but for
+   circles and ellipses the whole rectangle enclosing the shape is used
+   for calculations. A precise point detection limited only to the inside
+   of the circle or ellipse will be implemented at a later time.
+
+   Images must carry width and height parameters in the gs:draw-image statement.
+   Drawn text is detected by calculating the enclosing rectangle.
+
+   new gs:draw-path - similar to polygon but the path may stay unclosed.
+   new gs:export - exports to an image file in png in RGB + alpha channel
+   format.
+
+   Note that detection will fail if scaling or translation has been used to
+   for the canvas or drawn objects involved, because mouse coordinates do
+   not sync to object coordinates in a scaled or translated coordinate
+   system.
+
+   new gs:menu-pop and gs:show-popup implements popup menus for gs:text-area,
+   gs:text-pane and gs:canvas. For a demo see newlisp-edit.lsp and
+   drag-demo.lsp
+
+   bug fixes in newlisp-edit.lsp when closing other but the last tab.
+
+0.98
+   popup menus on canvas now also working on Win32
+
+   gs:open-file had problems with file masks (changed parameter format)
+
+   new gs:frame-closed - registers an event for a closing frame or dialog
+
+   new gs:find-text - finds and selects text in a text rea or text panel widget
+
+   new gs:mouse-event - registers a general mouse-event for any component
+   see allfonts-demo.lsp, button-demo.lsp  and the Fontbook button in 
+   newlisp-edit.lsp for demo
+
+   changed some shortcut keys in newlisp-edit.lsp to be more standard conform
+
+   newlisp-edit.lsp has now text search and replace implemented
+
+   newlisp-edit.lsp now has fontselection implemented
+
+   splash screen working, see doc for new gs:dispose-splash
+
+0.99
+   gs:find-text selection now positions and highlights correctly on Win32
+
+   now showing directories on Win32 even when file view is constrained to text files:
+   .lsp .c .h .txt .java .htm .html .css .php .pl .py .rb .lisp .el .cl .cpp
+   what are other essential text formats on Win32?
+
+   graceful error recovery on most errors in GUI-server: after the error
+   message box is closed, the app will try continue and not exit as before.
+
+   better parenthesis matching performance on larger files
+   (but minor flicker on Win32)
+
+   gs:get-font-metrics got stuck on last queried value
+
+   gs:set-tab-size when used on gs:text-pane, sets the tabsize in points
+   
+   added ctrl-M to clear monitor area in newlisp-edit.lsp
+
+   find previous, undo and redo in newlisp-edit.lsp
+
+   new gs:undo-text and gs:redo-text, if no menus or code is used
+   ctrl-z and ctrl-shift-z and meta-z meta-shift-z (MacOS X) are
+   still hardwired into gs:text-pane
+
+   text widgets now also respond to the general gs:mouse-event
+
+0.991
+   Text selection was still broken on Win32 when starting out with a file containing
+   carriage returns or when entering new text. It only worked on files loded without
+   CRs even when etering new text. Now it seems to work in all situations, setting
+   a Java system property to LF only and converting text when it goes in/out.
+
+   Changed run button to auxiliary stateful newLISP process as used
+   previously in console.lsp. Now evaluation via the newLISP run button
+   is stateful unless the restart button is hit to restart the 
+   other newLISP process. If  the process exits, e.g. when closing a GUI-server
+   applications the small LED turns red. When hitting the run-newLISP button
+   and the newLISP process is down, it will get restarted automatically.
+
+   Only one GUI applocation should be started at the time from newlisp-edit.lsp
+   starting more than one is unreliable and blocked on MacOX X.
+
+   There are som unreliabilities running GUI-Server apps from newlisp-edit.lsp
+   on Win32, which have not been worked out. Text in the edit area should be saved
+   before running a GUI-server app, to be safe.
+
+ 
+0.992
+  File dialog file mask selection was broken again
+
+0.993
+
+  Eliminated flicker when matching parenthesis in bigger files.
+
+  A canvas now can be treated like any other container adding other
+  widgets to it (see demo textrot-demo.lsp).
+
+  Custom control for font coolors and size in newlisp-edit.lsp
+
+  Now newlisp-editor.lsp stays functional while a lengthy evaluation
+  process is running and outputing to the monitor area. In another tab
+  files can be edite/saved etc.
+
+  Auxiary newLISP process in newlisp-edit.lsp now starts with home directory as
+  current directory
+
+  Trying to start  a second evaluation or trying to restart the newLISP process 
+  will make the led blink in yellow for a second and output "busy" in the monitor 
+  area. 
+ 
+  Trying to quit newlisp-edit.lsp while an evaluating process is running will 
+  leave the newlisp-edit.lsp application unfunctional on the screen until the 
+  evaluating process finishes. On MacOS X the Quit option of the top screen menu
+  can be used to exit newlisp-edit.lsp in this case but on Win32 the task manager 
+  must be used to shut down newlisp-edit.lsp or the other evaluating process.
+
+0.994
+  Many fixes for running programs from the editor. There should be no possibility
+  now to hang the editor, even if a pending newLISP evaluation cannot be finished,
+  the editor should be still functional to edit and save files.
+
+  The yellow led will now stay on when a newLISP evaluation is pending to exit and
+  an attempt has been make to start a second process. When the process has finished
+  the led goes red. Attempting to start another app will do a restart automatically.
+
+  Running GUI-Server apps from newlisp-edit.lsp seems to be reliable now on MacOX X
+  and Windows XP.
+
+  new menu 'File/Save Settings' saves all font, color and current directory when
+  loading file. The settimgs file contains many more settings, which can be changed
+  to give the editor a complete diferent appearance: 
+
+  - The toolbar can be hidden completely or made floatable.
+  - The tabs can be relocated to the bottom, left or right side of the editor.
+  - The window size can be set to a desired X,Y width and height.
+
+  When newlisp-edit.lsp starts the first time and does not encounter a config file
+  it gets created in the current home directory.
+
+  File and settings saving is announced in the monitor area.
+
+  Note, the directory remembered when open the file dialog is the directory of
+  the currently open tab.
+
+  An optional icon can be added to gs:message-dialog when defining the type as "plain".
+  In this case a user supplied icon will be shown.
+
+0.995
+  newlisp-edit.lsp:
+
+  - Font size did not get saved by 'File/Save Settings'.
+
+  - settings file ion Win32 gets now written to APPDATA/newLISP/newlisp-edit.conf
+  where APPDATA is the Win32 environment variable for the applications data
+  directory. If APPDATA is not defined USERPOFILE or DOCUMENT_ROOT is assumed
+  On all other OS .newlisp-edit.conf is written to the users home directory
+  in UNIX like fashion. This may change in the future for the Mac OX X to:
+  ~/Libarary/Application Support/newLISP/newlisp-edit.conf
+
+  - The toolbar can now be detached/reattached from the View menu
+
+  - The Tool menu as a 'Save Settings' option.
+
+  - The Help menu has options to access newLISP and GUI-Server docs.
+
+  - When editing the settings file and leaving an error, the next startup
+  of newlisp-edit will give an error message box with the error.
+
+  - Ctrl-F (Win32) or meta-F (OS X) reenter the find dialog if not already
+  open (this was already in 0.994, but not mentioned).
+
+  - Pressing ESC while in find dialog text field will close the find dialog
+  this is consisten with behaviour of other Java-Swing built-in dialogs.
+  When in the edit area ctrl-D / meta-D, will still work to dispose of the 
+  find-dialog
+
+  - on Mac OS X ctrl-up will select the tab, then keys left or right will
+  let select other tabs. This is Java-Swing built-in behaviour and assumed
+  to work like this on all platforms.
+
+  New gs:menu-item-check for checked menu items (behaves like a check box)
+  
+  A new chapter about writing and debugging event handlers was added in  the 
+  guiserver.lsp.html documentation.
+
+ 0.996
+  newlisp-edit.lsp:
+
+  - settings will now remember loaction and size of newlisp-edit.lsp on the screen 
+
+  - Edit/Find marked edit buffer as dirty, which was not correct (icon and red dot)
+
+  - new menu option Edit/Goto Line
+
+  - mew menu option Files/Recent Files remembers a list of recently saved files
+  the list is automatically updated each time a file is saved and maintained in
+  the file $APPDATA/newlisp-edit-recent on Win32 or in $HOME/.newlisp-edit-recent
+  on Mac OS X and Unix
+
+  popup menus now displayed in correct position on scrollable content
+
+  gs:get-bounds was broken, now displayes on-scrren coordinates for top level windows
+
+  new gs:goto-text - positions cursor in text at row columns position
+
+  new gs:load-text, gs:save-text to directlty load/save docs in to/from gs:text-pane
+  these should not be used from Win32 because they don't work correctly with
+  CR/LF line terminated files when using Edit/Find
+
+  documentation links in the Help menu have been taken out, because browser
+  blocks guiserver.jar from exiting on Win32
+
+ 0.997
+  When using gs:load-text it now correctly filters carriage returns when
+  loading files on Win32 or any other platforms. gs:save-text will always
+  write LF line terminations. If this is not desirable, gs:get-text should
+  be used instead.
+
+  ESC in find dialog also works when cursor in replace text field. ESC will close
+  the dialog without initiaiting search action, as it did wrongly before.
+
+  demo directory accessible from the Help menu
+ 
+  Many additions and corrections to the documentaion. 
+
+0.998
+  new gs:set-syntax-selected for enabling newLISP syntax highlighting in gs:text-pane
+
+  new gs:set-caret-color for setting a caret color in in all text widgets
+
+  new gs:set-selection-color for setting a text selection color
+
+  new gs:set-syntax-colors for setting syntax colors for keywords, comments etc.
+
+  new gs:key-event to register key events for any component (except text widgets,
+  which already register keyevents by default)
+
+  syntax highlighting in newlisp-edit.lsp:
+  - 3 preconfigured themes to choose from for medium, low and high contrast
+  - alt-Y (Win32) or meta-Y (Mac OS X) toggle syntax highlighting on/off
+  - by default all files ending in .lsp are highlighted
+
+0.999
+  newlisp-edit.lsp:
+
+  - any number of syntax profiles can now be configured in the settings file and
+  loaded automatically into the View menu on startup.
+
+  - for the Tool menu scripts can be registered using the settings file. The
+  scripts are run over the content of the current edit tab. The contents of the
+  current edit tab is saved to a tmporary file, and the name of this file is passed
+  as an argument to the script. The output of the script is shown in the monitor
+  area.
+
+  - added tabulator size (in points) to settings file
+
+  - syntax on/off is remembered when switching tabs
+
+  - Edit/Get Position tells line and column positin of text cursor
+
+  - undo/redo was broken when in syntax highlighting mode. Undo/redo is now reset
+  whenever switching syntax highligthing on/off. Loading a file is not part of an
+  undoable operation anymore.
+
+  - eliminated foreground/background color options which are set as part of
+  the color theme. When syntax highlighting is tirned off, foreground and background
+  are still defined by the colors of the current theme.
+
+  - non-existing files in the recent files list are eliminated automatically
+
+  - now remembers correctly screen positions in settings file on all platforms
+
+  - eliminated black flash before splash screen display
+
+  - startup on Win32 w/o run.exe now shows hour glass cursor
+
+  - Clear Monitor disable/enable was faulty
+
+  - now highlights search text when returning to find/replace dialog
+
+  - message box when saving failed, e.g. becuase of wromg permissions
+
+  gs:set-cursor now works correctly in text widgets.
+ 
+  gs:get-bonds now works correctly for on-screen widgets
+
+1.0 feature complete for release August 15th
+
+  fixed unreliable gs:layout
+  
+  fixed occasional text blur in monitor area of newlisp-edit.lsp
+
+  new gs:get-selected-text, works like gs:get-text but retrieves selected text only
+
+  added C, C++, Java and PHP syntax highlighting, automatically selected for .c, .cpp, .h,
+  .java and .php files. When a file does not have a known extension when loading, then no 
+  syntax highlighing is selected. But when switching highlighting on via View/Syntax 
+  or meta-Y (OS X) or alt-Y (Win32), a menu pops up for selecting a highlighting mode.
+
+  some small fixes for newLISP syntax highlighting
+
+  now 2 types of scripts in Tool menu and registered in currentScripts in settings file:
+
+  - Type "content" takes the contens of the edutor and passes it as a file to the script.
+    Anything printed in the script goes to the monitor area in the editor. See the
+    program word-count.lsp for an example
+
+  - Type "selection" takes the selection of the editor and passes it as a file to the
+    script. Anyting printed from thr script replaces the selectin. If nothing
+    was selected the output og the script gets inserted at the text caret.
+
+  The selection replace/insert type of script operation can be undone using Edit/Undo.
+  In the settings file: the menu string, the script path name, the type and an
+  optional shortcut key are specified. See the settings file for an example.
+
+  The settings file gets automatically created when not present on startup
+  and registers the two scripts word-count.lsp and uppercase.lsp. The settings file
+  can be edited using the option in the Tools menu. 
+
+  before installing this version remove old settingfile on Win32:
+  $HOME/Application Data/newLISP/newlisp-edit.conf or on Mac OS X and Unix: 
+  ~/.newlisp-edit.conf
+
+1.01 August 15th release
+ 
+  In newlis-edit.lsp: changed key assignments for fonts smaller/bigger:
+	meta-minus and shift-meta-equals on Mac OS X and ctrl-minus ctrl-equals on Win32.
+  For Mac OS X this is standard, for Win32 it mimics FireFox behaviour.
+
+  The items in gs:list-box and gs:combo-box can be either given individually
+  or in a list: (gs:list-box 'TheListBox 'list-action '("a" "b" "c))
+
+  New gs:play-sound plays/streams .wav and .aif sound files.
+
+
+1.03
+  The monitor area now works also as a newLISP shell, where expressions can
+  be typed in directly and evaluated. The red/green led is not necessary
+  anymore. The shell can be restarted at any time, even if a process is running.
+  The run button will only work if the shell is present. If the shell is exited
+  by a program, hit the restart button to restart. When restarting the shell
+  while a program in it is running, the program will quit and the shell restart.
+
+  When the monitor/shell area has focus:
+    Ctrl-l clears monitor and gives shell prompt (like Meta-m/Alt-m)
+    Ctrl-p copies previous command
+  Other common readline/editing commands usual in UNIX shells may be implemented
+  in the future.
+
+  On Win32 Ctrl-l used to be "goto line" now: Alt-l
+  On Win32 Ctrl-Shift-l used to "show current line/column" now: shift-Alt-l
+
+  newLISP-edit can be exited at any time, if a process is still running in the
+  shell window it keeps on running after newLISP-edit closed.
+
+  New gs:run-shell installs a shell process in the monitor area
+  New gs:eval-shell send a string for evaluation in the shell
+  New gs:destroy-shell destroys the shell
+
+  Note that newlis-edit.lsp uses newISP as a shell process, but other shells
+  can be started using gs:run-shell.
+
+  New gs:reorder-tags reorders the stacking order of tagged images.
+  See the file drag-demo.lsp for usage (comment in gs:reorder-tags statement
+  in line 47)
+
+1.04
+  Monitor background and foreground colors are now configuable in settings file
+  do a File/Save Settings first to have the new config variables registered, then
+  Tools/Edit Settings for editing: currentMonitorBackground and currentMonitorForeground.
+
+  Fix when evaluating in shell area after Ctrl-L, Meta-M (Alt-M).
+
+  Eliminated some quirks when copying/pasting between editor and monitor/shell area, and
+  when hitting enter in the middle of an edited command.
+
+  Now full commandline history in shell-commandline when using arrow-up/down.
+
+  meta-1, meta-2 (alt-1, alt-2 on Win32) for switching between editor and shell/monitor.
+
+  More bash-shell like key bindings on UNIX: Ctrl-A beginnining of line after the
+  shell prompt , Ctrl-E end of line (in gs:text-area with shell attached).
+
+  new gs:color-tag colors all shapes with the same tag
+
+1.05
+  gs:get-text now can be called without an action handler to return the text
+  immedeately. This new synchronous mnode of gs:get-text is not recommended when
+  receiving larger text areas, as the call is blocking until all text is returned,
+  but makes coding simple data forms a lot shorter.
+
+  gs:mouse-move now can take an additional boolean parameter to indicate that
+  a list of tags are to be returned in the mouse-move event handler. The flag
+  should not be used when large amount of tags are present as it can slow down
+  performance significantly calculating and transmitting tag lists on every
+  mouse movement.
+
+  gs:key-event now also can be registered as a second key listener on text widgets.
+  This is espacially interesting on gs:text-field, where individual key action
+  could not be captured before, as the normal handler registered with gs:text-area
+  only handles the ENTER and ESC key.
+
+  fix in gs:run-shell for shells without prompts
+
+  now uses patform independent: 
+    (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+  in all demo files to load guiserver.lsp
+
+1.06
+  edit buffer did not get marked as dirty when cutting/pasting into clean buffer
+
+  when file-recent-loading->saving->file-recent-reloading the same file editor crashed
+
+  make sure shell proccesses in monitor window are destroyed when closing newlisp-edit
+
+  because of new 'process' in newlisp core full java path is needed in process statement
+  in gs:init function. Assumes /usr/bin/java
+
+1.07
+  Tcp/Ip connection between Guiserver and newLISP now goes via 127.0.0.1, not localhost
+  to avoid loss of connection when computer sleeps, while an GS application was
+  running.
+
+  when runniung editor contents and shell is dow, the shell will be restarted 
+  automatically
+
+  the editor now  loads, saves and displays UTF-8 correctly
+
+1.08
+  Guiserver now adjusts automatically to set UTF-8 on/off depending on newLISP version
+
+  The Win32 is again shipped as not UTF-8 by default.
+
+  new gs:window-moved and gs:window-resized. See new demo file move-resize-demo.lsp
+
+1.09
+  reverse "meta N" and "shift meta N" on OS X to be standard with "meta N" new window/tab
+  on OS X
+
+  gs:mouse-event now can also be used on list boxes made with gs:list-box, this makes
+  it possible to process single clicks.
+
+1.10
+  the gs:list-box event now responds on any click-count, previously only on 2 for
+  double click. Addtionally the click-count is transmitted in the event as the last
+  parameter
+
+1.11
+  replace all can now be redone, double undo not required any more for replace
+
+  new gs:undo-enable undo is currently disabled in newlisp-edit for find/replace 
+  because of instabilities
+
+1.12
+  newlisp-edit "Undo Previous" button in find dialog, this is used to undo replacements.
+  Replacements cannot be undone with normal undo when the find dialog is closed again,
+  but can only be undone from inside the find dialog
+
+1.12-13-14
+  in guiserver.lsp now checking JAVA_HOME when not Win32 or OS X
+
+1.15
+  fixed highlighing for 'pop-assoc'
+
+1.16
+  highlighting for regex-comp, spawn, sync and abort
+
+  a bug fix for newlisp-edit.lsp 1.12 for an editor crash caused by index overrun
+  in switch-to-tab function
+
+  newlisp-edit.lsp will quit right away when buffers are clean without showing
+  "You really ..." dialog
+
+  fixed  gs:text-area area hangup when deleting backwards beyond beginning o line 
+  and hitting enter
+
+1.17
+  UTF-8 gs:set-text for gs:text-pane, gs:text-area and gs:text-field.
+
+1.18
+  UTF-8 text now working on all widgets and setter/getter functions. UTF-8 is
+  enabled by default on the Mac OS X installer but not on Win32 which uses 
+  ISO 8859 code pages to display some eastern European and Middle Eastern fonts.
+  Running an UTF-8 enabled version with newLISP-GS on Win32 will automatically
+  switch newLISP-GS to UTF-8.
+
+  new gs:midi-init, gs:midi-close, gs:midi-patch, gs:play-note, gs:play-sequence
+  gs:add-track and gs:mute-track for controlling an internal MIDI device. 
+  On Win32 a soundbank must be installed, see the description for gs:play-note 
+  for more details, where to get and how to install a soundbank file.
+
+1.19 
+  Non-default directory install on Win32 now works. Windows must be rebooted
+  when not accepting the default directory, so the different path set in
+  the environment variable NEWLISPDIR can come into effect.
+
+  New gs:save-sequence saves sequences created using gs:add-track to a MIDI
+  file. 
+
+  gs:midi-init now can take a file path to an external soundbank file.
+
+  gs:channel-bend can be used to tune a channel up or down by a halftone
+
+1.20
+  fixed check option in gs:menu-item-check 
+
+1.21
+  gs:channel-bend did not remember channel specific setting when using on more
+  than one channel
+
+  reworked handling of bpm and resolution (gs:midi-bpm). Now recording with
+  gs:save-sequence will work for any BPM settings correctly
+
+  notes in gs:play-note and gs:add-track now can have an optional last parameter
+  for a note specific pitch-pend
+ 
+1.22
+  when history line in cursor-up keystroke in minitor area contains more than
+  one line only the last line will enter history
+  
+  gs:set-canvas did not change current canvas for guiserver.lsp
+  
+1.23
+  fixed a long standing bug when copying pasting inside the monitor area
+  
+1.24
+  some code cleanup in TextAreaWidget.java
+  
+  Ctrl-A and HOME in monitor area now go to beginning of line _after_ the prompt
+  Ctrl-P goes up in history, Ctrl-N goes down in history (like cursor UP, DOWN)
+  Most Emacs (or Bash shell) commandline editing key strokes now work in the 
+  monitor area
+
+1.25 changes for 9.9.2
+
+1.26 guiserver
+  don't repeat last color change on keystroke but display normal color
+
+1.27
+  added $it, bits, estack and read-utf8 to syntax highlighting
+
+1.28
+  [cmd][/cmd] tags can now be used in the monitor area
+1.29
+  added transfer-event to syntax highlighter
+
+1.30 a fix in the syntax highlighter for newLISP mode 
+  in newlisp-edit.sp font can now shanged in both, the editor and the monitor
+
+1.31 syntax highlighting for new functions
+
+1.32 the function gs:color-tag was documented but not implemented
+     in newlisp-edit.lsp dirty-buffer indication did not work with Ctrl-x/v/z/Z
+     and Cmd-x/v/z/Z
+
+1.33/34 added new functions to the syntax highlighter
+
+1.35 added new 'extend' and changed all copyright notes to 2010
+
+1.36 added 'term', '++', '--' and eliminated 'name' from
+     SyntaxHighligher.java
+
+1.37 new OSXAdapter.java from Apple and related changes in guiserver.java
+     add 'serialVersionUID' to various files to avoid warnings in new Java versions
+
+1.38 an additional parameter in gs:text-field specifies a cover character to use
+     the text-field for password entry
+
+     new textfield-demo.lsp
+
+     a UTF-8 fix for gs:get-fonts when font names 
+
+     a UTF-8 fix for gs:append-text for labels 
+
+     a UTF-8 dix gs:select-list-items for combo boxes, added to widget-demo-(ru, jp).lsp
+
+     a UTF-8 fix for gs:get-text for Dialog widgets 
+
+     a UTF-8 fix for gs:menu-item-check
+
+     a UTF-8 fix for the tabbed pane when tabes are selected
+
+     a UTF-8 fix for gs:set-tool-tab
+
+     a UTF-8 fix for gs:set-font when font names are in UTF-8
+
+1.39
+     New Base64Coder.java with UTF8 aware encodeStringUTF8() and decodeStringUTF8()
+
+1.40
+     Syntax highlighting for date-parse (new writing of parse-date), date-list,
+     net-packet and net-ipv
+
+1.41
+     Instability when nesting gs:check-event calls inside handler functions called
+     from gs:listen, was entirely caused by an interaction of the global variable
+     'event' used in both functions. This variable is now localized in both functions.
+     Seperation of synchronous versus asynchronous communications, as suggested by
+     a user is therefore not necessary.
+
+1.42
+    New table widget and support functions with code contributed by Unya from:
+    http://newlispfanclub.alh.net/forum/
+
+1.43 
+    Bug fix in table API
+
+1.44
+    fixed error message in gs:save-sequence
+
+1.45
+    Some error messages in the Midi part now exit the program to avoid error dialog
+    loops.
+
+    Added struct to SyntaxHighlighter.java
+
+1.46 added various new primitives to SyntaxHighlighter.java
+
+1.47 gs:get-text now handles empty gs:text-field correctly
+
+1.48 added various new primitives to SyntaxHighlighter.java
+     syntxa highlighting for binary numbers like 0b10101
+
+1.50 fixed gs:run-shell in newlisp-edit.lsp and TextAreaWidget.java for different
+     handling of Runtime.getRuntime().exec(cmdArray) in Java 7 update 21.
+
+1.51 
+   When adding columns with empty string headers, this will not any more put the 
+   column number as header. This allows to add columns to headerless tables, as 
+   possible when supplying empty string headers in the initial gs:table statement.
+
+1.60
+   New table functions igs:table-remove-row, gs:table-set-column-name and 
+   gs:table-set-row-count. Thanks to Ferry de Bruin. 
+   The nameing of gs:table-set-row-number is deprecated and should be called
+   as gs:table-show-row-number. The old naming will continue to work.
+
+1.60
+   Addtions to the table interface.
+
+1.62
+   Make +123 and +1.23 work in syntax highlighter.
+   Make sicentific notation e.g. 1.23e-4 work in syntax highlighter.
+
+1.66 fixed screeen update when scrolling, fixed guierver quit menu.
+
diff --git a/guiserver/COPYING b/guiserver/COPYING
new file mode 100644
index 0000000..26f43a3
--- /dev/null
+++ b/guiserver/COPYING
@@ -0,0 +1,1046 @@
+Copyright information for guiserver.jar
+---------------------------------------
+
+Source code for this package copyright (c) Lutz Mueller is
+licensed under the "GNU GENERAL PUBLIC LICENSE Version 3, June 2007".
+The text of this license is contained in this file.
+
+Documentation found in this package is licensed under the
+"GNU Free Documentation License Version 1.2, November 2002".
+The text of this license is contained in this file.
+
+All icons and images are copyright (c) Michael Michaels
+under the "GNU GENERAL PUBLIC LICENSE Version 3, June 2007".
+
+Following:
+
+- GNU General Public License
+- GNU Free Documentation License
+
+---------------------------------------------------------------------
+
+
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+ 
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+  
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+		     END OF TERMS AND CONDITIONS
+
+
+-----------------------------------------------------------------------------
+
+		GNU Free Documentation License
+		  Version 1.2, November 2002
+
+
+ Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
+     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+0. PREAMBLE
+
+The purpose of this License is to make a manual, textbook, or other
+functional and useful document "free" in the sense of freedom: to
+assure everyone the effective freedom to copy and redistribute it,
+with or without modifying it, either commercially or noncommercially.
+Secondarily, this License preserves for the author and publisher a way
+to get credit for their work, while not being considered responsible
+for modifications made by others.
+
+This License is a kind of "copyleft", which means that derivative
+works of the document must themselves be free in the same sense.  It
+complements the GNU General Public License, which is a copyleft
+license designed for free software.
+
+We have designed this License in order to use it for manuals for free
+software, because free software needs free documentation: a free
+program should come with manuals providing the same freedoms that the
+software does.  But this License is not limited to software manuals;
+it can be used for any textual work, regardless of subject matter or
+whether it is published as a printed book.  We recommend this License
+principally for works whose purpose is instruction or reference.
+
+
+1. APPLICABILITY AND DEFINITIONS
+
+This License applies to any manual or other work, in any medium, that
+contains a notice placed by the copyright holder saying it can be
+distributed under the terms of this License.  Such a notice grants a
+world-wide, royalty-free license, unlimited in duration, to use that
+work under the conditions stated herein.  The "Document", below,
+refers to any such manual or work.  Any member of the public is a
+licensee, and is addressed as "you".  You accept the license if you
+copy, modify or distribute the work in a way requiring permission
+under copyright law.
+
+A "Modified Version" of the Document means any work containing the
+Document or a portion of it, either copied verbatim, or with
+modifications and/or translated into another language.
+
+A "Secondary Section" is a named appendix or a front-matter section of
+the Document that deals exclusively with the relationship of the
+publishers or authors of the Document to the Document's overall subject
+(or to related matters) and contains nothing that could fall directly
+within that overall subject.  (Thus, if the Document is in part a
+textbook of mathematics, a Secondary Section may not explain any
+mathematics.)  The relationship could be a matter of historical
+connection with the subject or with related matters, or of legal,
+commercial, philosophical, ethical or political position regarding
+them.
+
+The "Invariant Sections" are certain Secondary Sections whose titles
+are designated, as being those of Invariant Sections, in the notice
+that says that the Document is released under this License.  If a
+section does not fit the above definition of Secondary then it is not
+allowed to be designated as Invariant.  The Document may contain zero
+Invariant Sections.  If the Document does not identify any Invariant
+Sections then there are none.
+
+The "Cover Texts" are certain short passages of text that are listed,
+as Front-Cover Texts or Back-Cover Texts, in the notice that says that
+the Document is released under this License.  A Front-Cover Text may
+be at most 5 words, and a Back-Cover Text may be at most 25 words.
+
+A "Transparent" copy of the Document means a machine-readable copy,
+represented in a format whose specification is available to the
+general public, that is suitable for revising the document
+straightforwardly with generic text editors or (for images composed of
+pixels) generic paint programs or (for drawings) some widely available
+drawing editor, and that is suitable for input to text formatters or
+for automatic translation to a variety of formats suitable for input
+to text formatters.  A copy made in an otherwise Transparent file
+format whose markup, or absence of markup, has been arranged to thwart
+or discourage subsequent modification by readers is not Transparent.
+An image format is not Transparent if used for any substantial amount
+of text.  A copy that is not "Transparent" is called "Opaque".
+
+Examples of suitable formats for Transparent copies include plain
+ASCII without markup, Texinfo input format, LaTeX input format, SGML
+or XML using a publicly available DTD, and standard-conforming simple
+HTML, PostScript or PDF designed for human modification.  Examples of
+transparent image formats include PNG, XCF and JPG.  Opaque formats
+include proprietary formats that can be read and edited only by
+proprietary word processors, SGML or XML for which the DTD and/or
+processing tools are not generally available, and the
+machine-generated HTML, PostScript or PDF produced by some word
+processors for output purposes only.
+
+The "Title Page" means, for a printed book, the title page itself,
+plus such following pages as are needed to hold, legibly, the material
+this License requires to appear in the title page.  For works in
+formats which do not have any title page as such, "Title Page" means
+the text near the most prominent appearance of the work's title,
+preceding the beginning of the body of the text.
+
+A section "Entitled XYZ" means a named subunit of the Document whose
+title either is precisely XYZ or contains XYZ in parentheses following
+text that translates XYZ in another language.  (Here XYZ stands for a
+specific section name mentioned below, such as "Acknowledgements",
+"Dedications", "Endorsements", or "History".)  To "Preserve the Title"
+of such a section when you modify the Document means that it remains a
+section "Entitled XYZ" according to this definition.
+
+The Document may include Warranty Disclaimers next to the notice which
+states that this License applies to the Document.  These Warranty
+Disclaimers are considered to be included by reference in this
+License, but only as regards disclaiming warranties: any other
+implication that these Warranty Disclaimers may have is void and has
+no effect on the meaning of this License.
+
+
+2. VERBATIM COPYING
+
+You may copy and distribute the Document in any medium, either
+commercially or noncommercially, provided that this License, the
+copyright notices, and the license notice saying this License applies
+to the Document are reproduced in all copies, and that you add no other
+conditions whatsoever to those of this License.  You may not use
+technical measures to obstruct or control the reading or further
+copying of the copies you make or distribute.  However, you may accept
+compensation in exchange for copies.  If you distribute a large enough
+number of copies you must also follow the conditions in section 3.
+
+You may also lend copies, under the same conditions stated above, and
+you may publicly display copies.
+
+
+3. COPYING IN QUANTITY
+
+If you publish printed copies (or copies in media that commonly have
+printed covers) of the Document, numbering more than 100, and the
+Document's license notice requires Cover Texts, you must enclose the
+copies in covers that carry, clearly and legibly, all these Cover
+Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
+the back cover.  Both covers must also clearly and legibly identify
+you as the publisher of these copies.  The front cover must present
+the full title with all words of the title equally prominent and
+visible.  You may add other material on the covers in addition.
+Copying with changes limited to the covers, as long as they preserve
+the title of the Document and satisfy these conditions, can be treated
+as verbatim copying in other respects.
+
+If the required texts for either cover are too voluminous to fit
+legibly, you should put the first ones listed (as many as fit
+reasonably) on the actual cover, and continue the rest onto adjacent
+pages.
+
+If you publish or distribute Opaque copies of the Document numbering
+more than 100, you must either include a machine-readable Transparent
+copy along with each Opaque copy, or state in or with each Opaque copy
+a computer-network location from which the general network-using
+public has access to download using public-standard network protocols
+a complete Transparent copy of the Document, free of added material.
+If you use the latter option, you must take reasonably prudent steps,
+when you begin distribution of Opaque copies in quantity, to ensure
+that this Transparent copy will remain thus accessible at the stated
+location until at least one year after the last time you distribute an
+Opaque copy (directly or through your agents or retailers) of that
+edition to the public.
+
+It is requested, but not required, that you contact the authors of the
+Document well before redistributing any large number of copies, to give
+them a chance to provide you with an updated version of the Document.
+
+
+4. MODIFICATIONS
+
+You may copy and distribute a Modified Version of the Document under
+the conditions of sections 2 and 3 above, provided that you release
+the Modified Version under precisely this License, with the Modified
+Version filling the role of the Document, thus licensing distribution
+and modification of the Modified Version to whoever possesses a copy
+of it.  In addition, you must do these things in the Modified Version:
+
+A. Use in the Title Page (and on the covers, if any) a title distinct
+   from that of the Document, and from those of previous versions
+   (which should, if there were any, be listed in the History section
+   of the Document).  You may use the same title as a previous version
+   if the original publisher of that version gives permission.
+B. List on the Title Page, as authors, one or more persons or entities
+   responsible for authorship of the modifications in the Modified
+   Version, together with at least five of the principal authors of the
+   Document (all of its principal authors, if it has fewer than five),
+   unless they release you from this requirement.
+C. State on the Title page the name of the publisher of the
+   Modified Version, as the publisher.
+D. Preserve all the copyright notices of the Document.
+E. Add an appropriate copyright notice for your modifications
+   adjacent to the other copyright notices.
+F. Include, immediately after the copyright notices, a license notice
+   giving the public permission to use the Modified Version under the
+   terms of this License, in the form shown in the Addendum below.
+G. Preserve in that license notice the full lists of Invariant Sections
+   and required Cover Texts given in the Document's license notice.
+H. Include an unaltered copy of this License.
+I. Preserve the section Entitled "History", Preserve its Title, and add
+   to it an item stating at least the title, year, new authors, and
+   publisher of the Modified Version as given on the Title Page.  If
+   there is no section Entitled "History" in the Document, create one
+   stating the title, year, authors, and publisher of the Document as
+   given on its Title Page, then add an item describing the Modified
+   Version as stated in the previous sentence.
+J. Preserve the network location, if any, given in the Document for
+   public access to a Transparent copy of the Document, and likewise
+   the network locations given in the Document for previous versions
+   it was based on.  These may be placed in the "History" section.
+   You may omit a network location for a work that was published at
+   least four years before the Document itself, or if the original
+   publisher of the version it refers to gives permission.
+K. For any section Entitled "Acknowledgements" or "Dedications",
+   Preserve the Title of the section, and preserve in the section all
+   the substance and tone of each of the contributor acknowledgements
+   and/or dedications given therein.
+L. Preserve all the Invariant Sections of the Document,
+   unaltered in their text and in their titles.  Section numbers
+   or the equivalent are not considered part of the section titles.
+M. Delete any section Entitled "Endorsements".  Such a section
+   may not be included in the Modified Version.
+N. Do not retitle any existing section to be Entitled "Endorsements"
+   or to conflict in title with any Invariant Section.
+O. Preserve any Warranty Disclaimers.
+
+If the Modified Version includes new front-matter sections or
+appendices that qualify as Secondary Sections and contain no material
+copied from the Document, you may at your option designate some or all
+of these sections as invariant.  To do this, add their titles to the
+list of Invariant Sections in the Modified Version's license notice.
+These titles must be distinct from any other section titles.
+
+You may add a section Entitled "Endorsements", provided it contains
+nothing but endorsements of your Modified Version by various
+parties--for example, statements of peer review or that the text has
+been approved by an organization as the authoritative definition of a
+standard.
+
+You may add a passage of up to five words as a Front-Cover Text, and a
+passage of up to 25 words as a Back-Cover Text, to the end of the list
+of Cover Texts in the Modified Version.  Only one passage of
+Front-Cover Text and one of Back-Cover Text may be added by (or
+through arrangements made by) any one entity.  If the Document already
+includes a cover text for the same cover, previously added by you or
+by arrangement made by the same entity you are acting on behalf of,
+you may not add another; but you may replace the old one, on explicit
+permission from the previous publisher that added the old one.
+
+The author(s) and publisher(s) of the Document do not by this License
+give permission to use their names for publicity for or to assert or
+imply endorsement of any Modified Version.
+
+
+5. COMBINING DOCUMENTS
+
+You may combine the Document with other documents released under this
+License, under the terms defined in section 4 above for modified
+versions, provided that you include in the combination all of the
+Invariant Sections of all of the original documents, unmodified, and
+list them all as Invariant Sections of your combined work in its
+license notice, and that you preserve all their Warranty Disclaimers.
+
+The combined work need only contain one copy of this License, and
+multiple identical Invariant Sections may be replaced with a single
+copy.  If there are multiple Invariant Sections with the same name but
+different contents, make the title of each such section unique by
+adding at the end of it, in parentheses, the name of the original
+author or publisher of that section if known, or else a unique number.
+Make the same adjustment to the section titles in the list of
+Invariant Sections in the license notice of the combined work.
+
+In the combination, you must combine any sections Entitled "History"
+in the various original documents, forming one section Entitled
+"History"; likewise combine any sections Entitled "Acknowledgements",
+and any sections Entitled "Dedications".  You must delete all sections
+Entitled "Endorsements".
+
+
+6. COLLECTIONS OF DOCUMENTS
+
+You may make a collection consisting of the Document and other documents
+released under this License, and replace the individual copies of this
+License in the various documents with a single copy that is included in
+the collection, provided that you follow the rules of this License for
+verbatim copying of each of the documents in all other respects.
+
+You may extract a single document from such a collection, and distribute
+it individually under this License, provided you insert a copy of this
+License into the extracted document, and follow this License in all
+other respects regarding verbatim copying of that document.
+
+
+7. AGGREGATION WITH INDEPENDENT WORKS
+
+A compilation of the Document or its derivatives with other separate
+and independent documents or works, in or on a volume of a storage or
+distribution medium, is called an "aggregate" if the copyright
+resulting from the compilation is not used to limit the legal rights
+of the compilation's users beyond what the individual works permit.
+When the Document is included in an aggregate, this License does not
+apply to the other works in the aggregate which are not themselves
+derivative works of the Document.
+
+If the Cover Text requirement of section 3 is applicable to these
+copies of the Document, then if the Document is less than one half of
+the entire aggregate, the Document's Cover Texts may be placed on
+covers that bracket the Document within the aggregate, or the
+electronic equivalent of covers if the Document is in electronic form.
+Otherwise they must appear on printed covers that bracket the whole
+aggregate.
+
+
+8. TRANSLATION
+
+Translation is considered a kind of modification, so you may
+distribute translations of the Document under the terms of section 4.
+Replacing Invariant Sections with translations requires special
+permission from their copyright holders, but you may include
+translations of some or all Invariant Sections in addition to the
+original versions of these Invariant Sections.  You may include a
+translation of this License, and all the license notices in the
+Document, and any Warranty Disclaimers, provided that you also include
+the original English version of this License and the original versions
+of those notices and disclaimers.  In case of a disagreement between
+the translation and the original version of this License or a notice
+or disclaimer, the original version will prevail.
+
+If a section in the Document is Entitled "Acknowledgements",
+"Dedications", or "History", the requirement (section 4) to Preserve
+its Title (section 1) will typically require changing the actual
+title.
+
+
+9. TERMINATION
+
+You may not copy, modify, sublicense, or distribute the Document except
+as expressly provided for under this License.  Any other attempt to
+copy, modify, sublicense or distribute the Document is void, and will
+automatically terminate your rights under this License.  However,
+parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+
+10. FUTURE REVISIONS OF THIS LICENSE
+
+The Free Software Foundation may publish new, revised versions
+of the GNU Free Documentation License from time to time.  Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.  See
+http://www.gnu.org/copyleft/.
+
+Each version of the License is given a distinguishing version number.
+If the Document specifies that a particular numbered version of this
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that specified version or
+of any later version that has been published (not as a draft) by the
+Free Software Foundation.  If the Document does not specify a version
+number of this License, you may choose any version ever published (not
+as a draft) by the Free Software Foundation.
+
+
+ADDENDUM: How to use this License for your documents
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and
+license notices just after the title page:
+
+    Copyright (c)  YEAR  YOUR NAME.
+    Permission is granted to copy, distribute and/or modify this document
+    under the terms of the GNU Free Documentation License, Version 1.2
+    or any later version published by the Free Software Foundation;
+    with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
+    A copy of the license is included in the section entitled "GNU
+    Free Documentation License".
+
+If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
+replace the "with...Texts." line with this:
+
+    with the Invariant Sections being LIST THEIR TITLES, with the
+    Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
+
+If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License,
+to permit their use in free software.
+
+---------------------------------------------------------------------
diff --git a/guiserver/Makefile b/guiserver/Makefile
new file mode 100644
index 0000000..18ccd88
--- /dev/null
+++ b/guiserver/Makefile
@@ -0,0 +1,18 @@
+# this make file is only used during development
+# the main makefile in the newlisp-x.x.x/ will
+# normally peform the installation below
+
+all:
+	javac -Xlint java/*.java
+	mv java/*.class .
+	jar cmf Manifest guiserver.jar *.class images/*.png
+	rm *.class
+
+install:
+	-install -d  /usr/local/share/newlisp/guiserver
+	-install -d  /usr/local/share/doc/newlisp/guiserver
+	-install -m 644 guiserver.jar /usr/local/share/newlisp/
+	-install -m 644 guiserver.lsp /usr/local/share/newlisp/
+	-install -m 644 index.html /usr/local/share/doc/newlisp/guiserver/
+	-install -m 644 guiserver.lsp.html /usr/local/share/doc/newlisp/guiserver/
+	-install -m 755 newlisp-edit.lsp /usr/local/bin/newlisp-edit
diff --git a/guiserver/Manifest b/guiserver/Manifest
new file mode 100644
index 0000000..0ec706d
--- /dev/null
+++ b/guiserver/Manifest
@@ -0,0 +1 @@
+Main-Class: guiserver
diff --git a/guiserver/allfonts-demo.lsp b/guiserver/allfonts-demo.lsp
new file mode 100644
index 0000000..0af393b
--- /dev/null
+++ b/guiserver/allfonts-demo.lsp
@@ -0,0 +1,43 @@
+#!/usr/local/bin/newlisp
+;;
+;; allfonts-demo.lsp - show all fonts on the system
+;; this program also demonstrates that strings can be used instead 
+;; of symbols for widget names (label in this case)
+
+;;;; initialization
+(set-locale "C")
+
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+;;;; describe the GUI
+(gs:frame 'AllFontsDemo 100 100 500 400)
+(gs:set-background 'AllFontsDemo 1 1 1)
+(gs:get-fonts)
+(gs:panel 'FontPanel)
+(gs:set-grid-layout 'FontPanel (length gs:fonts) 1 0 0)
+(gs:set-text 'AllFontsDemo (string "All " (length gs:fonts) " fonts on this system"))
+(dolist (font gs:fonts)
+	(set 'font-label (string "label-" $idx))
+	(gs:label font-label font)
+	(gs:set-size font-label 100 30)
+	(gs:set-font font-label font 24 "plain")
+	(gs:mouse-event font-label 'mouse-action)
+	(gs:add-to 'FontPanel font-label))
+
+(gs:scroll-pane 'Scroll 'FontPanel)
+(gs:add-to 'AllFontsDemo 'Scroll)
+(gs:set-visible 'AllFontsDemo true)
+
+
+(define (mouse-action id type x y button cnt mods)
+	(gs:set-text 'AllFontsDemo 
+		(format "%s %s %d:%d button:%d count:%d mod-key:%d" id type x y button cnt mods))
+)
+;;;; listen for incoming action requests and dispatch
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/animation-demo.lsp b/guiserver/animation-demo.lsp
new file mode 100644
index 0000000..ff78562
--- /dev/null
+++ b/guiserver/animation-demo.lsp
@@ -0,0 +1,60 @@
+#!/usr/local/bin/newlisp
+;;
+;; animation-demo.lsp - demonstrate gs:move-tag for making animations
+;; and the mouse-wheel moving a text object
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;;;; describe the GUI
+(gs:frame 'AnimationDemo 100 100 400 400 "Animation ~ 50 frames/sec, 5  pixel/step")
+(gs:set-resizable 'AnimationDemo nil)
+(gs:canvas 'MyCanvas)
+(gs:set-background 'MyCanvas gs:white)
+(gs:mouse-wheel 'MyCanvas 'mouse-wheel-action)
+(gs:add-to 'AnimationDemo 'MyCanvas)
+
+(set 'Ty 200)
+(gs:set-font 'MyCanvas "Lucida Sans Oblique" 16 "plain")
+(gs:draw-text 'T "mouse wheel moves this text, changes speed" 20 Ty)
+(gs:fill-circle 'C 50 40 25 gs:red)
+(gs:fill-circle 'C 30 20 15 gs:black)
+(gs:fill-circle 'C 70 20 15 gs:black)
+(gs:fill-circle 'C 50 48 6 gs:yellow)
+
+(gs:set-visible 'AnimationDemo true)
+
+
+(define (mouse-wheel-action x y wheel)
+		(inc delay (* wheel 1000))
+		(if (> delay 80000) (set 'delay 80000))
+		(if (< delay 500) (set 'delay 500))
+        (if (= ostype "OSX")
+                (gs:move-tag 'T 0 (* wheel wheel (sgn wheel)))
+                (gs:move-tag 'T 0 (* 5 wheel)))
+)
+
+(set 'delay 20000) ;;
+
+(while (gs:check-event delay)
+	(dotimes (x 60)
+		(gs:check-event delay)
+		(gs:move-tag 'C 5 0))
+	(dotimes (x 60)
+		(gs:check-event delay)
+		(gs:move-tag 'C 0 5))
+	(dotimes (x 60)
+		(gs:check-event delay)
+		(gs:move-tag 'C -5 0))
+	(dotimes (x 60)
+		(gs:check-event delay)
+		(gs:move-tag 'C 0 -5))
+)
+
+(exit)
+
+;; eof
+
diff --git a/guiserver/border-layout-demo.lsp b/guiserver/border-layout-demo.lsp
new file mode 100644
index 0000000..f319754
--- /dev/null
+++ b/guiserver/border-layout-demo.lsp
@@ -0,0 +1,32 @@
+#!/usr/local/bin/newlisp
+;;
+;; border-layout-demo.lsp - demonstrate the border layout
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+
+;;;; describe the GUI
+(gs:frame 'BorderDemo 100 100 400 300 "Border layout demo")
+(gs:set-border-layout 'BorderDemo 0 0)
+(gs:panel 'NorthPanel 50 50)
+(gs:set-color 'NorthPanel 0.5 0 0)
+(gs:panel 'WestPanel 50 50)
+(gs:set-color 'WestPanel 0.5 0.5 0)
+(gs:panel 'CenterPanel 50 50)
+(gs:set-color 'CenterPanel 0.0 0.5 0)
+(gs:panel 'EastPanel 50 50)
+(gs:set-color 'EastPanel 0.0 0.5 0.5)
+(gs:panel 'SouthPanel 50 50)
+(gs:set-color 'SouthPanel 0.0 0 0.5)
+(gs:add-to 'BorderDemo 'NorthPanel "north" 'WestPanel "west" 'CenterPanel "center" 
+			'EastPanel "east" 'SouthPanel "south")
+(gs:set-visible 'BorderDemo true)
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/button-demo.lsp b/guiserver/button-demo.lsp
new file mode 100644
index 0000000..55234ad
--- /dev/null
+++ b/guiserver/button-demo.lsp
@@ -0,0 +1,36 @@
+#!/usr/local/bin/newlisp
+;;
+; button-demo.lsp - demonstrate the button control
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'ButtonDemo 100 100 400 300 "Click on button or color panel")
+(gs:set-resizable 'ButtonDemo nil)
+(gs:panel 'ColorPanel 360 200)
+(gs:set-background 'ColorPanel '(0 1 0) 0.2)
+(gs:button 'aButton 'button-action "color")
+(gs:set-flow-layout 'ButtonDemo "center" 2 15)
+(gs:add-to 'ButtonDemo 'ColorPanel 'aButton)
+(gs:set-visible 'ButtonDemo true)
+
+(gs:mouse-event 'ColorPanel 'mouse-action)
+
+;;;; define actions
+(define (button-action id)
+	(gs:set-color 'ColorPanel (random) (random) (random)))
+
+(define (mouse-action id type x y button cnt mods)
+	(gs:set-text 'ButtonDemo (format "%8s  %3d:%3d %d %d %2d" type x  y button cnt mods))
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/clipboard-demo.lsp b/guiserver/clipboard-demo.lsp
new file mode 100644
index 0000000..454db3f
--- /dev/null
+++ b/guiserver/clipboard-demo.lsp
@@ -0,0 +1,27 @@
+#!/usr/local/bin/newlisp
+;;
+;; clipboard-demo.lsp - demonstrate the gs:paste-text function
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+(gs:frame 'Frame 200 200 400 300) 
+(gs:set-border-layout 'Frame)
+(gs:text-area 'TheText 'text-handler)
+(gs:button 'TheButton 'button-handler "get clipboard")
+(gs:add-to 'Frame 'TheText "center" 'TheButton "south")
+(gs:set-visible 'Frame true) 
+
+(define (button-handler)
+	(gs:paste-text 'TheText))
+
+(define (text-handler))
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/cursor-demo.lsp b/guiserver/cursor-demo.lsp
new file mode 100644
index 0000000..a4e5cf2
--- /dev/null
+++ b/guiserver/cursor-demo.lsp
@@ -0,0 +1,47 @@
+#!/usr/local/bin/newlisp
+;;
+;; cursor-demo - demonstrate cursor shapes with gs:set-cursor
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+
+(set 'cursor-shapes '(
+		"default"
+		"crosshair"
+		"text"
+		"wait"
+		"sw-resize"
+		"se-resize"
+		"nw-resize"
+		"ne-resize"
+		"n-resize"
+		"s-resize"
+		"w-resize"
+		"e-resize"
+		"hand"
+		"move"
+))
+
+;; describe the GUI
+(gs:frame 'CursorDemo 100 100 500 200 "Cursor shapes - move the cursor over the panels")
+(gs:set-grid-layout 'CursorDemo 2 7)
+
+(dolist (c cursor-shapes)
+	(set 'id (sym c))
+	(gs:panel id)
+	(gs:set-background id (list (random) (random) (random)))
+	(gs:set-cursor id c)
+	(gs:add-to 'CursorDemo id))
+
+;(gs:set-resizable 'CursorDemo nil)
+
+(gs:set-visible 'CursorDemo true)
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/drag-demo.lsp b/guiserver/drag-demo.lsp
new file mode 100644
index 0000000..7d86eda
--- /dev/null
+++ b/guiserver/drag-demo.lsp
@@ -0,0 +1,83 @@
+#!/usr/local/bin/newlisp
+;;
+;; drag-demo.lsp - demonstrate dragging of objects with the mouse
+;;
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'DragDemo  100 100 600 500 "Drag demo")
+;(gs:set-resizable 'DragDemo nil)
+(gs:canvas 'MyCanvas)
+(gs:set-background 'MyCanvas gs:white)
+(gs:add-to 'DragDemo 'MyCanvas) 
+(gs:mouse-clicked 'MyCanvas 'mouse-clicked-action true)
+(gs:mouse-pressed 'MyCanvas 'mouse-pressed-action true)
+(gs:mouse-released 'MyCanvas 'mouse-released-action true)
+(gs:mouse-dragged 'MyCanvas 'mouse-dragged-action)
+
+;(gs:set-scale 0.5 0.5) ; only for testing, dragging would fail
+
+(gs:set-font 'MyCanvas "Lucida Sans Oblique" 18 "plain")
+(gs:draw-text 'T "Drag objects with the mouse, click right for popup menu" 20 250 gs:darkGray)
+(gs:fill-circle 'C 100 100 50 gs:red)
+(gs:fill-circle 'C 60 60 30 gs:black)
+(gs:fill-circle 'C 140 60 30 gs:black)
+(gs:fill-circle 'C 100 110 8 gs:yellow)
+
+
+(gs:draw-polygon 'P '(300 200 400 50 500 200) gs:blue)
+
+(gs:draw-image 'I "/local/newLISP128.png" 300 300 128 128)
+
+(gs:menu-popup 'EditMenuPopup "Edit")
+(gs:menu-item 'EditCut 'gs:no-action "Cut")
+(gs:menu-item 'EditCopy 'gs:no-action "Copy")
+(gs:menu-item 'EditPaste 'gs:no-action "Paste")
+(gs:disable 'EditCut 'EditCopy 'EditPaste)
+(gs:add-to 'EditMenuPopup 'EditCut 'EditCopy 'EditPaste)
+
+; comment out to test reorder
+;(gs:reorder-tags '(I P C T))
+
+(gs:set-visible 'DragDemo true)
+
+;(gs:update)
+
+;; actions
+(set 'mouse-down-tags '())
+
+(define (mouse-clicked-action x y button cnt  modifiers tags)
+	(gs:set-text 'DragDemo (string  x ":" y " "  button " " cnt " " tags))
+	(if (or (= 3 button) (= modifiers 18)) ; check for ctrl-button1-click on Mac
+		(gs:show-popup 'EditMenuPopup 'MyCanvas x y))	
+)
+
+(define (mouse-pressed-action x y button modifiers tags)
+		(gs:set-text 'DragDemo (string  x ":" y " "  button " " modifiers " " tags))
+		(set 'mouse-down-tags tags)
+		(set 'mouse-old-x x)
+		(set 'mouse-old-y y)
+)
+
+(define (mouse-released-action x y button modifiers tags)
+		(gs:set-text 'DragDemo (string  x ":" y " "  button " " modifiers " " tags))
+		(set 'mouse-down-tags '())
+)
+
+(define (mouse-dragged-action x y)
+	(dolist (t mouse-down-tags)
+		(gs:move-tag t (- x mouse-old-x) (- y mouse-old-y)))
+	(set 'mouse-old-x x)
+	(set 'mouse-old-y y)
+)
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/font-demo.lsp b/guiserver/font-demo.lsp
new file mode 100644
index 0000000..d3a072e
--- /dev/null
+++ b/guiserver/font-demo.lsp
@@ -0,0 +1,61 @@
+#!/usr/local/bin/newlisp
+;;
+;; font-demo.lsp - show all built-in Java fonts (available on all platforms)
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;;;; describe the GUI
+(gs:frame 'TestFrame 100 100 480 320 "newLISP-GS built-in Font Families")
+(gs:set-background 'TestFrame 1 1 1)
+(gs:set-grid-layout 'TestFrame 12 1)
+(gs:label 'L1 "Lucida Sans Regular")
+(gs:set-font 'L1 "Lucida Sans" 20 "plain")
+(gs:label 'L2 "Lucida Sans Bold")
+(gs:set-font 'L2 "Lucida Sans" 20 "bold")
+(gs:label 'L3 "Lucida Sans Oblique")
+(gs:set-font 'L3 "Lucida Sans" 20 "italic")
+
+(gs:label 'L4 "Lucida Bright Regular")
+(gs:set-font 'L4 "Lucida Bright" 20 "plain")
+(gs:label 'L5 "Lucida Bright Bold")
+(gs:set-font 'L5 "Lucida Bright" 20 "bold")
+(gs:label 'L6 "Lucida Bright Oblique")
+(gs:set-font 'L6 "Lucida Bright" 20 "italic")
+
+(gs:label 'L7 "Lucida Sans Typewriter Regular")
+(gs:set-font 'L7 "Lucida Sans Typewriter" 20 "plain")
+(gs:label 'L8 "Lucida Sans Typewriter Bold")
+(gs:set-font 'L8 "Lucida Sans Typewriter" 20 "bold")
+(gs:label 'L9 "Lucida Sans Typewriter Oblique")
+(gs:set-font 'L9 "Lucida Sans Typewriter" 20 "italic")
+
+(gs:label 'L10 "Monospaced Regular")
+(gs:set-font 'L10 "Monospaced" 20 "plain")
+(gs:label 'L11 "Monospaced Bold")
+(gs:set-font 'L11 "Monospaced" 20 "bold")
+(gs:label 'L12 "Monospaced Oblique")
+(gs:set-font 'L12 "Monospaced" 20 "italic")
+
+(dolist (i '(L1 L2 L3 L4 L5 L6 L7 L8 L9 L10 L11 L12))
+	(gs:set-foreground i 0 0 0.4))
+
+(gs:add-to 'TestFrame 'L1 'L2 'L3 'L4 'L5 'L6 'L7 'L8 'L9 'L10 'L11 'L12)
+(gs:set-visible 'TestFrame true)
+
+;; actions
+
+(define (toggle-action id flag)
+	(if flag
+		(gs:set-icon 'aImage "/local/newLISP32.png")
+		(gs:set-icon 'aImage "/local/newLISP128.png"))
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/frameless-demo.lsp b/guiserver/frameless-demo.lsp
new file mode 100644
index 0000000..e792d6b
--- /dev/null
+++ b/guiserver/frameless-demo.lsp
@@ -0,0 +1,28 @@
+#!/usr/local/bin/newlisp
+
+;; frameless-demo.lsp - frameless and transparent (on MacOS X)
+
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+(gs:window 'Window 100 100 400 100)
+(gs:set-background 'Window 0 0 0.5 0.2)
+(gs:set-border-layout 'Window)
+(gs:label 'Time " ") 
+(gs:set-font 'Time "Mono Spaced" 40 "bold")
+(gs:set-foreground 'Time 1 1 0 )
+(gs:add-to 'Window 'Time "center")
+(gs:button 'Button 'button-handler "close")
+(gs:add-to 'Window 'Button "south")
+(gs:set-visible 'Window true)
+
+(define (button-handler) (exit))
+
+(while (gs:check-event 10000)
+	(sleep 200) 
+	(gs:set-text 'Time (date (date-value) 0 "%b %d %H:%M:%S"))
+)
+
+;; eof
diff --git a/guiserver/guiserver.jar b/guiserver/guiserver.jar
new file mode 100644
index 0000000..526d530
Binary files /dev/null and b/guiserver/guiserver.jar differ
diff --git a/guiserver/guiserver.lsp b/guiserver/guiserver.lsp
new file mode 100644
index 0000000..4879081
--- /dev/null
+++ b/guiserver/guiserver.lsp
@@ -0,0 +1,3829 @@
+;; @module guiserver.lsp
+;; @description Functions for programming GUIs and 2D graphics.
+;; @version 1.40 use text-field as a password field with additional parameter
+;; @version 1.41 bug fixes for gs:listen and gs:check-event
+;; @version 1.42 new table UI
+;; @version 1.43 bug fix in new table UI action parameters
+;; @version 1.44 fixes in newlisp-edit.lsp
+;; @version 1.50 doc fixes
+;; @version 1.51 return value for gs:export
+;; @version 1.52 fix in run-shell for Java 7 update 21
+;; @version 1.53 doc fixes
+;; @version 1.60 new table functions, new naming gs:table-show-row-number
+;; @version 1.61 more options for gs:scroll-pane added by FdB
+;; @version 1.62 doc corrections
+;; @version 1.63 make deprecated gs:table-set-row-number work
+;; @version 1.70 default comm port with Guiserver are now 64001 and 64002
+;; @version 1.71 references to /usr/ changed to /usr/local/
+;; @version 1.72 doc corrections
+;; @author LM, 2008, 2009, 2010, 2015, Unya 2012, FdB 2013, LM 2015
+;;
+;; This module has been tested on MacOS X 10.5 (Leopard) and Windows XP, both with the
+;; Standard SUN Java RE v.1.5 (runtime environment) which came pre-installed on
+;; those platforms. On Linux the installation of the original Sun Java Runtime 
+;; Environment is required the preinstalled GNU Java is not compatible. After
+;; installation a soft-link has to be made from the original java executable to
+;; '/usr/bin/java'.
+;; 
+;;
+;; On Windows the MIDI sound features require a soundbank file to
+;; be installed. See the description for 'gs:play-note' for details.
+;; <br><br>
+;; <h2>What is newLISP-GS</h2>
+;; 'guiserver.lsp' is a module for interfacing to 'guiserver.jar'
+;; a Java server application for generating GUIs (graphical user interfaces)
+;; and 2D graphics for newLISP applications. The 'guiserver.lsp', module
+;; implements a newLISP API much smaller and more abstract than the APIs of the 
+;; Java Swing libraries which it interfaces with. Because of this, GUI applications
+;; can be built much faster than when using the original Java APIs.
+;; <br><br>
+;; <h2>Usage</h2>
+;; At the beginning of the program file, include a 'load' statement for the module:
+;; <pre>
+;; (load "/usr/local/share/newlisp/guiserver.lsp")
+;; </pre>
+;; or on MS Windows:
+;; <pre>
+;; (load "c:/Program Files/newlisp/guiserver.lsp")
+;; </pre>
+;; 'guiserver.lsp' expects the server 'guiserver.jar' to be
+;; in the directoey specified in the environment variable NEWLISPDIR.
+;; When newLISP starts up and this variable is not set yet, it sets it
+;; to a default value of '/usr/local/share/newlisp' on MacOS X and Unix OSs, and 
+;; to 'C:\Program Files\newlisp' or whatever it finds in the 'PROGRAMFILES'
+;; environment variable on MS Windows systems and adding '/newlisp' to it.
+;; This can be overwritten by specifying system wide  setting for the environment 
+;; variable <tt>NEWLISPDIR</tt>, which normally is set to '%PROGRAMFILES%/newlisp' 
+;; on MS Windows. When using the MS Windows binary installer 'NEWLISPDIR' is written 
+;; to the registry automatically and gets into effect after rebooting.
+;; <br><br>
+;; <h2>Architecture of a newLISP GUI application</h2>
+;; A GUI application in newLISP is composed of four parts:
+;;
+;; <blockquote>
+;; <b>initialization</b> - this means starting the newLISP-GS 'guiserver.jar' and initializing 
+;; communications with it. Only one function call is required to do this.
+;;
+;; <b>building widgets</b> - in this step windows, buttons, text fields etc., and
+;; all visual aspects of the GUI are described. newLISP newLISP-GS offers a wide range
+;; of different control widgets.
+;;
+;; <b>defining event actions</b> - in this step all the functions are defined to
+;; react to events coming from the GUI as a consequence of button pushes, keystrokes,
+;; mouse-movements etc.. These event actions send many commands back to the GUI
+;; to change information for the user, popup dialogs etc..
+;;
+;; <b>listening for events</b> - the newLISP program sits in a loop waiting for
+;; events and dispatching them to the defined event actions. Only one function call
+;; is required for this step.
+;; </blockquote>
+;; <br><br>
+;; <h2>Example</h2>
+;; The following example application shows all the essential elements of a newLISP GUI
+;; application:
+;;
+;; @example
+;; #!/usr/bin/newlisp
+;; ; button-demo.lsp - demonstrate the button control
+;;  
+;; ; initialization
+;; (load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+;;
+;; (gs:init) 
+;;  
+;; ; describe the GUI
+;; (gs:frame 'ButtonDemo 100 100 400 300 "Button demo")
+;; (gs:set-resizable 'ButtonDemo nil)
+;; (gs:panel 'ColorPanel 360 200)
+;; (gs:set-color 'ColorPanel (random) (random) (random))
+;; (gs:button 'aButton 'abutton-action "color")
+;; (gs:set-flow-layout 'ButtonDemo "center" 2 15)
+;; (gs:add-to 'ButtonDemo 'ColorPanel 'aButton)
+;; (gs:set-visible 'ButtonDemo true)
+;;  
+;; ; define actions
+;; (define (abutton-action id)
+;;     (gs:set-color 'ColorPanel (random) (random) (random)))
+;;  
+;; ; listen for incoming action requests and dispatch
+;; (gs:listen)
+;;  
+;; ; eof 
+
+;; <br>
+;; <h2>Application start</h2>
+;; <pre>
+;;     ./button-demo       ; on MacOS X and Unix
+;;     newlisp button-demo ; on MS Windows
+;; </pre>
+;; By default guiserver.jar uses the ports 64001 and 64002, but this setting can be overwritten 
+;; either by supplying a port number parameter to the 'gs:init' function or by overwriting the
+;; port number from the command-line. newLISP-GS will then use the port number supplied and the number
+;; following it:
+;; <pre>
+;;     ./button-demo 10001       ; on MacOS X and Unix
+;;     newlisp button-demo 10001 ; on MS Windows
+;; </pre>
+;; newLISP-GS 'guiserver.jar' will now use the ports '64001' and '60002'.
+;; Ports under <tt>1024</tt> should not be used, as many of them are already in use by other
+;; OS services and need administrator privileges to use them.
+;;
+;; A second method to start a newLISP-GS application starts the 'guiserver.jar' first, which then
+;; starts the newLISP application:
+;; <pre>
+;;     java -jar /usr/local/share/newlisp/guiserver.jar 64001 /usr/home/aUser/MyApplication.lsp
+;; </pre>
+;; A different port number can be used. Port numbers below 1024 need administrator
+;; permissions. Optionally a splash screen can be specified as the last parameter:
+;; <pre>
+;;     java -jar /usr/local/share/newlisp/guiserver.jar 64001 /home/apps/myapp.lsp /local/newLISP128.png
+;; </pre>
+;; The example specifies an image inside 'guiserver.jar'. Any other image path on the local file system
+;; can be used.
+;;
+;; On MS Windows similar methods can be used replacing the appropriate file paths, but on MS Windows Java jar files
+;; can also be treated as executables and executed directly without calling Java explicitly. By default
+;; 'guiserver.jar' and 'guiserver.lsp' are  installed in 'c:\Program Files\newlisp\' or any other 
+;; directory configured on a MS Windows platform using the 'PROGRAMFILES' environment variable:
+;; <pre>
+;;    "c:\Program Files\newlisp\guiserver.jar" 64001 c:\myprogs\MyApplication.lsp
+;; </pre>
+;; Quotes are necessary when spaces are present in the argument string. The example assumes that
+;; 'newlisp.exe' is in the path for executables, and it also assumes that the Windows registry has
+;; an association of the <tt>.jar</tt> file extension with the <tt>javaw.exe</tt> executable. This
+;; association is normally present when a java run-time environment (JRE) is installed in Windows.
+;; If this association is not registered, the following method can be used:
+;; <pre>
+;;    javaw -jar "c:\Program Files\newlisp\guiserver.jar" 64001 c:\myprogs\MyApplication.lsp
+;; </pre>
+;; The quotes are necessary for path-names containing spaces.
+;;
+;; <h2>Debugging</h2>
+;; <b>Tracing commands to newLISP-GS</b><br><br>
+;; For debugging purpose put the following directive at the beginning of your application
+;; or at the place from where to start tracing.
+;; <pre>
+;;         (gs:set-trace true)
+;; </pre>
+;; Then start the application from a terminal or command shell window. Now newLISP-GS
+;; will output startup, version and connection messages and a trace for each 'gs:xxs' directive
+;; as it is received by the newLISP-GS dispatcher:
+;;
+;; <blockquote><pre>
+;; newLISP-GS v.0.94
+;; listening on 64001
+;; accepted from 0.0.0.0
+;; connecting to 0.0.0.0 64002
+;; retrying to connect
+;; connected
+;; -> frame MAIN:ButtonDemo 100 100 400 300 QnV0dG9uIGRlbW8= nil
+;; -> set-resizable MAIN:ButtonDemo nil
+;; -> panel MAIN:ColorPanel 360 200
+;; -> set-color MAIN:ColorPanel 0 1 0 0.2
+;; -> button MAIN:aButton MAIN:abutton-action Y29sb3I=
+;; -> set-flow-layout MAIN:ButtonDemo center 2 15
+;; -> add-to MAIN:ButtonDemo MAIN:ColorPanel MAIN:aButton 
+;; -> set-visible MAIN:ButtonDemo true
+;; -> set-color MAIN:ColorPanel 0.8401877172 0.3943829268 0.7830992238
+;; server shut down
+;; </blockquote></pre>
+;;
+;; Text strings for button names, icon paths and other texts are encode in
+;; Base64 strings as the first trace line for MAIN:ButtonDemo shows. To switch
+;; off tracing mode use:
+;; <pre>
+;;        (gs:set-trace nil)
+;; </pre>
+;; Even if trace mode is switched off, wrong or missing parameters are still messaged
+;; by newLISP-GS in a small message box. After such an error the application and guiserver
+;; will exit. Unknown commands will be ignored. Functions which are not applicable to
+;; certain widgets will also pop up an error message box. In certain situations a
+;; function will have no effect, e.g. 'gs:set-size' or 'gs:set-color' sometimes do not
+;; have an effect, depending on how a widget is configured or depending on the layout
+;; which hosts the widget. Sometimes the platform look-and-feel overwrites colors.
+;; <br><br>
+;; <h2>Event handlers</h2>
+;; For most widgets, event handlers must be defined. Sometimes an event handler is
+;; not required. In this case specify <tt>'gs:no-action</tt> as the event handler
+;; symbol. When developing programs it is useful to watch the event handler first
+;; before coding for it. This can be done easily by printing out event parameters:
+;; <blockquote><pre>
+;; (gs:button 'aButton 'abutton-handler "press")
+;; (define (abutton-handler id)
+;;     (println id))
+;; </pre></blockquote>
+;; Sometimes the same event handler function is attached to several widgets' keyboard
+;; or mouse events. Some of these events receive a greater number of parameters. There
+;; are two easy ways to discover the nature of an event:
+;; <blockquote><pre>
+;; (define (the-handler)
+;;     (doargs (p)
+;;         (println "->" p)))
+;; </pre></blockquote>
+;; The other method looks at the source of the event as it was transmitted by the newLISP-GS.
+;; This is useful to recognize the data types used in the event:
+;; <blockquote><pre>
+;; (define (the-handler)
+;;     (println gs:event))
+;; </pre></blockquote>
+;; All text from text fields are received as base64-encoded strings. E.g. the text: 
+;; '"Hello World"' would be received as: '"SGVsbG8gV29ybGQ="':
+;; <blockquote><pre>
+;; (gs:text-field 'TextField 'textfield-handler)
+;;
+;; (define (textfield-handler id text)
+;;     (printnl id ": " (base64-dec text)))
+;; </pre></blockquote>
+;; When the text "Hello World" is entered in the text field, the following output
+;; would be generated:
+;; <blockquote><pre>
+;; TextField: "Hello World"
+;; </pre></blockquote>
+;; In case the ESC key is pressed in the text field, the event handler would
+;; report 'nil' for the text field. A handler should therefore always check text
+;; for string contents before trying to apply the 'base64-dec' function on it.
+;; <br><br>
+;; <h2>Mapping or applying 'gs:xxx' functions</h2>
+;; Like any newLISP functions, 'gs:xxx' functions can be mapped or applied to lists of 
+;; parameters using the newLISP 'map' and 'apply' functions. When doing this, make sure to 
+;; map or apply the quoted <tt>'gs:xxx symbol</tt>, so the <tt>gs:xx</tt> functions 
+;; get executed under the <tt>gs</tt> context, prefixing symbols in parameter lists
+;; correctly with the context prefix of their origin.
+;; <pre>
+;;    (map 'gs:panel '(first second third fourth)) ; note quoted gs: function
+;; </pre>
+;; <h2>Some shortcuts when writing 'gs:xxx' functions</h2>
+;; Due to the nature of transfer between newLISP and the guiserver as text, the following
+;; convenient shortcuts can be taken when writing functions:
+;; <blockquote>
+;; <ul>
+;; <li>Symbol ids of components can be expressed as strings.</li>
+;; <li>Number values can be expressed as strings.</li>
+;; <li>Numbers can be expressed as floats or integers.</li>
+;; </ul>
+;; </blockquote>
+;; Here are some examples:
+;; <pre>
+;;     (gs:panel 'ColorPanel 360 200)
+;;     ; is the same as
+;;     (gs:panel "ColorPanel" 360 200)
+;;     ; is the same as
+;;     (gs:panel "ColorPanel" "360" "200")
+;;     ; is the same as
+;;     (gs:panel "ColorPanel" 360.0 "200.00")
+;; </pre>
+;; Although the first form is preferred for clarity and readability, in some cases coding
+;; may be more efficient using the other forms.
+;;
+;; Except for the symbols used for action handlers, all symbols are used only by their
+;; face (term) value. This means that reserved symbols of the newLISP programming
+;; language can be used freely in symbol ids for all components, e.g:
+;; <pre>
+;;     (gs:label 'term "Input here") ; term is a reserved name since v10.2.0
+;; </pre>
+;; The usage of the reserved symbol 'term' will not pose a problem.
+;; <br><br>
+;; <h2>Return values</h2>
+;; newLISP-GS is an event driven asynchronous system. Most functions return
+;; right away the number of characters sent out to the server.
+;; In general, return values of 'gs:xxx' functions do not have
+;; any specific meaning and can be discarded. Only the functions 'gs:get-bounds',
+;; 'gs:get-fonts', 'gs:get-font-metrics', 'gs:get-instruments'
+;; 'gs:get-screen', 'gs:get-text' and 'gs:get-version' return meaningful values or
+;; lists of values, which are stored in similar named variables: 'gs:bounds',
+;; 'gs:fonts', 'gs:font-metrics', 'gs:instruments', 'gs:screen', 'gs:text' and
+;; 'gs:version'. These functions will not return right away but block until
+;; the return valuse is sent back from newLISP-GS.
+;;
+;; The function 'gs:get-text' can work both ways: event driven or with a return
+;; value depending on the call pattern used.
+;; <br><br>
+;; <h2>Function overview</h2>
+;; <ul>
+;; <li><b>Initialization and application setup</b><br>
+;; <pre>
+;;    (gs:init [<server-port>])
+;; </pre>
+;; The initialization function starts <tt>guiserver.jar</tt> which will listen to the <i>server-port</i>
+;; and initiate another connection on <tt>server-port + 1</tt> back to newLISP. If a <server-port>
+;; is not supplied <tt>guiserver</tt> will assume <tt>64001</tt> and <tt>64002</tt>.
+;;
+;; As the last statement in the application put:
+;; <pre>
+;;    (gs:listen)
+;; </pre>
+;; This function listens on <tt>64002</tt> (by default) for event messages from newLISP-GS
+;; and dispatches them to the user-defined action handlers. To avoid newLISP shutting down
+;; when the guiserver shuts down, use:
+;; <pre>
+;;    (gs:listen true)
+;; </pre>
+;; </li>
+;; Sometimes it is necessary to run other tasks while listening for events. In this case use
+;; 'gs:check-event', which will wait for certain amount of microseconds for an event
+;; to be executed. After the wait-time, it returns. The function is typically used in a loop:
+;; <pre>
+;;    (while (gs:check-event 10000) ; check for 10 milli seconds
+;;			(do-myprocess))
+;;    (exit)
+;; </pre>
+;; The loop will exit when 'gs:check-event' returns 'nil' on communications errors, e.g.
+;; when the window's close button was clicked.
+;;
+;; <li><b>Containers</b><br>
+;; A <em>container</em> can contain any other container or control widget. Except for the 
+;; <tt>menu-bar</tt> and the <tt>split-pane</tt>, containers can have a special layout-manager set 
+;; with one of the three layout-manager function commands. By default containers have a flow layout. By
+;; nesting different containers and using different layout-manager settings, complex layouts
+;; can be configured. The function/command <tt>add-to</tt> is used to add components to containers.
+;; <pre>
+;;    (gs:dialog <sym-id> <sym-parent-frame> <str-message> <int-width> <int-height> [<boolean-visible> [<boolean-modal>]])
+;;    (gs:frame <sym-id> <int-x> <int-y> <int-width> <int-height> [<str-title> <boolean-visible>])
+;;    (gs:menu-bar <sym-frame> [<sym-menu-1> ...])  
+;;    (gs:panel <sym-id> [<int-width> <int-height>])
+;;    (gs:scroll-pane <sym-id> <sym-widget> [<int-width> <int-height>])
+;;    (gs:split-pane <sym-id> <str-orientation> [<float-weight> [<float-location> [int-divider-size>]]])
+;;    (gs:tabbed-pane <sym-id> <sym-action> <str-orientation> [<sym-widget> <sym-tab-title> ...])
+;;    (gs:tool-bar <sym-frame> [<bool-floatable> <int-hgap> <int-vgap>])
+;;    (gs:canvas <sym-id>) 
+;;    (gs:window <sym-id> <int-x> <int-y> <int-width> <int-height>)
+;; </pre>
+;; </li>
+;; <li><b>Labels</b><br>
+;; Labels can have text or an image or both. A normal text <tt>label</tt> can have an icon
+;; added to it and a <tt>image-label</tt> can have text added to it. Labels don't initiate
+;; actions and can be placed in any container like all button-type widgets - buttons, checkboxes
+;; and menu items. A basic set of icon images is built into <tt>guiserver.jar</tt>,
+;; but user-supplied images and icons in <tt>.jpg</tt>, <tt>.png</tt> and <tt>.gif</tt> formats
+;; can be used.
+;; <pre>
+;;    (gs:label <sym-id> <str-text> [<str-align> [<int-width> <int-height>]])
+;;    (gs:image-label <sym-id> <str-icon-path> [<str-align>])
+;; </pre>
+;; </li>
+;; <li><b>Control widgets</b><br>
+;; Except for the passive progress bar, all control widgets fire action requests to
+;; the newLISP program. These requests must be served to avoid error messages but can
+;; be defined as empty functions, if an action is not required:
+;; <pre>
+;;    ; empty action definition
+;;    (define (my-button-action) )
+;;
+;;    ; action handler printing the name of the button pressed
+;;    (define (my-button-action id) (println id " has been pressed"))
+;; </pre>
+;; All action events calls carry information about the widget, that initiated that the event,
+;; and event parameters like keystrokes, slider positions etc..
+;; <pre>
+;;    (gs:button <sym-id> <sym-action> [<str-text> [<int-width> <int-height>]])
+;;    (gs:check-box <sym-id> <sym-action> [<str-text> [<bool-selected>]])
+;;    (gs:combo-box <sym-id> <sym-action> [<str-item-1> ...])
+;;    (gs:combo-box <sym-id> <sym-action> [<list-str-items>])
+;;    (gs:image-button <sym-id> <sym-action> <str-icon-path> [<str-down-icon-path> [<int-width> <int-height>]])
+;;    (gs:list-box <sym-id> <sym-action> [<str-item-1> ...])
+;;    (gs:list-box <sym-id> <sym-action> [<list-str-items>])
+;;    (gs:menu <sym-id> <str-text>)
+;;    (gs:menu-popup <sym-id> <str-text>)
+;;    (gs:menu-item <sym-id> <sym-action> <str-text>)
+;;    (gs:menu-item-check <sym-id> <sym-action> <str-text> [<bool-selected>])
+;;    (gs:progress-bar <sym-id> <int-min> <in-max> <int-initial-value>)
+;;    (gs:radio-button <sym-id> <sym-action> [<str-text> [<bool-selected>]])
+;;    (gs:slider <sym-id> <sym-action> <str-orientation> <int-min> <int-max> <int-initial-value>)
+;;    (gs:text-area <sym-id> <sym-action> [<int-width> <int-height>])
+;;    (gs:text-field <sym-id> <sym-action> <int-columns>[<str-echo-char>])
+;;    (gs:text-pane <sym-id> <sym-action> <str-style> [<int-width> <int-height>])
+;;    (gs:toggle-button <sym-id> <sym-action> [<str-text> <bool-selected>])
+;; </pre>
+;; For all button widgets, and the check box and menu-item widgets, icons can be set using 
+;; the 'gs:set-icon' and 'gs:set-pressed-icon' functions.
+;; </li><br>
+;; <li><b>Placing components in containers</b><br>
+;; For the flow and grid layouts the components are added in the sequence they are listed.
+;; The grid-layout fills the grid row by row starting with the left most column. 
+;; <pre>
+;;    (gs:add-to <sym-container> <sym-component> [<sym-component ...])
+;; </pre>
+;; For the border layout an orientation parameter is specified as either <tt>"north"</tt>,
+;; <tt>"west"</tt>, <tt>"center"</tt>, <tt>"east"</tt> or <tt>"south"</tt>.
+;; <pre>
+;;    (gs:add-to <sym-container> [<sym-component> <str-orientation> ...])
+;; </pre>
+
+;; </li>
+;; <li><b>Summary of commands</b><br>
+;; Most of the commands set special attributes of containers or control widgets. 
+;; Not all functions can be applied to all containers and control widgets. A wrong
+;; application will either pop up an error message box or do nothing.
+;;
+;; Some functions will work on certain widgets only in certain situations. For example
+;; <tt>set-size</tt> will work not on components in a grid layout but on components
+;; in a flow layout. Some widgets have a preset background color which cannot be changed
+;; or is overwritten by the current 'gs:look-and-feel' settings.
+;;	<pre>
+;;    (gs:add-list-item <sym-list-combo> <str-text> [<str-text> ...])
+;;    (gs:add-separator <sym-menu-tool-bar>)
+;;    (gs:add-to <sym-container> <sym-component> [<sym-component ...])
+;;    (gs:add-to <sym-container> <sym-component> <str-orientation> [<sym-component> <str-orientation> ...])
+;;    (gs:append-text <sym-id> <str-text>)
+;;    (gs:check-event <int-microseconds>)
+;;    (gs:clear-list <sym-id>)
+;;    (gs:clear-text <sym-id>)
+;;    (gs:copy-text <sym-id>)
+;;    (gs:cut-text <sym-id>)
+;;    (gs:destroy-shell <sym-text-area>)
+;;    (gs:disable <sym-id-1> [<sym-id-2> ...])
+;;    (gs:dispose <sym-id>)
+;;    (gs:dispose-splash)
+;;    (gs:enable <sym-id-1> [<sym-id-2> ...])
+;;    (gs:eval-shell <sym-text-area> <str-commmand>)
+;;    (gs:find-text <sym-id> <str-text> <sym-action> [<str-direction>]])
+;;    (gs:frame-closed <sym-id> <sym-action>)
+;;    (gs:get-fonts)
+;;    (gs:get-bounds <sym-id>)
+;;    (gs:get-font-metrics <sym-id> <str-text>)
+;;    (gs:get-screen)
+;;    (gs:get-selected-text <sym-id> <sym-action>)
+;;    (gs:get-text <sym-id> [<sym-action>])
+;;    (gs:get-text-position <sym-id>)
+;;    (gs:get-version);
+;;    (gs:goto-text <sym-id> <sym-row> <sym-column>)
+;;    (gs:insert-list-item <sym-list-combo> <str-text> <int-index> [<str-text> <int-index>])
+;;    (gs:insert-tab <sym-tabbed-pane> <sym-component> [<str-text> [<int-index> [<str-icon-path>]])
+;;    (gs:insert-text <sym-id> <str-text> <int-pos>)
+;;    (gs:layout <sym-container>)
+;;    (gs:load-text <sym-id> <str-path>)
+;;    (gs:no-action)
+;;    (gs:paste-text <sym-id> [<str-text>])
+;;    (gs:redo-text <sym-id>)
+;;    (gs:remove-from <sym-container> <sym-component> [<sym-component> ...])
+;;    (gs:remove-list-item <sym-list-combo> <int-index> [<int-index> ...])
+;;    (gs:remove-tab <sym-tabbed-pane> <int-index>)
+;;    (gs:request-focus <sym-id>)
+;;    (gs:run-shell <sym-text-area> <str-commmand> <str-args>)
+;;    (gs:select-list-item <sym-id> <str-item> [<boolean-flag>])
+;;    (gs:select-text <sym-id> <int-from> [<int-to>])
+;;    (gs:set-accelerator <sym-menu-item> <str-keystroke>)
+;;    (gs:set-background <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;;    (gs:set-background <sym-id> <list-rgb> [<float-alpha>])
+;;    (gs:set-bevel-border <sym-panel> <str-type>)
+;;    (gs:set-border-layout <sym-container>  [<int-hgap> <int-vgap>])
+;;    (gs:set-caret <sym-id> <int-offset>)
+;;    (gs:set-caret-color <sym-id> <list-rgb>)
+;;    (gs:set-caret-color <sym-id> <float-red> <float-green> <float-blue>)
+;;    (gs:set-color <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;;    (gs:set-color <sym-id> <list-rgb> [<float-alpha>])
+;;    (gs:set-cursor <sym-id> <str-shape>)
+;;    (gs:set-echo-char <sym-id> <str-echo-char>)
+;;    (gs:set-editable <sym-id> <boolean-flag>)
+;;    (gs:set-flow-layout <sym-container> [<str-alignment> [<int-hgap> <int-vgap>]])
+;;    (gs:set-font <sym-id> <str-family> <int-size> <str-type>)
+;;    (gs:set-foreground <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;;    (gs:set-foreground <sym-id> <list-rgb> [<float-alpha>])
+;;    (gs:set-grid-layout <sym-container> <int-rows> <int-columns> [<int-hgap> <int-vgap>])
+;;    (gs:set-icon <sym-id> <str-icon-path> [<int-index>])
+;;    (gs:set-look-and-feel <str-look>)
+;;    (gs:set-resizable <sym-frame> <boolean-flag>)
+;;    (gs:set-pressed-icon <sym-id> <str-icon-path>)
+;;    (gs:set-selected <sym-id> <boolean-flag>)
+;;    (gs:set-size <sym-id> <int-width> <int-height>)
+;;    (gs:set-selection-color <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;;    (gs:set-syntax <sym-id> <str-type>) 
+;;    (gs:set-syntax-colors <list-rgb-comments> <list-rgb-keywords> <list-rgb-string> <list-rgb-number> <list-rgb-quoted> <list-rgb-prantheses>)
+;;    (gs:set-tab-size <sym-id> <int-size>)
+;;    (gs:set-text <sym-id> <str-text> [<int-index>])
+;;    (gs:set-titled-border <sym-component> <str-title>)
+;;    (gs:set-tool-tip <sym-id> <str-text>)
+;;    (gs:set-trace <boolean-flag>)
+;;    (gs:set-utf8 <boolean-flag>)
+;;    (gs:set-value <sym-id> <int-value>)
+;;    (gs:set-visible <sym-id> <boolean-visible>)
+;;    (gs:undo-text <sym-id>)
+;;    (gs:undo-enable <sym-id> <boolean-enabled>)
+;; </pre>
+;; </li>
+;; <li><b>The Table UI</b><br>
+;;  Since version 1.42 Guiserver has a table widget and supporting functions.
+;; <pre>
+;;    (gs:table <sym-id> <sym-action> [<str-column-header-name> ...])
+;;    (gs:table-add-column <sym-id> <str-column-header-name> ...)
+;;    (gs:table-add-row <sym-id> [<str-columns> ... ])
+;;    (gs:table-get <sym-id>)
+;;    (gs:table-get-cell <sym-id> <int-row> <int-column>)
+;;    (gs:table-get-size <sym-id>)
+;;    (gs:table-remove-row <sym-id> <int-row>
+;;    (gs:table-set-cell <sym-id> <int-row> <int-column> <str-value>)
+;;    (gs:table-set-column <sym-id> <int-column-number> <int-width> [<str-justification>])
+;;    (gs:table-set-column-name <sym-id> [<str-name1> [<str-name2> ...])
+;;    (gs:table-set-row-count <sym-id> <int-count>
+;;    (gs:table-set-row-number <sym-id> <bool-row-number>) DEPRECATED use gs:table-show-row-number
+;;    (gs:table-show-row-number <sym-id> <bool-row-number>)
+;; </pre>
+;; </li>
+;; <li><b>Special dialogs</b><br>
+;;  These are standard dialogs for opening and saving files and for choosing colors.
+;;  Each dialog when closed fires an event for which a handler function must be
+;;  defined by the newLISP program. 
+;;	<pre>
+;;    (gs:color-dialog <sym-parent-frame> <sym-action> <str-title> <float-red> <float-green> <float-blue>)
+;;    (gs:message-dialog <sym-parent-frame> <str-title> <str-message> [<str-type> [<str-icon-path>]])
+;;    (gs:confirm-dialog <sym-parent-frame> <sym-action> <str-title> <str-message> [<str-type>])
+;;    (gs:open-file-dialog <sym-parent-frame> <sym-action> [<str-directory> [<str-mask> <str-description>]])
+;;    (gs:save-file-dialog <sym-parent-frame> <sym-action> [<str-directory> [<str-initial-file> [<str-mask> <str-description>]]])
+;; </pre>
+;; </li>
+;; <li><b>2D Graphics functions</b><br>
+;; Every call to a 'gs:draw-xxx' or 'gs:fill-xxx' function will create a new graphics object, which
+;; will persist until destroyed by a call to 'gs:delete-tag'. Graphics objects are animated
+;; using the tag operations 'gs:move-tag', 'gs:rotate-tag', 'gs:scale-tag' and 
+;; 'gs:shear-tag' or using 'gs:hide-tag' and 'gs:show-tag'. 
+;;
+;; Any 'gs:draw-xxx' or 'gs:fill-xxx' will create graphics objects but not force a screen update.
+;; The canvas is automatically redrawn when made visible for the first time using 'gs:set-visible' or
+;; after a call to 'gs:update'. Redrawing is also forced when resizing the window which hosts the canvas
+;; or any action covering and uncovering the canvas. 
+;; 
+;; After all tag operations redrawing is initiated by default, but it can be forced off by specifying 
+;; 'nil' as the last parameter in a 'gs:xxx-tag' command. Suppressing immediate redraw is useful to avoid 
+;; flicker when a batch of tag operations is performed.
+;; 
+;; Every graphics object (line, shape, text, or image) carries a group tag. Objects are deleted
+;; using 'gs:delete-tag' and will disappear immediately from the canvas. Using 'gs:move-tag'
+;; lines, shapes, text and images can be moved to a different position.
+;;
+;; All positions given in <tt>int x</tt> and <tt>int y</tt> must be given as integers. Values
+;; will not be converted automatically as is the case with newLISP's built-in functions. To
+;; guarantee integer type, values can be casted e.g.: 
+;; <pre>(gs:draw-circle 'MyCircle (int x) (int y) (int r))</pre>
+;; <pre>
+;;    (gs:color-tag <sym-tag> <list-rgb> [<boolean-repaint>])
+;;    (gs:delete-tag <sym-tag>[<boolean-repaint>])
+;;    (gs:draw-arc <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-start> <int-angle> [<list-rgb>])
+;;    (gs:draw-circle <sym-tag> <int-x> <int-y> <int-radius> [<list-rgb>])
+;;    (gs:draw-ellipse <sym-tag> <int-x> <int-y> <int-radius-x> <int-radius-y> [<list-rgb>])
+;;    (gs:draw-image <sym-tag> <str-path> <int-x> <int-y> [<int-width> <int-height>])
+;;    (gs:draw-line <sym-tag> <int-x1> <int-y1> <int-x2> <int-y2> [<list-rgb>])
+;;    (gs:draw-path <sym-tag> <list-points> [<list-rgb>])
+;;    (gs:draw-polygon <sym-tag> <list-points> [<list-rgb>])
+;;    (gs:draw-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> [<list-rgb>])
+;;    (gs:draw-round-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-arc-width> <int-arc-height> [<list-rgb>])
+;;    (gs:draw-text <sym-tag> <str-text> <int-x> <int-y> [<list-rgb> [<float-angle>]])
+;;    (gs:export <str-path-file> [<int-width> <int-height>])
+;;    (gs:fill-arc <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-start> <int-angle> [<list-rgb>])
+;;    (gs:fill-circle <sym-tag> <int-x> <int-y> <int-radius> [<list-rgb>])
+;;    (gs:fill-ellipse <sym-tag> <int-x> <int-y> <int-radius-x> <int-radius-y> [<list-rgb>])
+;;    (gs:fill-polygon <sym-tag> <list-points> [<list-rgb>])
+;;    (gs:fill-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> [<list-rgb>])
+;;    (gs:fill-round-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-arc-width> <int-arc-height> [<list-rgb>])
+;;    (gs:hide-tag <sym-tag>  [<boolean-repaint>])
+;;    (gs:move-tag <sym-tag> <int-dx> <int-dy> [<boolean-repaint>])
+;;    (gs:reorder-tags <list-tags>)
+;;    (gs:rotate-tag <sym-tag> <float theta> <int-x> <int-y> [<boolean-repaint>])
+;;    (gs:save-text <sym-id> <str-path>)
+;;    (gs:scale-tag <sym-tag> <float-x> <float-y> [<boolean-repaint>])
+;;    (gs:shear-tag <sym-tag> <float-x> <float-y> [<boolean-repaint>])
+;;    (gs:show-popup <sym-tag> <sym-host> <int-x> <int-y>)
+;;    (gs:show-tag <sym-tag> [<boolean-repaint>])
+;;    (gs:set-canvas <sym-tag>)
+;;    (gs:set-paint <list-rgb>)
+;;    (gs:set-rotation <float-angle>)
+;;    (gs:set-scale <int-x> <int-y>)
+;;    (gs:set-stroke <float-width> [<str-cap> [<str-join> [<float-miterlimit>]]])
+;;    (gs:set-translation <int-x> <int-y>)
+;;    (gs:set-anti-aliasing <boolean-flag>)
+;;    (gs:translate-tag <sym-tag> <int-x> <int-y> [<boolean-repaint>])
+;;    (gs:update)
+;; </pre>
+;; </li>
+;; <li><b>Events</b><br>
+;; Additionally to the event actions registered when creating a widget,
+;; the canvas, windows and dialogs can fire events as a result of key or mouse
+;; actions or when the position or size of a windows or dialog has changed.
+;; <pre>
+;;    (gs:key-event <sym-id> <sym-action>)
+;;    (gs:mouse-clicked <sym-canvas> <sym-action> [<boolean-tags>])
+;;    (gs:mouse-dragged <sym-canvas> <sym-action>)
+;;    (gs:mouse-event <sym-id> <sym-action>)
+;;    (gs:mouse-moved <sym-canvas> <sym-action> [<boolean-tags>])
+;;    (gs:mouse-pressed <sym-canvas> <sym-action> [<boolean-tags>])
+;;    (gs:mouse-released <sym-canvas> <sym-action> [<boolean-tags>])
+;;    (gs:mouse-wheel <sym-canvas> <sym-action>)
+;;    (gs:window-closed <sym-id> <sym-action>)
+;;    (gs:window-moved <sym-id> <sym-action>)
+;;    (gs:window-resized <sym-id> <sym-action>)
+;; </pre>
+;; </li>
+;; <li><b>Built-in icons and images</b><br>
+;; The 'guiserver.jar' file has the following icons and images built in. Each of
+;; them is prefixed with the path '/local/'. For example '/local/newLISP128.png'
+;; addresses the newLISP logo of size 128x128. To address images outside of
+;; 'guiserver.jar', use a normal file path suitable to your platform. On MS Windows
+;; use forward slashes instead of backslashes.
+;; <pre>
+;; Image path
+;; ----------
+;; clear-down32.png
+;; clear32.png
+;; copy-down32.png
+;; copy32.png
+;; cut-down32.png
+;; cut32.png
+;; dotgray16.png
+;; dotgray32.png
+;; dotgreen16.png
+;; dotgreen32.png
+;; dotred16.png
+;; dotred32.png
+;; dotyellow16.png
+;; dotyellow32.png
+;; edit-down32.png
+;; edit32.png
+;; folder-closed-down32.png
+;; folder-closed32.png
+;; folder-opened-down32.png
+;; folder-opened32.png
+;; font-book-down32.png
+;; font-book32.png
+;; green10.png
+;; info-down32.png
+;; info32.png
+;; new-down32.png
+;; new32.png
+;; newLISP-down32.png
+;; newLISP128.png
+;; newLISP16.png
+;; newLISP20.png
+;; newLISP32.png
+;; newLISP64.png
+;; newLISPsplashWin.png
+;; paste-down32.png
+;; paste32.png
+;; pressedbutton32.png
+;; red10.png
+;; restart-down32.png
+;; restart32.png
+;; run-down32.png
+;; run32.png
+;; save-down32.png
+;; save32.png
+;; search-down32.png
+;; search32.png
+;; stop-down32.png
+;; stop32.png
+;; </pre>
+;; <li><b>Predefined colors</b><br>
+;; The following colors are predefined:
+;; <pre>
+;; Name          rgb components
+;; ----          -------------- 
+;; gs:black      (0.0 0.0 0.0)
+;; gs:blue       (0.0 0.0 1.0)
+;; gs:cyan       (0.0 1.0 1.0)
+;; gs:darkGray   (0.2509804 0.2509804 0.2509804)
+;; gs:gray       (0.5019608 0.5019608 0.5019608)
+;; gs:green      (0.0 1.0 0.0)
+;; gs:lightGray  (0.7529412 0.7529412 0.7529412)
+;; gs:magenta    (1.0 0.0 1.0)
+;; gs:orange     (1.0 0.78431374 0.0)
+;; gs:pink       (1.0 0.6862745 0.6862745)
+;; gs:red        (1.0 0.0 0.0)
+;; gs:white      (1.0 1.0 1.0)
+;; gs:yellow     (1.0 1.0 0.0)
+;; </pre>
+;; Colors in newLISP-GS can be specified as three (four with alpha component) single
+;; numbers or as a list of the three RGB values followed by the alpha channel number.
+;; <pre>
+;; (gs:set-background 'aPanel gs:magenta
+;; (gs:set-background 'aPanel 1.0 0 1
+;; (gs:set-background 'aPanel '(1 0 1)
+;; </pre>
+;; All of the above statements will produce the same background color on the <tt>aPanel</tt>.
+;;
+;; <li><b>Sound  and MIDI API</b><br>
+;; The newLISP-GS sound API uses the default saundbank and sound hardware installed 
+;; on the platform newLISP-GS is running on. On Mac OS X nothing additional needs to be
+;; installed. On MS Windows and some Unix platforms a soundbank file needs to be installed.
+;; Soundbanks for the Java JRE can be obtained at:
+;; @link http://java.sun.com/products/java-media/sound/soundbanks.html http://java.sun.com/products/java-media/sound/soundbanks.html
+;; The demo files shipped with the newLISP-GS installation use the midsize soundbank. Other soundbanks
+;; may require different naming of instruments in the 'gs:midi-patch' statement. 
+;;
+;; The sound API is capable of playing of mutliple tracks at the same time
+;; depending on the sound hardware installed on a specific platform. Mac OS X platforms
+;; and most MS Windows platforms should be capable of playing 16 instruments (channels) at the
+;; the same time 32 on parallel sounding tracks. newLISP GS supports 128 instruments of the
+;; default soundbank installed.
+;;
+;; On Mac OS X and MS Windows channel 9 is a special channel sounding a different rythm 
+;; instrument for all 128 different keys/notes.
+;;
+;; Basic capabilities of the sound API are shown in the demo files <tt>midi-demo.lsp</tt>
+;; and <tt>midi2-demo.lsp</tt> in the <tt>/usr/local/share/newlisp/guiserver/</tt> or 
+;; <tt>c:\Program files\newlisp\guiserver\</tt> directory.
+;; <pre>
+;;    (gs:add-track <int channel><list-notes>)
+;;    (gs:channel-bend <int-channel> <bend>)
+;;    (gs:get-instruments)
+;;    (gs:instruments)
+;;    (gs:midi-bpm <int-bpm> [<int-resolution>])
+;;    (gs:midi-close)
+;;    (gs:midi-init [<str-file-path>])
+;;    (gs:midi-patch <int-instrument> [<int-channel>])
+;;    (gs:mute-track <int-track> <bool-on-off>)
+;;    (gs:play-note <int-key> [<int-duration> [<int-velocity> [<int-channel> [int-bend]]]])
+;;    (gs:play-sequence [<int-start-tick> [<int-loop-count> [<int-start-loop> [<int-end-loop>]]]])
+;;    (gs:save-sequence <str-file-path>)
+;;    (gs:stop-sequence)
+;;    (gs:play-sound <str-file-path>)
+;; </pre>
+;; </ul>
+(context 'gs)
+
+; ======================= preset colors
+
+(set 'gs:black '(0.0 0.0 0.0))
+(set 'gs:blue '(0.0 0.0 1.0))
+(set 'gs:cyan '(0.0 1.0 1.0))
+(set 'gs:darkGray '(0.2509804 0.2509804 0.2509804))
+(set 'gs:gray '(0.5019608 0.5019608 0.5019608))
+(set 'gs:green '(0.0 1.0 0.0))
+(set 'gs:lightGray '(0.7529412 0.7529412 0.7529412))
+(set 'gs:magenta '(1.0 0.0 1.0))
+(set 'gs:orange '(1.0 0.78431374 0.0))
+(set 'gs:pink '(1.0 0.6862745 0.6862745))
+(set 'gs:red '(1.0 0.0 0.0))
+(set 'gs:white '(1.0 1.0 1.0))
+(set 'gs:yellow '(1.0 1.0 0.0))
+
+; ====================== utility routines
+
+; set server path
+(if (= ostype "Windows")
+	; on some MS Windows systems the jar -> javaw.exe association my be missing, the use the following:
+	;(set 'server-path (string "javaw.exe -jar " "'\"" (env "NEWLISPDIR") "/guiserver.jar\"'")) 
+	(set 'server-path (string  "'\"" (env "NEWLISPDIR") "/guiserver.jar\"'"))
+	(set 'server-path (string (env "NEWLISPDIR") "/guiserver.jar"))
+)
+
+; Not documented gs:begin-cmd and gs:end-cmd
+; sends graphics ommands in transactions, to be used in:
+;
+; draw-arc, draw-circle, draw-ellipse, draw-image, draw-line, 
+; draw-path, draw-polyon, draw-rect, draw-round-rect, draw-text,
+;
+; fill-arc, fill-circle, fill-ellipse, fill-polygon, fill-rect, 
+; fill-round-rect, 
+;
+; color-tag, delete-tag, hide-tag, move-tag, rotate-tag, scale-tag,
+; shear-tag, translate-tag
+;
+; example:
+; (gs:begin-cmd)
+;   ; andy code containing 
+;   ; gs:draw-xxx, gs:fill-xx, gs:xxx-tag
+;   ; comands
+; (gs:end-cmd)
+;
+; The whole command sequence between gs:begin-cmd and gs:end-cmd
+; will be sent at once to the Java guiserver. This way minimizing
+; network overhead. 
+; Turns out, the speedup is too small in most of the demos.
+
+(define (gs:begin-cmd)
+	(set 'transaction-active true)
+	(set 'transaction-buffer "")
+)
+
+(define (gs:end-cmd)
+	(net-send out transaction-buffer)
+	(set 'transaction-buffer "")
+	(set 'transaction-active nil)
+)
+	
+(define (gs:send-out str)
+	(if transaction-active
+		(write-buffer transaction-buffer str)
+		(net-send out str);
+	)
+)
+
+;; <br><br><br>
+
+;; @syntax (gs:add-list-item <sym-list-combo> <str-text> [<str-text> ...])
+;; @param <sym-list-combo> The name of the combo box or list box to which text entries are added.
+;; @param <str-text> The text of the entry to be added.
+;;
+;; Items are added in the same sequence as they appear in the 'gs:add-list-item' command and added to the
+;; end of the existing list of items.
+
+(define (add-list-item comp)
+	(let (s (string "add-list-item " comp " "))
+		(doargs (item)
+			(write-buffer s (string (base64-enc item) " ")))
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+;; @syntax (gs:add-separator <sym-menu-tool-bar>)
+;; @param <sym-menu-tool-bar> The name of the tool bar or menu bar to which a spacer entry is added.
+;;
+;; Depending on the OS platform the separator may not be visible and only occupy space before the next 
+;; component added to the tool or menu bar.
+
+(define (add-separator bar)
+	(net-send out (string "add-separator " bar "\n"))
+)
+
+
+;; @syntax (gs:add-track <int-channel> <list-of-notes>)
+;; @param <int-channel> The channel belonging to this track.
+;; @param <list-of-notes> A list of notes. Each note is a list of key duration velocity and bend.
+;;
+;; In case of 'gs:add-track' the duration of a note is given in ticks.
+;; 16 ticks are in a quarter note or <em>beat</em>.
+;;
+;; A note is a list of 4 elements: '(<int-key> <int-duration> <int-velocity> [<int-bend>])'. <key>
+;; <duration>, <velocity> and <bend> can be given as variables, which will be evaluated by
+;; 'gs:add-track'. The <int-bend>  parameter is optional and assumed as <tt>0</tt> if not
+;; present. See the command 'gs:play-note' for more information on the note bend parameter.
+;; The following code is a complete example:
+;;
+;; @example
+;; (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+;; (gs:init)
+;; (gs:midi-init)
+;;
+;; (map set '(C C# D D# E F F# G G# A A# B c c# d e f f# g g# a a# b) (sequence 60 82))
+;; (set 'pp 30 'p 40 'm 64 'f 127) ; set velocity/volume
+;;
+;; (gs:midi-patch "Piano" 0)
+;; (gs:midi-patch "Pizzicato Strings" 1)
+;; (gs:midi-patch "Woodblock" 2)
+;;
+;; (gs:add-track 0 '( (C 12 m) (C# 4 m) (D 16 m) (c 16 f) (D 16 m)) )
+;; (gs:add-track 1 (dup '(d 4 pp) 16))
+;; (gs:add-track 2 '( (c 4 p) (c 12 p) (c 4 p) (c 12 p) (c 4 p) (c 12 p)  (c 4 p) (c 12 p)) )
+;;
+;; (gs:play-sequence)
+;;
+;; (sleep 5000)
+;; (gs:midi-close)
+;; (exit)
+
+;; The second example shows the usage of pitch-bend in notes:
+;; 
+;; @example
+;; (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+;; (gs:init)
+;; (gs:midi-init)
+;; 
+;; (gs:midi-patch "Piano" 0)
+;; (gs:midi-patch "Gunshot" 1)
+;; (gs:midi-patch "Telephone" 2)
+;; 
+;; (for (n -8192 8191 128) (push (list 64 1 95 n) track0 -1))
+;; (for (n 64 96 2) (push (list n 8 76) track1 -1))
+;; 
+;; (gs:add-track 0 track0)
+;; (gs:add-track 1 track1)
+;; (gs:add-track 2 '((44 128 127)))
+;; 
+;; (gs:play-sequence)
+;; ;(gs:save-sequence "extremeAlarm.mid")
+;; 
+;; (sleep 8000)
+;; (gs:midi-close)
+;; (exit)
+
+(define (add-track channel notes)
+	(net-send out (string "add-track System " channel " "))
+	(local (bend)
+		(dolist (n notes)
+			(set 'bend (if (= 4 (length n)) (eval (n 3)) 0))
+			(net-send out (string (eval (n 0)) " " (eval (n 1)) " " (eval (n 2)) " " bend " ")))
+	)
+	(net-send out "\n")
+)
+
+;; @syntax (gs:add-to <sym-container> <sym-component> [<sym-componentl> ...])
+;; @param <sym-container> The name of the container to which components are added.
+;; @param <sym-component> One or more symbols of the components to add.
+
+
+;; @syntax (gs:add-to <sym-container> <sym-component> <str-orientation> [<sym-component> <str-orientation> ...])
+;; @param <sym-container> The name of the container to which components are added.
+;; @param <sym-component> The name of a component to add.
+;; @param <str-orientation> The orientation of a component to add in border layout, '"north"', '"west"', '"center"', '"east"' or '"south"'.
+
+(define (add-to id)
+	(let (s (string "add-to " id " "))
+		(doargs (item)
+			(write-buffer s (string item " ")))
+		(write-buffer s "\n")
+		(net-send out s)
+	)
+)
+
+;; @syntax (gs:append-text <sym-id> <str-text>)
+;; @param <sym-id> The name of the text field or text area to which text is appended.
+;; @param <str-text> The text to be appended.
+
+(define (append-text id text)
+	(net-send out (string "append-text " id " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:button <sym-id> <sym-action> [<str-text> [<int-width> <int-height>]])
+;; @param <sym-id> The name of the button.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-text> An optional text for the button.
+;; @param <int-width> The optional width of the button.
+;; @param <int-height> The optional height of the button.
+
+(define (button id action text x y)
+	(if text
+		(if (and x y)
+			(net-send out (string "button " id " " action " " (base64-enc text) " " x " " y "\n"))
+			(net-send out (string "button " id " " action " " (base64-enc text) "\n")))
+		(net-send out (string "button " id " " action "\n"))
+	)
+)
+
+;; @syntax (gs:canvas <sym-id>) 
+;; @param <sym-id> The name of the canvas.
+;;
+;; A canvas is a panel for drawing and receiving mouse input events. For most
+;; applications a background color should be specified for the canvas using
+;; 'gs:set-background' or 'gs:set-color' which call the same function internally. The
+;; background forces the canvas to be cleared before redrawing components
+;; which have been moved, rotated, scaled or deleted. In applications where
+;; this is not desired but a background color is still required, the background
+;; color can be specified for the container hosting the canvas. The canvas
+;; background will then appear in the color of the container, but erasing
+;; the canvas before repainting is not enforced.
+;;
+;; A canvas can also be used to host widgets like buttons etc.. In this case
+;; the canvas is treated like a 'gs:panel', with a flow layout by default.
+;; Similar to a panel created with 'gs:panel' other layouts can be set.
+;;
+;; When widgets are present on a canvas they appear to be floating over
+;; the drawing. See the file 'textrot-demo.lsp' for an example.
+
+(define (canvas id parent)
+	(set 'gs:currentCanvas id)
+	(net-send out (string "canvas " id "\n"))
+)
+
+;; @syntax (gs:channel-bend <int-channel> <bend>)
+;; @param <int-channel> The channel where the pitch bend is set.
+;; @param <int-bend> The channel bend between <tt>0</tt> and <tt>16383</tt>.
+;;
+;; Numbers upwards of <tt>8192</tt> bend the tone upwards, numbers smaller
+;; than <tt>8192</tt> bend the tone downwards. To switch off channel bend set
+;; the number to the middle posiotion of <tt>8192</tt>. 'gs:channel-bend' can 
+;; be used to bring a channel in tune with an external sound source.
+
+(define (channel-bend channel bend)
+	(net-send out (string "channel-bend System " channel " " bend "\n"))
+)
+
+; @syntax (gs:channel-reverb <int-channel> <reverb>)
+; @param <int-channel> The channel where the reverb is set.
+; @param <int-reverb> The channel reverb between <tt>0</tt> and <tt>127</tt>.
+;
+; Sets the reverberation of the channel for all notes.
+
+(define (channel-reverb channel reverb)
+	(net-send out (string "channel-reverb System " channel " " reverb "\n"))
+)
+
+;; @syntax (gs:check-box <sym-id> <sym-action> [<str-text> [<bool-selected>]])
+;; @param <sym-id> The name of the check box.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-text> The text of the check box.
+;; @param <bool-selected> An optional flag indicating the selection state 'true' or 'nil' (default).
+;;
+
+(define (check-box id action text selected)
+	(if text
+		(net-send out (string "check-box " id " " action " " (base64-enc text) " " selected "\n"))
+		(net-send out (string "check-box " id " " action "\n")))
+)
+
+;; @syntax (gs:check-event <int-microseconds>)
+;; @param <int-microseconds> Wait for an event a maximum of <int-microseconds> and execute it.
+;;
+;; The function 'gs:check-event' is used as an alternative to 'gs:listen' when the application
+;; is performing some activity while waiting for user input from the GUI. Typically
+;; 'gs:check-event' is used in a loop, which performs some other task and at the same time
+;; checks for events from the GUI part of the application. Like 'gs:listen' the function will 
+;; force an exit of the application when communication between the newLISP-GS and the newLISP
+;; application process fails. 
+;;
+;; @example
+;; (while (gs:check-event 10000) ; check for 10 milliseconds
+;;     (do-myprocess)
+;; )
+
+
+(define (check-event us , event)
+	(when (net-select in "read" us)
+		(if (net-receive in event 1000000000 "\n")
+			(begin 	
+			;	(println "check-event: " event)
+				(eval-string event))
+			(exit)))
+true
+)
+
+;; @syntax (gs:clear-list <sym-id>)
+;; @param <sum-id> The name of the list component in which to clear all entries.
+
+(define (clear-list id)
+	(net-send out (string "clear-list " id "\n"))
+)
+
+;; @syntax (gs:clear-text <sym-id>)
+;; @param <sum-id> The name of the component in which to clear the text.
+
+(define (clear-text id)
+	(net-send out (string "clear-text " id "\n"))
+)
+
+;; @syntax (gs:copy-text <sym-id>)
+;; @param <sum-id> The name of the text component from which to copy the selection to the clipboard.
+
+(define (copy-text id)
+	(net-send out (string "copy-text " id "\n"))
+)
+
+;; @syntax (gs:cut-text <sym-id>)
+;; @param <sym-id-text> The name of the text component from which to cut selected text and place it on the clipboard..
+
+(define (cut-text id)
+	(net-send out (string "cut-text " id "\n"))
+)
+
+
+;; @syntax (gs:color-dialog <sym-parent-frame> <sym-action> <str-title> <float-red> <float-green> <float-blue>)
+;; @param <sym-parent-frame> The name symbol of the parent frame.
+;; @param <sym-action> The symbol of the handler to call when leaving the dialog
+;; @param <str-title> The title of the color dialog.
+;; @param <float-red> The initial red color component.
+;; @param <float-green> The initial green color component.
+;; @param <float-blue> The initial blue color component.
+
+(define (color-dialog parent action title red green blue)
+	(net-send out (string "color-dialog " parent " " action " " (base64-enc title) " " red " " green " " blue "\n"))
+)
+
+
+;; @syntax (gs:color-tag <sym-tag> <list-color> [<boolean-update>])
+;; @param <sym-tag> The name tag of the shape(s) to set a new color.
+;; @param <list-color> The new color as a list of 3 numbers for the rgb components.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+
+(define (color-tag tag color (update true))
+	(send-out (string "color-tag " gs:currentCanvas " " tag " "
+		(color 0) " " (color 1) " " (color 2) " " update "\n"))
+)
+
+;; @syntax (gs:combo-box <sym-id> <sym-action> [<str-item-1> ...])
+;; @param <sym-id> The name of the combo box.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-item> Zero, one or more text entries in the combo box.
+;; @syntax (gs:combo-box <sym-id> <sym-action> [<list-str-items>])
+;; @param <sym-id> The name of the combo box.
+;; @param <sym-action> The name of the event handler.
+;; @param <list-str-items> Zero, one or more text entries in a list.
+
+(define (combo-box id action)
+	(let (	s (string "combo-box " id " " action " ")
+					entries (if (list? (args 0)) (args 0) (args)) )
+		(dolist (item entries)
+			(write-buffer s (string (base64-enc item) " ")))
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+;; @syntax (gs:confirm-dialog <sym-parent-frame> <sym-action> <str-title> <str-message> [<str-type>])
+;; @param <sym-parent-frame> The symbol name of the parent frame.
+;; @param <sym-action> The action to perform when the diaog is closed.
+;; @param <str-title> The title of the message box.
+;; @param <str-message> The message in the message box.
+;; @param <str-type> The type of the message box.
+;;
+;; The type of the message box can be one of: '"yes-no"', '"yes-no-cancel"'
+;; On return of the message box <sym-action> carries one of the responses <tt>0</tt> for the yes-,
+;; <tt>1</tt> for the no- or <tt>2</tt> for the cancel-button.
+
+(define (confirm-dialog parent action title msg (type "plain"))
+	(net-send out (string "confirm-dialog " parent " " action " " 
+						(base64-enc title) " " (base64-enc msg) " " type "\n"))
+)
+
+;; @syntax (gs:delete-tag <sym-tag> [<boolean-repaint>])
+;; @param <sym-tag> The tag group to be deleted.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+;; Deletes all 2D objects (lines, shapes, text, images) tagged with <sym-tag>.
+;;
+;; Each time a 'gs:draw-xxx' or 'gs:fill-xxx' function is called a graphical
+;; object is created. The tag used during creation is a way to address one
+;; or more of these objects. See the file 'mouse-demo.lsp' for an example.
+
+(define (delete-tag tag (repaint true))
+	(send-out (string "delete-tag " gs:currentCanvas " " tag  " " repaint "\n"))
+)
+
+;; @syntax (gs:destroy-shell <sym-text-area>)
+;; @param <sym-text-area> The name of the text component for which the shell process is destroyed.
+
+(define (destroy-shell id)
+	(net-send out (string "destroy-shell " id "\n"))
+)
+
+;; @syntax (gs:dialog <sym-id> <sym-parent> <str-title> <int-width> <int-height> [<boolean-visible> [<boolean-modal>]])
+;; @param <sym-id> The name of the dialog
+;; @param <sym-parent> The name of the parent frame.
+;; @param <str-title> The title string of the dialog frame.
+;; @param <int-width> The width of the dialog frame.
+;; @param <int-height> The height of the dialog frame.
+;; @param <boolean-visible> The optional flag with a value of 'true' or 'nil' for visibility of the dialog.
+;; @param <boolean-modal> The optional flag with a value of 'true' or 'nil' for modality of the dialog.
+;;
+;; Initially the dialog should not be visible until all widgets are added to it. 
+;; When no flags for visibility and modality are specified, 'nil' is assumed. A modal dialog will
+;; prevent input in the parent window. Components can be added to a dialog using 'gs:add-to'.
+;; Use the 'gs:set-border-layout', 'ga:set-flow-layout' or 'gs:set-grid-layout' to set a specific
+;; layout.
+
+(define (dialog id parent title width height visible modal)
+	(net-send out (string "dialog " id " " parent " " (base64-enc title) " " width " " height " " visible " " modal"\n"))
+)
+
+;; @syntax (gs:disable <sym-id-1> [sym-id-2 ...])
+;; @param <sym-id> The name of the component to disable.
+;;
+;; Disabled components are grayed and do not accept input.
+
+(define (disable)
+	(let (s "disable ")
+		(doargs (item)
+			(write-buffer s (string item " ")))
+		(write-buffer s "\n")
+		(net-send out s)
+	)
+)
+
+;; @syntax (gs:dispose <sym-id>)
+;; @param <sym-id> The name of the component to dispose of.
+;;
+;; Only objects created with 'gs:dialog', 'gs:frame' or 'gs:window' can be
+;; deleted with 'gs:dispose'.
+
+(define (dispose id)
+	(net-send out (string "dispose " id "\n"))
+)
+
+;; @syntax (gs:dispose-splash)
+;;
+;; A splash screen can be specified when starting the newLISP-GS process before newLISP. 
+;; The function 'gs:dispose-splash' is used to turn off the splash image after
+;; the newLISP GUI application has started.
+;;
+;; @example
+;; java -jar /usr/share/newlisp/guiserver.jar 64001 program.lsp /local/newLISP128.png
+;; ; or on MS Windows
+;; java -jar "c:\Program Files\newlisp\guiserver.jar" 64001 "newlisp program.lsp" /local/newLISPsplashWin.png
+
+;; The example starts newLISP-GS with an application 'program.lsp' and a splash
+;; screen showing the built-in newLISP logos and using port 64001/2. Instead, the full pathname 
+;; of a different image file can be specified. Inside 'program.lsp' the function
+;; 'gs:dispose-splash' or a mouse click on the image will turn off the splash screen. 
+;; For 'program.lsp' the full pathname may be necessary. On MS Windows quotes are necessary to bracket 
+;; arguments to 'guiserver.jar' which contain spaces. 
+
+(define (dispose-splash)
+	(net-send out "dispose-splash System\n")
+) 
+
+;; @syntax (gs:draw-arc <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-start> <int-angle> [<list-rgb>])
+;; @param <sym-tag> The tag group of the arc.
+;; @param <int-x> The X position of the arc.
+;; @param <int-y> The Y position of the arc.
+;; @param <int-width> The width of the arc.
+;; @param <int-height> The height of the arc.
+;; @param <int-start-angle> The start angle of the arc in 0 to 360 degrees.
+;; @param <int-arc-angle> The opening angle of the arc in 0 to 360 degrees.
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components
+;;
+;; The resulting arc begins at <int-start-angle> and extends for <int-arc-angle degrees>, 
+;; using the current color. Angles are interpreted such that 0 degrees is at the 3 o'clock 
+;; position. A positive value indicates a counter-clockwise rotation while a negative value 
+;; indicates a clockwise rotation.
+;;
+;; The center of the arc is the center of the rectangle whose origin is (x, y) and whose size 
+;; is specified by the width and height arguments.
+;;
+;; The resulting arc covers an area <int-width> pixels wide by <int-height> pixels tall.
+
+(define (draw-arc id x y width height start angle color)
+	(if color
+		(send-out (string "draw-arc " gs:currentCanvas " " id " " x " " y " "
+						width " " height " " start " " angle " " 
+						(color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "draw-arc " gs:currentCanvas " " id " " x " " y " "
+						width " " height " " start " " angle "\n"))
+	)
+)
+
+
+;; @syntax (gs:draw-circle <sym-tag> <int-x> <int-y> <int-radius> [<list-rgb>])
+;; @param <sym-tag> The tag group of the circle.
+;; @param <int-x> The X position of the circle center.
+;; @param <int-y> The Y position of the circle center.
+;; @param <int-radius> The radius of the circle.
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components
+;;
+;; Creates the outline of a circle. The color numbers must be entered in list form.
+;; If no <list-rgb> is used the current paint specified with 'gs:set-paint' is used.
+
+(define (draw-circle tag x y radius color)
+	(if color
+		(send-out (string "draw-circle " gs:currentCanvas " " 
+			tag " " x " " y " " radius " " (color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "draw-circle " gs:currentCanvas " " 
+			tag " " x " " y " " radius "\n"))
+	)
+)
+
+;; @syntax (gs:draw-ellipse <sym-tag> <int-x> <int-y> <int-radius-x> <int-radius-y> [<list-rgb>])
+;; @param <sym-tag> The tag group of the ellipse.
+;; @param <int-x> The X position of the ellipse center.
+;; @param <int-y> The Y position of the ellipse center.
+;; @param <int-radius-x> The radius of the ellipse.
+;; @param <int-radius-y> The radius of the ellipse.
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components
+;;
+;; Creates the outline of an ellipse. The color numbers must be enterd in list form.
+;; If no <list-rgb> is used the current paint specified with 'gs:set-paint' is used.
+
+(define (draw-ellipse tag x y radius-x radius-y color)
+	(if color
+		(send-out (string "draw-ellipse " gs:currentCanvas " " 
+			tag " " x " " y " " radius-x " " radius-y " " (color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "draw-ellipse " gs:currentCanvas " " 
+			tag " " x " " y " " radius-x " " radius-y  "\n"))
+	)
+)
+
+;; @syntax (gs:draw-image <sym-tag> <str-path> <int-x> <int-y> [<int-width> <int-height>])
+;; @param <sym-tag> The tag group of the image.
+;; @param <str-path> The file path-name of the image.
+;; @param <int-x> The X position of the image top left corner.
+;; @param <int-y> The Y position of the image top left corner.
+;; @param <int-width> The optional width in which to draw the image.
+;; @param <int-height> The optional height in which to draw the image.
+;;
+;; When <int-width> and <int-height> parameters are specified and they are not
+;; equal to the original size of the image (measured in pixels) the image will
+;; be displayed in either compressed or zoomed form.
+
+(define (draw-image tag image-path x y width height)
+	(if (and width height)
+		(send-out (string "draw-image " gs:currentCanvas " " tag " " 
+				(base64-enc image-path) " " x " " y " " width " " height "\n"))
+		(send-out (string "draw-image " gs:currentCanvas " " tag " " 
+				(base64-enc image-path) " " x " " y "\n"))
+	)
+) 
+
+;; @syntax (gs:draw-line <sym-tag> <int-x1> <int-y1> <int-x2> <int-y2> [<list-rgb>])
+;; @param <sym-tag> The tage of the line.
+;; @param <int-x1> The X position of the first point.
+;; @param <int-y1> The Y position of the first point.
+;; @param <int-x2> The X position of the second point.
+;; @param <int-y2> The Y position of the second point.
+;;
+;; Draws a line. The color numbers must be entered in list form.
+;; If no <list-rgb> is used the current paint specified with 'gs:set-paint' is used.
+
+(define (draw-line tag x1 y1 x2 y2 color)
+	(if color
+		(send-out (string "draw-line " gs:currentCanvas " " tag " "
+			x1 " " y1 " " x2 " " y2 " " (color 0) " " (color 1) " " (color 2) "\n"))
+	)
+)
+
+;; @syntax (gs:draw-path <sym-tag> <list-points> [<list-rgb>])
+;; @param <sym-tag> The tage group of the path.
+;; @param <list-points> The list of x and y coordinates of the points.
+;;
+;; Draws a path with the points found in <list-points>. 
+;;
+;; @example 
+;; (gs:draw-path 'P '(1 0 2 2 3 0))
+
+;; The example will draw an upwards-pointing triangle without base at the 
+;; points '1,0', '2,2' and '3,0' 
+
+(define (draw-path tag points color)
+	(if color
+		(let (s (string "draw-path " gs:currentCanvas " " tag " " (/ (length points) 2) " "))
+			(dolist (p points)
+				(write-buffer s (string p " ")))
+			(write-buffer s (string (color 0) " " (color 1) " " (color 2) "\n"))
+			(send-out s)
+		)
+		(let (s (string "draw-path " gs:currentCanvas " " tag " " (/ (length points) 2) " "))
+			(dolist (p points)
+				(write-buffer s (string p " ")))
+			(write-buffer s "\n")
+			(send-out s)
+		)
+	)
+)
+
+;; @syntax (gs:draw-polygon <sym-tag> <list-points> [<list-rgb>])
+;; @param <sym-tag> The tag group of the polygon.
+;; @param <list-points> The list of x and y coordinates of the points.
+;;
+;; Draws a polygon with the points found in <list-points>. 
+;;
+;; @example 
+;; (gs:draw-polygon 'P '(1 0 2 2 3 0))
+
+;; The example will draw an upwards-pointing triangle with the points '1,0', '2,2'
+;; and '3,0'.
+
+(define (draw-polygon tag points color)
+	(if color
+		(let (s (string "draw-polygon " gs:currentCanvas " " tag " " (/ (length points) 2) " "))
+			(dolist (p points)
+				(write-buffer s (string p " ")))
+			(write-buffer s (string (color 0) " " (color 1) " " (color 2) "\n"))
+			(send-out s)
+		)
+		(let (s (string "draw-polygon " gs:currentCanvas " " tag " " (/ (length points) 2) " "))
+			(dolist (p points)
+				(write-buffer s (string p " ")))
+			(write-buffer s "\n")
+			(send-out s)
+		)
+	)
+)
+
+
+;; @syntax (gs:draw-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> [<list-rgb>])
+;; @param <sym-tag> The tag group of the rectangle.
+;; @param <int-x> The X position of the top left corner.
+;; @param <int-y> The Y position of the top left corner.
+;; @param <int-width> The width of the rectangle.
+;; @param <int-height> The height of the rectangle..
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components
+;;
+;; Creates the outline of a rectangle. The color numbers must be entered in list form.
+;; If no <list-rgb> is used the current paint specified with 'gs:set-paint' is used.
+
+(define (draw-rect tag x y width height color)
+	(if color
+		(send-out (string "draw-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height " " (color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "draw-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height "\n"))
+	)
+)
+
+
+;; @syntax (gs:draw-round-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-arc-width> <int-arc-height> [<list-rgb>])
+;; @param <sym-tag> The tag group of the round rectangle.
+;; @param <int-x> The X position of the top left corner.
+;; @param <int-y> The Y position of the top left corner.
+;; @param <int-width> The width of the rectangle.
+;; @param <int-height> The height of the rectangle..
+;; @param <int-arc-width> The width of the corner rectangle.
+;; @param <int-arc-height> The height of the corner rectangle..
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components
+;;
+;; Draws a rectangle shape with round corners. The rounding is defined by the rectangle enclosing
+;; the rounding arc.
+
+(define (draw-round-rect tag x y width height arcw arch color)
+	(if color
+		(send-out (string "draw-round-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height " "  arcw " " arch " " 
+				(color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "draw-round-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height  " " arcw " " arch "\n"))
+	)
+)
+
+
+;; @syntax (gs:draw-text <sym-tag> <str-text> <int-x> <int-y> [<list-rgb> [<float-angle>])
+;; @param <sym-tag> The tag group of the text.
+;; @param <str-text> The text to be drawn.
+;; @param <int-x> The X position of the text.
+;; @param <int-y> The Y position of the text.
+;; @param <list-rgb> The optonal color for the text.
+;; @param <float-angle> The optional angle for text in degrees
+;;
+;; If no <list-rgb> is used, the current paint specified with 'gs:set-paint' is used.
+;; The optional angle is <tt>0</tt> by default for horizontal text. A value of <tt>90</tt>
+;; will rotate the text around the <tt>x</tt>, <tt>y</tt> position downwards clockwise.
+
+(define (draw-text tag text x y color angle)
+	(if color
+		(if angle
+			(send-out (string "draw-text " gs:currentCanvas " "
+				tag " "  (base64-enc text) " " x " " y " " 
+				(color 0) " " (color 1) " " (color 2) " " angle "\n"))
+			(send-out (string "draw-text " gs:currentCanvas " "
+				tag " "  (base64-enc text) " " x " " y " " 
+				(color 0) " " (color 1) " " (color 2) "\n"))
+		)
+		(send-out (string "draw-text " gs:currentCanvas " "
+			tag " "  (base64-enc text) " " x " " y "\n"))
+	)
+)
+
+
+
+
+;; @syntax (gs:enable <sym-id-1> [sym-id-2 ...])
+;; @param <sym-id> The name of a component to enable.
+;;
+;; Components are enabled by default.
+
+(define (enable)
+	(let (s (string "enable "))
+		(doargs (item)
+			(write-buffer s (string item " ")))
+		(write-buffer s "\n")
+		(net-send out s)
+	)
+)
+
+;; @syntax (gs:eval-shell <sym-id-text-area> <str-command>)
+;; @param <sym-id-text-area> The name of the text area in which to evaluate text.
+;; @param <str-command> The text to evaluate in the shell.
+
+(define (eval-shell id command)
+	(net-send out (string "eval-shell " id " " (base64-enc command) "\n"))
+)
+
+;; @syntax (gs:export <str-path-file> [<int-width> <int-height>])
+;; @param <str-path-file> The path and file name of the image file to write to.
+;; @param <int-width> The optional width of the image in pixels.
+;; @param <int-height> The optional height of the image in pixels.
+;;
+;; If no width and height are specified, the current size of the canvas is assumed.
+;;
+;; @example
+;;
+;; (gs:export "/usr/home/pictures/mypic.png")
+
+;; This will generate a '.png' file exactly as the image seen on the screen.
+;; The color format is RGBA with 8 bit per color and an alpha channel. When
+;; no background color is defined for the canvas, the background will be
+;; transparent.
+;;
+;; When specifying width and height, a smaller or bigger portion of the canvas
+;; than seen on the screen is printed to the image.
+
+(define (export image-path width height)
+	(let (result (if (and width height)
+		(net-send out (string "export " gs:currentCanvas " " (base64-enc image-path) " " width " " height "\n"))
+		(net-send out (string "export " gs:currentCanvas " " (base64-enc image-path) "\n")) ))
+        (if (number? result) true nil)
+    )
+)
+			
+
+;; @syntax (gs:fill-arc <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-start> <int-angle> [<list-rgb>])
+;; @param <sym-tag> The tag group of the arc.
+;; @param <int-x> The X position of the arc.
+;; @param <int-y> The Y position of the arc.
+;; @param <int-width> The width of the arc.
+;; @param <int-height> The height of the arc.
+;; @param <int-start-angle> The start angle of the arc in 0 to 360 degrees.
+;; @param <int-arc-angle> The opening angle of the arc in 0 to 360 degrees.
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components.
+;;
+;; The resulting arc begins at <int-start-angle> and extends for <int-arc-angle degrees>, 
+;; using the current color. Angles are interpreted such that 0 degrees is at the 3 o'clock 
+;; position. A positive value indicates a counter-clockwise rotation while a negative value 
+;; indicates a clockwise rotation.
+;;
+;; The center of the arc is the center of the rectangle whose origin is (x, y) and whose size 
+;; is specified by the width and height arguments.
+;;
+;; The resulting arc covers an area <int-width> pixels wide by <int-height> pixels tall.
+
+(define (fill-arc id x y width height start angle color)
+	(if color
+		(send-out (string "fill-arc " gs:currentCanvas " " id " " x " " y " "
+						width " " height " " start " " angle " " 
+						(color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "fill-arc " gs:currentCanvas " " id " " x " " y " "
+						width " " height " " start " " angle "\n"))
+	)
+)
+
+;; @syntax (gs:fill-circle <sym-tag> <int-x> <int-y> <int-radius> [<list-rgb>])
+;; @param <sym-tag> The tag group of the circle.
+;; @param <int-x> The X position of the circle center.
+;; @param <int-y> The Y position of the circle center.
+;; @param <int-radius> The radius of the circle.
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components.
+;;
+;; Creates a filled  circle. The color numbers must be entered in list form.
+;; If no <list-rgb> is used, the current paint specified with 'gs:set-paint' is used.
+
+(define (fill-circle tag x y radius color)
+	(if color
+		(send-out (string "fill-circle " gs:currentCanvas " " 
+			tag " " x " " y " " radius " " (color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "fill-circle " gs:currentCanvas " " 
+			tag " " x " " y " " radius "\n"))
+	)
+)
+
+;; @syntax (gs:fill-ellipse <sym-tag> <int-x> <int-y> <int-radius-x> <int-radius-y> [<list-rgb>])
+;; @param <sym-tag> The tag group of the ellipse.
+;; @param <int-x> The X position of the ellipse center.
+;; @param <int-y> The Y position of the ellipse center.
+;; @param <int-radius-x> The radius of the ellipse.
+;; @param <int-radius-y> The radius of the ellipse.
+;; @param <list-rgb> The fill color as a list of 3 numbers for the rgb components.
+;;
+;; Creates a filled ellipse. The color numbers must be entered in list form.
+;; If no <list-rgb> is used, the current paint specified with 'gs:set-paint' is used.
+
+(define (fill-ellipse tag x y radius-x radius-y color)
+	(if color
+		(send-out (string "fill-ellipse " gs:currentCanvas " " 
+			tag " " x " " y " " radius-x " " radius-y " " 
+				(color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "fill-ellipse " gs:currentCanvas " " 
+			tag " " x " " y " " radius-x " " radius-y  "\n"))
+	)
+)
+
+;; @syntax (gs:fill-polygon <sym-tag> <list-points> [<list-color>])
+;; @param <sym-tag> The tag group of the polygon.
+;; @param <list-points> The list of x and y coordinates of the points.
+;;
+;; Draws a polygon with the points found in <list-points> and fills it with
+;; the current color set with 'gs:set-paint' or the optional color
+;; given in <list-color>.
+;;
+;; @example 
+;; (gs:fill-polygon 'P '(1 0 2 2 3 0))
+;;
+;; (gs:fill-polygon 'P '(1 0 2 2 3 0) gs:gray)
+
+;; The example will fill an upwards pointing triangle with the points '1,0', '2,2'
+;; and '3,0' and fill it with the current color set with 'gs:set-paint'. The second
+;; example paints a gray triangle regardless of the current color set with
+;; 'gs:set-paint'.
+
+(define (fill-polygon tag points color)
+	(if color
+		(let (s (string "fill-polygon " gs:currentCanvas " " tag " " (/ (length points) 2) " "))
+			(dolist (p points)
+				(write-buffer s (string p " ")))
+			(write-buffer s (string (color 0) " " (color 1) " " (color 2) "\n"))
+			(send-out s)
+		)
+		(let (s (string "fill-polygon " gs:currentCanvas " " tag " " (/ (length points) 2) " "))
+			(dolist (p points)
+				(write-buffer s (string p " ")))
+			(write-buffer s "\n")
+			(send-out s)
+		)
+	)
+)
+
+;; @syntax (gs:fill-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> [<list-rgb>])
+;; @param <sym-tag> The tag group of the rectangle.
+;; @param <int-x> The X position of the top left corner.
+;; @param <int-y> The Y position of the top left corner.
+;; @param <int-width> The width of the rectangle.
+;; @param <int-height> The height of the rectangle.
+;; @param <list-rgb> The fill color as a list of 3 numbers for the rgb components.
+;;
+;; Creates a filled rectangle. The color numbers must be entered in list form.
+;; If no <list-rgb> is used, the current paint specified with 'gs:set-paint' is used.
+
+(define (fill-rect tag x y width height color)
+	(if color
+		(send-out (string "fill-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height " " (color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "fill-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height "\n"))
+	)
+)
+
+;; @syntax (gs:fill-round-rect <sym-tag> <int-x> <int-y> <int-width> <int-height> <int-arc-width> <int-arc-height> [<list-rgb>])
+;; @param <sym-tag> The tag group of the round rectangle.
+;; @param <int-x> The X position of the top left corner.
+;; @param <int-y> The Y position of the top left corner.
+;; @param <int-width> The width of the rectangle.
+;; @param <int-height> The height of the rectangle..
+;; @param <int-arc-width> The width of the corner rectangle.
+;; @param <int-arc-height> The height of the corner rectangle.
+;; @param <list-rgb> The outline color as a list of 3 numbers for the rgb components.
+;;
+;; Paints a rectangle shape with round corners. The rounding is defined by the rectangle enclosing
+;; the rounding arc.
+
+(define (fill-round-rect tag x y width height arcw arch color)
+	(if color
+		(send-out (string "fill-round-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height " "  arcw " " arch " " 
+				(color 0) " " (color 1) " " (color 2) "\n"))
+		(send-out (string "fill-round-rect " gs:currentCanvas " " 
+			tag " " x " " y " " width " " height  " " arcw " " arch "\n"))
+	)
+)
+
+;; @syntax (gs:find-text <sym-id> <str-text> <sym-action> [<str-direction>])
+;; @param <sym-id> The name of the text area or text pane.
+;; @param <str-text> The searching text.
+;; @param <sym-action> A optional action to peform after find-text.
+;; @param <str-direction> The optional direction string '"next"' (default) or '"previous"'.
+;;
+;; The text area or text pane will be searched starting at the current caret position
+;; forward or backwards depending on the optional direction field. After the search
+;; the found text is highlighted. If the optional <sym-action> is specified an event
+;; containing the id of the text area or pane and found position or '-1' will be fired.
+
+(define (find-text id text action (direction "next"))
+	(net-send out (string "find-text " id " " (base64-enc text) " " action " " direction "\n"))
+)
+
+
+
+;; @syntax (gs:frame <sym-id> <int-x> <int-y> <int-width> <int-height> [<str-title> <boolean-visible>])
+;; @param <sym-id> The name of the frame window.
+;; @param <int-x> The X position of the top left window corner.
+;; @param <int-y> The Y position of the top left windows corner.
+;; @param <int-width> The width of the window frame.
+;; @param <int-height> The height of the windows frame.
+;; @param <str-title> The optional title of the window.
+;; @param <boolean-visible> The optional flag with a value of 'true' or 'nil' for the visibility of the window.
+;;
+;; Initially the frame should not be visible until all widgets are added to it. 
+;; When no flag for visibility is specified 'nil' is assumed. The default layout of a frame behaves
+;; like a grid layout with one cell. Use the 'set-flow-layout', 'set-border-layout' and
+;; 'set-grid-layout' to change the layout.
+
+
+(define (frame id x y width height text visible)
+	(if text
+		(net-send out (string "frame " id " " x " " y " " width " " height " " (base64-enc text) " " visible "\n"))
+		(net-send out (string "frame " id " " x " " y " " width " " height "\n"))
+	)
+)
+
+;; @syntax (gs:get-bounds <sym-id>)
+;; @param <sym-id> The id of the component for which to get the list of bounding values.
+;; @return The bounding list '(<x> <y> <width> <height>)'
+ 
+(define (get-bounds id)
+	(set 'gs:bounds nil)
+	(net-send out (string "get-bounds " id "\n"))
+	(while (not gs:bounds) (check-event 10000))
+	gs:bounds
+)
+
+;; @syntax (gs:get-fonts)
+;; @return A list of family names for fonts on the current system.
+;;
+;; The function should be called only once because it may take considerable
+;; time in a system loaded with many fonts. The variable 'gs:fonts' contains
+;; the same list of fonts originally returned by a call to 'gs:get-fonts'.
+
+(define (get-fonts)
+	(if (not gs:fonts)
+		(begin
+    		(net-send out (string "get-fonts System\n"))
+			(while (not gs:fonts) (check-event 10000))
+			(set 'gs:fonts (map base64-dec gs:fonts))
+		)
+	)
+)
+
+;; @syntax (gs:get-font-metrics <sym-id> <str-text>)
+;; @return A list of the two values for width and height in pixels.
+;;
+;; The font metrics for the currently set font in <sym-id> are returned as a list
+;; of width and height in pixels when displaying the string in <str-text>.
+;; After the function call the variable 'gs:font-metrics' contains the same list
+;; of values as originally returned by the call to 'gs:get-font-metrics'.
+
+(define (get-font-metrics id text)
+	(set 'gs:font-metrics nil)
+	(net-send out (string "get-font-metrics " id " " (base64-enc text) "\n"))
+	(while (not gs:font-metrics) (check-event 10000))
+	gs:font-metrics	
+)
+
+;; @syntax (gs:get-instruments)
+;; @return A list of instrument names in the default MIDI soundbank.
+;;
+;; The function should be called only once because it may take considerable
+;; time in a system loaded with a big soundbank. The variable 'gs:instruments' contains
+;; the same list of instruments originally returned by a call to 'gs:get-instruments'.
+
+(define (get-instruments)
+	(if (not gs:instruments)
+		(begin
+    		(net-send out (string "get-instruments System\n"))
+			(while (not gs:instruments) (check-event 10000))
+			(set 'gs:instruments (map base64-dec gs:instruments))
+		)
+	)
+)
+
+
+;; @syntax (gs:get-screen)
+;; @return A list of screen width, height and resolution of the main computer screen.
+;;
+;; After calling the 'gs:get-screen' once the screen parameters are also available
+;; in the variable 'gs:screen'.
+
+(define (get-screen)
+    (net-send out (string "get-screen System\n"))
+	(while (not gs:screen) (check-event 10000))
+	gs:screen
+)
+
+
+;; @syntax (gs:get-selected-text <sym-id> <sym-action>)
+;; @param <sym-id> The name of the component from which to get the selected text.
+;; @param <sym-action> The symbol of the event handler which will receive the selected text.
+
+(define (get-selected-text id action)
+	(net-send out (string "get-selected-text " id " " action "\n"))
+)
+
+
+
+;; @syntax (gs:get-text <sym-id> [<sym-action>])
+;; @param <sym-id> The name of the component from which to get the text.
+;; @param <sym-action> The optional symbol of the event handler which will receive the text.
+;;
+;; If no <sym-action> is specified the function will block until the text is returned. 
+;; After return the text is also available in the variable 'gs:text'.
+;; If <sym-action> is specified the function will return immediately and a <sym-action> event 
+;; is fired containing the text. 
+
+(define (get-text id action)
+	(if action
+		(net-send out (string "get-text " id " " action "\n"))
+		(begin
+			(set 'gs:text nil)
+			(net-send out (string "get-text " id "\n"))
+			(while (not gs:text) (check-event 10000))
+			gs:text)
+	)
+)
+
+
+;; @syntax (gs:get-text-position <sym-id>)
+;; @param <sym-id> The name of the text component for which the line and column position is returned.
+;; @return A list of line and column position of the text caret.
+;;
+
+(define (get-text-position id)
+	(set 'gs:text-position nil)
+	(net-send out (string "get-text-position " id "\n"))
+	(while (not gs:text-position) (check-event 10000))
+	gs:text-position
+)
+
+;; @syntax (gs:get-version)
+;; @return The version of newLISP-GS running.
+;;
+;; After calling the 'gs:get-version' once the version number is also
+;; available in 'gs:version'.
+
+(define (get-version)
+    (net-send out (string "get-version System\n"))
+	(while (not gs:version) (check-event 10000))
+	gs:version
+)
+
+;; @syntax (gs:goto-text <sym-id> <int-row> <int-column>)
+;; @param <sym-id> The name of the text widget.
+;; @param <int-row> The row number where to place the cursor.
+;; @param <int-column> The column number where to place the cursor.
+
+(define (goto-text id row col)
+	(net-send out (string "goto-text " id " " row " " col "\n"))
+)
+
+
+
+;; @syntax (gs:hide-tag <sym-tag> [<boolean-repaint>])
+;; @param <sym-tag> The tag of the group to hide.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+
+(define (hide-tag tag (repaint true))
+	(send-out (string "hide-tag " gs:currentCanvas " " tag " " repaint "\n"))
+)
+
+
+;; @syntax (gs:image-button <sym-id> <sym-action> <str-icon-path> [<str-down-icon-path> [<int-width> <int-height>]])
+;; @param <sym-id> The name of the image button.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-icon-path> The path for an image icon.
+;; @param <str-down-icon-path> The path for a pressed down image icon.
+;; @param <int-width> The optional width of the image button.
+;; @param <int-height> The optional height of the image button.
+
+(define (image-button id action icon down-icon x y)
+	(if down-icon
+		(if (and x y)
+			(net-send out (string "image-button " id " " action " " (base64-enc icon) " " (base64-enc down-icon) " " x " " y "\n"))
+			(net-send out (string "image-button " id " " action " " (base64-enc icon) " " (base64-enc down-icon) "\n"))
+		)
+		(net-send out (string "image-button " id " " action " " (base64-enc icon) "\n"))
+	)
+)
+
+;; @syntax (gs:image-label <sym-id> <str-icon-path> [<str-align>])
+;; @param <sym-id> The name of the label.
+;; @param <str-ucon-path> A string with the icon file path.
+;; @param <str-align> An optional alignment '"left"', '"center"' or '"right"', '"leading"', '"trailing"', '"bottom"' or '"top"'.
+
+(define (image-label id icon align)
+	(if align
+		(net-send out (string "image-label " id " " (base64-enc icon) " " align "\n"))
+		(net-send out (string "image-label " id " " (base64-enc icon) "\n")))
+)
+
+
+;; @syntax (gs:init [<int-port> <str-host> [bool-manual]])
+;; @param <int-port> The optional guiserver server port.
+;; @param <str-host> The optional remote host of the guiserver.
+
+(define (init (portIn 64001) (host "127.0.0.1") manual)
+	; check for server portIn and if this was started by java
+	(if (main-args 2) (set 'portIn (int (main-args 2) portIn)))
+	; if guiserver.jar did not start this process then guiserver.jar
+	; still has to be started, except when manual parameter is true
+	(if (and (not (= (main-args 3) "javastart")) (not manual))
+		(if (= ostype "Windows")
+			(process (string "cmd /c " server-path " " portIn))
+
+			(= ostype "OSX")
+			(process (string "/usr/bin/java -jar " server-path " " portIn))
+
+			(env "JAVA_HOME")
+			(process (string (env "JAVA_HOME") "/bin/java -jar " server-path " " portIn))
+
+			(process (string "/usr/bin/java -jar " server-path " " portIn))
+
+		)
+	)
+
+	(set 'portOut (+ portIn 1))
+	(set 'retry 0)
+	(set 'out nil)
+	(while (not out)
+		(if (> retry 200) ; try for 20 seconds
+			(begin
+				(println "Could not connect to guiserver.jar")
+				(when (= ostype "Windows")
+					(import "user32.dll" "MessageBoxA")
+					(MessageBoxA 0 "Could not connect to guiserver.jar" "Problem connecting" 1)
+				)
+				(exit))
+			(inc retry))
+		(set 'out (net-connect host portIn))
+		(sleep 100))
+
+	(set 'listenSock (net-listen portOut))
+	(set 'in (net-accept listenSock))
+	(net-close listenSock)
+	(gs:set-utf8 (primitive? MAIN:utf8))
+)
+
+;; @syntax (gs:insert-list-item <sym-list-combo> <str-text> <int-index> [<str-text> <int-index>])
+;; @param <sym-list-combo> The name of the combo box or list box from which entries are removed.
+;; @param <str-text> The text of the list or combo box item to insert.
+;; @param <int-index> The index of an entry to add to the list or combo box.
+;;
+;; When specifying an index of <tt>0</tt> the first item gets inserted at the beginning. 
+;; When specifying an index equal or greater to the number of items in the list, the item 
+;; is added at the end.
+
+(define (insert-list-item comp)
+	(let (	s (string "insert-list-item " comp " ")
+			p (args))
+		(while p
+			(write-buffer s (string (base64-enc (pop p)) " " (pop p) " ")))
+		
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+;; @syntax (gs:insert-tab <sym-tabbed-pane> <sym-component> [<str-text> [<int-index> [<str-icon-path>]]])
+;; @param <sym-tabbed-pane> The name of the tabbed pane.
+;; @param <sym-component> The name of the component to insert as a tab.
+;; @param <str-text> The optional text on the tab.
+;; @param <int-index> The optional index where to insert the new tab.
+;; @param <str-icon-path> The file path to an optional icon.
+
+(define (insert-tab pane comp text idx icon)
+	(if text
+		(if idx
+			(if icon
+				(net-send out (string "insert-tab " pane " " comp " " (base64-enc text) " " idx " " (base64-enc icon) "\n"))
+				(net-send out (string "insert-tab " pane " " comp " " (base64-enc text) " " idx "\n")))
+			(net-send out (string "insert-tab " pane " " comp " " (base64-enc text) "\n")))
+		(net-send out (string "insert-tab " pane " " comp "\n")))
+)
+
+;; @syntax (gs:insert-text <sym-id> <str-text> <int-position>)
+;; @param <sym-id> The name of the text component.
+;; @param <str-text> The text to insert.
+;; @param <int-position> The offset position where to insert the text.
+
+(define (insert-text id text position)
+	(replace "\r" text "")
+	(net-send out (string "insert-text " id " " (base64-enc text) " " position "\n"))
+)
+
+;; @syntax (gs:key-event <sym-id> <sym-action>)
+;; @param <sym-id> The id of the component to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+;;
+;; 'gs:key-event' can be used to register a general unspecific key event handler
+;; for any component in the system. Since version 1.05 of newLISP-GS this also
+;; includes 'gs:text-field', which already handles key events 
+;; using the normal event handler function. With 'gs:key-event' a second handler 
+;; function can be registered. Both functions will fire on their respective events.
+;;
+;; Components respond to the following key event types: '"pressed"', '"released"', '"typed"'.
+;; 
+;; @example
+;;
+;; (define (key-action id type code modifiers)
+;;     (println "id:" id " type:" type " key code:" code " modifiers:" modifiers)
+;; )
+
+;; The example shows a handler which prints all key event parameters to the terminal/shell
+;; window where the applicaton was started.
+;;
+;; In order for key events to work, the component for which a key action handler
+;; is registered must have the input focus. Use '"gs:request-focus"' to set the
+;; input focus for the component.
+
+
+(define (gs:key-event id action)
+	(net-send out (string "key-event " id " " action "\n"))
+)
+
+;; @syntax (gs:label <sym-id> <str-text> [<str-align> [<int-width> <int-height>]])
+;; @param <sym-id> The name of the label.
+;; @param <str-text> The text to appear on the label.
+;; @param <str-align> The optional alignment of the text.
+;; @param <int-width> The optional width of the label.
+;; @param <int-height> The optional height of the label.
+;;
+;; The following alignment constants can be supplied: '"left"', '"center"', '"right"",
+;; '"leading"', '"trailing"', '"bottom"' and "'top'". By default each label text is
+;; '"center"' aligned.
+
+(define (label id text align width height)
+	(if align
+		(if (and width height)
+			(net-send out (string "label " id " " (base64-enc text) " " align " " width " " height "\n"))
+			(net-send out (string "label " id " " (base64-enc text) " " align "\n")))
+		(net-send out (string "label " id " " (base64-enc text) "\n")))
+)
+
+
+;; @syntax (gs:layout <sym-container>)
+;; @param <sym-container> The id of the container to lay out.
+;;
+;; Forces the container to lay out its components again, e.g. after a 'gs:add-to' or 'gs:remove-from'
+;; when the container was already visible.
+
+(define (layout id)
+	(net-send out (string "layout " id "\n"))
+)
+
+;; @syntax (gs:load-text <sym-id> <str-path>)
+;; @param <sym-id> The id of the 'gs:text-pane'.
+;; @param <str-path> The full path name of the file to load.
+;;
+;; 'gs:load-text' will load text into a 'gs:text-pane' directly by specifying
+;; the path name. During loading, CR-LF line terminators are automatically
+;; translated to LF-only line terminators by stripping all CRs from the file. All internal
+;; operations of guiserver on text assume LF as a line terminator.
+
+(define (load-text id image-path)
+	(net-send out (string "load-text " id " " (base64-enc image-path) "\n"))
+)
+
+;; @syntax (gs:listen [<boolean-flag>])
+;; @param <boolean-flag> Prevent exit on loss of communication.
+;; @return Never returns. Exits the application when the guiserver exits, except when <boolean-flag> is 'true'.
+
+(define (listen flag , event)
+	(while (net-receive in event 1000000000 "\n")
+		;(println "===>" event "<===")
+		(eval-string event))
+	(println "server shut down")
+	(if (not flag) (exit))
+)
+
+;; @syntax (gs:list-box <sym-id> <sym-action> [<str-item-1> ...])
+;; @param <sym-id> The name of the list box.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-item> Zero, one or more text entries in the list box.
+;; @syntax (gs:list-box <sym-id> <sym-action> [<list-str-items>])
+;; @param <sym-id> The name of the list box.
+;; @param <sym-action> The name of the event handler.
+;; @param <list-str-items> Zero, one or more text entries in a list.
+
+;; The listbox when clicked with the mouse, or when the [enter] key is
+;; presses, will pass the following parameters to the event handler:
+;; <br><br>
+;; <id> - the id string of the list box<br>
+;; <index> - the zero offset index of the highlighted listbox entry<br>
+;; <item> - the string of the highlighted listbox entry<br>
+;; <click-count> - the number of times the mouse has been clicked<br>
+
+(define (list-box id action)
+	(let (	s (string "list-box " id " " action " ")
+					entries (if (list? (args 0)) (args 0) (args)) )
+		(dolist (item entries)
+			(write-buffer s (string (base64-enc item) " ")))
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+
+;; @syntax (gs:message-dialog <sym-parent-frame> <str-title> <str-message> [<str-type> [<str-icon-path>]])
+;; @param <sym-parent-frame> The symbol name of the parent frame.
+;; @param <str-title> The title of the message box.
+;; @param <str-message> The message in the message box.
+;; @param <str-type> The type of the message box.
+;; @param <str-icon-path> The optional path for an icon.
+;;
+;; The type of the message box can be one of: '"error"', '"information"', '"warning"', '"question"', '"plain"'.
+;; The function initiating the message-dialog will return when the dialog is closed.
+
+(define (message-dialog parent title msg (type "plain") icon)
+	(if icon
+		(net-send out (string "message-dialog " parent " " 
+				(base64-enc title) " " (base64-enc msg) " " type  " " (base64-enc icon) "\n"))
+		(net-send out (string "message-dialog " parent " " 
+				(base64-enc title) " " (base64-enc msg) " " type "\n"))
+	)
+)
+
+;; @syntax (gs:menu <sym-id> <str-text>)
+;; @param <sym-id> The name of the menu.
+;; @param <str-text> The title string of the menu.
+
+(define (menu id text)
+	(net-send out (string "menu " id " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:menu-popup <sym-id> <str-text>)
+;; @param <sym-id> The name of the menu.
+;; @param <str-text> The title string of the menu.
+
+(define (menu-popup id text)
+	(net-send out (string "menu-popup " id " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:menu-bar <sym-frame> [<sym-menu-1> ...])  
+;; @param <sym-frame> The name of the frame hosting the menu bar.
+;; @param <sym-menu> Zero or more symbol names of menus to be positioned on the menu bar.
+
+(define (menu-bar aframe)
+	(let (s (string "menu-bar " aframe " "))
+		(doargs (item)
+			(write-buffer s (string item " ")))
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+;; @syntax (gs:menu-item <sym-id> <sym-action> <str-text>)
+;; @param <sym-id> The name of the menu item.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-text> The text to appear for the menu item.
+
+(define (menu-item id action text)
+	(net-send out (string "menu-item " id " " action " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:menu-item-check <sym-id> <sym-action> <str-text> [<bool-selected>])
+;; @param <sym-id> The name of the menu item.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-text> The text to appear for the menu item.
+;; @param <bool-selected> An optional flag indicating the selection state 'true' or 'nil' (default).
+
+(define (menu-item-check id action text selected)
+	(net-send out (string "menu-item-check " id " " action " " (base64-enc text) " " selected "\n"))
+)
+
+;; @syntax (gs:midi-bpm [<int-bpm> [<int-resolution>]]])
+;; @param <int-bpm> Beats per minute pay speed. Default is 120 BPM.
+;; @param <int-resolution> Ticks per beat. Deafult is 16 ticks per beat;
+;;
+;; Sets the speed of playing a notes with with either 'gs:play-note' or playing a 
+;; sequence with 'gs:play-sequence' in beats per minute (BPM).
+;;
+;; Before using 'gs:midi-bpm' the default speed is set to 120 BPM, which corresponds
+;; to two beats per second, where each beat corresponds to a quarter note of 16 ticks
+;; default resolution.
+;;
+;; While the BPM parameter controls the play-back speed of the sequencer, the
+;; resolution is a parameter of the sequence creation itself and must be set before
+;; the first 'gs:add-track' call.
+;;
+;; The preset resolution of 16 ticks per quarter note is the highest which can be set
+;; and should be sufficient for all applications.
+
+(define (midi-bpm (bpm 120) (resolution 16))
+	(set 'resolution (min resolution 16))
+	(net-send out (string "midi-bpm System " (string bpm) " " (string resolution) "\n"))
+)
+	
+
+
+
+;; 
+;; @syntax (gs:midi-close)
+;;
+;; Shut down the MIDI subsystem.
+
+(define (midi-close)
+	(net-send out (string "midi-close System\n"))
+)
+
+
+;; @syntax (gs:midi-init [<str-file-path>])
+;; @param <str-file-path> The optional file path for a soundbank file.
+;;
+;; Initialize the MIDI subsystem. If a soundbank file is specified load it,
+;; else load the built-in synthesizer's default soundbank.
+;;
+;; When not using the default soundbank, the function 'gs:get-instruments'
+;; should be used first to find out the correct naming of instruments
+;; for the 'gs:midi-patch' statements. The soundbank used for testing the
+;; demo files 'midi-demo.lsp' and 'midi2-demo.lsp' on Windows is the midsize
+;; soundbank available here:
+;; @link http://java.sun.com/products/java-media/sound/soundbanks.html http://java.sun.com/products/java-media/sound/soundbanks.html
+;; This soundbank has equivalent named instruments to those used in the Mac OS X default JRE installation.
+;; Currently only the first 128 instruments in a soundbank are accessed by newLISP-GS.
+
+(define (midi-init soundbank)
+	(if soundbank
+		(net-send out (string "midi-init System " (base64-enc soundbank) "\n"))
+		(net-send out (string "midi-init System\n"))
+	)
+)
+
+;; @syntax (gs:midi-patch <str-instrument> [<int-channel>])
+;; @param <str-instrument> The name of the instrument to attach to a channel.
+;; @param <int-channel> The channel for the instrument, default is <tt>0</tt>.
+;;
+;; An instrument from the current soundbank is attached to a
+;; specific channel or to channel <tt>0</tt> if no channel is specified.
+;;
+;; @example
+;; (gs:midi-patch (find "Electric Grand" gs:instruments) 0)
+
+;; In order for the 'gs:instruments' variable to contain a list of instruments,
+;; 'gs:get-instruments' must have been called earlier, i.e. after 'gs:midi-init'.
+
+(define (midi-patch program (channel 0))
+	(net-send out (string "midi-patch System " (base64-enc program) " " channel "\n"))
+)
+
+;; @syntax (gs:mouse-clicked <sym-canvas> <sym-action> [<boolean-tags>])
+;; @param <sym-canvas> The id of the canvas to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+;; @param <boolean-tags> A 'true' to indicate checking for tags.
+;;
+;; If <boolean-tags> is 'true', the action event will carry a list of
+;; all tags which contained the X,Y coordinates of the mouse.
+
+(define (mouse-clicked cnvs action flag)
+	(net-send out (string "mouse-clicked " cnvs " " action " " flag "\n"))
+)
+
+;; @syntax (gs:mouse-dragged <sym-canvas> <sym-action>)
+;; @param <sym-canvas> The id of the canvas to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+
+(define (gs:mouse-dragged cnvs action)
+	(net-send out (string "mouse-dragged " cnvs " " action "\n"))
+)
+
+;; @syntax (gs:mouse-event <sym-id> <sym-action>)
+;; @param <sym-id> The id of the component to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+;;
+;; 'gs:mouse-event' can be used to register a general unspecific mouse event handler
+;; for any component in the system. Components respond to the following types:
+;; '"pressed"', '"released"', '"clicked"',
+;; 
+;; @example
+;;
+;; (define (mouse-action id type x y button cnt mods)
+;;     (println "id:" id " type:" type " x:" x " y:" y " button:" button " count:" cnt " mods:" mods)
+;; )
+
+;; The example shows a handler which prints all mouse event parameters to the terminal/shell
+;; window where the applicaton was started.
+
+
+(define (gs:mouse-event id action)
+	(net-send out (string "mouse-event " id " " action "\n"))
+)
+
+;; @syntax (gs:mouse-moved <sym-canvas> <sym-action>)
+;; @param <sym-canvas> The id of the canvas to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+;; @param <boolean-tags> A 'true' to indicate checking for tags.
+;;
+;; If <boolean-tags> is 'true', the action event will carry a list of
+;; all tags which contained the X,Y coordinates of the mouse.
+
+(define (gs:mouse-moved cnvs action flag)
+	(net-send out (string "mouse-moved " cnvs " " action " " flag "\n"))
+)
+
+;; @syntax (gs:mouse-pressed <sym-canvas> <sym-action> [<boolean-tags>])
+;; @param <sym-canvas> The id of the canvas to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+;; @param <boolean-tags> A 'true' to indicate checking for tags.
+;;
+;; If <boolean-tags> is 'true', the action event will carry a list of
+;; all tags which contained the X,Y coordinates of the mouse.
+
+(define (gs:mouse-pressed cnvs action flag)
+	(net-send out (string "mouse-pressed " cnvs " " action " " flag "\n"))
+)
+
+;; @syntax (gs:mouse-released <sym-canvas> <sym-action> [<boolean-tags>])
+;; @param <sym-canvas> The id of the canvas to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+;; @param <boolean-tags> A 'true' to indicate checking for tags.
+;;
+;; If <boolean-tags> is 'true', the action event will carry a list of
+;; all tags which contained the X,Y coordinates of the mouse.
+
+(define (gs:mouse-released cnvs action flag)
+	(net-send out (string "mouse-released " cnvs " " action " " flag "\n"))
+)
+
+;; @syntax (gs:mouse-wheel <sym-canvas> <sym-action>)
+;; @param <sym-canvas> The id of the canvas to register the action handler.
+;; @param <sym-action> The symbol of the action handler.
+
+(define (gs:mouse-wheel cnvs action)
+	(net-send out (string "mouse-wheel " cnvs " " action "\n"))
+)
+
+;; @syntax (gs:move-tag <sym-tag> <int-dx> <int-dy> [<boolean-repaint>])
+;; @param <sym-tag> The tag of the group of objects to move.
+;; @param <int-dx> The distance to move on the X-axis.
+;; @param <int-dy> The distance to move on the Y-axis.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+;; 'gs:move-tag' is the only tag operation which actually changes the 
+;; internal data of a drawn object. All other tag operations like
+;; 'gs:translate-tag', 'gs:scale-tag', 'gs:rotate-tag' and 'gs:shear-tag'
+;; will transform object coordinates only for drawing.
+
+(define (gs:move-tag tag dx dy (repaint true))
+	(send-out (string "move-tag " gs:currentCanvas " " tag " " 
+		dx " " dy " " repaint "\n"))
+)
+
+;; @syntax (gs:mute-track <int-number> [<boolean-on-off>])
+;; @param <int-number> The number of the track starting with <tt>0</tt> for the first. Default is <tt>true</tt>.
+;; @param <boolean-on-off> The track will be muted with a value of <tt>true</tt>
+;;
+;; Any other value than <tt>true</tt> will unmute the track again. Muting tracks is practical
+;; during music development. The track can only be muted when th sequence has benn started
+;; using 'gs:play-sequence'. To completely mute a track the 'gs:mute-track' statement should
+;; come right after the 'gs:play-sequece' statement. 
+
+(define (mute-track number (bool true))
+	(net-send out (string "mute-track System " number " " (string bool) "\n"))
+)
+
+;; @syntax (gs:no-action)
+;;
+;; Specify as <sym-action> for widgets where no action handler is defined.
+
+(define (no-action))
+
+;; @syntax (gs:open-file-dialog <sym-parent-frame> <sym-action> [<str-directory> [<str-mask> <str-description>]])
+;; @param <sym-parent-frame> The parent frame of the file dialog.
+;; @param <sym-action> The handler function symbol.
+;; @param <str-directory> The initial directory to show.
+;; @param <str-mask> An optonal string mask.
+;; @param <str-description> An optional mask description.
+
+(define (open-file-dialog parent action dir mask desc)
+	(if dir
+		(if (and mask desc)
+			(net-send out (string "open-file-dialog " parent " " action " " (base64-enc dir) " " 
+								(base64-enc mask) " " (base64-enc desc) "\n"))
+			(net-send out (string "open-file-dialog " parent " " action " " (base64-enc dir) "\n")))
+		(net-send out (string "open-file-dialog " parent " " action "\n")))
+)
+
+;; @syntax (gs:panel <sym-id> [<int-width> <int-height>])
+;; @param <sym-id> The name of the panel.
+;; @param <int-width> The optional width of the panel.
+;; @param <int-height> The optional height of the panel.
+;;
+;; Panels have a flow layout by default. In a flow layout an unsized button will
+;; assume the natural size necessary to display the text on it.
+;; To change the layout use the 'set-flow-layout' or 'set-grid-layout' functions.
+
+(define (panel id width height)
+	(if (and width height)
+		(net-send out (string "panel " id " " width " " height "\n"))
+		(net-send out (string "panel " id "\n"))
+))
+
+;; @syntax (gs:paste-text <sym-id> [<str-text>])
+;; @param <sym-id> The name of the text component in which to paste text.
+;; @param <str-text> An optional text string to paste instead of the clipboard contents.
+;;
+;; If the <sym-id> contains selected text, this text gets replaced,
+;; otherwise the text is inserted at the current caret position.
+;; If no text is given in <str-text>, the text is taken from the clipboard.
+
+(define (paste-text id text)
+	(if text
+		(net-send out (string "paste-text " id " " (base64-enc text) "\n"))
+		(net-send out (string "paste-text " id "\n")))
+)
+
+;; @syntax (gs:play-note <int-key> [<int-duration> [<int-velocity> [<int-channel> [<int-bend>]]]])
+;; @param <int-key> The note or midi key <tt>0</tt> to <tt>127</tt>.
+;; @param <int-duration> The duration of the note in ticks, default is <tt>16</tt> for one beat or quarter note.
+;; @param <int-velocity> The velocity/volume of the note between <tt>0</tt> and <tt>127</tt>, default is <tt>64</tt>.
+;; @param <int-channel> The channel through which to play the note from <tt>0</tt> to <tt>15</tt>, default is <tt>0</tt>.
+;; @param <int-bend> The optional note bend to tune the note lower or higher from '-8192' to '8191'.
+;;
+;; Before using 'gs:play-note', 'gs:midi-init' should be used to initialize the MIDI system.
+;; The key of the note increases in half-tone steps. The key 60 corresponds to a Middle-C.
+;; The velocity of the note is usually it's volume and/or brightness, i.e. the speed with which 
+;; a key was pressed on an instrument. The channel is <tt>0</tt> by default and assigned to
+;; a Piano instrument unless the function 'gs:midi-patch' has been used to change assignment
+;; to a different instrument.
+;;
+;; On Windows and some Linux or other UNIX no MIDI soundbank files are installed by default. Goto 
+;; @link http://java.sun.com/products/java-media/sound/soundbanks.html http://java.sun.com/products/java-media/sound/soundbanks.html
+;; for instructions how to download and install a soundbank. For the demo files 'mide-demo.lsp' and
+;; 'midi2-demo' the midsize quality soundbank was used. On Mac OS X a soundbank is installed by default.
+;; The default for the bend parameer is <tt>0</tt> for no bend. Negative values down to '-8192'
+;; tune the note lower. Positive values up to '8191' tune the note higher. 
+;; The following code is a complete example:
+;;
+;; @example
+;; ; load Guiserver
+;; (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+;; (gs:init)
+;;
+;; ; play a chromatic scale on the default instrument (piano)
+;; ; each note a 16th note of 4 ticks and a moderate volume 
+;;
+;; (gs:midi-init)
+;; (gs:midi-patch "Piano" 0)
+;; (for (key 24 95) (gs:play-note key 4 95 0))
+;; (sleep 2000) ; wait until playing has finished
+;; (gs:midi-close)
+;;
+
+;; The second example demonstrated usage of the <int-bend> parameter:
+;;
+;; @example
+;; ; play the same note but with different bends below and above the note
+;; (gs:midi-patch "Violin" 0)
+;; (for (bend -2024 2024 128)
+;;     (gs:play-note 80 1 95 0 bend))
+
+;; To play polyphone music of multiple parallel tracks see the function 'gs:add-track' for
+;; a complete code example.
+
+(define (play-note key (duration 4) (velocity 64) (channel 0) (bend 0))
+	(net-send out (string "play-note System " 
+			key " " duration " " velocity " " channel " " bend "\n"))
+)
+
+;; @syntax (gs:play-sequence [<int-start> [<int-loop-count> [<int-start-loop> [<int-end-loop>]]])
+;; @param <int-start> The starting point in the sequence in ticks. Default is <tt>0</tt> for the beginning.
+;; @param <int-loop-count> The number of repetitions for looping. Default is <tt>0</tt> for no looping.
+;; @param <int-start-loop> The start of the loop to play in ticks. Default is <tt>0</tt>.
+;; @param <int-end-loop> The end of the loop in ticks. Default is <tt>-1</tt> for the end.
+;;
+;; All parameters are optional. When no parameters are given all tracks in the sequence are
+;; sequenced from start to end with no repetiton (loop count of 0). Note that the start-loop and
+;; end-loop positions refer only to loop played after playing the full track. After the sequence
+;; started playing 'gs:stop-sequence' can be used to stop it at any time. The midi system
+;; should not be closed using 'gs:midi-close' before playing has finished or playing will
+;; be cut off.
+;;
+;; See the function 'gs:add-track' for complete code example.
+
+(define (play-sequence (ticks 0) (loop 0) (start 0) (end -1))
+	(net-send out (string "play-sequence System " ticks " " loop " " start " " end "\n"))
+)
+
+
+;; @syntax (gs:play-sound <str-file-path>)
+;; @param <str-file-path> The path and file name of the sound file.
+;;
+;; On most OS platforms '.au' and '.wav' sound file formats are supported.
+
+(define (play-sound file-name)
+	(net-send out (string "play-sound System " (base64-enc file-name) "\n"))
+)
+
+
+;; @syntax (gs:progress-bar <sym-id> <int-min> <in-max> <int-initial-value>)
+;; @param <sym-id> The symbols of the progress bar.
+;; @param <int-min> The minimum value of the slider.
+;; @param <int-max> The maximum value of the slider.
+;; @param <int-initial-value> The initial value of the slider.
+
+(define (progress-bar id posmin posmax posinit)
+	(net-send out (string "progress-bar " id " " posmin " " posmax " " posinit "\n"))
+)
+
+;; @syntax (gs:radio-button <sym-id> <sym-action> [<str-text> [<bool-selected>]])
+;; @param <sym-id> The name of the radio button.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-text> The optional text of the radio button.
+;; @param <bool-seected> An optional flag 'true' or 'nil' (default) indicating the initial state of the radio button.
+
+(define (radio-button id action text selected)
+	(if text
+		(net-send out (string "radio-button " id " " action " " (base64-enc text) " " selected "\n"))
+		(net-send out (string "radio-button " id " " action "\n")))
+)
+
+;; @syntax (gs:redo-text <sym-id>)
+;; @param <sym-id> The id of the 'gs:text-pane' where to perform a redo operation.
+
+(define (redo-text id)
+	(net-send out (string "redo-text " id "\n"))
+)
+
+;; @syntax (gs:remove-from <sym-container> <sym-component> [<sym-component> ...])
+;; @param <sym-container> The container from which to remove a component.
+;; @param <sym-component> One or more optional components to remove.
+;;
+
+(define (remove-from id)
+	(let (s (string "remove-from " id " "))
+        (doargs (item)
+            (write-buffer s (string item " ")))
+        (write-buffer s "\n")
+        (net-send out s))
+)
+
+;; @syntax (gs:remove-list-item <sym-list-combo> <int-index> [<int-index> ...])
+;; @param <sym-list-combo> The name of the combo box or list box from which entries are removed.
+;; @param <int-index> The index of an entry to remove from the list or combo box.
+;;
+;; When specifying an index of <tt>0</tt>, the first item gets removed. When specifying an
+;; index equal or greater to the number of items in the list, the item is removed at the end.
+
+(define (remove-list-item comp)
+	(let (s (string "remove-list-item " comp " "))
+		(doargs (item)
+			(write-buffer s (string item " ")))
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+;; @syntax (gs:remove-tab <sym-tabbed-pane> [<int-index>])
+;; @param <sym-tabbed-pane> The name of the tabbed pane.
+;; @param <int-index> The optional index of the tab to remove. The default is <tt>0</tt> for the first tab.
+
+(define (remove-tab pane idx)
+	(if idx
+		(net-send out (string "remove-tab " pane " " idx "\n"))
+		(net-send out (string "remove-tab " pane "\n")))
+)
+
+;; @syntax (gs:request-focus <sym-id> [<int-tab-index>])
+;; @param <sym-id> The name of the component for which to request focus.
+;; @param <int-tab-index> The index of a tab for which focus is requested.
+
+(define (request-focus id idx)
+	(if idx
+		(net-send out (string "request-focus " id " " idx "\n"))
+		(net-send out (string "request-focus " id "\n")))
+)
+
+;; @syntax (gs:reorder-tags <list-tags>)
+;; @param <list-tags> The list of tag symbols or tag string names in the new order of display.
+;;
+;; The re-ordering itself will not repaint the canvas use 'gs:update' to repaint the current 
+;; canvas after using 'gs:reorder-tags'. The list of tags can be given as either a list of
+;; tags symbols or name strings. Tags not appearing in <list-tags> will be deleted.
+
+(define (reorder-tags tags)
+	(let (s (string "reorder-tags " gs:currentCanvas " "))
+		(dolist (tag tags)
+			(write-buffer s (string tag " ")))
+		(write-buffer s "\n")
+		(net-send out s)
+	)
+)
+
+;; @syntax (gs:rotate-tag <sym-tag> <float theta> <int-x> <int-y> [<boolean-repaint>])
+;; @param <sym-tag> The tag group to rotate.
+;; @param <float-theta> The rotation angle in degrees (0 - 360).
+;; @param <int-x> The X-coordinate of the rotation center.
+;; @param <int-y> The Y-coordinate of the rotation center.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+;; Like all tag operations, multiple 'gs:rotate-tag' operations are cumulative.
+
+(define (rotate-tag tag angle x y (repaint true))
+	(send-out (string "rotate-tag " gs:currentCanvas " " tag " " angle " " 
+		x " " y " " repaint "\n"))
+)
+
+;; @syntax (gs:run-shell <id-text-area> <str-command> <str-args>)
+;; @param <idx-text-area> The id of the text area to wich a shell process will be attached.
+;; @param <str-command> The command string to start the shell process.
+;; @param <str-args> The arguments of the command (max 8 arguments).
+
+(define (run-shell id command arguments)
+	(net-send out (string "run-shell " id " " (base64-enc command)  " " (base64-enc arguments) "\n"))
+)
+
+;; @syntax (gs:save-file-dialog <sym-parent-frame> <sym-action> [<str-directory> [<str-initial-file> [<str-mask> <str-description>]]])
+;; @param <sym-parent-frame> The parent frame of the file dialog.
+;; @param <sym-action> The handler function symbol.
+;; @param <str-directory> The initial directory to show.
+;; @param <str-file> The initial file name.
+;; @param <str-mask> An optional string mask.
+;; @param <str-description> An optional mask description.
+
+(define (save-file-dialog parent action dir file mask desc)
+	(if dir
+		(if file
+			(if (and mask desc)
+				(net-send out (string "save-file-dialog " parent " " action " " (base64-enc dir) " " (base64-enc file)
+																		" " (base64-enc mask) " " (base64-enc desc) "\n"))
+				(net-send out (string "save-file-dialog " parent " " action " " (base64-enc dir) " " (base64-enc file) "\n")))
+			(net-send out (string "save-file-dialog " parent " " action " " (base64-enc dir) "\n")))
+		(net-send out (string "save-file-dialog " parent " " action "\n")))
+)
+
+;; @syntax (gs:save-sequence <str-file-path>)
+;; @param <str-file-name> The name of the MIDI file to save to.
+;;
+;; Save the contents of a sequence created with 'gs:add-track' to a MIDI file.
+;; The file always should have the extension <tt>.mid</tt>.
+;;
+;; Note that all MIDI files created with 'gs:save-sequence' will play back at a fixed
+;; speed of 120 BPM. Therefore, when creating sequences for recording using 'gs:add-track',
+;; they should be timed for a play-back speed of 120 BPM.
+;;
+;; To change the speed for replay from a saved MIDI file the resolution parameter can
+;; be chaged from it's default of 16 tick per beat using the second optional parameter
+;; of 'gs:midi-bpm'. In this case the resolution parameter should be adjusted before
+;; calling 'gs:add-track' the first time.
+
+(define (save-sequence file-path)
+	(net-send out (string "save-sequence System " (base64-enc file-path) "\n"))
+)
+
+;; @syntax (gs:save-text <sym-id> <str-path>)
+;; @param <sym-id> The id of the 'gs:text-pane'.
+;; @param <str-path> The full path name of the file to save.
+;;
+;; This function will write text back from a 'gs:text-pane' directly
+;; by specifying a path name only. Line feed characters (ASCII 10)
+;; are used as line terminators. If this behavior is not desired,
+;; as is the case with Windows text files, then 'gs:get-text' should
+;; be used instead. A program can then add CR characters using a 
+;; newLISP 'replace', i.e. '(replace "\n" text "\r\n")' before
+;; saving the text to a file.
+
+(define (save-text id image-path)
+	(net-send out (string "save-text " id " " (base64-enc image-path) "\n"))
+)
+
+
+;; @syntax (gs:scale-tag <sym-tag> <float-x> <float-y> [<boolean-repaint>])
+;; @param <sym-tag> The tag group to scale.
+;; @param <float-x> The X scaling factor.
+;; @param <float-y> The Y scaling factor.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+;; 'gs:scale' scales the object to draw relative to the '0,0' point of
+;; the coordinate system. This means if a object is not at the center it
+;; will not only change in size when scaled but also change the distance
+;; to the center point of the coordinate system, moving away when scaling
+;; up with scale factor bigger '1.0' and moving closer to the center
+;; when scaling down using factors smaller than '1.0'.
+;;
+;; This means that objects which will be scaled should be defined in
+;; coordinates relative to their center point. Then a 'gs:translate-tag'
+;; command should be used to place the object to correct place:
+;;
+;; @example
+;; (gs:circle 'C 0 0 50)
+;; (gs:gs:translate-tag 'C 200 100)
+;; ...
+;; (gs:scale-tag 'C 1.1 1.1)
+
+;; In the example the circle, although defined for '0,0', will be displayed
+;; at the '200,200' position because of the 'gs:translate-tag' statement. When
+;; later scaling the circle will get bigger but stay in place.
+;; Like all tag operations, multiple 'gs:scale-tag' operations are cumulative.
+
+(define (scale-tag tag sx sy (repaint true))
+	(send-out (string "scale-tag " gs:currentCanvas " " tag " " 
+		sx " " sy " " repaint "\n"))
+)
+
+;; @syntax (gs:select-list-item <sym-id> <str-item> [<boolean-flag>])
+;; @param <sym-id> The name of the list or combo box.
+;; @param <str-item> The item to select.
+;; @param <boolean-flag> An optional flag only for list boxes to force scrolling to the selected entry.
+;;
+;; On combo boxes the optional <boolean-flag> has no effect. The selected entry will always
+;; appear as the visible text of the combo box. The flag has either the value 'true' or 'nil'.
+
+(define (select-list-item id item flag)
+	(net-send out (string "select-list-item " id " " (base64-enc item) " " flag "\n")))
+
+
+;; @syntax (gs:select-text <sym-id> <int-from> [<int-to>])
+;; @param <sym-id> The ame of the text component.
+;; @param <int-from> Start offset of selection.
+;; @param <int-to> Optional end offset of selection.
+;;
+;; If no <int-to> end offset is given, 'gs:select-text' will
+;; select to the end of the text.
+
+(define (select-text id from to)
+	(if to
+		(net-send out (string "select-text " id " " from " " to "\n"))
+		(net-send out (string "select-text " id " " from "\n")))
+)
+
+;; @syntax (gs:scroll-pane <sym-id> <sym-widget> [<int-width> <int-height> <sym-w-col> <sum-w-row> <sym-w-corner>])
+;; @param <sym-id> The name of the scroll pane.
+;; @param <sym-widget> The component in the scroll pane to be scrolled.
+;; @param <int-width> The optional width of the scroll pane.
+;; @param <int-height> The optional height of the scroll pane.
+;; @param <sym-col> The optional table widget for a custom column header.
+;; @param <sym-row> The optional table widget for a custom row header
+;; @param <sym-corner> The optional widget component in the upper left corner.
+;;
+;; @example
+;; (gs:scroll-pane 'scroll 'data-table 700 600 'col-table 'row-table 'Canvas)
+;;
+
+(define (scroll-pane id widget width height col-table row-table upper-left-corner )
+	(if (and col-table row-table upper-left-corner)
+		(net-send out (string "scroll-pane " id " " widget " " width " " height " " col-table " " row-table " " upper-left-corner "\n"))
+		(if (and width height)
+			(net-send out (string "scroll-pane " id " " widget " " width " " height "\n"))
+			(net-send out (string "scroll-pane " id " " widget "\n"))))
+)
+
+;; @syntax (gs:set-accelerator <sym-menu-item> <str-keystroke>)
+;; @param <sym-menu-item> The name of the menu item for which an accelerator key is set.
+;; @param <str-keystroke> A text string identifying the keystroke.
+;;
+;; The following rules are used to create keystroke strings:
+;;
+;; Syntax:
+;; <blockquote><pre>
+;; modifiers* (typedID | pressedReleasedID)
+;; modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
+;; typedID := typed typedKey
+;; typedKey := string of length 1 giving Unicode character.
+;; pressedReleasedID := (pressed | released) key
+;; key := KeyEvent key code name, i.e. the name following "VK_".
+;; </pre></blockquote>
+;; Examples:
+;; <blockquote><pre>
+;; "INSERT"
+;; "control DELETE"
+;; "alt shift X"
+;; "alt shift released X"
+;; "typed a"
+;; </pre></blockquote>
+;; Note that the <i>apple</i> key on MacOS X is the 'meta' key.
+;; The 'alt' on MacOS X is the <i>option</i> key.
+;; For letters use uppercase. 
+;; Keys are added to the menu item display automatically on all platforms.
+
+(define (set-accelerator item key)
+	(net-send out (string "set-accelerator " item " " (base64-enc key) "\n"))
+)
+
+;; @syntax (gs:set-anti-aliasing <boolean-flag>)
+;; @param <boolean-flag> The anti aliasing setting for the current canvas 'true' or 'nil'.
+;;
+;; The default setting is 'true'.
+
+(define (gs:set-anti-aliasing flag)
+	(net-send out (string "set-anti-aliasing " gs:currentCanvas " " flag "\n"))
+)
+
+;; @syntax (gs:set-background <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <float-red> The red color component expressed as a number between 0.0 and 1.0.
+;; @param <float-green> The green color component expressed as a number between 0.0 and 1.0.
+;; @param <float-blue> The blue color component expressed as a number between 0.0 and 1.0.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; @syntax (gs:set-background <sym-id> <list-rgb> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <list-rgb> The rgb color can be given as a list of three numbers.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; Note 'set-background' is the same as 'set-color'.
+
+(define (set-background id red green blue alpha)
+	(if (list? red) 
+		(begin
+			(set 'alpha (or green 1.0)) 
+			(map set '(red green blue) red))
+		(set 'alpha (or alpha 1.0)))
+	(net-send out (string "set-color " id " " red " " green " " blue " " alpha "\n"))
+)
+
+;; @syntax (gs:set-bevel-border <sym-id> <str-type>)
+;; @param <sym-id> The name of the component.
+;; @param <str-type> The type of the bevel '"raised"' or '"lowered"'.
+
+(define (set-bevel-border id type)
+	(net-send out (string "set-bevel-border " id " " type "\n"))
+)
+
+;; @syntax (gs:set-border-layout <sym-container>  [<int-hgap> <int-vgap>])
+;; @param <sym-container> The name of the container for which border layout is set.
+;; @param <int-hgap> The horizontal gap between components in the border layout.
+;; @param <int-vgap> The vertical gap between components in the border layout.
+;;
+;; Border layout divides the layout into 5 zones labeled '"north"', '"west"',
+;; '"center"', '"east"' and '"south"'. These string constants are used in
+;; the 'gs:add-to' command when adding components to a border layout.
+;;
+;; In a border layout each component will take the maximum size if components
+;; are not sized. If components are sized only some dimensions will be honored.
+;; The '"north"' and '"south"' components will stretch to maximum width and
+;; assume the height given in a size parameter of the component. The '"east"'
+;; and '"west"' components will stretch to the maximum height available assuming
+;; their width specified earlier. The '"center"' component will take the left over
+;; maximum space.
+
+(define (set-border-layout container hgap vgap)
+	(if (and hgap vgap)
+		(net-send out (string "set-border-layout " container " "  hgap " " vgap "\n"))
+		(net-send out (string "set-border-layout " container "\n")))
+)
+
+;; @syntax (gs:set-canvas <sym-id>)
+;; @param <sym-id> The id of the canvas to switch to.
+;;
+;; The canvas in <sym-id> must have been created earlier with a 'gs:canvas' 
+;; statement. All graphics operations which do not take a canvas as argument
+;; will automatically refer to this current canvas. If no 'gs:set-canvas' is
+;; used, the current canvas is assumed to be the last one created.
+
+(define (gs:set-canvas id)
+	(set 'gs:currentCanvas id)
+	(net-send out (string "set-canvas " id "\n"))
+)
+
+
+;; @syntax (gs:set-caret <sym-id> <int-offset>)
+;; @param <sym-id> The name of the component for which to set the cursor caret.
+;;
+;; The functions has the same effect as calling 'gs:select-text' with the same 
+;; offset for the dot and mark position.
+
+(define (gs:set-caret id offset)
+	(net-send out (string "set-caret " id " " offset "\n"))
+)
+
+;; @syntax (gs:set-caret-color <sym-id> <float-red> <float-green> <float-blue>)
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <float-red> The red color component expressed as a number between 0.0 and 1.0.
+;; @param <float-green> The green color component expressed as a  number between 0.0 and 1.0.
+;; @param <float-blue> The blue color component expressed as a  number between 0.0 and 1.0.
+;; @syntax (gs:set-caret-color <sym-id> <list-rgb> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <list-rgb> The rgb color can be given as a list of three numbers.
+
+(define (set-caret-color id red green blue)
+	(if (list? red) 
+		(map set '(red green blue) red))
+	(net-send out (string "set-caret-color " id " " red " " green " " blue "\n"))
+)
+
+;; @syntax (gs:set-color <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <float-red> The red color component expressed as a number between 0.0 and 1.0.
+;; @param <float-green> The green color component expressed as a number between 0.0 and 1.0.
+;; @param <float-blue> The blue color component expressed as a number between 0.0 and 1.0.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; @syntax (gs:set-color <sym-id> <list-rgb> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <list-rgb> The rgb color can be given as a list of three numbers.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; Note that 'set-color' is the same as 'set-background'.
+
+(define set-color set-background)
+
+;; @syntax (gs:set-cursor <sym-id> <str-shape>)
+;; @param <sym-id> The name of the frame, dialog or window.
+;; @param <str-shape> The string describing the cursor shape.
+;;
+;; The cursor shape can be one of the following:
+;; <pre>
+;;  "default"
+;;  "crosshair"
+;;  "text"
+;;  "wait"
+;;  "sw-resize"
+;;  "se-resize"
+;;  "nw-resize"
+;;  "ne-resize"
+;;  "n-resize"
+;;  "s-resize"
+;;  "w-resize"
+;;  "e-resize"
+;;  "hand"
+;;  "move"
+;; </pre>
+
+(define (set-cursor id shape)
+	(net-send out (string "set-cursor " id " " shape "\n"))
+)
+
+;; @syntax (gs:set-echo-char <sym-id> [<str-cover-char>])
+;; @param <sym-id> The name of the component for which text is set.
+;; @param <str-cover-char> Cover character for password entry.
+;; @example
+;; (gs:set-echo-char 'TheTextField "*")
+;; (gs:set-echo-char 'TheTextField)   ; no echo, behave as normal text field
+ 
+(define (set-echo-char id text)
+  (if (and text (> (length text) 0))
+  	(net-send out (string "set-echo-char " id " " (base64-enc text) "\n"))
+  	(net-send out (string "set-echo-char " id "\n")))
+)
+
+;; If no <str-cover-char> is specyfied or the string in <str-cover-char> is of
+;; 0 length, then the text field behaves as a normal text field.
+
+
+;; @syntax (gs:set-editable <sym-id> <boolean-editable>)
+;; @param <sym-id> The name of the text widget.
+;; @param <boolean-editable> The flag 'true' or 'nil' to indicate if this text widget can be edited.
+
+(define (set-editable id flag)
+	(net-send out (string "set-editable " id " " flag "\n"))
+)
+
+;; @syntax (gs:set-flow-layout <sym-container> [<str-alignment> [<int-hgap> <int-vgap>]])
+;; @param <sym-container> The name of the container for which flow layout is set.
+;; @param <sym-alignment> The alignment of the flow layout '"left"', '"center"' or '"right"'.
+;; @param <int-hgap> The horizontal gap between components in the flow layout.
+;; @param <int-vgap> The vertical gap between components in the flow layout.
+;;
+;; The flow layout lets components appear in their natural or preferred size. The preferred
+;; size of a component is set using the function 'gs:set-size'. Button-type widgets and
+;; combo boxes will take as much space as necessary to show the included text.
+
+(define (set-flow-layout id (direction "left") hGap vGap)
+	(if (and hGap vGap)
+		(net-send out (string "set-flow-layout " id " " direction  " " hGap " " vGap "\n"))
+		(net-send out (string "set-flow-layout " id " " direction "\n"))
+	)
+)
+
+;; @syntax (gs:set-font <sym-id> <str-family> <int-size> <str-type>)
+;; @param <sym-id> The name of the component for which to set the text font.
+;; @param <str-familiy> The family of the font, e.g.: '"Monospaced"', '"Serif"', '"Sans Serif"'.
+;; @param <int-size> The font size in points.
+;; @param <str-type> The type of the font, one or more of '"plain"', '"bold"', '"italic"'.
+;;
+;; More than the above noted families are available depending on the platform.
+
+(define (set-font id family size type)
+	(net-send out (string "set-font " id " " (base64-enc family) " " size " " type "\n"))
+)
+
+;; @syntax (gs:set-foreground <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <float-red> The red color component expressed as a number between 0.0 and 1.0.
+;; @param <float-green> The green color component expressed as a  number between 0.0 and 1.0.
+;; @param <float-blue> The blue color component expressed as a  number between 0.0 and 1.0.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; @syntax (gs:set-foreground <sym-id> <list-rgb> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the color.
+;; @param <list-rgb> The rgb color can be given as a list of three numbers.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; The foreground color is the color of the text in a component.
+
+(define (set-foreground id red green blue alpha)
+	(if (list? red) 
+		(begin
+			(set 'alpha (or green 1.0)) 
+			(map set '(red green blue) red))
+		(set 'alpha (or alpha 1.0)))
+	(net-send out (string "set-foreground " id " " red " " green " " blue " " alpha "\n"))
+)
+
+
+;; @syntax (gs:set-grid-layout <sym-container> <int-rows> <int-columns> [<int-hgap> <int-vgap>])
+;; @param <sym-container> The name of the container for which grid layout is set.
+;; @param <int-rows> The number of rows in the layout grid.
+;; @param <int-columns> The number of columns in the layout grid.
+;; @param <int-hgap> The horizontal gap between components in the grid layout.
+;; @param <int-vgap> The vertical gap between components in the grid layout.
+;;
+;; In a grid layout each component will assume the maximum size the grid cell allows
+;; regardless of sizes preset using 'gs:set-size' Because of this grid layout cells are
+;; frequently filled with panels using 'gs:panel' which have flow layout by default
+;; and allow deliberate sizing of components using 'gs:set-size'.
+
+(define (set-grid-layout container rows cols hgap vgap)
+	(if (and hgap vgap)
+		(net-send out (string "set-grid-layout " container " " rows " " cols " " hgap " " vgap "\n"))
+		(net-send out (string "set-grid-layout " container " " rows " " cols "\n")))
+)
+
+;; @syntax (gs:set-icon <sym-id> <str-icon-path> [<int-index>])
+;; @param <sym-id> The name of a button or label or menu-item for which to set an icon.
+;; @param <str-icon-path> The file path of the icon to be set.
+;; @param <int-index> If <sym-id> is a tabbed pane <int-index> is the index of the tab.
+
+(define (set-icon comp text idx)
+	(if idx
+    	(net-send out (string "set-icon " comp " " (base64-enc text) " " idx "\n"))
+    	(net-send out (string "set-icon " comp " " (base64-enc text) "\n"))
+	)
+)
+
+;; @syntax (gs:set-look-and-feel <str-look>)
+;; @param <str-look> The class description string for the look and feel of the application.
+;;
+;; The following strings can be tried in <str-look>, but not all will work on a specific
+;; platform. On the Mac the default look-and-feel is built-in to the JVM as the default
+;; style. The '"MacLookAndFeel"' is not available as an explicit flavor here, but may be
+;; on other platforms.
+;; <pre>
+;;    '"com.sun.java.swing.plaf.motif.MotifLookAndFeel"'<br>
+;;    '"javax.swing.plaf.metal.MetalLookAndFeel"'<br>
+;;    '"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"'<br>
+;;    '"javax.swing.plaf.mac.MacLookAndFeel"'<br>
+;;    '"com.sun.java.swing.plaf.gtk.GTKLookAndFeel"'
+;; </pre>
+
+(define (set-look-and-feel look)
+	(net-send out (string "set-look-and-feel System " look "\n"))
+)
+
+;; @syntax (gs:set-paint <list-rgb>)
+;; @param <list-rgb> The current paint used for outlines, text and fill color.
+
+(define (gs:set-paint color)
+	(net-send out (string "set-paint " gs:currentCanvas " " (color 0) " " (color 1) " " (color 2) "\n"))
+)
+
+;; @syntax (gs:set-pressed-icon <sym-id> <str-icon-path>)
+;; @param <sym-id> The name of the button, image button or toggle button.
+;; @param <str-icon-path> The file path of the icon or image to be set to the button in pressed state.
+;;
+;; By default a small grey dot is shown on image buttons when in a pressed state.
+
+(define (set-pressed-icon comp text)
+    (net-send out (string "set-pressed-icon " comp " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:set-resizable <sym-frame> <boolean-resizable>)
+;; @param <sym-frame> The name of the frame window.
+;; @param <bbolean-resizable> The flag 'true' or 'nil' to indicate if a frame can be resized by the user.
+
+(define (set-resizable id flag)
+	(net-send out (string "set-resizable " id " " flag "\n"))
+true
+)
+
+;; @syntax (gs:set-rotation <float-angle>)
+;; @param <float-angle> The angle in degrees (0 - 360) of the canvas rotation.
+;;
+;; Unlike the 'gs:rotate-tag' operation which is cumulative, 'gs:set-rotation'
+;; will set an absolute rotation value each time it is called.
+
+(define (gs:set-rotation angle)
+	(net-send out (string "set-rotation " gs:currentCanvas " " angle "\n"))
+)
+
+;; @syntax (gs:set-scale <float-x> <float-y>)
+;; @param <float-x> The X-scale value of the current canvas.
+;; @param <float-y> The Y-scale value of the current canvas.
+;;
+;; Unlike the 'gs:scale-tag' operation which is cumulative, 'gs:set-scale'
+;; will set an absolute scale value each time it is called.
+
+(define (gs:set-scale x y)
+	(net-send out (string "set-scale " gs:currentCanvas " " x " " y "\n"))
+)
+
+;; @syntax (gs:set-selected <sym-id> <boolean-selected> [<sym-id> <boolean-selected>])
+;; @param <sym-id> The name of the toggle or radio button or check box or menu item.
+;; @param <boolean-selected> A flag of 'true' or 'nil' to indicated the selection state.
+;;
+;; More then one toggle control may be set selected or unselected.
+
+(define (set-selected id flag)
+	(let (s (string "set-selected " id " " flag " "))
+		(doargs (item)
+			(write-buffer s (string item " ")))
+		(write-buffer s "\n")
+		(net-send out s)
+	)
+)
+
+;; @syntax (gs:set-selection-color <sym-id> <float-red> <float-green> <float-blue> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the text selection color.
+;; @param <float-red> The red color component expressed as a number between 0.0 and 1.0.
+;; @param <float-green> The green color component expressed as a number between 0.0 and 1.0.
+;; @param <float-blue> The blue color component expressed as a number between 0.0 and 1.0.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; @syntax (gs:set-selection-color <sym-id> <list-rgb> [<float-alpha>])
+;; @param <sym-id> The name of the component for which to set the text selection color.
+;; @param <list-rgb> The rgb color can be given as a list of three numbers.
+;; @param <float-alpha> The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).
+;;
+;; Note 'set-background' is the same as 'set-color'.
+
+(define (set-selection-color id red green blue alpha)
+	(if (list? red) 
+		(begin
+			(set 'alpha (or green 1.0)) 
+			(map set '(red green blue) red))
+		(set 'alpha (or alpha 1.0)))
+	(net-send out (string "set-selection-color " id " " red " " green " " blue " " alpha "\n"))
+)
+
+
+;; @syntax (gs:set-size <sym-id> <int-width> <int-height>)
+;; @param <sym-id> The name of the component of which a preferred size is set.
+;; @param <int-width> The preferred width of the component.
+;; @param <int-height> The preferred height of the component.
+;;
+;; Note that not all layouts allow setting the size of a component. The grid and
+;; border layouts will size the component to its maximum possible in the layout.
+
+(define (set-size id width height)
+	(net-send out (string "set-size " id " " width " " height "\n"))
+)
+
+;; @syntax (gs:set-stroke <float-width> [<str-cap> [<str-join> [<float-miterlimit>]]])
+;; @param <float-width> The width for drawing lines and outlines in shapes.
+;; @param <str-cap> One of optional '"butt"' (default), '"round"' or '"sqare"'.
+;; @param <str-join> One of optional '"miter"' (default), '"bevel"' or '"round"'
+;;
+;; For a <float-width> 0f 0.0 the thinnest possible line width be chosen. 
+;; Join is the decoration applied at the intersection of two path segments and at the 
+;; intersection of the endpoints.
+;; Cap is the decoration applied to the ends of unclosed subpaths and dash segments.
+;; The <float-miterlimit> should be greater or equal 1.0.
+
+(define (gs:set-stroke width cap jn limit)
+	(if cap
+		(if join
+			(if limit
+				(net-send out (string "set-stroke " gs:currentCanvas " " width " " cap " " jn " " limit "\n"))
+				(net-send out (string "set-stroke " gs:currentCanvas " " width " " cap " " jn "\n"))
+			)
+			(net-send out (string "set-stroke " gs:currentCanvas " " width " " cap "\n"))
+		)
+		(net-send out (string "set-stroke " gs:currentCanvas " " width "\n"))
+	)
+)
+
+;; @syntax (gs:set-syntax <sym-id> <str-type>)
+;; @param <sym-id> The name of the text pane for syntax coloring is enabled or disabled.
+;; @param <str-type> A string '"lsp"', '"c"', '"cpp"', '"java"' or '"php"' to indicate the 
+;; syntax desired, or 'nil' to switch off syntax highlighting.
+;;
+;; Colors for syntax highlighting are preselected for a white background, but can be changed using
+;; the following functions: 'gs:set-background', 'gs:set-foreground', 'gs:set-caret', 'gs:set-selection-color'
+;; and 'gs:set-syntax-colors'.
+
+(define (set-syntax id type)
+	(net-send out (string "set-syntax " id " " type "\n"))
+)
+
+;; @syntax (gs:set-syntax-colors <list-rgb-comment> <list-rgb-keyword> <list-rgb-string> <list-rgb-number> <list-rgb-quoted> <list-rgb-parentheses>)
+;; @param <list-rgb-comment> The color for comments.
+;; @param <list-rgb-keyword> The color for reserved keywords.
+;; @param <list-rgb-string> The color for strings.
+;; @param <list-rgb-number> The color for numbers.
+;; @param <list-rgb-quoted> The color for the quote and quoted symbols.
+;; @param <list-rgb-parentheses> The color for parenthesis.
+;;
+;; Syntax highlighting colors are given as lists of red, green and blue values between 0.0 and 1.0. 
+;; Depending on the syntax colors and the foreground and background colors set for the text pane, 
+;; the caret color and color for selected text should also be changed. Only text widgets created 
+;; using 'gs:text-pane' feature syntax highlighting.
+
+(define (set-syntax-colors comment keyword text number quoted parentheses)
+	(let (	components (append comment keyword text number quoted parentheses)
+			str "set-syntax-colors System ")
+		(dolist (c components)
+			(write-buffer str (string c " ")))
+		(write-buffer str "\n")
+		(net-send out str))
+)
+
+;; @syntax (gs:set-tab-size <sym-id> <int-size>)
+;; @param <sym-id> The name of the text area component.
+;; @param <int-size> The tabulator size.
+;;
+;; Note that 'gs:set-tab-size' will only work with fixed spaced fonts.
+
+(define (set-tab-size id size)
+	(net-send out (string "set-tab-size " id " " size "\n"))
+)
+
+;; @syntax (gs:set-text <sym-id> <str-text> [<int-index>])
+;; @param <sym-id> The name of the component for which text is set.
+;; @param <str-text> The text to be set in the component.
+;; @param <int-index> The index for a tab if the <sym-id> is a tabbed pane.
+
+(define (set-text id text idx)
+	(replace "\r" text "")
+	(if idx
+		(net-send out (string "set-text " id " " (base64-enc text) " " idx "\n"))
+		(net-send out (string "set-text " id " " (base64-enc text) "\n"))
+	)
+)
+
+;; @syntax (gs:set-titled-border <sym-component> <str-title>)
+;; @param <sym-component> The name of the component.
+;; @param <str-title> The text in the titled border around the component.
+;;
+;; The component is usually a 'panel'.
+
+(define (set-titled-border id text)
+	(net-send out (string "set-titled-border " id " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:set-tool-tip <sym-id> <str-text>)
+;; @param <sym-id> The name of the widget for which to supply a tool tip.
+;; @param <str-text> The text of the tool tip.
+;;
+;; The tool tip text is shown when leaving the mouse over the widget for certain
+;; amount of time.
+
+(define (set-tool-tip id text)
+    (net-send out (string "set-tool-tip " id " " (base64-enc text) "\n"))
+)
+
+;; @syntax (gs:set-trace <boolean-flag>)
+;; @param <boolean-flag> The flag 'true' or 'nil'.
+
+(define (set-trace flag)
+	(net-send out (string "set-trace System " flag "\n"))
+)
+
+;; @syntax (gs:set-translation <int-x> <int-y>)
+;; @param <int-x> The X-translation value of the current canvas.
+;; @param <int-y> The Y-translation value of the current canvas.
+;;
+;; Translates the current origin of the current canvas to the point in <int-x> <int-y>.
+;; Unlike the 'gs:translate-tag' operation which is cumulative, 'gs:set-translation'
+;; will set an absolute translation value each time it is called.
+
+(define (gs:set-translation x y)
+	(net-send out (string "set-translation " gs:currentCanvas " " x " " y "\n"))
+)
+
+;; @syntax (gs:set-utf8 <boolean-flag>)
+;; @param <boolean> The flag 'true' or 'nil' to indicate if in UTF-8 mode.
+;;
+;; When set in UTF-8 mode, guiserver will convert files to UTF-8 encoding
+;; when loading and saving files. On Mac OS X UTF-8 mode is by default enabled.
+;; On startup guiserver.lsp will detect if newLISP is UTF-8 enabled and
+;; switch the mode in Guiserver accordingly using 'gs:set-utf8'.
+
+(define (gs:set-utf8 flag)
+	(net-send out (string "set-utf8 System " flag "\n"))
+)
+
+;; @syntax (gs:set-value <sym-id> <int-value>)
+;; @param <sym-id> The name of a slider or progress bar for which to set the value.
+;; @param <int-value> The integer value of the name to be set.
+;;
+;; The value should not be bigger or smaller than the minimum or maximum values set
+;; when creating the slider or progress bar, otherwise the setting will default to either
+;; the minimum or maximum preset value.
+
+(define (set-value id value)
+	(net-send out (string "set-value " id " " value "\n"))
+)
+
+;; @syntax (gs:set-visible <sym-id> <boolean-visible>)
+;; @param <sym-id> The component which is hidden or made visible.
+;; @param <boolean-visible> A flag indicating if the component is visible '"true"', '"nil"'.
+;;
+;; Except for frames and dialog windows, components are visible by default. Normally
+;; frames and dialogs are not set visible before all other components are placed inside.
+
+(define (set-visible id flag)
+	(net-send out (string "set-visible " id " " flag "\n"))
+)
+
+;; @syntax (gs:shear-tag <sym-tag> <int-x> <int-y> [<boolean-repaint>])
+;; @param <sym-tag> The tag group to shear.
+;; @param <float-x> The X shearing factor.
+;; @param <float-y> The Y shearing factor.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+
+(define (shear-tag tag sx sy (repaint true))
+	(send-out (string "shear-tag " gs:currentCanvas " " tag " " 
+		sx " " sy " " repaint "\n"))
+)
+
+;; @syntax (gs:show-popup <sym-tag> <sym-host> <int-x> <int-y>)
+;; @param <sym-tag> The id of the popup menu.
+;; @param <sym-host> The host container where to pop up the menu.
+;; @param <int-x> The X coordinate of the menu popup position.
+;; @param <int-y> The Y coordinate of the menu popup position.
+
+(define (gs:show-popup id host x y)
+	(net-send out (string "show-popup " id " " host " " x " " y "\n"))
+)
+
+;; @syntax (gs:show-tag <sym-tag> [<boolean-repaint>])
+;; @param <sym-tag> The tag of the group to show.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+
+(define (show-tag tag (repaint true))
+	(net-send out (string "show-tag " gs:currentCanvas " " tag " " repaint "\n"))
+)
+
+;; @syntax (gs:slider <sym-id> <sym-action> <str-orientation> <int-min> <int-max> <int-initial-value>)
+;; @param <sym-id> The name of the slider.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-orientation> The orientation of the slider '"horizontal"' or '"vertical"'
+;; @param <int-min> The minimum value of the slider.
+;; @param <int-max> The maximum value of the slider.
+;; @param <int-initial-value> The initial value of the slider.
+
+(define (slider id action orient posmin posmax posinit)
+	(net-send out (string "slider " id " " action " " orient " " posmin " " posmax " " posinit "\n"))
+)
+
+;; @syntax (gs:split-pane <sym-id> <str-orientation> [<float-weight> [<float-location> [<int-divider-size>]]])
+;; @param <sym-id> The name of the split-pane.
+;; @param <str-orientation> The orientation '"horizontal"' or '"vertical"'.
+;; @param <float-weight> The optional weight distribution between '0.0' and '1.0' when re-sizing the window. The default is '0.0'.
+;; @param <float-location> The optional initial divider location between '0.0' and '1.0'.
+;; @param <int-divider-size> The optional size of the draggable divider in pixels.
+
+(define (split-pane id orient (weight 0.0)  (pos 0.5)  (dvdr 5))
+	(net-send out (string "split-pane " id " " orient " " weight " " pos " " dvdr "\n"))
+)
+
+;; @syntax (gs:stop-sequence)
+;;
+;; Stops playing tracks, as started with 'gs:play-sequence'.
+
+(define (gs:stop-sequence)
+	(net-send out (string "stop-sequence System\n"))
+)
+
+;; @syntax (gs:tabbed-pane <sym-id> <sym-action> <str-orientation> [<sym-tab> <str-title> ...])
+;; @param <sym-id> The name of the tabbed pane.
+;; @param <str-orientation> The position of the tabs; either '"top"' (default), '"bottom"','"left"' or '"right"'.
+;; @param <sym-tab> The id symbol name of a tab
+;; @param <str-title> The title of the tab.
+
+(define (tabbed-pane id action orient)
+	(let (s (string "tabbed-pane " id " " action " " orient " ")
+		  t (args))
+		(while t
+			(write-buffer s (string (pop t) " " (base64-enc (pop t)) " "))
+		) 
+		(write-buffer s "\n")
+		(net-send out s))
+)
+
+
+;; @syntax (gs:table <sym-id> <sym-action> [<str-column-header-name> ...])
+;; @param <sym-id> The name of the table.
+;; @param <sym-action> The handler function symbol when a cell is selected.
+;; @param <str-column-header-name> The optional column header name. 
+;;
+;; Creates a table with <str-column-header-name> specified column and empty row.
+;; For empty strings specified as column headers, the header will be left empty.
+;; If all header in a table are specified as empty, the table will be created
+;; without a header row. If there are no columns at all, an empty table (0 x 0) 
+;; is created. 
+;;
+;; When a cell is selected, the function in <sym-action> gets called with the table 
+;; id, row, column and cell-contents. See the file 'table-demo.lsp' for an example. 
+;; Cells can be edited  by either selecting or double clicking a cell.
+
+
+(define (table id action)
+  (let (s (string "table " id " " action)
+	  columns (if (null? (args)) '()
+		      (if (list? (args 0)) (args 0) (args))))
+    (dolist (col columns)
+      (write-buffer s (string " " (base64-enc col))))
+    ;(println "gs:table " s)
+    (write-buffer s "\n")
+    (net-send out s) ) )
+
+
+;; @syntax (gs:table-add-column <sym-id> <str-column-header-name> ...)
+;; @param <sym-id> The name of the table.
+;; @param <str-column-header-name> Add column header name(s). 
+;;
+;; More than one <str-column-header-name> can be specified to add more
+;; than one column. A column header can be set empty using and empty string <tt>""</tt>.
+;; When all headers in a table are empty, the
+;; table will be displayed without a header row.
+
+(define (table-add-column id)
+  (let (s (string "table-add-column " id)
+	  columns (if (null? (args)) '()
+		      (if (list? (args 0)) (args 0) (args))))
+    (dolist (col columns)
+      (write-buffer s (string " " (base64-enc col))))
+    ;(println "gs:table-add-column " s)
+    (write-buffer s "\n")
+    (net-send out s) ) )
+
+
+;; @syntax (gs:table-add-row <sym-id> [<str-columns> ... ])
+;; @syntax (gs:table-add-row <sym-id> ([<str-columns> ...))
+;; @param <sym-id> The name of the table.
+;; @param <str-columns> Add a row with contents in <str-columns>
+;;
+;; Add row with each column value. If necessary a scrollbar will appear.
+;; If no contents is defined in <str-columns>, or if contents for less
+;; columns is defined than available, column contents is left empty.
+;; Multiple column content can be specified as either a list
+;; of strings or as additional parameters of 'gs:table-add-row'. 
+
+(define (table-add-row id)
+  (let (s (string "table-add-row " id)
+	  columns (if (null? (args)) '()
+		      (if (list? (args 0)) (args 0) (args))))
+    (dolist (col columns)
+      (write-buffer s (string " " (base64-enc col))))
+    ;(println "gs:table-add-row " s)
+    (write-buffer s "\n")
+    (net-send out s) ) )
+
+
+;; @syntax (gs:table-get-cell <sym-id> <int-row> <int-column>)
+;; @param <sym-id> The name of the table.
+;; @param <int-row> The row of the cell.
+;; @param <int-column> The column of the cell.
+;; @return cell value. stored in gs:table-cell.
+;;
+;; Get the cell contents as a string at sepcifed <int-row> and <int-column>.
+
+(define (table-get-cell id row col)
+  (set 'gs:table-cell nil)
+  (let (s (string "table-get-cell " id
+		  " " row
+		  " " col))
+    ;(println "gs:table-get-cell " s)
+    (write-buffer s "\n")
+    (net-send out s)
+    (while (not gs:table-cell) (check-event 10000))
+    gs:table-cell)
+  )
+
+
+;; @syntax (gs:table-get-size <sym-id>)
+;; @param <sym-id> The name of the table.
+;; @return table size list (row-size, column-size)
+;;
+;; Get table size, stored in 'gs:table-size'.
+;; Note, that adding columns or row will not automatically update
+;; the 'gs:table-size' variable. Use 'gs:table-get-size' to update
+;; this variable.
+
+(define (table-get-size id)
+  (set 'gs:table-size nil)
+  (let (s (string "table-get-size " id))
+    ;(println "gs:table-get-size " s)
+    (write-buffer s "\n")
+    (net-send out s)
+    (while (not gs:table-size) (check-event 10000))
+    gs:table-size
+    ) )
+
+; FdB
+;; @syntax (gs:table-remove-row <sym-id> <int-rownumber>)
+;; @param <sym-id> The name of the table.
+;; @param <int-row> The row to remove
+;; 
+;; Removes a row See also 'gs:table-set-row-count'.
+
+	(define (table-remove-row id row)
+	  (let (s (string "table-remove-row " id " " row))
+	    ;(println "gs:table-remove-row " s)
+	    (write-buffer s "\n")
+	    (net-send out s) ) )
+
+
+;; @syntax (gs:table-set-cell <sym-id> <int-row> <int-column> <str-value>)
+;; @param <sym-id> The name of the table.
+;; @param <int-row> The row of the cell set.
+;; @param <int-column> The column of the cell set.
+;; @param <str-value> The cell value.
+;; @return The previous contents of the cell; also stored in 'gs:table-cell'.
+;;
+;; Sets a new table cell contents and returns the old cell contents. Row and
+;; column numbering starts with '0' (zero). The cell contents is passed
+;; as a string.
+
+(define (table-set-cell id row col value)
+  (set 'gs:table-cell nil)
+  (let (s (string "table-set-cell " id
+		  " " row
+		  " " col
+		  " " (base64-enc value)))
+    ;(println "gs:table-set-cell " s)
+    (write-buffer s "\n")
+    (net-send out s)
+    (while (not gs:table-cell) (check-event 10000))
+    gs:table-cell
+ ) )
+
+
+;; @syntax (gs:table-set-column <sym-id> <int-column-number> <int-width> [<str-justification>])
+;; @param <sym-id> The name of the table.
+;; @param <int-column-number> The column number of align.
+;; @param <int-width> The column width.
+;; @param <str-justification> The column align property, "left", "center", "right".
+;;
+;; A table column property is changed, adjusting the column width and alignment of cell
+;; contents. The <str-justification> parameter is optional and alignment is "left"
+;; by default.
+
+(define (table-set-column id columnNum width (justification "left"))
+  (let (s (string "table-set-column " id
+		  " " columnNum
+		  " " width
+		  " " justification))
+    ;(println "gs:table-set-column " s)
+    (write-buffer s "\n")
+    (net-send out s) ) )
+
+; FdB
+;; @syntax (gs:table-set-column-name <sym-id> [<str-columns> ... ])
+;; @syntax (gs:table-set-column-name <sym-id> ([<str-columns> ...))
+;; @param <sym-id> The name of the table.
+;; @param <str-columns> Set column names with contents in <str-columns>	
+;; 
+;; Replaces the column names in the table. If the number of names 
+;; is greater than the current number of columns, new columns are added to the end 
+;; of each row in the table. If the number of columnnames is less than the current
+;; number of columns, all the extra columns at the end of a row are discarded.
+	
+	(define (table-set-column-name id)
+	   (let (s (string "table-set-column-name " id)
+		  columns (if (null? (args)) '()
+			      (if (list? (args 0)) (args 0) (args))))
+		  (dolist (col columns)
+		    (write-buffer s (string " " (base64-enc col))))
+		  ;(println "gs:table-set-column-name " s)
+		  (write-buffer s "\n")
+		  (net-send out s)))
+	  
+; FdB
+;; @syntax (gs:table-set-row-count <sym-id> <int-row-count>)
+;; @param <sym-id> The name of the table.
+;; @param <int-row> Set the numbers of rows in the table with <int-row-count>	  
+;;
+;; Sets the number of rows in the table. If the new size is greater than the 
+;; current size, new rows are added to the end of the table. If the new size is 
+;; less than the current size, all rows at index rownumber and greater are discarded.
+	  
+	(define (table-set-row-count id num)
+	  (let (s (string "table-set-row-count " id " " num))
+		(write-buffer s " \n")
+		(net-send out s)) )
+
+;; @syntax (gs:table-get <sym-id>)
+;; @return table cells. stored in 'gs:table-full'.
+;;
+;; Get full table as a list of row lists.
+;; <pre>
+;; ( ("column0" "column1" ... ) ; 1'st row
+;;   ("column0" "column1" ... ) ; 2'nd row
+;;   ...
+;;   ... )
+;; </pre>
+;;
+;; The entire table contents is stored as a list of row lists in the 
+;; return value of 'gs:table-get', and is also stored in the variable 
+;; 'gs:table-full'. 
+
+(define (table-get id)
+	(set 'gs:table-full nil)
+	(let (s (string "table-get " id))
+		(write-buffer s "\n")
+		;(println "gs:table-get " s)
+		(net-send out s)
+		(while (not gs:table-full) (check-event 10000))
+		; decode base64 cell contents for each row in each cell
+		(set 'gs:table-full
+			(map (lambda (x) (map (lambda (s) 
+					(if (nil? s) nil (base64-dec s))
+						) x ) ) gs:table-full))
+	)
+)
+
+;; @syntax (gs:table-set-row-number <sym-id> <bool-row-number>) DEPRECATED
+;;
+;; Use 'gs:table-show-row-number'. The old naming is deprecated but will 
+;; still work.
+
+
+;; @syntax (gs:table-show-row-number <sym-id> <bool-row-number>)
+;; @param <sym-id> The name of the table.
+;; @param <bool-row-number> 'true' if rows should carry a row number; default 'nil'.
+;;
+;; Show or hide the row number headers. The default is hiding row numbers.
+
+(define (table-show-row-number id boolRowheader)
+  (let (s (string "table-show-row-number " id
+		  " " boolRowheader))
+    ;(println "gs:table-show-row-number " s)
+    (write-buffer s "\n")
+    (net-send out s) ) )
+
+(define table-set-row-number table-show-row-number)
+
+;; @syntax (gs:text-area <sym-id> <sym-action> <int-width> <int-height>)
+;; @param <symid> The name of the text area.
+;; @param <sym-action> The name of the event handler.
+;; @param <int-width> The optional width of the text area..
+;; @param <int-height> The optional height of the text area.
+;;
+;; @example
+;; (gs:text-area 'TheText 'textarea-event 10 8)
+;;
+;; (define (textarea-event id code dot mark) ...)
+
+;; 'gs:text-area' transmits the following parameters in its event:
+;; <pre>
+;; id   - name of the widget 
+;; code - key code equals ASCII code. Only for text keys
+;; dot  - position of text caret in the text 
+;; mark - extended (selection) position of caret 
+;; </pre>
+
+
+(define (text-area id action width height)
+	(if (and width height)
+		(net-send out (string "text-area " id " " action " " width " " height "\n"))
+		(net-send out (string "text-area " id " " action "\n")))
+)
+
+;; @syntax (gs:text-field <sym-id> <sym-action> <int-columns> [<str-cover-char>])
+;; @param <sym-id> The name of the text field.
+;; @param <sym-action> The name of the event handler.
+;; @param <int-columns> The number of columns in the text field.
+;; @param <str-cover-char> Cover character for password entry.
+;; @example
+;; (gs:text-field 'TheTextField 'textfield-event)
+;; (gs:text-field 'PasswordTextField 'textfield-event "*")
+
+;; The 'textfield-event' is fired when the enter key is pressed in the
+;; text field. As an alternative the cover character for passwords can be
+;; set with 'gs:set-echo-char'.
+
+(define (text-field id action columns text)
+  (if text
+      (net-send out (string "text-field " id " " action " " columns " " (base64-enc text) "\n"))
+      (net-send out (string "text-field " id " " action " " columns "\n")))
+)
+
+;; @syntax (gs:text-pane <sym-id> <sym-action> <str-style> [<int-width> <int-height>])
+;; @param <sym-id> The name of the text pane.
+;; @param <sym-action> The key action handler for the html pane.
+;; @param <sym-style> The content type of the text pane.
+;; @param <int-width> The optional width of the pane.
+;; @param <int-height> The optional height of the pane.
+;;
+;; The 'gs:text-pane' is used similar to 'gs:text-area. The following styles
+;; are supported in <sym-style>:
+;; <pre>
+;;    "text/plain"
+;;    "text/html"
+;; </pre>
+;;
+;; The 'gs:text-pane' widget will automatically display scroll bars when
+;; text does not fit in the visible space of the pane. When entering parentheses
+;; they are automatically matched with their opening or closing counterparts, if they exist.
+;; If this is undesired behavior, the simpler 'gs:text-area' control should
+;; be used instead. 
+;;
+;; On each change of the caret or selection in the text pane
+;; an event is fired containing several parameters about the caret and selection
+;; positions, the last character typed, and the modifier keys used. See the
+;; the file 'newlisp-edit.lsp' for a complex application using all features
+;; available in this widget.
+;;
+;; To make hyperlinks in 'HTML' formatted text clickable, editing must
+;; be disabled using the 'gs:set-editable' function. The functions 'gs:set-font'
+;; and 'gs:append-text' will work only on the 'text/plain' content style.
+;;
+;; @example
+;; (gs:text-pane 'TheTextPane 'textpane-event "text/plain")
+;;
+;; (define (textpane-event id code mods dot mark len undo redo) ...)
+
+;; 'gs:text-pane' transmits the following parameters in its event:
+;; <pre>
+;; id   - name of the widget 
+;; code - key code equals ASCII code. Only for text keys 
+;; mods - keys pressed together with the previous, like shift, ctrl etc.
+;; dot  - position of the text caret in the text 
+;; mark - extended (selection) position of the caret 
+;; len  - length of the text in the textarea 
+;; undo - undo enabled/disabled 
+;; redo - redo enabled/disabled 
+;; </pre>
+
+(define (text-pane id action style width height)
+	(if (and width height)
+		(net-send out (string "text-pane " id " " action " " style " " width " " height "\n"))
+		(net-send out (string "text-pane " id " " action " " style "\n"))
+	)
+)
+
+;; @syntax (gs:toggle-button <sym-id> <sym-action> <str-text> [<bool-selected>])
+;; @param <sym-id> The name of the toggle button.
+;; @param <sym-action> The name of the event handler.
+;; @param <str-text> The optional text of the toggle button.
+;; @param <bool-selected> An optional flag 'true' or 'nil' (default) indicating the initial state of the toggle button.
+
+(define (toggle-button id action text selected)
+	(if text
+		(net-send out (string "toggle-button " id " " action " " (base64-enc text) " " selected "\n"))
+		(net-send out (string "toggle-button " id " " action "\n")))
+)
+
+;; @syntax (gs:tool-bar <sym-frame> [<bool-floatable> <int-hgap> <int-vgap>])
+;; @param <sym-frame> The name of the frame hosting the toolbar.
+;; @param <bool-floatable> The optional flag 'true' or 'nil' to indicate if the toolbar can be detached.
+;; @param <int-hgap> The horizontal gap between components on the toolbar.
+;; @param <int-vgap> The vertical gap between the components on the toolbar.
+
+(define (tool-bar aframe floatable width height)
+	(if (and width height)
+		(net-send out (string "tool-bar " aframe " " floatable " " width " " height "\n"))
+		(net-send out (string "tool-bar " aframe " " floatable "\n")))
+)
+
+;; @syntax (gs:translate-tag <sym-tag> <int-x> <int-y> [<boolean-repaint>])
+;; @param <sym-tag> The name tag of the group to translate.
+;; @param <int-x> The X-coordinate translation value.
+;; @param <int-y> The Y-coordinate translation value.
+;; @param <boolean-repaint> An optional flag to indicate if repainting is required (default is 'true').
+;;
+;; Moves the origin of the coordinate system of all objects tagged with <sym-tag>.
+;; Like all tag operations multiple 'gs:translate-tag' operations are cumulative.
+
+(define (translate-tag tag x y (repaint true))
+	(send-out (string "translate-tag " gs:currentCanvas " " tag " " x " " y " " repaint "\n"))
+)
+
+;; @syntax (gs:undo-text <sym-id>)
+;; @param <sym-id> The id of the 'gs:text-pane' where to perform an undo operation.
+
+(define (undo-text id)
+	(net-send out (string "undo-text " id "\n"))
+)
+
+;; @syntax (gs:undo-enable <sym-id> <boolean-enabled>)
+;; @param <sym-id> The id of the 'gs:text-pane' for which to enabe/disable undo.
+;; @param <boolean-enabled> 'true' or 'nil' to enable or disable undo.  
+
+(define (undo-enable id enabled)
+	(net-send out (string "undo-enable " id  " " enabled "\n"))
+)
+
+
+;; @syntax (gs:update)
+;; 
+;; Forces a repaint of the current canvas, e.g. after changing the scale or translation of a visible
+;; canvas. This function is rarely used, as most screen updates are performed automatically.
+;; All tag operations can carry an additional parameter to force update after they have been
+;; draw.
+
+(define (update)
+	(net-send out (string "update " gs:currentCanvas "\n"))
+)
+
+;; @syntax (gs:window <sym-id> <int-x> <int-y> <int-width> <int-height>)
+;; @param <sym-id> The name of the invisible window.
+;; @param <int-x> The x-coordinate of the screen position.
+;; @param <int-y> The y-coordinate of the screen position.
+;; @param <int-width> The width of the window.
+;; @param <int-height> The height of the window.
+;;
+;; Creates a borderless window. Note that a borderless window may treat
+;; some hosted components differently from normal frames and dialogs.
+
+(define (window id x y width height)
+	(net-send out (string "window " id " " x " " y " " width " " height "\n"))
+)
+
+;; @syntax (gs:window-closed <sym-id> <sym-action>)
+;; @param <sym-id> The name of the frame or dialog.
+;; @param <sym-action> The action to perform when the frame or dialog closes.
+;;
+;; A window or dialog window can be closed using the system close button in
+;; one of the corners of the window. In this case it is useful to specify
+;; a handler function which is called upon closing.
+
+(define (frame-closed id action)
+	(net-send out (string "frame-closed " id " " action "\n"))
+)
+
+(define (window-closed id action)
+	(net-send out (string "frame-closed " id " " action "\n"))
+)
+
+
+;; @syntax (gs:window-moved <sym-id> <sym-action>)
+;; @param <sym-id> The name of the frame or dialog.
+;; @param <sym-action> The action to perform when the frame or dialog moves.
+;;
+;; The event will carry the <sym-id> of the window or dialog and current <tt>X</tt> and <tt>Y</tt>
+;; coordinates on the screen.
+;;
+
+(define (frame-moved id action)
+	(net-send out (string "frame-moved " id " " action "\n"))
+)
+
+(define (window-moved id action)
+	(net-send out (string "frame-moved " id " " action "\n"))
+)
+
+
+;; @syntax (gs:window-resized <sym-id> <sym-action>)
+;; @param <sym-id> The name of the frame or dialog.
+;; @param <sym-action> The action to perform when the frame or dialog is resized.
+;;
+;; The event will carry the <sym-id> of the window or dialog and current width and
+;; height.
+
+(define (frame-resized id action)
+	(net-send out (string "frame-resized " id " " action "\n"))
+)
+
+(define (window-resized id action)
+	(net-send out (string "frame-resized " id " " action "\n"))
+)
+
+
+; eof
diff --git a/guiserver/guiserver.lsp.html b/guiserver/guiserver.lsp.html
new file mode 100644
index 0000000..9c37b62
--- /dev/null
+++ b/guiserver/guiserver.lsp.html
@@ -0,0 +1,3068 @@
+<!DOCTYPE HTML PUBLIC "HTML 4.01 Transitional">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>guiserver.lsp</title>
+
+<link rel="stylesheet" type="text/css" href="newlispdoc.css" />
+</head>
+
+<body style="margin: 20px;" text="#111111" bgcolor="#FFFFFF" 
+            link="#376590" vlink="#551A8B" alink="#ffAA28">
+<blockquote>
+<center><h1>guiserver.lsp</h1></center>
+<p><a href="index.html">Module index</a></p><a href="guiserver.lsp.src.html">source</a>&nbsp;<a href="guiserver.lsp">download</a><br/>
+<h2>Module:&nbsp;guiserver.lsp</h2><p>Functions for programming GUIs and 2D graphics.</p>
+<b>Version: </b>1.40 use text-field as a password field with additional parameter<br/>
+<b>Version: </b>1.41 bug fixes for gs:listen and gs:check-event<br/>
+<b>Version: </b>1.42 new table UI<br/>
+<b>Version: </b>1.43 bug fix in new table UI action parameters<br/>
+<b>Version: </b>1.44 fixes in newlisp-edit.lsp<br/>
+<b>Version: </b>1.50 doc fixes<br/>
+<b>Version: </b>1.51 return value for gs:export<br/>
+<b>Version: </b>1.52 fix in run-shell for Java 7 update 21<br/>
+<b>Version: </b>1.53 doc fixes<br/>
+<b>Version: </b>1.60 new table functions, new naming gs:table-show-row-number<br/>
+<b>Version: </b>1.61 more options for gs:scroll-pane added by FdB<br/>
+<b>Version: </b>1.62 doc corrections<br/>
+<b>Version: </b>1.63 make deprecated gs:table-set-row-number work<br/>
+<b>Version: </b>1.70 default comm port with Guiserver are now 64001 and 64002<br/>
+<b>Version: </b>1.71 references to /usr/ changed to /usr/local/<br/>
+<b>Author: </b>LM, 2008, 2009, 2010, 2015, Unya 2012, FdB 2013, LM 2015<br/>
+<br/><br/>
+ This module has been tested on MacOS X 10.5 (Leopard) and Windows XP, both with the
+ Standard SUN Java RE v.1.5 (runtime environment) which came pre-installed on
+ those platforms. On Linux the installation of the original Sun Java Runtime 
+ Environment is required the preinstalled GNU Java is not compatible. After
+ installation a soft-link has to be made from the original java executable to
+ <tt>/usr/bin/java</tt>.
+<br/><br/>
+<br/><br/>
+ On Windows the MIDI sound features require a soundbank file to
+ be installed. See the description for <tt>gs:play-note</tt> for details.
+ <br><br>
+ <h2>What is newLISP-GS</h2>
+ <tt>guiserver.lsp</tt> is a module for interfacing to <tt>guiserver.jar</tt>
+ a Java server application for generating GUIs (graphical user interfaces)
+ and 2D graphics for newLISP applications. The <tt>guiserver.lsp</tt>, module
+ implements a newLISP API much smaller and more abstract than the APIs of the 
+ Java Swing libraries which it interfaces with. Because of this, GUI applications
+ can be built much faster than when using the original Java APIs.
+ <br><br>
+ <h2>Usage</h2>
+ At the beginning of the program file, include a <tt>load</tt> statement for the module:
+ <pre>
+ (load "/usr/local/share/newlisp/guiserver.lsp")
+ </pre>
+ or on MS Windows:
+ <pre>
+ (load "c:/Program Files/newlisp/guiserver.lsp")
+ </pre>
+ <tt>guiserver.lsp</tt> expects the server <tt>guiserver.jar</tt> to be
+ in the directoey specified in the environment variable NEWLISPDIR.
+ When newLISP starts up and this variable is not set yet, it sets it
+ to a default value of <tt>/usr/local/share/newlisp</tt> on MacOS X and Unix OSs, and 
+ to <tt>C:\Program Files\newlisp</tt> or whatever it finds in the <tt>PROGRAMFILES</tt>
+ environment variable on MS Windows systems and adding <tt>/newlisp</tt> to it.
+ This can be overwritten by specifying system wide  setting for the environment 
+ variable <tt>NEWLISPDIR</tt>, which normally is set to <tt>%PROGRAMFILES%/newlisp</tt> 
+ on MS Windows. When using the MS Windows binary installer <tt>NEWLISPDIR</tt> is written 
+ to the registry automatically and gets into effect after rebooting.
+ <br><br>
+ <h2>Architecture of a newLISP GUI application</h2>
+ A GUI application in newLISP is composed of four parts:
+<br/><br/>
+ <blockquote>
+ <b>initialization</b> - this means starting the newLISP-GS <tt>guiserver.jar</tt> and initializing 
+ communications with it. Only one function call is required to do this.
+<br/><br/>
+ <b>building widgets</b> - in this step windows, buttons, text fields etc., and
+ all visual aspects of the GUI are described. newLISP newLISP-GS offers a wide range
+ of different control widgets.
+<br/><br/>
+ <b>defining event actions</b> - in this step all the functions are defined to
+ react to events coming from the GUI as a consequence of button pushes, keystrokes,
+ mouse-movements etc.. These event actions send many commands back to the GUI
+ to change information for the user, popup dialogs etc..
+<br/><br/>
+ <b>listening for events</b> - the newLISP program sits in a loop waiting for
+ events and dispatching them to the defined event actions. Only one function call
+ is required for this step.
+ </blockquote>
+ <br><br>
+ <h2>Example</h2>
+ The following example application shows all the essential elements of a newLISP GUI
+ application:
+<br/><br/>
+<b>Example:</b><blockquote><pre> #!/usr/bin/newlisp
+ ; button-demo.lsp - demonstrate the button control
+  
+ ; initialization
+ (load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+ (gs:init) 
+  
+ ; describe the GUI
+ (gs:frame 'ButtonDemo 100 100 400 300 "Button demo")
+ (gs:set-resizable 'ButtonDemo nil)
+ (gs:panel 'ColorPanel 360 200)
+ (gs:set-color 'ColorPanel (random) (random) (random))
+ (gs:button 'aButton 'abutton-action "color")
+ (gs:set-flow-layout 'ButtonDemo "center" 2 15)
+ (gs:add-to 'ButtonDemo 'ColorPanel 'aButton)
+ (gs:set-visible 'ButtonDemo true)
+  
+ ; define actions
+ (define (abutton-action id)
+     (gs:set-color 'ColorPanel (random) (random) (random)))
+  
+ ; listen for incoming action requests and dispatch
+ (gs:listen)
+  
+ ; eof </pre></blockquote>
+ <br>
+ <h2>Application start</h2>
+ <pre>
+     ./button-demo       ; on MacOS X and Unix
+     newlisp button-demo ; on MS Windows
+ </pre>
+ By default guiserver.jar uses the ports 64001 and 64002, but this setting can be overwritten 
+ either by supplying a port number parameter to the <tt>gs:init</tt> function or by overwriting the
+ port number from the command-line. newLISP-GS will then use the port number supplied and the number
+ following it:
+ <pre>
+     ./button-demo 10001       ; on MacOS X and Unix
+     newlisp button-demo 10001 ; on MS Windows
+ </pre>
+ newLISP-GS <tt>guiserver.jar</tt> will now use the ports <tt>64001</tt> and <tt>60002</tt>.
+ Ports under <tt>1024</tt> should not be used, as many of them are already in use by other
+ OS services and need administrator privileges to use them.
+<br/><br/>
+ A second method to start a newLISP-GS application starts the <tt>guiserver.jar</tt> first, which then
+ starts the newLISP application:
+ <pre>
+     java -jar /usr/local/share/newlisp/guiserver.jar 64001 /usr/home/aUser/MyApplication.lsp
+ </pre>
+ A different port number can be used. Port numbers below 1024 need administrator
+ permissions. Optionally a splash screen can be specified as the last parameter:
+ <pre>
+     java -jar /usr/local/share/newlisp/guiserver.jar 64001 /home/apps/myapp.lsp /local/newLISP128.png
+ </pre>
+ The example specifies an image inside <tt>guiserver.jar</tt>. Any other image path on the local file system
+ can be used.
+<br/><br/>
+ On MS Windows similar methods can be used replacing the appropriate file paths, but on MS Windows Java jar files
+ can also be treated as executables and executed directly without calling Java explicitly. By default
+ <tt>guiserver.jar</tt> and <tt>guiserver.lsp</tt> are  installed in <tt>c:\Program Files\newlisp\</tt> or any other 
+ directory configured on a MS Windows platform using the <tt>PROGRAMFILES</tt> environment variable:
+ <pre>
+    "c:\Program Files\newlisp\guiserver.jar" 64001 c:\myprogs\MyApplication.lsp
+ </pre>
+ Quotes are necessary when spaces are present in the argument string. The example assumes that
+ <tt>newlisp.exe</tt> is in the path for executables, and it also assumes that the Windows registry has
+ an association of the <tt>.jar</tt> file extension with the <tt>javaw.exe</tt> executable. This
+ association is normally present when a java run-time environment (JRE) is installed in Windows.
+ If this association is not registered, the following method can be used:
+ <pre>
+    javaw -jar "c:\Program Files\newlisp\guiserver.jar" 64001 c:\myprogs\MyApplication.lsp
+ </pre>
+ The quotes are necessary for path-names containing spaces.
+<br/><br/>
+ <h2>Debugging</h2>
+ <b>Tracing commands to newLISP-GS</b><br><br>
+ For debugging purpose put the following directive at the beginning of your application
+ or at the place from where to start tracing.
+ <pre>
+         (gs:set-trace true)
+ </pre>
+ Then start the application from a terminal or command shell window. Now newLISP-GS
+ will output startup, version and connection messages and a trace for each <tt>gs:xxs</tt> directive
+ as it is received by the newLISP-GS dispatcher:
+<br/><br/>
+ <blockquote><pre>
+ newLISP-GS v.0.94
+ listening on 64001
+ accepted from 0.0.0.0
+ connecting to 0.0.0.0 64002
+ retrying to connect
+ connected
+ -> frame MAIN:ButtonDemo 100 100 400 300 QnV0dG9uIGRlbW8= nil
+ -> set-resizable MAIN:ButtonDemo nil
+ -> panel MAIN:ColorPanel 360 200
+ -> set-color MAIN:ColorPanel 0 1 0 0.2
+ -> button MAIN:aButton MAIN:abutton-action Y29sb3I=
+ -> set-flow-layout MAIN:ButtonDemo center 2 15
+ -> add-to MAIN:ButtonDemo MAIN:ColorPanel MAIN:aButton 
+ -> set-visible MAIN:ButtonDemo true
+ -> set-color MAIN:ColorPanel 0.8401877172 0.3943829268 0.7830992238
+ server shut down
+ </blockquote></pre>
+<br/><br/>
+ Text strings for button names, icon paths and other texts are encode in
+ Base64 strings as the first trace line for MAIN:ButtonDemo shows. To switch
+ off tracing mode use:
+ <pre>
+        (gs:set-trace nil)
+ </pre>
+ Even if trace mode is switched off, wrong or missing parameters are still messaged
+ by newLISP-GS in a small message box. After such an error the application and guiserver
+ will exit. Unknown commands will be ignored. Functions which are not applicable to
+ certain widgets will also pop up an error message box. In certain situations a
+ function will have no effect, e.g. <tt>gs:set-size</tt> or <tt>gs:set-color</tt> sometimes do not
+ have an effect, depending on how a widget is configured or depending on the layout
+ which hosts the widget. Sometimes the platform look-and-feel overwrites colors.
+ <br><br>
+ <h2>Event handlers</h2>
+ For most widgets, event handlers must be defined. Sometimes an event handler is
+ not required. In this case specify <tt>'gs:no-action</tt> as the event handler
+ symbol. When developing programs it is useful to watch the event handler first
+ before coding for it. This can be done easily by printing out event parameters:
+ <blockquote><pre>
+ (gs:button 'aButton 'abutton-handler "press")
+ (define (abutton-handler id)
+     (println id))
+ </pre></blockquote>
+ Sometimes the same event handler function is attached to several widgets' keyboard
+ or mouse events. Some of these events receive a greater number of parameters. There
+ are two easy ways to discover the nature of an event:
+ <blockquote><pre>
+ (define (the-handler)
+     (doargs (p)
+         (println "->" p)))
+ </pre></blockquote>
+ The other method looks at the source of the event as it was transmitted by the newLISP-GS.
+ This is useful to recognize the data types used in the event:
+ <blockquote><pre>
+ (define (the-handler)
+     (println gs:event))
+ </pre></blockquote>
+ All text from text fields are received as base64-encoded strings. E.g. the text: 
+ <tt>"Hello World"</tt> would be received as: <tt>"SGVsbG8gV29ybGQ="</tt>:
+ <blockquote><pre>
+ (gs:text-field 'TextField 'textfield-handler)
+<br/><br/>
+ (define (textfield-handler id text)
+     (printnl id ": " (base64-dec text)))
+ </pre></blockquote>
+ When the text "Hello World" is entered in the text field, the following output
+ would be generated:
+ <blockquote><pre>
+ TextField: "Hello World"
+ </pre></blockquote>
+ In case the ESC key is pressed in the text field, the event handler would
+ report <tt>nil</tt> for the text field. A handler should therefore always check text
+ for string contents before trying to apply the <tt>base64-dec</tt> function on it.
+ <br><br>
+ <h2>Mapping or applying <tt>gs:xxx</tt> functions</h2>
+ Like any newLISP functions, <tt>gs:xxx</tt> functions can be mapped or applied to lists of 
+ parameters using the newLISP <tt>map</tt> and <tt>apply</tt> functions. When doing this, make sure to 
+ map or apply the quoted <tt>'gs:xxx symbol</tt>, so the <tt>gs:xx</tt> functions 
+ get executed under the <tt>gs</tt> context, prefixing symbols in parameter lists
+ correctly with the context prefix of their origin.
+ <pre>
+    (map 'gs:panel '(first second third fourth)) ; note quoted gs: function
+ </pre>
+ <h2>Some shortcuts when writing <tt>gs:xxx</tt> functions</h2>
+ Due to the nature of transfer between newLISP and the guiserver as text, the following
+ convenient shortcuts can be taken when writing functions:
+ <blockquote>
+ <ul>
+ <li>Symbol ids of components can be expressed as strings.</li>
+ <li>Number values can be expressed as strings.</li>
+ <li>Numbers can be expressed as floats or integers.</li>
+ </ul>
+ </blockquote>
+ Here are some examples:
+ <pre>
+     (gs:panel 'ColorPanel 360 200)
+     ; is the same as
+     (gs:panel "ColorPanel" 360 200)
+     ; is the same as
+     (gs:panel "ColorPanel" "360" "200")
+     ; is the same as
+     (gs:panel "ColorPanel" 360.0 "200.00")
+ </pre>
+ Although the first form is preferred for clarity and readability, in some cases coding
+ may be more efficient using the other forms.
+<br/><br/>
+ Except for the symbols used for action handlers, all symbols are used only by their
+ face (term) value. This means that reserved symbols of the newLISP programming
+ language can be used freely in symbol ids for all components, e.g:
+ <pre>
+     (gs:label 'term "Input here") ; term is a reserved name since v10.2.0
+ </pre>
+ The usage of the reserved symbol <tt>term</tt> will not pose a problem.
+ <br><br>
+ <h2>Return values</h2>
+ newLISP-GS is an event driven asynchronous system. Most functions return
+ right away the number of characters sent out to the server.
+ In general, return values of <tt>gs:xxx</tt> functions do not have
+ any specific meaning and can be discarded. Only the functions <tt>gs:get-bounds</tt>,
+ <tt>gs:get-fonts</tt>, <tt>gs:get-font-metrics</tt>, <tt>gs:get-instruments</tt>
+ <tt>gs:get-screen</tt>, <tt>gs:get-text</tt> and <tt>gs:get-version</tt> return meaningful values or
+ lists of values, which are stored in similar named variables: <tt>gs:bounds</tt>,
+ <tt>gs:fonts</tt>, <tt>gs:font-metrics</tt>, <tt>gs:instruments</tt>, <tt>gs:screen</tt>, <tt>gs:text</tt> and
+ <tt>gs:version</tt>. These functions will not return right away but block until
+ the return valuse is sent back from newLISP-GS.
+<br/><br/>
+ The function <tt>gs:get-text</tt> can work both ways: event driven or with a return
+ value depending on the call pattern used.
+ <br><br>
+ <h2>Function overview</h2>
+ <ul>
+ <li><b>Initialization and application setup</b><br>
+ <pre>
+    (gs:init [<em>server-port</em>])
+ </pre>
+ The initialization function starts <tt>guiserver.jar</tt> which will listen to the <i>server-port</i>
+ and initiate another connection on <tt>server-port + 1</tt> back to newLISP. If a <em>server-port</em>
+ is not supplied <tt>guiserver</tt> will assume <tt>64001</tt> and <tt>64002</tt>.
+<br/><br/>
+ As the last statement in the application put:
+ <pre>
+    (gs:listen)
+ </pre>
+ This function listens on <tt>64002</tt> (by default) for event messages from newLISP-GS
+ and dispatches them to the user-defined action handlers. To avoid newLISP shutting down
+ when the guiserver shuts down, use:
+ <pre>
+    (gs:listen true)
+ </pre>
+ </li>
+ Sometimes it is necessary to run other tasks while listening for events. In this case use
+ <tt>gs:check-event</tt>, which will wait for certain amount of microseconds for an event
+ to be executed. After the wait-time, it returns. The function is typically used in a loop:
+ <pre>
+    (while (gs:check-event 10000) ; check for 10 milli seconds
+			(do-myprocess))
+    (exit)
+ </pre>
+ The loop will exit when <tt>gs:check-event</tt> returns <tt>nil</tt> on communications errors, e.g.
+ when the window's close button was clicked.
+<br/><br/>
+ <li><b>Containers</b><br>
+ A <em>container</em> can contain any other container or control widget. Except for the 
+ <tt>menu-bar</tt> and the <tt>split-pane</tt>, containers can have a special layout-manager set 
+ with one of the three layout-manager function commands. By default containers have a flow layout. By
+ nesting different containers and using different layout-manager settings, complex layouts
+ can be configured. The function/command <tt>add-to</tt> is used to add components to containers.
+ <pre>
+    (gs:dialog <em>sym-id</em> <em>sym-parent-frame</em> <em>str-message</em> <em>int-width</em> <em>int-height</em> [<em>boolean-visible</em> [<em>boolean-modal</em>]])
+    (gs:frame <em>sym-id</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> [<em>str-title</em> <em>boolean-visible</em>])
+    (gs:menu-bar <em>sym-frame</em> [<em>sym-menu-1</em> ...])  
+    (gs:panel <em>sym-id</em> [<em>int-width</em> <em>int-height</em>])
+    (gs:scroll-pane <em>sym-id</em> <em>sym-widget</em> [<em>int-width</em> <em>int-height</em>])
+    (gs:split-pane <em>sym-id</em> <em>str-orientation</em> [<em>float-weight</em> [<em>float-location</em> [int-divider-size>]]])
+    (gs:tabbed-pane <em>sym-id</em> <em>sym-action</em> <em>str-orientation</em> [<em>sym-widget</em> <em>sym-tab-title</em> ...])
+    (gs:tool-bar <em>sym-frame</em> [<em>bool-floatable</em> <em>int-hgap</em> <em>int-vgap</em>])
+    (gs:canvas <em>sym-id</em>) 
+    (gs:window <em>sym-id</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em>)
+ </pre>
+ </li>
+ <li><b>Labels</b><br>
+ Labels can have text or an image or both. A normal text <tt>label</tt> can have an icon
+ added to it and a <tt>image-label</tt> can have text added to it. Labels don't initiate
+ actions and can be placed in any container like all button-type widgets - buttons, checkboxes
+ and menu items. A basic set of icon images is built into <tt>guiserver.jar</tt>,
+ but user-supplied images and icons in <tt>.jpg</tt>, <tt>.png</tt> and <tt>.gif</tt> formats
+ can be used.
+ <pre>
+    (gs:label <em>sym-id</em> <em>str-text</em> [<em>str-align</em> [<em>int-width</em> <em>int-height</em>]])
+    (gs:image-label <em>sym-id</em> <em>str-icon-path</em> [<em>str-align</em>])
+ </pre>
+ </li>
+ <li><b>Control widgets</b><br>
+ Except for the passive progress bar, all control widgets fire action requests to
+ the newLISP program. These requests must be served to avoid error messages but can
+ be defined as empty functions, if an action is not required:
+ <pre>
+    ; empty action definition
+    (define (my-button-action) )
+<br/><br/>
+    ; action handler printing the name of the button pressed
+    (define (my-button-action id) (println id " has been pressed"))
+ </pre>
+ All action events calls carry information about the widget, that initiated that the event,
+ and event parameters like keystrokes, slider positions etc..
+ <pre>
+    (gs:button <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> [<em>int-width</em> <em>int-height</em>]])
+    (gs:check-box <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> [<em>bool-selected</em>]])
+    (gs:combo-box <em>sym-id</em> <em>sym-action</em> [<em>str-item-1</em> ...])
+    (gs:combo-box <em>sym-id</em> <em>sym-action</em> [<em>list-str-items</em>])
+    (gs:image-button <em>sym-id</em> <em>sym-action</em> <em>str-icon-path</em> [<em>str-down-icon-path</em> [<em>int-width</em> <em>int-height</em>]])
+    (gs:list-box <em>sym-id</em> <em>sym-action</em> [<em>str-item-1</em> ...])
+    (gs:list-box <em>sym-id</em> <em>sym-action</em> [<em>list-str-items</em>])
+    (gs:menu <em>sym-id</em> <em>str-text</em>)
+    (gs:menu-popup <em>sym-id</em> <em>str-text</em>)
+    (gs:menu-item <em>sym-id</em> <em>sym-action</em> <em>str-text</em>)
+    (gs:menu-item-check <em>sym-id</em> <em>sym-action</em> <em>str-text</em> [<em>bool-selected</em>])
+    (gs:progress-bar <em>sym-id</em> <em>int-min</em> <em>in-max</em> <em>int-initial-value</em>)
+    (gs:radio-button <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> [<em>bool-selected</em>]])
+    (gs:slider <em>sym-id</em> <em>sym-action</em> <em>str-orientation</em> <em>int-min</em> <em>int-max</em> <em>int-initial-value</em>)
+    (gs:text-area <em>sym-id</em> <em>sym-action</em> [<em>int-width</em> <em>int-height</em>])
+    (gs:text-field <em>sym-id</em> <em>sym-action</em> <em>int-columns</em>[<em>str-echo-char</em>])
+    (gs:text-pane <em>sym-id</em> <em>sym-action</em> <em>str-style</em> [<em>int-width</em> <em>int-height</em>])
+    (gs:toggle-button <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> <em>bool-selected</em>])
+ </pre>
+ For all button widgets, and the check box and menu-item widgets, icons can be set using 
+ the <tt>gs:set-icon</tt> and <tt>gs:set-pressed-icon</tt> functions.
+ </li><br>
+ <li><b>Placing components in containers</b><br>
+ For the flow and grid layouts the components are added in the sequence they are listed.
+ The grid-layout fills the grid row by row starting with the left most column. 
+ <pre>
+    (gs:add-to <em>sym-container</em> <em>sym-component</em> [<sym-component ...])
+ </pre>
+ For the border layout an orientation parameter is specified as either <tt>"north"</tt>,
+ <tt>"west"</tt>, <tt>"center"</tt>, <tt>"east"</tt> or <tt>"south"</tt>.
+ <pre>
+    (gs:add-to <em>sym-container</em> [<em>sym-component</em> <em>str-orientation</em> ...])
+ </pre>
+
+ </li>
+ <li><b>Summary of commands</b><br>
+ Most of the commands set special attributes of containers or control widgets. 
+ Not all functions can be applied to all containers and control widgets. A wrong
+ application will either pop up an error message box or do nothing.
+<br/><br/>
+ Some functions will work on certain widgets only in certain situations. For example
+ <tt>set-size</tt> will work not on components in a grid layout but on components
+ in a flow layout. Some widgets have a preset background color which cannot be changed
+ or is overwritten by the current <tt>gs:look-and-feel</tt> settings.
+	<pre>
+    (gs:add-list-item <em>sym-list-combo</em> <em>str-text</em> [<em>str-text</em> ...])
+    (gs:add-separator <em>sym-menu-tool-bar</em>)
+    (gs:add-to <em>sym-container</em> <em>sym-component</em> [<sym-component ...])
+    (gs:add-to <em>sym-container</em> <em>sym-component</em> <em>str-orientation</em> [<em>sym-component</em> <em>str-orientation</em> ...])
+    (gs:append-text <em>sym-id</em> <em>str-text</em>)
+    (gs:check-event <em>int-microseconds</em>)
+    (gs:clear-list <em>sym-id</em>)
+    (gs:clear-text <em>sym-id</em>)
+    (gs:copy-text <em>sym-id</em>)
+    (gs:cut-text <em>sym-id</em>)
+    (gs:destroy-shell <em>sym-text-area</em>)
+    (gs:disable <em>sym-id-1</em> [<em>sym-id-2</em> ...])
+    (gs:dispose <em>sym-id</em>)
+    (gs:dispose-splash)
+    (gs:enable <em>sym-id-1</em> [<em>sym-id-2</em> ...])
+    (gs:eval-shell <em>sym-text-area</em> <em>str-commmand</em>)
+    (gs:find-text <em>sym-id</em> <em>str-text</em> <em>sym-action</em> [<em>str-direction</em>]])
+    (gs:frame-closed <em>sym-id</em> <em>sym-action</em>)
+    (gs:get-fonts)
+    (gs:get-bounds <em>sym-id</em>)
+    (gs:get-font-metrics <em>sym-id</em> <em>str-text</em>)
+    (gs:get-screen)
+    (gs:get-selected-text <em>sym-id</em> <em>sym-action</em>)
+    (gs:get-text <em>sym-id</em> [<em>sym-action</em>])
+    (gs:get-text-position <em>sym-id</em>)
+    (gs:get-version);
+    (gs:goto-text <em>sym-id</em> <em>sym-row</em> <em>sym-column</em>)
+    (gs:insert-list-item <em>sym-list-combo</em> <em>str-text</em> <em>int-index</em> [<em>str-text</em> <em>int-index</em>])
+    (gs:insert-tab <em>sym-tabbed-pane</em> <em>sym-component</em> [<em>str-text</em> [<em>int-index</em> [<em>str-icon-path</em>]])
+    (gs:insert-text <em>sym-id</em> <em>str-text</em> <em>int-pos</em>)
+    (gs:layout <em>sym-container</em>)
+    (gs:load-text <em>sym-id</em> <em>str-path</em>)
+    (gs:no-action)
+    (gs:paste-text <em>sym-id</em> [<em>str-text</em>])
+    (gs:redo-text <em>sym-id</em>)
+    (gs:remove-from <em>sym-container</em> <em>sym-component</em> [<em>sym-component</em> ...])
+    (gs:remove-list-item <em>sym-list-combo</em> <em>int-index</em> [<em>int-index</em> ...])
+    (gs:remove-tab <em>sym-tabbed-pane</em> <em>int-index</em>)
+    (gs:request-focus <em>sym-id</em>)
+    (gs:run-shell <em>sym-text-area</em> <em>str-commmand</em> <em>str-args</em>)
+    (gs:select-list-item <em>sym-id</em> <em>str-item</em> [<em>boolean-flag</em>])
+    (gs:select-text <em>sym-id</em> <em>int-from</em> [<em>int-to</em>])
+    (gs:set-accelerator <em>sym-menu-item</em> <em>str-keystroke</em>)
+    (gs:set-background <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])
+    (gs:set-background <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])
+    (gs:set-bevel-border <em>sym-panel</em> <em>str-type</em>)
+    (gs:set-border-layout <em>sym-container</em>  [<em>int-hgap</em> <em>int-vgap</em>])
+    (gs:set-caret <em>sym-id</em> <em>int-offset</em>)
+    (gs:set-caret-color <em>sym-id</em> <em>list-rgb</em>)
+    (gs:set-caret-color <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em>)
+    (gs:set-color <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])
+    (gs:set-color <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])
+    (gs:set-cursor <em>sym-id</em> <em>str-shape</em>)
+    (gs:set-echo-char <em>sym-id</em> <em>str-echo-char</em>)
+    (gs:set-editable <em>sym-id</em> <em>boolean-flag</em>)
+    (gs:set-flow-layout <em>sym-container</em> [<em>str-alignment</em> [<em>int-hgap</em> <em>int-vgap</em>]])
+    (gs:set-font <em>sym-id</em> <em>str-family</em> <em>int-size</em> <em>str-type</em>)
+    (gs:set-foreground <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])
+    (gs:set-foreground <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])
+    (gs:set-grid-layout <em>sym-container</em> <em>int-rows</em> <em>int-columns</em> [<em>int-hgap</em> <em>int-vgap</em>])
+    (gs:set-icon <em>sym-id</em> <em>str-icon-path</em> [<em>int-index</em>])
+    (gs:set-look-and-feel <em>str-look</em>)
+    (gs:set-resizable <em>sym-frame</em> <em>boolean-flag</em>)
+    (gs:set-pressed-icon <em>sym-id</em> <em>str-icon-path</em>)
+    (gs:set-selected <em>sym-id</em> <em>boolean-flag</em>)
+    (gs:set-size <em>sym-id</em> <em>int-width</em> <em>int-height</em>)
+    (gs:set-selection-color <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])
+    (gs:set-syntax <em>sym-id</em> <em>str-type</em>) 
+    (gs:set-syntax-colors <em>list-rgb-comments</em> <em>list-rgb-keywords</em> <em>list-rgb-string</em> <em>list-rgb-number</em> <em>list-rgb-quoted</em> <em>list-rgb-prantheses</em>)
+    (gs:set-tab-size <em>sym-id</em> <em>int-size</em>)
+    (gs:set-text <em>sym-id</em> <em>str-text</em> [<em>int-index</em>])
+    (gs:set-titled-border <em>sym-component</em> <em>str-title</em>)
+    (gs:set-tool-tip <em>sym-id</em> <em>str-text</em>)
+    (gs:set-trace <em>boolean-flag</em>)
+    (gs:set-utf8 <em>boolean-flag</em>)
+    (gs:set-value <em>sym-id</em> <em>int-value</em>)
+    (gs:set-visible <em>sym-id</em> <em>boolean-visible</em>)
+    (gs:undo-text <em>sym-id</em>)
+    (gs:undo-enable <em>sym-id</em> <em>boolean-enabled</em>)
+ </pre>
+ </li>
+ <li><b>The Table UI</b><br>
+  Since version 1.42 Guiserver has a table widget and supporting functions.
+ <pre>
+    (gs:table <em>sym-id</em> <em>sym-action</em> [<em>str-column-header-name</em> ...])
+    (gs:table-add-column <em>sym-id</em> <em>str-column-header-name</em> ...)
+    (gs:table-add-row <em>sym-id</em> [<em>str-columns</em> ... ])
+    (gs:table-get <em>sym-id</em>)
+    (gs:table-get-cell <em>sym-id</em> <em>int-row</em> <em>int-column</em>)
+    (gs:table-get-size <em>sym-id</em>)
+    (gs:table-remove-row <em>sym-id</em> <em>int-row</em>
+    (gs:table-set-cell <em>sym-id</em> <em>int-row</em> <em>int-column</em> <em>str-value</em>)
+    (gs:table-set-column <em>sym-id</em> <em>int-column-number</em> <em>int-width</em> [<em>str-justification</em>])
+    (gs:table-set-column-name <em>sym-id</em> [<em>str-name1</em> [<em>str-name2</em> ...])
+    (gs:table-set-row-count <em>sym-id</em> <em>int-count</em>
+    (gs:table-set-row-number <em>sym-id</em> <em>bool-row-number</em>) DEPRECATED use gs:table-show-row-number
+    (gs:table-show-row-number <em>sym-id</em> <em>bool-row-number</em>)
+ </pre>
+ </li>
+ <li><b>Special dialogs</b><br>
+  These are standard dialogs for opening and saving files and for choosing colors.
+  Each dialog when closed fires an event for which a handler function must be
+  defined by the newLISP program. 
+	<pre>
+    (gs:color-dialog <em>sym-parent-frame</em> <em>sym-action</em> <em>str-title</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em>)
+    (gs:message-dialog <em>sym-parent-frame</em> <em>str-title</em> <em>str-message</em> [<em>str-type</em> [<em>str-icon-path</em>]])
+    (gs:confirm-dialog <em>sym-parent-frame</em> <em>sym-action</em> <em>str-title</em> <em>str-message</em> [<em>str-type</em>])
+    (gs:open-file-dialog <em>sym-parent-frame</em> <em>sym-action</em> [<em>str-directory</em> [<em>str-mask</em> <em>str-description</em>]])
+    (gs:save-file-dialog <em>sym-parent-frame</em> <em>sym-action</em> [<em>str-directory</em> [<em>str-initial-file</em> [<em>str-mask</em> <em>str-description</em>]]])
+ </pre>
+ </li>
+ <li><b>2D Graphics functions</b><br>
+ Every call to a <tt>gs:draw-xxx</tt> or <tt>gs:fill-xxx</tt> function will create a new graphics object, which
+ will persist until destroyed by a call to <tt>gs:delete-tag</tt>. Graphics objects are animated
+ using the tag operations <tt>gs:move-tag</tt>, <tt>gs:rotate-tag</tt>, <tt>gs:scale-tag</tt> and 
+ <tt>gs:shear-tag</tt> or using <tt>gs:hide-tag</tt> and <tt>gs:show-tag</tt>. 
+<br/><br/>
+ Any <tt>gs:draw-xxx</tt> or <tt>gs:fill-xxx</tt> will create graphics objects but not force a screen update.
+ The canvas is automatically redrawn when made visible for the first time using <tt>gs:set-visible</tt> or
+ after a call to <tt>gs:update</tt>. Redrawing is also forced when resizing the window which hosts the canvas
+ or any action covering and uncovering the canvas. 
+<br/><br/>
+ After all tag operations redrawing is initiated by default, but it can be forced off by specifying 
+ <tt>nil</tt> as the last parameter in a <tt>gs:xxx-tag</tt> command. Suppressing immediate redraw is useful to avoid 
+ flicker when a batch of tag operations is performed.
+<br/><br/>
+ Every graphics object (line, shape, text, or image) carries a group tag. Objects are deleted
+ using <tt>gs:delete-tag</tt> and will disappear immediately from the canvas. Using <tt>gs:move-tag</tt>
+ lines, shapes, text and images can be moved to a different position.
+<br/><br/>
+ All positions given in <tt>int x</tt> and <tt>int y</tt> must be given as integers. Values
+ will not be converted automatically as is the case with newLISP's built-in functions. To
+ guarantee integer type, values can be casted e.g.: 
+ <pre>(gs:draw-circle 'MyCircle (int x) (int y) (int r))</pre>
+ <pre>
+    (gs:color-tag <em>sym-tag</em> <em>list-rgb</em> [<em>boolean-repaint</em>])
+    (gs:delete-tag <em>sym-tag</em>[<em>boolean-repaint</em>])
+    (gs:draw-arc <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-start</em> <em>int-angle</em> [<em>list-rgb</em>])
+    (gs:draw-circle <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius</em> [<em>list-rgb</em>])
+    (gs:draw-ellipse <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius-x</em> <em>int-radius-y</em> [<em>list-rgb</em>])
+    (gs:draw-image <em>sym-tag</em> <em>str-path</em> <em>int-x</em> <em>int-y</em> [<em>int-width</em> <em>int-height</em>])
+    (gs:draw-line <em>sym-tag</em> <em>int-x1</em> <em>int-y1</em> <em>int-x2</em> <em>int-y2</em> [<em>list-rgb</em>])
+    (gs:draw-path <em>sym-tag</em> <em>list-points</em> [<em>list-rgb</em>])
+    (gs:draw-polygon <em>sym-tag</em> <em>list-points</em> [<em>list-rgb</em>])
+    (gs:draw-rect <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> [<em>list-rgb</em>])
+    (gs:draw-round-rect <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-arc-width</em> <em>int-arc-height</em> [<em>list-rgb</em>])
+    (gs:draw-text <em>sym-tag</em> <em>str-text</em> <em>int-x</em> <em>int-y</em> [<em>list-rgb</em> [<em>float-angle</em>]])
+    (gs:export <em>str-path-file</em> [<em>int-width</em> <em>int-height</em>])
+    (gs:fill-arc <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-start</em> <em>int-angle</em> [<em>list-rgb</em>])
+    (gs:fill-circle <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius</em> [<em>list-rgb</em>])
+    (gs:fill-ellipse <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius-x</em> <em>int-radius-y</em> [<em>list-rgb</em>])
+    (gs:fill-polygon <em>sym-tag</em> <em>list-points</em> [<em>list-rgb</em>])
+    (gs:fill-rect <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> [<em>list-rgb</em>])
+    (gs:fill-round-rect <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-arc-width</em> <em>int-arc-height</em> [<em>list-rgb</em>])
+    (gs:hide-tag <em>sym-tag</em>  [<em>boolean-repaint</em>])
+    (gs:move-tag <em>sym-tag</em> <em>int-dx</em> <em>int-dy</em> [<em>boolean-repaint</em>])
+    (gs:reorder-tags <em>list-tags</em>)
+    (gs:rotate-tag <em>sym-tag</em> <em>float theta</em> <em>int-x</em> <em>int-y</em> [<em>boolean-repaint</em>])
+    (gs:save-text <em>sym-id</em> <em>str-path</em>)
+    (gs:scale-tag <em>sym-tag</em> <em>float-x</em> <em>float-y</em> [<em>boolean-repaint</em>])
+    (gs:shear-tag <em>sym-tag</em> <em>float-x</em> <em>float-y</em> [<em>boolean-repaint</em>])
+    (gs:show-popup <em>sym-tag</em> <em>sym-host</em> <em>int-x</em> <em>int-y</em>)
+    (gs:show-tag <em>sym-tag</em> [<em>boolean-repaint</em>])
+    (gs:set-canvas <em>sym-tag</em>)
+    (gs:set-paint <em>list-rgb</em>)
+    (gs:set-rotation <em>float-angle</em>)
+    (gs:set-scale <em>int-x</em> <em>int-y</em>)
+    (gs:set-stroke <em>float-width</em> [<em>str-cap</em> [<em>str-join</em> [<em>float-miterlimit</em>]]])
+    (gs:set-translation <em>int-x</em> <em>int-y</em>)
+    (gs:set-anti-aliasing <em>boolean-flag</em>)
+    (gs:translate-tag <em>sym-tag</em> <em>int-x</em> <em>int-y</em> [<em>boolean-repaint</em>])
+    (gs:update)
+ </pre>
+ </li>
+ <li><b>Events</b><br>
+ Additionally to the event actions registered when creating a widget,
+ the canvas, windows and dialogs can fire events as a result of key or mouse
+ actions or when the position or size of a windows or dialog has changed.
+ <pre>
+    (gs:key-event <em>sym-id</em> <em>sym-action</em>)
+    (gs:mouse-clicked <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])
+    (gs:mouse-dragged <em>sym-canvas</em> <em>sym-action</em>)
+    (gs:mouse-event <em>sym-id</em> <em>sym-action</em>)
+    (gs:mouse-moved <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])
+    (gs:mouse-pressed <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])
+    (gs:mouse-released <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])
+    (gs:mouse-wheel <em>sym-canvas</em> <em>sym-action</em>)
+    (gs:window-closed <em>sym-id</em> <em>sym-action</em>)
+    (gs:window-moved <em>sym-id</em> <em>sym-action</em>)
+    (gs:window-resized <em>sym-id</em> <em>sym-action</em>)
+ </pre>
+ </li>
+ <li><b>Built-in icons and images</b><br>
+ The <tt>guiserver.jar</tt> file has the following icons and images built in. Each of
+ them is prefixed with the path <tt>/local/</tt>. For example <tt>/local/newLISP128.png</tt>
+ addresses the newLISP logo of size 128x128. To address images outside of
+ <tt>guiserver.jar</tt>, use a normal file path suitable to your platform. On MS Windows
+ use forward slashes instead of backslashes.
+ <pre>
+ Image path
+ ----------
+ clear-down32.png
+ clear32.png
+ copy-down32.png
+ copy32.png
+ cut-down32.png
+ cut32.png
+ dotgray16.png
+ dotgray32.png
+ dotgreen16.png
+ dotgreen32.png
+ dotred16.png
+ dotred32.png
+ dotyellow16.png
+ dotyellow32.png
+ edit-down32.png
+ edit32.png
+ folder-closed-down32.png
+ folder-closed32.png
+ folder-opened-down32.png
+ folder-opened32.png
+ font-book-down32.png
+ font-book32.png
+ green10.png
+ info-down32.png
+ info32.png
+ new-down32.png
+ new32.png
+ newLISP-down32.png
+ newLISP128.png
+ newLISP16.png
+ newLISP20.png
+ newLISP32.png
+ newLISP64.png
+ newLISPsplashWin.png
+ paste-down32.png
+ paste32.png
+ pressedbutton32.png
+ red10.png
+ restart-down32.png
+ restart32.png
+ run-down32.png
+ run32.png
+ save-down32.png
+ save32.png
+ search-down32.png
+ search32.png
+ stop-down32.png
+ stop32.png
+ </pre>
+ <li><b>Predefined colors</b><br>
+ The following colors are predefined:
+ <pre>
+ Name          rgb components
+ ----          -------------- 
+ gs:black      (0.0 0.0 0.0)
+ gs:blue       (0.0 0.0 1.0)
+ gs:cyan       (0.0 1.0 1.0)
+ gs:darkGray   (0.2509804 0.2509804 0.2509804)
+ gs:gray       (0.5019608 0.5019608 0.5019608)
+ gs:green      (0.0 1.0 0.0)
+ gs:lightGray  (0.7529412 0.7529412 0.7529412)
+ gs:magenta    (1.0 0.0 1.0)
+ gs:orange     (1.0 0.78431374 0.0)
+ gs:pink       (1.0 0.6862745 0.6862745)
+ gs:red        (1.0 0.0 0.0)
+ gs:white      (1.0 1.0 1.0)
+ gs:yellow     (1.0 1.0 0.0)
+ </pre>
+ Colors in newLISP-GS can be specified as three (four with alpha component) single
+ numbers or as a list of the three RGB values followed by the alpha channel number.
+ <pre>
+ (gs:set-background 'aPanel gs:magenta
+ (gs:set-background 'aPanel 1.0 0 1
+ (gs:set-background 'aPanel '(1 0 1)
+ </pre>
+ All of the above statements will produce the same background color on the <tt>aPanel</tt>.
+<br/><br/>
+ <li><b>Sound  and MIDI API</b><br>
+ The newLISP-GS sound API uses the default saundbank and sound hardware installed 
+ on the platform newLISP-GS is running on. On Mac OS X nothing additional needs to be
+ installed. On MS Windows and some Unix platforms a soundbank file needs to be installed.
+ Soundbanks for the Java JRE can be obtained at:
+ <a href="http://java.sun.com/products/java-media/sound/soundbanks.html">http://java.sun.com/products/java-media/sound/soundbanks.html</a>  The demo files shipped with the newLISP-GS installation use the midsize soundbank. Other soundbanks
+ may require different naming of instruments in the <tt>gs:midi-patch</tt> statement. 
+<br/><br/>
+ The sound API is capable of playing of mutliple tracks at the same time
+ depending on the sound hardware installed on a specific platform. Mac OS X platforms
+ and most MS Windows platforms should be capable of playing 16 instruments (channels) at the
+ the same time 32 on parallel sounding tracks. newLISP GS supports 128 instruments of the
+ default soundbank installed.
+<br/><br/>
+ On Mac OS X and MS Windows channel 9 is a special channel sounding a different rythm 
+ instrument for all 128 different keys/notes.
+<br/><br/>
+ Basic capabilities of the sound API are shown in the demo files <tt>midi-demo.lsp</tt>
+ and <tt>midi2-demo.lsp</tt> in the <tt>/usr/local/share/newlisp/guiserver/</tt> or 
+ <tt>c:\Program files\newlisp\guiserver\</tt> directory.
+ <pre>
+    (gs:add-track <em>int channel</em><em>list-notes</em>)
+    (gs:channel-bend <em>int-channel</em> <em>bend</em>)
+    (gs:get-instruments)
+    (gs:instruments)
+    (gs:midi-bpm <em>int-bpm</em> [<em>int-resolution</em>])
+    (gs:midi-close)
+    (gs:midi-init [<em>str-file-path</em>])
+    (gs:midi-patch <em>int-instrument</em> [<em>int-channel</em>])
+    (gs:mute-track <em>int-track</em> <em>bool-on-off</em>)
+    (gs:play-note <em>int-key</em> [<em>int-duration</em> [<em>int-velocity</em> [<em>int-channel</em> [int-bend]]]])
+    (gs:play-sequence [<em>int-start-tick</em> [<em>int-loop-count</em> [<em>int-start-loop</em> [<em>int-end-loop</em>]]]])
+    (gs:save-sequence <em>str-file-path</em>)
+    (gs:stop-sequence)
+    (gs:play-sound <em>str-file-path</em>)
+ </pre>
+ </ul>
+
+
+
+
+
+
+
+	
+
+ <br><br><br>
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_add-list-item"></a><h3><font color=#CC0000>gs:add-list-item</font></h3>
+<b>syntax: (<font color=#CC0000>gs:add-list-item</font> <em>sym-list-combo</em> <em>str-text</em> [<em>str-text</em> ...])</b><br/>
+<b>parameter: </b><em>sym-list-combo</em> - The name of the combo box or list box to which text entries are added.<br/>
+<b>parameter: </b><em>str-text</em> - The text of the entry to be added.<br/>
+<br/><br/>
+ Items are added in the same sequence as they appear in the <tt>gs:add-list-item</tt> command and added to the
+ end of the existing list of items.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_add-separator"></a><h3><font color=#CC0000>gs:add-separator</font></h3>
+<b>syntax: (<font color=#CC0000>gs:add-separator</font> <em>sym-menu-tool-bar</em>)</b><br/>
+<b>parameter: </b><em>sym-menu-tool-bar</em> - The name of the tool bar or menu bar to which a spacer entry is added.<br/>
+<br/><br/>
+ Depending on the OS platform the separator may not be visible and only occupy space before the next 
+ component added to the tool or menu bar.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_add-track"></a><h3><font color=#CC0000>gs:add-track</font></h3>
+<b>syntax: (<font color=#CC0000>gs:add-track</font> <em>int-channel</em> <em>list-of-notes</em>)</b><br/>
+<b>parameter: </b><em>int-channel</em> - The channel belonging to this track.<br/>
+<b>parameter: </b><em>list-of-notes</em> - A list of notes. Each note is a list of key duration velocity and bend.<br/>
+<br/><br/>
+ In case of <tt>gs:add-track</tt> the duration of a note is given in ticks.
+ 16 ticks are in a quarter note or <em>beat</em>.
+<br/><br/>
+ A note is a list of 4 elements: <tt>(<em>int-key</em> <em>int-duration</em> <em>int-velocity</em> [<em>int-bend</em>])</tt>. <em>key</em>
+ <em>duration</em>, <em>velocity</em> and <em>bend</em> can be given as variables, which will be evaluated by
+ <tt>gs:add-track</tt>. The <em>int-bend</em>  parameter is optional and assumed as <tt>0</tt> if not
+ present. See the command <tt>gs:play-note</tt> for more information on the note bend parameter.
+ The following code is a complete example:
+<br/><br/>
+<b>Example:</b><blockquote><pre> (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+ (gs:init)
+ (gs:midi-init)
+
+ (map set '(C C# D D# E F F# G G# A A# B c c# d e f f# g g# a a# b) (sequence 60 82))
+ (set 'pp 30 'p 40 'm 64 'f 127) ; set velocity/volume
+
+ (gs:midi-patch "Piano" 0)
+ (gs:midi-patch "Pizzicato Strings" 1)
+ (gs:midi-patch "Woodblock" 2)
+
+ (gs:add-track 0 '( (C 12 m) (C# 4 m) (D 16 m) (c 16 f) (D 16 m)) )
+ (gs:add-track 1 (dup '(d 4 pp) 16))
+ (gs:add-track 2 '( (c 4 p) (c 12 p) (c 4 p) (c 12 p) (c 4 p) (c 12 p)  (c 4 p) (c 12 p)) )
+
+ (gs:play-sequence)
+
+ (sleep 5000)
+ (gs:midi-close)
+ (exit)</pre></blockquote>
+ The second example shows the usage of pitch-bend in notes:
+<br/><br/>
+<b>Example:</b><blockquote><pre> (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+ (gs:init)
+ (gs:midi-init)
+ 
+ (gs:midi-patch "Piano" 0)
+ (gs:midi-patch "Gunshot" 1)
+ (gs:midi-patch "Telephone" 2)
+ 
+ (for (n -8192 8191 128) (push (list 64 1 95 n) track0 -1))
+ (for (n 64 96 2) (push (list n 8 76) track1 -1))
+ 
+ (gs:add-track 0 track0)
+ (gs:add-track 1 track1)
+ (gs:add-track 2 '((44 128 127)))
+ 
+ (gs:play-sequence)
+ ;(gs:save-sequence "extremeAlarm.mid")
+ 
+ (sleep 8000)
+ (gs:midi-close)
+ (exit)</pre></blockquote>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_add-to"></a><h3><font color=#CC0000>gs:add-to</font></h3>
+<b>syntax: (<font color=#CC0000>gs:add-to</font> <em>sym-container</em> <em>sym-component</em> [<em>sym-componentl</em> ...])</b><br/>
+<b>parameter: </b><em>sym-container</em> - The name of the container to which components are added.<br/>
+<b>parameter: </b><em>sym-component</em> - One or more symbols of the components to add.<br/>
+
+
+<b>syntax: (<font color=#CC0000>gs:add-to</font> <em>sym-container</em> <em>sym-component</em> <em>str-orientation</em> [<em>sym-component</em> <em>str-orientation</em> ...])</b><br/>
+<b>parameter: </b><em>sym-container</em> - The name of the container to which components are added.<br/>
+<b>parameter: </b><em>sym-component</em> - The name of a component to add.<br/>
+<b>parameter: </b><em>str-orientation</em> - The orientation of a component to add in border layout, <tt>"north"</tt>, <tt>"west"</tt>, <tt>"center"</tt>, <tt>"east"</tt> or <tt>"south"</tt>.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_append-text"></a><h3><font color=#CC0000>gs:append-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:append-text</font> <em>sym-id</em> <em>str-text</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text field or text area to which text is appended.<br/>
+<b>parameter: </b><em>str-text</em> - The text to be appended.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_button"></a><h3><font color=#CC0000>gs:button</font></h3>
+<b>syntax: (<font color=#CC0000>gs:button</font> <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> [<em>int-width</em> <em>int-height</em>]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the button.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-text</em> - An optional text for the button.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the button.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the button.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_canvas"></a><h3><font color=#CC0000>gs:canvas</font></h3>
+<b>syntax: (<font color=#CC0000>gs:canvas</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the canvas.<br/>
+<br/><br/>
+ A canvas is a panel for drawing and receiving mouse input events. For most
+ applications a background color should be specified for the canvas using
+ <tt>gs:set-background</tt> or <tt>gs:set-color</tt> which call the same function internally. The
+ background forces the canvas to be cleared before redrawing components
+ which have been moved, rotated, scaled or deleted. In applications where
+ this is not desired but a background color is still required, the background
+ color can be specified for the container hosting the canvas. The canvas
+ background will then appear in the color of the container, but erasing
+ the canvas before repainting is not enforced.
+<br/><br/>
+ A canvas can also be used to host widgets like buttons etc.. In this case
+ the canvas is treated like a <tt>gs:panel</tt>, with a flow layout by default.
+ Similar to a panel created with <tt>gs:panel</tt> other layouts can be set.
+<br/><br/>
+ When widgets are present on a canvas they appear to be floating over
+ the drawing. See the file <tt>textrot-demo.lsp</tt> for an example.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_channel-bend"></a><h3><font color=#CC0000>gs:channel-bend</font></h3>
+<b>syntax: (<font color=#CC0000>gs:channel-bend</font> <em>int-channel</em> <em>bend</em>)</b><br/>
+<b>parameter: </b><em>int-channel</em> - The channel where the pitch bend is set.<br/>
+<b>parameter: </b><em>int-bend</em> - The channel bend between <tt>0</tt> and <tt>16383</tt>.<br/>
+<br/><br/>
+ Numbers upwards of <tt>8192</tt> bend the tone upwards, numbers smaller
+ than <tt>8192</tt> bend the tone downwards. To switch off channel bend set
+ the number to the middle posiotion of <tt>8192</tt>. <tt>gs:channel-bend</tt> can 
+ be used to bring a channel in tune with an external sound source.
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_check-box"></a><h3><font color=#CC0000>gs:check-box</font></h3>
+<b>syntax: (<font color=#CC0000>gs:check-box</font> <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> [<em>bool-selected</em>]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the check box.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-text</em> - The text of the check box.<br/>
+<b>parameter: </b><em>bool-selected</em> - An optional flag indicating the selection state <tt>true</tt> or <tt>nil</tt> (default).<br/>
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_check-event"></a><h3><font color=#CC0000>gs:check-event</font></h3>
+<b>syntax: (<font color=#CC0000>gs:check-event</font> <em>int-microseconds</em>)</b><br/>
+<b>parameter: </b><em>int-microseconds</em> - Wait for an event a maximum of <em>int-microseconds</em> and execute it.<br/>
+<br/><br/>
+ The function <tt>gs:check-event</tt> is used as an alternative to <tt>gs:listen</tt> when the application
+ is performing some activity while waiting for user input from the GUI. Typically
+ <tt>gs:check-event</tt> is used in a loop, which performs some other task and at the same time
+ checks for events from the GUI part of the application. Like <tt>gs:listen</tt> the function will 
+ force an exit of the application when communication between the newLISP-GS and the newLISP
+ application process fails. 
+<br/><br/>
+<b>Example:</b><blockquote><pre> (while (gs:check-event 10000) ; check for 10 milliseconds
+     (do-myprocess)
+ )</pre></blockquote>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_clear-list"></a><h3><font color=#CC0000>gs:clear-list</font></h3>
+<b>syntax: (<font color=#CC0000>gs:clear-list</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sum-id</em> - The name of the list component in which to clear all entries.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_clear-text"></a><h3><font color=#CC0000>gs:clear-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:clear-text</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sum-id</em> - The name of the component in which to clear the text.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_copy-text"></a><h3><font color=#CC0000>gs:copy-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:copy-text</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sum-id</em> - The name of the text component from which to copy the selection to the clipboard.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_cut-text"></a><h3><font color=#CC0000>gs:cut-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:cut-text</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id-text</em> - The name of the text component from which to cut selected text and place it on the clipboard..<br/>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_color-dialog"></a><h3><font color=#CC0000>gs:color-dialog</font></h3>
+<b>syntax: (<font color=#CC0000>gs:color-dialog</font> <em>sym-parent-frame</em> <em>sym-action</em> <em>str-title</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em>)</b><br/>
+<b>parameter: </b><em>sym-parent-frame</em> - The name symbol of the parent frame.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the handler to call when leaving the dialog<br/>
+<b>parameter: </b><em>str-title</em> - The title of the color dialog.<br/>
+<b>parameter: </b><em>float-red</em> - The initial red color component.<br/>
+<b>parameter: </b><em>float-green</em> - The initial green color component.<br/>
+<b>parameter: </b><em>float-blue</em> - The initial blue color component.<br/>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_color-tag"></a><h3><font color=#CC0000>gs:color-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:color-tag</font> <em>sym-tag</em> <em>list-color</em> [<em>boolean-update</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The name tag of the shape(s) to set a new color.<br/>
+<b>parameter: </b><em>list-color</em> - The new color as a list of 3 numbers for the rgb components.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_combo-box"></a><h3><font color=#CC0000>gs:combo-box</font></h3>
+<b>syntax: (<font color=#CC0000>gs:combo-box</font> <em>sym-id</em> <em>sym-action</em> [<em>str-item-1</em> ...])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the combo box.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-item</em> - Zero, one or more text entries in the combo box.<br/>
+<b>syntax: (<font color=#CC0000>gs:combo-box</font> <em>sym-id</em> <em>sym-action</em> [<em>list-str-items</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the combo box.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>list-str-items</em> - Zero, one or more text entries in a list.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_confirm-dialog"></a><h3><font color=#CC0000>gs:confirm-dialog</font></h3>
+<b>syntax: (<font color=#CC0000>gs:confirm-dialog</font> <em>sym-parent-frame</em> <em>sym-action</em> <em>str-title</em> <em>str-message</em> [<em>str-type</em>])</b><br/>
+<b>parameter: </b><em>sym-parent-frame</em> - The symbol name of the parent frame.<br/>
+<b>parameter: </b><em>sym-action</em> - The action to perform when the diaog is closed.<br/>
+<b>parameter: </b><em>str-title</em> - The title of the message box.<br/>
+<b>parameter: </b><em>str-message</em> - The message in the message box.<br/>
+<b>parameter: </b><em>str-type</em> - The type of the message box.<br/>
+<br/><br/>
+ The type of the message box can be one of: <tt>"yes-no"</tt>, <tt>"yes-no-cancel"</tt>
+ On return of the message box <em>sym-action</em> carries one of the responses <tt>0</tt> for the yes-,
+ <tt>1</tt> for the no- or <tt>2</tt> for the cancel-button.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_delete-tag"></a><h3><font color=#CC0000>gs:delete-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:delete-tag</font> <em>sym-tag</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group to be deleted.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+ Deletes all 2D objects (lines, shapes, text, images) tagged with <em>sym-tag</em>.
+<br/><br/>
+ Each time a <tt>gs:draw-xxx</tt> or <tt>gs:fill-xxx</tt> function is called a graphical
+ object is created. The tag used during creation is a way to address one
+ or more of these objects. See the file <tt>mouse-demo.lsp</tt> for an example.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_destroy-shell"></a><h3><font color=#CC0000>gs:destroy-shell</font></h3>
+<b>syntax: (<font color=#CC0000>gs:destroy-shell</font> <em>sym-text-area</em>)</b><br/>
+<b>parameter: </b><em>sym-text-area</em> - The name of the text component for which the shell process is destroyed.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_dialog"></a><h3><font color=#CC0000>gs:dialog</font></h3>
+<b>syntax: (<font color=#CC0000>gs:dialog</font> <em>sym-id</em> <em>sym-parent</em> <em>str-title</em> <em>int-width</em> <em>int-height</em> [<em>boolean-visible</em> [<em>boolean-modal</em>]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the dialog<br/>
+<b>parameter: </b><em>sym-parent</em> - The name of the parent frame.<br/>
+<b>parameter: </b><em>str-title</em> - The title string of the dialog frame.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the dialog frame.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the dialog frame.<br/>
+<b>parameter: </b><em>boolean-visible</em> - The optional flag with a value of <tt>true</tt> or <tt>nil</tt> for visibility of the dialog.<br/>
+<b>parameter: </b><em>boolean-modal</em> - The optional flag with a value of <tt>true</tt> or <tt>nil</tt> for modality of the dialog.<br/>
+<br/><br/>
+ Initially the dialog should not be visible until all widgets are added to it. 
+ When no flags for visibility and modality are specified, <tt>nil</tt> is assumed. A modal dialog will
+ prevent input in the parent window. Components can be added to a dialog using <tt>gs:add-to</tt>.
+ Use the <tt>gs:set-border-layout</tt>, <tt>ga:set-flow-layout</tt> or <tt>gs:set-grid-layout</tt> to set a specific
+ layout.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_disable"></a><h3><font color=#CC0000>gs:disable</font></h3>
+<b>syntax: (<font color=#CC0000>gs:disable</font> <em>sym-id-1</em> [sym-id-2 ...])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component to disable.<br/>
+<br/><br/>
+ Disabled components are grayed and do not accept input.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_dispose"></a><h3><font color=#CC0000>gs:dispose</font></h3>
+<b>syntax: (<font color=#CC0000>gs:dispose</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component to dispose of.<br/>
+<br/><br/>
+ Only objects created with <tt>gs:dialog</tt>, <tt>gs:frame</tt> or <tt>gs:window</tt> can be
+ deleted with <tt>gs:dispose</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_dispose-splash"></a><h3><font color=#CC0000>gs:dispose-splash</font></h3>
+<b>syntax: (<font color=#CC0000>gs:dispose-splash</font>)</b><br/>
+<br/><br/>
+ A splash screen can be specified when starting the newLISP-GS process before newLISP. 
+ The function <tt>gs:dispose-splash</tt> is used to turn off the splash image after
+ the newLISP GUI application has started.
+<br/><br/>
+<b>Example:</b><blockquote><pre> java -jar /usr/share/newlisp/guiserver.jar 64001 program.lsp /local/newLISP128.png
+ ; or on MS Windows
+ java -jar "c:\Program Files\newlisp\guiserver.jar" 64001 "newlisp program.lsp" /local/newLISPsplashWin.png</pre></blockquote>
+ The example starts newLISP-GS with an application <tt>program.lsp</tt> and a splash
+ screen showing the built-in newLISP logos and using port 64001/2. Instead, the full pathname 
+ of a different image file can be specified. Inside <tt>program.lsp</tt> the function
+ <tt>gs:dispose-splash</tt> or a mouse click on the image will turn off the splash screen. 
+ For <tt>program.lsp</tt> the full pathname may be necessary. On MS Windows quotes are necessary to bracket 
+ arguments to <tt>guiserver.jar</tt> which contain spaces. 
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-arc"></a><h3><font color=#CC0000>gs:draw-arc</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-arc</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-start</em> <em>int-angle</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the arc.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the arc.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the arc.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the arc.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the arc.<br/>
+<b>parameter: </b><em>int-start-angle</em> - The start angle of the arc in 0 to 360 degrees.<br/>
+<b>parameter: </b><em>int-arc-angle</em> - The opening angle of the arc in 0 to 360 degrees.<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components<br/>
+<br/><br/>
+ The resulting arc begins at <em>int-start-angle</em> and extends for <em>int-arc-angle degrees</em>, 
+ using the current color. Angles are interpreted such that 0 degrees is at the 3 o'clock 
+ position. A positive value indicates a counter-clockwise rotation while a negative value 
+ indicates a clockwise rotation.
+<br/><br/>
+ The center of the arc is the center of the rectangle whose origin is (x, y) and whose size 
+ is specified by the width and height arguments.
+<br/><br/>
+ The resulting arc covers an area <em>int-width</em> pixels wide by <em>int-height</em> pixels tall.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-circle"></a><h3><font color=#CC0000>gs:draw-circle</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-circle</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the circle.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the circle center.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the circle center.<br/>
+<b>parameter: </b><em>int-radius</em> - The radius of the circle.<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components<br/>
+<br/><br/>
+ Creates the outline of a circle. The color numbers must be entered in list form.
+ If no <em>list-rgb</em> is used the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-ellipse"></a><h3><font color=#CC0000>gs:draw-ellipse</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-ellipse</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius-x</em> <em>int-radius-y</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the ellipse.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the ellipse center.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the ellipse center.<br/>
+<b>parameter: </b><em>int-radius-x</em> - The radius of the ellipse.<br/>
+<b>parameter: </b><em>int-radius-y</em> - The radius of the ellipse.<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components<br/>
+<br/><br/>
+ Creates the outline of an ellipse. The color numbers must be enterd in list form.
+ If no <em>list-rgb</em> is used the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-image"></a><h3><font color=#CC0000>gs:draw-image</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-image</font> <em>sym-tag</em> <em>str-path</em> <em>int-x</em> <em>int-y</em> [<em>int-width</em> <em>int-height</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the image.<br/>
+<b>parameter: </b><em>str-path</em> - The file path-name of the image.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the image top left corner.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the image top left corner.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width in which to draw the image.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height in which to draw the image.<br/>
+<br/><br/>
+ When <em>int-width</em> and <em>int-height</em> parameters are specified and they are not
+ equal to the original size of the image (measured in pixels) the image will
+ be displayed in either compressed or zoomed form.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-line"></a><h3><font color=#CC0000>gs:draw-line</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-line</font> <em>sym-tag</em> <em>int-x1</em> <em>int-y1</em> <em>int-x2</em> <em>int-y2</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tage of the line.<br/>
+<b>parameter: </b><em>int-x1</em> - The X position of the first point.<br/>
+<b>parameter: </b><em>int-y1</em> - The Y position of the first point.<br/>
+<b>parameter: </b><em>int-x2</em> - The X position of the second point.<br/>
+<b>parameter: </b><em>int-y2</em> - The Y position of the second point.<br/>
+<br/><br/>
+ Draws a line. The color numbers must be entered in list form.
+ If no <em>list-rgb</em> is used the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-path"></a><h3><font color=#CC0000>gs:draw-path</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-path</font> <em>sym-tag</em> <em>list-points</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tage group of the path.<br/>
+<b>parameter: </b><em>list-points</em> - The list of x and y coordinates of the points.<br/>
+<br/><br/>
+ Draws a path with the points found in <em>list-points</em>. 
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:draw-path 'P '(1 0 2 2 3 0))</pre></blockquote>
+ The example will draw an upwards-pointing triangle without base at the 
+ points <tt>1,0</tt>, <tt>2,2</tt> and <tt>3,0</tt> 
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-polygon"></a><h3><font color=#CC0000>gs:draw-polygon</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-polygon</font> <em>sym-tag</em> <em>list-points</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the polygon.<br/>
+<b>parameter: </b><em>list-points</em> - The list of x and y coordinates of the points.<br/>
+<br/><br/>
+ Draws a polygon with the points found in <em>list-points</em>. 
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:draw-polygon 'P '(1 0 2 2 3 0))</pre></blockquote>
+ The example will draw an upwards-pointing triangle with the points <tt>1,0</tt>, <tt>2,2</tt>
+ and <tt>3,0</tt>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-rect"></a><h3><font color=#CC0000>gs:draw-rect</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-rect</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the rectangle.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the top left corner.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the top left corner.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the rectangle.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the rectangle..<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components<br/>
+<br/><br/>
+ Creates the outline of a rectangle. The color numbers must be entered in list form.
+ If no <em>list-rgb</em> is used the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-round-rect"></a><h3><font color=#CC0000>gs:draw-round-rect</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-round-rect</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-arc-width</em> <em>int-arc-height</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the round rectangle.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the top left corner.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the top left corner.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the rectangle.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the rectangle..<br/>
+<b>parameter: </b><em>int-arc-width</em> - The width of the corner rectangle.<br/>
+<b>parameter: </b><em>int-arc-height</em> - The height of the corner rectangle..<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components<br/>
+<br/><br/>
+ Draws a rectangle shape with round corners. The rounding is defined by the rectangle enclosing
+ the rounding arc.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_draw-text"></a><h3><font color=#CC0000>gs:draw-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:draw-text</font> <em>sym-tag</em> <em>str-text</em> <em>int-x</em> <em>int-y</em> [<em>list-rgb</em> [<em>float-angle</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the text.<br/>
+<b>parameter: </b><em>str-text</em> - The text to be drawn.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the text.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the text.<br/>
+<b>parameter: </b><em>list-rgb</em> - The optonal color for the text.<br/>
+<b>parameter: </b><em>float-angle</em> - The optional angle for text in degrees<br/>
+<br/><br/>
+ If no <em>list-rgb</em> is used, the current paint specified with <tt>gs:set-paint</tt> is used.
+ The optional angle is <tt>0</tt> by default for horizontal text. A value of <tt>90</tt>
+ will rotate the text around the <tt>x</tt>, <tt>y</tt> position downwards clockwise.
+
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_enable"></a><h3><font color=#CC0000>gs:enable</font></h3>
+<b>syntax: (<font color=#CC0000>gs:enable</font> <em>sym-id-1</em> [sym-id-2 ...])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of a component to enable.<br/>
+<br/><br/>
+ Components are enabled by default.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_eval-shell"></a><h3><font color=#CC0000>gs:eval-shell</font></h3>
+<b>syntax: (<font color=#CC0000>gs:eval-shell</font> <em>sym-id-text-area</em> <em>str-command</em>)</b><br/>
+<b>parameter: </b><em>sym-id-text-area</em> - The name of the text area in which to evaluate text.<br/>
+<b>parameter: </b><em>str-command</em> - The text to evaluate in the shell.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_export"></a><h3><font color=#CC0000>gs:export</font></h3>
+<b>syntax: (<font color=#CC0000>gs:export</font> <em>str-path-file</em> [<em>int-width</em> <em>int-height</em>])</b><br/>
+<b>parameter: </b><em>str-path-file</em> - The path and file name of the image file to write to.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the image in pixels.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the image in pixels.<br/>
+<br/><br/>
+ If no width and height are specified, the current size of the canvas is assumed.
+<br/><br/>
+<b>Example:</b><blockquote><pre>
+ (gs:export "/usr/home/pictures/mypic.png")</pre></blockquote>
+ This will generate a <tt>.png</tt> file exactly as the image seen on the screen.
+ The color format is RGBA with 8 bit per color and an alpha channel. When
+ no background color is defined for the canvas, the background will be
+ transparent.
+<br/><br/>
+ When specifying width and height, a smaller or bigger portion of the canvas
+ than seen on the screen is printed to the image.
+
+			
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_fill-arc"></a><h3><font color=#CC0000>gs:fill-arc</font></h3>
+<b>syntax: (<font color=#CC0000>gs:fill-arc</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-start</em> <em>int-angle</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the arc.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the arc.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the arc.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the arc.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the arc.<br/>
+<b>parameter: </b><em>int-start-angle</em> - The start angle of the arc in 0 to 360 degrees.<br/>
+<b>parameter: </b><em>int-arc-angle</em> - The opening angle of the arc in 0 to 360 degrees.<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components.<br/>
+<br/><br/>
+ The resulting arc begins at <em>int-start-angle</em> and extends for <em>int-arc-angle degrees</em>, 
+ using the current color. Angles are interpreted such that 0 degrees is at the 3 o'clock 
+ position. A positive value indicates a counter-clockwise rotation while a negative value 
+ indicates a clockwise rotation.
+<br/><br/>
+ The center of the arc is the center of the rectangle whose origin is (x, y) and whose size 
+ is specified by the width and height arguments.
+<br/><br/>
+ The resulting arc covers an area <em>int-width</em> pixels wide by <em>int-height</em> pixels tall.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_fill-circle"></a><h3><font color=#CC0000>gs:fill-circle</font></h3>
+<b>syntax: (<font color=#CC0000>gs:fill-circle</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the circle.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the circle center.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the circle center.<br/>
+<b>parameter: </b><em>int-radius</em> - The radius of the circle.<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components.<br/>
+<br/><br/>
+ Creates a filled  circle. The color numbers must be entered in list form.
+ If no <em>list-rgb</em> is used, the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_fill-ellipse"></a><h3><font color=#CC0000>gs:fill-ellipse</font></h3>
+<b>syntax: (<font color=#CC0000>gs:fill-ellipse</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-radius-x</em> <em>int-radius-y</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the ellipse.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the ellipse center.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the ellipse center.<br/>
+<b>parameter: </b><em>int-radius-x</em> - The radius of the ellipse.<br/>
+<b>parameter: </b><em>int-radius-y</em> - The radius of the ellipse.<br/>
+<b>parameter: </b><em>list-rgb</em> - The fill color as a list of 3 numbers for the rgb components.<br/>
+<br/><br/>
+ Creates a filled ellipse. The color numbers must be entered in list form.
+ If no <em>list-rgb</em> is used, the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_fill-polygon"></a><h3><font color=#CC0000>gs:fill-polygon</font></h3>
+<b>syntax: (<font color=#CC0000>gs:fill-polygon</font> <em>sym-tag</em> <em>list-points</em> [<em>list-color</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the polygon.<br/>
+<b>parameter: </b><em>list-points</em> - The list of x and y coordinates of the points.<br/>
+<br/><br/>
+ Draws a polygon with the points found in <em>list-points</em> and fills it with
+ the current color set with <tt>gs:set-paint</tt> or the optional color
+ given in <em>list-color</em>.
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:fill-polygon 'P '(1 0 2 2 3 0))
+
+ (gs:fill-polygon 'P '(1 0 2 2 3 0) gs:gray)</pre></blockquote>
+ The example will fill an upwards pointing triangle with the points <tt>1,0</tt>, <tt>2,2</tt>
+ and <tt>3,0</tt> and fill it with the current color set with <tt>gs:set-paint</tt>. The second
+ example paints a gray triangle regardless of the current color set with
+ <tt>gs:set-paint</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_fill-rect"></a><h3><font color=#CC0000>gs:fill-rect</font></h3>
+<b>syntax: (<font color=#CC0000>gs:fill-rect</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the rectangle.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the top left corner.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the top left corner.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the rectangle.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the rectangle.<br/>
+<b>parameter: </b><em>list-rgb</em> - The fill color as a list of 3 numbers for the rgb components.<br/>
+<br/><br/>
+ Creates a filled rectangle. The color numbers must be entered in list form.
+ If no <em>list-rgb</em> is used, the current paint specified with <tt>gs:set-paint</tt> is used.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_fill-round-rect"></a><h3><font color=#CC0000>gs:fill-round-rect</font></h3>
+<b>syntax: (<font color=#CC0000>gs:fill-round-rect</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> <em>int-arc-width</em> <em>int-arc-height</em> [<em>list-rgb</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group of the round rectangle.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the top left corner.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the top left corner.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the rectangle.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the rectangle..<br/>
+<b>parameter: </b><em>int-arc-width</em> - The width of the corner rectangle.<br/>
+<b>parameter: </b><em>int-arc-height</em> - The height of the corner rectangle.<br/>
+<b>parameter: </b><em>list-rgb</em> - The outline color as a list of 3 numbers for the rgb components.<br/>
+<br/><br/>
+ Paints a rectangle shape with round corners. The rounding is defined by the rectangle enclosing
+ the rounding arc.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_find-text"></a><h3><font color=#CC0000>gs:find-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:find-text</font> <em>sym-id</em> <em>str-text</em> <em>sym-action</em> [<em>str-direction</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text area or text pane.<br/>
+<b>parameter: </b><em>str-text</em> - The searching text.<br/>
+<b>parameter: </b><em>sym-action</em> - A optional action to peform after find-text.<br/>
+<b>parameter: </b><em>str-direction</em> - The optional direction string <tt>"next"</tt> (default) or <tt>"previous"</tt>.<br/>
+<br/><br/>
+ The text area or text pane will be searched starting at the current caret position
+ forward or backwards depending on the optional direction field. After the search
+ the found text is highlighted. If the optional <em>sym-action</em> is specified an event
+ containing the id of the text area or pane and found position or <tt>-1</tt> will be fired.
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_frame"></a><h3><font color=#CC0000>gs:frame</font></h3>
+<b>syntax: (<font color=#CC0000>gs:frame</font> <em>sym-id</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em> [<em>str-title</em> <em>boolean-visible</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the frame window.<br/>
+<b>parameter: </b><em>int-x</em> - The X position of the top left window corner.<br/>
+<b>parameter: </b><em>int-y</em> - The Y position of the top left windows corner.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the window frame.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the windows frame.<br/>
+<b>parameter: </b><em>str-title</em> - The optional title of the window.<br/>
+<b>parameter: </b><em>boolean-visible</em> - The optional flag with a value of <tt>true</tt> or <tt>nil</tt> for the visibility of the window.<br/>
+<br/><br/>
+ Initially the frame should not be visible until all widgets are added to it. 
+ When no flag for visibility is specified <tt>nil</tt> is assumed. The default layout of a frame behaves
+ like a grid layout with one cell. Use the <tt>set-flow-layout</tt>, <tt>set-border-layout</tt> and
+ <tt>set-grid-layout</tt> to change the layout.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-bounds"></a><h3><font color=#CC0000>gs:get-bounds</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-bounds</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the component for which to get the list of bounding values.<br/>
+<p><b>return: </b>The bounding list <tt>(<em>x</em> <em>y</em> <em>width</em> <em>height</em>)</tt></p>
+ 
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-fonts"></a><h3><font color=#CC0000>gs:get-fonts</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-fonts</font>)</b><br/>
+<p><b>return: </b>A list of family names for fonts on the current system.</p>
+<br/><br/>
+ The function should be called only once because it may take considerable
+ time in a system loaded with many fonts. The variable <tt>gs:fonts</tt> contains
+ the same list of fonts originally returned by a call to <tt>gs:get-fonts</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-font-metrics"></a><h3><font color=#CC0000>gs:get-font-metrics</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-font-metrics</font> <em>sym-id</em> <em>str-text</em>)</b><br/>
+<p><b>return: </b>A list of the two values for width and height in pixels.</p>
+<br/><br/>
+ The font metrics for the currently set font in <em>sym-id</em> are returned as a list
+ of width and height in pixels when displaying the string in <em>str-text</em>.
+ After the function call the variable <tt>gs:font-metrics</tt> contains the same list
+ of values as originally returned by the call to <tt>gs:get-font-metrics</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-instruments"></a><h3><font color=#CC0000>gs:get-instruments</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-instruments</font>)</b><br/>
+<p><b>return: </b>A list of instrument names in the default MIDI soundbank.</p>
+<br/><br/>
+ The function should be called only once because it may take considerable
+ time in a system loaded with a big soundbank. The variable <tt>gs:instruments</tt> contains
+ the same list of instruments originally returned by a call to <tt>gs:get-instruments</tt>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-screen"></a><h3><font color=#CC0000>gs:get-screen</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-screen</font>)</b><br/>
+<p><b>return: </b>A list of screen width, height and resolution of the main computer screen.</p>
+<br/><br/>
+ After calling the <tt>gs:get-screen</tt> once the screen parameters are also available
+ in the variable <tt>gs:screen</tt>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-selected-text"></a><h3><font color=#CC0000>gs:get-selected-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-selected-text</font> <em>sym-id</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component from which to get the selected text.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the event handler which will receive the selected text.<br/>
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-text"></a><h3><font color=#CC0000>gs:get-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-text</font> <em>sym-id</em> [<em>sym-action</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component from which to get the text.<br/>
+<b>parameter: </b><em>sym-action</em> - The optional symbol of the event handler which will receive the text.<br/>
+<br/><br/>
+ If no <em>sym-action</em> is specified the function will block until the text is returned. 
+ After return the text is also available in the variable <tt>gs:text</tt>.
+ If <em>sym-action</em> is specified the function will return immediately and a <em>sym-action</em> event 
+ is fired containing the text. 
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-text-position"></a><h3><font color=#CC0000>gs:get-text-position</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-text-position</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text component for which the line and column position is returned.<br/>
+<p><b>return: </b>A list of line and column position of the text caret.</p>
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_get-version"></a><h3><font color=#CC0000>gs:get-version</font></h3>
+<b>syntax: (<font color=#CC0000>gs:get-version</font>)</b><br/>
+<p><b>return: </b>The version of newLISP-GS running.</p>
+<br/><br/>
+ After calling the <tt>gs:get-version</tt> once the version number is also
+ available in <tt>gs:version</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_goto-text"></a><h3><font color=#CC0000>gs:goto-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:goto-text</font> <em>sym-id</em> <em>int-row</em> <em>int-column</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text widget.<br/>
+<b>parameter: </b><em>int-row</em> - The row number where to place the cursor.<br/>
+<b>parameter: </b><em>int-column</em> - The column number where to place the cursor.<br/>
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_hide-tag"></a><h3><font color=#CC0000>gs:hide-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:hide-tag</font> <em>sym-tag</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag of the group to hide.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_image-button"></a><h3><font color=#CC0000>gs:image-button</font></h3>
+<b>syntax: (<font color=#CC0000>gs:image-button</font> <em>sym-id</em> <em>sym-action</em> <em>str-icon-path</em> [<em>str-down-icon-path</em> [<em>int-width</em> <em>int-height</em>]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the image button.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-icon-path</em> - The path for an image icon.<br/>
+<b>parameter: </b><em>str-down-icon-path</em> - The path for a pressed down image icon.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the image button.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the image button.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_image-label"></a><h3><font color=#CC0000>gs:image-label</font></h3>
+<b>syntax: (<font color=#CC0000>gs:image-label</font> <em>sym-id</em> <em>str-icon-path</em> [<em>str-align</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the label.<br/>
+<b>parameter: </b><em>str-ucon-path</em> - A string with the icon file path.<br/>
+<b>parameter: </b><em>str-align</em> - An optional alignment <tt>"left"</tt>, <tt>"center"</tt> or <tt>"right"</tt>, <tt>"leading"</tt>, <tt>"trailing"</tt>, <tt>"bottom"</tt> or <tt>"top"</tt>.<br/>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_init"></a><h3><font color=#CC0000>gs:init</font></h3>
+<b>syntax: (<font color=#CC0000>gs:init</font> [<em>int-port</em> <em>str-host</em> [bool-manual]])</b><br/>
+<b>parameter: </b><em>int-port</em> - The optional guiserver server port.<br/>
+<b>parameter: </b><em>str-host</em> - The optional remote host of the guiserver.<br/>
+
+
+
+
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_insert-list-item"></a><h3><font color=#CC0000>gs:insert-list-item</font></h3>
+<b>syntax: (<font color=#CC0000>gs:insert-list-item</font> <em>sym-list-combo</em> <em>str-text</em> <em>int-index</em> [<em>str-text</em> <em>int-index</em>])</b><br/>
+<b>parameter: </b><em>sym-list-combo</em> - The name of the combo box or list box from which entries are removed.<br/>
+<b>parameter: </b><em>str-text</em> - The text of the list or combo box item to insert.<br/>
+<b>parameter: </b><em>int-index</em> - The index of an entry to add to the list or combo box.<br/>
+<br/><br/>
+ When specifying an index of <tt>0</tt> the first item gets inserted at the beginning. 
+ When specifying an index equal or greater to the number of items in the list, the item 
+ is added at the end.
+
+		
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_insert-tab"></a><h3><font color=#CC0000>gs:insert-tab</font></h3>
+<b>syntax: (<font color=#CC0000>gs:insert-tab</font> <em>sym-tabbed-pane</em> <em>sym-component</em> [<em>str-text</em> [<em>int-index</em> [<em>str-icon-path</em>]]])</b><br/>
+<b>parameter: </b><em>sym-tabbed-pane</em> - The name of the tabbed pane.<br/>
+<b>parameter: </b><em>sym-component</em> - The name of the component to insert as a tab.<br/>
+<b>parameter: </b><em>str-text</em> - The optional text on the tab.<br/>
+<b>parameter: </b><em>int-index</em> - The optional index where to insert the new tab.<br/>
+<b>parameter: </b><em>str-icon-path</em> - The file path to an optional icon.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_insert-text"></a><h3><font color=#CC0000>gs:insert-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:insert-text</font> <em>sym-id</em> <em>str-text</em> <em>int-position</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text component.<br/>
+<b>parameter: </b><em>str-text</em> - The text to insert.<br/>
+<b>parameter: </b><em>int-position</em> - The offset position where to insert the text.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_key-event"></a><h3><font color=#CC0000>gs:key-event</font></h3>
+<b>syntax: (<font color=#CC0000>gs:key-event</font> <em>sym-id</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the component to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+<br/><br/>
+ <tt>gs:key-event</tt> can be used to register a general unspecific key event handler
+ for any component in the system. Since version 1.05 of newLISP-GS this also
+ includes text widgets, which already handle key events using their normal event 
+ handler function. With <tt>gs:key-event</tt> a second handler function can be registered
+ for text widgets. Both functions will fire on their respective events.
+<br/><br/>
+ Components respond to the following key event types: <tt>"pressed"</tt>, <tt>"released"</tt>, <tt>"typed"</tt>.
+<br/><br/>
+<b>Example:</b><blockquote><pre>
+ (define (key-action id type code modifiers)
+     (println "id:" id " type:" type " key code:" code " modifiers:" modifiers)
+ )</pre></blockquote>
+ The example shows a handler which prints all key event parameters to the terminal/shell
+ window where the applicaton was started.
+<br/><br/>
+ In order for key events to work, the component for which a key action handler
+ is registered must have the input focus. Use <tt>"gs:request-focus"</tt> to set the
+ input focus for the component.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_label"></a><h3><font color=#CC0000>gs:label</font></h3>
+<b>syntax: (<font color=#CC0000>gs:label</font> <em>sym-id</em> <em>str-text</em> [<em>str-align</em> [<em>int-width</em> <em>int-height</em>]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the label.<br/>
+<b>parameter: </b><em>str-text</em> - The text to appear on the label.<br/>
+<b>parameter: </b><em>str-align</em> - The optional alignment of the text.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the label.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the label.<br/>
+<br/><br/>
+ The following alignment constants can be supplied: <tt>"left"</tt>, <tt>"center"</tt>, '"right"",
+ <tt>"leading"</tt>, <tt>"trailing"</tt>, <tt>"bottom"</tt> and "<tt>top</tt>". By default each label text is
+ <tt>"center"</tt> aligned.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_layout"></a><h3><font color=#CC0000>gs:layout</font></h3>
+<b>syntax: (<font color=#CC0000>gs:layout</font> <em>sym-container</em>)</b><br/>
+<b>parameter: </b><em>sym-container</em> - The id of the container to lay out.<br/>
+<br/><br/>
+ Forces the container to lay out its components again, e.g. after a <tt>gs:add-to</tt> or <tt>gs:remove-from</tt>
+ when the container was already visible.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_load-text"></a><h3><font color=#CC0000>gs:load-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:load-text</font> <em>sym-id</em> <em>str-path</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the <tt>gs:text-pane</tt>.<br/>
+<b>parameter: </b><em>str-path</em> - The full path name of the file to load.<br/>
+<br/><br/>
+ <tt>gs:load-text</tt> will load text into a <tt>gs:text-pane</tt> directly by specifying
+ the path name. During loading, CR-LF line terminators are automatically
+ translated to LF-only line terminators by stripping all CRs from the file. All internal
+ operations of guiserver on text assume LF as a line terminator.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_listen"></a><h3><font color=#CC0000>gs:listen</font></h3>
+<b>syntax: (<font color=#CC0000>gs:listen</font> [<em>boolean-flag</em>])</b><br/>
+<b>parameter: </b><em>boolean-flag</em> - Prevent exit on loss of communication.<br/>
+<p><b>return: </b>Never returns. Exits the application when the guiserver exits, except when <em>boolean-flag</em> is <tt>true</tt>.</p>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_list-box"></a><h3><font color=#CC0000>gs:list-box</font></h3>
+<b>syntax: (<font color=#CC0000>gs:list-box</font> <em>sym-id</em> <em>sym-action</em> [<em>str-item-1</em> ...])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the list box.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-item</em> - Zero, one or more text entries in the list box.<br/>
+<b>syntax: (<font color=#CC0000>gs:list-box</font> <em>sym-id</em> <em>sym-action</em> [<em>list-str-items</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the list box.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>list-str-items</em> - Zero, one or more text entries in a list.<br/>
+
+ The listbox when clicked with the mouse, or when the [enter] key is
+ presses, will pass the following parameters to the event handler:
+ <br><br>
+ <em>id</em> - the id string of the list box<br>
+ <em>index</em> - the zero offset index of the highlighted listbox entry<br>
+ <em>item</em> - the string of the highlighted listbox entry<br>
+ <em>click-count</em> - the number of times the mouse has been clicked<br>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_message-dialog"></a><h3><font color=#CC0000>gs:message-dialog</font></h3>
+<b>syntax: (<font color=#CC0000>gs:message-dialog</font> <em>sym-parent-frame</em> <em>str-title</em> <em>str-message</em> [<em>str-type</em> [<em>str-icon-path</em>]])</b><br/>
+<b>parameter: </b><em>sym-parent-frame</em> - The symbol name of the parent frame.<br/>
+<b>parameter: </b><em>str-title</em> - The title of the message box.<br/>
+<b>parameter: </b><em>str-message</em> - The message in the message box.<br/>
+<b>parameter: </b><em>str-type</em> - The type of the message box.<br/>
+<b>parameter: </b><em>str-icon-path</em> - The optional path for an icon.<br/>
+<br/><br/>
+ The type of the message box can be one of: <tt>"error"</tt>, <tt>"information"</tt>, <tt>"warning"</tt>, <tt>"question"</tt>, <tt>"plain"</tt>.
+ The function initiating the message-dialog will return when the dialog is closed.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_menu"></a><h3><font color=#CC0000>gs:menu</font></h3>
+<b>syntax: (<font color=#CC0000>gs:menu</font> <em>sym-id</em> <em>str-text</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the menu.<br/>
+<b>parameter: </b><em>str-text</em> - The title string of the menu.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_menu-popup"></a><h3><font color=#CC0000>gs:menu-popup</font></h3>
+<b>syntax: (<font color=#CC0000>gs:menu-popup</font> <em>sym-id</em> <em>str-text</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the menu.<br/>
+<b>parameter: </b><em>str-text</em> - The title string of the menu.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_menu-bar"></a><h3><font color=#CC0000>gs:menu-bar</font></h3>
+<b>syntax: (<font color=#CC0000>gs:menu-bar</font> <em>sym-frame</em> [<em>sym-menu-1</em> ...])</b><br/>
+<b>parameter: </b><em>sym-frame</em> - The name of the frame hosting the menu bar.<br/>
+<b>parameter: </b><em>sym-menu</em> - Zero or more symbol names of menus to be positioned on the menu bar.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_menu-item"></a><h3><font color=#CC0000>gs:menu-item</font></h3>
+<b>syntax: (<font color=#CC0000>gs:menu-item</font> <em>sym-id</em> <em>sym-action</em> <em>str-text</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the menu item.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-text</em> - The text to appear for the menu item.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_menu-item-check"></a><h3><font color=#CC0000>gs:menu-item-check</font></h3>
+<b>syntax: (<font color=#CC0000>gs:menu-item-check</font> <em>sym-id</em> <em>sym-action</em> <em>str-text</em> [<em>bool-selected</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the menu item.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-text</em> - The text to appear for the menu item.<br/>
+<b>parameter: </b><em>bool-selected</em> - An optional flag indicating the selection state <tt>true</tt> or <tt>nil</tt> (default).<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_midi-bpm"></a><h3><font color=#CC0000>gs:midi-bpm</font></h3>
+<b>syntax: (<font color=#CC0000>gs:midi-bpm</font> [<em>int-bpm</em> [<em>int-resolution</em>]]])</b><br/>
+<b>parameter: </b><em>int-bpm</em> - Beats per minute pay speed. Default is 120 BPM.<br/>
+<b>parameter: </b><em>int-resolution</em> - Ticks per beat. Deafult is 16 ticks per beat;<br/>
+<br/><br/>
+ Sets the speed of playing a notes with with either <tt>gs:play-note</tt> or playing a 
+ sequence with <tt>gs:play-sequence</tt> in beats per minute (BPM).
+<br/><br/>
+ Before using <tt>gs:midi-bpm</tt> the default speed is set to 120 BPM, which corresponds
+ to two beats per second, where each beat corresponds to a quarter note of 16 ticks
+ default resolution.
+<br/><br/>
+ While the BPM parameter controls the play-back speed of the sequencer, the
+ resolution is a parameter of the sequence creation itself and must be set before
+ the first <tt>gs:add-track</tt> call.
+<br/><br/>
+ The preset resolution of 16 ticks per quarter note is the highest which can be set
+ and should be sufficient for all applications.
+
+	
+
+
+
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_midi-close"></a><h3><font color=#CC0000>gs:midi-close</font></h3>
+<b>syntax: (<font color=#CC0000>gs:midi-close</font>)</b><br/>
+<br/><br/>
+ Shut down the MIDI subsystem.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_midi-init"></a><h3><font color=#CC0000>gs:midi-init</font></h3>
+<b>syntax: (<font color=#CC0000>gs:midi-init</font> [<em>str-file-path</em>])</b><br/>
+<b>parameter: </b><em>str-file-path</em> - The optional file path for a soundbank file.<br/>
+<br/><br/>
+ Initialize the MIDI subsystem. If a soundbank file is specified load it,
+ else load the built-in synthesizer's default soundbank.
+<br/><br/>
+ When not using the default soundbank, the function <tt>gs:get-instruments</tt>
+ should be used first to find out the correct naming of instruments
+ for the <tt>gs:midi-patch</tt> statements. The soundbank used for testing the
+ demo files <tt>midi-demo.lsp</tt> and <tt>midi2-demo.lsp</tt> on Windows is the midsize
+ soundbank available here:
+ <a href="http://java.sun.com/products/java-media/sound/soundbanks.html">http://java.sun.com/products/java-media/sound/soundbanks.html</a>  This soundbank has equivalent named instruments to those used in the Mac OS X default JRE installation.
+ Currently only the first 128 instruments in a soundbank are accessed by newLISP-GS.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_midi-patch"></a><h3><font color=#CC0000>gs:midi-patch</font></h3>
+<b>syntax: (<font color=#CC0000>gs:midi-patch</font> <em>str-instrument</em> [<em>int-channel</em>])</b><br/>
+<b>parameter: </b><em>str-instrument</em> - The name of the instrument to attach to a channel.<br/>
+<b>parameter: </b><em>int-channel</em> - The channel for the instrument, default is <tt>0</tt>.<br/>
+<br/><br/>
+ An instrument from the current soundbank is attached to a
+ specific channel or to channel <tt>0</tt> if no channel is specified.
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:midi-patch (find "Electric Grand" gs:instruments) 0)</pre></blockquote>
+ In order for the <tt>gs:instruments</tt> variable to contain a list of instruments,
+ <tt>gs:get-instruments</tt> must have been called earlier, i.e. after <tt>gs:midi-init</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-clicked"></a><h3><font color=#CC0000>gs:mouse-clicked</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-clicked</font> <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])</b><br/>
+<b>parameter: </b><em>sym-canvas</em> - The id of the canvas to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+<b>parameter: </b><em>boolean-tags</em> - A <tt>true</tt> to indicate checking for tags.<br/>
+<br/><br/>
+ If <em>boolean-tags</em> is <tt>true</tt>, the action event will carry a list of
+ all tags which contained the X,Y coordinates of the mouse.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-dragged"></a><h3><font color=#CC0000>gs:mouse-dragged</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-dragged</font> <em>sym-canvas</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-canvas</em> - The id of the canvas to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-event"></a><h3><font color=#CC0000>gs:mouse-event</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-event</font> <em>sym-id</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the component to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+<br/><br/>
+ <tt>gs:mouse-event</tt> can be used to register a general unspecific mouse event handler
+ for any component in the system. Components respond to the following types:
+ <tt>"pressed"</tt>, <tt>"released"</tt>, <tt>"clicked"</tt>,
+<br/><br/>
+<b>Example:</b><blockquote><pre>
+ (define (mouse-action id type x y button cnt mods)
+     (println "id:" id " type:" type " x:" x " y:" y " button:" button " count:" cnt " mods:" mods)
+ )</pre></blockquote>
+ The example shows a handler which prints all mouse event parameters to the terminal/shell
+ window where the applicaton was started.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-moved"></a><h3><font color=#CC0000>gs:mouse-moved</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-moved</font> <em>sym-canvas</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-canvas</em> - The id of the canvas to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+<b>parameter: </b><em>boolean-tags</em> - A <tt>true</tt> to indicate checking for tags.<br/>
+<br/><br/>
+ If <em>boolean-tags</em> is <tt>true</tt>, the action event will carry a list of
+ all tags which contained the X,Y coordinates of the mouse.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-pressed"></a><h3><font color=#CC0000>gs:mouse-pressed</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-pressed</font> <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])</b><br/>
+<b>parameter: </b><em>sym-canvas</em> - The id of the canvas to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+<b>parameter: </b><em>boolean-tags</em> - A <tt>true</tt> to indicate checking for tags.<br/>
+<br/><br/>
+ If <em>boolean-tags</em> is <tt>true</tt>, the action event will carry a list of
+ all tags which contained the X,Y coordinates of the mouse.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-released"></a><h3><font color=#CC0000>gs:mouse-released</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-released</font> <em>sym-canvas</em> <em>sym-action</em> [<em>boolean-tags</em>])</b><br/>
+<b>parameter: </b><em>sym-canvas</em> - The id of the canvas to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+<b>parameter: </b><em>boolean-tags</em> - A <tt>true</tt> to indicate checking for tags.<br/>
+<br/><br/>
+ If <em>boolean-tags</em> is <tt>true</tt>, the action event will carry a list of
+ all tags which contained the X,Y coordinates of the mouse.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mouse-wheel"></a><h3><font color=#CC0000>gs:mouse-wheel</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mouse-wheel</font> <em>sym-canvas</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-canvas</em> - The id of the canvas to register the action handler.<br/>
+<b>parameter: </b><em>sym-action</em> - The symbol of the action handler.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_move-tag"></a><h3><font color=#CC0000>gs:move-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:move-tag</font> <em>sym-tag</em> <em>int-dx</em> <em>int-dy</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag of the group of objects to move.<br/>
+<b>parameter: </b><em>int-dx</em> - The distance to move on the X-axis.<br/>
+<b>parameter: </b><em>int-dy</em> - The distance to move on the Y-axis.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+ <tt>gs:move-tag</tt> is the only tag operation which actually changes the 
+ internal data of a drawn object. All other tag operations like
+ <tt>gs:translate-tag</tt>, <tt>gs:scale-tag</tt>, <tt>gs:rotate-tag</tt> and <tt>gs:shear-tag</tt>
+ will transform object coordinates only for drawing.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_mute-track"></a><h3><font color=#CC0000>gs:mute-track</font></h3>
+<b>syntax: (<font color=#CC0000>gs:mute-track</font> <em>int-number</em> [<em>boolean-on-off</em>])</b><br/>
+<b>parameter: </b><em>int-number</em> - The number of the track starting with <tt>0</tt> for the first. Default is <tt>true</tt>.<br/>
+<b>parameter: </b><em>boolean-on-off</em> - The track will be muted with a value of <tt>true</tt><br/>
+<br/><br/>
+ Any other value than <tt>true</tt> will unmute the track again. Muting tracks is practical
+ during music development. The track can only be muted when th sequence has benn started
+ using <tt>gs:play-sequence</tt>. To completely mute a track the <tt>gs:mute-track</tt> statement should
+ come right after the <tt>gs:play-sequece</tt> statement. 
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_no-action"></a><h3><font color=#CC0000>gs:no-action</font></h3>
+<b>syntax: (<font color=#CC0000>gs:no-action</font>)</b><br/>
+<br/><br/>
+ Specify as <em>sym-action</em> for widgets where no action handler is defined.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_open-file-dialog"></a><h3><font color=#CC0000>gs:open-file-dialog</font></h3>
+<b>syntax: (<font color=#CC0000>gs:open-file-dialog</font> <em>sym-parent-frame</em> <em>sym-action</em> [<em>str-directory</em> [<em>str-mask</em> <em>str-description</em>]])</b><br/>
+<b>parameter: </b><em>sym-parent-frame</em> - The parent frame of the file dialog.<br/>
+<b>parameter: </b><em>sym-action</em> - The handler function symbol.<br/>
+<b>parameter: </b><em>str-directory</em> - The initial directory to show.<br/>
+<b>parameter: </b><em>str-mask</em> - An optonal string mask.<br/>
+<b>parameter: </b><em>str-description</em> - An optional mask description.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_panel"></a><h3><font color=#CC0000>gs:panel</font></h3>
+<b>syntax: (<font color=#CC0000>gs:panel</font> <em>sym-id</em> [<em>int-width</em> <em>int-height</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the panel.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the panel.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the panel.<br/>
+<br/><br/>
+ Panels have a flow layout by default. In a flow layout an unsized button will
+ assume the natural size necessary to display the text on it.
+ To change the layout use the <tt>set-flow-layout</tt> or <tt>set-grid-layout</tt> functions.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_paste-text"></a><h3><font color=#CC0000>gs:paste-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:paste-text</font> <em>sym-id</em> [<em>str-text</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text component in which to paste text.<br/>
+<b>parameter: </b><em>str-text</em> - An optional text string to paste instead of the clipboard contents.<br/>
+<br/><br/>
+ If the <em>sym-id</em> contains selected text, this text gets replaced,
+ otherwise the text is inserted at the current caret position.
+ If no text is given in <em>str-text</em>, the text is taken from the clipboard.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_play-note"></a><h3><font color=#CC0000>gs:play-note</font></h3>
+<b>syntax: (<font color=#CC0000>gs:play-note</font> <em>int-key</em> [<em>int-duration</em> [<em>int-velocity</em> [<em>int-channel</em> [<em>int-bend</em>]]]])</b><br/>
+<b>parameter: </b><em>int-key</em> - The note or midi key <tt>0</tt> to <tt>127</tt>.<br/>
+<b>parameter: </b><em>int-duration</em> - The duration of the note in ticks, default is <tt>16</tt> for one beat or quarter note.<br/>
+<b>parameter: </b><em>int-velocity</em> - The velocity/volume of the note between <tt>0</tt> and <tt>127</tt>, default is <tt>64</tt>.<br/>
+<b>parameter: </b><em>int-channel</em> - The channel through which to play the note from <tt>0</tt> to <tt>15</tt>, default is <tt>0</tt>.<br/>
+<b>parameter: </b><em>int-bend</em> - The optional note bend to tune the note lower or higher from <tt>-8192</tt> to <tt>8191</tt>.<br/>
+<br/><br/>
+ Before using <tt>gs:play-note</tt>, <tt>gs:midi-init</tt> should be used to initialize the MIDI system.
+ The key of the note increases in half-tone steps. The key 60 corresponds to a Middle-C.
+ The velocity of the note is usually it's volume and/or brightness, i.e. the speed with which 
+ a key was pressed on an instrument. The channel is <tt>0</tt> by default and assigned to
+ a Piano instrument unless the function <tt>gs:midi-patch</tt> has been used to change assignment
+ to a different instrument.
+<br/><br/>
+ On Windows and some Linux or other UNIX no MIDI soundbank files are installed by default. Goto 
+ <a href="http://java.sun.com/products/java-media/sound/soundbanks.html">http://java.sun.com/products/java-media/sound/soundbanks.html</a>  for instructions how to download and install a soundbank. For the demo files <tt>mide-demo.lsp</tt> and
+ <tt>midi2-demo</tt> the midsize quality soundbank was used. On Mac OS X a soundbank is installed by default.
+ The default for the bend parameer is <tt>0</tt> for no bend. Negative values down to <tt>-8192</tt>
+ tune the note lower. Positive values up to <tt>8191</tt> tune the note higher. 
+ The following code is a complete example:
+<br/><br/>
+<b>Example:</b><blockquote><pre> ; load Guiserver
+ (load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+ (gs:init)
+
+ ; play a chromatic scale on the default instrument (piano)
+ ; each note a 16th note of 4 ticks and a moderate volume 
+
+ (gs:midi-init)
+ (gs:midi-patch "Piano" 0)
+ (for (key 24 95) (gs:play-note key 4 95 0))
+ (sleep 2000) ; wait until playing has finished
+ (gs:midi-close)
+</pre></blockquote>
+ The second example demonstrated usage of the <em>int-bend</em> parameter:
+<br/><br/>
+<b>Example:</b><blockquote><pre> ; play the same note but with different bends below and above the note
+ (gs:midi-patch "Violin" 0)
+ (for (bend -2024 2024 128)
+     (gs:play-note 80 1 95 0 bend))</pre></blockquote>
+ To play polyphone music of multiple parallel tracks see the function <tt>gs:add-track</tt> for
+ a complete code example.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_play-sequence"></a><h3><font color=#CC0000>gs:play-sequence</font></h3>
+<b>syntax: (<font color=#CC0000>gs:play-sequence</font> [<em>int-start</em> [<em>int-loop-count</em> [<em>int-start-loop</em> [<em>int-end-loop</em>]]])</b><br/>
+<b>parameter: </b><em>int-start</em> - The starting point in the sequence in ticks. Default is <tt>0</tt> for the beginning.<br/>
+<b>parameter: </b><em>int-loop-count</em> - The number of repetitions for looping. Default is <tt>0</tt> for no looping.<br/>
+<b>parameter: </b><em>int-start-loop</em> - The start of the loop to play in ticks. Default is <tt>0</tt>.<br/>
+<b>parameter: </b><em>int-end-loop</em> - The end of the loop in ticks. Default is <tt>-1</tt> for the end.<br/>
+<br/><br/>
+ All parameters are optional. When no parameters are given all tracks in the sequence are
+ sequenced from start to end with no repetiton (loop count of 0). Note that the start-loop and
+ end-loop positions refer only to loop played after playing the full track. After the sequence
+ started playing <tt>gs:stop-sequence</tt> can be used to stop it at any time. The midi system
+ should not be closed using <tt>gs:midi-close</tt> before playing has finished or playing will
+ be cut off.
+<br/><br/>
+ See the function <tt>gs:add-track</tt> for complete code example.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_play-sound"></a><h3><font color=#CC0000>gs:play-sound</font></h3>
+<b>syntax: (<font color=#CC0000>gs:play-sound</font> <em>str-file-path</em>)</b><br/>
+<b>parameter: </b><em>str-file-path</em> - The path and file name of the sound file.<br/>
+<br/><br/>
+ On most OS platforms <tt>.au</tt> and <tt>.wav</tt> sound file formats are supported.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_progress-bar"></a><h3><font color=#CC0000>gs:progress-bar</font></h3>
+<b>syntax: (<font color=#CC0000>gs:progress-bar</font> <em>sym-id</em> <em>int-min</em> <em>in-max</em> <em>int-initial-value</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The symbols of the progress bar.<br/>
+<b>parameter: </b><em>int-min</em> - The minimum value of the slider.<br/>
+<b>parameter: </b><em>int-max</em> - The maximum value of the slider.<br/>
+<b>parameter: </b><em>int-initial-value</em> - The initial value of the slider.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_radio-button"></a><h3><font color=#CC0000>gs:radio-button</font></h3>
+<b>syntax: (<font color=#CC0000>gs:radio-button</font> <em>sym-id</em> <em>sym-action</em> [<em>str-text</em> [<em>bool-selected</em>]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the radio button.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-text</em> - The optional text of the radio button.<br/>
+<b>parameter: </b><em>bool-seected</em> - An optional flag <tt>true</tt> or <tt>nil</tt> (default) indicating the initial state of the radio button.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_redo-text"></a><h3><font color=#CC0000>gs:redo-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:redo-text</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the <tt>gs:text-pane</tt> where to perform a redo operation.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_remove-from"></a><h3><font color=#CC0000>gs:remove-from</font></h3>
+<b>syntax: (<font color=#CC0000>gs:remove-from</font> <em>sym-container</em> <em>sym-component</em> [<em>sym-component</em> ...])</b><br/>
+<b>parameter: </b><em>sym-container</em> - The container from which to remove a component.<br/>
+<b>parameter: </b><em>sym-component</em> - One or more optional components to remove.<br/>
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_remove-list-item"></a><h3><font color=#CC0000>gs:remove-list-item</font></h3>
+<b>syntax: (<font color=#CC0000>gs:remove-list-item</font> <em>sym-list-combo</em> <em>int-index</em> [<em>int-index</em> ...])</b><br/>
+<b>parameter: </b><em>sym-list-combo</em> - The name of the combo box or list box from which entries are removed.<br/>
+<b>parameter: </b><em>int-index</em> - The index of an entry to remove from the list or combo box.<br/>
+<br/><br/>
+ When specifying an index of <tt>0</tt>, the first item gets removed. When specifying an
+ index equal or greater to the number of items in the list, the item is removed at the end.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_remove-tab"></a><h3><font color=#CC0000>gs:remove-tab</font></h3>
+<b>syntax: (<font color=#CC0000>gs:remove-tab</font> <em>sym-tabbed-pane</em> [<em>int-index</em>])</b><br/>
+<b>parameter: </b><em>sym-tabbed-pane</em> - The name of the tabbed pane.<br/>
+<b>parameter: </b><em>int-index</em> - The optional index of the tab to remove. The default is <tt>0</tt> for the first tab.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_request-focus"></a><h3><font color=#CC0000>gs:request-focus</font></h3>
+<b>syntax: (<font color=#CC0000>gs:request-focus</font> <em>sym-id</em> [<em>int-tab-index</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to request focus.<br/>
+<b>parameter: </b><em>int-tab-index</em> - The index of a tab for which focus is requested.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_reorder-tags"></a><h3><font color=#CC0000>gs:reorder-tags</font></h3>
+<b>syntax: (<font color=#CC0000>gs:reorder-tags</font> <em>list-tags</em>)</b><br/>
+<b>parameter: </b><em>list-tags</em> - The list of tag symbols or tag string names in the new order of display.<br/>
+<br/><br/>
+ The re-ordering itself will not repaint the canvas use <tt>gs:update</tt> to repaint the current 
+ canvas after using <tt>gs:reorder-tags</tt>. The list of tags can be given as either a list of
+ tags symbols or name strings. Tags not appearing in <em>list-tags</em> will be deleted.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_rotate-tag"></a><h3><font color=#CC0000>gs:rotate-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:rotate-tag</font> <em>sym-tag</em> <em>float theta</em> <em>int-x</em> <em>int-y</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group to rotate.<br/>
+<b>parameter: </b><em>float-theta</em> - The rotation angle in degrees (0 - 360).<br/>
+<b>parameter: </b><em>int-x</em> - The X-coordinate of the rotation center.<br/>
+<b>parameter: </b><em>int-y</em> - The Y-coordinate of the rotation center.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+ Like all tag operations, multiple <tt>gs:rotate-tag</tt> operations are cumulative.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_run-shell"></a><h3><font color=#CC0000>gs:run-shell</font></h3>
+<b>syntax: (<font color=#CC0000>gs:run-shell</font> <em>id-text-area</em> <em>str-command</em> <em>str-args</em>)</b><br/>
+<b>parameter: </b><em>idx-text-area</em> - The id of the text area to wich a shell process will be attached.<br/>
+<b>parameter: </b><em>str-command</em> - The command string to start the shell process.<br/>
+<b>parameter: </b><em>str-args</em> - The arguments of the command (max 8 arguments).<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_save-file-dialog"></a><h3><font color=#CC0000>gs:save-file-dialog</font></h3>
+<b>syntax: (<font color=#CC0000>gs:save-file-dialog</font> <em>sym-parent-frame</em> <em>sym-action</em> [<em>str-directory</em> [<em>str-initial-file</em> [<em>str-mask</em> <em>str-description</em>]]])</b><br/>
+<b>parameter: </b><em>sym-parent-frame</em> - The parent frame of the file dialog.<br/>
+<b>parameter: </b><em>sym-action</em> - The handler function symbol.<br/>
+<b>parameter: </b><em>str-directory</em> - The initial directory to show.<br/>
+<b>parameter: </b><em>str-file</em> - The initial file name.<br/>
+<b>parameter: </b><em>str-mask</em> - An optional string mask.<br/>
+<b>parameter: </b><em>str-description</em> - An optional mask description.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_save-sequence"></a><h3><font color=#CC0000>gs:save-sequence</font></h3>
+<b>syntax: (<font color=#CC0000>gs:save-sequence</font> <em>str-file-path</em>)</b><br/>
+<b>parameter: </b><em>str-file-name</em> - The name of the MIDI file to save to.<br/>
+<br/><br/>
+ Save the contents of a sequence created with <tt>gs:add-track</tt> to a MIDI file.
+ The file always should have the extension <tt>.mid</tt>.
+<br/><br/>
+ Note that all MIDI files created with <tt>gs:save-sequence</tt> will play back at a fixed
+ speed of 120 BPM. Therefore, when creating sequences for recording using <tt>gs:add-track</tt>,
+ they should be timed for a play-back speed of 120 BPM.
+<br/><br/>
+ To change the speed for replay from a saved MIDI file the resolution parameter can
+ be chaged from it's default of 16 tick per beat using the second optional parameter
+ of <tt>gs:midi-bpm</tt>. In this case the resolution parameter should be adjusted before
+ calling <tt>gs:add-track</tt> the first time.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_save-text"></a><h3><font color=#CC0000>gs:save-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:save-text</font> <em>sym-id</em> <em>str-path</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the <tt>gs:text-pane</tt>.<br/>
+<b>parameter: </b><em>str-path</em> - The full path name of the file to save.<br/>
+<br/><br/>
+ This function will write text back from a <tt>gs:text-pane</tt> directly
+ by specifying a path name only. Line feed characters (ASCII 10)
+ are used as line terminators. If this behavior is not desired,
+ as is the case with Windows text files, then <tt>gs:get-text</tt> should
+ be used instead. A program can then add CR characters using a 
+ newLISP <tt>replace</tt>, i.e. <tt>(replace "\n" text "\r\n")</tt> before
+ saving the text to a file.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_scale-tag"></a><h3><font color=#CC0000>gs:scale-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:scale-tag</font> <em>sym-tag</em> <em>float-x</em> <em>float-y</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group to scale.<br/>
+<b>parameter: </b><em>float-x</em> - The X scaling factor.<br/>
+<b>parameter: </b><em>float-y</em> - The Y scaling factor.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+ <tt>gs:scale</tt> scales the object to draw relative to the <tt>0,0</tt> point of
+ the coordinate system. This means if a object is not at the center it
+ will not only change in size when scaled but also change the distance
+ to the center point of the coordinate system, moving away when scaling
+ up with scale factor bigger <tt>1.0</tt> and moving closer to the center
+ when scaling down using factors smaller than <tt>1.0</tt>.
+<br/><br/>
+ This means that objects which will be scaled should be defined in
+ coordinates relative to their center point. Then a <tt>gs:translate-tag</tt>
+ command should be used to place the object to correct place:
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:circle 'C 0 0 50)
+ (gs:gs:translate-tag 'C 200 100)
+ ...
+ (gs:scale-tag 'C 1.1 1.1)</pre></blockquote>
+ In the example the circle, although defined for <tt>0,0</tt>, will be displayed
+ at the <tt>200,200</tt> position because of the <tt>gs:translate-tag</tt> statement. When
+ later scaling the circle will get bigger but stay in place.
+ Like all tag operations, multiple <tt>gs:scale-tag</tt> operations are cumulative.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_select-list-item"></a><h3><font color=#CC0000>gs:select-list-item</font></h3>
+<b>syntax: (<font color=#CC0000>gs:select-list-item</font> <em>sym-id</em> <em>str-item</em> [<em>boolean-flag</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the list or combo box.<br/>
+<b>parameter: </b><em>str-item</em> - The item to select.<br/>
+<b>parameter: </b><em>boolean-flag</em> - An optional flag only for list boxes to force scrolling to the selected entry.<br/>
+<br/><br/>
+ On combo boxes the optional <em>boolean-flag</em> has no effect. The selected entry will always
+ appear as the visible text of the combo box. The flag has either the value <tt>true</tt> or <tt>nil</tt>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_select-text"></a><h3><font color=#CC0000>gs:select-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:select-text</font> <em>sym-id</em> <em>int-from</em> [<em>int-to</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The ame of the text component.<br/>
+<b>parameter: </b><em>int-from</em> - Start offset of selection.<br/>
+<b>parameter: </b><em>int-to</em> - Optional end offset of selection.<br/>
+<br/><br/>
+ If no <em>int-to</em> end offset is given, <tt>gs:select-text</tt> will
+ select to the end of the text.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_scroll-pane"></a><h3><font color=#CC0000>gs:scroll-pane</font></h3>
+<b>syntax: (<font color=#CC0000>gs:scroll-pane</font> <em>sym-id</em> <em>sym-widget</em> [<em>int-width</em> <em>int-height</em> <em>sym-w-col</em> <em>sum-w-row</em> <em>sym-w-corner</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the scroll pane.<br/>
+<b>parameter: </b><em>sym-widget</em> - The component in the scroll pane to be scrolled.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the scroll pane.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the scroll pane.<br/>
+<b>parameter: </b><em>sym-col</em> - The optional table widget for a custom column header.<br/>
+<b>parameter: </b><em>sym-row</em> - The optional table widget for a custom row header<br/>
+<b>parameter: </b><em>sym-corner</em> - The optional widget component in the upper left corner.<br/>
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:scroll-pane 'scroll 'data-table 700 600 'col-table 'row-table 'Canvas)
+</pre></blockquote>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-accelerator"></a><h3><font color=#CC0000>gs:set-accelerator</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-accelerator</font> <em>sym-menu-item</em> <em>str-keystroke</em>)</b><br/>
+<b>parameter: </b><em>sym-menu-item</em> - The name of the menu item for which an accelerator key is set.<br/>
+<b>parameter: </b><em>str-keystroke</em> - A text string identifying the keystroke.<br/>
+<br/><br/>
+ The following rules are used to create keystroke strings:
+<br/><br/>
+ Syntax:
+ <blockquote><pre>
+ modifiers* (typedID | pressedReleasedID)
+ modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
+ typedID := typed typedKey
+ typedKey := string of length 1 giving Unicode character.
+ pressedReleasedID := (pressed | released) key
+ key := KeyEvent key code name, i.e. the name following "VK_".
+ </pre></blockquote>
+ Examples:
+ <blockquote><pre>
+ "INSERT"
+ "control DELETE"
+ "alt shift X"
+ "alt shift released X"
+ "typed a"
+ </pre></blockquote>
+ Note that the <i>apple</i> key on MacOS X is the <tt>meta</tt> key.
+ The <tt>alt</tt> on MacOS X is the <i>option</i> key.
+ For letters use uppercase. 
+ Keys are added to the menu item display automatically on all platforms.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-anti-aliasing"></a><h3><font color=#CC0000>gs:set-anti-aliasing</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-anti-aliasing</font> <em>boolean-flag</em>)</b><br/>
+<b>parameter: </b><em>boolean-flag</em> - The anti aliasing setting for the current canvas <tt>true</tt> or <tt>nil</tt>.<br/>
+<br/><br/>
+ The default setting is <tt>true</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-background"></a><h3><font color=#CC0000>gs:set-background</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-background</font> <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>float-red</em> - The red color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-green</em> - The green color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-blue</em> - The blue color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+<b>syntax: (<font color=#CC0000>gs:set-background</font> <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>list-rgb</em> - The rgb color can be given as a list of three numbers.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+ Note <tt>set-background</tt> is the same as <tt>set-color</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-bevel-border"></a><h3><font color=#CC0000>gs:set-bevel-border</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-bevel-border</font> <em>sym-id</em> <em>str-type</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component.<br/>
+<b>parameter: </b><em>str-type</em> - The type of the bevel <tt>"raised"</tt> or <tt>"lowered"</tt>.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-border-layout"></a><h3><font color=#CC0000>gs:set-border-layout</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-border-layout</font> <em>sym-container</em>  [<em>int-hgap</em> <em>int-vgap</em>])</b><br/>
+<b>parameter: </b><em>sym-container</em> - The name of the container for which border layout is set.<br/>
+<b>parameter: </b><em>int-hgap</em> - The horizontal gap between components in the border layout.<br/>
+<b>parameter: </b><em>int-vgap</em> - The vertical gap between components in the border layout.<br/>
+<br/><br/>
+ Border layout divides the layout into 5 zones labeled <tt>"north"</tt>, <tt>"west"</tt>,
+ <tt>"center"</tt>, <tt>"east"</tt> and <tt>"south"</tt>. These string constants are used in
+ the <tt>gs:add-to</tt> command when adding components to a border layout.
+<br/><br/>
+ In a border layout each component will take the maximum size if components
+ are not sized. If components are sized only some dimensions will be honored.
+ The <tt>"north"</tt> and <tt>"south"</tt> components will stretch to maximum width and
+ assume the height given in a size parameter of the component. The <tt>"east"</tt>
+ and <tt>"west"</tt> components will stretch to the maximum height available assuming
+ their width specified earlier. The <tt>"center"</tt> component will take the left over
+ maximum space.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-canvas"></a><h3><font color=#CC0000>gs:set-canvas</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-canvas</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the canvas to switch to.<br/>
+<br/><br/>
+ The canvas in <em>sym-id</em> must have been created earlier with a <tt>gs:canvas</tt> 
+ statement. All graphics operations which do not take a canvas as argument
+ will automatically refer to this current canvas. If no <tt>gs:set-canvas</tt> is
+ used, the current canvas is assumed to be the last one created.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-caret"></a><h3><font color=#CC0000>gs:set-caret</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-caret</font> <em>sym-id</em> <em>int-offset</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the cursor caret.<br/>
+<br/><br/>
+ The functions has the same effect as calling <tt>gs:select-text</tt> with the same 
+ offset for the dot and mark position.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-caret-color"></a><h3><font color=#CC0000>gs:set-caret-color</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-caret-color</font> <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>float-red</em> - The red color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-green</em> - The green color component expressed as a  number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-blue</em> - The blue color component expressed as a  number between 0.0 and 1.0.<br/>
+<b>syntax: (<font color=#CC0000>gs:set-caret-color</font> <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>list-rgb</em> - The rgb color can be given as a list of three numbers.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-color"></a><h3><font color=#CC0000>gs:set-color</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-color</font> <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>float-red</em> - The red color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-green</em> - The green color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-blue</em> - The blue color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+<b>syntax: (<font color=#CC0000>gs:set-color</font> <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>list-rgb</em> - The rgb color can be given as a list of three numbers.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+ Note that <tt>set-color</tt> is the same as <tt>set-background</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-cursor"></a><h3><font color=#CC0000>gs:set-cursor</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-cursor</font> <em>sym-id</em> <em>str-shape</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the frame, dialog or window.<br/>
+<b>parameter: </b><em>str-shape</em> - The string describing the cursor shape.<br/>
+<br/><br/>
+ The cursor shape can be one of the following:
+ <pre>
+  "default"
+  "crosshair"
+  "text"
+  "wait"
+  "sw-resize"
+  "se-resize"
+  "nw-resize"
+  "ne-resize"
+  "n-resize"
+  "s-resize"
+  "w-resize"
+  "e-resize"
+  "hand"
+  "move"
+ </pre>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-echo-char"></a><h3><font color=#CC0000>gs:set-echo-char</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-echo-char</font> <em>sym-id</em> [<em>str-cover-char</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which text is set.<br/>
+<b>parameter: </b><em>str-cover-char</em> - Cover character for password entry.<br/>
+<b>Example:</b><blockquote><pre> (gs:set-echo-char 'TheTextField "*")
+ (gs:set-echo-char 'TheTextField)   ; no echo, behave as normal text field</pre></blockquote>
+ If no <em>str-cover-char</em> is specyfied or the string in <em>str-cover-char</em> is of
+ 0 length, then the text field behaves as a normal text field.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-editable"></a><h3><font color=#CC0000>gs:set-editable</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-editable</font> <em>sym-id</em> <em>boolean-editable</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text widget.<br/>
+<b>parameter: </b><em>boolean-editable</em> - The flag <tt>true</tt> or <tt>nil</tt> to indicate if this text widget can be edited.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-flow-layout"></a><h3><font color=#CC0000>gs:set-flow-layout</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-flow-layout</font> <em>sym-container</em> [<em>str-alignment</em> [<em>int-hgap</em> <em>int-vgap</em>]])</b><br/>
+<b>parameter: </b><em>sym-container</em> - The name of the container for which flow layout is set.<br/>
+<b>parameter: </b><em>sym-alignment</em> - The alignment of the flow layout <tt>"left"</tt>, <tt>"center"</tt> or <tt>"right"</tt>.<br/>
+<b>parameter: </b><em>int-hgap</em> - The horizontal gap between components in the flow layout.<br/>
+<b>parameter: </b><em>int-vgap</em> - The vertical gap between components in the flow layout.<br/>
+<br/><br/>
+ The flow layout lets components appear in their natural or preferred size. The preferred
+ size of a component is set using the function <tt>gs:set-size</tt>. Button-type widgets and
+ combo boxes will take as much space as necessary to show the included text.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-font"></a><h3><font color=#CC0000>gs:set-font</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-font</font> <em>sym-id</em> <em>str-family</em> <em>int-size</em> <em>str-type</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the text font.<br/>
+<b>parameter: </b><em>str-familiy</em> - The family of the font, e.g.: <tt>"Monospaced"</tt>, <tt>"Serif"</tt>, <tt>"Sans Serif"</tt>.<br/>
+<b>parameter: </b><em>int-size</em> - The font size in points.<br/>
+<b>parameter: </b><em>str-type</em> - The type of the font, one or more of <tt>"plain"</tt>, <tt>"bold"</tt>, <tt>"italic"</tt>.<br/>
+<br/><br/>
+ More than the above noted families are available depending on the platform.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-foreground"></a><h3><font color=#CC0000>gs:set-foreground</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-foreground</font> <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>float-red</em> - The red color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-green</em> - The green color component expressed as a  number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-blue</em> - The blue color component expressed as a  number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+<b>syntax: (<font color=#CC0000>gs:set-foreground</font> <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the color.<br/>
+<b>parameter: </b><em>list-rgb</em> - The rgb color can be given as a list of three numbers.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+ The foreground color is the color of the text in a component.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-grid-layout"></a><h3><font color=#CC0000>gs:set-grid-layout</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-grid-layout</font> <em>sym-container</em> <em>int-rows</em> <em>int-columns</em> [<em>int-hgap</em> <em>int-vgap</em>])</b><br/>
+<b>parameter: </b><em>sym-container</em> - The name of the container for which grid layout is set.<br/>
+<b>parameter: </b><em>int-rows</em> - The number of rows in the layout grid.<br/>
+<b>parameter: </b><em>int-columns</em> - The number of columns in the layout grid.<br/>
+<b>parameter: </b><em>int-hgap</em> - The horizontal gap between components in the grid layout.<br/>
+<b>parameter: </b><em>int-vgap</em> - The vertical gap between components in the grid layout.<br/>
+<br/><br/>
+ In a grid layout each component will assume the maximum size the grid cell allows
+ regardless of sizes preset using <tt>gs:set-size</tt> Because of this grid layout cells are
+ frequently filled with panels using <tt>gs:panel</tt> which have flow layout by default
+ and allow deliberate sizing of components using <tt>gs:set-size</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-icon"></a><h3><font color=#CC0000>gs:set-icon</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-icon</font> <em>sym-id</em> <em>str-icon-path</em> [<em>int-index</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of a button or label or menu-item for which to set an icon.<br/>
+<b>parameter: </b><em>str-icon-path</em> - The file path of the icon to be set.<br/>
+<b>parameter: </b><em>int-index</em> - If <em>sym-id</em> is a tabbed pane <em>int-index</em> is the index of the tab.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-look-and-feel"></a><h3><font color=#CC0000>gs:set-look-and-feel</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-look-and-feel</font> <em>str-look</em>)</b><br/>
+<b>parameter: </b><em>str-look</em> - The class description string for the look and feel of the application.<br/>
+<br/><br/>
+ The following strings can be tried in <em>str-look</em>, but not all will work on a specific
+ platform. On the Mac the default look-and-feel is built-in to the JVM as the default
+ style. The <tt>"MacLookAndFeel"</tt> is not available as an explicit flavor here, but may be
+ on other platforms.
+ <pre>
+    <tt>"com.sun.java.swing.plaf.motif.MotifLookAndFeel"</tt><br>
+    <tt>"javax.swing.plaf.metal.MetalLookAndFeel"</tt><br>
+    <tt>"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"</tt><br>
+    <tt>"javax.swing.plaf.mac.MacLookAndFeel"</tt><br>
+    <tt>"com.sun.java.swing.plaf.gtk.GTKLookAndFeel"</tt>
+ </pre>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-paint"></a><h3><font color=#CC0000>gs:set-paint</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-paint</font> <em>list-rgb</em>)</b><br/>
+<b>parameter: </b><em>list-rgb</em> - The current paint used for outlines, text and fill color.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-pressed-icon"></a><h3><font color=#CC0000>gs:set-pressed-icon</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-pressed-icon</font> <em>sym-id</em> <em>str-icon-path</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the button, image button or toggle button.<br/>
+<b>parameter: </b><em>str-icon-path</em> - The file path of the icon or image to be set to the button in pressed state.<br/>
+<br/><br/>
+ By default a small grey dot is shown on image buttons when in a pressed state.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-resizable"></a><h3><font color=#CC0000>gs:set-resizable</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-resizable</font> <em>sym-frame</em> <em>boolean-resizable</em>)</b><br/>
+<b>parameter: </b><em>sym-frame</em> - The name of the frame window.<br/>
+<b>parameter: </b><em>bbolean-resizable</em> - The flag <tt>true</tt> or <tt>nil</tt> to indicate if a frame can be resized by the user.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-rotation"></a><h3><font color=#CC0000>gs:set-rotation</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-rotation</font> <em>float-angle</em>)</b><br/>
+<b>parameter: </b><em>float-angle</em> - The angle in degrees (0 - 360) of the canvas rotation.<br/>
+<br/><br/>
+ Unlike the <tt>gs:rotate-tag</tt> operation which is cumulative, <tt>gs:set-rotation</tt>
+ will set an absolute rotation value each time it is called.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-scale"></a><h3><font color=#CC0000>gs:set-scale</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-scale</font> <em>float-x</em> <em>float-y</em>)</b><br/>
+<b>parameter: </b><em>float-x</em> - The X-scale value of the current canvas.<br/>
+<b>parameter: </b><em>float-y</em> - The Y-scale value of the current canvas.<br/>
+<br/><br/>
+ Unlike the <tt>gs:scale-tag</tt> operation which is cumulative, <tt>gs:set-scale</tt>
+ will set an absolute scale value each time it is called.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-selected"></a><h3><font color=#CC0000>gs:set-selected</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-selected</font> <em>sym-id</em> <em>boolean-selected</em> [<em>sym-id</em> <em>boolean-selected</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the toggle or radio button or check box or menu item.<br/>
+<b>parameter: </b><em>boolean-selected</em> - A flag of <tt>true</tt> or <tt>nil</tt> to indicated the selection state.<br/>
+<br/><br/>
+ More then one toggle control may be set selected or unselected.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-selection-color"></a><h3><font color=#CC0000>gs:set-selection-color</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-selection-color</font> <em>sym-id</em> <em>float-red</em> <em>float-green</em> <em>float-blue</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the text selection color.<br/>
+<b>parameter: </b><em>float-red</em> - The red color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-green</em> - The green color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-blue</em> - The blue color component expressed as a number between 0.0 and 1.0.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+<b>syntax: (<font color=#CC0000>gs:set-selection-color</font> <em>sym-id</em> <em>list-rgb</em> [<em>float-alpha</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which to set the text selection color.<br/>
+<b>parameter: </b><em>list-rgb</em> - The rgb color can be given as a list of three numbers.<br/>
+<b>parameter: </b><em>float-alpha</em> - The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).<br/>
+<br/><br/>
+ Note <tt>set-background</tt> is the same as <tt>set-color</tt>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-size"></a><h3><font color=#CC0000>gs:set-size</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-size</font> <em>sym-id</em> <em>int-width</em> <em>int-height</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component of which a preferred size is set.<br/>
+<b>parameter: </b><em>int-width</em> - The preferred width of the component.<br/>
+<b>parameter: </b><em>int-height</em> - The preferred height of the component.<br/>
+<br/><br/>
+ Note that not all layouts allow setting the size of a component. The grid and
+ border layouts will size the component to its maximum possible in the layout.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-stroke"></a><h3><font color=#CC0000>gs:set-stroke</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-stroke</font> <em>float-width</em> [<em>str-cap</em> [<em>str-join</em> [<em>float-miterlimit</em>]]])</b><br/>
+<b>parameter: </b><em>float-width</em> - The width for drawing lines and outlines in shapes.<br/>
+<b>parameter: </b><em>str-cap</em> - One of optional <tt>"butt"</tt> (default), <tt>"round"</tt> or <tt>"sqare"</tt>.<br/>
+<b>parameter: </b><em>str-join</em> - One of optional <tt>"miter"</tt> (default), <tt>"bevel"</tt> or <tt>"round"</tt><br/>
+<br/><br/>
+ For a <em>float-width</em> 0f 0.0 the thinnest possible line width be chosen. 
+ Join is the decoration applied at the intersection of two path segments and at the 
+ intersection of the endpoints.
+ Cap is the decoration applied to the ends of unclosed subpaths and dash segments.
+ The <em>float-miterlimit</em> should be greater or equal 1.0.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-syntax"></a><h3><font color=#CC0000>gs:set-syntax</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-syntax</font> <em>sym-id</em> <em>str-type</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text pane for syntax coloring is enabled or disabled.<br/>
+<b>parameter: </b><em>str-type</em> - A string <tt>"lsp"</tt>, <tt>"c"</tt>, <tt>"cpp"</tt>, <tt>"java"</tt> or <tt>"php"</tt> to indicate the <br/>
+ syntax desired, or <tt>nil</tt> to switch off syntax highlighting.
+<br/><br/>
+ Colors for syntax highlighting are preselected for a white background, but can be changed using
+ the following functions: <tt>gs:set-background</tt>, <tt>gs:set-foreground</tt>, <tt>gs:set-caret</tt>, <tt>gs:set-selection-color</tt>
+ and <tt>gs:set-syntax-colors</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-syntax-colors"></a><h3><font color=#CC0000>gs:set-syntax-colors</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-syntax-colors</font> <em>list-rgb-comment</em> <em>list-rgb-keyword</em> <em>list-rgb-string</em> <em>list-rgb-number</em> <em>list-rgb-quoted</em> <em>list-rgb-parentheses</em>)</b><br/>
+<b>parameter: </b><em>list-rgb-comment</em> - The color for comments.<br/>
+<b>parameter: </b><em>list-rgb-keyword</em> - The color for reserved keywords.<br/>
+<b>parameter: </b><em>list-rgb-string</em> - The color for strings.<br/>
+<b>parameter: </b><em>list-rgb-number</em> - The color for numbers.<br/>
+<b>parameter: </b><em>list-rgb-quoted</em> - The color for the quote and quoted symbols.<br/>
+<b>parameter: </b><em>list-rgb-parentheses</em> - The color for parenthesis.<br/>
+<br/><br/>
+ Syntax highlighting colors are given as lists of red, green and blue values between 0.0 and 1.0. 
+ Depending on the syntax colors and the foreground and background colors set for the text pane, 
+ the caret color and color for selected text should also be changed. Only text widgets created 
+ using <tt>gs:text-pane</tt> feature syntax highlighting.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-tab-size"></a><h3><font color=#CC0000>gs:set-tab-size</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-tab-size</font> <em>sym-id</em> <em>int-size</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text area component.<br/>
+<b>parameter: </b><em>int-size</em> - The tabulator size.<br/>
+<br/><br/>
+ Note that <tt>gs:set-tab-size</tt> will only work with fixed spaced fonts.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-text"></a><h3><font color=#CC0000>gs:set-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-text</font> <em>sym-id</em> <em>str-text</em> [<em>int-index</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the component for which text is set.<br/>
+<b>parameter: </b><em>str-text</em> - The text to be set in the component.<br/>
+<b>parameter: </b><em>int-index</em> - The index for a tab if the <em>sym-id</em> is a tabbed pane.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-titled-border"></a><h3><font color=#CC0000>gs:set-titled-border</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-titled-border</font> <em>sym-component</em> <em>str-title</em>)</b><br/>
+<b>parameter: </b><em>sym-component</em> - The name of the component.<br/>
+<b>parameter: </b><em>str-title</em> - The text in the titled border around the component.<br/>
+<br/><br/>
+ The component is usually a <tt>panel</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-tool-tip"></a><h3><font color=#CC0000>gs:set-tool-tip</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-tool-tip</font> <em>sym-id</em> <em>str-text</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the widget for which to supply a tool tip.<br/>
+<b>parameter: </b><em>str-text</em> - The text of the tool tip.<br/>
+<br/><br/>
+ The tool tip text is shown when leaving the mouse over the widget for certain
+ amount of time.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-trace"></a><h3><font color=#CC0000>gs:set-trace</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-trace</font> <em>boolean-flag</em>)</b><br/>
+<b>parameter: </b><em>boolean-flag</em> - The flag <tt>true</tt> or <tt>nil</tt>.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-translation"></a><h3><font color=#CC0000>gs:set-translation</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-translation</font> <em>int-x</em> <em>int-y</em>)</b><br/>
+<b>parameter: </b><em>int-x</em> - The X-translation value of the current canvas.<br/>
+<b>parameter: </b><em>int-y</em> - The Y-translation value of the current canvas.<br/>
+<br/><br/>
+ Translates the current origin of the current canvas to the point in <em>int-x</em> <em>int-y</em>.
+ Unlike the <tt>gs:translate-tag</tt> operation which is cumulative, <tt>gs:set-translation</tt>
+ will set an absolute translation value each time it is called.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-utf8"></a><h3><font color=#CC0000>gs:set-utf8</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-utf8</font> <em>boolean-flag</em>)</b><br/>
+<b>parameter: </b><em>boolean</em> - The flag <tt>true</tt> or <tt>nil</tt> to indicate if in UTF-8 mode.<br/>
+<br/><br/>
+ When set in UTF-8 mode, guiserver will convert files to UTF-8 encoding
+ when loading and saving files. On Mac OS X UTF-8 mode is by default enabled.
+ On startup guiserver.lsp will detect if newLISP is UTF-8 enabled and
+ switch the mode in Guiserver accordingly using <tt>gs:set-utf8</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-value"></a><h3><font color=#CC0000>gs:set-value</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-value</font> <em>sym-id</em> <em>int-value</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of a slider or progress bar for which to set the value.<br/>
+<b>parameter: </b><em>int-value</em> - The integer value of the name to be set.<br/>
+<br/><br/>
+ The value should not be bigger or smaller than the minimum or maximum values set
+ when creating the slider or progress bar, otherwise the setting will default to either
+ the minimum or maximum preset value.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_set-visible"></a><h3><font color=#CC0000>gs:set-visible</font></h3>
+<b>syntax: (<font color=#CC0000>gs:set-visible</font> <em>sym-id</em> <em>boolean-visible</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The component which is hidden or made visible.<br/>
+<b>parameter: </b><em>boolean-visible</em> - A flag indicating if the component is visible <tt>"true"</tt>, <tt>"nil"</tt>.<br/>
+<br/><br/>
+ Except for frames and dialog windows, components are visible by default. Normally
+ frames and dialogs are not set visible before all other components are placed inside.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_shear-tag"></a><h3><font color=#CC0000>gs:shear-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:shear-tag</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag group to shear.<br/>
+<b>parameter: </b><em>float-x</em> - The X shearing factor.<br/>
+<b>parameter: </b><em>float-y</em> - The Y shearing factor.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_show-popup"></a><h3><font color=#CC0000>gs:show-popup</font></h3>
+<b>syntax: (<font color=#CC0000>gs:show-popup</font> <em>sym-tag</em> <em>sym-host</em> <em>int-x</em> <em>int-y</em>)</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The id of the popup menu.<br/>
+<b>parameter: </b><em>sym-host</em> - The host container where to pop up the menu.<br/>
+<b>parameter: </b><em>int-x</em> - The X coordinate of the menu popup position.<br/>
+<b>parameter: </b><em>int-y</em> - The Y coordinate of the menu popup position.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_show-tag"></a><h3><font color=#CC0000>gs:show-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:show-tag</font> <em>sym-tag</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The tag of the group to show.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_slider"></a><h3><font color=#CC0000>gs:slider</font></h3>
+<b>syntax: (<font color=#CC0000>gs:slider</font> <em>sym-id</em> <em>sym-action</em> <em>str-orientation</em> <em>int-min</em> <em>int-max</em> <em>int-initial-value</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the slider.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-orientation</em> - The orientation of the slider <tt>"horizontal"</tt> or <tt>"vertical"</tt><br/>
+<b>parameter: </b><em>int-min</em> - The minimum value of the slider.<br/>
+<b>parameter: </b><em>int-max</em> - The maximum value of the slider.<br/>
+<b>parameter: </b><em>int-initial-value</em> - The initial value of the slider.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_split-pane"></a><h3><font color=#CC0000>gs:split-pane</font></h3>
+<b>syntax: (<font color=#CC0000>gs:split-pane</font> <em>sym-id</em> <em>str-orientation</em> [<em>float-weight</em> [<em>float-location</em> [<em>int-divider-size</em>]]])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the split-pane.<br/>
+<b>parameter: </b><em>str-orientation</em> - The orientation <tt>"horizontal"</tt> or <tt>"vertical"</tt>.<br/>
+<b>parameter: </b><em>float-weight</em> - The optional weight distribution between <tt>0.0</tt> and <tt>1.0</tt> when re-sizing the window. The default is <tt>0.0</tt>.<br/>
+<b>parameter: </b><em>float-location</em> - The optional initial divider location between <tt>0.0</tt> and <tt>1.0</tt>.<br/>
+<b>parameter: </b><em>int-divider-size</em> - The optional size of the draggable divider in pixels.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_stop-sequence"></a><h3><font color=#CC0000>gs:stop-sequence</font></h3>
+<b>syntax: (<font color=#CC0000>gs:stop-sequence</font>)</b><br/>
+<br/><br/>
+ Stops playing tracks, as started with <tt>gs:play-sequence</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_tabbed-pane"></a><h3><font color=#CC0000>gs:tabbed-pane</font></h3>
+<b>syntax: (<font color=#CC0000>gs:tabbed-pane</font> <em>sym-id</em> <em>sym-action</em> <em>str-orientation</em> [<em>sym-tab</em> <em>str-title</em> ...])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the tabbed pane.<br/>
+<b>parameter: </b><em>str-orientation</em> - The position of the tabs; either <tt>"top"</tt> (default), <tt>"bottom"</tt>,<tt>"left"</tt> or <tt>"right"</tt>.<br/>
+<b>parameter: </b><em>sym-tab</em> - The id symbol name of a tab<br/>
+<b>parameter: </b><em>str-title</em> - The title of the tab.<br/>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table"></a><h3><font color=#CC0000>gs:table</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table</font> <em>sym-id</em> <em>sym-action</em> [<em>str-column-header-name</em> ...])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>sym-action</em> - The handler function symbol when a cell is selected.<br/>
+<b>parameter: </b><em>str-column-header-name</em> - The optional column header name. <br/>
+<br/><br/>
+ Creates a table with <em>str-column-header-name</em> specified column and empty row.
+ For empty strings specified as column headers, the header will be left empty.
+ If all header in a table are specified as empty, the table will be created
+ without a header row. If there are no columns at all, an empty table (0 x 0) 
+ is created. 
+<br/><br/>
+ When a cell is selected, the function in <em>sym-action</em> gets called with the table 
+ id, row, column and cell-contents. See the file <tt>table-demo.lsp</tt> for an example. 
+ Cells can be edited  by either selecting or double clicking a cell.
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-add-column"></a><h3><font color=#CC0000>gs:table-add-column</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-add-column</font> <em>sym-id</em> <em>str-column-header-name</em> ...)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>str-column-header-name</em> - Add column header name(s). <br/>
+<br/><br/>
+ More than one <em>str-column-header-name</em> can be specified to add more
+ than one column. A column header can be set empty using and empty string <tt>""</tt>.
+ When all headers in a table are empty, the
+ table will be displayed without a header row.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-add-row"></a><h3><font color=#CC0000>gs:table-add-row</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-add-row</font> <em>sym-id</em> [<em>str-columns</em> ... ])</b><br/>
+<b>syntax: (<font color=#CC0000>gs:table-add-row</font> <em>sym-id</em> ([<em>str-columns</em> ...))</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>str-columns</em> - Add a row with contents in <em>str-columns</em><br/>
+<br/><br/>
+ Add row with each column value. If necessary a scrollbar will appear.
+ If no contents is defined in <em>str-columns</em>, or if contents for less
+ columns is defined than available, column contents is left empty.
+ Multiple column content can be specified as either a list
+ of strings or as additional parameters of <tt>gs:table-add-row</tt>. 
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-get-cell"></a><h3><font color=#CC0000>gs:table-get-cell</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-get-cell</font> <em>sym-id</em> <em>int-row</em> <em>int-column</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>int-row</em> - The row of the cell.<br/>
+<b>parameter: </b><em>int-column</em> - The column of the cell.<br/>
+<p><b>return: </b>cell value. stored in gs:table-cell.</p>
+<br/><br/>
+ Get the cell contents as a string at sepcifed <em>int-row</em> and <em>int-column</em>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-get-size"></a><h3><font color=#CC0000>gs:table-get-size</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-get-size</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<p><b>return: </b>table size list (row-size, column-size)</p>
+<br/><br/>
+ Get table size, stored in <tt>gs:table-size</tt>.
+ Note, that adding columns or row will not automatically update
+ the <tt>gs:table-size</tt> variable. Use <tt>gs:table-get-size</tt> to update
+ this variable.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-remove-row"></a><h3><font color=#CC0000>gs:table-remove-row</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-remove-row</font> <em>sym-id</em> <em>int-rownumber</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>int-row</em> - The row to remove<br/>
+<br/><br/>
+ Removes a row See also <tt>gs:table-set-row-count</tt>.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-set-cell"></a><h3><font color=#CC0000>gs:table-set-cell</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-set-cell</font> <em>sym-id</em> <em>int-row</em> <em>int-column</em> <em>str-value</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>int-row</em> - The row of the cell set.<br/>
+<b>parameter: </b><em>int-column</em> - The column of the cell set.<br/>
+<b>parameter: </b><em>str-value</em> - The cell value.<br/>
+<p><b>return: </b>The previous contents of the cell; also stored in <tt>gs:table-cell</tt>.</p>
+<br/><br/>
+ Sets a new table cell contents and returns the old cell contents. Row and
+ column numbering starts with '0' (zero). The cell contents is passed
+ as a string.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-set-column"></a><h3><font color=#CC0000>gs:table-set-column</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-set-column</font> <em>sym-id</em> <em>int-column-number</em> <em>int-width</em> [<em>str-justification</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>int-column-number</em> - The column number of align.<br/>
+<b>parameter: </b><em>int-width</em> - The column width.<br/>
+<b>parameter: </b><em>str-justification</em> - The column align property, "left", "center", "right".<br/>
+<br/><br/>
+ A table column property is changed, adjusting the column width and alignment of cell
+ contents. The <em>str-justification</em> parameter is optional and alignment is "left"
+ by default.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-set-column-name"></a><h3><font color=#CC0000>gs:table-set-column-name</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-set-column-name</font> <em>sym-id</em> [<em>str-columns</em> ... ])</b><br/>
+<b>syntax: (<font color=#CC0000>gs:table-set-column-name</font> <em>sym-id</em> ([<em>str-columns</em> ...))</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>str-columns</em> - Set column names with contents in <em>str-columns</em>	<br/>
+<br/><br/>
+ Replaces the column names in the table. If the number of names 
+ is greater than the current number of columns, new columns are added to the end 
+ of each row in the table. If the number of columnnames is less than the current
+ number of columns, all the extra columns at the end of a row are discarded.
+	
+	  
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-set-row-count"></a><h3><font color=#CC0000>gs:table-set-row-count</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-set-row-count</font> <em>sym-id</em> <em>int-row-count</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>int-row</em> - Set the numbers of rows in the table with <em>int-row-count</em>	  <br/>
+<br/><br/>
+ Sets the number of rows in the table. If the new size is greater than the 
+ current size, new rows are added to the end of the table. If the new size is 
+ less than the current size, all rows at index rownumber and greater are discarded.
+	  
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-get"></a><h3><font color=#CC0000>gs:table-get</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-get</font> <em>sym-id</em>)</b><br/>
+<p><b>return: </b>table cells. stored in <tt>gs:table-full</tt>.</p>
+<br/><br/>
+ Get full table as a list of row lists.
+ <pre>
+ ( ("column0" "column1" ... ) ; 1'st row
+   ("column0" "column1" ... ) ; 2'nd row
+   ...
+   ... )
+ </pre>
+<br/><br/>
+ The entire table contents is stored as a list of row lists in the 
+ return value of <tt>gs:table-get</tt>, and is also stored in the variable 
+ <tt>gs:table-full</tt>. 
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-set-row-number"></a><h3><font color=#CC0000>gs:table-set-row-number</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-set-row-number</font> <em>sym-id</em> <em>bool-row-number</em>) DEPRECATED</b><br/>
+<br/><br/>
+ Use <tt>gs:table-show-row-number</tt>. The old naming is deprecated but will 
+ still work.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_table-show-row-number"></a><h3><font color=#CC0000>gs:table-show-row-number</font></h3>
+<b>syntax: (<font color=#CC0000>gs:table-show-row-number</font> <em>sym-id</em> <em>bool-row-number</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the table.<br/>
+<b>parameter: </b><em>bool-row-number</em> - <tt>true</tt> if rows should carry a row number; default <tt>nil</tt>.<br/>
+<br/><br/>
+ Show or hide the row number headers. The default is hiding row numbers.
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_text-area"></a><h3><font color=#CC0000>gs:text-area</font></h3>
+<b>syntax: (<font color=#CC0000>gs:text-area</font> <em>sym-id</em> <em>sym-action</em> <em>int-width</em> <em>int-height</em>)</b><br/>
+<b>parameter: </b><em>symid</em> - The name of the text area.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the text area..<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the text area.<br/>
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:text-area 'TheText 'textarea-event 10 8)
+
+ (define (textarea-event id code dot mark) ...)</pre></blockquote>
+ <tt>gs:text-area</tt> transmits the following parameters in its event:
+ <pre>
+ id   - name of the widget 
+ code - key code equals ASCII code. Only for text keys
+ dot  - position of text caret in the text 
+ mark - extended (selection) position of caret 
+ </pre>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_text-field"></a><h3><font color=#CC0000>gs:text-field</font></h3>
+<b>syntax: (<font color=#CC0000>gs:text-field</font> <em>sym-id</em> <em>sym-action</em> <em>int-columns</em> [<em>str-cover-char</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text field.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>int-columns</em> - The number of columns in the text field.<br/>
+<b>parameter: </b><em>str-cover-char</em> - Cover character for password entry.<br/>
+<b>Example:</b><blockquote><pre> (gs:text-field 'TheTextField 'textfield-event)
+ (gs:text-field 'PasswordTextField 'textfield-event "*")</pre></blockquote>
+ The <tt>textfield-event</tt> is fired when the enter key is pressed in the
+ text field. As an alternative the cover character for passwords can be
+ set with <tt>gs:set-echo-char</tt>.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_text-pane"></a><h3><font color=#CC0000>gs:text-pane</font></h3>
+<b>syntax: (<font color=#CC0000>gs:text-pane</font> <em>sym-id</em> <em>sym-action</em> <em>str-style</em> [<em>int-width</em> <em>int-height</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the text pane.<br/>
+<b>parameter: </b><em>sym-action</em> - The key action handler for the html pane.<br/>
+<b>parameter: </b><em>sym-style</em> - The content type of the text pane.<br/>
+<b>parameter: </b><em>int-width</em> - The optional width of the pane.<br/>
+<b>parameter: </b><em>int-height</em> - The optional height of the pane.<br/>
+<br/><br/>
+ The <tt>gs:text-pane</tt> is used similar to 'gs:text-area. The following styles
+ are supported in <em>sym-style</em>:
+ <pre>
+    "text/plain"
+    "text/html"
+ </pre>
+<br/><br/>
+ The <tt>gs:text-pane</tt> widget will automatically display scroll bars when
+ text does not fit in the visible space of the pane. When entering parentheses
+ they are automatically matched with their opening or closing counterparts, if they exist.
+ If this is undesired behavior, the simpler <tt>gs:text-area</tt> control should
+ be used instead. 
+<br/><br/>
+ On each change of the caret or selection in the text pane
+ an event is fired containing several parameters about the caret and selection
+ positions, the last character typed, and the modifier keys used. See the
+ the file <tt>newlisp-edit.lsp</tt> for a complex application using all features
+ available in this widget.
+<br/><br/>
+ To make hyperlinks in <tt>HTML</tt> formatted text clickable, editing must
+ be disabled using the <tt>gs:set-editable</tt> function. The functions <tt>gs:set-font</tt>
+ and <tt>gs:append-text</tt> will work only on the <tt>text/plain</tt> content style.
+<br/><br/>
+<b>Example:</b><blockquote><pre> (gs:text-pane 'TheTextPane 'textpane-event "text/plain")
+
+ (define (textpane-event id code mods dot mark len undo redo) ...)</pre></blockquote>
+ <tt>gs:text-pane</tt> transmits the following parameters in its event:
+ <pre>
+ id   - name of the widget 
+ code - key code equals ASCII code. Only for text keys 
+ mods - keys pressed together with the previous, like shift, ctrl etc.
+ dot  - position of the text caret in the text 
+ mark - extended (selection) position of the caret 
+ len  - length of the text in the textarea 
+ undo - undo enabled/disabled 
+ redo - redo enabled/disabled 
+ </pre>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_toggle-button"></a><h3><font color=#CC0000>gs:toggle-button</font></h3>
+<b>syntax: (<font color=#CC0000>gs:toggle-button</font> <em>sym-id</em> <em>sym-action</em> <em>str-text</em> [<em>bool-selected</em>])</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the toggle button.<br/>
+<b>parameter: </b><em>sym-action</em> - The name of the event handler.<br/>
+<b>parameter: </b><em>str-text</em> - The optional text of the toggle button.<br/>
+<b>parameter: </b><em>bool-selected</em> - An optional flag <tt>true</tt> or <tt>nil</tt> (default) indicating the initial state of the toggle button.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_tool-bar"></a><h3><font color=#CC0000>gs:tool-bar</font></h3>
+<b>syntax: (<font color=#CC0000>gs:tool-bar</font> <em>sym-frame</em> [<em>bool-floatable</em> <em>int-hgap</em> <em>int-vgap</em>])</b><br/>
+<b>parameter: </b><em>sym-frame</em> - The name of the frame hosting the toolbar.<br/>
+<b>parameter: </b><em>bool-floatable</em> - The optional flag <tt>true</tt> or <tt>nil</tt> to indicate if the toolbar can be detached.<br/>
+<b>parameter: </b><em>int-hgap</em> - The horizontal gap between components on the toolbar.<br/>
+<b>parameter: </b><em>int-vgap</em> - The vertical gap between the components on the toolbar.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_translate-tag"></a><h3><font color=#CC0000>gs:translate-tag</font></h3>
+<b>syntax: (<font color=#CC0000>gs:translate-tag</font> <em>sym-tag</em> <em>int-x</em> <em>int-y</em> [<em>boolean-repaint</em>])</b><br/>
+<b>parameter: </b><em>sym-tag</em> - The name tag of the group to translate.<br/>
+<b>parameter: </b><em>int-x</em> - The X-coordinate translation value.<br/>
+<b>parameter: </b><em>int-y</em> - The Y-coordinate translation value.<br/>
+<b>parameter: </b><em>boolean-repaint</em> - An optional flag to indicate if repainting is required (default is <tt>true</tt>).<br/>
+<br/><br/>
+ Moves the origin of the coordinate system of all objects tagged with <em>sym-tag</em>.
+ Like all tag operations multiple <tt>gs:translate-tag</tt> operations are cumulative.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_undo-text"></a><h3><font color=#CC0000>gs:undo-text</font></h3>
+<b>syntax: (<font color=#CC0000>gs:undo-text</font> <em>sym-id</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the <tt>gs:text-pane</tt> where to perform an undo operation.<br/>
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_undo-enable"></a><h3><font color=#CC0000>gs:undo-enable</font></h3>
+<b>syntax: (<font color=#CC0000>gs:undo-enable</font> <em>sym-id</em> <em>boolean-enabled</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The id of the <tt>gs:text-pane</tt> for which to enabe/disable undo.<br/>
+<b>parameter: </b><em>boolean-enabled</em> - <tt>true</tt> or <tt>nil</tt> to enable or disable undo.  <br/>
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_update"></a><h3><font color=#CC0000>gs:update</font></h3>
+<b>syntax: (<font color=#CC0000>gs:update</font>)</b><br/>
+<br/><br/>
+ Forces a repaint of the current canvas, e.g. after changing the scale or translation of a visible
+ canvas. This function is rarely used, as most screen updates are performed automatically.
+ All tag operations can carry an additional parameter to force update after they have been
+ draw.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_window"></a><h3><font color=#CC0000>gs:window</font></h3>
+<b>syntax: (<font color=#CC0000>gs:window</font> <em>sym-id</em> <em>int-x</em> <em>int-y</em> <em>int-width</em> <em>int-height</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the invisible window.<br/>
+<b>parameter: </b><em>int-x</em> - The x-coordinate of the screen position.<br/>
+<b>parameter: </b><em>int-y</em> - The y-coordinate of the screen position.<br/>
+<b>parameter: </b><em>int-width</em> - The width of the window.<br/>
+<b>parameter: </b><em>int-height</em> - The height of the window.<br/>
+<br/><br/>
+ Creates a borderless window. Note that a borderless window may treat
+ some hosted components differently from normal frames and dialogs.
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_window-closed"></a><h3><font color=#CC0000>gs:window-closed</font></h3>
+<b>syntax: (<font color=#CC0000>gs:window-closed</font> <em>sym-id</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the frame or dialog.<br/>
+<b>parameter: </b><em>sym-action</em> - The action to perform when the frame or dialog closes.<br/>
+<br/><br/>
+ A window or dialog window can be closed using the system close button in
+ one of the corners of the window. In this case it is useful to specify
+ a handler function which is called upon closing.
+
+
+
+
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_window-moved"></a><h3><font color=#CC0000>gs:window-moved</font></h3>
+<b>syntax: (<font color=#CC0000>gs:window-moved</font> <em>sym-id</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the frame or dialog.<br/>
+<b>parameter: </b><em>sym-action</em> - The action to perform when the frame or dialog moves.<br/>
+<br/><br/>
+ The event will carry the <em>sym-id</em> of the window or dialog and current <tt>X</tt> and <tt>Y</tt>
+ coordinates on the screen.
+<br/><br/>
+<br/><br/><center>&sect;</center><br/>
+<a name="gs_window-resized"></a><h3><font color=#CC0000>gs:window-resized</font></h3>
+<b>syntax: (<font color=#CC0000>gs:window-resized</font> <em>sym-id</em> <em>sym-action</em>)</b><br/>
+<b>parameter: </b><em>sym-id</em> - The name of the frame or dialog.<br/>
+<b>parameter: </b><em>sym-action</em> - The action to perform when the frame or dialog is resized.<br/>
+<br/><br/>
+ The event will carry the <em>sym-id</em> of the window or dialog and current width and
+ height.
+
+
+
+
+
+<br/><br/><center>- &part; -</center><br/>
+<center><font face='Arial' size='-2' color='#444444'>
+generated with <a href="http://newlisp.org">newLISP</a>&nbsp;
+and <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a>
+</font></center>
+</blockquote>
+</body>
+</html>
diff --git a/guiserver/guiserver.lsp.src.html b/guiserver/guiserver.lsp.src.html
new file mode 100644
index 0000000..3bbbb85
--- /dev/null
+++ b/guiserver/guiserver.lsp.src.html
@@ -0,0 +1,3832 @@
+<!DOCTYPE HTML PUBLIC "4.01 Transitional"><META http-equiv="Content-Type" content="text/html; charset=utf-8" /><html><title>guiserver.lsp</title><body><pre>
+<font color='#555555'>;; <font color='#308080'>@module</font> guiserver.lsp</font>
+<font color='#555555'>;; <font color='#308080'>@description</font> Functions for programming GUIs and 2D graphics.</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.40 use text-field as a password field with additional parameter</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.41 bug fixes for gs:listen and gs:check-event</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.42 new table UI</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.43 bug fix in new table UI action parameters</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.44 fixes in newlisp-edit.lsp</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.50 doc fixes</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.51 return value for gs:export</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.52 fix in run-shell for Java 7 update 21</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.53 doc fixes</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.60 new table functions, new naming gs:table-show-row-number</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.61 more options for gs:scroll-pane added by FdB</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.62 doc corrections</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.63 make deprecated gs:table-set-row-number work</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.70 default comm port with Guiserver are now 64001 and 64002</font>
+<font color='#555555'>;; <font color='#308080'>@version</font> 1.71 references to /usr/ changed to /usr/local/</font>
+<font color='#555555'>;; <font color='#308080'>@author</font> LM, 2008, 2009, 2010, 2015, Unya 2012, FdB 2013, LM 2015</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; This module has been tested on MacOS X 10.5 (Leopard) and Windows XP, both with the</font>
+<font color='#555555'>;; Standard SUN Java RE v.1.5 (runtime environment) which came pre-installed on</font>
+<font color='#555555'>;; those platforms. On Linux the installation of the original Sun Java Runtime </font>
+<font color='#555555'>;; Environment is required the preinstalled GNU Java is not compatible. After</font>
+<font color='#555555'>;; installation a soft-link has to be made from the original java executable to</font>
+<font color='#555555'>;; '/usr/bin/java'.</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On Windows the MIDI sound features require a soundbank file to</font>
+<font color='#555555'>;; be installed. See the description for 'gs:play-note' for details.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;What is newLISP-GS&lt;/h2&gt;</font>
+<font color='#555555'>;; 'guiserver.lsp' is a module for interfacing to 'guiserver.jar'</font>
+<font color='#555555'>;; a Java server application for generating GUIs (graphical user interfaces)</font>
+<font color='#555555'>;; and 2D graphics for newLISP applications. The 'guiserver.lsp', module</font>
+<font color='#555555'>;; implements a newLISP API much smaller and more abstract than the APIs of the </font>
+<font color='#555555'>;; Java Swing libraries which it interfaces with. Because of this, GUI applications</font>
+<font color='#555555'>;; can be built much faster than when using the original Java APIs.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Usage&lt;/h2&gt;</font>
+<font color='#555555'>;; At the beginning of the program file, include a 'load' statement for the module:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; (load "/usr/local/share/newlisp/guiserver.lsp")</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; or on MS Windows:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; (load "c:/Program Files/newlisp/guiserver.lsp")</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; 'guiserver.lsp' expects the server 'guiserver.jar' to be</font>
+<font color='#555555'>;; in the directoey specified in the environment variable NEWLISPDIR.</font>
+<font color='#555555'>;; When newLISP starts up and this variable is not set yet, it sets it</font>
+<font color='#555555'>;; to a default value of '/usr/local/share/newlisp' on MacOS X and Unix OSs, and </font>
+<font color='#555555'>;; to 'C:\Program Files\newlisp' or whatever it finds in the 'PROGRAMFILES'</font>
+<font color='#555555'>;; environment variable on MS Windows systems and adding '/newlisp' to it.</font>
+<font color='#555555'>;; This can be overwritten by specifying system wide  setting for the environment </font>
+<font color='#555555'>;; variable &lt;tt&gt;NEWLISPDIR&lt;/tt&gt;, which normally is set to '%PROGRAMFILES%/newlisp' </font>
+<font color='#555555'>;; on MS Windows. When using the MS Windows binary installer 'NEWLISPDIR' is written </font>
+<font color='#555555'>;; to the registry automatically and gets into effect after rebooting.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Architecture of a newLISP GUI application&lt;/h2&gt;</font>
+<font color='#555555'>;; A GUI application in newLISP is composed of four parts:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;blockquote&gt;</font>
+<font color='#555555'>;; &lt;b&gt;initialization&lt;/b&gt; - this means starting the newLISP-GS 'guiserver.jar' and initializing </font>
+<font color='#555555'>;; communications with it. Only one function call is required to do this.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;b&gt;building widgets&lt;/b&gt; - in this step windows, buttons, text fields etc., and</font>
+<font color='#555555'>;; all visual aspects of the GUI are described. newLISP newLISP-GS offers a wide range</font>
+<font color='#555555'>;; of different control widgets.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;b&gt;defining event actions&lt;/b&gt; - in this step all the functions are defined to</font>
+<font color='#555555'>;; react to events coming from the GUI as a consequence of button pushes, keystrokes,</font>
+<font color='#555555'>;; mouse-movements etc.. These event actions send many commands back to the GUI</font>
+<font color='#555555'>;; to change information for the user, popup dialogs etc..</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;b&gt;listening for events&lt;/b&gt; - the newLISP program sits in a loop waiting for</font>
+<font color='#555555'>;; events and dispatching them to the defined event actions. Only one function call</font>
+<font color='#555555'>;; is required for this step.</font>
+<font color='#555555'>;; &lt;/blockquote&gt;</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Example&lt;/h2&gt;</font>
+<font color='#555555'>;; The following example application shows all the essential elements of a newLISP GUI</font>
+<font color='#555555'>;; application:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; #!/usr/bin/newlisp</font>
+<font color='#555555'>;; ; button-demo.lsp - demonstrate the button control</font>
+<font color='#555555'>;;  </font>
+<font color='#555555'>;; ; initialization</font>
+<font color='#555555'>;; (load (append (env "NEWLISPDIR") "/guiserver.lsp")) </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:init) </font>
+<font color='#555555'>;;  </font>
+<font color='#555555'>;; ; describe the GUI</font>
+<font color='#555555'>;; (gs:frame 'ButtonDemo 100 100 400 300 "Button demo")</font>
+<font color='#555555'>;; (gs:set-resizable 'ButtonDemo nil)</font>
+<font color='#555555'>;; (gs:panel 'ColorPanel 360 200)</font>
+<font color='#555555'>;; (gs:set-color 'ColorPanel (random) (random) (random))</font>
+<font color='#555555'>;; (gs:button 'aButton 'abutton-action "color")</font>
+<font color='#555555'>;; (gs:set-flow-layout 'ButtonDemo "center" 2 15)</font>
+<font color='#555555'>;; (gs:add-to 'ButtonDemo 'ColorPanel 'aButton)</font>
+<font color='#555555'>;; (gs:set-visible 'ButtonDemo true)</font>
+<font color='#555555'>;;  </font>
+<font color='#555555'>;; ; define actions</font>
+<font color='#555555'>;; (define (abutton-action id)</font>
+<font color='#555555'>;;     (gs:set-color 'ColorPanel (random) (random) (random)))</font>
+<font color='#555555'>;;  </font>
+<font color='#555555'>;; ; listen for incoming action requests and dispatch</font>
+<font color='#555555'>;; (gs:listen)</font>
+<font color='#555555'>;;  </font>
+<font color='#555555'>;; ; eof </font>
+
+<font color='#555555'>;; &lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Application start&lt;/h2&gt;</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;     ./button-demo       ; on MacOS X and Unix</font>
+<font color='#555555'>;;     newlisp button-demo ; on MS Windows</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; By default guiserver.jar uses the ports 64001 and 64002, but this setting can be overwritten </font>
+<font color='#555555'>;; either by supplying a port number parameter to the 'gs:init' function or by overwriting the</font>
+<font color='#555555'>;; port number from the command-line. newLISP-GS will then use the port number supplied and the number</font>
+<font color='#555555'>;; following it:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;     ./button-demo 10001       ; on MacOS X and Unix</font>
+<font color='#555555'>;;     newlisp button-demo 10001 ; on MS Windows</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; newLISP-GS 'guiserver.jar' will now use the ports '64001' and '60002'.</font>
+<font color='#555555'>;; Ports under &lt;tt&gt;1024&lt;/tt&gt; should not be used, as many of them are already in use by other</font>
+<font color='#555555'>;; OS services and need administrator privileges to use them.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A second method to start a newLISP-GS application starts the 'guiserver.jar' first, which then</font>
+<font color='#555555'>;; starts the newLISP application:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;     java -jar /usr/local/share/newlisp/guiserver.jar 64001 /usr/home/aUser/MyApplication.lsp</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; A different port number can be used. Port numbers below 1024 need administrator</font>
+<font color='#555555'>;; permissions. Optionally a splash screen can be specified as the last parameter:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;     java -jar /usr/local/share/newlisp/guiserver.jar 64001 /home/apps/myapp.lsp /local/newLISP128.png</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; The example specifies an image inside 'guiserver.jar'. Any other image path on the local file system</font>
+<font color='#555555'>;; can be used.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On MS Windows similar methods can be used replacing the appropriate file paths, but on MS Windows Java jar files</font>
+<font color='#555555'>;; can also be treated as executables and executed directly without calling Java explicitly. By default</font>
+<font color='#555555'>;; 'guiserver.jar' and 'guiserver.lsp' are  installed in 'c:\Program Files\newlisp\' or any other </font>
+<font color='#555555'>;; directory configured on a MS Windows platform using the 'PROGRAMFILES' environment variable:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    "c:&#092;Program Files&#092;newlisp&#092;guiserver.jar" 64001 c:\myprogs\MyApplication.lsp</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; Quotes are necessary when spaces are present in the argument string. The example assumes that</font>
+<font color='#555555'>;; 'newlisp.exe' is in the path for executables, and it also assumes that the Windows registry has</font>
+<font color='#555555'>;; an association of the &lt;tt&gt;.jar&lt;/tt&gt; file extension with the &lt;tt&gt;javaw.exe&lt;/tt&gt; executable. This</font>
+<font color='#555555'>;; association is normally present when a java run-time environment (JRE) is installed in Windows.</font>
+<font color='#555555'>;; If this association is not registered, the following method can be used:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    javaw -jar "c:&#092;Program Files&#092;newlisp&#092;guiserver.jar" 64001 c:\myprogs\MyApplication.lsp</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; The quotes are necessary for path-names containing spaces.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;h2&gt;Debugging&lt;/h2&gt;</font>
+<font color='#555555'>;; &lt;b&gt;Tracing commands to newLISP-GS&lt;/b&gt;&lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; For debugging purpose put the following directive at the beginning of your application</font>
+<font color='#555555'>;; or at the place from where to start tracing.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;         (gs:set-trace true)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; Then start the application from a terminal or command shell window. Now newLISP-GS</font>
+<font color='#555555'>;; will output startup, version and connection messages and a trace for each 'gs:xxs' directive</font>
+<font color='#555555'>;; as it is received by the newLISP-GS dispatcher:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; newLISP-GS v.0.94</font>
+<font color='#555555'>;; listening on 64001</font>
+<font color='#555555'>;; accepted from 0.0.0.0</font>
+<font color='#555555'>;; connecting to 0.0.0.0 64002</font>
+<font color='#555555'>;; retrying to connect</font>
+<font color='#555555'>;; connected</font>
+<font color='#555555'>;; -> frame MAIN:ButtonDemo 100 100 400 300 QnV0dG9uIGRlbW8= nil</font>
+<font color='#555555'>;; -> set-resizable MAIN:ButtonDemo nil</font>
+<font color='#555555'>;; -> panel MAIN:ColorPanel 360 200</font>
+<font color='#555555'>;; -> set-color MAIN:ColorPanel 0 1 0 0.2</font>
+<font color='#555555'>;; -> button MAIN:aButton MAIN:abutton-action Y29sb3I=</font>
+<font color='#555555'>;; -> set-flow-layout MAIN:ButtonDemo center 2 15</font>
+<font color='#555555'>;; -> add-to MAIN:ButtonDemo MAIN:ColorPanel MAIN:aButton </font>
+<font color='#555555'>;; -> set-visible MAIN:ButtonDemo true</font>
+<font color='#555555'>;; -> set-color MAIN:ColorPanel 0.8401877172 0.3943829268 0.7830992238</font>
+<font color='#555555'>;; server shut down</font>
+<font color='#555555'>;; &lt;/blockquote&gt;&lt;/pre&gt;</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Text strings for button names, icon paths and other texts are encode in</font>
+<font color='#555555'>;; Base64 strings as the first trace line for MAIN:ButtonDemo shows. To switch</font>
+<font color='#555555'>;; off tracing mode use:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;        (gs:set-trace nil)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; Even if trace mode is switched off, wrong or missing parameters are still messaged</font>
+<font color='#555555'>;; by newLISP-GS in a small message box. After such an error the application and guiserver</font>
+<font color='#555555'>;; will exit. Unknown commands will be ignored. Functions which are not applicable to</font>
+<font color='#555555'>;; certain widgets will also pop up an error message box. In certain situations a</font>
+<font color='#555555'>;; function will have no effect, e.g. 'gs:set-size' or 'gs:set-color' sometimes do not</font>
+<font color='#555555'>;; have an effect, depending on how a widget is configured or depending on the layout</font>
+<font color='#555555'>;; which hosts the widget. Sometimes the platform look-and-feel overwrites colors.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Event handlers&lt;/h2&gt;</font>
+<font color='#555555'>;; For most widgets, event handlers must be defined. Sometimes an event handler is</font>
+<font color='#555555'>;; not required. In this case specify &lt;tt&gt;'gs:no-action&lt;/tt&gt; as the event handler</font>
+<font color='#555555'>;; symbol. When developing programs it is useful to watch the event handler first</font>
+<font color='#555555'>;; before coding for it. This can be done easily by printing out event parameters:</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; (gs:button 'aButton 'abutton-handler "press")</font>
+<font color='#555555'>;; (define (abutton-handler id)</font>
+<font color='#555555'>;;     (println id))</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; Sometimes the same event handler function is attached to several widgets' keyboard</font>
+<font color='#555555'>;; or mouse events. Some of these events receive a greater number of parameters. There</font>
+<font color='#555555'>;; are two easy ways to discover the nature of an event:</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; (define (the-handler)</font>
+<font color='#555555'>;;     (doargs (p)</font>
+<font color='#555555'>;;         (println "->" p)))</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; The other method looks at the source of the event as it was transmitted by the newLISP-GS.</font>
+<font color='#555555'>;; This is useful to recognize the data types used in the event:</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; (define (the-handler)</font>
+<font color='#555555'>;;     (println gs:event))</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; All text from text fields are received as base64-encoded strings. E.g. the text: </font>
+<font color='#555555'>;; '"Hello World"' would be received as: '"SGVsbG8gV29ybGQ="':</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; (gs:text-field 'TextField 'textfield-handler)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (define (textfield-handler id text)</font>
+<font color='#555555'>;;     (printnl id ": " (base64-dec text)))</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; When the text "Hello World" is entered in the text field, the following output</font>
+<font color='#555555'>;; would be generated:</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; TextField: "Hello World"</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; In case the ESC key is pressed in the text field, the event handler would</font>
+<font color='#555555'>;; report 'nil' for the text field. A handler should therefore always check text</font>
+<font color='#555555'>;; for string contents before trying to apply the 'base64-dec' function on it.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Mapping or applying 'gs:xxx' functions&lt;/h2&gt;</font>
+<font color='#555555'>;; Like any newLISP functions, 'gs:xxx' functions can be mapped or applied to lists of </font>
+<font color='#555555'>;; parameters using the newLISP 'map' and 'apply' functions. When doing this, make sure to </font>
+<font color='#555555'>;; map or apply the quoted &lt;tt&gt;'gs:xxx symbol&lt;/tt&gt;, so the &lt;tt&gt;gs:xx&lt;/tt&gt; functions </font>
+<font color='#555555'>;; get executed under the &lt;tt&gt;gs&lt;/tt&gt; context, prefixing symbols in parameter lists</font>
+<font color='#555555'>;; correctly with the context prefix of their origin.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (map 'gs:panel '(first second third fourth)) ; note quoted gs: function</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Some shortcuts when writing 'gs:xxx' functions&lt;/h2&gt;</font>
+<font color='#555555'>;; Due to the nature of transfer between newLISP and the guiserver as text, the following</font>
+<font color='#555555'>;; convenient shortcuts can be taken when writing functions:</font>
+<font color='#555555'>;; &lt;blockquote&gt;</font>
+<font color='#555555'>;; &lt;ul&gt;</font>
+<font color='#555555'>;; &lt;li&gt;Symbol ids of components can be expressed as strings.&lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;Number values can be expressed as strings.&lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;Numbers can be expressed as floats or integers.&lt;/li&gt;</font>
+<font color='#555555'>;; &lt;/ul&gt;</font>
+<font color='#555555'>;; &lt;/blockquote&gt;</font>
+<font color='#555555'>;; Here are some examples:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;     (gs:panel 'ColorPanel 360 200)</font>
+<font color='#555555'>;;     ; is the same as</font>
+<font color='#555555'>;;     (gs:panel "ColorPanel" 360 200)</font>
+<font color='#555555'>;;     ; is the same as</font>
+<font color='#555555'>;;     (gs:panel "ColorPanel" "360" "200")</font>
+<font color='#555555'>;;     ; is the same as</font>
+<font color='#555555'>;;     (gs:panel "ColorPanel" 360.0 "200.00")</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; Although the first form is preferred for clarity and readability, in some cases coding</font>
+<font color='#555555'>;; may be more efficient using the other forms.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Except for the symbols used for action handlers, all symbols are used only by their</font>
+<font color='#555555'>;; face (term) value. This means that reserved symbols of the newLISP programming</font>
+<font color='#555555'>;; language can be used freely in symbol ids for all components, e.g:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;     (gs:label 'term "Input here") ; term is a reserved name since v10.2.0</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; The usage of the reserved symbol 'term' will not pose a problem.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Return values&lt;/h2&gt;</font>
+<font color='#555555'>;; newLISP-GS is an event driven asynchronous system. Most functions return</font>
+<font color='#555555'>;; right away the number of characters sent out to the server.</font>
+<font color='#555555'>;; In general, return values of 'gs:xxx' functions do not have</font>
+<font color='#555555'>;; any specific meaning and can be discarded. Only the functions 'gs:get-bounds',</font>
+<font color='#555555'>;; 'gs:get-fonts', 'gs:get-font-metrics', 'gs:get-instruments'</font>
+<font color='#555555'>;; 'gs:get-screen', 'gs:get-text' and 'gs:get-version' return meaningful values or</font>
+<font color='#555555'>;; lists of values, which are stored in similar named variables: 'gs:bounds',</font>
+<font color='#555555'>;; 'gs:fonts', 'gs:font-metrics', 'gs:instruments', 'gs:screen', 'gs:text' and</font>
+<font color='#555555'>;; 'gs:version'. These functions will not return right away but block until</font>
+<font color='#555555'>;; the return valuse is sent back from newLISP-GS.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The function 'gs:get-text' can work both ways: event driven or with a return</font>
+<font color='#555555'>;; value depending on the call pattern used.</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;h2&gt;Function overview&lt;/h2&gt;</font>
+<font color='#555555'>;; &lt;ul&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Initialization and application setup&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:init [&lt;server-port&gt;])</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; The initialization function starts &lt;tt&gt;guiserver.jar&lt;/tt&gt; which will listen to the &lt;i&gt;server-port&lt;/i&gt;</font>
+<font color='#555555'>;; and initiate another connection on &lt;tt&gt;server-port + 1&lt;/tt&gt; back to newLISP. If a &lt;server-port&gt;</font>
+<font color='#555555'>;; is not supplied &lt;tt&gt;guiserver&lt;/tt&gt; will assume &lt;tt&gt;64001&lt;/tt&gt; and &lt;tt&gt;64002&lt;/tt&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; As the last statement in the application put:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:listen)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; This function listens on &lt;tt&gt;64002&lt;/tt&gt; (by default) for event messages from newLISP-GS</font>
+<font color='#555555'>;; and dispatches them to the user-defined action handlers. To avoid newLISP shutting down</font>
+<font color='#555555'>;; when the guiserver shuts down, use:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:listen true)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; Sometimes it is necessary to run other tasks while listening for events. In this case use</font>
+<font color='#555555'>;; 'gs:check-event', which will wait for certain amount of microseconds for an event</font>
+<font color='#555555'>;; to be executed. After the wait-time, it returns. The function is typically used in a loop:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (while (gs:check-event 10000) ; check for 10 milli seconds</font>
+<font color='#555555'>;;			(do-myprocess))</font>
+<font color='#555555'>;;    (exit)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; The loop will exit when 'gs:check-event' returns 'nil' on communications errors, e.g.</font>
+<font color='#555555'>;; when the window's close button was clicked.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Containers&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; A &lt;em&gt;container&lt;/em&gt; can contain any other container or control widget. Except for the </font>
+<font color='#555555'>;; &lt;tt&gt;menu-bar&lt;/tt&gt; and the &lt;tt&gt;split-pane&lt;/tt&gt;, containers can have a special layout-manager set </font>
+<font color='#555555'>;; with one of the three layout-manager function commands. By default containers have a flow layout. By</font>
+<font color='#555555'>;; nesting different containers and using different layout-manager settings, complex layouts</font>
+<font color='#555555'>;; can be configured. The function/command &lt;tt&gt;add-to&lt;/tt&gt; is used to add components to containers.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:dialog &lt;sym-id&gt; &lt;sym-parent-frame&gt; &lt;str-message&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;boolean-visible&gt; [&lt;boolean-modal&gt;]])</font>
+<font color='#555555'>;;    (gs:frame &lt;sym-id&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;str-title&gt; &lt;boolean-visible&gt;])</font>
+<font color='#555555'>;;    (gs:menu-bar &lt;sym-frame&gt; [&lt;sym-menu-1&gt; ...])  </font>
+<font color='#555555'>;;    (gs:panel &lt;sym-id&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;;    (gs:scroll-pane &lt;sym-id&gt; &lt;sym-widget&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;;    (gs:split-pane &lt;sym-id&gt; &lt;str-orientation&gt; [&lt;float-weight&gt; [&lt;float-location&gt; [int-divider-size&gt;]]])</font>
+<font color='#555555'>;;    (gs:tabbed-pane &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-orientation&gt; [&lt;sym-widget&gt; &lt;sym-tab-title&gt; ...])</font>
+<font color='#555555'>;;    (gs:tool-bar &lt;sym-frame&gt; [&lt;bool-floatable&gt; &lt;int-hgap&gt; &lt;int-vgap&gt;])</font>
+<font color='#555555'>;;    (gs:canvas &lt;sym-id&gt;) </font>
+<font color='#555555'>;;    (gs:window &lt;sym-id&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt;)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Labels&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; Labels can have text or an image or both. A normal text &lt;tt&gt;label&lt;/tt&gt; can have an icon</font>
+<font color='#555555'>;; added to it and a &lt;tt&gt;image-label&lt;/tt&gt; can have text added to it. Labels don't initiate</font>
+<font color='#555555'>;; actions and can be placed in any container like all button-type widgets - buttons, checkboxes</font>
+<font color='#555555'>;; and menu items. A basic set of icon images is built into &lt;tt&gt;guiserver.jar&lt;/tt&gt;,</font>
+<font color='#555555'>;; but user-supplied images and icons in &lt;tt&gt;.jpg&lt;/tt&gt;, &lt;tt&gt;.png&lt;/tt&gt; and &lt;tt&gt;.gif&lt;/tt&gt; formats</font>
+<font color='#555555'>;; can be used.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:label &lt;sym-id&gt; &lt;str-text&gt; [&lt;str-align&gt; [&lt;int-width&gt; &lt;int-height&gt;]])</font>
+<font color='#555555'>;;    (gs:image-label &lt;sym-id&gt; &lt;str-icon-path&gt; [&lt;str-align&gt;])</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Control widgets&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; Except for the passive progress bar, all control widgets fire action requests to</font>
+<font color='#555555'>;; the newLISP program. These requests must be served to avoid error messages but can</font>
+<font color='#555555'>;; be defined as empty functions, if an action is not required:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    ; empty action definition</font>
+<font color='#555555'>;;    (define (my-button-action) )</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;;    ; action handler printing the name of the button pressed</font>
+<font color='#555555'>;;    (define (my-button-action id) (println id " has been pressed"))</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; All action events calls carry information about the widget, that initiated that the event,</font>
+<font color='#555555'>;; and event parameters like keystrokes, slider positions etc..</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:button &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; [&lt;int-width&gt; &lt;int-height&gt;]])</font>
+<font color='#555555'>;;    (gs:check-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; [&lt;bool-selected&gt;]])</font>
+<font color='#555555'>;;    (gs:combo-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-item-1&gt; ...])</font>
+<font color='#555555'>;;    (gs:combo-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;list-str-items&gt;])</font>
+<font color='#555555'>;;    (gs:image-button &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-icon-path&gt; [&lt;str-down-icon-path&gt; [&lt;int-width&gt; &lt;int-height&gt;]])</font>
+<font color='#555555'>;;    (gs:list-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-item-1&gt; ...])</font>
+<font color='#555555'>;;    (gs:list-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;list-str-items&gt;])</font>
+<font color='#555555'>;;    (gs:menu &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;;    (gs:menu-popup &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;;    (gs:menu-item &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;;    (gs:menu-item-check &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-text&gt; [&lt;bool-selected&gt;])</font>
+<font color='#555555'>;;    (gs:progress-bar &lt;sym-id&gt; &lt;int-min&gt; &lt;in-max&gt; &lt;int-initial-value&gt;)</font>
+<font color='#555555'>;;    (gs:radio-button &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; [&lt;bool-selected&gt;]])</font>
+<font color='#555555'>;;    (gs:slider &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-orientation&gt; &lt;int-min&gt; &lt;int-max&gt; &lt;int-initial-value&gt;)</font>
+<font color='#555555'>;;    (gs:text-area &lt;sym-id&gt; &lt;sym-action&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;;    (gs:text-field &lt;sym-id&gt; &lt;sym-action&gt; &lt;int-columns&gt;[&lt;str-echo-char&gt;])</font>
+<font color='#555555'>;;    (gs:text-pane &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-style&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;;    (gs:toggle-button &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; &lt;bool-selected&gt;])</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; For all button widgets, and the check box and menu-item widgets, icons can be set using </font>
+<font color='#555555'>;; the 'gs:set-icon' and 'gs:set-pressed-icon' functions.</font>
+<font color='#555555'>;; &lt;/li&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Placing components in containers&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; For the flow and grid layouts the components are added in the sequence they are listed.</font>
+<font color='#555555'>;; The grid-layout fills the grid row by row starting with the left most column. </font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:add-to &lt;sym-container&gt; &lt;sym-component&gt; [&lt;sym-component ...])</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; For the border layout an orientation parameter is specified as either &lt;tt&gt;"north"&lt;/tt&gt;,</font>
+<font color='#555555'>;; &lt;tt&gt;"west"&lt;/tt&gt;, &lt;tt&gt;"center"&lt;/tt&gt;, &lt;tt&gt;"east"&lt;/tt&gt; or &lt;tt&gt;"south"&lt;/tt&gt;.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:add-to &lt;sym-container&gt; [&lt;sym-component&gt; &lt;str-orientation&gt; ...])</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Summary of commands&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; Most of the commands set special attributes of containers or control widgets. </font>
+<font color='#555555'>;; Not all functions can be applied to all containers and control widgets. A wrong</font>
+<font color='#555555'>;; application will either pop up an error message box or do nothing.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Some functions will work on certain widgets only in certain situations. For example</font>
+<font color='#555555'>;; &lt;tt&gt;set-size&lt;/tt&gt; will work not on components in a grid layout but on components</font>
+<font color='#555555'>;; in a flow layout. Some widgets have a preset background color which cannot be changed</font>
+<font color='#555555'>;; or is overwritten by the current 'gs:look-and-feel' settings.</font>
+<font color='#555555'>;;	&lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:add-list-item &lt;sym-list-combo&gt; &lt;str-text&gt; [&lt;str-text&gt; ...])</font>
+<font color='#555555'>;;    (gs:add-separator &lt;sym-menu-tool-bar&gt;)</font>
+<font color='#555555'>;;    (gs:add-to &lt;sym-container&gt; &lt;sym-component&gt; [&lt;sym-component ...])</font>
+<font color='#555555'>;;    (gs:add-to &lt;sym-container&gt; &lt;sym-component&gt; &lt;str-orientation&gt; [&lt;sym-component&gt; &lt;str-orientation&gt; ...])</font>
+<font color='#555555'>;;    (gs:append-text &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;;    (gs:check-event &lt;int-microseconds&gt;)</font>
+<font color='#555555'>;;    (gs:clear-list &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:clear-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:copy-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:cut-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:destroy-shell &lt;sym-text-area&gt;)</font>
+<font color='#555555'>;;    (gs:disable &lt;sym-id-1&gt; [&lt;sym-id-2&gt; ...])</font>
+<font color='#555555'>;;    (gs:dispose &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:dispose-splash)</font>
+<font color='#555555'>;;    (gs:enable &lt;sym-id-1&gt; [&lt;sym-id-2&gt; ...])</font>
+<font color='#555555'>;;    (gs:eval-shell &lt;sym-text-area&gt; &lt;str-commmand&gt;)</font>
+<font color='#555555'>;;    (gs:find-text &lt;sym-id&gt; &lt;str-text&gt; &lt;sym-action&gt; [&lt;str-direction&gt;]])</font>
+<font color='#555555'>;;    (gs:frame-closed &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:get-fonts)</font>
+<font color='#555555'>;;    (gs:get-bounds &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:get-font-metrics &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;;    (gs:get-screen)</font>
+<font color='#555555'>;;    (gs:get-selected-text &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:get-text &lt;sym-id&gt; [&lt;sym-action&gt;])</font>
+<font color='#555555'>;;    (gs:get-text-position &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:get-version);</font>
+<font color='#555555'>;;    (gs:goto-text &lt;sym-id&gt; &lt;sym-row&gt; &lt;sym-column&gt;)</font>
+<font color='#555555'>;;    (gs:insert-list-item &lt;sym-list-combo&gt; &lt;str-text&gt; &lt;int-index&gt; [&lt;str-text&gt; &lt;int-index&gt;])</font>
+<font color='#555555'>;;    (gs:insert-tab &lt;sym-tabbed-pane&gt; &lt;sym-component&gt; [&lt;str-text&gt; [&lt;int-index&gt; [&lt;str-icon-path&gt;]])</font>
+<font color='#555555'>;;    (gs:insert-text &lt;sym-id&gt; &lt;str-text&gt; &lt;int-pos&gt;)</font>
+<font color='#555555'>;;    (gs:layout &lt;sym-container&gt;)</font>
+<font color='#555555'>;;    (gs:load-text &lt;sym-id&gt; &lt;str-path&gt;)</font>
+<font color='#555555'>;;    (gs:no-action)</font>
+<font color='#555555'>;;    (gs:paste-text &lt;sym-id&gt; [&lt;str-text&gt;])</font>
+<font color='#555555'>;;    (gs:redo-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:remove-from &lt;sym-container&gt; &lt;sym-component&gt; [&lt;sym-component&gt; ...])</font>
+<font color='#555555'>;;    (gs:remove-list-item &lt;sym-list-combo&gt; &lt;int-index&gt; [&lt;int-index&gt; ...])</font>
+<font color='#555555'>;;    (gs:remove-tab &lt;sym-tabbed-pane&gt; &lt;int-index&gt;)</font>
+<font color='#555555'>;;    (gs:request-focus &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:run-shell &lt;sym-text-area&gt; &lt;str-commmand&gt; &lt;str-args&gt;)</font>
+<font color='#555555'>;;    (gs:select-list-item &lt;sym-id&gt; &lt;str-item&gt; [&lt;boolean-flag&gt;])</font>
+<font color='#555555'>;;    (gs:select-text &lt;sym-id&gt; &lt;int-from&gt; [&lt;int-to&gt;])</font>
+<font color='#555555'>;;    (gs:set-accelerator &lt;sym-menu-item&gt; &lt;str-keystroke&gt;)</font>
+<font color='#555555'>;;    (gs:set-background &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-background &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-bevel-border &lt;sym-panel&gt; &lt;str-type&gt;)</font>
+<font color='#555555'>;;    (gs:set-border-layout &lt;sym-container&gt;  [&lt;int-hgap&gt; &lt;int-vgap&gt;])</font>
+<font color='#555555'>;;    (gs:set-caret &lt;sym-id&gt; &lt;int-offset&gt;)</font>
+<font color='#555555'>;;    (gs:set-caret-color &lt;sym-id&gt; &lt;list-rgb&gt;)</font>
+<font color='#555555'>;;    (gs:set-caret-color &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt;)</font>
+<font color='#555555'>;;    (gs:set-color &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-color &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-cursor &lt;sym-id&gt; &lt;str-shape&gt;)</font>
+<font color='#555555'>;;    (gs:set-echo-char &lt;sym-id&gt; &lt;str-echo-char&gt;)</font>
+<font color='#555555'>;;    (gs:set-editable &lt;sym-id&gt; &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;;    (gs:set-flow-layout &lt;sym-container&gt; [&lt;str-alignment&gt; [&lt;int-hgap&gt; &lt;int-vgap&gt;]])</font>
+<font color='#555555'>;;    (gs:set-font &lt;sym-id&gt; &lt;str-family&gt; &lt;int-size&gt; &lt;str-type&gt;)</font>
+<font color='#555555'>;;    (gs:set-foreground &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-foreground &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-grid-layout &lt;sym-container&gt; &lt;int-rows&gt; &lt;int-columns&gt; [&lt;int-hgap&gt; &lt;int-vgap&gt;])</font>
+<font color='#555555'>;;    (gs:set-icon &lt;sym-id&gt; &lt;str-icon-path&gt; [&lt;int-index&gt;])</font>
+<font color='#555555'>;;    (gs:set-look-and-feel &lt;str-look&gt;)</font>
+<font color='#555555'>;;    (gs:set-resizable &lt;sym-frame&gt; &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;;    (gs:set-pressed-icon &lt;sym-id&gt; &lt;str-icon-path&gt;)</font>
+<font color='#555555'>;;    (gs:set-selected &lt;sym-id&gt; &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;;    (gs:set-size &lt;sym-id&gt; &lt;int-width&gt; &lt;int-height&gt;)</font>
+<font color='#555555'>;;    (gs:set-selection-color &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;;    (gs:set-syntax &lt;sym-id&gt; &lt;str-type&gt;) </font>
+<font color='#555555'>;;    (gs:set-syntax-colors &lt;list-rgb-comments&gt; &lt;list-rgb-keywords&gt; &lt;list-rgb-string&gt; &lt;list-rgb-number&gt; &lt;list-rgb-quoted&gt; &lt;list-rgb-prantheses&gt;)</font>
+<font color='#555555'>;;    (gs:set-tab-size &lt;sym-id&gt; &lt;int-size&gt;)</font>
+<font color='#555555'>;;    (gs:set-text &lt;sym-id&gt; &lt;str-text&gt; [&lt;int-index&gt;])</font>
+<font color='#555555'>;;    (gs:set-titled-border &lt;sym-component&gt; &lt;str-title&gt;)</font>
+<font color='#555555'>;;    (gs:set-tool-tip &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;;    (gs:set-trace &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;;    (gs:set-utf8 &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;;    (gs:set-value &lt;sym-id&gt; &lt;int-value&gt;)</font>
+<font color='#555555'>;;    (gs:set-visible &lt;sym-id&gt; &lt;boolean-visible&gt;)</font>
+<font color='#555555'>;;    (gs:undo-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:undo-enable &lt;sym-id&gt; &lt;boolean-enabled&gt;)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;The Table UI&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;;  Since version 1.42 Guiserver has a table widget and supporting functions.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:table &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-column-header-name&gt; ...])</font>
+<font color='#555555'>;;    (gs:table-add-column &lt;sym-id&gt; &lt;str-column-header-name&gt; ...)</font>
+<font color='#555555'>;;    (gs:table-add-row &lt;sym-id&gt; [&lt;str-columns&gt; ... ])</font>
+<font color='#555555'>;;    (gs:table-get &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:table-get-cell &lt;sym-id&gt; &lt;int-row&gt; &lt;int-column&gt;)</font>
+<font color='#555555'>;;    (gs:table-get-size &lt;sym-id&gt;)</font>
+<font color='#555555'>;;    (gs:table-remove-row &lt;sym-id&gt; &lt;int-row&gt;</font>
+<font color='#555555'>;;    (gs:table-set-cell &lt;sym-id&gt; &lt;int-row&gt; &lt;int-column&gt; &lt;str-value&gt;)</font>
+<font color='#555555'>;;    (gs:table-set-column &lt;sym-id&gt; &lt;int-column-number&gt; &lt;int-width&gt; [&lt;str-justification&gt;])</font>
+<font color='#555555'>;;    (gs:table-set-column-name &lt;sym-id&gt; [&lt;str-name1&gt; [&lt;str-name2&gt; ...])</font>
+<font color='#555555'>;;    (gs:table-set-row-count &lt;sym-id&gt; &lt;int-count&gt;</font>
+<font color='#555555'>;;    (gs:table-set-row-number &lt;sym-id&gt; &lt;bool-row-number&gt;) DEPRECATED use gs:table-show-row-number</font>
+<font color='#555555'>;;    (gs:table-show-row-number &lt;sym-id&gt; &lt;bool-row-number&gt;)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Special dialogs&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;;  These are standard dialogs for opening and saving files and for choosing colors.</font>
+<font color='#555555'>;;  Each dialog when closed fires an event for which a handler function must be</font>
+<font color='#555555'>;;  defined by the newLISP program. </font>
+<font color='#555555'>;;	&lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:color-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; &lt;str-title&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt;)</font>
+<font color='#555555'>;;    (gs:message-dialog &lt;sym-parent-frame&gt; &lt;str-title&gt; &lt;str-message&gt; [&lt;str-type&gt; [&lt;str-icon-path&gt;]])</font>
+<font color='#555555'>;;    (gs:confirm-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; &lt;str-title&gt; &lt;str-message&gt; [&lt;str-type&gt;])</font>
+<font color='#555555'>;;    (gs:open-file-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; [&lt;str-directory&gt; [&lt;str-mask&gt; &lt;str-description&gt;]])</font>
+<font color='#555555'>;;    (gs:save-file-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; [&lt;str-directory&gt; [&lt;str-initial-file&gt; [&lt;str-mask&gt; &lt;str-description&gt;]]])</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;2D Graphics functions&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; Every call to a 'gs:draw-xxx' or 'gs:fill-xxx' function will create a new graphics object, which</font>
+<font color='#555555'>;; will persist until destroyed by a call to 'gs:delete-tag'. Graphics objects are animated</font>
+<font color='#555555'>;; using the tag operations 'gs:move-tag', 'gs:rotate-tag', 'gs:scale-tag' and </font>
+<font color='#555555'>;; 'gs:shear-tag' or using 'gs:hide-tag' and 'gs:show-tag'. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Any 'gs:draw-xxx' or 'gs:fill-xxx' will create graphics objects but not force a screen update.</font>
+<font color='#555555'>;; The canvas is automatically redrawn when made visible for the first time using 'gs:set-visible' or</font>
+<font color='#555555'>;; after a call to 'gs:update'. Redrawing is also forced when resizing the window which hosts the canvas</font>
+<font color='#555555'>;; or any action covering and uncovering the canvas. </font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; After all tag operations redrawing is initiated by default, but it can be forced off by specifying </font>
+<font color='#555555'>;; 'nil' as the last parameter in a 'gs:xxx-tag' command. Suppressing immediate redraw is useful to avoid </font>
+<font color='#555555'>;; flicker when a batch of tag operations is performed.</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; Every graphics object (line, shape, text, or image) carries a group tag. Objects are deleted</font>
+<font color='#555555'>;; using 'gs:delete-tag' and will disappear immediately from the canvas. Using 'gs:move-tag'</font>
+<font color='#555555'>;; lines, shapes, text and images can be moved to a different position.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; All positions given in &lt;tt&gt;int x&lt;/tt&gt; and &lt;tt&gt;int y&lt;/tt&gt; must be given as integers. Values</font>
+<font color='#555555'>;; will not be converted automatically as is the case with newLISP's built-in functions. To</font>
+<font color='#555555'>;; guarantee integer type, values can be casted e.g.: </font>
+<font color='#555555'>;; &lt;pre&gt;(gs:draw-circle 'MyCircle (int x) (int y) (int r))&lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:color-tag &lt;sym-tag&gt; &lt;list-rgb&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:delete-tag &lt;sym-tag&gt;[&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:draw-arc &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-start&gt; &lt;int-angle&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-circle &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-ellipse &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius-x&gt; &lt;int-radius-y&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-image &lt;sym-tag&gt; &lt;str-path&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;;    (gs:draw-line &lt;sym-tag&gt; &lt;int-x1&gt; &lt;int-y1&gt; &lt;int-x2&gt; &lt;int-y2&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-path &lt;sym-tag&gt; &lt;list-points&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-polygon &lt;sym-tag&gt; &lt;list-points&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-round-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-arc-width&gt; &lt;int-arc-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:draw-text &lt;sym-tag&gt; &lt;str-text&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;list-rgb&gt; [&lt;float-angle&gt;]])</font>
+<font color='#555555'>;;    (gs:export &lt;str-path-file&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;;    (gs:fill-arc &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-start&gt; &lt;int-angle&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:fill-circle &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:fill-ellipse &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius-x&gt; &lt;int-radius-y&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:fill-polygon &lt;sym-tag&gt; &lt;list-points&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:fill-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:fill-round-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-arc-width&gt; &lt;int-arc-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;;    (gs:hide-tag &lt;sym-tag&gt;  [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:move-tag &lt;sym-tag&gt; &lt;int-dx&gt; &lt;int-dy&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:reorder-tags &lt;list-tags&gt;)</font>
+<font color='#555555'>;;    (gs:rotate-tag &lt;sym-tag&gt; &lt;float theta&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:save-text &lt;sym-id&gt; &lt;str-path&gt;)</font>
+<font color='#555555'>;;    (gs:scale-tag &lt;sym-tag&gt; &lt;float-x&gt; &lt;float-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:shear-tag &lt;sym-tag&gt; &lt;float-x&gt; &lt;float-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:show-popup &lt;sym-tag&gt; &lt;sym-host&gt; &lt;int-x&gt; &lt;int-y&gt;)</font>
+<font color='#555555'>;;    (gs:show-tag &lt;sym-tag&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:set-canvas &lt;sym-tag&gt;)</font>
+<font color='#555555'>;;    (gs:set-paint &lt;list-rgb&gt;)</font>
+<font color='#555555'>;;    (gs:set-rotation &lt;float-angle&gt;)</font>
+<font color='#555555'>;;    (gs:set-scale &lt;int-x&gt; &lt;int-y&gt;)</font>
+<font color='#555555'>;;    (gs:set-stroke &lt;float-width&gt; [&lt;str-cap&gt; [&lt;str-join&gt; [&lt;float-miterlimit&gt;]]])</font>
+<font color='#555555'>;;    (gs:set-translation &lt;int-x&gt; &lt;int-y&gt;)</font>
+<font color='#555555'>;;    (gs:set-anti-aliasing &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;;    (gs:translate-tag &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;;    (gs:update)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Events&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; Additionally to the event actions registered when creating a widget,</font>
+<font color='#555555'>;; the canvas, windows and dialogs can fire events as a result of key or mouse</font>
+<font color='#555555'>;; actions or when the position or size of a windows or dialog has changed.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:key-event &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:mouse-clicked &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;;    (gs:mouse-dragged &lt;sym-canvas&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:mouse-event &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:mouse-moved &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;;    (gs:mouse-pressed &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;;    (gs:mouse-released &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;;    (gs:mouse-wheel &lt;sym-canvas&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:window-closed &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:window-moved &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;;    (gs:window-resized &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/li&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Built-in icons and images&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; The 'guiserver.jar' file has the following icons and images built in. Each of</font>
+<font color='#555555'>;; them is prefixed with the path '/local/'. For example '/local/newLISP128.png'</font>
+<font color='#555555'>;; addresses the newLISP logo of size 128x128. To address images outside of</font>
+<font color='#555555'>;; 'guiserver.jar', use a normal file path suitable to your platform. On MS Windows</font>
+<font color='#555555'>;; use forward slashes instead of backslashes.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; Image path</font>
+<font color='#555555'>;; ----------</font>
+<font color='#555555'>;; clear-down32.png</font>
+<font color='#555555'>;; clear32.png</font>
+<font color='#555555'>;; copy-down32.png</font>
+<font color='#555555'>;; copy32.png</font>
+<font color='#555555'>;; cut-down32.png</font>
+<font color='#555555'>;; cut32.png</font>
+<font color='#555555'>;; dotgray16.png</font>
+<font color='#555555'>;; dotgray32.png</font>
+<font color='#555555'>;; dotgreen16.png</font>
+<font color='#555555'>;; dotgreen32.png</font>
+<font color='#555555'>;; dotred16.png</font>
+<font color='#555555'>;; dotred32.png</font>
+<font color='#555555'>;; dotyellow16.png</font>
+<font color='#555555'>;; dotyellow32.png</font>
+<font color='#555555'>;; edit-down32.png</font>
+<font color='#555555'>;; edit32.png</font>
+<font color='#555555'>;; folder-closed-down32.png</font>
+<font color='#555555'>;; folder-closed32.png</font>
+<font color='#555555'>;; folder-opened-down32.png</font>
+<font color='#555555'>;; folder-opened32.png</font>
+<font color='#555555'>;; font-book-down32.png</font>
+<font color='#555555'>;; font-book32.png</font>
+<font color='#555555'>;; green10.png</font>
+<font color='#555555'>;; info-down32.png</font>
+<font color='#555555'>;; info32.png</font>
+<font color='#555555'>;; new-down32.png</font>
+<font color='#555555'>;; new32.png</font>
+<font color='#555555'>;; newLISP-down32.png</font>
+<font color='#555555'>;; newLISP128.png</font>
+<font color='#555555'>;; newLISP16.png</font>
+<font color='#555555'>;; newLISP20.png</font>
+<font color='#555555'>;; newLISP32.png</font>
+<font color='#555555'>;; newLISP64.png</font>
+<font color='#555555'>;; newLISPsplashWin.png</font>
+<font color='#555555'>;; paste-down32.png</font>
+<font color='#555555'>;; paste32.png</font>
+<font color='#555555'>;; pressedbutton32.png</font>
+<font color='#555555'>;; red10.png</font>
+<font color='#555555'>;; restart-down32.png</font>
+<font color='#555555'>;; restart32.png</font>
+<font color='#555555'>;; run-down32.png</font>
+<font color='#555555'>;; run32.png</font>
+<font color='#555555'>;; save-down32.png</font>
+<font color='#555555'>;; save32.png</font>
+<font color='#555555'>;; search-down32.png</font>
+<font color='#555555'>;; search32.png</font>
+<font color='#555555'>;; stop-down32.png</font>
+<font color='#555555'>;; stop32.png</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Predefined colors&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; The following colors are predefined:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; Name          rgb components</font>
+<font color='#555555'>;; ----          -------------- </font>
+<font color='#555555'>;; gs:black      (0.0 0.0 0.0)</font>
+<font color='#555555'>;; gs:blue       (0.0 0.0 1.0)</font>
+<font color='#555555'>;; gs:cyan       (0.0 1.0 1.0)</font>
+<font color='#555555'>;; gs:darkGray   (0.2509804 0.2509804 0.2509804)</font>
+<font color='#555555'>;; gs:gray       (0.5019608 0.5019608 0.5019608)</font>
+<font color='#555555'>;; gs:green      (0.0 1.0 0.0)</font>
+<font color='#555555'>;; gs:lightGray  (0.7529412 0.7529412 0.7529412)</font>
+<font color='#555555'>;; gs:magenta    (1.0 0.0 1.0)</font>
+<font color='#555555'>;; gs:orange     (1.0 0.78431374 0.0)</font>
+<font color='#555555'>;; gs:pink       (1.0 0.6862745 0.6862745)</font>
+<font color='#555555'>;; gs:red        (1.0 0.0 0.0)</font>
+<font color='#555555'>;; gs:white      (1.0 1.0 1.0)</font>
+<font color='#555555'>;; gs:yellow     (1.0 1.0 0.0)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; Colors in newLISP-GS can be specified as three (four with alpha component) single</font>
+<font color='#555555'>;; numbers or as a list of the three RGB values followed by the alpha channel number.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; (gs:set-background 'aPanel gs:magenta</font>
+<font color='#555555'>;; (gs:set-background 'aPanel 1.0 0 1</font>
+<font color='#555555'>;; (gs:set-background 'aPanel '(1 0 1)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; All of the above statements will produce the same background color on the &lt;tt&gt;aPanel&lt;/tt&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; &lt;li&gt;&lt;b&gt;Sound  and MIDI API&lt;/b&gt;&lt;br&gt;</font>
+<font color='#555555'>;; The newLISP-GS sound API uses the default saundbank and sound hardware installed </font>
+<font color='#555555'>;; on the platform newLISP-GS is running on. On Mac OS X nothing additional needs to be</font>
+<font color='#555555'>;; installed. On MS Windows and some Unix platforms a soundbank file needs to be installed.</font>
+<font color='#555555'>;; Soundbanks for the Java JRE can be obtained at:</font>
+<font color='#555555'>;; <font color='#308080'>@link</font> http://java.sun.com/products/java-media/sound/soundbanks.html http://java.sun.com/products/java-media/sound/soundbanks.html</font>
+<font color='#555555'>;; The demo files shipped with the newLISP-GS installation use the midsize soundbank. Other soundbanks</font>
+<font color='#555555'>;; may require different naming of instruments in the 'gs:midi-patch' statement. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The sound API is capable of playing of mutliple tracks at the same time</font>
+<font color='#555555'>;; depending on the sound hardware installed on a specific platform. Mac OS X platforms</font>
+<font color='#555555'>;; and most MS Windows platforms should be capable of playing 16 instruments (channels) at the</font>
+<font color='#555555'>;; the same time 32 on parallel sounding tracks. newLISP GS supports 128 instruments of the</font>
+<font color='#555555'>;; default soundbank installed.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On Mac OS X and MS Windows channel 9 is a special channel sounding a different rythm </font>
+<font color='#555555'>;; instrument for all 128 different keys/notes.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Basic capabilities of the sound API are shown in the demo files &lt;tt&gt;midi-demo.lsp&lt;/tt&gt;</font>
+<font color='#555555'>;; and &lt;tt&gt;midi2-demo.lsp&lt;/tt&gt; in the &lt;tt&gt;/usr/local/share/newlisp/guiserver/&lt;/tt&gt; or </font>
+<font color='#555555'>;; &lt;tt&gt;c:\Program files\newlisp\guiserver\&lt;/tt&gt; directory.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    (gs:add-track &lt;int channel&gt;&lt;list-notes&gt;)</font>
+<font color='#555555'>;;    (gs:channel-bend &lt;int-channel&gt; &lt;bend&gt;)</font>
+<font color='#555555'>;;    (gs:get-instruments)</font>
+<font color='#555555'>;;    (gs:instruments)</font>
+<font color='#555555'>;;    (gs:midi-bpm &lt;int-bpm&gt; [&lt;int-resolution&gt;])</font>
+<font color='#555555'>;;    (gs:midi-close)</font>
+<font color='#555555'>;;    (gs:midi-init [&lt;str-file-path&gt;])</font>
+<font color='#555555'>;;    (gs:midi-patch &lt;int-instrument&gt; [&lt;int-channel&gt;])</font>
+<font color='#555555'>;;    (gs:mute-track &lt;int-track&gt; &lt;bool-on-off&gt;)</font>
+<font color='#555555'>;;    (gs:play-note &lt;int-key&gt; [&lt;int-duration&gt; [&lt;int-velocity&gt; [&lt;int-channel&gt; [int-bend]]]])</font>
+<font color='#555555'>;;    (gs:play-sequence [&lt;int-start-tick&gt; [&lt;int-loop-count&gt; [&lt;int-start-loop&gt; [&lt;int-end-loop&gt;]]]])</font>
+<font color='#555555'>;;    (gs:save-sequence &lt;str-file-path&gt;)</font>
+<font color='#555555'>;;    (gs:stop-sequence)</font>
+<font color='#555555'>;;    (gs:play-sound &lt;str-file-path&gt;)</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;; &lt;/ul&gt;</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>context</font> 'gs<font color='#AA0000'>)</font>
+
+<font color='#555555'>; ======================= preset colors</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:black '<font color='#AA0000'>(</font><font color='#665500'>0.0</font> <font color='#665500'>0.0</font> <font color='#665500'>0.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:blue '<font color='#AA0000'>(</font><font color='#665500'>0.0</font> <font color='#665500'>0.0</font> <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:cyan '<font color='#AA0000'>(</font><font color='#665500'>0.0</font> <font color='#665500'>1.0</font> <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:darkGray '<font color='#AA0000'>(</font><font color='#665500'>0.2509804</font> <font color='#665500'>0.2509804</font> <font color='#665500'>0.2509804</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:gray '<font color='#AA0000'>(</font><font color='#665500'>0.5019608</font> <font color='#665500'>0.5019608</font> <font color='#665500'>0.5019608</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:green '<font color='#AA0000'>(</font><font color='#665500'>0.0</font> <font color='#665500'>1.0</font> <font color='#665500'>0.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:lightGray '<font color='#AA0000'>(</font><font color='#665500'>0.7529412</font> <font color='#665500'>0.7529412</font> <font color='#665500'>0.7529412</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:magenta '<font color='#AA0000'>(</font><font color='#665500'>1.0</font> <font color='#665500'>0.0</font> <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:orange '<font color='#AA0000'>(</font><font color='#665500'>1.0</font> <font color='#665500'>0.78431374</font> <font color='#665500'>0.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:pink '<font color='#AA0000'>(</font><font color='#665500'>1.0</font> <font color='#665500'>0.6862745</font> <font color='#665500'>0.6862745</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:red '<font color='#AA0000'>(</font><font color='#665500'>1.0</font> <font color='#665500'>0.0</font> <font color='#665500'>0.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:white '<font color='#AA0000'>(</font><font color='#665500'>1.0</font> <font color='#665500'>1.0</font> <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:yellow '<font color='#AA0000'>(</font><font color='#665500'>1.0</font> <font color='#665500'>1.0</font> <font color='#665500'>0.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+<font color='#555555'>; ====================== utility routines</font>
+
+<font color='#555555'>; set server path</font>
+<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>=</font> ostype <font color='#008800'>"Windows"</font><font color='#AA0000'>)</font>
+	<font color='#555555'>; on some MS Windows systems the jar -> javaw.exe association my be missing, the use the following:</font>
+	<font color='#555555'>;(set 'server-path (string "javaw.exe -jar " "'&#092;&#034;" (env "NEWLISPDIR") "/guiserver.jar&#092;&#034;'")) </font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'server-path <font color='#AA0000'>(</font><font color='#0000AA'>string</font>  <font color='#008800'>"'&#092;&#034;"</font> <font color='#AA0000'>(</font><font color='#0000AA'>env</font> <font color='#008800'>"NEWLISPDIR"</font><font color='#AA0000'>)</font> <font color='#008800'>"/guiserver.jar&#092;&#034;'"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'server-path <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>env</font> <font color='#008800'>"NEWLISPDIR"</font><font color='#AA0000'>)</font> <font color='#008800'>"/guiserver.jar"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>; Not documented gs:begin-cmd and gs:end-cmd</font>
+<font color='#555555'>; sends graphics ommands in transactions, to be used in:</font>
+<font color='#555555'>;</font>
+<font color='#555555'>; draw-arc, draw-circle, draw-ellipse, draw-image, draw-line, </font>
+<font color='#555555'>; draw-path, draw-polyon, draw-rect, draw-round-rect, draw-text,</font>
+<font color='#555555'>;</font>
+<font color='#555555'>; fill-arc, fill-circle, fill-ellipse, fill-polygon, fill-rect, </font>
+<font color='#555555'>; fill-round-rect, </font>
+<font color='#555555'>;</font>
+<font color='#555555'>; color-tag, delete-tag, hide-tag, move-tag, rotate-tag, scale-tag,</font>
+<font color='#555555'>; shear-tag, translate-tag</font>
+<font color='#555555'>;</font>
+<font color='#555555'>; example:</font>
+<font color='#555555'>; (gs:begin-cmd)</font>
+<font color='#555555'>;   ; andy code containing </font>
+<font color='#555555'>;   ; gs:draw-xxx, gs:fill-xx, gs:xxx-tag</font>
+<font color='#555555'>;   ; comands</font>
+<font color='#555555'>; (gs:end-cmd)</font>
+<font color='#555555'>;</font>
+<font color='#555555'>; The whole command sequence between gs:begin-cmd and gs:end-cmd</font>
+<font color='#555555'>; will be sent at once to the Java guiserver. This way minimizing</font>
+<font color='#555555'>; network overhead. </font>
+<font color='#555555'>; Turns out, the speedup is too small in most of the demos.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:begin-cmd<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'transaction-active <font color='#0000AA'>true</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'transaction-buffer <font color='#008800'>""</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:end-cmd<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out transaction-buffer<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'transaction-buffer <font color='#008800'>""</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'transaction-active <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+	
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:send-out str<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> transaction-active
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> transaction-buffer str<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out str<font color='#AA0000'>)</font><font color='#555555'>;</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;&lt;br&gt;</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:add-list-item &lt;sym-list-combo&gt; &lt;str-text&gt; [&lt;str-text&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-list-combo&gt; The name of the combo box or list box to which text entries are added.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text of the entry to be added.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Items are added in the same sequence as they appear in the 'gs:add-list-item' command and added to the</font>
+<font color='#555555'>;; end of the existing list of items.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>add-list-item comp<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"add-list-item "</font> comp <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> item<font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:add-separator &lt;sym-menu-tool-bar&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-menu-tool-bar&gt; The name of the tool bar or menu bar to which a spacer entry is added.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Depending on the OS platform the separator may not be visible and only occupy space before the next </font>
+<font color='#555555'>;; component added to the tool or menu bar.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>add-separator bar<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"add-separator "</font> bar <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:add-track &lt;int-channel&gt; &lt;list-of-notes&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-channel&gt; The channel belonging to this track.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-of-notes&gt; A list of notes. Each note is a list of key duration velocity and bend.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; In case of 'gs:add-track' the duration of a note is given in ticks.</font>
+<font color='#555555'>;; 16 ticks are in a quarter note or &lt;em&gt;beat&lt;/em&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A note is a list of 4 elements: '(&lt;int-key&gt; &lt;int-duration&gt; &lt;int-velocity&gt; [&lt;int-bend&gt;])'. &lt;key&gt;</font>
+<font color='#555555'>;; &lt;duration&gt;, &lt;velocity&gt; and &lt;bend&gt; can be given as variables, which will be evaluated by</font>
+<font color='#555555'>;; 'gs:add-track'. The &lt;int-bend&gt;  parameter is optional and assumed as &lt;tt&gt;0&lt;/tt&gt; if not</font>
+<font color='#555555'>;; present. See the command 'gs:play-note' for more information on the note bend parameter.</font>
+<font color='#555555'>;; The following code is a complete example:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (load (append (env "NEWLISPDIR") "/guiserver.lsp"))</font>
+<font color='#555555'>;; (gs:init)</font>
+<font color='#555555'>;; (gs:midi-init)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (map set '(C C# D D# E F F# G G# A A# B c c# d e f f# g g# a a# b) (sequence 60 82))</font>
+<font color='#555555'>;; (set 'pp 30 'p 40 'm 64 'f 127) ; set velocity/volume</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:midi-patch "Piano" 0)</font>
+<font color='#555555'>;; (gs:midi-patch "Pizzicato Strings" 1)</font>
+<font color='#555555'>;; (gs:midi-patch "Woodblock" 2)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:add-track 0 '( (C 12 m) (C# 4 m) (D 16 m) (c 16 f) (D 16 m)) )</font>
+<font color='#555555'>;; (gs:add-track 1 (dup '(d 4 pp) 16))</font>
+<font color='#555555'>;; (gs:add-track 2 '( (c 4 p) (c 12 p) (c 4 p) (c 12 p) (c 4 p) (c 12 p)  (c 4 p) (c 12 p)) )</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:play-sequence)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (sleep 5000)</font>
+<font color='#555555'>;; (gs:midi-close)</font>
+<font color='#555555'>;; (exit)</font>
+
+<font color='#555555'>;; The second example shows the usage of pitch-bend in notes:</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (load (append (env "NEWLISPDIR") "/guiserver.lsp"))</font>
+<font color='#555555'>;; (gs:init)</font>
+<font color='#555555'>;; (gs:midi-init)</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; (gs:midi-patch "Piano" 0)</font>
+<font color='#555555'>;; (gs:midi-patch "Gunshot" 1)</font>
+<font color='#555555'>;; (gs:midi-patch "Telephone" 2)</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; (for (n -8192 8191 128) (push (list 64 1 95 n) track0 -1))</font>
+<font color='#555555'>;; (for (n 64 96 2) (push (list n 8 76) track1 -1))</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; (gs:add-track 0 track0)</font>
+<font color='#555555'>;; (gs:add-track 1 track1)</font>
+<font color='#555555'>;; (gs:add-track 2 '((44 128 127)))</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; (gs:play-sequence)</font>
+<font color='#555555'>;; ;(gs:save-sequence "extremeAlarm.mid")</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; (sleep 8000)</font>
+<font color='#555555'>;; (gs:midi-close)</font>
+<font color='#555555'>;; (exit)</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>add-track channel notes<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"add-track System "</font> channel <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>local</font> <font color='#AA0000'>(</font>bend<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>n notes<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'bend <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>=</font> <font color='#665500'>4</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> n<font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>eval</font> <font color='#AA0000'>(</font>n <font color='#665500'>3</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>eval</font> <font color='#AA0000'>(</font>n <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>eval</font> <font color='#AA0000'>(</font>n <font color='#665500'>1</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>eval</font> <font color='#AA0000'>(</font>n <font color='#665500'>2</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> bend <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:add-to &lt;sym-container&gt; &lt;sym-component&gt; [&lt;sym-componentl&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The name of the container to which components are added.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-component&gt; One or more symbols of the components to add.</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:add-to &lt;sym-container&gt; &lt;sym-component&gt; &lt;str-orientation&gt; [&lt;sym-component&gt; &lt;str-orientation&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The name of the container to which components are added.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-component&gt; The name of a component to add.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-orientation&gt; The orientation of a component to add in border layout, '"north"', '"west"', '"center"', '"east"' or '"south"'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>add-to id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"add-to "</font> id <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:append-text &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text field or text area to which text is appended.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to be appended.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>append-text id text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"append-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:button &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; [&lt;int-width&gt; &lt;int-height&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; An optional text for the button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the button.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>button id action text x y<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> x y<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:canvas &lt;sym-id&gt;) </font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the canvas.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A canvas is a panel for drawing and receiving mouse input events. For most</font>
+<font color='#555555'>;; applications a background color should be specified for the canvas using</font>
+<font color='#555555'>;; 'gs:set-background' or 'gs:set-color' which call the same function internally. The</font>
+<font color='#555555'>;; background forces the canvas to be cleared before redrawing components</font>
+<font color='#555555'>;; which have been moved, rotated, scaled or deleted. In applications where</font>
+<font color='#555555'>;; this is not desired but a background color is still required, the background</font>
+<font color='#555555'>;; color can be specified for the container hosting the canvas. The canvas</font>
+<font color='#555555'>;; background will then appear in the color of the container, but erasing</font>
+<font color='#555555'>;; the canvas before repainting is not enforced.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A canvas can also be used to host widgets like buttons etc.. In this case</font>
+<font color='#555555'>;; the canvas is treated like a 'gs:panel', with a flow layout by default.</font>
+<font color='#555555'>;; Similar to a panel created with 'gs:panel' other layouts can be set.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When widgets are present on a canvas they appear to be floating over</font>
+<font color='#555555'>;; the drawing. See the file 'textrot-demo.lsp' for an example.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>canvas id parent<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:currentCanvas id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"canvas "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:channel-bend &lt;int-channel&gt; &lt;bend&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-channel&gt; The channel where the pitch bend is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-bend&gt; The channel bend between &lt;tt&gt;0&lt;/tt&gt; and &lt;tt&gt;16383&lt;/tt&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Numbers upwards of &lt;tt&gt;8192&lt;/tt&gt; bend the tone upwards, numbers smaller</font>
+<font color='#555555'>;; than &lt;tt&gt;8192&lt;/tt&gt; bend the tone downwards. To switch off channel bend set</font>
+<font color='#555555'>;; the number to the middle posiotion of &lt;tt&gt;8192&lt;/tt&gt;. 'gs:channel-bend' can </font>
+<font color='#555555'>;; be used to bring a channel in tune with an external sound source.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>channel-bend channel bend<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"channel-bend System "</font> channel <font color='#008800'>" "</font> bend <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>; @syntax (gs:channel-reverb &lt;int-channel&gt; &lt;reverb&gt;)</font>
+<font color='#555555'>; @param &lt;int-channel&gt; The channel where the reverb is set.</font>
+<font color='#555555'>; @param &lt;int-reverb&gt; The channel reverb between &lt;tt&gt;0&lt;/tt&gt; and &lt;tt&gt;127&lt;/tt&gt;.</font>
+<font color='#555555'>;</font>
+<font color='#555555'>; Sets the reverberation of the channel for all notes.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>channel-reverb channel reverb<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"channel-reverb System "</font> channel <font color='#008800'>" "</font> reverb <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:check-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; [&lt;bool-selected&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the check box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text of the check box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bool-selected&gt; An optional flag indicating the selection state 'true' or 'nil' (default).</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>check-box id action text selected<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"check-box "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> selected <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"check-box "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:check-event &lt;int-microseconds&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-microseconds&gt; Wait for an event a maximum of &lt;int-microseconds&gt; and execute it.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The function 'gs:check-event' is used as an alternative to 'gs:listen' when the application</font>
+<font color='#555555'>;; is performing some activity while waiting for user input from the GUI. Typically</font>
+<font color='#555555'>;; 'gs:check-event' is used in a loop, which performs some other task and at the same time</font>
+<font color='#555555'>;; checks for events from the GUI part of the application. Like 'gs:listen' the function will </font>
+<font color='#555555'>;; force an exit of the application when communication between the newLISP-GS and the newLISP</font>
+<font color='#555555'>;; application process fails. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (while (gs:check-event 10000) ; check for 10 milliseconds</font>
+<font color='#555555'>;;     (do-myprocess)</font>
+<font color='#555555'>;; )</font>
+
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>check-event us , event<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>when</font> <font color='#AA0000'>(</font><font color='#0000AA'>net-select</font> in <font color='#008800'>"read"</font> us<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>net-receive</font> in event <font color='#665500'>1000000000</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>begin</font> 	
+			<font color='#555555'>;	(println "check-event: " event)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>eval-string</font> event<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>exit</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#0000AA'>true</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:clear-list &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sum-id&gt; The name of the list component in which to clear all entries.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>clear-list id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"clear-list "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:clear-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sum-id&gt; The name of the component in which to clear the text.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>clear-text id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"clear-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:copy-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sum-id&gt; The name of the text component from which to copy the selection to the clipboard.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>copy-text id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"copy-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:cut-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id-text&gt; The name of the text component from which to cut selected text and place it on the clipboard..</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>cut-text id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"cut-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:color-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; &lt;str-title&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-parent-frame&gt; The name symbol of the parent frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the handler to call when leaving the dialog</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The title of the color dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-red&gt; The initial red color component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-green&gt; The initial green color component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-blue&gt; The initial blue color component.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>color-dialog parent action title red green blue<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"color-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> title<font color='#AA0000'>)</font> <font color='#008800'>" "</font> red <font color='#008800'>" "</font> green <font color='#008800'>" "</font> blue <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:color-tag &lt;sym-tag&gt; &lt;list-color&gt; [&lt;boolean-update&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The name tag of the shape(s) to set a new color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-color&gt; The new color as a list of 3 numbers for the rgb components.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>color-tag tag color <font color='#AA0000'>(</font>update <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"color-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font>
+		<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> update <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:combo-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-item-1&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the combo box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-item&gt; Zero, one or more text entries in the combo box.</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:combo-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;list-str-items&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the combo box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-str-items&gt; Zero, one or more text entries in a list.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>combo-box id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>	s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"combo-box "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font><font color='#AA0000'>)</font>
+					entries <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>item entries<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> item<font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:confirm-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; &lt;str-title&gt; &lt;str-message&gt; [&lt;str-type&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-parent-frame&gt; The symbol name of the parent frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The action to perform when the diaog is closed.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The title of the message box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-message&gt; The message in the message box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-type&gt; The type of the message box.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The type of the message box can be one of: '"yes-no"', '"yes-no-cancel"'</font>
+<font color='#555555'>;; On return of the message box &lt;sym-action&gt; carries one of the responses &lt;tt&gt;0&lt;/tt&gt; for the yes-,</font>
+<font color='#555555'>;; &lt;tt&gt;1&lt;/tt&gt; for the no- or &lt;tt&gt;2&lt;/tt&gt; for the cancel-button.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>confirm-dialog parent action title msg <font color='#AA0000'>(</font>type <font color='#008800'>"plain"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"confirm-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> 
+						<font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> title<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> msg<font color='#AA0000'>)</font> <font color='#008800'>" "</font> type <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:delete-tag &lt;sym-tag&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group to be deleted.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Deletes all 2D objects (lines, shapes, text, images) tagged with &lt;sym-tag&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Each time a 'gs:draw-xxx' or 'gs:fill-xxx' function is called a graphical</font>
+<font color='#555555'>;; object is created. The tag used during creation is a way to address one</font>
+<font color='#555555'>;; or more of these objects. See the file 'mouse-demo.lsp' for an example.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>delete-tag tag <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"delete-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag  <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:destroy-shell &lt;sym-text-area&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-text-area&gt; The name of the text component for which the shell process is destroyed.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>destroy-shell id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"destroy-shell "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:dialog &lt;sym-id&gt; &lt;sym-parent&gt; &lt;str-title&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;boolean-visible&gt; [&lt;boolean-modal&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the dialog</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-parent&gt; The name of the parent frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The title string of the dialog frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the dialog frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the dialog frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-visible&gt; The optional flag with a value of 'true' or 'nil' for visibility of the dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-modal&gt; The optional flag with a value of 'true' or 'nil' for modality of the dialog.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Initially the dialog should not be visible until all widgets are added to it. </font>
+<font color='#555555'>;; When no flags for visibility and modality are specified, 'nil' is assumed. A modal dialog will</font>
+<font color='#555555'>;; prevent input in the parent window. Components can be added to a dialog using 'gs:add-to'.</font>
+<font color='#555555'>;; Use the 'gs:set-border-layout', 'ga:set-flow-layout' or 'gs:set-grid-layout' to set a specific</font>
+<font color='#555555'>;; layout.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>dialog id parent title width height visible modal<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"dialog "</font> id <font color='#008800'>" "</font> parent <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> title<font color='#AA0000'>)</font> <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> visible <font color='#008800'>" "</font> modal<font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:disable &lt;sym-id-1&gt; [sym-id-2 ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component to disable.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Disabled components are grayed and do not accept input.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>disable<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#008800'>"disable "</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:dispose &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component to dispose of.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Only objects created with 'gs:dialog', 'gs:frame' or 'gs:window' can be</font>
+<font color='#555555'>;; deleted with 'gs:dispose'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>dispose id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"dispose "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:dispose-splash)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A splash screen can be specified when starting the newLISP-GS process before newLISP. </font>
+<font color='#555555'>;; The function 'gs:dispose-splash' is used to turn off the splash image after</font>
+<font color='#555555'>;; the newLISP GUI application has started.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; java -jar /usr/share/newlisp/guiserver.jar 64001 program.lsp /local/newLISP128.png</font>
+<font color='#555555'>;; ; or on MS Windows</font>
+<font color='#555555'>;; java -jar "c:&#092;Program Files&#092;newlisp&#092;guiserver.jar" 64001 "newlisp program.lsp" /local/newLISPsplashWin.png</font>
+
+<font color='#555555'>;; The example starts newLISP-GS with an application 'program.lsp' and a splash</font>
+<font color='#555555'>;; screen showing the built-in newLISP logos and using port 64001/2. Instead, the full pathname </font>
+<font color='#555555'>;; of a different image file can be specified. Inside 'program.lsp' the function</font>
+<font color='#555555'>;; 'gs:dispose-splash' or a mouse click on the image will turn off the splash screen. </font>
+<font color='#555555'>;; For 'program.lsp' the full pathname may be necessary. On MS Windows quotes are necessary to bracket </font>
+<font color='#555555'>;; arguments to 'guiserver.jar' which contain spaces. </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>dispose-splash<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#008800'>"dispose-splash System&#092;n"</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font> 
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-arc &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-start&gt; &lt;int-angle&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-start-angle&gt; The start angle of the arc in 0 to 360 degrees.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-arc-angle&gt; The opening angle of the arc in 0 to 360 degrees.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The resulting arc begins at &lt;int-start-angle&gt; and extends for &lt;int-arc-angle degrees&gt;, </font>
+<font color='#555555'>;; using the current color. Angles are interpreted such that 0 degrees is at the 3 o'clock </font>
+<font color='#555555'>;; position. A positive value indicates a counter-clockwise rotation while a negative value </font>
+<font color='#555555'>;; indicates a clockwise rotation.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The center of the arc is the center of the rectangle whose origin is (x, y) and whose size </font>
+<font color='#555555'>;; is specified by the width and height arguments.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The resulting arc covers an area &lt;int-width&gt; pixels wide by &lt;int-height&gt; pixels tall.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-arc id x y width height start angle color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-arc "</font> gs:currentCanvas <font color='#008800'>" "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font>
+						width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> start <font color='#008800'>" "</font> angle <font color='#008800'>" "</font> 
+						<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-arc "</font> gs:currentCanvas <font color='#008800'>" "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font>
+						width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> start <font color='#008800'>" "</font> angle <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-circle &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the circle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the circle center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the circle center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-radius&gt; The radius of the circle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates the outline of a circle. The color numbers must be entered in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-circle tag x y radius color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-circle "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-circle "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-ellipse &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius-x&gt; &lt;int-radius-y&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the ellipse.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the ellipse center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the ellipse center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-radius-x&gt; The radius of the ellipse.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-radius-y&gt; The radius of the ellipse.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates the outline of an ellipse. The color numbers must be enterd in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-ellipse tag x y radius-x radius-y color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-ellipse "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius-x <font color='#008800'>" "</font> radius-y <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-ellipse "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius-x <font color='#008800'>" "</font> radius-y  <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-image &lt;sym-tag&gt; &lt;str-path&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the image.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-path&gt; The file path-name of the image.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the image top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the image top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width in which to draw the image.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height in which to draw the image.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When &lt;int-width&gt; and &lt;int-height&gt; parameters are specified and they are not</font>
+<font color='#555555'>;; equal to the original size of the image (measured in pixels) the image will</font>
+<font color='#555555'>;; be displayed in either compressed or zoomed form.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-image tag image-path x y width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-image "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> image-path<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-image "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> image-path<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font> 
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-line &lt;sym-tag&gt; &lt;int-x1&gt; &lt;int-y1&gt; &lt;int-x2&gt; &lt;int-y2&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tage of the line.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x1&gt; The X position of the first point.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y1&gt; The Y position of the first point.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x2&gt; The X position of the second point.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y2&gt; The Y position of the second point.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Draws a line. The color numbers must be entered in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-line tag x1 y1 x2 y2 color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-line "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font>
+			x1 <font color='#008800'>" "</font> y1 <font color='#008800'>" "</font> x2 <font color='#008800'>" "</font> y2 <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-path &lt;sym-tag&gt; &lt;list-points&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tage group of the path.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-points&gt; The list of x and y coordinates of the points.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Draws a path with the points found in &lt;list-points&gt;. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font> </font>
+<font color='#555555'>;; (gs:draw-path 'P '(1 0 2 2 3 0))</font>
+
+<font color='#555555'>;; The example will draw an upwards-pointing triangle without base at the </font>
+<font color='#555555'>;; points '1,0', '2,2' and '3,0' </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-path tag points color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-path "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>/</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> points<font color='#AA0000'>)</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>p points<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> p <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-path "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>/</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> points<font color='#AA0000'>)</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>p points<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> p <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-polygon &lt;sym-tag&gt; &lt;list-points&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the polygon.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-points&gt; The list of x and y coordinates of the points.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Draws a polygon with the points found in &lt;list-points&gt;. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font> </font>
+<font color='#555555'>;; (gs:draw-polygon 'P '(1 0 2 2 3 0))</font>
+
+<font color='#555555'>;; The example will draw an upwards-pointing triangle with the points '1,0', '2,2'</font>
+<font color='#555555'>;; and '3,0'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-polygon tag points color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-polygon "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>/</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> points<font color='#AA0000'>)</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>p points<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> p <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-polygon "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>/</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> points<font color='#AA0000'>)</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>p points<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> p <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the rectangle..</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates the outline of a rectangle. The color numbers must be entered in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-rect tag x y width height color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-round-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-arc-width&gt; &lt;int-arc-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the round rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the rectangle..</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-arc-width&gt; The width of the corner rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-arc-height&gt; The height of the corner rectangle..</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Draws a rectangle shape with round corners. The rounding is defined by the rectangle enclosing</font>
+<font color='#555555'>;; the rounding arc.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-round-rect tag x y width height arcw arch color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-round-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font>  arcw <font color='#008800'>" "</font> arch <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-round-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height  <font color='#008800'>" "</font> arcw <font color='#008800'>" "</font> arch <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:draw-text &lt;sym-tag&gt; &lt;str-text&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;list-rgb&gt; [&lt;float-angle&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to be drawn.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The optonal color for the text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-angle&gt; The optional angle for text in degrees</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used, the current paint specified with 'gs:set-paint' is used.</font>
+<font color='#555555'>;; The optional angle is &lt;tt&gt;0&lt;/tt&gt; by default for horizontal text. A value of &lt;tt&gt;90&lt;/tt&gt;</font>
+<font color='#555555'>;; will rotate the text around the &lt;tt&gt;x&lt;/tt&gt;, &lt;tt&gt;y&lt;/tt&gt; position downwards clockwise.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>draw-text tag text x y color angle<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> angle
+			<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-text "</font> gs:currentCanvas <font color='#008800'>" "</font>
+				tag <font color='#008800'>" "</font>  <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> angle <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-text "</font> gs:currentCanvas <font color='#008800'>" "</font>
+				tag <font color='#008800'>" "</font>  <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"draw-text "</font> gs:currentCanvas <font color='#008800'>" "</font>
+			tag <font color='#008800'>" "</font>  <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:enable &lt;sym-id-1&gt; [sym-id-2 ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of a component to enable.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Components are enabled by default.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>enable<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"enable "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:eval-shell &lt;sym-id-text-area&gt; &lt;str-command&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id-text-area&gt; The name of the text area in which to evaluate text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-command&gt; The text to evaluate in the shell.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>eval-shell id command<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"eval-shell "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> command<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:export &lt;str-path-file&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-path-file&gt; The path and file name of the image file to write to.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the image in pixels.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the image in pixels.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If no width and height are specified, the current size of the canvas is assumed.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:export "/usr/home/pictures/mypic.png")</font>
+
+<font color='#555555'>;; This will generate a '.png' file exactly as the image seen on the screen.</font>
+<font color='#555555'>;; The color format is RGBA with 8 bit per color and an alpha channel. When</font>
+<font color='#555555'>;; no background color is defined for the canvas, the background will be</font>
+<font color='#555555'>;; transparent.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When specifying width and height, a smaller or bigger portion of the canvas</font>
+<font color='#555555'>;; than seen on the screen is printed to the image.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>export image-path width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>result <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"export "</font> gs:currentCanvas <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> image-path<font color='#AA0000'>)</font> <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"export "</font> gs:currentCanvas <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> image-path<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+        <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>number?</font> result<font color='#AA0000'>)</font> <font color='#0000AA'>true</font> <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+			
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:fill-arc &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-start&gt; &lt;int-angle&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the arc.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-start-angle&gt; The start angle of the arc in 0 to 360 degrees.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-arc-angle&gt; The opening angle of the arc in 0 to 360 degrees.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The resulting arc begins at &lt;int-start-angle&gt; and extends for &lt;int-arc-angle degrees&gt;, </font>
+<font color='#555555'>;; using the current color. Angles are interpreted such that 0 degrees is at the 3 o'clock </font>
+<font color='#555555'>;; position. A positive value indicates a counter-clockwise rotation while a negative value </font>
+<font color='#555555'>;; indicates a clockwise rotation.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The center of the arc is the center of the rectangle whose origin is (x, y) and whose size </font>
+<font color='#555555'>;; is specified by the width and height arguments.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The resulting arc covers an area &lt;int-width&gt; pixels wide by &lt;int-height&gt; pixels tall.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>fill-arc id x y width height start angle color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-arc "</font> gs:currentCanvas <font color='#008800'>" "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font>
+						width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> start <font color='#008800'>" "</font> angle <font color='#008800'>" "</font> 
+						<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-arc "</font> gs:currentCanvas <font color='#008800'>" "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font>
+						width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> start <font color='#008800'>" "</font> angle <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:fill-circle &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the circle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the circle center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the circle center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-radius&gt; The radius of the circle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates a filled  circle. The color numbers must be entered in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used, the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>fill-circle tag x y radius color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-circle "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-circle "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:fill-ellipse &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-radius-x&gt; &lt;int-radius-y&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the ellipse.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the ellipse center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the ellipse center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-radius-x&gt; The radius of the ellipse.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-radius-y&gt; The radius of the ellipse.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The fill color as a list of 3 numbers for the rgb components.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates a filled ellipse. The color numbers must be entered in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used, the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>fill-ellipse tag x y radius-x radius-y color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-ellipse "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius-x <font color='#008800'>" "</font> radius-y <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-ellipse "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> radius-x <font color='#008800'>" "</font> radius-y  <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:fill-polygon &lt;sym-tag&gt; &lt;list-points&gt; [&lt;list-color&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the polygon.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-points&gt; The list of x and y coordinates of the points.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Draws a polygon with the points found in &lt;list-points&gt; and fills it with</font>
+<font color='#555555'>;; the current color set with 'gs:set-paint' or the optional color</font>
+<font color='#555555'>;; given in &lt;list-color&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font> </font>
+<font color='#555555'>;; (gs:fill-polygon 'P '(1 0 2 2 3 0))</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:fill-polygon 'P '(1 0 2 2 3 0) gs:gray)</font>
+
+<font color='#555555'>;; The example will fill an upwards pointing triangle with the points '1,0', '2,2'</font>
+<font color='#555555'>;; and '3,0' and fill it with the current color set with 'gs:set-paint'. The second</font>
+<font color='#555555'>;; example paints a gray triangle regardless of the current color set with</font>
+<font color='#555555'>;; 'gs:set-paint'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>fill-polygon tag points color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-polygon "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>/</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> points<font color='#AA0000'>)</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>p points<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> p <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-polygon "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>/</font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> points<font color='#AA0000'>)</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>p points<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> p <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font>send-out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:fill-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The fill color as a list of 3 numbers for the rgb components.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates a filled rectangle. The color numbers must be entered in list form.</font>
+<font color='#555555'>;; If no &lt;list-rgb&gt; is used, the current paint specified with 'gs:set-paint' is used.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>fill-rect tag x y width height color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:fill-round-rect &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; &lt;int-arc-width&gt; &lt;int-arc-height&gt; [&lt;list-rgb&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group of the round rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the top left corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the rectangle..</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-arc-width&gt; The width of the corner rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-arc-height&gt; The height of the corner rectangle.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The outline color as a list of 3 numbers for the rgb components.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Paints a rectangle shape with round corners. The rounding is defined by the rectangle enclosing</font>
+<font color='#555555'>;; the rounding arc.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>fill-round-rect tag x y width height arcw arch color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> color
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-round-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font>  arcw <font color='#008800'>" "</font> arch <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"fill-round-rect "</font> gs:currentCanvas <font color='#008800'>" "</font> 
+			tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height  <font color='#008800'>" "</font> arcw <font color='#008800'>" "</font> arch <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:find-text &lt;sym-id&gt; &lt;str-text&gt; &lt;sym-action&gt; [&lt;str-direction&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text area or text pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The searching text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; A optional action to peform after find-text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-direction&gt; The optional direction string '"next"' (default) or '"previous"'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The text area or text pane will be searched starting at the current caret position</font>
+<font color='#555555'>;; forward or backwards depending on the optional direction field. After the search</font>
+<font color='#555555'>;; the found text is highlighted. If the optional &lt;sym-action&gt; is specified an event</font>
+<font color='#555555'>;; containing the id of the text area or pane and found position or '-1' will be fired.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>find-text id text action <font color='#AA0000'>(</font>direction <font color='#008800'>"next"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"find-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> action <font color='#008800'>" "</font> direction <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:frame &lt;sym-id&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt; [&lt;str-title&gt; &lt;boolean-visible&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the frame window.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X position of the top left window corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y position of the top left windows corner.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the window frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the windows frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The optional title of the window.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-visible&gt; The optional flag with a value of 'true' or 'nil' for the visibility of the window.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Initially the frame should not be visible until all widgets are added to it. </font>
+<font color='#555555'>;; When no flag for visibility is specified 'nil' is assumed. The default layout of a frame behaves</font>
+<font color='#555555'>;; like a grid layout with one cell. Use the 'set-flow-layout', 'set-border-layout' and</font>
+<font color='#555555'>;; 'set-grid-layout' to change the layout.</font>
+
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>frame id x y width height text visible<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> visible <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-bounds &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the component for which to get the list of bounding values.</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> The bounding list '(&lt;x&gt; &lt;y&gt; &lt;width&gt; &lt;height&gt;)'</font>
+ 
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-bounds id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:bounds <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-bounds "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:bounds<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	gs:bounds
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-fonts)</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> A list of family names for fonts on the current system.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The function should be called only once because it may take considerable</font>
+<font color='#555555'>;; time in a system loaded with many fonts. The variable 'gs:fonts' contains</font>
+<font color='#555555'>;; the same list of fonts originally returned by a call to 'gs:get-fonts'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-fonts<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:fonts<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+    		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-fonts System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:fonts<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:fonts <font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#0000AA'>base64-dec</font> gs:fonts<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-font-metrics &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> A list of the two values for width and height in pixels.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The font metrics for the currently set font in &lt;sym-id&gt; are returned as a list</font>
+<font color='#555555'>;; of width and height in pixels when displaying the string in &lt;str-text&gt;.</font>
+<font color='#555555'>;; After the function call the variable 'gs:font-metrics' contains the same list</font>
+<font color='#555555'>;; of values as originally returned by the call to 'gs:get-font-metrics'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-font-metrics id text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:font-metrics <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-font-metrics "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:font-metrics<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	gs:font-metrics	
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-instruments)</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> A list of instrument names in the default MIDI soundbank.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The function should be called only once because it may take considerable</font>
+<font color='#555555'>;; time in a system loaded with a big soundbank. The variable 'gs:instruments' contains</font>
+<font color='#555555'>;; the same list of instruments originally returned by a call to 'gs:get-instruments'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-instruments<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:instruments<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+    		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-instruments System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:instruments<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:instruments <font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#0000AA'>base64-dec</font> gs:instruments<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-screen)</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> A list of screen width, height and resolution of the main computer screen.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; After calling the 'gs:get-screen' once the screen parameters are also available</font>
+<font color='#555555'>;; in the variable 'gs:screen'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-screen<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-screen System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:screen<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	gs:screen
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-selected-text &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component from which to get the selected text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the event handler which will receive the selected text.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-selected-text id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-selected-text "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-text &lt;sym-id&gt; [&lt;sym-action&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component from which to get the text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The optional symbol of the event handler which will receive the text.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If no &lt;sym-action&gt; is specified the function will block until the text is returned. </font>
+<font color='#555555'>;; After return the text is also available in the variable 'gs:text'.</font>
+<font color='#555555'>;; If &lt;sym-action&gt; is specified the function will return immediately and a &lt;sym-action&gt; event </font>
+<font color='#555555'>;; is fired containing the text. </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-text id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> action
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-text "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:text <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:text<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			gs:text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-text-position &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text component for which the line and column position is returned.</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> A list of line and column position of the text caret.</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-text-position id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:text-position <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-text-position "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:text-position<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	gs:text-position
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:get-version)</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> The version of newLISP-GS running.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; After calling the 'gs:get-version' once the version number is also</font>
+<font color='#555555'>;; available in 'gs:version'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>get-version<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"get-version System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:version<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	gs:version
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:goto-text &lt;sym-id&gt; &lt;int-row&gt; &lt;int-column&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text widget.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-row&gt; The row number where to place the cursor.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-column&gt; The column number where to place the cursor.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>goto-text id row col<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"goto-text "</font> id <font color='#008800'>" "</font> row <font color='#008800'>" "</font> col <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:hide-tag &lt;sym-tag&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag of the group to hide.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>hide-tag tag <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"hide-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:image-button &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-icon-path&gt; [&lt;str-down-icon-path&gt; [&lt;int-width&gt; &lt;int-height&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the image button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-icon-path&gt; The path for an image icon.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-down-icon-path&gt; The path for a pressed down image icon.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the image button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the image button.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>image-button id action icon down-icon x y<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> down-icon
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> x y<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"image-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> down-icon<font color='#AA0000'>)</font> <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"image-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> down-icon<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"image-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:image-label &lt;sym-id&gt; &lt;str-icon-path&gt; [&lt;str-align&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the label.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-ucon-path&gt; A string with the icon file path.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-align&gt; An optional alignment '"left"', '"center"' or '"right"', '"leading"', '"trailing"', '"bottom"' or '"top"'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>image-label id icon align<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> align
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"image-label "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>" "</font> align <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"image-label "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:init [&lt;int-port&gt; &lt;str-host&gt; [bool-manual]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-port&gt; The optional guiserver server port.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-host&gt; The optional remote host of the guiserver.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>init <font color='#AA0000'>(</font>portIn <font color='#665500'>64001</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>host <font color='#008800'>"127.0.0.1"</font><font color='#AA0000'>)</font> manual<font color='#AA0000'>)</font>
+	<font color='#555555'>; check for server portIn and if this was started by java</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>main-args</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'portIn <font color='#AA0000'>(</font><font color='#0000AA'>int</font> <font color='#AA0000'>(</font><font color='#0000AA'>main-args</font> <font color='#665500'>2</font><font color='#AA0000'>)</font> portIn<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#555555'>; if guiserver.jar did not start this process then guiserver.jar</font>
+	<font color='#555555'>; still has to be started, except when manual parameter is true</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> <font color='#AA0000'>(</font><font color='#0000AA'>=</font> <font color='#AA0000'>(</font><font color='#0000AA'>main-args</font> <font color='#665500'>3</font><font color='#AA0000'>)</font> <font color='#008800'>"javastart"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> manual<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>=</font> ostype <font color='#008800'>"Windows"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>process</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"cmd /c "</font> server-path <font color='#008800'>" "</font> portIn<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+			<font color='#AA0000'>(</font><font color='#0000AA'>=</font> ostype <font color='#008800'>"OSX"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>process</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"/usr/bin/java -jar "</font> server-path <font color='#008800'>" "</font> portIn<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+			<font color='#AA0000'>(</font><font color='#0000AA'>env</font> <font color='#008800'>"JAVA_HOME"</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>process</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>env</font> <font color='#008800'>"JAVA_HOME"</font><font color='#AA0000'>)</font> <font color='#008800'>"/bin/java -jar "</font> server-path <font color='#008800'>" "</font> portIn<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+			<font color='#AA0000'>(</font><font color='#0000AA'>process</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"/usr/bin/java -jar "</font> server-path <font color='#008800'>" "</font> portIn<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+		<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'portOut <font color='#AA0000'>(</font><font color='#0000AA'>+</font> portIn <font color='#665500'>1</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'retry <font color='#665500'>0</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'out <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> out<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>></font> retry <font color='#665500'>200</font><font color='#AA0000'>)</font> <font color='#555555'>; try for 20 seconds</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>println</font> <font color='#008800'>"Could not connect to guiserver.jar"</font><font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>when</font> <font color='#AA0000'>(</font><font color='#0000AA'>=</font> ostype <font color='#008800'>"Windows"</font><font color='#AA0000'>)</font>
+					<font color='#AA0000'>(</font><font color='#0000AA'>import</font> <font color='#008800'>"user32.dll"</font> <font color='#008800'>"MessageBoxA"</font><font color='#AA0000'>)</font>
+					<font color='#AA0000'>(</font>MessageBoxA <font color='#665500'>0</font> <font color='#008800'>"Could not connect to guiserver.jar"</font> <font color='#008800'>"Problem connecting"</font> <font color='#665500'>1</font><font color='#AA0000'>)</font>
+				<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>exit</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>inc</font> retry<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'out <font color='#AA0000'>(</font><font color='#0000AA'>net-connect</font> host portIn<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>sleep</font> <font color='#665500'>100</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'listenSock <font color='#AA0000'>(</font><font color='#0000AA'>net-listen</font> portOut<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'in <font color='#AA0000'>(</font><font color='#0000AA'>net-accept</font> listenSock<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-close</font> listenSock<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>gs:set-utf8 <font color='#AA0000'>(</font><font color='#0000AA'>primitive?</font> MAIN:utf8<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:insert-list-item &lt;sym-list-combo&gt; &lt;str-text&gt; &lt;int-index&gt; [&lt;str-text&gt; &lt;int-index&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-list-combo&gt; The name of the combo box or list box from which entries are removed.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text of the list or combo box item to insert.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-index&gt; The index of an entry to add to the list or combo box.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When specifying an index of &lt;tt&gt;0&lt;/tt&gt; the first item gets inserted at the beginning. </font>
+<font color='#555555'>;; When specifying an index equal or greater to the number of items in the list, the item </font>
+<font color='#555555'>;; is added at the end.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>insert-list-item comp<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>	s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"insert-list-item "</font> comp <font color='#008800'>" "</font><font color='#AA0000'>)</font>
+			p <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>while</font> p
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> <font color='#AA0000'>(</font><font color='#0000AA'>pop</font> p<font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>pop</font> p<font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:insert-tab &lt;sym-tabbed-pane&gt; &lt;sym-component&gt; [&lt;str-text&gt; [&lt;int-index&gt; [&lt;str-icon-path&gt;]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tabbed-pane&gt; The name of the tabbed pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-component&gt; The name of the component to insert as a tab.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The optional text on the tab.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-index&gt; The optional index where to insert the new tab.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-icon-path&gt; The file path to an optional icon.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>insert-tab pane comp text idx icon<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> idx
+			<font color='#AA0000'>(</font><font color='#0000AA'>if</font> icon
+				<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"insert-tab "</font> pane <font color='#008800'>" "</font> comp <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> idx <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"insert-tab "</font> pane <font color='#008800'>" "</font> comp <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> idx <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"insert-tab "</font> pane <font color='#008800'>" "</font> comp <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"insert-tab "</font> pane <font color='#008800'>" "</font> comp <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:insert-text &lt;sym-id&gt; &lt;str-text&gt; &lt;int-position&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to insert.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-position&gt; The offset position where to insert the text.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>insert-text id text position<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>replace</font> <font color='#008800'>"&#092;r"</font> text <font color='#008800'>""</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"insert-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> position <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:key-event &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the component to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; 'gs:key-event' can be used to register a general unspecific key event handler</font>
+<font color='#555555'>;; for any component in the system. Since version 1.05 of newLISP-GS this also</font>
+<font color='#555555'>;; includes text widgets, which already handle key events using their normal event </font>
+<font color='#555555'>;; handler function. With 'gs:key-event' a second handler function can be registered</font>
+<font color='#555555'>;; for text widgets. Both functions will fire on their respective events.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Components respond to the following key event types: '"pressed"', '"released"', '"typed"'.</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (define (key-action id type code modifiers)</font>
+<font color='#555555'>;;     (println "id:" id " type:" type " key code:" code " modifiers:" modifiers)</font>
+<font color='#555555'>;; )</font>
+
+<font color='#555555'>;; The example shows a handler which prints all key event parameters to the terminal/shell</font>
+<font color='#555555'>;; window where the applicaton was started.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; In order for key events to work, the component for which a key action handler</font>
+<font color='#555555'>;; is registered must have the input focus. Use '"gs:request-focus"' to set the</font>
+<font color='#555555'>;; input focus for the component.</font>
+
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:key-event id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"key-event "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:label &lt;sym-id&gt; &lt;str-text&gt; [&lt;str-align&gt; [&lt;int-width&gt; &lt;int-height&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the label.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to appear on the label.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-align&gt; The optional alignment of the text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the label.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the label.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The following alignment constants can be supplied: '"left"', '"center"', '"right"",</font>
+<font color='#555555'>;; '"leading"', '"trailing"', '"bottom"' and "'top'". By default each label text is</font>
+<font color='#555555'>;; '"center"' aligned.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>label id text align width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> align
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"label "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> align <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"label "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> align <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"label "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:layout &lt;sym-container&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The id of the container to lay out.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Forces the container to lay out its components again, e.g. after a 'gs:add-to' or 'gs:remove-from'</font>
+<font color='#555555'>;; when the container was already visible.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>layout id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"layout "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:load-text &lt;sym-id&gt; &lt;str-path&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the 'gs:text-pane'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-path&gt; The full path name of the file to load.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; 'gs:load-text' will load text into a 'gs:text-pane' directly by specifying</font>
+<font color='#555555'>;; the path name. During loading, CR-LF line terminators are automatically</font>
+<font color='#555555'>;; translated to LF-only line terminators by stripping all CRs from the file. All internal</font>
+<font color='#555555'>;; operations of guiserver on text assume LF as a line terminator.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>load-text id image-path<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"load-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> image-path<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:listen [&lt;boolean-flag&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-flag&gt; Prevent exit on loss of communication.</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> Never returns. Exits the application when the guiserver exits, except when &lt;boolean-flag&gt; is 'true'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>listen flag , event<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>net-receive</font> in event <font color='#665500'>1000000000</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#555555'>;(println "===>" event "<===")</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>eval-string</font> event<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>println</font> <font color='#008800'>"server shut down"</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> flag<font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>exit</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:list-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-item-1&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the list box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-item&gt; Zero, one or more text entries in the list box.</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:list-box &lt;sym-id&gt; &lt;sym-action&gt; [&lt;list-str-items&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the list box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-str-items&gt; Zero, one or more text entries in a list.</font>
+
+<font color='#555555'>;; The listbox when clicked with the mouse, or when the [enter] key is</font>
+<font color='#555555'>;; presses, will pass the following parameters to the event handler:</font>
+<font color='#555555'>;; &lt;br&gt;&lt;br&gt;</font>
+<font color='#555555'>;; &lt;id&gt; - the id string of the list box&lt;br&gt;</font>
+<font color='#555555'>;; &lt;index&gt; - the zero offset index of the highlighted listbox entry&lt;br&gt;</font>
+<font color='#555555'>;; &lt;item&gt; - the string of the highlighted listbox entry&lt;br&gt;</font>
+<font color='#555555'>;; &lt;click-count&gt; - the number of times the mouse has been clicked&lt;br&gt;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>list-box id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>	s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"list-box "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font><font color='#AA0000'>)</font>
+					entries <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>item entries<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> item<font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:message-dialog &lt;sym-parent-frame&gt; &lt;str-title&gt; &lt;str-message&gt; [&lt;str-type&gt; [&lt;str-icon-path&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-parent-frame&gt; The symbol name of the parent frame.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The title of the message box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-message&gt; The message in the message box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-type&gt; The type of the message box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-icon-path&gt; The optional path for an icon.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The type of the message box can be one of: '"error"', '"information"', '"warning"', '"question"', '"plain"'.</font>
+<font color='#555555'>;; The function initiating the message-dialog will return when the dialog is closed.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>message-dialog parent title msg <font color='#AA0000'>(</font>type <font color='#008800'>"plain"</font><font color='#AA0000'>)</font> icon<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> icon
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"message-dialog "</font> parent <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> title<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> msg<font color='#AA0000'>)</font> <font color='#008800'>" "</font> type  <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> icon<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"message-dialog "</font> parent <font color='#008800'>" "</font> 
+				<font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> title<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> msg<font color='#AA0000'>)</font> <font color='#008800'>" "</font> type <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:menu &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the menu.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The title string of the menu.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>menu id text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"menu "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:menu-popup &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the menu.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The title string of the menu.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>menu-popup id text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"menu-popup "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:menu-bar &lt;sym-frame&gt; [&lt;sym-menu-1&gt; ...])  </font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-frame&gt; The name of the frame hosting the menu bar.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-menu&gt; Zero or more symbol names of menus to be positioned on the menu bar.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>menu-bar aframe<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"menu-bar "</font> aframe <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:menu-item &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the menu item.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to appear for the menu item.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>menu-item id action text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"menu-item "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:menu-item-check &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-text&gt; [&lt;bool-selected&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the menu item.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to appear for the menu item.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bool-selected&gt; An optional flag indicating the selection state 'true' or 'nil' (default).</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>menu-item-check id action text selected<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"menu-item-check "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> selected <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:midi-bpm [&lt;int-bpm&gt; [&lt;int-resolution&gt;]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-bpm&gt; Beats per minute pay speed. Default is 120 BPM.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-resolution&gt; Ticks per beat. Deafult is 16 ticks per beat;</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Sets the speed of playing a notes with with either 'gs:play-note' or playing a </font>
+<font color='#555555'>;; sequence with 'gs:play-sequence' in beats per minute (BPM).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Before using 'gs:midi-bpm' the default speed is set to 120 BPM, which corresponds</font>
+<font color='#555555'>;; to two beats per second, where each beat corresponds to a quarter note of 16 ticks</font>
+<font color='#555555'>;; default resolution.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; While the BPM parameter controls the play-back speed of the sequencer, the</font>
+<font color='#555555'>;; resolution is a parameter of the sequence creation itself and must be set before</font>
+<font color='#555555'>;; the first 'gs:add-track' call.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The preset resolution of 16 ticks per quarter note is the highest which can be set</font>
+<font color='#555555'>;; and should be sufficient for all applications.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>midi-bpm <font color='#AA0000'>(</font>bpm <font color='#665500'>120</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>resolution <font color='#665500'>16</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'resolution <font color='#AA0000'>(</font><font color='#0000AA'>min</font> resolution <font color='#665500'>16</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"midi-bpm System "</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> bpm<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> resolution<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+	
+
+
+
+<font color='#555555'>;; </font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:midi-close)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Shut down the MIDI subsystem.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>midi-close<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"midi-close System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:midi-init [&lt;str-file-path&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-file-path&gt; The optional file path for a soundbank file.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Initialize the MIDI subsystem. If a soundbank file is specified load it,</font>
+<font color='#555555'>;; else load the built-in synthesizer's default soundbank.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When not using the default soundbank, the function 'gs:get-instruments'</font>
+<font color='#555555'>;; should be used first to find out the correct naming of instruments</font>
+<font color='#555555'>;; for the 'gs:midi-patch' statements. The soundbank used for testing the</font>
+<font color='#555555'>;; demo files 'midi-demo.lsp' and 'midi2-demo.lsp' on Windows is the midsize</font>
+<font color='#555555'>;; soundbank available here:</font>
+<font color='#555555'>;; <font color='#308080'>@link</font> http://java.sun.com/products/java-media/sound/soundbanks.html http://java.sun.com/products/java-media/sound/soundbanks.html</font>
+<font color='#555555'>;; This soundbank has equivalent named instruments to those used in the Mac OS X default JRE installation.</font>
+<font color='#555555'>;; Currently only the first 128 instruments in a soundbank are accessed by newLISP-GS.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>midi-init soundbank<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> soundbank
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"midi-init System "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> soundbank<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"midi-init System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:midi-patch &lt;str-instrument&gt; [&lt;int-channel&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-instrument&gt; The name of the instrument to attach to a channel.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-channel&gt; The channel for the instrument, default is &lt;tt&gt;0&lt;/tt&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; An instrument from the current soundbank is attached to a</font>
+<font color='#555555'>;; specific channel or to channel &lt;tt&gt;0&lt;/tt&gt; if no channel is specified.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:midi-patch (find "Electric Grand" gs:instruments) 0)</font>
+
+<font color='#555555'>;; In order for the 'gs:instruments' variable to contain a list of instruments,</font>
+<font color='#555555'>;; 'gs:get-instruments' must have been called earlier, i.e. after 'gs:midi-init'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>midi-patch program <font color='#AA0000'>(</font>channel <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"midi-patch System "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> program<font color='#AA0000'>)</font> <font color='#008800'>" "</font> channel <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-clicked &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-canvas&gt; The id of the canvas to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-tags&gt; A 'true' to indicate checking for tags.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If &lt;boolean-tags&gt; is 'true', the action event will carry a list of</font>
+<font color='#555555'>;; all tags which contained the X,Y coordinates of the mouse.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>mouse-clicked cnvs action flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-clicked "</font> cnvs <font color='#008800'>" "</font> action <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-dragged &lt;sym-canvas&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-canvas&gt; The id of the canvas to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:mouse-dragged cnvs action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-dragged "</font> cnvs <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-event &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the component to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; 'gs:mouse-event' can be used to register a general unspecific mouse event handler</font>
+<font color='#555555'>;; for any component in the system. Components respond to the following types:</font>
+<font color='#555555'>;; '"pressed"', '"released"', '"clicked"',</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (define (mouse-action id type x y button cnt mods)</font>
+<font color='#555555'>;;     (println "id:" id " type:" type " x:" x " y:" y " button:" button " count:" cnt " mods:" mods)</font>
+<font color='#555555'>;; )</font>
+
+<font color='#555555'>;; The example shows a handler which prints all mouse event parameters to the terminal/shell</font>
+<font color='#555555'>;; window where the applicaton was started.</font>
+
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:mouse-event id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-event "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-moved &lt;sym-canvas&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-canvas&gt; The id of the canvas to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-tags&gt; A 'true' to indicate checking for tags.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If &lt;boolean-tags&gt; is 'true', the action event will carry a list of</font>
+<font color='#555555'>;; all tags which contained the X,Y coordinates of the mouse.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:mouse-moved cnvs action flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-moved "</font> cnvs <font color='#008800'>" "</font> action <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-pressed &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-canvas&gt; The id of the canvas to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-tags&gt; A 'true' to indicate checking for tags.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If &lt;boolean-tags&gt; is 'true', the action event will carry a list of</font>
+<font color='#555555'>;; all tags which contained the X,Y coordinates of the mouse.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:mouse-pressed cnvs action flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-pressed "</font> cnvs <font color='#008800'>" "</font> action <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-released &lt;sym-canvas&gt; &lt;sym-action&gt; [&lt;boolean-tags&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-canvas&gt; The id of the canvas to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-tags&gt; A 'true' to indicate checking for tags.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If &lt;boolean-tags&gt; is 'true', the action event will carry a list of</font>
+<font color='#555555'>;; all tags which contained the X,Y coordinates of the mouse.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:mouse-released cnvs action flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-released "</font> cnvs <font color='#008800'>" "</font> action <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mouse-wheel &lt;sym-canvas&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-canvas&gt; The id of the canvas to register the action handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The symbol of the action handler.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:mouse-wheel cnvs action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mouse-wheel "</font> cnvs <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:move-tag &lt;sym-tag&gt; &lt;int-dx&gt; &lt;int-dy&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag of the group of objects to move.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-dx&gt; The distance to move on the X-axis.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-dy&gt; The distance to move on the Y-axis.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; 'gs:move-tag' is the only tag operation which actually changes the </font>
+<font color='#555555'>;; internal data of a drawn object. All other tag operations like</font>
+<font color='#555555'>;; 'gs:translate-tag', 'gs:scale-tag', 'gs:rotate-tag' and 'gs:shear-tag'</font>
+<font color='#555555'>;; will transform object coordinates only for drawing.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:move-tag tag dx dy <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"move-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> 
+		dx <font color='#008800'>" "</font> dy <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:mute-track &lt;int-number&gt; [&lt;boolean-on-off&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-number&gt; The number of the track starting with &lt;tt&gt;0&lt;/tt&gt; for the first. Default is &lt;tt&gt;true&lt;/tt&gt;.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-on-off&gt; The track will be muted with a value of &lt;tt&gt;true&lt;/tt&gt;</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Any other value than &lt;tt&gt;true&lt;/tt&gt; will unmute the track again. Muting tracks is practical</font>
+<font color='#555555'>;; during music development. The track can only be muted when th sequence has benn started</font>
+<font color='#555555'>;; using 'gs:play-sequence'. To completely mute a track the 'gs:mute-track' statement should</font>
+<font color='#555555'>;; come right after the 'gs:play-sequece' statement. </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>mute-track number <font color='#AA0000'>(</font>bool <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"mute-track System "</font> number <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>string</font> bool<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:no-action)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Specify as &lt;sym-action&gt; for widgets where no action handler is defined.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>no-action<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:open-file-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; [&lt;str-directory&gt; [&lt;str-mask&gt; &lt;str-description&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-parent-frame&gt; The parent frame of the file dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The handler function symbol.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-directory&gt; The initial directory to show.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-mask&gt; An optonal string mask.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-description&gt; An optional mask description.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>open-file-dialog parent action dir mask desc<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> dir
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> mask desc<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"open-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> dir<font color='#AA0000'>)</font> <font color='#008800'>" "</font> 
+								<font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> mask<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> desc<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"open-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> dir<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"open-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:panel &lt;sym-id&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the panel.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the panel.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the panel.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Panels have a flow layout by default. In a flow layout an unsized button will</font>
+<font color='#555555'>;; assume the natural size necessary to display the text on it.</font>
+<font color='#555555'>;; To change the layout use the 'set-flow-layout' or 'set-grid-layout' functions.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>panel id width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"panel "</font> id <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"panel "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:paste-text &lt;sym-id&gt; [&lt;str-text&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text component in which to paste text.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; An optional text string to paste instead of the clipboard contents.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If the &lt;sym-id&gt; contains selected text, this text gets replaced,</font>
+<font color='#555555'>;; otherwise the text is inserted at the current caret position.</font>
+<font color='#555555'>;; If no text is given in &lt;str-text&gt;, the text is taken from the clipboard.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>paste-text id text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"paste-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"paste-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:play-note &lt;int-key&gt; [&lt;int-duration&gt; [&lt;int-velocity&gt; [&lt;int-channel&gt; [&lt;int-bend&gt;]]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-key&gt; The note or midi key &lt;tt&gt;0&lt;/tt&gt; to &lt;tt&gt;127&lt;/tt&gt;.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-duration&gt; The duration of the note in ticks, default is &lt;tt&gt;16&lt;/tt&gt; for one beat or quarter note.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-velocity&gt; The velocity/volume of the note between &lt;tt&gt;0&lt;/tt&gt; and &lt;tt&gt;127&lt;/tt&gt;, default is &lt;tt&gt;64&lt;/tt&gt;.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-channel&gt; The channel through which to play the note from &lt;tt&gt;0&lt;/tt&gt; to &lt;tt&gt;15&lt;/tt&gt;, default is &lt;tt&gt;0&lt;/tt&gt;.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-bend&gt; The optional note bend to tune the note lower or higher from '-8192' to '8191'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Before using 'gs:play-note', 'gs:midi-init' should be used to initialize the MIDI system.</font>
+<font color='#555555'>;; The key of the note increases in half-tone steps. The key 60 corresponds to a Middle-C.</font>
+<font color='#555555'>;; The velocity of the note is usually it's volume and/or brightness, i.e. the speed with which </font>
+<font color='#555555'>;; a key was pressed on an instrument. The channel is &lt;tt&gt;0&lt;/tt&gt; by default and assigned to</font>
+<font color='#555555'>;; a Piano instrument unless the function 'gs:midi-patch' has been used to change assignment</font>
+<font color='#555555'>;; to a different instrument.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On Windows and some Linux or other UNIX no MIDI soundbank files are installed by default. Goto </font>
+<font color='#555555'>;; <font color='#308080'>@link</font> http://java.sun.com/products/java-media/sound/soundbanks.html http://java.sun.com/products/java-media/sound/soundbanks.html</font>
+<font color='#555555'>;; for instructions how to download and install a soundbank. For the demo files 'mide-demo.lsp' and</font>
+<font color='#555555'>;; 'midi2-demo' the midsize quality soundbank was used. On Mac OS X a soundbank is installed by default.</font>
+<font color='#555555'>;; The default for the bend parameer is &lt;tt&gt;0&lt;/tt&gt; for no bend. Negative values down to '-8192'</font>
+<font color='#555555'>;; tune the note lower. Positive values up to '8191' tune the note higher. </font>
+<font color='#555555'>;; The following code is a complete example:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; ; load Guiserver</font>
+<font color='#555555'>;; (load (append (env "NEWLISPDIR") "/guiserver.lsp"))</font>
+<font color='#555555'>;; (gs:init)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; ; play a chromatic scale on the default instrument (piano)</font>
+<font color='#555555'>;; ; each note a 16th note of 4 ticks and a moderate volume </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (gs:midi-init)</font>
+<font color='#555555'>;; (gs:midi-patch "Piano" 0)</font>
+<font color='#555555'>;; (for (key 24 95) (gs:play-note key 4 95 0))</font>
+<font color='#555555'>;; (sleep 2000) ; wait until playing has finished</font>
+<font color='#555555'>;; (gs:midi-close)</font>
+<font color='#555555'>;;</font>
+
+<font color='#555555'>;; The second example demonstrated usage of the &lt;int-bend&gt; parameter:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; ; play the same note but with different bends below and above the note</font>
+<font color='#555555'>;; (gs:midi-patch "Violin" 0)</font>
+<font color='#555555'>;; (for (bend -2024 2024 128)</font>
+<font color='#555555'>;;     (gs:play-note 80 1 95 0 bend))</font>
+
+<font color='#555555'>;; To play polyphone music of multiple parallel tracks see the function 'gs:add-track' for</font>
+<font color='#555555'>;; a complete code example.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>play-note key <font color='#AA0000'>(</font>duration <font color='#665500'>4</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>velocity <font color='#665500'>64</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>channel <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>bend <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"play-note System "</font> 
+			key <font color='#008800'>" "</font> duration <font color='#008800'>" "</font> velocity <font color='#008800'>" "</font> channel <font color='#008800'>" "</font> bend <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:play-sequence [&lt;int-start&gt; [&lt;int-loop-count&gt; [&lt;int-start-loop&gt; [&lt;int-end-loop&gt;]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-start&gt; The starting point in the sequence in ticks. Default is &lt;tt&gt;0&lt;/tt&gt; for the beginning.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-loop-count&gt; The number of repetitions for looping. Default is &lt;tt&gt;0&lt;/tt&gt; for no looping.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-start-loop&gt; The start of the loop to play in ticks. Default is &lt;tt&gt;0&lt;/tt&gt;.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-end-loop&gt; The end of the loop in ticks. Default is &lt;tt&gt;-1&lt;/tt&gt; for the end.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; All parameters are optional. When no parameters are given all tracks in the sequence are</font>
+<font color='#555555'>;; sequenced from start to end with no repetiton (loop count of 0). Note that the start-loop and</font>
+<font color='#555555'>;; end-loop positions refer only to loop played after playing the full track. After the sequence</font>
+<font color='#555555'>;; started playing 'gs:stop-sequence' can be used to stop it at any time. The midi system</font>
+<font color='#555555'>;; should not be closed using 'gs:midi-close' before playing has finished or playing will</font>
+<font color='#555555'>;; be cut off.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; See the function 'gs:add-track' for complete code example.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>play-sequence <font color='#AA0000'>(</font>ticks <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>loop <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>start <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font>end <font color='#665500'>-1</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"play-sequence System "</font> ticks <font color='#008800'>" "</font> loop <font color='#008800'>" "</font> start <font color='#008800'>" "</font> end <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:play-sound &lt;str-file-path&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-file-path&gt; The path and file name of the sound file.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On most OS platforms '.au' and '.wav' sound file formats are supported.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>play-sound file-name<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"play-sound System "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> file-name<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:progress-bar &lt;sym-id&gt; &lt;int-min&gt; &lt;in-max&gt; &lt;int-initial-value&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The symbols of the progress bar.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-min&gt; The minimum value of the slider.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-max&gt; The maximum value of the slider.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-initial-value&gt; The initial value of the slider.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>progress-bar id posmin posmax posinit<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"progress-bar "</font> id <font color='#008800'>" "</font> posmin <font color='#008800'>" "</font> posmax <font color='#008800'>" "</font> posinit <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:radio-button &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-text&gt; [&lt;bool-selected&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the radio button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The optional text of the radio button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bool-seected&gt; An optional flag 'true' or 'nil' (default) indicating the initial state of the radio button.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>radio-button id action text selected<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"radio-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> selected <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"radio-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:redo-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the 'gs:text-pane' where to perform a redo operation.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>redo-text id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"redo-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:remove-from &lt;sym-container&gt; &lt;sym-component&gt; [&lt;sym-component&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The container from which to remove a component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-component&gt; One or more optional components to remove.</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>remove-from id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"remove-from "</font> id <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+        <font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+            <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+        <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+        <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:remove-list-item &lt;sym-list-combo&gt; &lt;int-index&gt; [&lt;int-index&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-list-combo&gt; The name of the combo box or list box from which entries are removed.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-index&gt; The index of an entry to remove from the list or combo box.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When specifying an index of &lt;tt&gt;0&lt;/tt&gt;, the first item gets removed. When specifying an</font>
+<font color='#555555'>;; index equal or greater to the number of items in the list, the item is removed at the end.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>remove-list-item comp<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"remove-list-item "</font> comp <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:remove-tab &lt;sym-tabbed-pane&gt; [&lt;int-index&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tabbed-pane&gt; The name of the tabbed pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-index&gt; The optional index of the tab to remove. The default is &lt;tt&gt;0&lt;/tt&gt; for the first tab.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>remove-tab pane idx<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> idx
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"remove-tab "</font> pane <font color='#008800'>" "</font> idx <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"remove-tab "</font> pane <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:request-focus &lt;sym-id&gt; [&lt;int-tab-index&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to request focus.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-tab-index&gt; The index of a tab for which focus is requested.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>request-focus id idx<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> idx
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"request-focus "</font> id <font color='#008800'>" "</font> idx <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"request-focus "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:reorder-tags &lt;list-tags&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-tags&gt; The list of tag symbols or tag string names in the new order of display.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The re-ordering itself will not repaint the canvas use 'gs:update' to repaint the current </font>
+<font color='#555555'>;; canvas after using 'gs:reorder-tags'. The list of tags can be given as either a list of</font>
+<font color='#555555'>;; tags symbols or name strings. Tags not appearing in &lt;list-tags&gt; will be deleted.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>reorder-tags tags<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"reorder-tags "</font> gs:currentCanvas <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>tag tags<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> tag <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:rotate-tag &lt;sym-tag&gt; &lt;float theta&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group to rotate.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-theta&gt; The rotation angle in degrees (0 - 360).</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X-coordinate of the rotation center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y-coordinate of the rotation center.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Like all tag operations, multiple 'gs:rotate-tag' operations are cumulative.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>rotate-tag tag angle x y <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"rotate-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> angle <font color='#008800'>" "</font> 
+		x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:run-shell &lt;id-text-area&gt; &lt;str-command&gt; &lt;str-args&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;idx-text-area&gt; The id of the text area to wich a shell process will be attached.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-command&gt; The command string to start the shell process.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-args&gt; The arguments of the command (max 8 arguments).</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>run-shell id command arguments<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"run-shell "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> command<font color='#AA0000'>)</font>  <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> arguments<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:save-file-dialog &lt;sym-parent-frame&gt; &lt;sym-action&gt; [&lt;str-directory&gt; [&lt;str-initial-file&gt; [&lt;str-mask&gt; &lt;str-description&gt;]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-parent-frame&gt; The parent frame of the file dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The handler function symbol.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-directory&gt; The initial directory to show.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-file&gt; The initial file name.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-mask&gt; An optional string mask.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-description&gt; An optional mask description.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>save-file-dialog parent action dir file mask desc<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> dir
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> file
+			<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> mask desc<font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"save-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> dir<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> file<font color='#AA0000'>)</font>
+																		<font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> mask<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> desc<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"save-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> dir<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> file<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"save-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> dir<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"save-file-dialog "</font> parent <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:save-sequence &lt;str-file-path&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-file-name&gt; The name of the MIDI file to save to.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Save the contents of a sequence created with 'gs:add-track' to a MIDI file.</font>
+<font color='#555555'>;; The file always should have the extension &lt;tt&gt;.mid&lt;/tt&gt;.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Note that all MIDI files created with 'gs:save-sequence' will play back at a fixed</font>
+<font color='#555555'>;; speed of 120 BPM. Therefore, when creating sequences for recording using 'gs:add-track',</font>
+<font color='#555555'>;; they should be timed for a play-back speed of 120 BPM.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; To change the speed for replay from a saved MIDI file the resolution parameter can</font>
+<font color='#555555'>;; be chaged from it's default of 16 tick per beat using the second optional parameter</font>
+<font color='#555555'>;; of 'gs:midi-bpm'. In this case the resolution parameter should be adjusted before</font>
+<font color='#555555'>;; calling 'gs:add-track' the first time.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>save-sequence file-path<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"save-sequence System "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> file-path<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:save-text &lt;sym-id&gt; &lt;str-path&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the 'gs:text-pane'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-path&gt; The full path name of the file to save.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; This function will write text back from a 'gs:text-pane' directly</font>
+<font color='#555555'>;; by specifying a path name only. Line feed characters (ASCII 10)</font>
+<font color='#555555'>;; are used as line terminators. If this behavior is not desired,</font>
+<font color='#555555'>;; as is the case with Windows text files, then 'gs:get-text' should</font>
+<font color='#555555'>;; be used instead. A program can then add CR characters using a </font>
+<font color='#555555'>;; newLISP 'replace', i.e. '(replace "&#092;n" text "&#092;r&#092;n")' before</font>
+<font color='#555555'>;; saving the text to a file.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>save-text id image-path<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"save-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> image-path<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:scale-tag &lt;sym-tag&gt; &lt;float-x&gt; &lt;float-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group to scale.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-x&gt; The X scaling factor.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-y&gt; The Y scaling factor.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; 'gs:scale' scales the object to draw relative to the '0,0' point of</font>
+<font color='#555555'>;; the coordinate system. This means if a object is not at the center it</font>
+<font color='#555555'>;; will not only change in size when scaled but also change the distance</font>
+<font color='#555555'>;; to the center point of the coordinate system, moving away when scaling</font>
+<font color='#555555'>;; up with scale factor bigger '1.0' and moving closer to the center</font>
+<font color='#555555'>;; when scaling down using factors smaller than '1.0'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; This means that objects which will be scaled should be defined in</font>
+<font color='#555555'>;; coordinates relative to their center point. Then a 'gs:translate-tag'</font>
+<font color='#555555'>;; command should be used to place the object to correct place:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:circle 'C 0 0 50)</font>
+<font color='#555555'>;; (gs:gs:translate-tag 'C 200 100)</font>
+<font color='#555555'>;; ...</font>
+<font color='#555555'>;; (gs:scale-tag 'C 1.1 1.1)</font>
+
+<font color='#555555'>;; In the example the circle, although defined for '0,0', will be displayed</font>
+<font color='#555555'>;; at the '200,200' position because of the 'gs:translate-tag' statement. When</font>
+<font color='#555555'>;; later scaling the circle will get bigger but stay in place.</font>
+<font color='#555555'>;; Like all tag operations, multiple 'gs:scale-tag' operations are cumulative.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>scale-tag tag sx sy <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"scale-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> 
+		sx <font color='#008800'>" "</font> sy <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:select-list-item &lt;sym-id&gt; &lt;str-item&gt; [&lt;boolean-flag&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the list or combo box.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-item&gt; The item to select.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-flag&gt; An optional flag only for list boxes to force scrolling to the selected entry.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On combo boxes the optional &lt;boolean-flag&gt; has no effect. The selected entry will always</font>
+<font color='#555555'>;; appear as the visible text of the combo box. The flag has either the value 'true' or 'nil'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>select-list-item id item flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"select-list-item "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> item<font color='#AA0000'>)</font> <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:select-text &lt;sym-id&gt; &lt;int-from&gt; [&lt;int-to&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The ame of the text component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-from&gt; Start offset of selection.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-to&gt; Optional end offset of selection.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; If no &lt;int-to&gt; end offset is given, 'gs:select-text' will</font>
+<font color='#555555'>;; select to the end of the text.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>select-text id from to<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> to
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"select-text "</font> id <font color='#008800'>" "</font> from <font color='#008800'>" "</font> to <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"select-text "</font> id <font color='#008800'>" "</font> from <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:scroll-pane &lt;sym-id&gt; &lt;sym-widget&gt; [&lt;int-width&gt; &lt;int-height&gt; &lt;sym-w-col&gt; &lt;sum-w-row&gt; &lt;sym-w-corner&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the scroll pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-widget&gt; The component in the scroll pane to be scrolled.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the scroll pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the scroll pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-col&gt; The optional table widget for a custom column header.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-row&gt; The optional table widget for a custom row header</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-corner&gt; The optional widget component in the upper left corner.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:scroll-pane 'scroll 'data-table 700 600 'col-table 'row-table 'Canvas)</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>scroll-pane id widget width height col-table row-table upper-left-corner <font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> col-table row-table upper-left-corner<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"scroll-pane "</font> id <font color='#008800'>" "</font> widget <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>" "</font> col-table <font color='#008800'>" "</font> row-table <font color='#008800'>" "</font> upper-left-corner <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"scroll-pane "</font> id <font color='#008800'>" "</font> widget <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"scroll-pane "</font> id <font color='#008800'>" "</font> widget <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-accelerator &lt;sym-menu-item&gt; &lt;str-keystroke&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-menu-item&gt; The name of the menu item for which an accelerator key is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-keystroke&gt; A text string identifying the keystroke.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The following rules are used to create keystroke strings:</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Syntax:</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; modifiers* (typedID | pressedReleasedID)</font>
+<font color='#555555'>;; modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3</font>
+<font color='#555555'>;; typedID := typed typedKey</font>
+<font color='#555555'>;; typedKey := string of length 1 giving Unicode character.</font>
+<font color='#555555'>;; pressedReleasedID := (pressed | released) key</font>
+<font color='#555555'>;; key := KeyEvent key code name, i.e. the name following "VK_".</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; Examples:</font>
+<font color='#555555'>;; &lt;blockquote&gt;&lt;pre&gt;</font>
+<font color='#555555'>;; "INSERT"</font>
+<font color='#555555'>;; "control DELETE"</font>
+<font color='#555555'>;; "alt shift X"</font>
+<font color='#555555'>;; "alt shift released X"</font>
+<font color='#555555'>;; "typed a"</font>
+<font color='#555555'>;; &lt;/pre&gt;&lt;/blockquote&gt;</font>
+<font color='#555555'>;; Note that the &lt;i&gt;apple&lt;/i&gt; key on MacOS X is the 'meta' key.</font>
+<font color='#555555'>;; The 'alt' on MacOS X is the &lt;i&gt;option&lt;/i&gt; key.</font>
+<font color='#555555'>;; For letters use uppercase. </font>
+<font color='#555555'>;; Keys are added to the menu item display automatically on all platforms.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-accelerator item key<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-accelerator "</font> item <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> key<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-anti-aliasing &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-flag&gt; The anti aliasing setting for the current canvas 'true' or 'nil'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The default setting is 'true'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-anti-aliasing flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-anti-aliasing "</font> gs:currentCanvas <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-background &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-red&gt; The red color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-green&gt; The green color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-blue&gt; The blue color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-background &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The rgb color can be given as a list of three numbers.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Note 'set-background' is the same as 'set-color'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-background id red green blue alpha<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> red<font color='#AA0000'>)</font> 
+		<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'alpha <font color='#AA0000'>(</font><font color='#0000AA'>or</font> green <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> 
+			<font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#0000AA'>set</font> '<font color='#AA0000'>(</font>red green blue<font color='#AA0000'>)</font> red<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'alpha <font color='#AA0000'>(</font><font color='#0000AA'>or</font> alpha <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-color "</font> id <font color='#008800'>" "</font> red <font color='#008800'>" "</font> green <font color='#008800'>" "</font> blue <font color='#008800'>" "</font> alpha <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-bevel-border &lt;sym-id&gt; &lt;str-type&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-type&gt; The type of the bevel '"raised"' or '"lowered"'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-bevel-border id type<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-bevel-border "</font> id <font color='#008800'>" "</font> type <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-border-layout &lt;sym-container&gt;  [&lt;int-hgap&gt; &lt;int-vgap&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The name of the container for which border layout is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-hgap&gt; The horizontal gap between components in the border layout.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-vgap&gt; The vertical gap between components in the border layout.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Border layout divides the layout into 5 zones labeled '"north"', '"west"',</font>
+<font color='#555555'>;; '"center"', '"east"' and '"south"'. These string constants are used in</font>
+<font color='#555555'>;; the 'gs:add-to' command when adding components to a border layout.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; In a border layout each component will take the maximum size if components</font>
+<font color='#555555'>;; are not sized. If components are sized only some dimensions will be honored.</font>
+<font color='#555555'>;; The '"north"' and '"south"' components will stretch to maximum width and</font>
+<font color='#555555'>;; assume the height given in a size parameter of the component. The '"east"'</font>
+<font color='#555555'>;; and '"west"' components will stretch to the maximum height available assuming</font>
+<font color='#555555'>;; their width specified earlier. The '"center"' component will take the left over</font>
+<font color='#555555'>;; maximum space.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-border-layout container hgap vgap<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> hgap vgap<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-border-layout "</font> container <font color='#008800'>" "</font>  hgap <font color='#008800'>" "</font> vgap <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-border-layout "</font> container <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-canvas &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the canvas to switch to.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The canvas in &lt;sym-id&gt; must have been created earlier with a 'gs:canvas' </font>
+<font color='#555555'>;; statement. All graphics operations which do not take a canvas as argument</font>
+<font color='#555555'>;; will automatically refer to this current canvas. If no 'gs:set-canvas' is</font>
+<font color='#555555'>;; used, the current canvas is assumed to be the last one created.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-canvas id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:currentCanvas id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-canvas "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-caret &lt;sym-id&gt; &lt;int-offset&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the cursor caret.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The functions has the same effect as calling 'gs:select-text' with the same </font>
+<font color='#555555'>;; offset for the dot and mark position.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-caret id offset<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-caret "</font> id <font color='#008800'>" "</font> offset <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-caret-color &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-red&gt; The red color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-green&gt; The green color component expressed as a  number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-blue&gt; The blue color component expressed as a  number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-caret-color &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The rgb color can be given as a list of three numbers.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-caret-color id red green blue<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> red<font color='#AA0000'>)</font> 
+		<font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#0000AA'>set</font> '<font color='#AA0000'>(</font>red green blue<font color='#AA0000'>)</font> red<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-caret-color "</font> id <font color='#008800'>" "</font> red <font color='#008800'>" "</font> green <font color='#008800'>" "</font> blue <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-color &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-red&gt; The red color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-green&gt; The green color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-blue&gt; The blue color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-color &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The rgb color can be given as a list of three numbers.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Note that 'set-color' is the same as 'set-background'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> set-color set-background<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-cursor &lt;sym-id&gt; &lt;str-shape&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the frame, dialog or window.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-shape&gt; The string describing the cursor shape.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The cursor shape can be one of the following:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;  "default"</font>
+<font color='#555555'>;;  "crosshair"</font>
+<font color='#555555'>;;  "text"</font>
+<font color='#555555'>;;  "wait"</font>
+<font color='#555555'>;;  "sw-resize"</font>
+<font color='#555555'>;;  "se-resize"</font>
+<font color='#555555'>;;  "nw-resize"</font>
+<font color='#555555'>;;  "ne-resize"</font>
+<font color='#555555'>;;  "n-resize"</font>
+<font color='#555555'>;;  "s-resize"</font>
+<font color='#555555'>;;  "w-resize"</font>
+<font color='#555555'>;;  "e-resize"</font>
+<font color='#555555'>;;  "hand"</font>
+<font color='#555555'>;;  "move"</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-cursor id shape<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-cursor "</font> id <font color='#008800'>" "</font> shape <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-echo-char &lt;sym-id&gt; [&lt;str-cover-char&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which text is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-cover-char&gt; Cover character for password entry.</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:set-echo-char 'TheTextField "*")</font>
+<font color='#555555'>;; (gs:set-echo-char 'TheTextField)   ; no echo, behave as normal text field</font>
+ 
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-echo-char id text<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> text <font color='#AA0000'>(</font><font color='#0000AA'>></font> <font color='#AA0000'>(</font><font color='#0000AA'>length</font> text<font color='#AA0000'>)</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+  	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-echo-char "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+  	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-echo-char "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; If no &lt;str-cover-char&gt; is specyfied or the string in &lt;str-cover-char&gt; is of</font>
+<font color='#555555'>;; 0 length, then the text field behaves as a normal text field.</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-editable &lt;sym-id&gt; &lt;boolean-editable&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text widget.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-editable&gt; The flag 'true' or 'nil' to indicate if this text widget can be edited.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-editable id flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-editable "</font> id <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-flow-layout &lt;sym-container&gt; [&lt;str-alignment&gt; [&lt;int-hgap&gt; &lt;int-vgap&gt;]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The name of the container for which flow layout is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-alignment&gt; The alignment of the flow layout '"left"', '"center"' or '"right"'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-hgap&gt; The horizontal gap between components in the flow layout.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-vgap&gt; The vertical gap between components in the flow layout.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The flow layout lets components appear in their natural or preferred size. The preferred</font>
+<font color='#555555'>;; size of a component is set using the function 'gs:set-size'. Button-type widgets and</font>
+<font color='#555555'>;; combo boxes will take as much space as necessary to show the included text.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-flow-layout id <font color='#AA0000'>(</font>direction <font color='#008800'>"left"</font><font color='#AA0000'>)</font> hGap vGap<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> hGap vGap<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-flow-layout "</font> id <font color='#008800'>" "</font> direction  <font color='#008800'>" "</font> hGap <font color='#008800'>" "</font> vGap <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-flow-layout "</font> id <font color='#008800'>" "</font> direction <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-font &lt;sym-id&gt; &lt;str-family&gt; &lt;int-size&gt; &lt;str-type&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the text font.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-familiy&gt; The family of the font, e.g.: '"Monospaced"', '"Serif"', '"Sans Serif"'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-size&gt; The font size in points.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-type&gt; The type of the font, one or more of '"plain"', '"bold"', '"italic"'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; More than the above noted families are available depending on the platform.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-font id family size type<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-font "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> family<font color='#AA0000'>)</font> <font color='#008800'>" "</font> size <font color='#008800'>" "</font> type <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-foreground &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-red&gt; The red color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-green&gt; The green color component expressed as a  number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-blue&gt; The blue color component expressed as a  number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-foreground &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The rgb color can be given as a list of three numbers.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The foreground color is the color of the text in a component.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-foreground id red green blue alpha<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> red<font color='#AA0000'>)</font> 
+		<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'alpha <font color='#AA0000'>(</font><font color='#0000AA'>or</font> green <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> 
+			<font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#0000AA'>set</font> '<font color='#AA0000'>(</font>red green blue<font color='#AA0000'>)</font> red<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'alpha <font color='#AA0000'>(</font><font color='#0000AA'>or</font> alpha <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-foreground "</font> id <font color='#008800'>" "</font> red <font color='#008800'>" "</font> green <font color='#008800'>" "</font> blue <font color='#008800'>" "</font> alpha <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-grid-layout &lt;sym-container&gt; &lt;int-rows&gt; &lt;int-columns&gt; [&lt;int-hgap&gt; &lt;int-vgap&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-container&gt; The name of the container for which grid layout is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-rows&gt; The number of rows in the layout grid.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-columns&gt; The number of columns in the layout grid.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-hgap&gt; The horizontal gap between components in the grid layout.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-vgap&gt; The vertical gap between components in the grid layout.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; In a grid layout each component will assume the maximum size the grid cell allows</font>
+<font color='#555555'>;; regardless of sizes preset using 'gs:set-size' Because of this grid layout cells are</font>
+<font color='#555555'>;; frequently filled with panels using 'gs:panel' which have flow layout by default</font>
+<font color='#555555'>;; and allow deliberate sizing of components using 'gs:set-size'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-grid-layout container rows cols hgap vgap<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> hgap vgap<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-grid-layout "</font> container <font color='#008800'>" "</font> rows <font color='#008800'>" "</font> cols <font color='#008800'>" "</font> hgap <font color='#008800'>" "</font> vgap <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-grid-layout "</font> container <font color='#008800'>" "</font> rows <font color='#008800'>" "</font> cols <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-icon &lt;sym-id&gt; &lt;str-icon-path&gt; [&lt;int-index&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of a button or label or menu-item for which to set an icon.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-icon-path&gt; The file path of the icon to be set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-index&gt; If &lt;sym-id&gt; is a tabbed pane &lt;int-index&gt; is the index of the tab.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-icon comp text idx<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> idx
+    	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-icon "</font> comp <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> idx <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-icon "</font> comp <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-look-and-feel &lt;str-look&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-look&gt; The class description string for the look and feel of the application.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The following strings can be tried in &lt;str-look&gt;, but not all will work on a specific</font>
+<font color='#555555'>;; platform. On the Mac the default look-and-feel is built-in to the JVM as the default</font>
+<font color='#555555'>;; style. The '"MacLookAndFeel"' is not available as an explicit flavor here, but may be</font>
+<font color='#555555'>;; on other platforms.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    '"com.sun.java.swing.plaf.motif.MotifLookAndFeel"'&lt;br&gt;</font>
+<font color='#555555'>;;    '"javax.swing.plaf.metal.MetalLookAndFeel"'&lt;br&gt;</font>
+<font color='#555555'>;;    '"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"'&lt;br&gt;</font>
+<font color='#555555'>;;    '"javax.swing.plaf.mac.MacLookAndFeel"'&lt;br&gt;</font>
+<font color='#555555'>;;    '"com.sun.java.swing.plaf.gtk.GTKLookAndFeel"'</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-look-and-feel look<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-look-and-feel System "</font> look <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-paint &lt;list-rgb&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The current paint used for outlines, text and fill color.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-paint color<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-paint "</font> gs:currentCanvas <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>1</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font>color <font color='#665500'>2</font><font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-pressed-icon &lt;sym-id&gt; &lt;str-icon-path&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the button, image button or toggle button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-icon-path&gt; The file path of the icon or image to be set to the button in pressed state.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; By default a small grey dot is shown on image buttons when in a pressed state.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-pressed-icon comp text<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-pressed-icon "</font> comp <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-resizable &lt;sym-frame&gt; &lt;boolean-resizable&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-frame&gt; The name of the frame window.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bbolean-resizable&gt; The flag 'true' or 'nil' to indicate if a frame can be resized by the user.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-resizable id flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-resizable "</font> id <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#0000AA'>true</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-rotation &lt;float-angle&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-angle&gt; The angle in degrees (0 - 360) of the canvas rotation.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Unlike the 'gs:rotate-tag' operation which is cumulative, 'gs:set-rotation'</font>
+<font color='#555555'>;; will set an absolute rotation value each time it is called.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-rotation angle<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-rotation "</font> gs:currentCanvas <font color='#008800'>" "</font> angle <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-scale &lt;float-x&gt; &lt;float-y&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-x&gt; The X-scale value of the current canvas.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-y&gt; The Y-scale value of the current canvas.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Unlike the 'gs:scale-tag' operation which is cumulative, 'gs:set-scale'</font>
+<font color='#555555'>;; will set an absolute scale value each time it is called.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-scale x y<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-scale "</font> gs:currentCanvas <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-selected &lt;sym-id&gt; &lt;boolean-selected&gt; [&lt;sym-id&gt; &lt;boolean-selected&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the toggle or radio button or check box or menu item.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-selected&gt; A flag of 'true' or 'nil' to indicated the selection state.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; More then one toggle control may be set selected or unselected.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-selected id flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-selected "</font> id <font color='#008800'>" "</font> flag <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>doargs</font> <font color='#AA0000'>(</font>item<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> item <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-selection-color &lt;sym-id&gt; &lt;float-red&gt; &lt;float-green&gt; &lt;float-blue&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the text selection color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-red&gt; The red color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-green&gt; The green color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-blue&gt; The blue color component expressed as a number between 0.0 and 1.0.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-selection-color &lt;sym-id&gt; &lt;list-rgb&gt; [&lt;float-alpha&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which to set the text selection color.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb&gt; The rgb color can be given as a list of three numbers.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-alpha&gt; The transparency of the color expressed as a number between 0.0 (fully transparent)and 1.0 (completely opaque).</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Note 'set-background' is the same as 'set-color'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-selection-color id red green blue alpha<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> red<font color='#AA0000'>)</font> 
+		<font color='#AA0000'>(</font><font color='#0000AA'>begin</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'alpha <font color='#AA0000'>(</font><font color='#0000AA'>or</font> green <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> 
+			<font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#0000AA'>set</font> '<font color='#AA0000'>(</font>red green blue<font color='#AA0000'>)</font> red<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'alpha <font color='#AA0000'>(</font><font color='#0000AA'>or</font> alpha <font color='#665500'>1.0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-selection-color "</font> id <font color='#008800'>" "</font> red <font color='#008800'>" "</font> green <font color='#008800'>" "</font> blue <font color='#008800'>" "</font> alpha <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-size &lt;sym-id&gt; &lt;int-width&gt; &lt;int-height&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component of which a preferred size is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The preferred width of the component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The preferred height of the component.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Note that not all layouts allow setting the size of a component. The grid and</font>
+<font color='#555555'>;; border layouts will size the component to its maximum possible in the layout.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-size id width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-size "</font> id <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-stroke &lt;float-width&gt; [&lt;str-cap&gt; [&lt;str-join&gt; [&lt;float-miterlimit&gt;]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-width&gt; The width for drawing lines and outlines in shapes.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-cap&gt; One of optional '"butt"' (default), '"round"' or '"sqare"'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-join&gt; One of optional '"miter"' (default), '"bevel"' or '"round"'</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; For a &lt;float-width&gt; 0f 0.0 the thinnest possible line width be chosen. </font>
+<font color='#555555'>;; Join is the decoration applied at the intersection of two path segments and at the </font>
+<font color='#555555'>;; intersection of the endpoints.</font>
+<font color='#555555'>;; Cap is the decoration applied to the ends of unclosed subpaths and dash segments.</font>
+<font color='#555555'>;; The &lt;float-miterlimit&gt; should be greater or equal 1.0.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-stroke width cap jn limit<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> cap
+		<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#0000AA'>join</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>if</font> limit
+				<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-stroke "</font> gs:currentCanvas <font color='#008800'>" "</font> width <font color='#008800'>" "</font> cap <font color='#008800'>" "</font> jn <font color='#008800'>" "</font> limit <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+				<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-stroke "</font> gs:currentCanvas <font color='#008800'>" "</font> width <font color='#008800'>" "</font> cap <font color='#008800'>" "</font> jn <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+			<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-stroke "</font> gs:currentCanvas <font color='#008800'>" "</font> width <font color='#008800'>" "</font> cap <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-stroke "</font> gs:currentCanvas <font color='#008800'>" "</font> width <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-syntax &lt;sym-id&gt; &lt;str-type&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text pane for syntax coloring is enabled or disabled.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-type&gt; A string '"lsp"', '"c"', '"cpp"', '"java"' or '"php"' to indicate the </font>
+<font color='#555555'>;; syntax desired, or 'nil' to switch off syntax highlighting.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Colors for syntax highlighting are preselected for a white background, but can be changed using</font>
+<font color='#555555'>;; the following functions: 'gs:set-background', 'gs:set-foreground', 'gs:set-caret', 'gs:set-selection-color'</font>
+<font color='#555555'>;; and 'gs:set-syntax-colors'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-syntax id type<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-syntax "</font> id <font color='#008800'>" "</font> type <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-syntax-colors &lt;list-rgb-comment&gt; &lt;list-rgb-keyword&gt; &lt;list-rgb-string&gt; &lt;list-rgb-number&gt; &lt;list-rgb-quoted&gt; &lt;list-rgb-parentheses&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb-comment&gt; The color for comments.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb-keyword&gt; The color for reserved keywords.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb-string&gt; The color for strings.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb-number&gt; The color for numbers.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb-quoted&gt; The color for the quote and quoted symbols.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;list-rgb-parentheses&gt; The color for parenthesis.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Syntax highlighting colors are given as lists of red, green and blue values between 0.0 and 1.0. </font>
+<font color='#555555'>;; Depending on the syntax colors and the foreground and background colors set for the text pane, </font>
+<font color='#555555'>;; the caret color and color for selected text should also be changed. Only text widgets created </font>
+<font color='#555555'>;; using 'gs:text-pane' feature syntax highlighting.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-syntax-colors comment keyword text number quoted parentheses<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>	components <font color='#AA0000'>(</font><font color='#0000AA'>append</font> comment keyword text number quoted parentheses<font color='#AA0000'>)</font>
+			str <font color='#008800'>"set-syntax-colors System "</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>c components<font color='#AA0000'>)</font>
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> str <font color='#AA0000'>(</font><font color='#0000AA'>string</font> c <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> str <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out str<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-tab-size &lt;sym-id&gt; &lt;int-size&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text area component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-size&gt; The tabulator size.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Note that 'gs:set-tab-size' will only work with fixed spaced fonts.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-tab-size id size<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-tab-size "</font> id <font color='#008800'>" "</font> size <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-text &lt;sym-id&gt; &lt;str-text&gt; [&lt;int-index&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the component for which text is set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text to be set in the component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-index&gt; The index for a tab if the &lt;sym-id&gt; is a tabbed pane.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-text id text idx<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>replace</font> <font color='#008800'>"&#092;r"</font> text <font color='#008800'>""</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> idx
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> idx <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-text "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-titled-border &lt;sym-component&gt; &lt;str-title&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-component&gt; The name of the component.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The text in the titled border around the component.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The component is usually a 'panel'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-titled-border id text<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-titled-border "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-tool-tip &lt;sym-id&gt; &lt;str-text&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the widget for which to supply a tool tip.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The text of the tool tip.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The tool tip text is shown when leaving the mouse over the widget for certain</font>
+<font color='#555555'>;; amount of time.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-tool-tip id text<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-tool-tip "</font> id <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-trace &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-flag&gt; The flag 'true' or 'nil'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-trace flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-trace System "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-translation &lt;int-x&gt; &lt;int-y&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X-translation value of the current canvas.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y-translation value of the current canvas.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Translates the current origin of the current canvas to the point in &lt;int-x&gt; &lt;int-y&gt;.</font>
+<font color='#555555'>;; Unlike the 'gs:translate-tag' operation which is cumulative, 'gs:set-translation'</font>
+<font color='#555555'>;; will set an absolute translation value each time it is called.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-translation x y<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-translation "</font> gs:currentCanvas <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-utf8 &lt;boolean-flag&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean&gt; The flag 'true' or 'nil' to indicate if in UTF-8 mode.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When set in UTF-8 mode, guiserver will convert files to UTF-8 encoding</font>
+<font color='#555555'>;; when loading and saving files. On Mac OS X UTF-8 mode is by default enabled.</font>
+<font color='#555555'>;; On startup guiserver.lsp will detect if newLISP is UTF-8 enabled and</font>
+<font color='#555555'>;; switch the mode in Guiserver accordingly using 'gs:set-utf8'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:set-utf8 flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-utf8 System "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-value &lt;sym-id&gt; &lt;int-value&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of a slider or progress bar for which to set the value.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-value&gt; The integer value of the name to be set.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The value should not be bigger or smaller than the minimum or maximum values set</font>
+<font color='#555555'>;; when creating the slider or progress bar, otherwise the setting will default to either</font>
+<font color='#555555'>;; the minimum or maximum preset value.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-value id value<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-value "</font> id <font color='#008800'>" "</font> value <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:set-visible &lt;sym-id&gt; &lt;boolean-visible&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The component which is hidden or made visible.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-visible&gt; A flag indicating if the component is visible '"true"', '"nil"'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Except for frames and dialog windows, components are visible by default. Normally</font>
+<font color='#555555'>;; frames and dialogs are not set visible before all other components are placed inside.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>set-visible id flag<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"set-visible "</font> id <font color='#008800'>" "</font> flag <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:shear-tag &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag group to shear.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-x&gt; The X shearing factor.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-y&gt; The Y shearing factor.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>shear-tag tag sx sy <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"shear-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> 
+		sx <font color='#008800'>" "</font> sy <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:show-popup &lt;sym-tag&gt; &lt;sym-host&gt; &lt;int-x&gt; &lt;int-y&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The id of the popup menu.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-host&gt; The host container where to pop up the menu.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X coordinate of the menu popup position.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y coordinate of the menu popup position.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:show-popup id host x y<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"show-popup "</font> id <font color='#008800'>" "</font> host <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:show-tag &lt;sym-tag&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The tag of the group to show.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>show-tag tag <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"show-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:slider &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-orientation&gt; &lt;int-min&gt; &lt;int-max&gt; &lt;int-initial-value&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the slider.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-orientation&gt; The orientation of the slider '"horizontal"' or '"vertical"'</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-min&gt; The minimum value of the slider.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-max&gt; The maximum value of the slider.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-initial-value&gt; The initial value of the slider.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>slider id action orient posmin posmax posinit<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"slider "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> orient <font color='#008800'>" "</font> posmin <font color='#008800'>" "</font> posmax <font color='#008800'>" "</font> posinit <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:split-pane &lt;sym-id&gt; &lt;str-orientation&gt; [&lt;float-weight&gt; [&lt;float-location&gt; [&lt;int-divider-size&gt;]]])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the split-pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-orientation&gt; The orientation '"horizontal"' or '"vertical"'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-weight&gt; The optional weight distribution between '0.0' and '1.0' when re-sizing the window. The default is '0.0'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;float-location&gt; The optional initial divider location between '0.0' and '1.0'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-divider-size&gt; The optional size of the draggable divider in pixels.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>split-pane id orient <font color='#AA0000'>(</font>weight <font color='#665500'>0.0</font><font color='#AA0000'>)</font>  <font color='#AA0000'>(</font>pos <font color='#665500'>0.5</font><font color='#AA0000'>)</font>  <font color='#AA0000'>(</font>dvdr <font color='#665500'>5</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"split-pane "</font> id <font color='#008800'>" "</font> orient <font color='#008800'>" "</font> weight <font color='#008800'>" "</font> pos <font color='#008800'>" "</font> dvdr <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:stop-sequence)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Stops playing tracks, as started with 'gs:play-sequence'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>gs:stop-sequence<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"stop-sequence System&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:tabbed-pane &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-orientation&gt; [&lt;sym-tab&gt; &lt;str-title&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the tabbed pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-orientation&gt; The position of the tabs; either '"top"' (default), '"bottom"','"left"' or '"right"'.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tab&gt; The id symbol name of a tab</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-title&gt; The title of the tab.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>tabbed-pane id action orient<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"tabbed-pane "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> orient <font color='#008800'>" "</font><font color='#AA0000'>)</font>
+		  t <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>while</font> t
+			<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#AA0000'>(</font><font color='#0000AA'>pop</font> t<font color='#AA0000'>)</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> <font color='#AA0000'>(</font><font color='#0000AA'>pop</font> t<font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#008800'>" "</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>)</font> 
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table &lt;sym-id&gt; &lt;sym-action&gt; [&lt;str-column-header-name&gt; ...])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The handler function symbol when a cell is selected.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-column-header-name&gt; The optional column header name. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates a table with &lt;str-column-header-name&gt; specified column and empty row.</font>
+<font color='#555555'>;; For empty strings specified as column headers, the header will be left empty.</font>
+<font color='#555555'>;; If all header in a table are specified as empty, the table will be created</font>
+<font color='#555555'>;; without a header row. If there are no columns at all, an empty table (0 x 0) </font>
+<font color='#555555'>;; is created. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; When a cell is selected, the function in &lt;sym-action&gt; gets called with the table </font>
+<font color='#555555'>;; id, row, column and cell-contents. See the file 'table-demo.lsp' for an example. </font>
+<font color='#555555'>;; Cells can be edited  by either selecting or double clicking a cell.</font>
+
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table id action<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table "</font> id <font color='#008800'>" "</font> action<font color='#AA0000'>)</font>
+	  columns <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>null?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> '<font color='#AA0000'>(</font><font color='#AA0000'>)</font>
+		      <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>col columns<font color='#AA0000'>)</font>
+      <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> col<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font> <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-add-column &lt;sym-id&gt; &lt;str-column-header-name&gt; ...)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-column-header-name&gt; Add column header name(s). </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; More than one &lt;str-column-header-name&gt; can be specified to add more</font>
+<font color='#555555'>;; than one column. A column header can be set empty using and empty string &lt;tt&gt;""&lt;/tt&gt;.</font>
+<font color='#555555'>;; When all headers in a table are empty, the</font>
+<font color='#555555'>;; table will be displayed without a header row.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-add-column id<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-add-column "</font> id<font color='#AA0000'>)</font>
+	  columns <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>null?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> '<font color='#AA0000'>(</font><font color='#AA0000'>)</font>
+		      <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>col columns<font color='#AA0000'>)</font>
+      <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> col<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-add-column " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font> <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-add-row &lt;sym-id&gt; [&lt;str-columns&gt; ... ])</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-add-row &lt;sym-id&gt; ([&lt;str-columns&gt; ...))</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-columns&gt; Add a row with contents in &lt;str-columns&gt;</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Add row with each column value. If necessary a scrollbar will appear.</font>
+<font color='#555555'>;; If no contents is defined in &lt;str-columns&gt;, or if contents for less</font>
+<font color='#555555'>;; columns is defined than available, column contents is left empty.</font>
+<font color='#555555'>;; Multiple column content can be specified as either a list</font>
+<font color='#555555'>;; of strings or as additional parameters of 'gs:table-add-row'. </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-add-row id<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-add-row "</font> id<font color='#AA0000'>)</font>
+	  columns <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>null?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> '<font color='#AA0000'>(</font><font color='#AA0000'>)</font>
+		      <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>col columns<font color='#AA0000'>)</font>
+      <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> col<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-add-row " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font> <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-get-cell &lt;sym-id&gt; &lt;int-row&gt; &lt;int-column&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-row&gt; The row of the cell.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-column&gt; The column of the cell.</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> cell value. stored in gs:table-cell.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Get the cell contents as a string at sepcifed &lt;int-row&gt; and &lt;int-column&gt;.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-get-cell id row col<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:table-cell <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-get-cell "</font> id
+		  <font color='#008800'>" "</font> row
+		  <font color='#008800'>" "</font> col<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-get-cell " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:table-cell<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    gs:table-cell<font color='#AA0000'>)</font>
+  <font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-get-size &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> table size list (row-size, column-size)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Get table size, stored in 'gs:table-size'.</font>
+<font color='#555555'>;; Note, that adding columns or row will not automatically update</font>
+<font color='#555555'>;; the 'gs:table-size' variable. Use 'gs:table-get-size' to update</font>
+<font color='#555555'>;; this variable.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-get-size id<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:table-size <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-get-size "</font> id<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-get-size " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:table-size<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    gs:table-size
+    <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+<font color='#555555'>; FdB</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-remove-row &lt;sym-id&gt; &lt;int-rownumber&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-row&gt; The row to remove</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; Removes a row See also 'gs:table-set-row-count'.</font>
+
+	<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-remove-row id row<font color='#AA0000'>)</font>
+	  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-remove-row "</font> id <font color='#008800'>" "</font> row<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	    <font color='#555555'>;(println "gs:table-remove-row " s)</font>
+	    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+	    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font> <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-set-cell &lt;sym-id&gt; &lt;int-row&gt; &lt;int-column&gt; &lt;str-value&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-row&gt; The row of the cell set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-column&gt; The column of the cell set.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-value&gt; The cell value.</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> The previous contents of the cell; also stored in 'gs:table-cell'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Sets a new table cell contents and returns the old cell contents. Row and</font>
+<font color='#555555'>;; column numbering starts with '0' (zero). The cell contents is passed</font>
+<font color='#555555'>;; as a string.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-set-cell id row col value<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:table-cell <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-set-cell "</font> id
+		  <font color='#008800'>" "</font> row
+		  <font color='#008800'>" "</font> col
+		  <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> value<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-set-cell " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:table-cell<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    gs:table-cell
+ <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-set-column &lt;sym-id&gt; &lt;int-column-number&gt; &lt;int-width&gt; [&lt;str-justification&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-column-number&gt; The column number of align.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The column width.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-justification&gt; The column align property, "left", "center", "right".</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A table column property is changed, adjusting the column width and alignment of cell</font>
+<font color='#555555'>;; contents. The &lt;str-justification&gt; parameter is optional and alignment is "left"</font>
+<font color='#555555'>;; by default.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-set-column id columnNum width <font color='#AA0000'>(</font>justification <font color='#008800'>"left"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-set-column "</font> id
+		  <font color='#008800'>" "</font> columnNum
+		  <font color='#008800'>" "</font> width
+		  <font color='#008800'>" "</font> justification<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-set-column " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font> <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+<font color='#555555'>; FdB</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-set-column-name &lt;sym-id&gt; [&lt;str-columns&gt; ... ])</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-set-column-name &lt;sym-id&gt; ([&lt;str-columns&gt; ...))</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-columns&gt; Set column names with contents in &lt;str-columns&gt;	</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; Replaces the column names in the table. If the number of names </font>
+<font color='#555555'>;; is greater than the current number of columns, new columns are added to the end </font>
+<font color='#555555'>;; of each row in the table. If the number of columnnames is less than the current</font>
+<font color='#555555'>;; number of columns, all the extra columns at the end of a row are discarded.</font>
+	
+	<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-set-column-name id<font color='#AA0000'>)</font>
+	   <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-set-column-name "</font> id<font color='#AA0000'>)</font>
+		  columns <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>null?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> '<font color='#AA0000'>(</font><font color='#AA0000'>)</font>
+			      <font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>list?</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font> <font color='#665500'>0</font><font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>args</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		  <font color='#AA0000'>(</font><font color='#0000AA'>dolist</font> <font color='#AA0000'>(</font>col columns<font color='#AA0000'>)</font>
+		    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> col<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		  <font color='#555555'>;(println "gs:table-set-column-name " s)</font>
+		  <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		  <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	  
+<font color='#555555'>; FdB</font>
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-set-row-count &lt;sym-id&gt; &lt;int-row-count&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-row&gt; Set the numbers of rows in the table with &lt;int-row-count&gt;	  </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Sets the number of rows in the table. If the new size is greater than the </font>
+<font color='#555555'>;; current size, new rows are added to the end of the table. If the new size is </font>
+<font color='#555555'>;; less than the current size, all rows at index rownumber and greater are discarded.</font>
+	  
+	<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-set-row-count id num<font color='#AA0000'>)</font>
+	  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-set-row-count "</font> id <font color='#008800'>" "</font> num<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>" &#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font><font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-get &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@return</font> table cells. stored in 'gs:table-full'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Get full table as a list of row lists.</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; ( ("column0" "column1" ... ) ; 1'st row</font>
+<font color='#555555'>;;   ("column0" "column1" ... ) ; 2'nd row</font>
+<font color='#555555'>;;   ...</font>
+<font color='#555555'>;;   ... )</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The entire table contents is stored as a list of row lists in the </font>
+<font color='#555555'>;; return value of 'gs:table-get', and is also stored in the variable </font>
+<font color='#555555'>;; 'gs:table-full'. </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-get id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:table-full <font color='#0000AA'>nil</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-get "</font> id<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+		<font color='#555555'>;(println "gs:table-get " s)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>while</font> <font color='#AA0000'>(</font><font color='#0000AA'>not</font> gs:table-full<font color='#AA0000'>)</font> <font color='#AA0000'>(</font>check-event <font color='#665500'>10000</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#555555'>; decode base64 cell contents for each row in each cell</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>set</font> 'gs:table-full
+			<font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#AA0000'>(</font>lambda <font color='#AA0000'>(</font>x<font color='#AA0000'>)</font> <font color='#AA0000'>(</font><font color='#0000AA'>map</font> <font color='#AA0000'>(</font>lambda <font color='#AA0000'>(</font>s<font color='#AA0000'>)</font> 
+					<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>nil?</font> s<font color='#AA0000'>)</font> <font color='#0000AA'>nil</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-dec</font> s<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+						<font color='#AA0000'>)</font> x <font color='#AA0000'>)</font> <font color='#AA0000'>)</font> gs:table-full<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-set-row-number &lt;sym-id&gt; &lt;bool-row-number&gt;) DEPRECATED</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Use 'gs:table-show-row-number'. The old naming is deprecated but will </font>
+<font color='#555555'>;; still work.</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:table-show-row-number &lt;sym-id&gt; &lt;bool-row-number&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the table.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bool-row-number&gt; 'true' if rows should carry a row number; default 'nil'.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Show or hide the row number headers. The default is hiding row numbers.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>table-show-row-number id boolRowheader<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>let</font> <font color='#AA0000'>(</font>s <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"table-show-row-number "</font> id
+		  <font color='#008800'>" "</font> boolRowheader<font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+    <font color='#555555'>;(println "gs:table-show-row-number " s)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>write-buffer</font> s <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font>
+    <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out s<font color='#AA0000'>)</font> <font color='#AA0000'>)</font> <font color='#AA0000'>)</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> table-set-row-number table-show-row-number<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:text-area &lt;sym-id&gt; &lt;sym-action&gt; &lt;int-width&gt; &lt;int-height&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;symid&gt; The name of the text area.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the text area..</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the text area.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:text-area 'TheText 'textarea-event 10 8)</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (define (textarea-event id code dot mark) ...)</font>
+
+<font color='#555555'>;; 'gs:text-area' transmits the following parameters in its event:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; id   - name of the widget </font>
+<font color='#555555'>;; code - key code equals ASCII code. Only for text keys</font>
+<font color='#555555'>;; dot  - position of text caret in the text </font>
+<font color='#555555'>;; mark - extended (selection) position of caret </font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>text-area id action width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"text-area "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"text-area "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:text-field &lt;sym-id&gt; &lt;sym-action&gt; &lt;int-columns&gt; [&lt;str-cover-char&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text field.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-columns&gt; The number of columns in the text field.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-cover-char&gt; Cover character for password entry.</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:text-field 'TheTextField 'textfield-event)</font>
+<font color='#555555'>;; (gs:text-field 'PasswordTextField 'textfield-event "*")</font>
+
+<font color='#555555'>;; The 'textfield-event' is fired when the enter key is pressed in the</font>
+<font color='#555555'>;; text field. As an alternative the cover character for passwords can be</font>
+<font color='#555555'>;; set with 'gs:set-echo-char'.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>text-field id action columns text<font color='#AA0000'>)</font>
+  <font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+      <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"text-field "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> columns <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+      <font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"text-field "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> columns <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:text-pane &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-style&gt; [&lt;int-width&gt; &lt;int-height&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the text pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The key action handler for the html pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-style&gt; The content type of the text pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The optional width of the pane.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The optional height of the pane.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The 'gs:text-pane' is used similar to 'gs:text-area. The following styles</font>
+<font color='#555555'>;; are supported in &lt;sym-style&gt;:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;;    "text/plain"</font>
+<font color='#555555'>;;    "text/html"</font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The 'gs:text-pane' widget will automatically display scroll bars when</font>
+<font color='#555555'>;; text does not fit in the visible space of the pane. When entering parentheses</font>
+<font color='#555555'>;; they are automatically matched with their opening or closing counterparts, if they exist.</font>
+<font color='#555555'>;; If this is undesired behavior, the simpler 'gs:text-area' control should</font>
+<font color='#555555'>;; be used instead. </font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; On each change of the caret or selection in the text pane</font>
+<font color='#555555'>;; an event is fired containing several parameters about the caret and selection</font>
+<font color='#555555'>;; positions, the last character typed, and the modifier keys used. See the</font>
+<font color='#555555'>;; the file 'newlisp-edit.lsp' for a complex application using all features</font>
+<font color='#555555'>;; available in this widget.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; To make hyperlinks in 'HTML' formatted text clickable, editing must</font>
+<font color='#555555'>;; be disabled using the 'gs:set-editable' function. The functions 'gs:set-font'</font>
+<font color='#555555'>;; and 'gs:append-text' will work only on the 'text/plain' content style.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; <font color='#308080'>@example</font></font>
+<font color='#555555'>;; (gs:text-pane 'TheTextPane 'textpane-event "text/plain")</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; (define (textpane-event id code mods dot mark len undo redo) ...)</font>
+
+<font color='#555555'>;; 'gs:text-pane' transmits the following parameters in its event:</font>
+<font color='#555555'>;; &lt;pre&gt;</font>
+<font color='#555555'>;; id   - name of the widget </font>
+<font color='#555555'>;; code - key code equals ASCII code. Only for text keys </font>
+<font color='#555555'>;; mods - keys pressed together with the previous, like shift, ctrl etc.</font>
+<font color='#555555'>;; dot  - position of the text caret in the text </font>
+<font color='#555555'>;; mark - extended (selection) position of the caret </font>
+<font color='#555555'>;; len  - length of the text in the textarea </font>
+<font color='#555555'>;; undo - undo enabled/disabled </font>
+<font color='#555555'>;; redo - redo enabled/disabled </font>
+<font color='#555555'>;; &lt;/pre&gt;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>text-pane id action style width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"text-pane "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> style <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"text-pane "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> style <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:toggle-button &lt;sym-id&gt; &lt;sym-action&gt; &lt;str-text&gt; [&lt;bool-selected&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the toggle button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The name of the event handler.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;str-text&gt; The optional text of the toggle button.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bool-selected&gt; An optional flag 'true' or 'nil' (default) indicating the initial state of the toggle button.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>toggle-button id action text selected<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> text
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"toggle-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>" "</font> <font color='#AA0000'>(</font><font color='#0000AA'>base64-enc</font> text<font color='#AA0000'>)</font> <font color='#008800'>" "</font> selected <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"toggle-button "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:tool-bar &lt;sym-frame&gt; [&lt;bool-floatable&gt; &lt;int-hgap&gt; &lt;int-vgap&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-frame&gt; The name of the frame hosting the toolbar.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;bool-floatable&gt; The optional flag 'true' or 'nil' to indicate if the toolbar can be detached.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-hgap&gt; The horizontal gap between components on the toolbar.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-vgap&gt; The vertical gap between the components on the toolbar.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>tool-bar aframe floatable width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>if</font> <font color='#AA0000'>(</font><font color='#0000AA'>and</font> width height<font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"tool-bar "</font> aframe <font color='#008800'>" "</font> floatable <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+		<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"tool-bar "</font> aframe <font color='#008800'>" "</font> floatable <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:translate-tag &lt;sym-tag&gt; &lt;int-x&gt; &lt;int-y&gt; [&lt;boolean-repaint&gt;])</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-tag&gt; The name tag of the group to translate.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The X-coordinate translation value.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The Y-coordinate translation value.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-repaint&gt; An optional flag to indicate if repainting is required (default is 'true').</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Moves the origin of the coordinate system of all objects tagged with &lt;sym-tag&gt;.</font>
+<font color='#555555'>;; Like all tag operations multiple 'gs:translate-tag' operations are cumulative.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>translate-tag tag x y <font color='#AA0000'>(</font>repaint <font color='#0000AA'>true</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font>send-out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"translate-tag "</font> gs:currentCanvas <font color='#008800'>" "</font> tag <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> repaint <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:undo-text &lt;sym-id&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the 'gs:text-pane' where to perform an undo operation.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>undo-text id<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"undo-text "</font> id <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:undo-enable &lt;sym-id&gt; &lt;boolean-enabled&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The id of the 'gs:text-pane' for which to enabe/disable undo.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;boolean-enabled&gt; 'true' or 'nil' to enable or disable undo.  </font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>undo-enable id enabled<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"undo-enable "</font> id  <font color='#008800'>" "</font> enabled <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:update)</font>
+<font color='#555555'>;; </font>
+<font color='#555555'>;; Forces a repaint of the current canvas, e.g. after changing the scale or translation of a visible</font>
+<font color='#555555'>;; canvas. This function is rarely used, as most screen updates are performed automatically.</font>
+<font color='#555555'>;; All tag operations can carry an additional parameter to force update after they have been</font>
+<font color='#555555'>;; draw.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>update<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"update "</font> gs:currentCanvas <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:window &lt;sym-id&gt; &lt;int-x&gt; &lt;int-y&gt; &lt;int-width&gt; &lt;int-height&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the invisible window.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-x&gt; The x-coordinate of the screen position.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-y&gt; The y-coordinate of the screen position.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-width&gt; The width of the window.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;int-height&gt; The height of the window.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; Creates a borderless window. Note that a borderless window may treat</font>
+<font color='#555555'>;; some hosted components differently from normal frames and dialogs.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>window id x y width height<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"window "</font> id <font color='#008800'>" "</font> x <font color='#008800'>" "</font> y <font color='#008800'>" "</font> width <font color='#008800'>" "</font> height <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:window-closed &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the frame or dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The action to perform when the frame or dialog closes.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; A window or dialog window can be closed using the system close button in</font>
+<font color='#555555'>;; one of the corners of the window. In this case it is useful to specify</font>
+<font color='#555555'>;; a handler function which is called upon closing.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>frame-closed id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame-closed "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>window-closed id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame-closed "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:window-moved &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the frame or dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The action to perform when the frame or dialog moves.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The event will carry the &lt;sym-id&gt; of the window or dialog and current &lt;tt&gt;X&lt;/tt&gt; and &lt;tt&gt;Y&lt;/tt&gt;</font>
+<font color='#555555'>;; coordinates on the screen.</font>
+<font color='#555555'>;;</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>frame-moved id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame-moved "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>window-moved id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame-moved "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>;; <font color='#308080'>@syntax</font> (gs:window-resized &lt;sym-id&gt; &lt;sym-action&gt;)</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-id&gt; The name of the frame or dialog.</font>
+<font color='#555555'>;; <font color='#308080'>@param</font> &lt;sym-action&gt; The action to perform when the frame or dialog is resized.</font>
+<font color='#555555'>;;</font>
+<font color='#555555'>;; The event will carry the &lt;sym-id&gt; of the window or dialog and current width and</font>
+<font color='#555555'>;; height.</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>frame-resized id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame-resized "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+<font color='#AA0000'>(</font><font color='#0000AA'>define</font> <font color='#AA0000'>(</font>window-resized id action<font color='#AA0000'>)</font>
+	<font color='#AA0000'>(</font><font color='#0000AA'>net-send</font> out <font color='#AA0000'>(</font><font color='#0000AA'>string</font> <font color='#008800'>"frame-resized "</font> id <font color='#008800'>" "</font> action <font color='#008800'>"&#092;n"</font><font color='#AA0000'>)</font><font color='#AA0000'>)</font>
+<font color='#AA0000'>)</font>
+
+
+<font color='#555555'>; eof</font>
+
+
+</pre><center><font face='Arial' size='-3' color='#666666'>syntax highlighting with <a href="http://newlisp.org">newLISP</a>&nbsp;and <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a></font></center></body></html>
\ No newline at end of file
diff --git a/guiserver/html-demo.lsp b/guiserver/html-demo.lsp
new file mode 100644
index 0000000..bf92406
--- /dev/null
+++ b/guiserver/html-demo.lsp
@@ -0,0 +1,56 @@
+#!/usr/local/bin/newlisp
+;;
+;; html-demo.lsp - demonstrate  the text pane with HTML
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;;;; describe the GUI
+(gs:frame 'HtmlDemo 100 100 400 270 "HTML text-pane demo")
+(gs:text-pane 'HtmlPane 'htmlpane-action "text/html" 200 500)
+(gs:set-editable 'HtmlPane nil)
+(gs:set-tab-size 'HtmlPane 4)
+(gs:set-font 'HtmlPane "Monospaced" 14 "plain")
+(gs:set-background 'HtmlPane 1 1 0.96)
+
+(if (= ostype "Windows")
+	(set 'url (string "file:///" (env "NEWLISPDIR") "/guiserver/html-demo.lsp"))
+	(set 'url "file:///usr/local/share/newlisp/guiserver/html-demo.lsp")
+)
+
+(set 'page (format [text]
+<html>
+<center><br><h2>Text panes for HTML</h2></center>
+<blockquote>
+<p>This is a page of <i>html</i> text with a clickable hyperlink 
+<a href="%s">html-demo.lsp</a>.</p>
+
+<p>The previous link expects the file <tt>html-demo.lsp</tt> in 
+the current directory from where the program was started.</p>
+
+<p>Only simple pages are processed correctly.</p>
+
+</blockquote>
+</html>
+[/text] url))
+
+(gs:set-text 'HtmlPane page)
+(gs:append-text 'HtmlPane "This is appended text")
+(gs:add-to 'HtmlDemo 'HtmlPane)
+(gs:set-visible 'HtmlDemo true)
+
+;;;; define actions
+(define (urlfield-action id txt)
+)
+
+(define (htmlpane-action id text)
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/image-demo.lsp b/guiserver/image-demo.lsp
new file mode 100644
index 0000000..e7deaa5
--- /dev/null
+++ b/guiserver/image-demo.lsp
@@ -0,0 +1,66 @@
+#!/usr/local/bin/newlisp
+;;
+;; image-demo.lsp - demonstrate images rotating and zooming
+;; and the mouse-wheel rotating an object
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;;;; describe the GUI
+(gs:frame 'ImageDemo  100 100 600 600 "Image demo")
+(gs:set-border-layout 'ImageDemo)
+;(gs:set-resizable 'ImageDemo nil)
+(gs:canvas 'MyCanvas)
+(gs:set-background 'MyCanvas gs:white)
+(gs:panel 'Select)
+(gs:radio-button 'ZoomButton 'zoom-action "zoom")
+(gs:radio-button 'TurnButton 'turn-action "turn")
+(gs:set-selected 'TurnButton true)
+(set 'turn-flag true)
+(gs:add-to 'Select 'ZoomButton 'TurnButton)
+(gs:add-to 'ImageDemo 'MyCanvas "center" 'Select "south")
+(gs:mouse-wheel 'MyCanvas 'mouse-wheel-action)
+
+;(gs:set-scale 0.5 0.5) ; only for testing
+
+(gs:set-font 'MyCanvas "Lucida Sans Oblique" 14 "plain")
+(gs:draw-text 'T "turn mouse wheel to turn or zoom image" 20 50 gs:darkGray)
+(gs:draw-image 'S "/local/newLISP128.png" 320 20 32 50)
+(gs:draw-image 'S "/local/newLISP128.png" 380 30 50 32)
+
+(gs:draw-image 'I "/local/newLISP128.png" -64 -64)
+(gs:translate-tag 'I 300 300)
+
+(gs:set-visible 'ImageDemo true)
+
+;; actions
+
+(define (zoom-action id flag)
+	(gs:set-selected 'TurnButton (not flag))
+	(set 'turn-flag (not flag))
+)
+
+(define (turn-action id flag)
+	(gs:set-selected 'ZoomButton (not flag))
+	(set 'turn-flag flag)
+)
+
+
+(define (mouse-wheel-action x y wheel)
+	(if turn-flag
+		(gs:rotate-tag 'I wheel 0 0)
+		(if (< wheel 0)
+			(gs:scale-tag 'I 0.9 0.9)
+			(gs:scale-tag 'I 1.1 1.1)
+		)
+	)
+)
+
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/images/change-name b/guiserver/images/change-name
new file mode 100644
index 0000000..3b659ef
--- /dev/null
+++ b/guiserver/images/change-name
@@ -0,0 +1,2 @@
+replace-filename "(.*?)-icon-(.*)" ".*png" "(string \$1 \$2)"
+
diff --git a/guiserver/images/clear-down32.png b/guiserver/images/clear-down32.png
new file mode 100644
index 0000000..de62f40
Binary files /dev/null and b/guiserver/images/clear-down32.png differ
diff --git a/guiserver/images/clear32.png b/guiserver/images/clear32.png
new file mode 100644
index 0000000..86cdc11
Binary files /dev/null and b/guiserver/images/clear32.png differ
diff --git a/guiserver/images/copy-down32.png b/guiserver/images/copy-down32.png
new file mode 100644
index 0000000..0886a85
Binary files /dev/null and b/guiserver/images/copy-down32.png differ
diff --git a/guiserver/images/copy32.png b/guiserver/images/copy32.png
new file mode 100644
index 0000000..09ac14a
Binary files /dev/null and b/guiserver/images/copy32.png differ
diff --git a/guiserver/images/cut-down32.png b/guiserver/images/cut-down32.png
new file mode 100644
index 0000000..d1abc5a
Binary files /dev/null and b/guiserver/images/cut-down32.png differ
diff --git a/guiserver/images/cut32.png b/guiserver/images/cut32.png
new file mode 100644
index 0000000..74b9ecb
Binary files /dev/null and b/guiserver/images/cut32.png differ
diff --git a/guiserver/images/dotgray16.png b/guiserver/images/dotgray16.png
new file mode 100644
index 0000000..8cc1a20
Binary files /dev/null and b/guiserver/images/dotgray16.png differ
diff --git a/guiserver/images/dotgray32.png b/guiserver/images/dotgray32.png
new file mode 100644
index 0000000..1c2e258
Binary files /dev/null and b/guiserver/images/dotgray32.png differ
diff --git a/guiserver/images/dotgreen16.png b/guiserver/images/dotgreen16.png
new file mode 100644
index 0000000..b1259eb
Binary files /dev/null and b/guiserver/images/dotgreen16.png differ
diff --git a/guiserver/images/dotgreen32.png b/guiserver/images/dotgreen32.png
new file mode 100644
index 0000000..d74ee34
Binary files /dev/null and b/guiserver/images/dotgreen32.png differ
diff --git a/guiserver/images/dotred16.png b/guiserver/images/dotred16.png
new file mode 100644
index 0000000..a5dd93c
Binary files /dev/null and b/guiserver/images/dotred16.png differ
diff --git a/guiserver/images/dotred32.png b/guiserver/images/dotred32.png
new file mode 100644
index 0000000..9eaeda5
Binary files /dev/null and b/guiserver/images/dotred32.png differ
diff --git a/guiserver/images/dotyellow16.png b/guiserver/images/dotyellow16.png
new file mode 100644
index 0000000..8558b00
Binary files /dev/null and b/guiserver/images/dotyellow16.png differ
diff --git a/guiserver/images/dotyellow32.png b/guiserver/images/dotyellow32.png
new file mode 100644
index 0000000..be6ab61
Binary files /dev/null and b/guiserver/images/dotyellow32.png differ
diff --git a/guiserver/images/edit-down32.png b/guiserver/images/edit-down32.png
new file mode 100644
index 0000000..fb0edba
Binary files /dev/null and b/guiserver/images/edit-down32.png differ
diff --git a/guiserver/images/edit32.png b/guiserver/images/edit32.png
new file mode 100644
index 0000000..7c0be93
Binary files /dev/null and b/guiserver/images/edit32.png differ
diff --git a/guiserver/images/folder-closed-down32.png b/guiserver/images/folder-closed-down32.png
new file mode 100644
index 0000000..b887153
Binary files /dev/null and b/guiserver/images/folder-closed-down32.png differ
diff --git a/guiserver/images/folder-closed32.png b/guiserver/images/folder-closed32.png
new file mode 100644
index 0000000..05f168e
Binary files /dev/null and b/guiserver/images/folder-closed32.png differ
diff --git a/guiserver/images/folder-opened-down32.png b/guiserver/images/folder-opened-down32.png
new file mode 100644
index 0000000..6b4c515
Binary files /dev/null and b/guiserver/images/folder-opened-down32.png differ
diff --git a/guiserver/images/folder-opened32.png b/guiserver/images/folder-opened32.png
new file mode 100644
index 0000000..d9754c0
Binary files /dev/null and b/guiserver/images/folder-opened32.png differ
diff --git a/guiserver/images/font-book-down32.png b/guiserver/images/font-book-down32.png
new file mode 100644
index 0000000..af4b9c4
Binary files /dev/null and b/guiserver/images/font-book-down32.png differ
diff --git a/guiserver/images/font-book32.png b/guiserver/images/font-book32.png
new file mode 100644
index 0000000..fe3b5d2
Binary files /dev/null and b/guiserver/images/font-book32.png differ
diff --git a/guiserver/images/green10.png b/guiserver/images/green10.png
new file mode 100644
index 0000000..cfa4f78
Binary files /dev/null and b/guiserver/images/green10.png differ
diff --git a/guiserver/images/index.cgi b/guiserver/images/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/guiserver/images/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/guiserver/images/info-down32.png b/guiserver/images/info-down32.png
new file mode 100644
index 0000000..84de75e
Binary files /dev/null and b/guiserver/images/info-down32.png differ
diff --git a/guiserver/images/info32.png b/guiserver/images/info32.png
new file mode 100644
index 0000000..980a571
Binary files /dev/null and b/guiserver/images/info32.png differ
diff --git a/guiserver/images/new-down32.png b/guiserver/images/new-down32.png
new file mode 100644
index 0000000..a83e3d9
Binary files /dev/null and b/guiserver/images/new-down32.png differ
diff --git a/guiserver/images/new32.png b/guiserver/images/new32.png
new file mode 100644
index 0000000..7ace01c
Binary files /dev/null and b/guiserver/images/new32.png differ
diff --git a/guiserver/images/newLISP-down32.png b/guiserver/images/newLISP-down32.png
new file mode 100644
index 0000000..06fc129
Binary files /dev/null and b/guiserver/images/newLISP-down32.png differ
diff --git a/guiserver/images/newLISP128.png b/guiserver/images/newLISP128.png
new file mode 100644
index 0000000..01f58e0
Binary files /dev/null and b/guiserver/images/newLISP128.png differ
diff --git a/guiserver/images/newLISP16.png b/guiserver/images/newLISP16.png
new file mode 100644
index 0000000..f516c55
Binary files /dev/null and b/guiserver/images/newLISP16.png differ
diff --git a/guiserver/images/newLISP20.png b/guiserver/images/newLISP20.png
new file mode 100644
index 0000000..af144d7
Binary files /dev/null and b/guiserver/images/newLISP20.png differ
diff --git a/guiserver/images/newLISP32.png b/guiserver/images/newLISP32.png
new file mode 100644
index 0000000..94c1107
Binary files /dev/null and b/guiserver/images/newLISP32.png differ
diff --git a/guiserver/images/newLISP64.png b/guiserver/images/newLISP64.png
new file mode 100644
index 0000000..a35dc8f
Binary files /dev/null and b/guiserver/images/newLISP64.png differ
diff --git a/guiserver/images/newLISPsplash.jpg b/guiserver/images/newLISPsplash.jpg
new file mode 100644
index 0000000..08d48a1
Binary files /dev/null and b/guiserver/images/newLISPsplash.jpg differ
diff --git a/guiserver/images/newLISPsplash.png b/guiserver/images/newLISPsplash.png
new file mode 100644
index 0000000..a193b4d
Binary files /dev/null and b/guiserver/images/newLISPsplash.png differ
diff --git a/guiserver/images/paste-down32.png b/guiserver/images/paste-down32.png
new file mode 100644
index 0000000..c36c67c
Binary files /dev/null and b/guiserver/images/paste-down32.png differ
diff --git a/guiserver/images/paste32.png b/guiserver/images/paste32.png
new file mode 100644
index 0000000..760cfdd
Binary files /dev/null and b/guiserver/images/paste32.png differ
diff --git a/guiserver/images/pressedbutton32.png b/guiserver/images/pressedbutton32.png
new file mode 100644
index 0000000..13c8183
Binary files /dev/null and b/guiserver/images/pressedbutton32.png differ
diff --git a/guiserver/images/red10.png b/guiserver/images/red10.png
new file mode 100644
index 0000000..8e30673
Binary files /dev/null and b/guiserver/images/red10.png differ
diff --git a/guiserver/images/restart-down32.png b/guiserver/images/restart-down32.png
new file mode 100644
index 0000000..25085e3
Binary files /dev/null and b/guiserver/images/restart-down32.png differ
diff --git a/guiserver/images/restart32.png b/guiserver/images/restart32.png
new file mode 100644
index 0000000..9f26c91
Binary files /dev/null and b/guiserver/images/restart32.png differ
diff --git a/guiserver/images/run-down32.png b/guiserver/images/run-down32.png
new file mode 100644
index 0000000..67ba7d6
Binary files /dev/null and b/guiserver/images/run-down32.png differ
diff --git a/guiserver/images/run16.png b/guiserver/images/run16.png
new file mode 100644
index 0000000..d0d9869
Binary files /dev/null and b/guiserver/images/run16.png differ
diff --git a/guiserver/images/run32.png b/guiserver/images/run32.png
new file mode 100644
index 0000000..7e414de
Binary files /dev/null and b/guiserver/images/run32.png differ
diff --git a/guiserver/images/save-down32.png b/guiserver/images/save-down32.png
new file mode 100644
index 0000000..10ac51b
Binary files /dev/null and b/guiserver/images/save-down32.png differ
diff --git a/guiserver/images/save32.png b/guiserver/images/save32.png
new file mode 100644
index 0000000..bf923f8
Binary files /dev/null and b/guiserver/images/save32.png differ
diff --git a/guiserver/images/search-down32.png b/guiserver/images/search-down32.png
new file mode 100644
index 0000000..f2edbe8
Binary files /dev/null and b/guiserver/images/search-down32.png differ
diff --git a/guiserver/images/search32.png b/guiserver/images/search32.png
new file mode 100644
index 0000000..7930caa
Binary files /dev/null and b/guiserver/images/search32.png differ
diff --git a/guiserver/images/stop-down32.png b/guiserver/images/stop-down32.png
new file mode 100644
index 0000000..5586755
Binary files /dev/null and b/guiserver/images/stop-down32.png differ
diff --git a/guiserver/images/stop32.png b/guiserver/images/stop32.png
new file mode 100644
index 0000000..68b3df0
Binary files /dev/null and b/guiserver/images/stop32.png differ
diff --git a/guiserver/images/web32.png b/guiserver/images/web32.png
new file mode 100644
index 0000000..c089a30
Binary files /dev/null and b/guiserver/images/web32.png differ
diff --git a/guiserver/index-gs.html b/guiserver/index-gs.html
new file mode 100644
index 0000000..cb1942f
--- /dev/null
+++ b/guiserver/index-gs.html
@@ -0,0 +1,25 @@
+<!DOCTYPE HTML PUBLIC "HTML 4.01 Transitional">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>Index</title>
+
+<link rel="stylesheet" type="text/css" href="newlispdoc.css" />
+</head>
+
+<body style="margin: 20px;" text="#111111" bgcolor="#FFFFFF" 
+            link="#376590" vlink="#551A8B" alink="#ffAA28">
+<blockquote>
+<center><h1>Index</h1></center>
+<a href="guiserver.lsp.html"><br/>
+<h2>Module:&nbsp;guiserver.lsp</h2></a>
+<p>Functions for programming GUIs and 2D graphics.</p>
+<a href="guiserver.lsp.html#gs_add-list-item">add-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_add-separator">add-separator</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_add-track">add-track</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_add-to">add-to</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_append-text">append-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_button">button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_canvas">canvas</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_channel-bend">channel-bend</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_check-box">check-box</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_check-event">check-event</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_clear-list">clear-list</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_clear-text">clear-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_copy-text">copy-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_cut-text">cut-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_color-dialog">color-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_color-tag">color-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_combo-box">combo-box</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_confirm-dialog">confirm-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_delete-tag">delete-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_destroy-shell">destroy-shell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_dialog">dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_disable">disable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_dispose">dispose</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_dispose-splash">dispose-splash</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-arc">draw-arc</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-circle">draw-circle</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-ellipse">draw-ellipse</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-image">draw-image</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-line">draw-line</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-path">draw-path</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-polygon">draw-polygon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-rect">draw-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-round-rect">draw-round-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-text">draw-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_enable">enable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_eval-shell">eval-shell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_export">export</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-arc">fill-arc</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-circle">fill-circle</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-ellipse">fill-ellipse</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-polygon">fill-polygon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-rect">fill-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-round-rect">fill-round-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_find-text">find-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_frame">frame</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-bounds">get-bounds</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-fonts">get-fonts</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-font-metrics">get-font-metrics</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-instruments">get-instruments</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-screen">get-screen</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-selected-text">get-selected-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-text">get-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-text-position">get-text-position</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-version">get-version</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_goto-text">goto-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_hide-tag">hide-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_image-button">image-button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_image-label">image-label</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_init">init</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_insert-list-item">insert-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_insert-tab">insert-tab</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_insert-text">insert-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_key-event">key-event</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_label">label</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_layout">layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_load-text">load-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_listen">listen</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_list-box">list-box</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_message-dialog">message-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu">menu</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-popup">menu-popup</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-bar">menu-bar</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-item">menu-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-item-check">menu-item-check</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-bpm">midi-bpm</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-close">midi-close</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-init">midi-init</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-patch">midi-patch</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-clicked">mouse-clicked</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-dragged">mouse-dragged</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-event">mouse-event</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-moved">mouse-moved</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-pressed">mouse-pressed</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-released">mouse-released</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-wheel">mouse-wheel</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_move-tag">move-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mute-track">mute-track</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_no-action">no-action</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_open-file-dialog">open-file-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_panel">panel</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_paste-text">paste-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_play-note">play-note</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_play-sequence">play-sequence</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_play-sound">play-sound</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_progress-bar">progress-bar</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_radio-button">radio-button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_redo-text">redo-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_remove-from">remove-from</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_remove-list-item">remove-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_remove-tab">remove-tab</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_request-focus">request-focus</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_reorder-tags">reorder-tags</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_rotate-tag">rotate-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_run-shell">run-shell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_save-file-dialog">save-file-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_save-sequence">save-sequence</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_save-text">save-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_scale-tag">scale-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_select-list-item">select-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_select-text">select-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_scroll-pane">scroll-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-accelerator">set-accelerator</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-anti-aliasing">set-anti-aliasing</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-background">set-background</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-bevel-border">set-bevel-border</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-border-layout">set-border-layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-canvas">set-canvas</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-caret">set-caret</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-caret-color">set-caret-color</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-color">set-color</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-cursor">set-cursor</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-echo-char">set-echo-char</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-editable">set-editable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-flow-layout">set-flow-layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-font">set-font</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-foreground">set-foreground</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-grid-layout">set-grid-layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-icon">set-icon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-look-and-feel">set-look-and-feel</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-paint">set-paint</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-pressed-icon">set-pressed-icon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-resizable">set-resizable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-rotation">set-rotation</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-scale">set-scale</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-selected">set-selected</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-selection-color">set-selection-color</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-size">set-size</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-stroke">set-stroke</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-syntax">set-syntax</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-syntax-colors">set-syntax-colors</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-tab-size">set-tab-size</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-text">set-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-titled-border">set-titled-border</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-tool-tip">set-tool-tip</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-trace">set-trace</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-translation">set-translation</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-utf8">set-utf8</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-value">set-value</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-visible">set-visible</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_shear-tag">shear-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_show-popup">show-popup</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_show-tag">show-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_slider">slider</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_split-pane">split-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_stop-sequence">stop-sequence</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_tabbed-pane">tabbed-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table">table</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-add-column">table-add-column</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-add-row">table-add-row</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-get-cell">table-get-cell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-get-size">table-get-size</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-remove-row">table-remove-row</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-cell">table-set-cell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-column">table-set-column</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-column-name">table-set-column-name</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-row-count">table-set-row-count</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-get">table-get</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-row-number">table-set-row-number</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-show-row-number">table-show-row-number</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_text-area">text-area</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_text-field">text-field</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_text-pane">text-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_toggle-button">toggle-button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_tool-bar">tool-bar</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_translate-tag">translate-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_undo-text">undo-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_undo-enable">undo-enable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_update">update</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window">window</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window-closed">window-closed</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window-moved">window-moved</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window-resized">window-resized</a>&nbsp; &nbsp; 
+<br/><br/><center>- &part; -</center><br/>
+<center><font face='Arial' size='-2' color='#444444'>
+generated with <a href="http://newlisp.org">newLISP</a>&nbsp;
+and <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a>
+</font></center>
+</blockquote>
+</body>
+</html>
diff --git a/guiserver/index.cgi b/guiserver/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/guiserver/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/guiserver/index.html b/guiserver/index.html
new file mode 100644
index 0000000..cb1942f
--- /dev/null
+++ b/guiserver/index.html
@@ -0,0 +1,25 @@
+<!DOCTYPE HTML PUBLIC "HTML 4.01 Transitional">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>Index</title>
+
+<link rel="stylesheet" type="text/css" href="newlispdoc.css" />
+</head>
+
+<body style="margin: 20px;" text="#111111" bgcolor="#FFFFFF" 
+            link="#376590" vlink="#551A8B" alink="#ffAA28">
+<blockquote>
+<center><h1>Index</h1></center>
+<a href="guiserver.lsp.html"><br/>
+<h2>Module:&nbsp;guiserver.lsp</h2></a>
+<p>Functions for programming GUIs and 2D graphics.</p>
+<a href="guiserver.lsp.html#gs_add-list-item">add-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_add-separator">add-separator</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_add-track">add-track</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_add-to">add-to</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_append-text">append-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_button">button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_canvas">canvas</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_channel-bend">channel-bend</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_check-box">check-box</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_check-event">check-event</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_clear-list">clear-list</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_clear-text">clear-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_copy-text">copy-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_cut-text">cut-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_color-dialog">color-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_color-tag">color-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_combo-box">combo-box</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_confirm-dialog">confirm-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_delete-tag">delete-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_destroy-shell">destroy-shell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_dialog">dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_disable">disable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_dispose">dispose</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_dispose-splash">dispose-splash</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-arc">draw-arc</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-circle">draw-circle</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-ellipse">draw-ellipse</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-image">draw-image</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-line">draw-line</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-path">draw-path</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-polygon">draw-polygon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-rect">draw-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-round-rect">draw-round-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_draw-text">draw-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_enable">enable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_eval-shell">eval-shell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_export">export</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-arc">fill-arc</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-circle">fill-circle</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-ellipse">fill-ellipse</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-polygon">fill-polygon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-rect">fill-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_fill-round-rect">fill-round-rect</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_find-text">find-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_frame">frame</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-bounds">get-bounds</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-fonts">get-fonts</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-font-metrics">get-font-metrics</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-instruments">get-instruments</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-screen">get-screen</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-selected-text">get-selected-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-text">get-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-text-position">get-text-position</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_get-version">get-version</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_goto-text">goto-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_hide-tag">hide-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_image-button">image-button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_image-label">image-label</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_init">init</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_insert-list-item">insert-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_insert-tab">insert-tab</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_insert-text">insert-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_key-event">key-event</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_label">label</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_layout">layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_load-text">load-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_listen">listen</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_list-box">list-box</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_message-dialog">message-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu">menu</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-popup">menu-popup</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-bar">menu-bar</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-item">menu-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_menu-item-check">menu-item-check</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-bpm">midi-bpm</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-close">midi-close</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-init">midi-init</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_midi-patch">midi-patch</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-clicked">mouse-clicked</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-dragged">mouse-dragged</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-event">mouse-event</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-moved">mouse-moved</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-pressed">mouse-pressed</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-released">mouse-released</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mouse-wheel">mouse-wheel</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_move-tag">move-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_mute-track">mute-track</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_no-action">no-action</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_open-file-dialog">open-file-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_panel">panel</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_paste-text">paste-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_play-note">play-note</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_play-sequence">play-sequence</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_play-sound">play-sound</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_progress-bar">progress-bar</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_radio-button">radio-button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_redo-text">redo-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_remove-from">remove-from</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_remove-list-item">remove-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_remove-tab">remove-tab</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_request-focus">request-focus</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_reorder-tags">reorder-tags</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_rotate-tag">rotate-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_run-shell">run-shell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_save-file-dialog">save-file-dialog</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_save-sequence">save-sequence</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_save-text">save-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_scale-tag">scale-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_select-list-item">select-list-item</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_select-text">select-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_scroll-pane">scroll-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-accelerator">set-accelerator</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-anti-aliasing">set-anti-aliasing</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-background">set-background</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-bevel-border">set-bevel-border</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-border-layout">set-border-layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-canvas">set-canvas</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-caret">set-caret</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-caret-color">set-caret-color</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-color">set-color</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-cursor">set-cursor</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-echo-char">set-echo-char</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-editable">set-editable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-flow-layout">set-flow-layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-font">set-font</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-foreground">set-foreground</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-grid-layout">set-grid-layout</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-icon">set-icon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-look-and-feel">set-look-and-feel</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-paint">set-paint</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-pressed-icon">set-pressed-icon</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-resizable">set-resizable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-rotation">set-rotation</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-scale">set-scale</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-selected">set-selected</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-selection-color">set-selection-color</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-size">set-size</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-stroke">set-stroke</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-syntax">set-syntax</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-syntax-colors">set-syntax-colors</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-tab-size">set-tab-size</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-text">set-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-titled-border">set-titled-border</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-tool-tip">set-tool-tip</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-trace">set-trace</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-translation">set-translation</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-utf8">set-utf8</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-value">set-value</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_set-visible">set-visible</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_shear-tag">shear-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_show-popup">show-popup</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_show-tag">show-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_slider">slider</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_split-pane">split-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_stop-sequence">stop-sequence</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_tabbed-pane">tabbed-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table">table</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-add-column">table-add-column</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-add-row">table-add-row</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-get-cell">table-get-cell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-get-size">table-get-size</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-remove-row">table-remove-row</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-cell">table-set-cell</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-column">table-set-column</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-column-name">table-set-column-name</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-row-count">table-set-row-count</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-get">table-get</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-set-row-number">table-set-row-number</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_table-show-row-number">table-show-row-number</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_text-area">text-area</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_text-field">text-field</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_text-pane">text-pane</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_toggle-button">toggle-button</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_tool-bar">tool-bar</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_translate-tag">translate-tag</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_undo-text">undo-text</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_undo-enable">undo-enable</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_update">update</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window">window</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window-closed">window-closed</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window-moved">window-moved</a>&nbsp; &nbsp; <a href="guiserver.lsp.html#gs_window-resized">window-resized</a>&nbsp; &nbsp; 
+<br/><br/><center>- &part; -</center><br/>
+<center><font face='Arial' size='-2' color='#444444'>
+generated with <a href="http://newlisp.org">newLISP</a>&nbsp;
+and <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a>
+</font></center>
+</blockquote>
+</body>
+</html>
diff --git a/guiserver/java/ArcShape.java b/guiserver/java/ArcShape.java
new file mode 100644
index 0000000..8a62136
--- /dev/null
+++ b/guiserver/java/ArcShape.java
@@ -0,0 +1,75 @@
+//
+//  ArcShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class ArcShape extends Shape {
+
+int width;
+int height;
+int startAngle;
+int arcAngle;
+
+public ArcShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	startAngle = Integer.parseInt(tokens.nextToken());
+	arcAngle = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawArc(X, Y, width - 1, height - 1, startAngle, arcAngle);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ArcShape.java.bak b/guiserver/java/ArcShape.java.bak
new file mode 100644
index 0000000..1226e35
--- /dev/null
+++ b/guiserver/java/ArcShape.java.bak
@@ -0,0 +1,75 @@
+//
+//  ArcShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class ArcShape extends Shape {
+
+int width;
+int height;
+int startAngle;
+int arcAngle;
+
+public ArcShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	startAngle = Integer.parseInt(tokens.nextToken());
+	arcAngle = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawArc(X, Y, width - 1, height - 1, startAngle, arcAngle);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/Base64Coder.java b/guiserver/java/Base64Coder.java
new file mode 100644
index 0000000..bc61a20
--- /dev/null
+++ b/guiserver/java/Base64Coder.java
@@ -0,0 +1,173 @@
+/**
+* A Base64 Encoder/Decoder.
+*
+* <p>
+* This class is used to encode and decode data in Base64 format as described in RFC 1521.
+*
+* <p>
+* This is "Open Source" software and released under the <a href="http://www.gnu.org/licenses/lgpl.html">GNU/LGPL</a> license.<br>
+* It is provided "as is" without warranty of any kind.<br>
+* Copyright 2003: Christian d'Heureuse, Inventec Informatik AG, Switzerland.<br>
+* Home page: <a href="http://www.source-code.biz">www.source-code.biz</a><br>
+*
+* <p>
+* Version history:<br>
+* 2003-07-22 Christian d'Heureuse (chdh): Module created.<br>
+* 2005-08-11 chdh: Lincense changed from GPL to LGPL.<br>
+* 2006-11-21 chdh:<br>
+*  &nbsp; Method encode(String) renamed to encodeString(String).<br>
+*  &nbsp; Method decode(String) renamed to decodeString(String).<br>
+*  &nbsp; New method encode(byte[],int) added.<br>
+*  &nbsp; New method decode(String) added.<br>
+* 2010-08-11 added encodeStringUTF8(String) and decodeStringUTF8(String).<br>
+*/
+
+import java.io.UnsupportedEncodingException;
+
+public class Base64Coder {
+
+// Mapping table from 6-bit nibbles to Base64 characters.
+private static char[]    map1 = new char[64];
+   static {
+      int i=0;
+      for (char c='A'; c<='Z'; c++) map1[i++] = c;
+      for (char c='a'; c<='z'; c++) map1[i++] = c;
+      for (char c='0'; c<='9'; c++) map1[i++] = c;
+      map1[i++] = '+'; map1[i++] = '/'; }
+
+// Mapping table from Base64 characters to 6-bit nibbles.
+private static byte[]    map2 = new byte[128];
+   static {
+      for (int i=0; i<map2.length; i++) map2[i] = -1;
+      for (int i=0; i<64; i++) map2[map1[i]] = (byte)i; }
+
+/**
+* Encodes a string into Base64 format.
+* No blanks or line breaks are inserted.
+* @param s  a String to be encoded.
+* @return   A String with the Base64 encoded data.
+*/
+public static String encodeString (String s) {
+   return new String(encode(s.getBytes())); }
+
+public static String encodeStringUTF8(String s) {
+   byte [] bs ;
+   try {
+       bs = s.getBytes("UTF-8") ;
+       String r = new String(encode(bs)) ;
+       return r ;
+   } catch (UnsupportedEncodingException ee) {}
+   return new String("") ;
+}
+
+
+/**
+* Encodes a byte array into Base64 format.
+* No blanks or line breaks are inserted.
+* @param in  an array containing the data bytes to be encoded.
+* @return    A character array with the Base64 encoded data.
+*/
+public static char[] encode (byte[] in) {
+   return encode(in,in.length); }
+
+/**
+* Encodes a byte array into Base64 format.
+* No blanks or line breaks are inserted.
+* @param in   an array containing the data bytes to be encoded.
+* @param iLen number of bytes to process in <code>in</code>.
+* @return     A character array with the Base64 encoded data.
+*/
+public static char[] encode (byte[] in, int iLen) {
+   int oDataLen = (iLen*4+2)/3;       // output length without padding
+   int oLen = ((iLen+2)/3)*4;         // output length including padding
+   char[] out = new char[oLen];
+   int ip = 0;
+   int op = 0;
+   while (ip < iLen) {
+      int i0 = in[ip++] & 0xff;
+      int i1 = ip < iLen ? in[ip++] & 0xff : 0;
+      int i2 = ip < iLen ? in[ip++] & 0xff : 0;
+      int o0 = i0 >>> 2;
+      int o1 = ((i0 &   3) << 4) | (i1 >>> 4);
+      int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
+      int o3 = i2 & 0x3F;
+      out[op++] = map1[o0];
+      out[op++] = map1[o1];
+      out[op] = op < oDataLen ? map1[o2] : '='; op++;
+      out[op] = op < oDataLen ? map1[o3] : '='; op++; }
+   return out; }
+
+/**
+* Decodes a string from Base64 format.
+* @param s  a Base64 String to be decoded.
+* @return   A String containing the decoded data.
+* @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static String decodeString (String s) {
+   if(s.equals("nil")) return("");
+   return new String(decode(s)); }
+
+public static String decodeStringUTF8(String s) {
+   if(s.equals("nil")) return("");
+   try {
+       String r = new String(decode(s), "UTF-8") ;
+       return r ;
+   } catch (UnsupportedEncodingException ee) {}
+   return ("") ;
+}
+
+
+
+
+/**
+* Decodes a byte array from Base64 format.
+* @param s  a Base64 String to be decoded.
+* @return   An array containing the decoded data bytes.
+* @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static byte[] decode (String s) {
+   return decode(s.toCharArray()); }
+
+/**
+* Decodes a byte array from Base64 format.
+* No blanks or line breaks are allowed within the Base64 encoded data.
+* @param in  a character array containing the Base64 encoded data.
+* @return    An array containing the decoded data bytes.
+* @throws    IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static byte[] decode (char[] in) {
+   int iLen = in.length;
+   if (iLen%4 != 0) throw new IllegalArgumentException ("Length of Base64 encoded input string is not a multiple of 4.");
+   while (iLen > 0 && in[iLen-1] == '=') iLen--;
+   int oLen = (iLen*3) / 4;
+   byte[] out = new byte[oLen];
+   int ip = 0;
+   int op = 0;
+   while (ip < iLen) {
+      int i0 = in[ip++];
+      int i1 = in[ip++];
+      int i2 = ip < iLen ? in[ip++] : 'A';
+      int i3 = ip < iLen ? in[ip++] : 'A';
+      if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127)
+         throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
+      int b0 = map2[i0];
+      int b1 = map2[i1];
+      int b2 = map2[i2];
+      int b3 = map2[i3];
+      if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
+         throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
+      int o0 = ( b0       <<2) | (b1>>>4);
+      int o1 = ((b1 & 0xf)<<4) | (b2>>>2);
+      int o2 = ((b2 &   3)<<6) |  b3;
+      out[op++] = (byte)o0;
+      if (op<oLen) out[op++] = (byte)o1;
+      if (op<oLen) out[op++] = (byte)o2; }
+   return out; }
+
+// Dummy constructor.
+private Base64Coder() {}
+
+} // end class Base64Coder
+ 
+ 
+// eof //
diff --git a/guiserver/java/Base64Coder.java.bak b/guiserver/java/Base64Coder.java.bak
new file mode 100644
index 0000000..bc61a20
--- /dev/null
+++ b/guiserver/java/Base64Coder.java.bak
@@ -0,0 +1,173 @@
+/**
+* A Base64 Encoder/Decoder.
+*
+* <p>
+* This class is used to encode and decode data in Base64 format as described in RFC 1521.
+*
+* <p>
+* This is "Open Source" software and released under the <a href="http://www.gnu.org/licenses/lgpl.html">GNU/LGPL</a> license.<br>
+* It is provided "as is" without warranty of any kind.<br>
+* Copyright 2003: Christian d'Heureuse, Inventec Informatik AG, Switzerland.<br>
+* Home page: <a href="http://www.source-code.biz">www.source-code.biz</a><br>
+*
+* <p>
+* Version history:<br>
+* 2003-07-22 Christian d'Heureuse (chdh): Module created.<br>
+* 2005-08-11 chdh: Lincense changed from GPL to LGPL.<br>
+* 2006-11-21 chdh:<br>
+*  &nbsp; Method encode(String) renamed to encodeString(String).<br>
+*  &nbsp; Method decode(String) renamed to decodeString(String).<br>
+*  &nbsp; New method encode(byte[],int) added.<br>
+*  &nbsp; New method decode(String) added.<br>
+* 2010-08-11 added encodeStringUTF8(String) and decodeStringUTF8(String).<br>
+*/
+
+import java.io.UnsupportedEncodingException;
+
+public class Base64Coder {
+
+// Mapping table from 6-bit nibbles to Base64 characters.
+private static char[]    map1 = new char[64];
+   static {
+      int i=0;
+      for (char c='A'; c<='Z'; c++) map1[i++] = c;
+      for (char c='a'; c<='z'; c++) map1[i++] = c;
+      for (char c='0'; c<='9'; c++) map1[i++] = c;
+      map1[i++] = '+'; map1[i++] = '/'; }
+
+// Mapping table from Base64 characters to 6-bit nibbles.
+private static byte[]    map2 = new byte[128];
+   static {
+      for (int i=0; i<map2.length; i++) map2[i] = -1;
+      for (int i=0; i<64; i++) map2[map1[i]] = (byte)i; }
+
+/**
+* Encodes a string into Base64 format.
+* No blanks or line breaks are inserted.
+* @param s  a String to be encoded.
+* @return   A String with the Base64 encoded data.
+*/
+public static String encodeString (String s) {
+   return new String(encode(s.getBytes())); }
+
+public static String encodeStringUTF8(String s) {
+   byte [] bs ;
+   try {
+       bs = s.getBytes("UTF-8") ;
+       String r = new String(encode(bs)) ;
+       return r ;
+   } catch (UnsupportedEncodingException ee) {}
+   return new String("") ;
+}
+
+
+/**
+* Encodes a byte array into Base64 format.
+* No blanks or line breaks are inserted.
+* @param in  an array containing the data bytes to be encoded.
+* @return    A character array with the Base64 encoded data.
+*/
+public static char[] encode (byte[] in) {
+   return encode(in,in.length); }
+
+/**
+* Encodes a byte array into Base64 format.
+* No blanks or line breaks are inserted.
+* @param in   an array containing the data bytes to be encoded.
+* @param iLen number of bytes to process in <code>in</code>.
+* @return     A character array with the Base64 encoded data.
+*/
+public static char[] encode (byte[] in, int iLen) {
+   int oDataLen = (iLen*4+2)/3;       // output length without padding
+   int oLen = ((iLen+2)/3)*4;         // output length including padding
+   char[] out = new char[oLen];
+   int ip = 0;
+   int op = 0;
+   while (ip < iLen) {
+      int i0 = in[ip++] & 0xff;
+      int i1 = ip < iLen ? in[ip++] & 0xff : 0;
+      int i2 = ip < iLen ? in[ip++] & 0xff : 0;
+      int o0 = i0 >>> 2;
+      int o1 = ((i0 &   3) << 4) | (i1 >>> 4);
+      int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
+      int o3 = i2 & 0x3F;
+      out[op++] = map1[o0];
+      out[op++] = map1[o1];
+      out[op] = op < oDataLen ? map1[o2] : '='; op++;
+      out[op] = op < oDataLen ? map1[o3] : '='; op++; }
+   return out; }
+
+/**
+* Decodes a string from Base64 format.
+* @param s  a Base64 String to be decoded.
+* @return   A String containing the decoded data.
+* @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static String decodeString (String s) {
+   if(s.equals("nil")) return("");
+   return new String(decode(s)); }
+
+public static String decodeStringUTF8(String s) {
+   if(s.equals("nil")) return("");
+   try {
+       String r = new String(decode(s), "UTF-8") ;
+       return r ;
+   } catch (UnsupportedEncodingException ee) {}
+   return ("") ;
+}
+
+
+
+
+/**
+* Decodes a byte array from Base64 format.
+* @param s  a Base64 String to be decoded.
+* @return   An array containing the decoded data bytes.
+* @throws   IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static byte[] decode (String s) {
+   return decode(s.toCharArray()); }
+
+/**
+* Decodes a byte array from Base64 format.
+* No blanks or line breaks are allowed within the Base64 encoded data.
+* @param in  a character array containing the Base64 encoded data.
+* @return    An array containing the decoded data bytes.
+* @throws    IllegalArgumentException if the input is not valid Base64 encoded data.
+*/
+public static byte[] decode (char[] in) {
+   int iLen = in.length;
+   if (iLen%4 != 0) throw new IllegalArgumentException ("Length of Base64 encoded input string is not a multiple of 4.");
+   while (iLen > 0 && in[iLen-1] == '=') iLen--;
+   int oLen = (iLen*3) / 4;
+   byte[] out = new byte[oLen];
+   int ip = 0;
+   int op = 0;
+   while (ip < iLen) {
+      int i0 = in[ip++];
+      int i1 = in[ip++];
+      int i2 = ip < iLen ? in[ip++] : 'A';
+      int i3 = ip < iLen ? in[ip++] : 'A';
+      if (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127)
+         throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
+      int b0 = map2[i0];
+      int b1 = map2[i1];
+      int b2 = map2[i2];
+      int b3 = map2[i3];
+      if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
+         throw new IllegalArgumentException ("Illegal character in Base64 encoded data.");
+      int o0 = ( b0       <<2) | (b1>>>4);
+      int o1 = ((b1 & 0xf)<<4) | (b2>>>2);
+      int o2 = ((b2 &   3)<<6) |  b3;
+      out[op++] = (byte)o0;
+      if (op<oLen) out[op++] = (byte)o1;
+      if (op<oLen) out[op++] = (byte)o2; }
+   return out; }
+
+// Dummy constructor.
+private Base64Coder() {}
+
+} // end class Base64Coder
+ 
+ 
+// eof //
diff --git a/guiserver/java/ButtonWidget.java b/guiserver/java/ButtonWidget.java
new file mode 100644
index 0000000..357405e
--- /dev/null
+++ b/guiserver/java/ButtonWidget.java
@@ -0,0 +1,86 @@
+//
+//  ButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/12/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class ButtonWidget extends aButton {
+
+@SuppressWarnings("unchecked") 
+public ButtonWidget(StringTokenizer params)
+	{
+	abutton = new JButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	else
+		{
+		abutton.setVerticalAlignment(JButton.CENTER);
+		}
+		
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		abutton.setPreferredSize(new Dimension(width, height));
+		}
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{
+			if(action != null)
+				{
+				guiserver.out.println("("+ action + " \"" + id +  "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	abutton.addActionListener(listener);
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ButtonWidget.java.bak b/guiserver/java/ButtonWidget.java.bak
new file mode 100644
index 0000000..9bafdc1
--- /dev/null
+++ b/guiserver/java/ButtonWidget.java.bak
@@ -0,0 +1,86 @@
+//
+//  ButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/12/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class ButtonWidget extends aButton {
+
+@SuppressWarnings("unchecked") 
+public ButtonWidget(StringTokenizer params)
+	{
+	abutton = new JButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	else
+		{
+		abutton.setVerticalAlignment(JButton.CENTER);
+		}
+		
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		abutton.setPreferredSize(new Dimension(width, height));
+		}
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{
+			if(action != null)
+				{
+				guiserver.out.println("("+ action + " \"" + id +  "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	abutton.addActionListener(listener);
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/CanvasWidget.java b/guiserver/java/CanvasWidget.java
new file mode 100644
index 0000000..3bc68ca
--- /dev/null
+++ b/guiserver/java/CanvasWidget.java
@@ -0,0 +1,833 @@
+//
+//  CanvasWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/8/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+import java.awt.print.*;
+import java.awt.image.BufferStrategy;
+import java.awt.image.BufferedImage;
+import javax.swing.*;
+import javax.imageio.ImageIO;
+import java.util.*;
+import java.io.File;
+import java.io.IOException;
+
+@SuppressWarnings("unchecked")
+public class CanvasWidget extends gsObject {
+
+static CanvasWidget currentCanvas;
+
+Vector drawobjects = new Vector();
+
+MyCanvas canvas;
+//Window ownerWindow;
+double translationX = 0;
+double translationY = 0;
+double theta = 0;
+double scaleX = 1;
+double scaleY = 1;
+Color background = null;
+Stroke currentStroke;
+Color currentPaint;
+//AffineTransform transform = AffineTransform.getScaleInstance(1.0, 1.0);
+AffineTransform transform = null;
+AlphaComposite currentComposite;
+Font currentFont = null;
+boolean antiAliasing = true;
+boolean visible = true;
+
+String mouseClickedEvent;
+String mouseEnteredEvent;
+String mouseExitedEvent;
+String mousePressedEvent;
+String mouseReleasedEvent;
+String mouseDraggedEvent; 	
+String mouseMovedEvent; 	
+String mouseWheelMovedEvent;
+
+boolean mousePressedTags = false;
+boolean mouseReleasedTags = false;
+boolean mouseClickedTags = false;
+boolean mouseMovedTags = false;
+
+public CanvasWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	canvas = new MyCanvas();
+
+	component = canvas;
+	
+	// if canvas is not Canvas but JPanel
+	container = canvas;
+	jcomponent = canvas;
+
+	CanvasWidget.currentCanvas = this;
+	
+	currentStroke = new BasicStroke();
+	currentPaint = new Color(0,0,0);
+	
+	scaleX = 1.0;
+	scaleY = 1.0;
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void g2Canvas(StringTokenizer tokens)
+	{
+	CanvasWidget.currentCanvas = this;
+	}
+	
+public void g2Translation(StringTokenizer tokens)
+	{
+	translationX = Float.parseFloat(tokens.nextToken());
+	translationY = Float.parseFloat(tokens.nextToken());
+	}	
+
+public void g2Scale(StringTokenizer tokens)
+	{
+	scaleX = Float.parseFloat(tokens.nextToken());
+	scaleY = Float.parseFloat(tokens.nextToken());
+	}	
+	
+public void g2Rotation(StringTokenizer tokens)
+	{
+	double rotation = Float.parseFloat(tokens.nextToken());
+	theta = 2.0 * Math.PI * rotation / 360.0;
+	}	
+	
+public void g2Transform(StringTokenizer tokens)
+	{
+	double m00 = Float.parseFloat(tokens.nextToken());
+	double m01 = Float.parseFloat(tokens.nextToken());
+	double m02 = Float.parseFloat(tokens.nextToken());
+	double m10 = Float.parseFloat(tokens.nextToken());
+	double m11 = Float.parseFloat(tokens.nextToken());
+	double m12 = Float.parseFloat(tokens.nextToken());
+	
+	//transform.concatenate(new AffineTransform(m00, m01, m02, m10, m11, m12));
+	}	
+
+public void g2Stroke(StringTokenizer tokens)
+	{
+	float strokeWidth = Float.parseFloat(tokens.nextToken());
+	int strokeCap = BasicStroke.CAP_BUTT;
+	int strokeJoin = BasicStroke.JOIN_MITER;
+	float strokeMiterLimit = (float)10.0;
+	
+	if(tokens.hasMoreTokens())
+		{
+		String cap = tokens.nextToken();
+		if(cap.equals("round")) strokeCap = BasicStroke.CAP_ROUND;
+		else if(cap.equals("square")) strokeCap = BasicStroke.CAP_SQUARE;
+		else strokeCap = BasicStroke.CAP_BUTT;
+		}
+	
+	if(tokens.hasMoreTokens())
+		{
+		String join = tokens.nextToken();
+		if(join.equals("round")) strokeJoin = BasicStroke.JOIN_BEVEL;
+		else if(join.equals("square")) strokeJoin = BasicStroke.JOIN_ROUND;
+		else strokeJoin = BasicStroke.JOIN_MITER;
+		}
+		
+	if(tokens.hasMoreTokens())
+		strokeMiterLimit = Float.parseFloat(tokens.nextToken());
+
+	currentStroke = new BasicStroke(strokeWidth, strokeCap, strokeJoin, strokeMiterLimit);
+	}
+	
+public void g2Paint(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	R = Float.parseFloat(tokens.nextToken());
+	G = Float.parseFloat(tokens.nextToken());
+	B = Float.parseFloat(tokens.nextToken());
+
+	if(tokens.hasMoreTokens())
+		alpha = Float.parseFloat(tokens.nextToken());
+	else 
+		alpha = 1;
+
+	currentPaint = new Color(R, G, B, alpha);
+	}
+	
+public void g2Update(StringTokenizer tokens)
+	{
+	canvas.repaint();
+	}
+	
+public void g2Export(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	int width = canvas.getWidth();
+	int height = canvas.getHeight();
+	
+	if(tokens.hasMoreTokens())
+		{
+		width = Integer.parseInt(tokens.nextToken());
+		height = Integer.parseInt(tokens.nextToken());
+		}
+	
+	canvas.export(path, "PNG", width, height);
+	}
+	
+public void g2Print(StringTokenizer tokens)
+	{
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	R = Float.parseFloat(tokens.nextToken());
+	G = Float.parseFloat(tokens.nextToken());
+	B = Float.parseFloat(tokens.nextToken());
+
+	if(tokens.hasMoreTokens())
+		alpha = Float.parseFloat(tokens.nextToken());
+	else 
+		alpha = 1;
+	
+	background = new Color(R, G, B, alpha);
+	
+	component.setBackground(background);
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	String name = Base64Coder.decodeString(tokens.nextToken());
+	int style = 0;
+	int size = 12;
+	
+	if(tokens.hasMoreTokens())
+		size = Integer.parseInt(tokens.nextToken());
+	
+	while(tokens.hasMoreTokens())
+		{
+		String sstyle = tokens.nextToken();
+		if(sstyle.equals("plain")) style = style | Font.PLAIN;
+		if(sstyle.equals("bold")) style = style | Font.BOLD;
+		if(sstyle.equals("italic")) style = style | Font.ITALIC;
+		}
+		
+	currentFont = new Font(name, style, size);
+	component.setFont(currentFont);
+	}
+	
+
+public void setAntiAliasing(StringTokenizer tokens) 
+	{
+	antiAliasing = tokens.nextToken().equals("true");
+	}
+
+// create shapes
+
+public void drawLine(StringTokenizer tokens)
+	{
+	new LineShape(tokens);
+	}
+	
+public void drawRectangle(StringTokenizer tokens)
+	{
+	new RectangleShape(tokens);
+	}
+
+public void fillRectangle(StringTokenizer tokens)
+	{
+	new FilledRectangleShape(tokens);
+	}
+
+public void drawRoundRect(StringTokenizer tokens)
+	{
+	new RoundRectangleShape(tokens);
+	}
+
+public void fillRoundRect(StringTokenizer tokens)
+	{
+	new FilledRoundRectangleShape(tokens);
+	}
+
+public void drawEllipse(StringTokenizer tokens)
+	{
+	new EllipseShape(tokens);
+	}
+
+public void fillEllipse(StringTokenizer tokens)
+	{
+	new FilledEllipseShape(tokens);
+	}
+
+public void drawCircle(StringTokenizer tokens)
+	{
+	new CircleShape(tokens);
+	}
+
+public void fillCircle(StringTokenizer tokens)
+	{
+	new FilledCircleShape(tokens);
+	}
+
+public void drawArc(StringTokenizer tokens)
+	{
+	new ArcShape(tokens);
+	}
+
+public void fillArc(StringTokenizer tokens)
+	{
+	new FilledArcShape(tokens);
+	}
+
+public void drawPolygon(StringTokenizer tokens)
+	{
+	new PolygonShape(tokens);
+	}
+	
+public void fillPolygon(StringTokenizer tokens)
+	{
+	new FilledPolygonShape(tokens);
+	}
+
+public void drawPath(StringTokenizer tokens)
+	{
+	new PathShape(tokens);
+	}
+	
+public void drawText(StringTokenizer tokens)
+	{
+	new TextShape(tokens);
+	}
+
+public void drawImage(StringTokenizer tokens)
+	{
+	new ImageShape(tokens);
+	}
+	
+// register mouse events
+	
+public void registerMouseClicked(StringTokenizer tokens)
+	{
+	mouseClickedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mouseClickedTags = tokens.nextToken().equals("true");
+	}
+	
+public void registerMousePressed(StringTokenizer tokens)
+	{
+	mousePressedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mousePressedTags = tokens.nextToken().equals("true");
+	}
+
+public void registerMouseRelease(StringTokenizer tokens)
+	{
+	mouseReleasedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mouseReleasedTags = tokens.nextToken().equals("true");
+	}
+	
+public void registerMouseExited(StringTokenizer tokens)
+	{
+	mouseExitedEvent = tokens.nextToken();
+	}
+	
+public void registerMouseEntered(StringTokenizer tokens)
+	{
+	mouseEnteredEvent = tokens.nextToken();
+	}
+	
+public void registerMouseDragged(StringTokenizer tokens)
+	{
+	mouseDraggedEvent = tokens.nextToken();
+	}
+	
+public void registerMouseMoved(StringTokenizer tokens)
+	{
+	mouseMovedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mouseMovedTags = tokens.nextToken().equals("true");
+	}
+	
+public void registerMouseWheel(StringTokenizer tokens)
+	{
+	mouseWheelMovedEvent = tokens.nextToken();
+	}
+
+// manipulate shapes
+	
+public void colorTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	Color paintColor = Shape.getColorParameter(tokens);
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+		
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.paintColor = paintColor;
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+		
+
+public void deleteTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Vector filteredObjects = new Vector();
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(!aShape.tag.equals(label))
+			filteredObjects.add(aShape);
+		}
+		
+	drawobjects = filteredObjects;
+	if(updateFlag) canvas.repaint();
+	}
+	
+public void moveTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	int dx = Integer.parseInt(tokens.nextToken());
+	int dy = Integer.parseInt(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			{
+			aShape.X += dx;
+			aShape.Y += dy;
+			}
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+public void translateTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double X = Float.parseFloat(tokens.nextToken());
+	double Y = Float.parseFloat(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.translate(X, Y);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+	
+public void rotateTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double theta = Float.parseFloat(tokens.nextToken());
+	int X = Integer.parseInt(tokens.nextToken());
+	int Y = Integer.parseInt(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	theta = 2.0 * Math.PI * theta / 360.0;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.rotate(theta, X, Y);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+	
+public void scaleTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double sx = Float.parseFloat(tokens.nextToken());
+	double sy = Float.parseFloat(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.scale(sx, sy);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+public void shearTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double shx = Float.parseFloat(tokens.nextToken());
+	double shy = Float.parseFloat(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.shear(shx, shy);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+			
+public void hideTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.visible = false;
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+	
+	
+public void showTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.visible = true;
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+
+public void orderTaggedShapes(StringTokenizer tokens)
+	{
+	String label;
+	Shape aShape;
+	
+	Vector orderedTags = new Vector();
+	
+	while(tokens.hasMoreTokens())
+		{
+		label = tokens.nextToken();
+		for(int i = 0; i < drawobjects.size(); i++)
+			{
+			aShape = (Shape)drawobjects.elementAt(i);
+//			System.out.println("comparing:" + label + "<->" + aShape.tag);
+			if(aShape.tag.equals(label))
+				{
+				orderedTags.add(aShape);
+//				System.out.println("adding->" + aShape.tag);
+				}
+			}
+		}
+		
+	drawobjects = orderedTags;
+	}
+
+class MyCanvas extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener, Printable  {
+public static final long serialVersionUID = 1L;
+	public MyCanvas() {
+		super();
+		
+		// if canvas extends JPanel
+		if(guiserver.DOUBLE_BUFFERING)
+			this.setDoubleBuffered(true);
+		
+		addMouseListener(this);
+		addMouseMotionListener(this);
+		addMouseWheelListener(this);
+		}
+
+	public void update(Graphics g) 
+		{ 
+		if(guiserver.MAC_OS_X) super.update(g);
+		else paint(g); 
+		} 
+ 
+	public void paint(Graphics g)
+		{
+		Graphics2D g2;
+//		BufferStrategy myStrategy = null; 
+		
+/* only if canvas extends Canvas
+		if(guiserver.DOUBLE_BUFFERING)
+			{
+			try {
+				this.createBufferStrategy(2);
+				}	
+			catch (Exception evt) 
+				{
+				System.out.println("event: =>" + evt);
+				}
+	
+			
+			myStrategy = this.getBufferStrategy();
+			Graphics myg = myStrategy.getDrawGraphics();
+			g2 = (Graphics2D)myg;
+			}
+		else
+*/
+			g2 = (Graphics2D)g;
+		
+		render(g2);
+			
+		/* only used if canvas is Canvas
+		if(guiserver.DOUBLE_BUFFERING)
+			{
+			myStrategy.show();
+			g2.dispose();
+			}
+		*/
+		}
+		
+		
+	public void render(Graphics2D g2)
+		{
+		if(background != null) g2.setColor(background);
+		
+		// fill background
+		if(background != null)
+			{
+			g2.setPaint(background);
+			g2.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
+			}
+				
+		g2.translate(translationX, translationY);
+		g2.scale(scaleX, scaleY);
+		g2.rotate(theta);
+		
+		AffineTransform normalTransform = g2.getTransform();
+		
+		if(antiAliasing)
+			g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                            RenderingHints.VALUE_ANTIALIAS_ON);
+		
+		for(int i = 0; i < drawobjects.size(); i++)
+			{
+			Shape shape = (Shape)drawobjects.elementAt(i);
+
+			if(shape.visible) 
+				{
+				g2.transform(shape.transform);
+				shape.drawShape(g2);
+				g2.setTransform(normalTransform);
+				}
+			}
+		
+		paintComponents(g2);
+		}
+		
+	public Iterator getTagsFromPoint(int X, int Y)
+		{
+		HashMap tags = new HashMap();
+		for(int i = 0; i < drawobjects.size(); i++)
+			{
+			Shape shape = (Shape)drawobjects.elementAt(i);
+			if(shape.hasPoint(X, Y))
+				{
+				if(!tags.containsKey(shape.tag))
+					tags.put(shape.tag, 0);
+				}
+			}
+			
+		return tags.keySet().iterator();
+		}
+		
+	public void mouseClicked(MouseEvent e) 
+		{
+		if(mouseClickedEvent == null) return;
+		
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mouseClickedEvent + " " + X + " " + Y + " " + 
+			e.getButton() + " " + e.getClickCount() + " " + e.getModifiers());
+		
+		if(mouseClickedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+			
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseEntered(MouseEvent e)
+		{
+		if(mouseEnteredEvent == null) return;
+		}
+	
+	public void mouseExited(MouseEvent e) 
+		{
+		if(mouseExitedEvent == null) return;
+		}
+	
+	public void mousePressed(MouseEvent e)
+		{
+		if(mousePressedEvent == null) return;
+			
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mousePressedEvent + " " + X + " " + Y + " " + 
+			e.getButton() + " " + e.getModifiers());
+		
+		if(mousePressedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+			
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseReleased(MouseEvent e)
+		{
+		if(mouseReleasedEvent == null) return;
+				
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mouseReleasedEvent + " " + X + " " + Y + " " + 
+			e.getButton() + " " + e.getModifiers());
+		
+		if(mouseReleasedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+			
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseDragged(MouseEvent e) 
+		{
+		if(mouseDraggedEvent == null) return;
+			
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.println("(" + mouseDraggedEvent + " " + X + " " + Y + " " + 
+				e.getButton() + " " + e.getModifiers() + ")" );
+		guiserver.out.flush();
+		}
+
+	public void mouseMoved(MouseEvent e) 
+		{
+		if(mouseMovedEvent == null) return;
+			
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mouseMovedEvent + " " + X + " " + Y);
+		
+		if(mouseMovedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+		
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseWheelMoved(MouseWheelEvent e) 
+		{
+		if(mouseWheelMovedEvent == null) return;
+		
+		int rotation = e.getWheelRotation();
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.println("(" + mouseWheelMovedEvent + " " + X + " " + Y + " " + rotation + ")" );
+		guiserver.out.flush();
+		}
+		
+	public void export(String path, String format, int width, int height)
+		{
+		//BufferedImage bufferimage = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
+		BufferedImage bufferimage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+		
+		Graphics2D g2 = bufferimage.createGraphics();
+		
+		render(g2);
+		
+		try { ImageIO.write(bufferimage, format, new File(path)); } 
+		catch (IOException ie) {
+				ErrorDialog.show("Exporting", "Could not write file: " + path);
+				}
+		}
+	
+	public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) 
+		{
+		return(0);
+		}
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/CanvasWidget.java.bak b/guiserver/java/CanvasWidget.java.bak
new file mode 100644
index 0000000..0f377ca
--- /dev/null
+++ b/guiserver/java/CanvasWidget.java.bak
@@ -0,0 +1,833 @@
+//
+//  CanvasWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/8/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+import java.awt.print.*;
+import java.awt.image.BufferStrategy;
+import java.awt.image.BufferedImage;
+import javax.swing.*;
+import javax.imageio.ImageIO;
+import java.util.*;
+import java.io.File;
+import java.io.IOException;
+
+@SuppressWarnings("unchecked")
+public class CanvasWidget extends gsObject {
+
+static CanvasWidget currentCanvas;
+
+Vector drawobjects = new Vector();
+
+MyCanvas canvas;
+//Window ownerWindow;
+double translationX = 0;
+double translationY = 0;
+double theta = 0;
+double scaleX = 1;
+double scaleY = 1;
+Color background = null;
+Stroke currentStroke;
+Color currentPaint;
+//AffineTransform transform = AffineTransform.getScaleInstance(1.0, 1.0);
+AffineTransform transform = null;
+AlphaComposite currentComposite;
+Font currentFont = null;
+boolean antiAliasing = true;
+boolean visible = true;
+
+String mouseClickedEvent;
+String mouseEnteredEvent;
+String mouseExitedEvent;
+String mousePressedEvent;
+String mouseReleasedEvent;
+String mouseDraggedEvent; 	
+String mouseMovedEvent; 	
+String mouseWheelMovedEvent;
+
+boolean mousePressedTags = false;
+boolean mouseReleasedTags = false;
+boolean mouseClickedTags = false;
+boolean mouseMovedTags = false;
+
+public CanvasWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	canvas = new MyCanvas();
+
+	component = canvas;
+	
+	// if canvas is not Canvas but JPanel
+	container = canvas;
+	jcomponent = canvas;
+
+	CanvasWidget.currentCanvas = this;
+	
+	currentStroke = new BasicStroke();
+	currentPaint = new Color(0,0,0);
+	
+	scaleX = 1.0;
+	scaleY = 1.0;
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void g2Canvas(StringTokenizer tokens)
+	{
+	CanvasWidget.currentCanvas = this;
+	}
+	
+public void g2Translation(StringTokenizer tokens)
+	{
+	translationX = Float.parseFloat(tokens.nextToken());
+	translationY = Float.parseFloat(tokens.nextToken());
+	}	
+
+public void g2Scale(StringTokenizer tokens)
+	{
+	scaleX = Float.parseFloat(tokens.nextToken());
+	scaleY = Float.parseFloat(tokens.nextToken());
+	}	
+	
+public void g2Rotation(StringTokenizer tokens)
+	{
+	double rotation = Float.parseFloat(tokens.nextToken());
+	theta = 2.0 * Math.PI * rotation / 360.0;
+	}	
+	
+public void g2Transform(StringTokenizer tokens)
+	{
+	double m00 = Float.parseFloat(tokens.nextToken());
+	double m01 = Float.parseFloat(tokens.nextToken());
+	double m02 = Float.parseFloat(tokens.nextToken());
+	double m10 = Float.parseFloat(tokens.nextToken());
+	double m11 = Float.parseFloat(tokens.nextToken());
+	double m12 = Float.parseFloat(tokens.nextToken());
+	
+	//transform.concatenate(new AffineTransform(m00, m01, m02, m10, m11, m12));
+	}	
+
+public void g2Stroke(StringTokenizer tokens)
+	{
+	float strokeWidth = Float.parseFloat(tokens.nextToken());
+	int strokeCap = BasicStroke.CAP_BUTT;
+	int strokeJoin = BasicStroke.JOIN_MITER;
+	float strokeMiterLimit = (float)10.0;
+	
+	if(tokens.hasMoreTokens())
+		{
+		String cap = tokens.nextToken();
+		if(cap.equals("round")) strokeCap = BasicStroke.CAP_ROUND;
+		else if(cap.equals("square")) strokeCap = BasicStroke.CAP_SQUARE;
+		else strokeCap = BasicStroke.CAP_BUTT;
+		}
+	
+	if(tokens.hasMoreTokens())
+		{
+		String join = tokens.nextToken();
+		if(join.equals("round")) strokeJoin = BasicStroke.JOIN_BEVEL;
+		else if(join.equals("square")) strokeJoin = BasicStroke.JOIN_ROUND;
+		else strokeJoin = BasicStroke.JOIN_MITER;
+		}
+		
+	if(tokens.hasMoreTokens())
+		strokeMiterLimit = Float.parseFloat(tokens.nextToken());
+
+	currentStroke = new BasicStroke(strokeWidth, strokeCap, strokeJoin, strokeMiterLimit);
+	}
+	
+public void g2Paint(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	R = Float.parseFloat(tokens.nextToken());
+	G = Float.parseFloat(tokens.nextToken());
+	B = Float.parseFloat(tokens.nextToken());
+
+	if(tokens.hasMoreTokens())
+		alpha = Float.parseFloat(tokens.nextToken());
+	else 
+		alpha = 1;
+
+	currentPaint = new Color(R, G, B, alpha);
+	}
+	
+public void g2Update(StringTokenizer tokens)
+	{
+	canvas.repaint();
+	}
+	
+public void g2Export(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	int width = canvas.getWidth();
+	int height = canvas.getHeight();
+	
+	if(tokens.hasMoreTokens())
+		{
+		width = Integer.parseInt(tokens.nextToken());
+		height = Integer.parseInt(tokens.nextToken());
+		}
+	
+	canvas.export(path, "PNG", width, height);
+	}
+	
+public void g2Print(StringTokenizer tokens)
+	{
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	R = Float.parseFloat(tokens.nextToken());
+	G = Float.parseFloat(tokens.nextToken());
+	B = Float.parseFloat(tokens.nextToken());
+
+	if(tokens.hasMoreTokens())
+		alpha = Float.parseFloat(tokens.nextToken());
+	else 
+		alpha = 1;
+	
+	background = new Color(R, G, B, alpha);
+	
+	component.setBackground(background);
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	String name = Base64Coder.decodeString(tokens.nextToken());
+	int style = 0;
+	int size = 12;
+	
+	if(tokens.hasMoreTokens())
+		size = Integer.parseInt(tokens.nextToken());
+	
+	while(tokens.hasMoreTokens())
+		{
+		String sstyle = tokens.nextToken();
+		if(sstyle.equals("plain")) style = style | Font.PLAIN;
+		if(sstyle.equals("bold")) style = style | Font.BOLD;
+		if(sstyle.equals("italic")) style = style | Font.ITALIC;
+		}
+		
+	currentFont = new Font(name, style, size);
+	component.setFont(currentFont);
+	}
+	
+
+public void setAntiAliasing(StringTokenizer tokens) 
+	{
+	antiAliasing = tokens.nextToken().equals("true");
+	}
+
+// create shapes
+
+public void drawLine(StringTokenizer tokens)
+	{
+	new LineShape(tokens);
+	}
+	
+public void drawRectangle(StringTokenizer tokens)
+	{
+	new RectangleShape(tokens);
+	}
+
+public void fillRectangle(StringTokenizer tokens)
+	{
+	new FilledRectangleShape(tokens);
+	}
+
+public void drawRoundRect(StringTokenizer tokens)
+	{
+	new RoundRectangleShape(tokens);
+	}
+
+public void fillRoundRect(StringTokenizer tokens)
+	{
+	new FilledRoundRectangleShape(tokens);
+	}
+
+public void drawEllipse(StringTokenizer tokens)
+	{
+	new EllipseShape(tokens);
+	}
+
+public void fillEllipse(StringTokenizer tokens)
+	{
+	new FilledEllipseShape(tokens);
+	}
+
+public void drawCircle(StringTokenizer tokens)
+	{
+	new CircleShape(tokens);
+	}
+
+public void fillCircle(StringTokenizer tokens)
+	{
+	new FilledCircleShape(tokens);
+	}
+
+public void drawArc(StringTokenizer tokens)
+	{
+	new ArcShape(tokens);
+	}
+
+public void fillArc(StringTokenizer tokens)
+	{
+	new FilledArcShape(tokens);
+	}
+
+public void drawPolygon(StringTokenizer tokens)
+	{
+	new PolygonShape(tokens);
+	}
+	
+public void fillPolygon(StringTokenizer tokens)
+	{
+	new FilledPolygonShape(tokens);
+	}
+
+public void drawPath(StringTokenizer tokens)
+	{
+	new PathShape(tokens);
+	}
+	
+public void drawText(StringTokenizer tokens)
+	{
+	new TextShape(tokens);
+	}
+
+public void drawImage(StringTokenizer tokens)
+	{
+	new ImageShape(tokens);
+	}
+	
+// register mouse events
+	
+public void registerMouseClicked(StringTokenizer tokens)
+	{
+	mouseClickedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mouseClickedTags = tokens.nextToken().equals("true");
+	}
+	
+public void registerMousePressed(StringTokenizer tokens)
+	{
+	mousePressedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mousePressedTags = tokens.nextToken().equals("true");
+	}
+
+public void registerMouseRelease(StringTokenizer tokens)
+	{
+	mouseReleasedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mouseReleasedTags = tokens.nextToken().equals("true");
+	}
+	
+public void registerMouseExited(StringTokenizer tokens)
+	{
+	mouseExitedEvent = tokens.nextToken();
+	}
+	
+public void registerMouseEntered(StringTokenizer tokens)
+	{
+	mouseEnteredEvent = tokens.nextToken();
+	}
+	
+public void registerMouseDragged(StringTokenizer tokens)
+	{
+	mouseDraggedEvent = tokens.nextToken();
+	}
+	
+public void registerMouseMoved(StringTokenizer tokens)
+	{
+	mouseMovedEvent = tokens.nextToken();
+	if(tokens.hasMoreTokens())
+		mouseMovedTags = tokens.nextToken().equals("true");
+	}
+	
+public void registerMouseWheel(StringTokenizer tokens)
+	{
+	mouseWheelMovedEvent = tokens.nextToken();
+	}
+
+// manipulate shapes
+	
+public void colorTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	Color paintColor = Shape.getColorParameter(tokens);
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+		
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.paintColor = paintColor;
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+		
+
+public void deleteTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Vector filteredObjects = new Vector();
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(!aShape.tag.equals(label))
+			filteredObjects.add(aShape);
+		}
+		
+	drawobjects = filteredObjects;
+	if(updateFlag) canvas.repaint();
+	}
+	
+public void moveTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	int dx = Integer.parseInt(tokens.nextToken());
+	int dy = Integer.parseInt(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			{
+			aShape.X += dx;
+			aShape.Y += dy;
+			}
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+public void translateTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double X = Float.parseFloat(tokens.nextToken());
+	double Y = Float.parseFloat(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.translate(X, Y);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+	
+public void rotateTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double theta = Float.parseFloat(tokens.nextToken());
+	int X = Integer.parseInt(tokens.nextToken());
+	int Y = Integer.parseInt(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	theta = 2.0 * Math.PI * theta / 360.0;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.rotate(theta, X, Y);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+	
+public void scaleTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double sx = Float.parseFloat(tokens.nextToken());
+	double sy = Float.parseFloat(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.scale(sx, sy);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+public void shearTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	double shx = Float.parseFloat(tokens.nextToken());
+	double shy = Float.parseFloat(tokens.nextToken());
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.transform.shear(shx, shy);
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+			
+public void hideTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.visible = false;
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+	
+	
+public void showTaggedShape(StringTokenizer tokens)
+	{
+	String label = tokens.nextToken();
+	boolean updateFlag = tokens.nextToken().equals("true");
+	Shape aShape;
+	
+	for(int i = 0; i < drawobjects.size(); i++)
+		{
+		aShape = (Shape)drawobjects.elementAt(i);
+		if(aShape.tag.equals(label))
+			aShape.visible = true;
+		}
+		
+	if(updateFlag) canvas.repaint();
+	}
+
+
+public void orderTaggedShapes(StringTokenizer tokens)
+	{
+	String label;
+	Shape aShape;
+	
+	Vector orderedTags = new Vector();
+	
+	while(tokens.hasMoreTokens())
+		{
+		label = tokens.nextToken();
+		for(int i = 0; i < drawobjects.size(); i++)
+			{
+			aShape = (Shape)drawobjects.elementAt(i);
+//			System.out.println("comparing:" + label + "<->" + aShape.tag);
+			if(aShape.tag.equals(label))
+				{
+				orderedTags.add(aShape);
+//				System.out.println("adding->" + aShape.tag);
+				}
+			}
+		}
+		
+	drawobjects = orderedTags;
+	}
+
+class MyCanvas extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener, Printable  {
+public static final long serialVersionUID = 1L;
+	public MyCanvas() {
+		super();
+		
+		// if canvas extends JPanel
+		if(guiserver.DOUBLE_BUFFERING)
+			this.setDoubleBuffered(true);
+		
+		addMouseListener(this);
+		addMouseMotionListener(this);
+		addMouseWheelListener(this);
+		}
+
+	public void update(Graphics g) 
+		{ 
+		if(guiserver.MAC_OS_X) super.update(g);
+		else paint(g); 
+		} 
+ 
+	public void paint(Graphics g)
+		{
+		Graphics2D g2;
+//		BufferStrategy myStrategy = null; 
+		
+/* only if canvas extends Canvas
+		if(guiserver.DOUBLE_BUFFERING)
+			{
+			try {
+				this.createBufferStrategy(2);
+				}	
+			catch (Exception evt) 
+				{
+				System.out.println("event: =>" + evt);
+				}
+	
+			
+			myStrategy = this.getBufferStrategy();
+			Graphics myg = myStrategy.getDrawGraphics();
+			g2 = (Graphics2D)myg;
+			}
+		else
+*/
+			g2 = (Graphics2D)g;
+		
+		render(g2);
+			
+		/* only used if canvas is Canvas
+		if(guiserver.DOUBLE_BUFFERING)
+			{
+			myStrategy.show();
+			g2.dispose();
+			}
+		*/
+		}
+		
+		
+	public void render(Graphics2D g2)
+		{
+		if(background != null) g2.setColor(background);
+		
+		// fill background
+		if(background != null)
+			{
+			g2.setPaint(background);
+			g2.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
+			}
+				
+		g2.translate(translationX, translationY);
+		g2.scale(scaleX, scaleY);
+		g2.rotate(theta);
+		
+		AffineTransform normalTransform = g2.getTransform();
+		
+		if(antiAliasing)
+			g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                            RenderingHints.VALUE_ANTIALIAS_ON);
+		
+		for(int i = 0; i < drawobjects.size(); i++)
+			{
+			Shape shape = (Shape)drawobjects.elementAt(i);
+
+			if(shape.visible) 
+				{
+				g2.transform(shape.transform);
+				shape.drawShape(g2);
+				g2.setTransform(normalTransform);
+				}
+			}
+		
+		paintComponents(g2);
+		}
+		
+	public Iterator getTagsFromPoint(int X, int Y)
+		{
+		HashMap tags = new HashMap();
+		for(int i = 0; i < drawobjects.size(); i++)
+			{
+			Shape shape = (Shape)drawobjects.elementAt(i);
+			if(shape.hasPoint(X, Y))
+				{
+				if(!tags.containsKey(shape.tag))
+					tags.put(shape.tag, 0);
+				}
+			}
+			
+		return tags.keySet().iterator();
+		}
+		
+	public void mouseClicked(MouseEvent e) 
+		{
+		if(mouseClickedEvent == null) return;
+		
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mouseClickedEvent + " " + X + " " + Y + " " + 
+			e.getButton() + " " + e.getClickCount() + " " + e.getModifiers());
+		
+		if(mouseClickedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+			
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseEntered(MouseEvent e)
+		{
+		if(mouseEnteredEvent == null) return;
+		}
+	
+	public void mouseExited(MouseEvent e) 
+		{
+		if(mouseExitedEvent == null) return;
+		}
+	
+	public void mousePressed(MouseEvent e)
+		{
+		if(mousePressedEvent == null) return;
+			
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mousePressedEvent + " " + X + " " + Y + " " + 
+			e.getButton() + " " + e.getModifiers());
+		
+		if(mousePressedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+			
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseReleased(MouseEvent e)
+		{
+		if(mouseReleasedEvent == null) return;
+				
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mouseReleasedEvent + " " + X + " " + Y + " " + 
+			e.getButton() + " " + e.getModifiers());
+		
+		if(mouseReleasedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+			
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseDragged(MouseEvent e) 
+		{
+		if(mouseDraggedEvent == null) return;
+			
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.println("(" + mouseDraggedEvent + " " + X + " " + Y + " " + 
+				e.getButton() + " " + e.getModifiers() + ")" );
+		guiserver.out.flush();
+		}
+
+	public void mouseMoved(MouseEvent e) 
+		{
+		if(mouseMovedEvent == null) return;
+			
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.print("(" + mouseMovedEvent + " " + X + " " + Y);
+		
+		if(mouseMovedTags)
+			{
+			guiserver.out.print(" '(");
+			Iterator tags = getTagsFromPoint(X, Y);
+			while(tags.hasNext())
+				guiserver.out.print("\"" + tags.next() + "\" ");
+			guiserver.out.print(")");
+			}
+		
+		guiserver.out.println(")");	
+		guiserver.out.flush();
+		}
+	
+	public void mouseWheelMoved(MouseWheelEvent e) 
+		{
+		if(mouseWheelMovedEvent == null) return;
+		
+		int rotation = e.getWheelRotation();
+		int X = e.getX();
+		int Y = e.getY();
+		
+		guiserver.out.println("(" + mouseWheelMovedEvent + " " + X + " " + Y + " " + rotation + ")" );
+		guiserver.out.flush();
+		}
+		
+	public void export(String path, String format, int width, int height)
+		{
+		//BufferedImage bufferimage = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
+		BufferedImage bufferimage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+		
+		Graphics2D g2 = bufferimage.createGraphics();
+		
+		render(g2);
+		
+		try { ImageIO.write(bufferimage, format, new File(path)); } 
+		catch (IOException ie) {
+				ErrorDialog.show("Exporting", "Could not write file: " + path);
+				}
+		}
+	
+	public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) 
+		{
+		return(0);
+		}
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/CheckBoxWidget.java b/guiserver/java/CheckBoxWidget.java
new file mode 100644
index 0000000..2789473
--- /dev/null
+++ b/guiserver/java/CheckBoxWidget.java
@@ -0,0 +1,87 @@
+//
+//  CheckBoxWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/13/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class CheckBoxWidget extends aButton {
+
+@SuppressWarnings("unchecked") 
+
+public CheckBoxWidget(StringTokenizer params)
+	{
+	abutton = new JCheckBox();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			abutton.setSelected(true);
+		}
+	
+	gsObject.widgets.put(id, this);
+
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(abutton.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	abutton.addActionListener(listener);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/CheckBoxWidget.java.bak b/guiserver/java/CheckBoxWidget.java.bak
new file mode 100644
index 0000000..0663954
--- /dev/null
+++ b/guiserver/java/CheckBoxWidget.java.bak
@@ -0,0 +1,87 @@
+//
+//  CheckBoxWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/13/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class CheckBoxWidget extends aButton {
+
+@SuppressWarnings("unchecked") 
+
+public CheckBoxWidget(StringTokenizer params)
+	{
+	abutton = new JCheckBox();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			abutton.setSelected(true);
+		}
+	
+	gsObject.widgets.put(id, this);
+
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(abutton.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	abutton.addActionListener(listener);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/CircleShape.java b/guiserver/java/CircleShape.java
new file mode 100644
index 0000000..6e8541f
--- /dev/null
+++ b/guiserver/java/CircleShape.java
@@ -0,0 +1,69 @@
+//
+//  CircleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked")
+public class CircleShape extends Shape {
+
+int radius;
+
+public CircleShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radius = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawOval(X - radius, Y - radius, 2 * radius - 1, 2 * radius - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radius, Y - radius, 2 * radius, 2 * radius).contains(x, y));
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/CircleShape.java.bak b/guiserver/java/CircleShape.java.bak
new file mode 100644
index 0000000..d9e4d37
--- /dev/null
+++ b/guiserver/java/CircleShape.java.bak
@@ -0,0 +1,69 @@
+//
+//  CircleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked")
+public class CircleShape extends Shape {
+
+int radius;
+
+public CircleShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radius = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawOval(X - radius, Y - radius, 2 * radius - 1, 2 * radius - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radius, Y - radius, 2 * radius, 2 * radius).contains(x, y));
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ComboBoxWidget.java b/guiserver/java/ComboBoxWidget.java
new file mode 100644
index 0000000..a1cf9d0
--- /dev/null
+++ b/guiserver/java/ComboBoxWidget.java
@@ -0,0 +1,140 @@
+//
+//  ComboBoxWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/13/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked") 
+public class ComboBoxWidget extends gsObject implements ActionListener{
+
+JComboBox combobox;
+
+public ComboBoxWidget(StringTokenizer params)
+	{
+	combobox = new JComboBox();
+	jcomponent = combobox;
+	component = combobox;
+	container = combobox;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+		
+	while(params.hasMoreTokens())
+		{
+		addListItem(params);
+		}
+		
+	gsObject.widgets.put(id, this);
+
+	combobox.addActionListener(this);
+	}
+	
+public void actionPerformed(ActionEvent e)
+	{
+	int index = combobox.getSelectedIndex();
+	String idx = Integer.toString(index);
+	String item = combobox.getSelectedItem().toString();
+
+	if(guiserver.UTF8 && item.length() != 0)
+		item = Base64Coder.encodeStringUTF8(item);
+	else
+		item = Base64Coder.encodeString(item);
+	
+	guiserver.out.println("(" + action + " \"" + id + "\" " + idx + " \"" + item + "\")");
+	guiserver.out.flush();
+	}
+	
+public void addListItem(StringTokenizer tokens)
+	{
+	while(tokens.hasMoreTokens()) 
+		{
+		String text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		combobox.addItem(text);
+		}
+	}
+	
+public void removeListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	
+	while(tokens.hasMoreTokens()) 
+		{
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (combobox.getItemCount() - 1)) index = combobox.getItemCount() - 1;
+		if(index < 0) index = 0;
+		combobox.removeItemAt(index);
+		}
+	}
+
+public void insertListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	String text;
+	
+	while(tokens.hasMoreTokens())
+		{
+		text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+		
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (combobox.getItemCount() - 1)) index = combobox.getItemCount() - 1;
+		if(index < 0) index = 0;
+		combobox.insertItemAt(text, index);
+		}
+	}
+	
+public void selectListItem(StringTokenizer tokens)
+	{
+	String item = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		item = Base64Coder.decodeStringUTF8(item);
+	else
+		item = Base64Coder.decodeString(item);
+
+	combobox.setSelectedItem(item);
+	}
+
+public void clearList(StringTokenizer tokens)
+	{
+	combobox.removeAllItems();
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ComboBoxWidget.java.bak b/guiserver/java/ComboBoxWidget.java.bak
new file mode 100644
index 0000000..310b7b7
--- /dev/null
+++ b/guiserver/java/ComboBoxWidget.java.bak
@@ -0,0 +1,140 @@
+//
+//  ComboBoxWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/13/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked") 
+public class ComboBoxWidget extends gsObject implements ActionListener{
+
+JComboBox combobox;
+
+public ComboBoxWidget(StringTokenizer params)
+	{
+	combobox = new JComboBox();
+	jcomponent = combobox;
+	component = combobox;
+	container = combobox;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+		
+	while(params.hasMoreTokens())
+		{
+		addListItem(params);
+		}
+		
+	gsObject.widgets.put(id, this);
+
+	combobox.addActionListener(this);
+	}
+	
+public void actionPerformed(ActionEvent e)
+	{
+	int index = combobox.getSelectedIndex();
+	String idx = Integer.toString(index);
+	String item = combobox.getSelectedItem().toString();
+
+	if(guiserver.UTF8 && item.length() != 0)
+		item = Base64Coder.encodeStringUTF8(item);
+	else
+		item = Base64Coder.encodeString(item);
+	
+	guiserver.out.println("(" + action + " \"" + id + "\" " + idx + " \"" + item + "\")");
+	guiserver.out.flush();
+	}
+	
+public void addListItem(StringTokenizer tokens)
+	{
+	while(tokens.hasMoreTokens()) 
+		{
+		String text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		combobox.addItem(text);
+		}
+	}
+	
+public void removeListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	
+	while(tokens.hasMoreTokens()) 
+		{
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (combobox.getItemCount() - 1)) index = combobox.getItemCount() - 1;
+		if(index < 0) index = 0;
+		combobox.removeItemAt(index);
+		}
+	}
+
+public void insertListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	String text;
+	
+	while(tokens.hasMoreTokens())
+		{
+		text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+		
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (combobox.getItemCount() - 1)) index = combobox.getItemCount() - 1;
+		if(index < 0) index = 0;
+		combobox.insertItemAt(text, index);
+		}
+	}
+	
+public void selectListItem(StringTokenizer tokens)
+	{
+	String item = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		item = Base64Coder.decodeStringUTF8(item);
+	else
+		item = Base64Coder.decodeString(item);
+
+	combobox.setSelectedItem(item);
+	}
+
+public void clearList(StringTokenizer tokens)
+	{
+	combobox.removeAllItems();
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/DialogWidget.java b/guiserver/java/DialogWidget.java
new file mode 100644
index 0000000..0e467f3
--- /dev/null
+++ b/guiserver/java/DialogWidget.java
@@ -0,0 +1,251 @@
+//
+//  DialogWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/23/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+// DO NOT USE, when set modal inhibits Dispather from processing incoming messages
+// this makes it imposible to serve newLISP requests from the Dialog, if modal
+
+@SuppressWarnings("unchecked")
+
+public class DialogWidget extends gsObject {
+
+JDialog jdialog;
+JFrame jfowner;
+String dialogCloseAction = null;
+String dialogMoveAction = null;
+String dialogResizeAction = null;
+
+public DialogWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	String owner = params.nextToken();
+ 
+	String message = params.nextToken();
+	
+	if(guiserver.UTF8)
+		message = Base64Coder.decodeStringUTF8(message);
+	else
+		message = Base64Coder.decodeString(message);
+
+	boolean ismodal = false;
+	
+	jfowner = ((WindowFrame)gsObject.widgets.get(owner)).jframe;
+		
+	//String closeButtonId = params.nextToken();
+	//ButtonWidget closeButton = (ButtonWidget)gsObject.widgets.get(closeButtonId);
+	
+	int x = jfowner.getX() + 100;
+	int y = jfowner.getY() + 100;
+	int width = Integer.parseInt(params.nextToken());
+	int height = Integer.parseInt(params.nextToken());
+	
+	jdialog	= new JDialog(jfowner, message, false);
+	//closeButton.jdialog = jdialog;
+		
+	jdialog.setBounds(x, y, width, height);
+	
+	container = jdialog.getContentPane();
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			jdialog.setVisible(true);	
+		}
+	else jdialog.setVisible(false);
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			jfowner.setEnabled(false);
+		}
+	
+	WindowAdapter listener = new WindowAdapter() {
+		public void windowClosing(WindowEvent w)
+			{
+			//System.out.println("Closing dialog");
+			jfowner.setEnabled(true);
+			jdialog.dispose();
+			if(dialogCloseAction != null)
+				{
+				guiserver.out.println("(" + dialogCloseAction + "\"" + id + "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+
+ 	jdialog.addWindowListener(listener);
+	
+	ComponentAdapter componentListener = new ComponentAdapter() {
+		public void componentResized(ComponentEvent re) 
+			{
+			if(dialogResizeAction != null)
+				{
+				guiserver.out.println("(" + dialogResizeAction + "\"" + id + "\"" + 
+						jdialog.getWidth() + " " + jdialog.getHeight() +")");
+				guiserver.out.flush();
+				}
+			}
+			
+		public void componentMoved(ComponentEvent me)
+			{
+			if(dialogMoveAction != null)
+				{
+				guiserver.out.println("(" + dialogMoveAction + "\"" + id + "\"" + 
+						jdialog.getLocationOnScreen().x + " " + jdialog.getLocationOnScreen().y +")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	jdialog.addComponentListener(componentListener);
+
+	gsObject.widgets.put(id, this);
+	
+	jdialog.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+	}
+	
+	
+public void setText(StringTokenizer tokens)
+	{	
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	jdialog.setTitle(text);
+	}
+
+
+public void getText(StringTokenizer tokens)
+	{
+	String action = tokens.nextToken();
+	String text = jdialog.getTitle();
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+	
+
+public void clearText(StringTokenizer tokens)
+	{
+	jdialog.setTitle("");
+	}
+
+
+public void setVisible(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		jdialog.setVisible(true);
+	else
+		jdialog.setVisible(false);
+	}
+
+public void setResizable(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		jdialog.setResizable(true);
+	else
+		jdialog.setResizable(false);
+	}
+
+public void dispose(StringTokenizer tokens)
+	{
+	jfowner.setEnabled(true);
+	jdialog.dispose();
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jdialog.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		jdialog.setBackground(new Color(red, green, blue));
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setToolTip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = jdialog.getLocationOnScreen().x;
+	y = jdialog.getLocationOnScreen().y;
+		
+	width = jdialog.getWidth();
+	height = jdialog.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+
+	
+public void frameCloseEvent(StringTokenizer tokens)
+	{
+	dialogCloseAction = tokens.nextToken();
+	}
+	
+public void frameResizeEvent(StringTokenizer tokens)
+	{
+	dialogResizeAction = tokens.nextToken();
+	}
+	
+public void frameMoveEvent(StringTokenizer tokens)
+	{
+	dialogMoveAction = tokens.nextToken();
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/DialogWidget.java.bak b/guiserver/java/DialogWidget.java.bak
new file mode 100644
index 0000000..847a9d8
--- /dev/null
+++ b/guiserver/java/DialogWidget.java.bak
@@ -0,0 +1,251 @@
+//
+//  DialogWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/23/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+// DO NOT USE, when set modal inhibits Dispather from processing incoming messages
+// this makes it imposible to serve newLISP requests from the Dialog, if modal
+
+@SuppressWarnings("unchecked")
+
+public class DialogWidget extends gsObject {
+
+JDialog jdialog;
+JFrame jfowner;
+String dialogCloseAction = null;
+String dialogMoveAction = null;
+String dialogResizeAction = null;
+
+public DialogWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	String owner = params.nextToken();
+ 
+	String message = params.nextToken();
+	
+	if(guiserver.UTF8)
+		message = Base64Coder.decodeStringUTF8(message);
+	else
+		message = Base64Coder.decodeString(message);
+
+	boolean ismodal = false;
+	
+	jfowner = ((WindowFrame)gsObject.widgets.get(owner)).jframe;
+		
+	//String closeButtonId = params.nextToken();
+	//ButtonWidget closeButton = (ButtonWidget)gsObject.widgets.get(closeButtonId);
+	
+	int x = jfowner.getX() + 100;
+	int y = jfowner.getY() + 100;
+	int width = Integer.parseInt(params.nextToken());
+	int height = Integer.parseInt(params.nextToken());
+	
+	jdialog	= new JDialog(jfowner, message, false);
+	//closeButton.jdialog = jdialog;
+		
+	jdialog.setBounds(x, y, width, height);
+	
+	container = jdialog.getContentPane();
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			jdialog.setVisible(true);	
+		}
+	else jdialog.setVisible(false);
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			jfowner.setEnabled(false);
+		}
+	
+	WindowAdapter listener = new WindowAdapter() {
+		public void windowClosing(WindowEvent w)
+			{
+			//System.out.println("Closing dialog");
+			jfowner.setEnabled(true);
+			jdialog.dispose();
+			if(dialogCloseAction != null)
+				{
+				guiserver.out.println("(" + dialogCloseAction + "\"" + id + "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+
+ 	jdialog.addWindowListener(listener);
+	
+	ComponentAdapter componentListener = new ComponentAdapter() {
+		public void componentResized(ComponentEvent re) 
+			{
+			if(dialogResizeAction != null)
+				{
+				guiserver.out.println("(" + dialogResizeAction + "\"" + id + "\"" + 
+						jdialog.getWidth() + " " + jdialog.getHeight() +")");
+				guiserver.out.flush();
+				}
+			}
+			
+		public void componentMoved(ComponentEvent me)
+			{
+			if(dialogMoveAction != null)
+				{
+				guiserver.out.println("(" + dialogMoveAction + "\"" + id + "\"" + 
+						jdialog.getLocationOnScreen().x + " " + jdialog.getLocationOnScreen().y +")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	jdialog.addComponentListener(componentListener);
+
+	gsObject.widgets.put(id, this);
+	
+	jdialog.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+	}
+	
+	
+public void setText(StringTokenizer tokens)
+	{	
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	jdialog.setTitle(text);
+	}
+
+
+public void getText(StringTokenizer tokens)
+	{
+	String action = tokens.nextToken();
+	String text = jdialog.getTitle();
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+	
+
+public void clearText(StringTokenizer tokens)
+	{
+	jdialog.setTitle("");
+	}
+
+
+public void setVisible(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		jdialog.setVisible(true);
+	else
+		jdialog.setVisible(false);
+	}
+
+public void setResizable(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		jdialog.setResizable(true);
+	else
+		jdialog.setResizable(false);
+	}
+
+public void dispose(StringTokenizer tokens)
+	{
+	jfowner.setEnabled(true);
+	jdialog.dispose();
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jdialog.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		jdialog.setBackground(new Color(red, green, blue));
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setToolTip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = jdialog.getLocationOnScreen().x;
+	y = jdialog.getLocationOnScreen().y;
+		
+	width = jdialog.getWidth();
+	height = jdialog.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+
+	
+public void frameCloseEvent(StringTokenizer tokens)
+	{
+	dialogCloseAction = tokens.nextToken();
+	}
+	
+public void frameResizeEvent(StringTokenizer tokens)
+	{
+	dialogResizeAction = tokens.nextToken();
+	}
+	
+public void frameMoveEvent(StringTokenizer tokens)
+	{
+	dialogMoveAction = tokens.nextToken();
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/Dispatcher.java b/guiserver/java/Dispatcher.java
new file mode 100644
index 0000000..4689087
--- /dev/null
+++ b/guiserver/java/Dispatcher.java
@@ -0,0 +1,336 @@
+//
+//  Dispatcher.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/14/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+import java.awt.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class Dispatcher {
+
+static String cmd;
+static HashMap classes = new HashMap();
+static HashMap methods = new HashMap();
+	
+public static void dispatch(String command)
+	{
+	StringTokenizer tokens = null;
+	String id = null;
+	gsObject gsobject = null;
+	Class cfoo;
+	Constructor constor;
+	Class[] defArgs = {StringTokenizer.class};
+	Method method;
+	String methodName;
+	
+	if(guiserver.debug) System.out.println("-> " + command);
+	
+	tokens = new StringTokenizer(command);
+	
+	Object[] initArgs = {tokens};
+	cmd = tokens.nextToken();
+			
+	// look for constructor methods
+	if((cfoo = (Class)classes.get(cmd)) != null)
+		{
+		try { 
+			constor = cfoo.getConstructor(defArgs); 
+			constor.newInstance(initArgs);
+			} catch (Exception ce) { 
+			if(guiserver.debug)
+				System.out.println("Error: " + cmd + "=>" + ce);
+			else
+				{
+				ErrorDialog.show(command, "Could not create " + cmd);
+				//System.exit(1);
+				return;
+				}
+			}
+				
+		return;
+		}
+
+	else // get target object
+		{
+		id = tokens.nextToken();
+		gsobject = (gsObject)gsObject.widgets.get(id);
+		//System.out.println("get target: " + id);
+		if(gsobject == null)
+			{
+			ErrorDialog.wrongApplication(cmd, id);
+			//System.exit(1);
+			return;
+			}
+		}
+
+	// get method for target and invoke it with arguments
+	try { 
+		//System.out.println("invoke " + cmd + " on " + id);
+		methodName = (String)methods.get(cmd);
+		//System.out.println("methodName:" + methodName);
+		method = gsobject.getClass().getMethod(methodName, defArgs);
+		//System.out.println("method:" + method);
+		if(method != null)
+			{
+			method.invoke(gsobject, initArgs);
+			return;
+			}
+		} catch (Exception ce) { 
+		if(guiserver.debug)
+			ce.printStackTrace();
+		else
+			{
+			ErrorDialog.show(command, "Could not invoke method " + cmd + " with " + id);
+			//System.exit(1);
+			return;
+			}
+		}
+	}
+	
+public static void init()
+	{
+	// GUI widget classes
+	classes.put("window", WindowWidget.class);
+	classes.put("frame", WindowFrame.class);
+	classes.put("dialog", DialogWidget.class);
+	classes.put("panel", PanelWidget.class);
+	classes.put("tabbed-pane", TabbedPaneWidget.class);
+	classes.put("split-pane", SplitPaneWidget.class);
+	classes.put("scroll-pane", ScrollPaneWidget.class);
+	classes.put("label", LabelWidget.class);
+	classes.put("image-label", ImageLabelWidget.class);
+	classes.put("set-grid-layout", LayoutGrid.class);
+	classes.put("set-flow-layout", LayoutFlow.class);
+	classes.put("set-border-layout", LayoutBorder.class);
+	classes.put("button", ButtonWidget.class);
+	classes.put("image-button", ImageButtonWidget.class);
+	classes.put("toggle-button", ToggleButtonWidget.class);
+	classes.put("check-box", CheckBoxWidget.class);
+	classes.put("radio-button", RadioButtonWidget.class);
+	classes.put("combo-box", ComboBoxWidget.class);
+	classes.put("slider", SliderWidget.class);
+	classes.put("progress-bar", ProgressBarWidget.class);
+	classes.put("list-box", ListBoxWidget.class);
+	classes.put("text-field", TextFieldWidget.class);
+	classes.put("text-area", TextAreaWidget.class);
+	classes.put("menu-item", MenuItemWidget.class);
+	classes.put("menu-item-check", MenuItemCheckWidget.class);
+	classes.put("menu", MenuWidget.class);
+	classes.put("menu-popup", PopupMenuWidget.class);
+	classes.put("menu-bar", MenuBarWidget.class);
+	classes.put("table", TableWidget.class);
+	classes.put("tool-bar", ToolbarWidget.class);
+	classes.put("text-pane", TextPaneWidget.class);
+
+	// 2D Graphics classes
+	classes.put("canvas", CanvasWidget.class);
+	
+	// GUI methods
+	methods.put("add-list-item","addListItem");
+	methods.put("add-separator","addSeparator");
+	methods.put("add-to","addTo");
+	methods.put("append-text","appendText");
+	methods.put("clear-list","clearList");
+	methods.put("clear-text","clearText");
+	methods.put("confirm-dialog","confirmDialog");
+	methods.put("color-dialog","ColorChooser");
+	methods.put("copy-text","copyText");
+	methods.put("cut-text","cutText");
+	methods.put("disable","Disable");
+	methods.put("dispose","dispose");
+	methods.put("enable","Enable");
+	methods.put("find-text", "findText");
+	methods.put("frame-closed", "frameCloseEvent");
+	methods.put("frame-moved", "frameMoveEvent");
+	methods.put("frame-resized", "frameResizeEvent");
+	methods.put("get-bounds", "getBounds");
+	methods.put("get-font-metrics", "getFontMetrics");
+	methods.put("get-selected-text", "getSelection");
+	methods.put("get-text","getText");
+	methods.put("get-text-position","getTextPosition");
+	methods.put("goto-text", "gotoText");
+	methods.put("insert-list-item","insertListItem");
+	methods.put("insert-tab","insertTab");
+	methods.put("insert-text", "insertText");
+	methods.put("layout", "layout");
+	methods.put("load-text", "loadText");
+	methods.put("open-file-dialog","OpenFileChooser");
+	methods.put("message-dialog","messageDialog");
+	methods.put("paste-text","pasteText");
+	methods.put("redo-text","redoText");
+	methods.put("remove-from", "removeFrom");
+	methods.put("remove-list-item","removeListItem");
+	methods.put("remove-tab","removeTab");
+	methods.put("request-focus","requestFocus");
+	methods.put("save-file-dialog","SaveFileChooser");
+	methods.put("save-text", "saveText");
+	methods.put("set-caret", "setCaret");
+	methods.put("select-text","selectText");
+	methods.put("set-accelerator","setAccelerator");
+	methods.put("set-background","setBackground");
+	methods.put("set-bevel-border","setBevelBorder");
+	methods.put("set-caret-color","setCaretColor");
+	methods.put("set-color","setBackground");	
+	methods.put("set-cursor","setCursor");
+	methods.put("set-echo-char", "setEchoChar");
+	methods.put("set-editable","setEditable");
+	methods.put("set-font","setFont");
+	methods.put("set-foreground","setForeground");
+	methods.put("set-icon","setIcon");
+	methods.put("select-list-item","selectListItem");
+	methods.put("set-pressed-icon","setPressedIcon");
+	methods.put("set-resizable","setResizable");
+	methods.put("set-selected","setSelected");
+	methods.put("set-selection-color","setSelectionColor");
+	methods.put("set-size","setPreferredSize");
+	methods.put("set-text","setText");
+	methods.put("set-tab-size","setTabSize");
+	methods.put("set-titled-border","setTitledBorder");
+	methods.put("set-tool-tip","setToolTip");
+	methods.put("set-value","setValue");
+	methods.put("set-visible","setVisible");
+	methods.put("set-syntax", "setSyntax");
+	methods.put("show-popup", "showPopup");
+	methods.put("undo-text","undoText");
+	methods.put("undo-enable", "undoEnable");
+	methods.put("run-shell", "runShell");
+	methods.put("eval-shell", "evalShell");
+	methods.put("destroy-shell", "destroyShell");
+	
+	// methods for System object (guiserver)
+	methods.put("add-track", "addTrack");
+	methods.put("channel-bend", "channelBend");
+	methods.put("channel-reverb", "channelReverb");
+	methods.put("dispose-splash", "disposeSplash");
+	methods.put("get-fonts", "getFonts");
+	methods.put("get-screen", "getScreen");
+	methods.put("get-instruments", "getInstruments");
+	methods.put("get-version", "getVersion");
+	methods.put("midi-init", "midiInit");
+	methods.put("midi-close", "midiClose");
+	methods.put("midi-patch", "midiPatch");
+	methods.put("midi-bpm", "midiBPM");
+	methods.put("mute-track", "muteTrack");
+	methods.put("solo-track", "soloTrack");
+	methods.put("set-trace", "setTrace");
+	methods.put("set-look-and-feel", "setLookAndFeel");
+	methods.put("set-syntax-colors", "setSyntaxColors");
+	methods.put("play-note", "playNote");
+	methods.put("play-sound", "playSound");
+	methods.put("play-sequence", "playSequence");
+	methods.put("stop-sequence", "stopSequence");
+	methods.put("save-sequence", "saveSequence");
+	methods.put("set-utf8", "setUTF8");
+	
+	// text table
+	methods.put("table-add-column", "tableAddColumn") ;
+	methods.put("table-add-row", "tableAddRow");
+	methods.put("table-remove-row", "tableRemoveRow"); // FdB
+	methods.put("table-set-column", "tableSetColumn");
+	methods.put("table-set-column-name", "tableSetColumnIdentifiers"); // FdB
+	methods.put("table-show-row-number", "tableShowRowNumber");
+	methods.put("table-set-row-number", "tableShowRowNumber"); // deprecated
+	methods.put("table-set-row-count", "tableSetRowCount"); // FdB
+	methods.put("table-set-cell", "tableSetCell");
+	methods.put("table-get-cell", "tableGetCell");
+	methods.put("table-get", "tableGetValueAll");
+	methods.put("table-get-size", "tableGetSize");
+
+	// 2D Grapics
+	// All methods hace the current canvas as target
+	
+	// methods for creating shapes
+	// put in Vector in current canvas
+	methods.put("draw-arc", "drawArc");
+	methods.put("draw-circle", "drawCircle");
+	methods.put("draw-ellipse", "drawEllipse");
+	methods.put("draw-image", "drawImage"); 
+	methods.put("draw-line", "drawLine");
+	methods.put("draw-path", "drawPath"); 
+	methods.put("draw-polygon", "drawPolygon");
+	methods.put("draw-text", "drawText"); 
+	methods.put("draw-rect", "drawRectangle");
+	methods.put("draw-round-rect", "drawRoundRect");
+	methods.put("fill-arc", "fillArc");
+	methods.put("fill-circle", "fillCircle");
+	methods.put("fill-ellipse", "fillEllipse");
+	methods.put("fill-polygon", "fillPolygon");
+	methods.put("fill-rect", "fillRectangle");
+	methods.put("fill-round-rect", "fillRoundRect");
+	methods.put("set-anti-aliasing", "setAntiAliasing");
+
+	// general mouse and key events
+	methods.put("mouse-event","registerMouseEvent");
+	methods.put("key-event","registerKeyEvent");
+	
+	// specialize events for canvas
+	methods.put("mouse-clicked","registerMouseClicked");
+	methods.put("mouse-pressed","registerMousePressed");
+	methods.put("mouse-released","registerMouseRelease");
+	methods.put("mouse-entered","registerMouseEntered");
+	methods.put("mouse-exited","registerMouseExited");
+	methods.put("mouse-dragged","registerMouseDragged");
+	methods.put("mouse-moved","registerMouseMoved");
+	methods.put("mouse-wheel", "registerMouseWheel");
+	
+	// take canvas for global settings as target
+	methods.put("set-canvas", "g2Canvas");
+	methods.put("set-translation", "g2Translation");
+	methods.put("set-transform", "g2Transform");
+	methods.put("set-rotation", "g2Rotation");
+	methods.put("set-scale", "g2Scale");
+	methods.put("export", "g2Export");
+	methods.put("print", "g2Print");
+	methods.put("update", "g2Update");
+	
+	// current canvas settings used in next shape
+	methods.put("set-stroke", "g2Stroke");
+	methods.put("set-paint", "g2Paint");
+	methods.put("set-composite", "g2Composite");
+	methods.put("set-clipping", "g2Clip");
+	
+	// take tags for drawing shapes as target
+	methods.put("delete-tag", "deleteTaggedShape");
+	methods.put("move-tag", "moveTaggedShape");
+	methods.put("translate-tag", "translateTaggedShape");
+	methods.put("rotate-tag", "rotateTaggedShape");
+	methods.put("scale-tag", "scaleTaggedShape");
+	methods.put("shear-tag", "shearTaggedShape");
+	methods.put("hide-tag", "hideTaggedShape");
+	methods.put("show-tag", "showTaggedShape");
+	methods.put("delete-tag", "deleteTaggedShape");	
+	methods.put("reorder-tags", "orderTaggedShapes");	
+	methods.put("color-tag", "colorTaggedShape");	
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/Dispatcher.java.bak b/guiserver/java/Dispatcher.java.bak
new file mode 100644
index 0000000..54782c2
--- /dev/null
+++ b/guiserver/java/Dispatcher.java.bak
@@ -0,0 +1,336 @@
+//
+//  Dispatcher.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/14/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+import java.awt.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class Dispatcher {
+
+static String cmd;
+static HashMap classes = new HashMap();
+static HashMap methods = new HashMap();
+	
+public static void dispatch(String command)
+	{
+	StringTokenizer tokens = null;
+	String id = null;
+	gsObject gsobject = null;
+	Class cfoo;
+	Constructor constor;
+	Class[] defArgs = {StringTokenizer.class};
+	Method method;
+	String methodName;
+	
+	if(guiserver.debug) System.out.println("-> " + command);
+	
+	tokens = new StringTokenizer(command);
+	
+	Object[] initArgs = {tokens};
+	cmd = tokens.nextToken();
+			
+	// look for constructor methods
+	if((cfoo = (Class)classes.get(cmd)) != null)
+		{
+		try { 
+			constor = cfoo.getConstructor(defArgs); 
+			constor.newInstance(initArgs);
+			} catch (Exception ce) { 
+			if(guiserver.debug)
+				System.out.println("Error: " + cmd + "=>" + ce);
+			else
+				{
+				ErrorDialog.show(command, "Could not create " + cmd);
+				//System.exit(1);
+				return;
+				}
+			}
+				
+		return;
+		}
+
+	else // get target object
+		{
+		id = tokens.nextToken();
+		gsobject = (gsObject)gsObject.widgets.get(id);
+		//System.out.println("get target: " + id);
+		if(gsobject == null)
+			{
+			ErrorDialog.wrongApplication(cmd, id);
+			//System.exit(1);
+			return;
+			}
+		}
+
+	// get method for target and invoke it with arguments
+	try { 
+		//System.out.println("invoke " + cmd + " on " + id);
+		methodName = (String)methods.get(cmd);
+		//System.out.println("methodName:" + methodName);
+		method = gsobject.getClass().getMethod(methodName, defArgs);
+		//System.out.println("method:" + method);
+		if(method != null)
+			{
+			method.invoke(gsobject, initArgs);
+			return;
+			}
+		} catch (Exception ce) { 
+		if(guiserver.debug)
+			ce.printStackTrace();
+		else
+			{
+			ErrorDialog.show(command, "Could not invoke method " + cmd + " with " + id);
+			//System.exit(1);
+			return;
+			}
+		}
+	}
+	
+public static void init()
+	{
+	// GUI widget classes
+	classes.put("window", WindowWidget.class);
+	classes.put("frame", WindowFrame.class);
+	classes.put("dialog", DialogWidget.class);
+	classes.put("panel", PanelWidget.class);
+	classes.put("tabbed-pane", TabbedPaneWidget.class);
+	classes.put("split-pane", SplitPaneWidget.class);
+	classes.put("scroll-pane", ScrollPaneWidget.class);
+	classes.put("label", LabelWidget.class);
+	classes.put("image-label", ImageLabelWidget.class);
+	classes.put("set-grid-layout", LayoutGrid.class);
+	classes.put("set-flow-layout", LayoutFlow.class);
+	classes.put("set-border-layout", LayoutBorder.class);
+	classes.put("button", ButtonWidget.class);
+	classes.put("image-button", ImageButtonWidget.class);
+	classes.put("toggle-button", ToggleButtonWidget.class);
+	classes.put("check-box", CheckBoxWidget.class);
+	classes.put("radio-button", RadioButtonWidget.class);
+	classes.put("combo-box", ComboBoxWidget.class);
+	classes.put("slider", SliderWidget.class);
+	classes.put("progress-bar", ProgressBarWidget.class);
+	classes.put("list-box", ListBoxWidget.class);
+	classes.put("text-field", TextFieldWidget.class);
+	classes.put("text-area", TextAreaWidget.class);
+	classes.put("menu-item", MenuItemWidget.class);
+	classes.put("menu-item-check", MenuItemCheckWidget.class);
+	classes.put("menu", MenuWidget.class);
+	classes.put("menu-popup", PopupMenuWidget.class);
+	classes.put("menu-bar", MenuBarWidget.class);
+	classes.put("table", TableWidget.class);
+	classes.put("tool-bar", ToolbarWidget.class);
+	classes.put("text-pane", TextPaneWidget.class);
+
+	// 2D Graphics classes
+	classes.put("canvas", CanvasWidget.class);
+	
+	// GUI methods
+	methods.put("add-list-item","addListItem");
+	methods.put("add-separator","addSeparator");
+	methods.put("add-to","addTo");
+	methods.put("append-text","appendText");
+	methods.put("clear-list","clearList");
+	methods.put("clear-text","clearText");
+	methods.put("confirm-dialog","confirmDialog");
+	methods.put("color-dialog","ColorChooser");
+	methods.put("copy-text","copyText");
+	methods.put("cut-text","cutText");
+	methods.put("disable","Disable");
+	methods.put("dispose","dispose");
+	methods.put("enable","Enable");
+	methods.put("find-text", "findText");
+	methods.put("frame-closed", "frameCloseEvent");
+	methods.put("frame-moved", "frameMoveEvent");
+	methods.put("frame-resized", "frameResizeEvent");
+	methods.put("get-bounds", "getBounds");
+	methods.put("get-font-metrics", "getFontMetrics");
+	methods.put("get-selected-text", "getSelection");
+	methods.put("get-text","getText");
+	methods.put("get-text-position","getTextPosition");
+	methods.put("goto-text", "gotoText");
+	methods.put("insert-list-item","insertListItem");
+	methods.put("insert-tab","insertTab");
+	methods.put("insert-text", "insertText");
+	methods.put("layout", "layout");
+	methods.put("load-text", "loadText");
+	methods.put("open-file-dialog","OpenFileChooser");
+	methods.put("message-dialog","messageDialog");
+	methods.put("paste-text","pasteText");
+	methods.put("redo-text","redoText");
+	methods.put("remove-from", "removeFrom");
+	methods.put("remove-list-item","removeListItem");
+	methods.put("remove-tab","removeTab");
+	methods.put("request-focus","requestFocus");
+	methods.put("save-file-dialog","SaveFileChooser");
+	methods.put("save-text", "saveText");
+	methods.put("set-caret", "setCaret");
+	methods.put("select-text","selectText");
+	methods.put("set-accelerator","setAccelerator");
+	methods.put("set-background","setBackground");
+	methods.put("set-bevel-border","setBevelBorder");
+	methods.put("set-caret-color","setCaretColor");
+	methods.put("set-color","setBackground");	
+	methods.put("set-cursor","setCursor");
+	methods.put("set-echo-char", "setEchoChar");
+	methods.put("set-editable","setEditable");
+	methods.put("set-font","setFont");
+	methods.put("set-foreground","setForeground");
+	methods.put("set-icon","setIcon");
+	methods.put("select-list-item","selectListItem");
+	methods.put("set-pressed-icon","setPressedIcon");
+	methods.put("set-resizable","setResizable");
+	methods.put("set-selected","setSelected");
+	methods.put("set-selection-color","setSelectionColor");
+	methods.put("set-size","setPreferredSize");
+	methods.put("set-text","setText");
+	methods.put("set-tab-size","setTabSize");
+	methods.put("set-titled-border","setTitledBorder");
+	methods.put("set-tool-tip","setToolTip");
+	methods.put("set-value","setValue");
+	methods.put("set-visible","setVisible");
+	methods.put("set-syntax", "setSyntax");
+	methods.put("show-popup", "showPopup");
+	methods.put("undo-text","undoText");
+	methods.put("undo-enable", "undoEnable");
+	methods.put("run-shell", "runShell");
+	methods.put("eval-shell", "evalShell");
+	methods.put("destroy-shell", "destroyShell");
+	
+	// methods for System object (guiserver)
+	methods.put("add-track", "addTrack");
+	methods.put("channel-bend", "channelBend");
+	methods.put("channel-reverb", "channelReverb");
+	methods.put("dispose-splash", "disposeSplash");
+	methods.put("get-fonts", "getFonts");
+	methods.put("get-screen", "getScreen");
+	methods.put("get-instruments", "getInstruments");
+	methods.put("get-version", "getVersion");
+	methods.put("midi-init", "midiInit");
+	methods.put("midi-close", "midiClose");
+	methods.put("midi-patch", "midiPatch");
+	methods.put("midi-bpm", "midiBPM");
+	methods.put("mute-track", "muteTrack");
+	methods.put("solo-track", "soloTrack");
+	methods.put("set-trace", "setTrace");
+	methods.put("set-look-and-feel", "setLookAndFeel");
+	methods.put("set-syntax-colors", "setSyntaxColors");
+	methods.put("play-note", "playNote");
+	methods.put("play-sound", "playSound");
+	methods.put("play-sequence", "playSequence");
+	methods.put("stop-sequence", "stopSequence");
+	methods.put("save-sequence", "saveSequence");
+	methods.put("set-utf8", "setUTF8");
+	
+	// text table
+	methods.put("table-add-column", "tableAddColumn") ;
+	methods.put("table-add-row", "tableAddRow");
+	methods.put("table-remove-row", "tableRemoveRow"); // FdB
+	methods.put("table-set-column", "tableSetColumn");
+	methods.put("table-set-column-name", "tableSetColumnIdentifiers"); // FdB
+	methods.put("table-show-row-number", "tableShowRowNumber");
+	methods.put("table-set-row-number", "tableShowRowNumber"); // deprecated
+	methods.put("table-set-row-count", "tableSetRowCount"); // FdB
+	methods.put("table-set-cell", "tableSetCell");
+	methods.put("table-get-cell", "tableGetCell");
+	methods.put("table-get", "tableGetValueAll");
+	methods.put("table-get-size", "tableGetSize");
+
+	// 2D Grapics
+	// All methods hace the current canvas as target
+	
+	// methods for creating shapes
+	// put in Vector in current canvas
+	methods.put("draw-arc", "drawArc");
+	methods.put("draw-circle", "drawCircle");
+	methods.put("draw-ellipse", "drawEllipse");
+	methods.put("draw-image", "drawImage"); 
+	methods.put("draw-line", "drawLine");
+	methods.put("draw-path", "drawPath"); 
+	methods.put("draw-polygon", "drawPolygon");
+	methods.put("draw-text", "drawText"); 
+	methods.put("draw-rect", "drawRectangle");
+	methods.put("draw-round-rect", "drawRoundRect");
+	methods.put("fill-arc", "fillArc");
+	methods.put("fill-circle", "fillCircle");
+	methods.put("fill-ellipse", "fillEllipse");
+	methods.put("fill-polygon", "fillPolygon");
+	methods.put("fill-rect", "fillRectangle");
+	methods.put("fill-round-rect", "fillRoundRect");
+	methods.put("set-anti-aliasing", "setAntiAliasing");
+
+	// general mouse and key events
+	methods.put("mouse-event","registerMouseEvent");
+	methods.put("key-event","registerKeyEvent");
+	
+	// specialize events for canvas
+	methods.put("mouse-clicked","registerMouseClicked");
+	methods.put("mouse-pressed","registerMousePressed");
+	methods.put("mouse-released","registerMouseRelease");
+	methods.put("mouse-entered","registerMouseEntered");
+	methods.put("mouse-exited","registerMouseExited");
+	methods.put("mouse-dragged","registerMouseDragged");
+	methods.put("mouse-moved","registerMouseMoved");
+	methods.put("mouse-wheel", "registerMouseWheel");
+	
+	// take canvas for global settings as target
+	methods.put("set-canvas", "g2Canvas");
+	methods.put("set-translation", "g2Translation");
+	methods.put("set-transform", "g2Transform");
+	methods.put("set-rotation", "g2Rotation");
+	methods.put("set-scale", "g2Scale");
+	methods.put("export", "g2Export");
+	methods.put("print", "g2Print");
+	methods.put("update", "g2Update");
+	
+	// current canvas settings used in next shape
+	methods.put("set-stroke", "g2Stroke");
+	methods.put("set-paint", "g2Paint");
+	methods.put("set-composite", "g2Composite");
+	methods.put("set-clipping", "g2Clip");
+	
+	// take tags for drawing shapes as target
+	methods.put("delete-tag", "deleteTaggedShape");
+	methods.put("move-tag", "moveTaggedShape");
+	methods.put("translate-tag", "translateTaggedShape");
+	methods.put("rotate-tag", "rotateTaggedShape");
+	methods.put("scale-tag", "scaleTaggedShape");
+	methods.put("shear-tag", "shearTaggedShape");
+	methods.put("hide-tag", "hideTaggedShape");
+	methods.put("show-tag", "showTaggedShape");
+	methods.put("delete-tag", "deleteTaggedShape");	
+	methods.put("reorder-tags", "orderTaggedShapes");	
+	methods.put("color-tag", "colorTaggedShape");	
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/EllipseShape.java b/guiserver/java/EllipseShape.java
new file mode 100644
index 0000000..e9a6e9e
--- /dev/null
+++ b/guiserver/java/EllipseShape.java
@@ -0,0 +1,71 @@
+//
+//  EllipseShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class EllipseShape extends Shape {
+
+int radiusX;
+int radiusY;
+
+public EllipseShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radiusX = Integer.parseInt(tokens.nextToken());
+	radiusY = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawOval(X - radiusX, Y - radiusY, 2 * radiusX - 1, 2 * radiusY - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radiusX, Y - radiusY, 2 * radiusX, 2 * radiusY).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/EllipseShape.java.bak b/guiserver/java/EllipseShape.java.bak
new file mode 100644
index 0000000..c686ec7
--- /dev/null
+++ b/guiserver/java/EllipseShape.java.bak
@@ -0,0 +1,71 @@
+//
+//  EllipseShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class EllipseShape extends Shape {
+
+int radiusX;
+int radiusY;
+
+public EllipseShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radiusX = Integer.parseInt(tokens.nextToken());
+	radiusY = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawOval(X - radiusX, Y - radiusY, 2 * radiusX - 1, 2 * radiusY - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radiusX, Y - radiusY, 2 * radiusX, 2 * radiusY).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ErrorDialog.java b/guiserver/java/ErrorDialog.java
new file mode 100644
index 0000000..7d7b9d3
--- /dev/null
+++ b/guiserver/java/ErrorDialog.java
@@ -0,0 +1,78 @@
+//
+//  ErrorDialog.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/18/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.util.*;
+import java.awt.*;
+import javax.swing.*;
+
+public class ErrorDialog {
+
+static public void show(String command, String message)
+	{
+	int len = command.length();
+	String cmd;
+	
+	if(len > 128) 
+		cmd = command.substring(0, 64) + "..." + command.substring(len - 64);
+	else 
+		cmd = command;
+	
+	JOptionPane.showMessageDialog(null,
+					cmd + " :    \n" + message + "    ",
+					"newLISP GUI server",
+					JOptionPane.ERROR_MESSAGE);
+	//System.exit(0);
+	return;
+	}
+
+static public void showExit(String command, String message)
+    {
+    show(command, message);
+    System.exit(0);
+    }
+
+static public void wrongApplication(String command, String id)
+	{
+	int len = command.length();
+	String cmd;
+		
+	if(len > 128) 
+		cmd = command.substring(0, 64) + "..." + command.substring(len - 64);
+	else 
+		cmd = command;
+	
+
+	JOptionPane.showMessageDialog(null,
+				cmd + ":    \ncannot be applied to " + id + "    ",
+				"newLISP GUI server",
+				JOptionPane.ERROR_MESSAGE);
+	//System.exit(0);
+	return;
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ErrorDialog.java.bak b/guiserver/java/ErrorDialog.java.bak
new file mode 100644
index 0000000..b46ab2b
--- /dev/null
+++ b/guiserver/java/ErrorDialog.java.bak
@@ -0,0 +1,78 @@
+//
+//  ErrorDialog.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/18/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.util.*;
+import java.awt.*;
+import javax.swing.*;
+
+public class ErrorDialog {
+
+static public void show(String command, String message)
+	{
+	int len = command.length();
+	String cmd;
+	
+	if(len > 128) 
+		cmd = command.substring(0, 64) + "..." + command.substring(len - 64);
+	else 
+		cmd = command;
+	
+	JOptionPane.showMessageDialog(null,
+					cmd + " :    \n" + message + "    ",
+					"newLISP GUI server",
+					JOptionPane.ERROR_MESSAGE);
+	//System.exit(0);
+	return;
+	}
+
+static public void showExit(String command, String message)
+    {
+    show(command, message);
+    System.exit(0);
+    }
+
+static public void wrongApplication(String command, String id)
+	{
+	int len = command.length();
+	String cmd;
+		
+	if(len > 128) 
+		cmd = command.substring(0, 64) + "..." + command.substring(len - 64);
+	else 
+		cmd = command;
+	
+
+	JOptionPane.showMessageDialog(null,
+				cmd + ":    \ncannot be applied to " + id + "    ",
+				"newLISP GUI server",
+				JOptionPane.ERROR_MESSAGE);
+	//System.exit(0);
+	return;
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledArcShape.java b/guiserver/java/FilledArcShape.java
new file mode 100644
index 0000000..b93eabf
--- /dev/null
+++ b/guiserver/java/FilledArcShape.java
@@ -0,0 +1,77 @@
+//
+//  FilledArcShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledArcShape extends Shape {
+
+
+int width;
+int height;
+int startAngle;
+int arcAngle;
+
+public FilledArcShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	startAngle = Integer.parseInt(tokens.nextToken());
+	arcAngle = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillArc(X, Y, width - 1, height - 1, startAngle, arcAngle);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledArcShape.java.bak b/guiserver/java/FilledArcShape.java.bak
new file mode 100644
index 0000000..adb930f
--- /dev/null
+++ b/guiserver/java/FilledArcShape.java.bak
@@ -0,0 +1,77 @@
+//
+//  FilledArcShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledArcShape extends Shape {
+
+
+int width;
+int height;
+int startAngle;
+int arcAngle;
+
+public FilledArcShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	startAngle = Integer.parseInt(tokens.nextToken());
+	arcAngle = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillArc(X, Y, width - 1, height - 1, startAngle, arcAngle);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledCircleShape.java b/guiserver/java/FilledCircleShape.java
new file mode 100644
index 0000000..94f2aa9
--- /dev/null
+++ b/guiserver/java/FilledCircleShape.java
@@ -0,0 +1,70 @@
+//
+//  FilledCircleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked")
+public class FilledCircleShape extends Shape {
+
+int radius;
+
+public FilledCircleShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radius = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillOval(X - radius, Y - radius, 2 * radius - 1, 2 * radius - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radius, Y - radius, 2 * radius, 2 * radius).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledCircleShape.java.bak b/guiserver/java/FilledCircleShape.java.bak
new file mode 100644
index 0000000..9e89d52
--- /dev/null
+++ b/guiserver/java/FilledCircleShape.java.bak
@@ -0,0 +1,70 @@
+//
+//  FilledCircleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked")
+public class FilledCircleShape extends Shape {
+
+int radius;
+
+public FilledCircleShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radius = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillOval(X - radius, Y - radius, 2 * radius - 1, 2 * radius - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radius, Y - radius, 2 * radius, 2 * radius).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledEllipseShape.java b/guiserver/java/FilledEllipseShape.java
new file mode 100644
index 0000000..fdaf712
--- /dev/null
+++ b/guiserver/java/FilledEllipseShape.java
@@ -0,0 +1,72 @@
+//
+//  FilledEllipseShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledEllipseShape extends Shape {
+
+
+int radiusX;
+int radiusY;
+
+public FilledEllipseShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radiusX = Integer.parseInt(tokens.nextToken());
+	radiusY = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillOval(X - radiusX, Y - radiusY, 2 * radiusX - 1, 2 * radiusY - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radiusX, Y - radiusY, 2 * radiusX, 2 * radiusY).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledEllipseShape.java.bak b/guiserver/java/FilledEllipseShape.java.bak
new file mode 100644
index 0000000..c8b8f04
--- /dev/null
+++ b/guiserver/java/FilledEllipseShape.java.bak
@@ -0,0 +1,72 @@
+//
+//  FilledEllipseShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledEllipseShape extends Shape {
+
+
+int radiusX;
+int radiusY;
+
+public FilledEllipseShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	radiusX = Integer.parseInt(tokens.nextToken());
+	radiusY = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillOval(X - radiusX, Y - radiusY, 2 * radiusX - 1, 2 * radiusY - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X - radiusX, Y - radiusY, 2 * radiusX, 2 * radiusY).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledPolygonShape.java b/guiserver/java/FilledPolygonShape.java
new file mode 100644
index 0000000..633ceb8
--- /dev/null
+++ b/guiserver/java/FilledPolygonShape.java
@@ -0,0 +1,103 @@
+//
+//  FilledPolygonShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledPolygonShape extends Shape {
+
+int pointXd[];
+int pointYd[];
+
+int N;
+
+public FilledPolygonShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	N = Integer.parseInt(tokens.nextToken());
+	
+	pointXd = new int [N];
+	pointYd = new int [N];
+	
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	pointXd[0] = pointYd[0] = 0;
+	
+	for(int i = 1; i < N; i++)
+		{
+		pointXd[i] = Integer.parseInt(tokens.nextToken()) - X;
+		pointYd[i] = Integer.parseInt(tokens.nextToken()) - Y;
+		}
+		
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+		
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+		
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	
+/*
+	int pX[] = new int [N];
+	int pY[] = new int [N];
+	
+	for(int i = 0; i < N; i++)
+		{
+		pX[i] = pointXd[i] + X;
+		pY[i] = pointYd[i] + Y;
+		}
+
+	g2.fillPolygon(pX, pY, N);
+*/
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+
+	g2.fill(polygon);
+	}
+
+public boolean hasPoint(int x, int y)
+	{	
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+	
+	return(polygon.contains(x, y));
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledPolygonShape.java.bak b/guiserver/java/FilledPolygonShape.java.bak
new file mode 100644
index 0000000..2411cca
--- /dev/null
+++ b/guiserver/java/FilledPolygonShape.java.bak
@@ -0,0 +1,103 @@
+//
+//  FilledPolygonShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledPolygonShape extends Shape {
+
+int pointXd[];
+int pointYd[];
+
+int N;
+
+public FilledPolygonShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	N = Integer.parseInt(tokens.nextToken());
+	
+	pointXd = new int [N];
+	pointYd = new int [N];
+	
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	pointXd[0] = pointYd[0] = 0;
+	
+	for(int i = 1; i < N; i++)
+		{
+		pointXd[i] = Integer.parseInt(tokens.nextToken()) - X;
+		pointYd[i] = Integer.parseInt(tokens.nextToken()) - Y;
+		}
+		
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+		
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+		
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	
+/*
+	int pX[] = new int [N];
+	int pY[] = new int [N];
+	
+	for(int i = 0; i < N; i++)
+		{
+		pX[i] = pointXd[i] + X;
+		pY[i] = pointYd[i] + Y;
+		}
+
+	g2.fillPolygon(pX, pY, N);
+*/
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+
+	g2.fill(polygon);
+	}
+
+public boolean hasPoint(int x, int y)
+	{	
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+	
+	return(polygon.contains(x, y));
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRectangle.java b/guiserver/java/FilledRectangle.java
new file mode 100644
index 0000000..cafda30
--- /dev/null
+++ b/guiserver/java/FilledRectangle.java
@@ -0,0 +1,79 @@
+//
+//  FilledRectangle.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRectangle extends Shape {
+
+int X;
+int Y;
+int width;
+int height;
+
+public FilledRectangle(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		R = Float.parseFloat(tokens.nextToken());
+		G = Float.parseFloat(tokens.nextToken());
+		B = Float.parseFloat(tokens.nextToken());
+		if(tokens.hasMoreTokens())
+			alpha = Float.parseFloat(tokens.nextToken());
+		else 
+			alpha = 1;
+		paintColor = new Color(R, G, B, alpha);
+		}
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRect(X, Y, width, height);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRectangle.java.bak b/guiserver/java/FilledRectangle.java.bak
new file mode 100644
index 0000000..797e409
--- /dev/null
+++ b/guiserver/java/FilledRectangle.java.bak
@@ -0,0 +1,79 @@
+//
+//  FilledRectangle.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRectangle extends Shape {
+
+int X;
+int Y;
+int width;
+int height;
+
+public FilledRectangle(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		R = Float.parseFloat(tokens.nextToken());
+		G = Float.parseFloat(tokens.nextToken());
+		B = Float.parseFloat(tokens.nextToken());
+		if(tokens.hasMoreTokens())
+			alpha = Float.parseFloat(tokens.nextToken());
+		else 
+			alpha = 1;
+		paintColor = new Color(R, G, B, alpha);
+		}
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRect(X, Y, width, height);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRectangleShape.java b/guiserver/java/FilledRectangleShape.java
new file mode 100644
index 0000000..fbb6aba
--- /dev/null
+++ b/guiserver/java/FilledRectangleShape.java
@@ -0,0 +1,70 @@
+//
+//  FilledRectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRectangleShape extends Shape {
+
+int width;
+int height;
+
+public FilledRectangleShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRect(X, Y, width, height);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRectangleShape.java.bak b/guiserver/java/FilledRectangleShape.java.bak
new file mode 100644
index 0000000..23d284f
--- /dev/null
+++ b/guiserver/java/FilledRectangleShape.java.bak
@@ -0,0 +1,70 @@
+//
+//  FilledRectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRectangleShape extends Shape {
+
+int width;
+int height;
+
+public FilledRectangleShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRect(X, Y, width, height);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRoundRectShape.java b/guiserver/java/FilledRoundRectShape.java
new file mode 100644
index 0000000..e9b9de7
--- /dev/null
+++ b/guiserver/java/FilledRoundRectShape.java
@@ -0,0 +1,81 @@
+//
+//  FilledRoundRectShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRoundRectShape extends Shape {
+
+
+int width;
+int height;
+int arcWidth;
+int arcHeight;
+
+@SuppressWarnings("unchecked")
+public FilledRoundRectShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRoundRectShape.java.bak b/guiserver/java/FilledRoundRectShape.java.bak
new file mode 100644
index 0000000..31dfefd
--- /dev/null
+++ b/guiserver/java/FilledRoundRectShape.java.bak
@@ -0,0 +1,81 @@
+//
+//  FilledRoundRectShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRoundRectShape extends Shape {
+
+
+int width;
+int height;
+int arcWidth;
+int arcHeight;
+
+@SuppressWarnings("unchecked")
+public FilledRoundRectShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRoundRectangleShape.java b/guiserver/java/FilledRoundRectangleShape.java
new file mode 100644
index 0000000..8c6b291
--- /dev/null
+++ b/guiserver/java/FilledRoundRectangleShape.java
@@ -0,0 +1,78 @@
+//
+//  FilledRoundRectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRoundRectangleShape extends Shape {
+
+int width;
+int height;
+
+int arcWidth;
+int arcHeight;
+
+public FilledRoundRectangleShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilledRoundRectangleShape.java.bak b/guiserver/java/FilledRoundRectangleShape.java.bak
new file mode 100644
index 0000000..b0f53f1
--- /dev/null
+++ b/guiserver/java/FilledRoundRectangleShape.java.bak
@@ -0,0 +1,78 @@
+//
+//  FilledRoundRectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class FilledRoundRectangleShape extends Shape {
+
+int width;
+int height;
+
+int arcWidth;
+int arcHeight;
+
+public FilledRoundRectangleShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.fillRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/FilterFileReader.java b/guiserver/java/FilterFileReader.java
new file mode 100644
index 0000000..1efaff3
--- /dev/null
+++ b/guiserver/java/FilterFileReader.java
@@ -0,0 +1,72 @@
+//
+//  FilterFileReader.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/17/07.
+//    Copyright (C) 2016 Lutz Mueller
+
+import java.awt.event.*;
+import java.io.*;
+import java.io.InputStreamReader;
+// import java.io.FileReader;
+import java.io.FileInputStream;
+
+
+public class FilterFileReader extends InputStreamReader {
+
+public FilterFileReader(String path, String charSet) throws java.io.FileNotFoundException, UnsupportedEncodingException
+	{
+	super(new FileInputStream(path), charSet);
+	}
+
+public FilterFileReader(String path) throws java.io.FileNotFoundException, UnsupportedEncodingException
+	{
+	super(new FileInputStream(path));
+	}
+
+/*
+public class FilterFileReader extends FileReader  {
+
+public FilterFileReader(String path) throws java.io.FileNotFoundException
+	{
+	super(path);
+	}
+*/
+	
+public int read() throws java.io.IOException
+	{
+	int chr = super.read();
+	
+	if(chr  == 13)
+		chr = super.read();
+	
+	return(chr);
+	}
+	
+public int read(char[] cbuf, int offset, int length) throws IOException
+	{
+	int chr;
+	int len = 0;
+
+	//System.out.println("reading:" + offset + " " + length);
+	
+	for(int i = 0; i < length; i++)
+		{
+		chr = super.read();
+
+		if(chr == 13)
+			chr = super.read();
+		
+		if(chr == -1) break;
+
+		cbuf[offset + i] = (char)chr;
+		++len;
+		}
+
+	if(len == 0) return(-1);
+	
+	return(len);
+	}
+		
+
+}
diff --git a/guiserver/java/FilterFileReader.java.bak b/guiserver/java/FilterFileReader.java.bak
new file mode 100644
index 0000000..5cfcd36
--- /dev/null
+++ b/guiserver/java/FilterFileReader.java.bak
@@ -0,0 +1,72 @@
+//
+//  FilterFileReader.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/17/07.
+//    Copyright (C) 2015 Lutz Mueller
+
+import java.awt.event.*;
+import java.io.*;
+import java.io.InputStreamReader;
+// import java.io.FileReader;
+import java.io.FileInputStream;
+
+
+public class FilterFileReader extends InputStreamReader {
+
+public FilterFileReader(String path, String charSet) throws java.io.FileNotFoundException, UnsupportedEncodingException
+	{
+	super(new FileInputStream(path), charSet);
+	}
+
+public FilterFileReader(String path) throws java.io.FileNotFoundException, UnsupportedEncodingException
+	{
+	super(new FileInputStream(path));
+	}
+
+/*
+public class FilterFileReader extends FileReader  {
+
+public FilterFileReader(String path) throws java.io.FileNotFoundException
+	{
+	super(path);
+	}
+*/
+	
+public int read() throws java.io.IOException
+	{
+	int chr = super.read();
+	
+	if(chr  == 13)
+		chr = super.read();
+	
+	return(chr);
+	}
+	
+public int read(char[] cbuf, int offset, int length) throws IOException
+	{
+	int chr;
+	int len = 0;
+
+	//System.out.println("reading:" + offset + " " + length);
+	
+	for(int i = 0; i < length; i++)
+		{
+		chr = super.read();
+
+		if(chr == 13)
+			chr = super.read();
+		
+		if(chr == -1) break;
+
+		cbuf[offset + i] = (char)chr;
+		++len;
+		}
+
+	if(len == 0) return(-1);
+	
+	return(len);
+	}
+		
+
+}
diff --git a/guiserver/java/ImageButtonWidget.java b/guiserver/java/ImageButtonWidget.java
new file mode 100644
index 0000000..a13a555
--- /dev/null
+++ b/guiserver/java/ImageButtonWidget.java
@@ -0,0 +1,94 @@
+//
+//  ImageButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/22/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+public class ImageButtonWidget  extends aButton {
+
+@SuppressWarnings("unchecked") 
+public ImageButtonWidget(StringTokenizer params)
+	{
+	int width = 32;
+	int height = 32;
+	
+	abutton = new JButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	setIconFromPath(Base64Coder.decodeString(params.nextToken()));
+	
+	if(params.hasMoreTokens())
+		setPressedIconFromPath(Base64Coder.decodeString(params.nextToken()));
+	else
+		abutton.setPressedIcon(new ImageIcon(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/images/pressedbutton32.png"))));
+	
+	
+	if(params.hasMoreTokens())
+		{
+		width = Integer.parseInt(params.nextToken());
+		height = Integer.parseInt(params.nextToken());
+		}
+		
+	abutton.setPreferredSize(new Dimension(width, height));
+	
+	abutton.setBorder(BorderFactory.createEmptyBorder());
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{
+			if(action != null)
+				{
+				guiserver.out.println("("+ action + " \"" + id +  "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	abutton.addActionListener(listener);
+	}
+	
+		
+public void setIconFromPath(String path)
+	{
+	abutton.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+	
+public void setPressedIconFromPath(String path)
+	{
+	abutton.setPressedIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ImageButtonWidget.java.bak b/guiserver/java/ImageButtonWidget.java.bak
new file mode 100644
index 0000000..8096715
--- /dev/null
+++ b/guiserver/java/ImageButtonWidget.java.bak
@@ -0,0 +1,94 @@
+//
+//  ImageButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/22/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+public class ImageButtonWidget  extends aButton {
+
+@SuppressWarnings("unchecked") 
+public ImageButtonWidget(StringTokenizer params)
+	{
+	int width = 32;
+	int height = 32;
+	
+	abutton = new JButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	setIconFromPath(Base64Coder.decodeString(params.nextToken()));
+	
+	if(params.hasMoreTokens())
+		setPressedIconFromPath(Base64Coder.decodeString(params.nextToken()));
+	else
+		abutton.setPressedIcon(new ImageIcon(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/images/pressedbutton32.png"))));
+	
+	
+	if(params.hasMoreTokens())
+		{
+		width = Integer.parseInt(params.nextToken());
+		height = Integer.parseInt(params.nextToken());
+		}
+		
+	abutton.setPreferredSize(new Dimension(width, height));
+	
+	abutton.setBorder(BorderFactory.createEmptyBorder());
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{
+			if(action != null)
+				{
+				guiserver.out.println("("+ action + " \"" + id +  "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	abutton.addActionListener(listener);
+	}
+	
+		
+public void setIconFromPath(String path)
+	{
+	abutton.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+	
+public void setPressedIconFromPath(String path)
+	{
+	abutton.setPressedIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ImageLabelWidget.java b/guiserver/java/ImageLabelWidget.java
new file mode 100644
index 0000000..1615f9b
--- /dev/null
+++ b/guiserver/java/ImageLabelWidget.java
@@ -0,0 +1,89 @@
+//
+//  ImageLabelWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/23/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class ImageLabelWidget extends gsObject {
+
+JLabel label;
+
+@SuppressWarnings("unchecked") 
+public ImageLabelWidget(StringTokenizer params)
+	{
+	label = new JLabel();
+	jcomponent = label;
+	component = label;
+	container = label;
+	
+	id = params.nextToken();
+	String align = "center";
+	if(params.hasMoreTokens())
+		this.setIcon(params);
+	
+	if(params.hasMoreTokens())
+		align = params.nextToken();
+		
+	if(align.equals("left")) label.setHorizontalAlignment(JLabel.LEFT);
+	else if(align.equals("center")) label.setHorizontalAlignment(JLabel.CENTER);
+	else if(align.equals("right")) 	label.setHorizontalAlignment(JLabel.RIGHT);
+	else if(align.equals("leading")) label.setHorizontalAlignment(JLabel.LEADING);
+	else if(align.equals("trailing")) label.setHorizontalAlignment(JLabel.TRAILING);
+	else if(align.equals("bottom")) label.setVerticalAlignment(JLabel.BOTTOM);
+	else if(align.equals("top")) label.setVerticalAlignment(JLabel.TOP);
+		
+	gsObject.widgets.put(id, this);
+	}
+
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	label.setText(text);
+	}
+	
+public void clearText(StringTokenizer tokens)
+	{
+	label.setText("");
+	}
+
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	label.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ImageLabelWidget.java.bak b/guiserver/java/ImageLabelWidget.java.bak
new file mode 100644
index 0000000..eb5bb5c
--- /dev/null
+++ b/guiserver/java/ImageLabelWidget.java.bak
@@ -0,0 +1,89 @@
+//
+//  ImageLabelWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/23/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class ImageLabelWidget extends gsObject {
+
+JLabel label;
+
+@SuppressWarnings("unchecked") 
+public ImageLabelWidget(StringTokenizer params)
+	{
+	label = new JLabel();
+	jcomponent = label;
+	component = label;
+	container = label;
+	
+	id = params.nextToken();
+	String align = "center";
+	if(params.hasMoreTokens())
+		this.setIcon(params);
+	
+	if(params.hasMoreTokens())
+		align = params.nextToken();
+		
+	if(align.equals("left")) label.setHorizontalAlignment(JLabel.LEFT);
+	else if(align.equals("center")) label.setHorizontalAlignment(JLabel.CENTER);
+	else if(align.equals("right")) 	label.setHorizontalAlignment(JLabel.RIGHT);
+	else if(align.equals("leading")) label.setHorizontalAlignment(JLabel.LEADING);
+	else if(align.equals("trailing")) label.setHorizontalAlignment(JLabel.TRAILING);
+	else if(align.equals("bottom")) label.setVerticalAlignment(JLabel.BOTTOM);
+	else if(align.equals("top")) label.setVerticalAlignment(JLabel.TOP);
+		
+	gsObject.widgets.put(id, this);
+	}
+
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	label.setText(text);
+	}
+	
+public void clearText(StringTokenizer tokens)
+	{
+	label.setText("");
+	}
+
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	label.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ImageShape.java b/guiserver/java/ImageShape.java
new file mode 100644
index 0000000..5aa6e33
--- /dev/null
+++ b/guiserver/java/ImageShape.java
@@ -0,0 +1,97 @@
+//
+//  ImageShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class ImageShape extends Shape {
+
+Image image;
+int width;
+int height;
+
+boolean hasDimensions = false;
+
+
+public ImageShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		{
+		width = Integer.parseInt(tokens.nextToken());
+		height = Integer.parseInt(tokens.nextToken());
+		hasDimensions = true;
+		}
+		
+	image = guiserver.getImageFromPath(path, this.getClass());
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	
+	/*
+	MediaTracker mt = new MediaTracker(imageObserver);
+	Image splashImage = Toolkit.getDefaultToolkit().getImage(
+	frame.getClass().getResource("/quids/unilever.jpg"));
+	mt.addImage(splashImage, 0);
+
+	try { mt.waitForID(0); }
+	catch(InterruptedException ie) {}
+
+	SplashWindow sw = new SplashWindow(frame, splashImage);
+	try { Thread.sleep(1500); }
+	catch(InterruptedException ie) {}
+	*/
+
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	//g2.setStroke(stroke);
+	//g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	//int realW = image.getWidth(imageObserver);
+	//int realH = image.getWidth(imageObserver);
+	if(hasDimensions)
+		g2.drawImage(image, X, Y, width, height, CanvasWidget.currentCanvas.component);
+	else
+		g2.drawImage(image, X, Y, CanvasWidget.currentCanvas.component);
+	}
+	
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ImageShape.java.bak b/guiserver/java/ImageShape.java.bak
new file mode 100644
index 0000000..005af2b
--- /dev/null
+++ b/guiserver/java/ImageShape.java.bak
@@ -0,0 +1,97 @@
+//
+//  ImageShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class ImageShape extends Shape {
+
+Image image;
+int width;
+int height;
+
+boolean hasDimensions = false;
+
+
+public ImageShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		{
+		width = Integer.parseInt(tokens.nextToken());
+		height = Integer.parseInt(tokens.nextToken());
+		hasDimensions = true;
+		}
+		
+	image = guiserver.getImageFromPath(path, this.getClass());
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	
+	/*
+	MediaTracker mt = new MediaTracker(imageObserver);
+	Image splashImage = Toolkit.getDefaultToolkit().getImage(
+	frame.getClass().getResource("/quids/unilever.jpg"));
+	mt.addImage(splashImage, 0);
+
+	try { mt.waitForID(0); }
+	catch(InterruptedException ie) {}
+
+	SplashWindow sw = new SplashWindow(frame, splashImage);
+	try { Thread.sleep(1500); }
+	catch(InterruptedException ie) {}
+	*/
+
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	//g2.setStroke(stroke);
+	//g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	//int realW = image.getWidth(imageObserver);
+	//int realH = image.getWidth(imageObserver);
+	if(hasDimensions)
+		g2.drawImage(image, X, Y, width, height, CanvasWidget.currentCanvas.component);
+	else
+		g2.drawImage(image, X, Y, CanvasWidget.currentCanvas.component);
+	}
+	
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LabelWidget.java b/guiserver/java/LabelWidget.java
new file mode 100644
index 0000000..f1920fd
--- /dev/null
+++ b/guiserver/java/LabelWidget.java
@@ -0,0 +1,128 @@
+//
+//  LabelWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/14/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class LabelWidget extends gsObject {
+
+JLabel label;
+
+@SuppressWarnings("unchecked") 
+public LabelWidget(StringTokenizer params)
+	{
+	label = new JLabel();
+	jcomponent = label;
+	component = label;
+	container = label;
+	
+	id = params.nextToken();
+	String align = "center";
+
+	setText(params);
+	
+	if(params.hasMoreTokens())
+		align = params.nextToken();
+		
+	if(align.equals("left")) label.setHorizontalAlignment(JLabel.LEFT);
+	else if(align.equals("center")) label.setHorizontalAlignment(JLabel.CENTER);
+	else if(align.equals("right")) 	label.setHorizontalAlignment(JLabel.RIGHT);
+	else if(align.equals("leading")) label.setHorizontalAlignment(JLabel.LEADING);
+	else if(align.equals("trailing")) label.setHorizontalAlignment(JLabel.TRAILING);
+	else if(align.equals("bottom")) label.setVerticalAlignment(JLabel.BOTTOM);
+	else if(align.equals("top")) label.setVerticalAlignment(JLabel.TOP);
+		
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jcomponent.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	
+	}
+
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	label.setText(text);
+	}
+	
+public void getText(StringTokenizer params)
+	{
+	String action = params.nextToken();
+	String text = label.getText();
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+
+
+public void appendText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = label.getText();
+	label.setText(oldtext + text);
+	}
+	
+public void clearText(StringTokenizer tokens)
+	{
+	label.setText("");
+	}
+
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	label.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LabelWidget.java.bak b/guiserver/java/LabelWidget.java.bak
new file mode 100644
index 0000000..dc78204
--- /dev/null
+++ b/guiserver/java/LabelWidget.java.bak
@@ -0,0 +1,128 @@
+//
+//  LabelWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/14/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class LabelWidget extends gsObject {
+
+JLabel label;
+
+@SuppressWarnings("unchecked") 
+public LabelWidget(StringTokenizer params)
+	{
+	label = new JLabel();
+	jcomponent = label;
+	component = label;
+	container = label;
+	
+	id = params.nextToken();
+	String align = "center";
+
+	setText(params);
+	
+	if(params.hasMoreTokens())
+		align = params.nextToken();
+		
+	if(align.equals("left")) label.setHorizontalAlignment(JLabel.LEFT);
+	else if(align.equals("center")) label.setHorizontalAlignment(JLabel.CENTER);
+	else if(align.equals("right")) 	label.setHorizontalAlignment(JLabel.RIGHT);
+	else if(align.equals("leading")) label.setHorizontalAlignment(JLabel.LEADING);
+	else if(align.equals("trailing")) label.setHorizontalAlignment(JLabel.TRAILING);
+	else if(align.equals("bottom")) label.setVerticalAlignment(JLabel.BOTTOM);
+	else if(align.equals("top")) label.setVerticalAlignment(JLabel.TOP);
+		
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jcomponent.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	
+	}
+
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	label.setText(text);
+	}
+	
+public void getText(StringTokenizer params)
+	{
+	String action = params.nextToken();
+	String text = label.getText();
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+
+
+public void appendText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = label.getText();
+	label.setText(oldtext + text);
+	}
+	
+public void clearText(StringTokenizer tokens)
+	{
+	label.setText("");
+	}
+
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	label.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LayoutBorder.java b/guiserver/java/LayoutBorder.java
new file mode 100644
index 0000000..40a335c
--- /dev/null
+++ b/guiserver/java/LayoutBorder.java
@@ -0,0 +1,53 @@
+//
+//  LayoutBorder.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/15/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("serial")
+public class LayoutBorder extends BorderLayout{
+
+public LayoutBorder(StringTokenizer params)
+	{
+	super();
+	
+	String id = params.nextToken();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(id);
+	Container target = gsobject.container;
+
+	if(params.hasMoreTokens())
+		{
+		setHgap(Integer.parseInt(params.nextToken()));
+		setVgap(Integer.parseInt(params.nextToken()));
+		}
+	
+	target.setLayout(this);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LayoutBorder.java.bak b/guiserver/java/LayoutBorder.java.bak
new file mode 100644
index 0000000..b1da75b
--- /dev/null
+++ b/guiserver/java/LayoutBorder.java.bak
@@ -0,0 +1,53 @@
+//
+//  LayoutBorder.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/15/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("serial")
+public class LayoutBorder extends BorderLayout{
+
+public LayoutBorder(StringTokenizer params)
+	{
+	super();
+	
+	String id = params.nextToken();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(id);
+	Container target = gsobject.container;
+
+	if(params.hasMoreTokens())
+		{
+		setHgap(Integer.parseInt(params.nextToken()));
+		setVgap(Integer.parseInt(params.nextToken()));
+		}
+	
+	target.setLayout(this);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LayoutFlow.java b/guiserver/java/LayoutFlow.java
new file mode 100644
index 0000000..d10313d
--- /dev/null
+++ b/guiserver/java/LayoutFlow.java
@@ -0,0 +1,64 @@
+//
+//  LayoutFlow.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/14/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("serial")
+public class LayoutFlow extends FlowLayout{
+
+public LayoutFlow(StringTokenizer params)
+	{
+	super();
+	
+	String id = params.nextToken();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(id);
+	
+	Container target = gsobject.container;
+	setAlignment(FlowLayout.LEFT);
+	
+	if(params.hasMoreTokens())
+		{
+		String alignment = params.nextToken();
+		if(alignment.equals("left")) setAlignment(FlowLayout.LEFT);
+		if(alignment.equals("center")) setAlignment(FlowLayout.CENTER);
+		if(alignment.equals("right")) setAlignment(FlowLayout.RIGHT);
+		}
+	else setAlignment(FlowLayout.LEFT);
+
+	if(params.hasMoreTokens())
+		{
+		setHgap(Integer.parseInt(params.nextToken()));
+		setVgap(Integer.parseInt(params.nextToken()));
+		}
+	
+	target.setLayout(this);
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LayoutFlow.java.bak b/guiserver/java/LayoutFlow.java.bak
new file mode 100644
index 0000000..0ed68d8
--- /dev/null
+++ b/guiserver/java/LayoutFlow.java.bak
@@ -0,0 +1,64 @@
+//
+//  LayoutFlow.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/14/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("serial")
+public class LayoutFlow extends FlowLayout{
+
+public LayoutFlow(StringTokenizer params)
+	{
+	super();
+	
+	String id = params.nextToken();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(id);
+	
+	Container target = gsobject.container;
+	setAlignment(FlowLayout.LEFT);
+	
+	if(params.hasMoreTokens())
+		{
+		String alignment = params.nextToken();
+		if(alignment.equals("left")) setAlignment(FlowLayout.LEFT);
+		if(alignment.equals("center")) setAlignment(FlowLayout.CENTER);
+		if(alignment.equals("right")) setAlignment(FlowLayout.RIGHT);
+		}
+	else setAlignment(FlowLayout.LEFT);
+
+	if(params.hasMoreTokens())
+		{
+		setHgap(Integer.parseInt(params.nextToken()));
+		setVgap(Integer.parseInt(params.nextToken()));
+		}
+	
+	target.setLayout(this);
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LayoutGrid.java b/guiserver/java/LayoutGrid.java
new file mode 100644
index 0000000..815e2d0
--- /dev/null
+++ b/guiserver/java/LayoutGrid.java
@@ -0,0 +1,57 @@
+//
+//  LayoutGrid.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/12/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("serial")
+public class LayoutGrid extends GridLayout{
+
+public LayoutGrid(StringTokenizer params)
+	{
+	super();
+	
+	String id = params.nextToken();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(id);
+	
+	Container target = gsobject.container;
+	
+	setRows(Integer.parseInt(params.nextToken()));
+	setColumns(Integer.parseInt(params.nextToken()));
+	
+	if(params.hasMoreTokens())
+		{
+		setHgap(Integer.parseInt(params.nextToken()));
+		setVgap(Integer.parseInt(params.nextToken()));
+		}
+	
+	target.setLayout(this);
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LayoutGrid.java.bak b/guiserver/java/LayoutGrid.java.bak
new file mode 100644
index 0000000..eec7323
--- /dev/null
+++ b/guiserver/java/LayoutGrid.java.bak
@@ -0,0 +1,57 @@
+//
+//  LayoutGrid.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/12/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("serial")
+public class LayoutGrid extends GridLayout{
+
+public LayoutGrid(StringTokenizer params)
+	{
+	super();
+	
+	String id = params.nextToken();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(id);
+	
+	Container target = gsobject.container;
+	
+	setRows(Integer.parseInt(params.nextToken()));
+	setColumns(Integer.parseInt(params.nextToken()));
+	
+	if(params.hasMoreTokens())
+		{
+		setHgap(Integer.parseInt(params.nextToken()));
+		setVgap(Integer.parseInt(params.nextToken()));
+		}
+	
+	target.setLayout(this);
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LineShape.java b/guiserver/java/LineShape.java
new file mode 100644
index 0000000..039479e
--- /dev/null
+++ b/guiserver/java/LineShape.java
@@ -0,0 +1,73 @@
+//
+//  LineShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class LineShape extends Shape {
+
+int dx;
+int dy;
+
+public LineShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	int X2, Y2;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	X2 = Integer.parseInt(tokens.nextToken());
+	Y2 = Integer.parseInt(tokens.nextToken());
+	
+	dx = X2 - X;
+	dy = Y2 - Y;
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawLine(X, Y, X + dx, Y + dy);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/LineShape.java.bak b/guiserver/java/LineShape.java.bak
new file mode 100644
index 0000000..45aedbd
--- /dev/null
+++ b/guiserver/java/LineShape.java.bak
@@ -0,0 +1,73 @@
+//
+//  LineShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class LineShape extends Shape {
+
+int dx;
+int dy;
+
+public LineShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	int X2, Y2;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	X2 = Integer.parseInt(tokens.nextToken());
+	Y2 = Integer.parseInt(tokens.nextToken());
+	
+	dx = X2 - X;
+	dy = Y2 - Y;
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawLine(X, Y, X + dx, Y + dy);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ListBoxWidget.java b/guiserver/java/ListBoxWidget.java
new file mode 100644
index 0000000..5634ede
--- /dev/null
+++ b/guiserver/java/ListBoxWidget.java
@@ -0,0 +1,220 @@
+//
+//  ListBoxWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/15/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked") 
+public class ListBoxWidget extends gsObject {
+
+JList list = null;
+JScrollPane scrollpane;
+DefaultListModel listModel;
+
+public ListBoxWidget(StringTokenizer params)
+	{
+	scrollpane = new JScrollPane();
+	component = scrollpane;
+	container = scrollpane;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	listModel = new DefaultListModel();
+	while(params.hasMoreTokens())
+		{
+		addListItem(params);
+		}
+	
+//	listModel.addElement(Base64Coder.decodeString(params.nextToken()));
+		
+	list = new JList(listModel);
+	jcomponent = list;
+	scrollpane.getViewport().setView(list);
+	
+	list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+    list.setSelectedIndex(0);
+
+	gsObject.widgets.put(id, this);
+	
+	
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyTyped(KeyEvent e)
+			{
+			int index = list.getSelectedIndex();
+			String item = (String)list.getSelectedValue();
+	
+			if(guiserver.UTF8 && item.length() != 0)
+				item = Base64Coder.encodeStringUTF8(item);
+			else
+				item = Base64Coder.encodeString(item);
+	
+			guiserver.out.println("(" + action + " \"" + id + "\" " + index + " \"" + item + "\")");
+			guiserver.out.flush();
+			}
+		};
+
+	MouseListener mouseListener = new MouseAdapter() {
+     public void mouseClicked(MouseEvent e) 
+		{
+		int clickCount = e.getClickCount();
+		int index = list.locationToIndex(e.getPoint());
+
+		if(action != null)
+			{
+			try {
+				String item = (String)listModel.getElementAt(index);
+
+				if(guiserver.UTF8 && item.length() != 0)
+					item = Base64Coder.encodeStringUTF8(item);
+				else
+					item = Base64Coder.encodeString(item);
+
+				guiserver.out.println("(" + action + " \"" + id + "\" " + index + " \"" + item + "\" " + clickCount + ")");
+				guiserver.out.flush();
+				} catch (Exception exc) { }
+			}
+
+		if(mouseEvent != null) 
+			{
+			mouseEventOut(e, "clicked");
+			}
+		}
+		
+	public void mousePressed(MouseEvent e) 
+		{ 
+		if(mouseEvent != null) mouseEventOut(e, "pressed"); 
+		}
+		
+	public void mouseReleased(MouseEvent e) 
+		{ 
+		if(mouseEvent != null) mouseEventOut(e, "released"); 
+		}
+	
+	};
+	
+	list.addMouseListener(mouseListener);	
+	list.addKeyListener(keyListener);
+	}
+	
+public void addListItem(StringTokenizer tokens)
+	{
+	while(tokens.hasMoreTokens()) 
+		{
+		String text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		listModel.addElement(text);
+		}
+	}
+	
+public void removeListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	
+	while(tokens.hasMoreTokens()) 
+		{
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (listModel.size() - 1)) index = listModel.size() - 1;
+		if(index < 0) index = 0;
+		listModel.remove(index);
+		}
+	}
+	
+public void clearList(StringTokenizer tokens)
+	{
+	while(listModel.size() > 0)
+		listModel.remove(0);
+	}
+	
+public void insertListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	String text;
+	
+	while(tokens.hasMoreTokens())
+		{
+		text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (listModel.size() - 1)) index = listModel.size() - 1;
+		if(index < 0) index = 0;
+		
+		listModel.insertElementAt(text, index);
+		}
+	}
+	
+	
+public void selectListItem(StringTokenizer tokens)
+	{
+	Boolean flag = false;
+	String item = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		item = Base64Coder.decodeStringUTF8(item);
+	else
+		item = Base64Coder.decodeString(item);
+	
+	if(tokens.hasMoreTokens())
+		flag = tokens.nextToken().equals("true");
+
+	list.setSelectedValue(item, flag);
+	}
+	
+					
+public void scrollDown()
+    {
+	JScrollBar vbar = scrollpane.getVerticalScrollBar();
+    vbar.setValue(vbar.getMinimum());
+    }
+	
+public void registerMouseEvent(StringTokenizer tokens)
+	{
+	mouseEvent = tokens.nextToken();
+	}
+	
+private void mouseEventOut(MouseEvent e, String type)
+	{
+	guiserver.out.println("(" + mouseEvent + " \"" + id + "\" \"" + type + "\" " + e.getX() + " " + e.getY() + " " + 
+		e.getButton() + " " + e.getClickCount() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ListBoxWidget.java.bak b/guiserver/java/ListBoxWidget.java.bak
new file mode 100644
index 0000000..dbea6e7
--- /dev/null
+++ b/guiserver/java/ListBoxWidget.java.bak
@@ -0,0 +1,220 @@
+//
+//  ListBoxWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/15/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked") 
+public class ListBoxWidget extends gsObject {
+
+JList list = null;
+JScrollPane scrollpane;
+DefaultListModel listModel;
+
+public ListBoxWidget(StringTokenizer params)
+	{
+	scrollpane = new JScrollPane();
+	component = scrollpane;
+	container = scrollpane;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	listModel = new DefaultListModel();
+	while(params.hasMoreTokens())
+		{
+		addListItem(params);
+		}
+	
+//	listModel.addElement(Base64Coder.decodeString(params.nextToken()));
+		
+	list = new JList(listModel);
+	jcomponent = list;
+	scrollpane.getViewport().setView(list);
+	
+	list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+    list.setSelectedIndex(0);
+
+	gsObject.widgets.put(id, this);
+	
+	
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyTyped(KeyEvent e)
+			{
+			int index = list.getSelectedIndex();
+			String item = (String)list.getSelectedValue();
+	
+			if(guiserver.UTF8 && item.length() != 0)
+				item = Base64Coder.encodeStringUTF8(item);
+			else
+				item = Base64Coder.encodeString(item);
+	
+			guiserver.out.println("(" + action + " \"" + id + "\" " + index + " \"" + item + "\")");
+			guiserver.out.flush();
+			}
+		};
+
+	MouseListener mouseListener = new MouseAdapter() {
+     public void mouseClicked(MouseEvent e) 
+		{
+		int clickCount = e.getClickCount();
+		int index = list.locationToIndex(e.getPoint());
+
+		if(action != null)
+			{
+			try {
+				String item = (String)listModel.getElementAt(index);
+
+				if(guiserver.UTF8 && item.length() != 0)
+					item = Base64Coder.encodeStringUTF8(item);
+				else
+					item = Base64Coder.encodeString(item);
+
+				guiserver.out.println("(" + action + " \"" + id + "\" " + index + " \"" + item + "\" " + clickCount + ")");
+				guiserver.out.flush();
+				} catch (Exception exc) { }
+			}
+
+		if(mouseEvent != null) 
+			{
+			mouseEventOut(e, "clicked");
+			}
+		}
+		
+	public void mousePressed(MouseEvent e) 
+		{ 
+		if(mouseEvent != null) mouseEventOut(e, "pressed"); 
+		}
+		
+	public void mouseReleased(MouseEvent e) 
+		{ 
+		if(mouseEvent != null) mouseEventOut(e, "released"); 
+		}
+	
+	};
+	
+	list.addMouseListener(mouseListener);	
+	list.addKeyListener(keyListener);
+	}
+	
+public void addListItem(StringTokenizer tokens)
+	{
+	while(tokens.hasMoreTokens()) 
+		{
+		String text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		listModel.addElement(text);
+		}
+	}
+	
+public void removeListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	
+	while(tokens.hasMoreTokens()) 
+		{
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (listModel.size() - 1)) index = listModel.size() - 1;
+		if(index < 0) index = 0;
+		listModel.remove(index);
+		}
+	}
+	
+public void clearList(StringTokenizer tokens)
+	{
+	while(listModel.size() > 0)
+		listModel.remove(0);
+	}
+	
+public void insertListItem(StringTokenizer tokens)
+	{
+	int index = 0; 
+	String text;
+	
+	while(tokens.hasMoreTokens())
+		{
+		text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		index = Integer.parseInt(tokens.nextToken());
+		if(index > (listModel.size() - 1)) index = listModel.size() - 1;
+		if(index < 0) index = 0;
+		
+		listModel.insertElementAt(text, index);
+		}
+	}
+	
+	
+public void selectListItem(StringTokenizer tokens)
+	{
+	Boolean flag = false;
+	String item = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		item = Base64Coder.decodeStringUTF8(item);
+	else
+		item = Base64Coder.decodeString(item);
+	
+	if(tokens.hasMoreTokens())
+		flag = tokens.nextToken().equals("true");
+
+	list.setSelectedValue(item, flag);
+	}
+	
+					
+public void scrollDown()
+    {
+	JScrollBar vbar = scrollpane.getVerticalScrollBar();
+    vbar.setValue(vbar.getMinimum());
+    }
+	
+public void registerMouseEvent(StringTokenizer tokens)
+	{
+	mouseEvent = tokens.nextToken();
+	}
+	
+private void mouseEventOut(MouseEvent e, String type)
+	{
+	guiserver.out.println("(" + mouseEvent + " \"" + id + "\" \"" + type + "\" " + e.getX() + " " + e.getY() + " " + 
+		e.getButton() + " " + e.getClickCount() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ListenerThread.java b/guiserver/java/ListenerThread.java
new file mode 100644
index 0000000..a554612
--- /dev/null
+++ b/guiserver/java/ListenerThread.java
@@ -0,0 +1,52 @@
+//
+//  ListenerThread.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+
+public class ListenerThread implements Runnable {
+
+public ListenerThread() 
+	{
+	}
+	
+public void run() {
+	String cmd = null;
+	while(true)
+		{
+		try { cmd = guiserver.in.readLine(); } catch (Exception ex) {}
+		//cmd =  guiserver.in.readLine();
+		if(cmd == null) System.exit(0);   
+		//if(guiserver.debug) Dispatcher.dispatch(cmd);
+		//else
+			{
+			try { Dispatcher.dispatch(cmd);	}
+			catch (Exception e)	{ ErrorDialog.show(cmd, "Missing argument or item not found"); }
+			}
+		}
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ListenerThread.java.bak b/guiserver/java/ListenerThread.java.bak
new file mode 100644
index 0000000..a3f42da
--- /dev/null
+++ b/guiserver/java/ListenerThread.java.bak
@@ -0,0 +1,52 @@
+//
+//  ListenerThread.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+
+public class ListenerThread implements Runnable {
+
+public ListenerThread() 
+	{
+	}
+	
+public void run() {
+	String cmd = null;
+	while(true)
+		{
+		try { cmd = guiserver.in.readLine(); } catch (Exception ex) {}
+		//cmd =  guiserver.in.readLine();
+		if(cmd == null) System.exit(0);   
+		//if(guiserver.debug) Dispatcher.dispatch(cmd);
+		//else
+			{
+			try { Dispatcher.dispatch(cmd);	}
+			catch (Exception e)	{ ErrorDialog.show(cmd, "Missing argument or item not found"); }
+			}
+		}
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuBarWidget.java b/guiserver/java/MenuBarWidget.java
new file mode 100644
index 0000000..bbe35fd
--- /dev/null
+++ b/guiserver/java/MenuBarWidget.java
@@ -0,0 +1,63 @@
+//
+//  MenuBarWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+
+public class MenuBarWidget extends gsObject {
+
+JMenuBar menubar;
+JFrame jframe;
+
+public MenuBarWidget(StringTokenizer params)
+	{
+	String target = params.nextToken();
+	menubar = new JMenuBar();
+	
+	jframe = ((WindowFrame)gsObject.widgets.get(target)).jframe;
+	jframe.setJMenuBar(menubar);
+	
+	while(params.hasMoreTokens())
+		{
+		String menu = params.nextToken();
+		JMenu jmenu = ((MenuWidget)gsObject.widgets.get(menu)).jmenu;
+		menubar.add(jmenu);
+		}
+	
+	}
+	
+public void addTo(StringTokenizer tokens)
+	{}
+
+public void setSize(StringTokenizer tokens)
+	{}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuBarWidget.java.bak b/guiserver/java/MenuBarWidget.java.bak
new file mode 100644
index 0000000..ee46649
--- /dev/null
+++ b/guiserver/java/MenuBarWidget.java.bak
@@ -0,0 +1,63 @@
+//
+//  MenuBarWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+
+public class MenuBarWidget extends gsObject {
+
+JMenuBar menubar;
+JFrame jframe;
+
+public MenuBarWidget(StringTokenizer params)
+	{
+	String target = params.nextToken();
+	menubar = new JMenuBar();
+	
+	jframe = ((WindowFrame)gsObject.widgets.get(target)).jframe;
+	jframe.setJMenuBar(menubar);
+	
+	while(params.hasMoreTokens())
+		{
+		String menu = params.nextToken();
+		JMenu jmenu = ((MenuWidget)gsObject.widgets.get(menu)).jmenu;
+		menubar.add(jmenu);
+		}
+	
+	}
+	
+public void addTo(StringTokenizer tokens)
+	{}
+
+public void setSize(StringTokenizer tokens)
+	{}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuItemCheckWidget.java b/guiserver/java/MenuItemCheckWidget.java
new file mode 100644
index 0000000..883d0b8
--- /dev/null
+++ b/guiserver/java/MenuItemCheckWidget.java
@@ -0,0 +1,147 @@
+//
+//  MenuItemCheckWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class MenuItemCheckWidget extends gsObject{
+
+JCheckBoxMenuItem cbmenuitem;
+
+@SuppressWarnings("unchecked") 
+public MenuItemCheckWidget(StringTokenizer params)
+	{
+	cbmenuitem = new JCheckBoxMenuItem();
+	jcomponent = cbmenuitem;
+	component = cbmenuitem;
+	container = cbmenuitem;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String mstring = params.nextToken();
+	
+		if(guiserver.UTF8)
+			mstring = Base64Coder.decodeStringUTF8(mstring);
+		else
+			mstring = Base64Coder.decodeString(mstring);
+
+		cbmenuitem.setText(mstring);
+		}
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			cbmenuitem.setSelected(true);
+		}
+	
+	gsObject.widgets.put(id, this);
+
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(cbmenuitem.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	cbmenuitem.addActionListener(listener);
+	}
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	cbmenuitem.setText(text);
+	}
+
+public void clearText(StringTokenizer tokens)
+	{
+	cbmenuitem.setText("");
+	}
+
+public void setSelected(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		cbmenuitem.setSelected(true);
+	else
+		cbmenuitem.setSelected(false);
+	}
+	
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = tokens.nextToken();
+	cbmenuitem.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+public void setAccelerator(StringTokenizer tokens)
+	{
+	String keystroke = Base64Coder.decodeString(tokens.nextToken());
+	
+	//System.out.println("setting accelerator: " + keystroke);
+	
+	cbmenuitem.setAccelerator(KeyStroke.getKeyStroke(keystroke));
+	
+	// Syntax:
+	// <modifiers>* (<typedID> | <pressedReleasedID>)
+	// modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
+	// typedID := typed <typedKey>
+    // typedKey := string of length 1 giving Unicode character.
+    // pressedReleasedID := (pressed | released) key
+    // key := KeyEvent key code name, i.e. the name following "VK_".
+	//
+	// Examples:
+	// "INSERT"
+    // "control DELETE"
+    // "alt shift X"
+    // "alt shift released X"
+    // "typed a"
+	//
+	// note that alt on MacOS X is the option key
+	// for letters use uppercase, keys care added in menu item display automatically
+	}
+
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuItemCheckWidget.java.bak b/guiserver/java/MenuItemCheckWidget.java.bak
new file mode 100644
index 0000000..6eac9fa
--- /dev/null
+++ b/guiserver/java/MenuItemCheckWidget.java.bak
@@ -0,0 +1,147 @@
+//
+//  MenuItemCheckWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class MenuItemCheckWidget extends gsObject{
+
+JCheckBoxMenuItem cbmenuitem;
+
+@SuppressWarnings("unchecked") 
+public MenuItemCheckWidget(StringTokenizer params)
+	{
+	cbmenuitem = new JCheckBoxMenuItem();
+	jcomponent = cbmenuitem;
+	component = cbmenuitem;
+	container = cbmenuitem;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String mstring = params.nextToken();
+	
+		if(guiserver.UTF8)
+			mstring = Base64Coder.decodeStringUTF8(mstring);
+		else
+			mstring = Base64Coder.decodeString(mstring);
+
+		cbmenuitem.setText(mstring);
+		}
+	
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			cbmenuitem.setSelected(true);
+		}
+	
+	gsObject.widgets.put(id, this);
+
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(cbmenuitem.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	cbmenuitem.addActionListener(listener);
+	}
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	cbmenuitem.setText(text);
+	}
+
+public void clearText(StringTokenizer tokens)
+	{
+	cbmenuitem.setText("");
+	}
+
+public void setSelected(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		cbmenuitem.setSelected(true);
+	else
+		cbmenuitem.setSelected(false);
+	}
+	
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = tokens.nextToken();
+	cbmenuitem.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+
+public void setAccelerator(StringTokenizer tokens)
+	{
+	String keystroke = Base64Coder.decodeString(tokens.nextToken());
+	
+	//System.out.println("setting accelerator: " + keystroke);
+	
+	cbmenuitem.setAccelerator(KeyStroke.getKeyStroke(keystroke));
+	
+	// Syntax:
+	// <modifiers>* (<typedID> | <pressedReleasedID>)
+	// modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
+	// typedID := typed <typedKey>
+    // typedKey := string of length 1 giving Unicode character.
+    // pressedReleasedID := (pressed | released) key
+    // key := KeyEvent key code name, i.e. the name following "VK_".
+	//
+	// Examples:
+	// "INSERT"
+    // "control DELETE"
+    // "alt shift X"
+    // "alt shift released X"
+    // "typed a"
+	//
+	// note that alt on MacOS X is the option key
+	// for letters use uppercase, keys care added in menu item display automatically
+	}
+
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuItemWidget.java b/guiserver/java/MenuItemWidget.java
new file mode 100644
index 0000000..f286417
--- /dev/null
+++ b/guiserver/java/MenuItemWidget.java
@@ -0,0 +1,102 @@
+//
+//  MenuItemWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class MenuItemWidget extends aButton {
+
+JMenuItem menuitem;
+
+@SuppressWarnings("unchecked") 
+public MenuItemWidget(StringTokenizer params)
+	{
+	menuitem = new JMenuItem();
+	jcomponent = menuitem;
+	component = menuitem;
+	container = menuitem;
+	abutton = menuitem;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	String mtext = params.nextToken();
+	
+	if(guiserver.UTF8)
+		mtext = Base64Coder.decodeStringUTF8(mtext);
+	else
+		mtext = Base64Coder.decodeString(mtext);
+
+	menuitem.setText(mtext);
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				guiserver.out.println("("+ action + " \"" + id + "\")");		
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	menuitem.addActionListener(listener);
+	}
+	
+public void setAccelerator(StringTokenizer tokens)
+	{
+	String keystroke = Base64Coder.decodeString(tokens.nextToken());
+	
+	//System.out.println("setting accelerator: " + keystroke);
+	
+	menuitem.setAccelerator(KeyStroke.getKeyStroke(keystroke));
+	
+	// Syntax:
+	// <modifiers>* (<typedID> | <pressedReleasedID>)
+	// modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
+	// typedID := typed <typedKey>
+    // typedKey := string of length 1 giving Unicode character.
+    // pressedReleasedID := (pressed | released) key
+    // key := KeyEvent key code name, i.e. the name following "VK_".
+	//
+	// Examples:
+	// "INSERT"
+    // "control DELETE"
+    // "alt shift X"
+    // "alt shift released X"
+    // "typed a"
+	//
+	// note that alt on MacOS X is the option key
+	// for letters use uppercase, keys care added in menu item display automatically
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuItemWidget.java.bak b/guiserver/java/MenuItemWidget.java.bak
new file mode 100644
index 0000000..8a38204
--- /dev/null
+++ b/guiserver/java/MenuItemWidget.java.bak
@@ -0,0 +1,102 @@
+//
+//  MenuItemWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class MenuItemWidget extends aButton {
+
+JMenuItem menuitem;
+
+@SuppressWarnings("unchecked") 
+public MenuItemWidget(StringTokenizer params)
+	{
+	menuitem = new JMenuItem();
+	jcomponent = menuitem;
+	component = menuitem;
+	container = menuitem;
+	abutton = menuitem;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	String mtext = params.nextToken();
+	
+	if(guiserver.UTF8)
+		mtext = Base64Coder.decodeStringUTF8(mtext);
+	else
+		mtext = Base64Coder.decodeString(mtext);
+
+	menuitem.setText(mtext);
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				guiserver.out.println("("+ action + " \"" + id + "\")");		
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	menuitem.addActionListener(listener);
+	}
+	
+public void setAccelerator(StringTokenizer tokens)
+	{
+	String keystroke = Base64Coder.decodeString(tokens.nextToken());
+	
+	//System.out.println("setting accelerator: " + keystroke);
+	
+	menuitem.setAccelerator(KeyStroke.getKeyStroke(keystroke));
+	
+	// Syntax:
+	// <modifiers>* (<typedID> | <pressedReleasedID>)
+	// modifiers := shift | control | ctrl | meta | alt | button1 | button2 | button3
+	// typedID := typed <typedKey>
+    // typedKey := string of length 1 giving Unicode character.
+    // pressedReleasedID := (pressed | released) key
+    // key := KeyEvent key code name, i.e. the name following "VK_".
+	//
+	// Examples:
+	// "INSERT"
+    // "control DELETE"
+    // "alt shift X"
+    // "alt shift released X"
+    // "typed a"
+	//
+	// note that alt on MacOS X is the option key
+	// for letters use uppercase, keys care added in menu item display automatically
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuWidget.java b/guiserver/java/MenuWidget.java
new file mode 100644
index 0000000..1ff03c7
--- /dev/null
+++ b/guiserver/java/MenuWidget.java
@@ -0,0 +1,62 @@
+//
+//  MenuWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class MenuWidget extends gsObject {
+
+JMenu jmenu;
+
+@SuppressWarnings("unchecked") 
+public MenuWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	String text = params.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	jmenu = new JMenu(text);
+	container = jmenu;
+	jcomponent = jmenu;
+	component = jmenu;
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void addSeparator(StringTokenizer tokens)
+	{
+	jmenu.addSeparator();
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MenuWidget.java.bak b/guiserver/java/MenuWidget.java.bak
new file mode 100644
index 0000000..c463aca
--- /dev/null
+++ b/guiserver/java/MenuWidget.java.bak
@@ -0,0 +1,62 @@
+//
+//  MenuWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class MenuWidget extends gsObject {
+
+JMenu jmenu;
+
+@SuppressWarnings("unchecked") 
+public MenuWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	String text = params.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	jmenu = new JMenu(text);
+	container = jmenu;
+	jcomponent = jmenu;
+	component = jmenu;
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void addSeparator(StringTokenizer tokens)
+	{
+	jmenu.addSeparator();
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MidiSynth.java b/guiserver/java/MidiSynth.java
new file mode 100644
index 0000000..1907bec
--- /dev/null
+++ b/guiserver/java/MidiSynth.java
@@ -0,0 +1,385 @@
+// MidiSynth.java
+// guiserver
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.lang.*;
+import java.awt.*;
+import java.util.*;
+import java.io.File;
+import javax.sound.midi.*;
+
+public class MidiSynth
+{
+static int	noteNumber = 0;
+static int	velocity = 0;
+static int	duration = 0;
+static Synthesizer synth = null;
+static Sequencer sequencer = null;
+static Receiver receiver = null;
+static Transmitter transmitter = null;
+static MidiChannel[] channels = null;
+static Instrument instruments[] = null;
+static Sequence sequence = null;
+static Soundbank soundbank = null;
+static int sysResolution = 32;
+static final int sysBpm = 120;
+static int userResolution = 16;
+static int userBpm = 120; 
+static int tickAccum;
+static Track track;
+static Integer[] channelPrograms = null;
+static Integer[] channelBends = null;
+static HashMap instrumentNumbers = new HashMap();
+
+@SuppressWarnings("unchecked")
+public static void midiInit(StringTokenizer params)
+	{
+	String filePath;
+	try	{
+		synth = MidiSystem.getSynthesizer();
+		synth.open();
+		sequencer = MidiSystem.getSequencer(); 
+		//transmitter = sequencer.getTransmitter();
+		//receiver = synth.getReceiver();			
+		//transmitter.setReceiver(receiver);
+		} 
+	catch (Exception me)
+		{
+		ErrorDialog.showExit("gs:midi-init", "MIDI system unavailable - will exit");	
+		return;	
+		}
+		
+	if(params.hasMoreTokens())
+		{
+		filePath = Base64Coder.decodeString(params.nextToken());
+		try { soundbank = MidiSystem.getSoundbank(new File(filePath)); }
+		catch (Exception me) {
+			ErrorDialog.show("gs:midi-init", "Cannot read soundbank:" + filePath);
+			}
+		}
+	else 
+		soundbank = synth.getDefaultSoundbank();
+		
+	instruments = soundbank.getInstruments();
+	
+	//instruments = synth.getDefaultSoundbank().getInstruments();
+	//instruments = synth.getAvailableInstruments();
+	for(int i = 0; i < Math.min(128, instruments.length); i++)
+		instrumentNumbers.put(instruments[i].getName(), i);
+		
+    synth.loadInstrument(instruments[0]);
+	channelPrograms = new Integer[16];
+	channelBends = new Integer[16];
+	for(int i = 0; i < 16; i++) 
+		{
+		channelPrograms[i] = 0;
+		channelBends[i] = 8192;
+		}
+	channels = synth.getChannels();
+	}
+
+public static void playNote(StringTokenizer params)
+	{
+	int bend = 0;
+	
+	noteNumber = Integer.parseInt(params.nextToken());
+	noteNumber = Math.min(127, Math.max(0, noteNumber));
+	
+	duration = Integer.parseInt(params.nextToken());
+	int milliseconds = (duration * 60000)/(userBpm * userResolution);
+	
+	velocity = Integer.parseInt(params.nextToken());
+	velocity = Math.min(127, Math.max(0, velocity));
+	
+	int chan = Integer.parseInt(params.nextToken());
+		
+	if(params.hasMoreTokens())
+		{
+		bend = Integer.parseInt(params.nextToken());
+		bend = Math.min(8192, Math.max(-8192, bend));
+		}
+	
+	if(channels == null)
+		{
+		ErrorDialog.showExit("gs:play-note", "MIDI system no initialized - will exit");
+		return;
+		}
+		
+	MidiChannel	channel = channels[chan];
+	channel.setPitchBend(channelBends[chan] + bend);
+
+	channel.noteOn(noteNumber, velocity);
+	
+	try	{ Thread.sleep(milliseconds);}
+	catch (InterruptedException e) { }
+
+	channel.noteOff(noteNumber);
+	}
+	
+public static void getInstruments()
+	{
+	if(instruments == null)
+		{
+		ErrorDialog.showExit("gs:get-instruments", "MIDI system no initialized - will exit");
+		return;
+		}
+		
+	guiserver.out.print("(set 'gs:instruments '( ");
+	for(int i = 0; i < Math.min(128, instruments.length); i++)
+		{
+		Instrument instrument = instruments[i];
+		guiserver.out.print("\"" + Base64Coder.encodeString(instrument.getName()) + "\" ");
+		}
+	guiserver.out.println(")) ");
+	guiserver.out.flush();
+
+	}
+	
+public static void midiPatch(StringTokenizer params)
+	{
+	String programName = Base64Coder.decodeString(params.nextToken());
+	int chan = Integer.parseInt(params.nextToken());
+	
+	if(synth == null)
+		ErrorDialog.showExit("gs:midi-patch", "MIDI system no initialized - will exit");
+
+	int program = 0;
+	
+	try { program = (Integer)instrumentNumbers.get(programName); }
+	catch (Exception ex) {
+		ErrorDialog.show("gs:midi-patch", "Instrument not known");
+		}
+			
+	try { synth.loadInstrument(instruments[program]); }
+	catch (Exception e)	{ 
+		ErrorDialog.show("gs:midi-path", "Instrument not available");
+		}
+		
+	MidiChannel	channel = channels[chan];
+	channel.programChange(program);
+	channelPrograms[chan] = program;
+	}
+	
+public static void midiBPM(StringTokenizer params)
+	{
+	userBpm = Integer.parseInt(params.nextToken());
+	if(params.hasMoreTokens())
+		userResolution = Integer.parseInt(params.nextToken());
+	}
+	
+public static void channelBend(StringTokenizer params)
+	{
+	int chan = Integer.parseInt(params.nextToken());
+	int bend = Integer.parseInt(params.nextToken());
+	bend = Math.min(8191, Math.max(-8192, bend));
+	channelBends[chan] = bend + 8192;
+	
+	MidiChannel channel = channels[chan];
+	}
+	
+public static void channelReverb(StringTokenizer params)
+	{
+	final int REVERB = 91;
+	int chan = Integer.parseInt(params.nextToken());
+	int reverb = Integer.parseInt(params.nextToken());
+	reverb = Math.min(127, Math.max(0, reverb));
+	
+	MidiChannel channel = channels[chan];
+	channel.controlChange(REVERB, reverb);
+	}
+
+public static void channelPressure(StringTokenizer params)
+	{
+	int chan = Integer.parseInt(params.nextToken());
+	int pressure = Integer.parseInt(params.nextToken());
+	pressure = Math.min(127, Math.max(0, pressure));
+	
+	MidiChannel channel = channels[chan];
+	channel.setChannelPressure(pressure);
+	}
+	
+public static void addTrack(StringTokenizer params)
+	{
+	ShortMessage message;
+	int chan = Integer.parseInt(params.nextToken());
+	MidiChannel channel = channels[chan];
+	int program = channelPrograms[chan];
+	float tickFactor = ((userResolution * 120) / userBpm);
+	
+	//System.out.println("tickFactor: " + tickFactor);
+	
+	if(sequence == null)
+		try {
+			//System.out.println("creating sequence: " + resolution);
+			sequence = new Sequence(Sequence.PPQ, sysResolution);
+			}
+		catch (Exception ex) {
+			ErrorDialog.showExit("gs:add-track", "Cannot create sequence - will exit");
+		}
+
+
+	track = sequence.createTrack();
+	tickAccum = 0;
+	
+	synth.loadInstrument(instruments[program]);
+	createShortMessage(ShortMessage.PROGRAM_CHANGE, chan, program, 64);
+	tickAccum = 1;
+
+	int oldBend = 8192;
+	
+	while(params.hasMoreTokens())
+		{
+		int key = Integer.parseInt(params.nextToken());
+		int duration = Integer.parseInt(params.nextToken());
+		int velocity = Integer.parseInt(params.nextToken()); 
+		int bend = Integer.parseInt(params.nextToken());
+		bend = Math.min(8191, Math.max(-8192, bend)) + channelBends[chan];
+		
+		//System.out.println("bend: " + bend + " tick: " + tickAccum);
+		
+		int tickIncrement = (int)((duration * tickFactor)/8);
+		
+		if(bend != oldBend)
+			{ 
+			createShortMessage(ShortMessage.PITCH_BEND, 0, bend & 0x7F, (bend >> 7) & 0xFF); 
+			tickAccum += 1;
+			tickIncrement -= 1;
+			oldBend = bend;
+			}			
+			
+		createShortMessage(ShortMessage.NOTE_ON, chan, key, velocity);
+		tickAccum += tickIncrement;
+		createShortMessage(ShortMessage.NOTE_OFF, chan, key, velocity);
+		}
+	}
+	
+public static void createShortMessage(int type, int chan, int num, int velocity)
+	{
+	ShortMessage message = new ShortMessage();
+	
+	try {
+		message.setMessage(type, chan, num, velocity);
+		MidiEvent event = new MidiEvent(message, tickAccum);
+		track.add(event);
+		}
+	catch (InvalidMidiDataException de) 
+		{ 
+		ErrorDialog.show("MIDI system", "Cannot create message channel:" + chan + " tick:" + tickAccum ); 
+		de.printStackTrace();
+		}
+	}
+	
+public static void muteTrack(StringTokenizer params)
+	{
+	int track = Integer.parseInt(params.nextToken());
+	if(params.nextToken().equals("nil"))
+		sequencer.setTrackMute(track, false);
+	else
+		sequencer.setTrackMute(track, true);
+	}
+	
+// seems not to work on Mac OS X, 2007 MacBook
+public static void soloTrack(StringTokenizer params)
+	{
+	int track = Integer.parseInt(params.nextToken());
+	if(params.nextToken().equals("nil"))
+		sequencer.setTrackSolo(track, false);
+	else
+		sequencer.setTrackSolo(track, false);
+	}
+	
+public static void playSequence(StringTokenizer params)
+	{
+	if(synth == null)
+		ErrorDialog.showExit("gs:play-sequence", "MIDI system not initialized - will exit");
+
+	if(sequence == null)
+		ErrorDialog.showExit("gs:play-sequence", "No tracks created - will exit");
+
+	int start = Integer.parseInt(params.nextToken()); // default = 0	
+	int loopCount = Integer.parseInt(params.nextToken()); // default = 0
+	long startPoint = Long.parseLong(params.nextToken()); // default = 0
+	long endPoint = Long.parseLong(params.nextToken()); // default = -1
+
+	
+	try	{
+		if(sequencer.isOpen() != true) 		
+			sequencer.open();
+		
+		sequencer.setSequence(sequence);
+		
+		if(endPoint == -1) endPoint = sequence.getTickLength();
+
+		//System.out.println("start:" + start + " loop count:" + loopCount + " loop start:" + startPoint + " loop end:" + endPoint);
+	
+		sequencer.setTickPosition(start);
+		sequencer.start();
+		sequencer.setLoopStartPoint(startPoint);
+		sequencer.setLoopEndPoint(endPoint);
+		sequencer.setLoopCount(loopCount);
+		sequencer.setTempoInBPM(sysBpm);
+		} 
+	catch (Exception e)
+		{ ErrorDialog.showExit("gs:play-sequence", "Cannot start sequencer - will exit"); }
+
+	}
+	
+public static void stopSequence()
+	{
+	if(sequencer == null)
+		ErrorDialog.show("gs:play-sequence", "No sequencer to stop");
+		
+	sequencer.stop();
+	long tickCount = sequencer.getTickPosition();
+	
+	guiserver.out.print("(set 'gs:tick-position " + tickCount + ")");
+	guiserver.out.flush();
+	}
+	
+	
+public static void saveSequence(StringTokenizer params) 
+	{
+	String filePath = Base64Coder.decodeString(params.nextToken());
+	//System.out.println("MIDI file:" + filePath);
+	File file = new File(filePath);
+	try 	
+		{
+		int[] fileTypes = MidiSystem.getMidiFileTypes(sequence);
+		if (fileTypes.length == 0)
+			ErrorDialog.show("gs:save-sequence", "Cannot save sequence");
+		else 
+			if (MidiSystem.write(sequence, fileTypes[0], file) == -1) 
+				ErrorDialog.show("gs:save-sequence", "Cannot write file");
+		} catch (Exception ex) {ErrorDialog.show("gs:save-sequence", "Cannot write file:" + filePath);}
+	}
+
+
+public static void midiClose()
+	{
+	if(synth != null) synth.close();
+	if(sequence != null) sequencer.close();
+		
+	synth = null;
+	sequencer = null;
+	}
+
+}
+
+
+/* eof */
diff --git a/guiserver/java/MidiSynth.java.bak b/guiserver/java/MidiSynth.java.bak
new file mode 100644
index 0000000..1eb0e12
--- /dev/null
+++ b/guiserver/java/MidiSynth.java.bak
@@ -0,0 +1,385 @@
+// MidiSynth.java
+// guiserver
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.lang.*;
+import java.awt.*;
+import java.util.*;
+import java.io.File;
+import javax.sound.midi.*;
+
+public class MidiSynth
+{
+static int	noteNumber = 0;
+static int	velocity = 0;
+static int	duration = 0;
+static Synthesizer synth = null;
+static Sequencer sequencer = null;
+static Receiver receiver = null;
+static Transmitter transmitter = null;
+static MidiChannel[] channels = null;
+static Instrument instruments[] = null;
+static Sequence sequence = null;
+static Soundbank soundbank = null;
+static int sysResolution = 32;
+static final int sysBpm = 120;
+static int userResolution = 16;
+static int userBpm = 120; 
+static int tickAccum;
+static Track track;
+static Integer[] channelPrograms = null;
+static Integer[] channelBends = null;
+static HashMap instrumentNumbers = new HashMap();
+
+@SuppressWarnings("unchecked")
+public static void midiInit(StringTokenizer params)
+	{
+	String filePath;
+	try	{
+		synth = MidiSystem.getSynthesizer();
+		synth.open();
+		sequencer = MidiSystem.getSequencer(); 
+		//transmitter = sequencer.getTransmitter();
+		//receiver = synth.getReceiver();			
+		//transmitter.setReceiver(receiver);
+		} 
+	catch (Exception me)
+		{
+		ErrorDialog.showExit("gs:midi-init", "MIDI system unavailable - will exit");	
+		return;	
+		}
+		
+	if(params.hasMoreTokens())
+		{
+		filePath = Base64Coder.decodeString(params.nextToken());
+		try { soundbank = MidiSystem.getSoundbank(new File(filePath)); }
+		catch (Exception me) {
+			ErrorDialog.show("gs:midi-init", "Cannot read soundbank:" + filePath);
+			}
+		}
+	else 
+		soundbank = synth.getDefaultSoundbank();
+		
+	instruments = soundbank.getInstruments();
+	
+	//instruments = synth.getDefaultSoundbank().getInstruments();
+	//instruments = synth.getAvailableInstruments();
+	for(int i = 0; i < Math.min(128, instruments.length); i++)
+		instrumentNumbers.put(instruments[i].getName(), i);
+		
+    synth.loadInstrument(instruments[0]);
+	channelPrograms = new Integer[16];
+	channelBends = new Integer[16];
+	for(int i = 0; i < 16; i++) 
+		{
+		channelPrograms[i] = 0;
+		channelBends[i] = 8192;
+		}
+	channels = synth.getChannels();
+	}
+
+public static void playNote(StringTokenizer params)
+	{
+	int bend = 0;
+	
+	noteNumber = Integer.parseInt(params.nextToken());
+	noteNumber = Math.min(127, Math.max(0, noteNumber));
+	
+	duration = Integer.parseInt(params.nextToken());
+	int milliseconds = (duration * 60000)/(userBpm * userResolution);
+	
+	velocity = Integer.parseInt(params.nextToken());
+	velocity = Math.min(127, Math.max(0, velocity));
+	
+	int chan = Integer.parseInt(params.nextToken());
+		
+	if(params.hasMoreTokens())
+		{
+		bend = Integer.parseInt(params.nextToken());
+		bend = Math.min(8192, Math.max(-8192, bend));
+		}
+	
+	if(channels == null)
+		{
+		ErrorDialog.showExit("gs:play-note", "MIDI system no initialized - will exit");
+		return;
+		}
+		
+	MidiChannel	channel = channels[chan];
+	channel.setPitchBend(channelBends[chan] + bend);
+
+	channel.noteOn(noteNumber, velocity);
+	
+	try	{ Thread.sleep(milliseconds);}
+	catch (InterruptedException e) { }
+
+	channel.noteOff(noteNumber);
+	}
+	
+public static void getInstruments()
+	{
+	if(instruments == null)
+		{
+		ErrorDialog.showExit("gs:get-instruments", "MIDI system no initialized - will exit");
+		return;
+		}
+		
+	guiserver.out.print("(set 'gs:instruments '( ");
+	for(int i = 0; i < Math.min(128, instruments.length); i++)
+		{
+		Instrument instrument = instruments[i];
+		guiserver.out.print("\"" + Base64Coder.encodeString(instrument.getName()) + "\" ");
+		}
+	guiserver.out.println(")) ");
+	guiserver.out.flush();
+
+	}
+	
+public static void midiPatch(StringTokenizer params)
+	{
+	String programName = Base64Coder.decodeString(params.nextToken());
+	int chan = Integer.parseInt(params.nextToken());
+	
+	if(synth == null)
+		ErrorDialog.showExit("gs:midi-patch", "MIDI system no initialized - will exit");
+
+	int program = 0;
+	
+	try { program = (Integer)instrumentNumbers.get(programName); }
+	catch (Exception ex) {
+		ErrorDialog.show("gs:midi-patch", "Instrument not known");
+		}
+			
+	try { synth.loadInstrument(instruments[program]); }
+	catch (Exception e)	{ 
+		ErrorDialog.show("gs:midi-path", "Instrument not available");
+		}
+		
+	MidiChannel	channel = channels[chan];
+	channel.programChange(program);
+	channelPrograms[chan] = program;
+	}
+	
+public static void midiBPM(StringTokenizer params)
+	{
+	userBpm = Integer.parseInt(params.nextToken());
+	if(params.hasMoreTokens())
+		userResolution = Integer.parseInt(params.nextToken());
+	}
+	
+public static void channelBend(StringTokenizer params)
+	{
+	int chan = Integer.parseInt(params.nextToken());
+	int bend = Integer.parseInt(params.nextToken());
+	bend = Math.min(8191, Math.max(-8192, bend));
+	channelBends[chan] = bend + 8192;
+	
+	MidiChannel channel = channels[chan];
+	}
+	
+public static void channelReverb(StringTokenizer params)
+	{
+	final int REVERB = 91;
+	int chan = Integer.parseInt(params.nextToken());
+	int reverb = Integer.parseInt(params.nextToken());
+	reverb = Math.min(127, Math.max(0, reverb));
+	
+	MidiChannel channel = channels[chan];
+	channel.controlChange(REVERB, reverb);
+	}
+
+public static void channelPressure(StringTokenizer params)
+	{
+	int chan = Integer.parseInt(params.nextToken());
+	int pressure = Integer.parseInt(params.nextToken());
+	pressure = Math.min(127, Math.max(0, pressure));
+	
+	MidiChannel channel = channels[chan];
+	channel.setChannelPressure(pressure);
+	}
+	
+public static void addTrack(StringTokenizer params)
+	{
+	ShortMessage message;
+	int chan = Integer.parseInt(params.nextToken());
+	MidiChannel channel = channels[chan];
+	int program = channelPrograms[chan];
+	float tickFactor = ((userResolution * 120) / userBpm);
+	
+	//System.out.println("tickFactor: " + tickFactor);
+	
+	if(sequence == null)
+		try {
+			//System.out.println("creating sequence: " + resolution);
+			sequence = new Sequence(Sequence.PPQ, sysResolution);
+			}
+		catch (Exception ex) {
+			ErrorDialog.showExit("gs:add-track", "Cannot create sequence - will exit");
+		}
+
+
+	track = sequence.createTrack();
+	tickAccum = 0;
+	
+	synth.loadInstrument(instruments[program]);
+	createShortMessage(ShortMessage.PROGRAM_CHANGE, chan, program, 64);
+	tickAccum = 1;
+
+	int oldBend = 8192;
+	
+	while(params.hasMoreTokens())
+		{
+		int key = Integer.parseInt(params.nextToken());
+		int duration = Integer.parseInt(params.nextToken());
+		int velocity = Integer.parseInt(params.nextToken()); 
+		int bend = Integer.parseInt(params.nextToken());
+		bend = Math.min(8191, Math.max(-8192, bend)) + channelBends[chan];
+		
+		//System.out.println("bend: " + bend + " tick: " + tickAccum);
+		
+		int tickIncrement = (int)((duration * tickFactor)/8);
+		
+		if(bend != oldBend)
+			{ 
+			createShortMessage(ShortMessage.PITCH_BEND, 0, bend & 0x7F, (bend >> 7) & 0xFF); 
+			tickAccum += 1;
+			tickIncrement -= 1;
+			oldBend = bend;
+			}			
+			
+		createShortMessage(ShortMessage.NOTE_ON, chan, key, velocity);
+		tickAccum += tickIncrement;
+		createShortMessage(ShortMessage.NOTE_OFF, chan, key, velocity);
+		}
+	}
+	
+public static void createShortMessage(int type, int chan, int num, int velocity)
+	{
+	ShortMessage message = new ShortMessage();
+	
+	try {
+		message.setMessage(type, chan, num, velocity);
+		MidiEvent event = new MidiEvent(message, tickAccum);
+		track.add(event);
+		}
+	catch (InvalidMidiDataException de) 
+		{ 
+		ErrorDialog.show("MIDI system", "Cannot create message channel:" + chan + " tick:" + tickAccum ); 
+		de.printStackTrace();
+		}
+	}
+	
+public static void muteTrack(StringTokenizer params)
+	{
+	int track = Integer.parseInt(params.nextToken());
+	if(params.nextToken().equals("nil"))
+		sequencer.setTrackMute(track, false);
+	else
+		sequencer.setTrackMute(track, true);
+	}
+	
+// seems not to work on Mac OS X, 2007 MacBook
+public static void soloTrack(StringTokenizer params)
+	{
+	int track = Integer.parseInt(params.nextToken());
+	if(params.nextToken().equals("nil"))
+		sequencer.setTrackSolo(track, false);
+	else
+		sequencer.setTrackSolo(track, false);
+	}
+	
+public static void playSequence(StringTokenizer params)
+	{
+	if(synth == null)
+		ErrorDialog.showExit("gs:play-sequence", "MIDI system not initialized - will exit");
+
+	if(sequence == null)
+		ErrorDialog.showExit("gs:play-sequence", "No tracks created - will exit");
+
+	int start = Integer.parseInt(params.nextToken()); // default = 0	
+	int loopCount = Integer.parseInt(params.nextToken()); // default = 0
+	long startPoint = Long.parseLong(params.nextToken()); // default = 0
+	long endPoint = Long.parseLong(params.nextToken()); // default = -1
+
+	
+	try	{
+		if(sequencer.isOpen() != true) 		
+			sequencer.open();
+		
+		sequencer.setSequence(sequence);
+		
+		if(endPoint == -1) endPoint = sequence.getTickLength();
+
+		//System.out.println("start:" + start + " loop count:" + loopCount + " loop start:" + startPoint + " loop end:" + endPoint);
+	
+		sequencer.setTickPosition(start);
+		sequencer.start();
+		sequencer.setLoopStartPoint(startPoint);
+		sequencer.setLoopEndPoint(endPoint);
+		sequencer.setLoopCount(loopCount);
+		sequencer.setTempoInBPM(sysBpm);
+		} 
+	catch (Exception e)
+		{ ErrorDialog.showExit("gs:play-sequence", "Cannot start sequencer - will exit"); }
+
+	}
+	
+public static void stopSequence()
+	{
+	if(sequencer == null)
+		ErrorDialog.show("gs:play-sequence", "No sequencer to stop");
+		
+	sequencer.stop();
+	long tickCount = sequencer.getTickPosition();
+	
+	guiserver.out.print("(set 'gs:tick-position " + tickCount + ")");
+	guiserver.out.flush();
+	}
+	
+	
+public static void saveSequence(StringTokenizer params) 
+	{
+	String filePath = Base64Coder.decodeString(params.nextToken());
+	//System.out.println("MIDI file:" + filePath);
+	File file = new File(filePath);
+	try 	
+		{
+		int[] fileTypes = MidiSystem.getMidiFileTypes(sequence);
+		if (fileTypes.length == 0)
+			ErrorDialog.show("gs:save-sequence", "Cannot save sequence");
+		else 
+			if (MidiSystem.write(sequence, fileTypes[0], file) == -1) 
+				ErrorDialog.show("gs:save-sequence", "Cannot write file");
+		} catch (Exception ex) {ErrorDialog.show("gs:save-sequence", "Cannot write file:" + filePath);}
+	}
+
+
+public static void midiClose()
+	{
+	if(synth != null) synth.close();
+	if(sequence != null) sequencer.close();
+		
+	synth = null;
+	sequencer = null;
+	}
+
+}
+
+
+/* eof */
diff --git a/guiserver/java/MyDocumentFilter.java b/guiserver/java/MyDocumentFilter.java
new file mode 100644
index 0000000..fd14560
--- /dev/null
+++ b/guiserver/java/MyDocumentFilter.java
@@ -0,0 +1,57 @@
+//
+//  MyDocumentFilter.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/7/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import javax.swing.*;
+import javax.swing.text.*;
+import java.awt.Toolkit;
+
+public class MyDocumentFilter extends DocumentFilter
+	{
+	int maxCharacters;
+		
+	public MyDocumentFilter(int max)
+		{
+		maxCharacters = max;
+		}
+	
+	public void insertString(FilterBypass fb, int offs, String str, AttributeSet a) throws BadLocationException 
+		{
+		if ((fb.getDocument().getLength() + str.length()) <= maxCharacters)
+			super.insertString(fb, offs, str, a);
+        else
+			Toolkit.getDefaultToolkit().beep();
+		}
+	
+    public void replace(FilterBypass fb, int offs, int length, String str, AttributeSet a) throws BadLocationException 
+		{
+        if ((fb.getDocument().getLength() + str.length()
+             - length) <= maxCharacters)
+            super.replace(fb, offs, length, str, a);
+        else
+            Toolkit.getDefaultToolkit().beep();
+		}
+	}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MyDocumentFilter.java.bak b/guiserver/java/MyDocumentFilter.java.bak
new file mode 100644
index 0000000..bf093f1
--- /dev/null
+++ b/guiserver/java/MyDocumentFilter.java.bak
@@ -0,0 +1,57 @@
+//
+//  MyDocumentFilter.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/7/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import javax.swing.*;
+import javax.swing.text.*;
+import java.awt.Toolkit;
+
+public class MyDocumentFilter extends DocumentFilter
+	{
+	int maxCharacters;
+		
+	public MyDocumentFilter(int max)
+		{
+		maxCharacters = max;
+		}
+	
+	public void insertString(FilterBypass fb, int offs, String str, AttributeSet a) throws BadLocationException 
+		{
+		if ((fb.getDocument().getLength() + str.length()) <= maxCharacters)
+			super.insertString(fb, offs, str, a);
+        else
+			Toolkit.getDefaultToolkit().beep();
+		}
+	
+    public void replace(FilterBypass fb, int offs, int length, String str, AttributeSet a) throws BadLocationException 
+		{
+        if ((fb.getDocument().getLength() + str.length()
+             - length) <= maxCharacters)
+            super.replace(fb, offs, length, str, a);
+        else
+            Toolkit.getDefaultToolkit().beep();
+		}
+	}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MyFileFilter.java b/guiserver/java/MyFileFilter.java
new file mode 100644
index 0000000..612c6dc
--- /dev/null
+++ b/guiserver/java/MyFileFilter.java
@@ -0,0 +1,63 @@
+//
+//  MyFileFilter.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.io.File;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+
+
+public class MyFileFilter extends javax.swing.filechooser.FileFilter {
+
+String extensions;
+String description = null;
+
+public boolean accept(File file)
+	{
+	String fileName = file.getName();
+	String ext;
+	
+	StringTokenizer tokens = new StringTokenizer(extensions);
+	
+	while(tokens.hasMoreTokens())
+		{
+		ext = tokens.nextToken();
+		if(fileName.endsWith(ext)) 
+			return(true);
+		
+		if(file.isDirectory()) return(true);
+		}
+	
+	return(false);
+	}
+	
+public String getDescription() {
+        return description;
+    }
+	
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/MyFileFilter.java.bak b/guiserver/java/MyFileFilter.java.bak
new file mode 100644
index 0000000..8c035c6
--- /dev/null
+++ b/guiserver/java/MyFileFilter.java.bak
@@ -0,0 +1,63 @@
+//
+//  MyFileFilter.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/21/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.io.File;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+
+
+public class MyFileFilter extends javax.swing.filechooser.FileFilter {
+
+String extensions;
+String description = null;
+
+public boolean accept(File file)
+	{
+	String fileName = file.getName();
+	String ext;
+	
+	StringTokenizer tokens = new StringTokenizer(extensions);
+	
+	while(tokens.hasMoreTokens())
+		{
+		ext = tokens.nextToken();
+		if(fileName.endsWith(ext)) 
+			return(true);
+		
+		if(file.isDirectory()) return(true);
+		}
+	
+	return(false);
+	}
+	
+public String getDescription() {
+        return description;
+    }
+	
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/OSXAdapter.java b/guiserver/java/OSXAdapter.java
new file mode 100644
index 0000000..d153d44
--- /dev/null
+++ b/guiserver/java/OSXAdapter.java
@@ -0,0 +1,330 @@
+/*
+File: OSXAdapter.java
+
+Abstract: Hooks existing preferences/about/quit functionality from an
+    existing Java app into handlers for the Mac OS X application menu.
+    Uses a Proxy object to dynamically implement the 
+    com.apple.eawt.ApplicationListener interface and register it with the
+    com.apple.eawt.Application object.  This allows the complete project
+    to be both built and run on any platform without any stubs or 
+    placeholders. Useful for developers looking to implement Mac OS X 
+    features while supporting multiple platforms with minimal impact.
+
+Version: 2.0
+
+Disclaimer: IMPORTANT:  This Apple software is supplied to you by 
+Apple Inc. ("Apple") in consideration of your agreement to the
+following terms, and your use, installation, modification or
+redistribution of this Apple software constitutes acceptance of these
+terms.  If you do not agree with these terms, please do not use,
+install, modify or redistribute this Apple software.
+
+In consideration of your agreement to abide by the following terms, and
+subject to these terms, Apple grants you a personal, non-exclusive
+license, under Apple's copyrights in this original Apple software (the
+"Apple Software"), to use, reproduce, modify and redistribute the Apple
+Software, with or without modifications, in source and/or binary forms;
+provided that if you redistribute the Apple Software in its entirety and
+without modifications, you must retain this notice and the following
+text and disclaimers in all such redistributions of the Apple Software. 
+Neither the name, trademarks, service marks or logos of Apple Inc. 
+may be used to endorse or promote products derived from the Apple
+Software without specific prior written permission from Apple.  Except
+as expressly stated in this notice, no other rights or licenses, express
+or implied, are granted by Apple herein, including but not limited to
+any patent rights that may be infringed by your derivative works or by
+other works in which the Apple Software may be incorporated.
+
+The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
+MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
+THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
+OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
+
+IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
+MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
+AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
+STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+Copyright ยฉ 2003-2007 Apple, Inc., All Rights Reserved
+
+*/
+
+ 
+
+import java.lang.reflect.*;
+import java.util.HashMap;
+
+@SuppressWarnings("unchecked")
+
+public class OSXAdapter implements InvocationHandler {
+    protected Object targetObject;
+    protected Method targetMethod;
+    protected String proxySignature;
+
+    static Object macOSXApplication;
+
+    // Pass this method an Object and Method equipped to perform application shutdown logic
+    // The method passed should return a boolean stating whether or not the quit should occur
+    public static void setQuitHandler(Object target, Method quitHandler) {
+        setHandler(new OSXAdapter("handleQuit", target, quitHandler));
+    }
+
+    // Pass this method an Object and Method equipped to display application info
+    // They will be called when the About menu item is selected from the application menu
+    public static void setAboutHandler(Object target, Method aboutHandler) {
+        boolean enableAboutMenu = (target != null && aboutHandler != null);
+        if (enableAboutMenu) {
+            setHandler(new OSXAdapter("handleAbout", target, aboutHandler));
+        }
+
+        // If we're setting a handler, enable the About menu item by calling
+
+        // com.apple.eawt.Application reflectively
+
+        try {
+
+            Method enableAboutMethod = macOSXApplication.getClass().getDeclaredMethod("setEnabledAboutMenu", new Class[] { boolean.class });
+
+            enableAboutMethod.invoke(macOSXApplication, new Object[] { Boolean.valueOf(enableAboutMenu) });
+
+        } catch (Exception ex) {
+
+            System.err.println("OSXAdapter could not access the About Menu");
+
+            ex.printStackTrace();
+
+        }
+
+    }
+
+    
+
+    // Pass this method an Object and a Method equipped to display application options
+
+    // They will be called when the Preferences menu item is selected from the application menu
+
+    public static void setPreferencesHandler(Object target, Method prefsHandler) {
+
+        boolean enablePrefsMenu = (target != null && prefsHandler != null);
+
+        if (enablePrefsMenu) {
+
+            setHandler(new OSXAdapter("handlePreferences", target, prefsHandler));
+
+        }
+
+        // If we're setting a handler, enable the Preferences menu item by calling
+
+        // com.apple.eawt.Application reflectively
+
+        try {
+
+            Method enablePrefsMethod = macOSXApplication.getClass().getDeclaredMethod("setEnabledPreferencesMenu", new Class[] { boolean.class });
+
+            enablePrefsMethod.invoke(macOSXApplication, new Object[] { Boolean.valueOf(enablePrefsMenu) });
+
+        } catch (Exception ex) {
+
+            System.err.println("OSXAdapter could not access the About Menu");
+
+            ex.printStackTrace();
+
+        }
+
+    }
+
+    
+
+    // Pass this method an Object and a Method equipped to handle document events from the Finder
+
+    // Documents are registered with the Finder via the CFBundleDocumentTypes dictionary in the 
+
+    // application bundle's Info.plist
+
+    public static void setFileHandler(Object target, Method fileHandler) {
+
+        setHandler(new OSXAdapter("handleOpenFile", target, fileHandler) {
+
+            // Override OSXAdapter.callTarget to send information on the
+
+            // file to be opened
+
+            public boolean callTarget(Object appleEvent) {
+
+                if (appleEvent != null) {
+
+                    try {
+
+                        Method getFilenameMethod = appleEvent.getClass().getDeclaredMethod("getFilename", (Class[])null);
+
+                        String filename = (String) getFilenameMethod.invoke(appleEvent, (Object[])null);
+
+                        this.targetMethod.invoke(this.targetObject, new Object[] { filename });
+
+                    } catch (Exception ex) {
+
+                        
+
+                    }
+
+                }
+
+                return true;
+
+            }
+
+        });
+
+    }
+
+    
+
+    // setHandler creates a Proxy object from the passed OSXAdapter and adds it as an ApplicationListener
+
+    public static void setHandler(OSXAdapter adapter) {
+
+        try {
+
+            Class applicationClass = Class.forName("com.apple.eawt.Application");
+
+            if (macOSXApplication == null) {
+
+                macOSXApplication = applicationClass.getConstructor((Class[])null).newInstance((Object[])null);
+
+            }
+
+            Class applicationListenerClass = Class.forName("com.apple.eawt.ApplicationListener");
+
+            Method addListenerMethod = applicationClass.getDeclaredMethod("addApplicationListener", new Class[] { applicationListenerClass });
+
+            // Create a proxy object around this handler that can be reflectively added as an Apple ApplicationListener
+
+            Object osxAdapterProxy = Proxy.newProxyInstance(OSXAdapter.class.getClassLoader(), new Class[] { applicationListenerClass }, adapter);
+
+            addListenerMethod.invoke(macOSXApplication, new Object[] { osxAdapterProxy });
+
+        } catch (ClassNotFoundException cnfe) {
+
+            System.err.println("This version of Mac OS X does not support the Apple EAWT.  ApplicationEvent handling has been disabled (" + cnfe + ")");
+
+        } catch (Exception ex) {  // Likely a NoSuchMethodException or an IllegalAccessException loading/invoking eawt.Application methods
+
+            System.err.println("Mac OS X Adapter could not talk to EAWT:");
+
+            ex.printStackTrace();
+
+        }
+
+    }
+
+ 
+
+    // Each OSXAdapter has the name of the EAWT method it intends to listen for (handleAbout, for example),
+
+    // the Object that will ultimately perform the task, and the Method to be called on that Object
+
+    protected OSXAdapter(String proxySignature, Object target, Method handler) {
+
+        this.proxySignature = proxySignature;
+
+        this.targetObject = target;
+
+        this.targetMethod = handler;
+
+    }
+
+    
+
+    // Override this method to perform any operations on the event 
+
+    // that comes with the various callbacks
+
+    // See setFileHandler above for an example
+
+    public boolean callTarget(Object appleEvent) throws InvocationTargetException, IllegalAccessException {
+
+        Object result = targetMethod.invoke(targetObject, (Object[])null);
+
+        if (result == null) {
+
+            return true;
+
+        }
+
+        return Boolean.valueOf(result.toString()).booleanValue();
+
+    }
+
+    
+
+    // InvocationHandler implementation
+
+    // This is the entry point for our proxy object; it is called every time an ApplicationListener method is invoked
+
+    public Object invoke (Object proxy, Method method, Object[] args) throws Throwable {
+
+        if (isCorrectMethod(method, args)) {
+
+            boolean handled = callTarget(args[0]);
+
+            setApplicationEventHandled(args[0], handled);
+
+        }
+
+        // All of the ApplicationListener methods are void; return null regardless of what happens
+
+        return null;
+
+    }
+
+    
+
+    // Compare the method that was called to the intended method when the OSXAdapter instance was created
+
+    // (e.g. handleAbout, handleQuit, handleOpenFile, etc.)
+
+    protected boolean isCorrectMethod(Method method, Object[] args) {
+
+        return (targetMethod != null && proxySignature.equals(method.getName()) && args.length == 1);
+
+    }
+
+    
+
+    // It is important to mark the ApplicationEvent as handled and cancel the default behavior
+
+    // This method checks for a boolean result from the proxy method and sets the event accordingly
+
+    protected void setApplicationEventHandled(Object event, boolean handled) {
+
+        if (event != null) {
+
+            try {
+
+                Method setHandledMethod = event.getClass().getDeclaredMethod("setHandled", new Class[] { boolean.class });
+
+                // If the target method returns a boolean, use that as a hint
+
+                setHandledMethod.invoke(event, new Object[] { Boolean.valueOf(handled) });
+
+            } catch (Exception ex) {
+
+                System.err.println("OSXAdapter was unable to handle an ApplicationEvent: " + event);
+
+                ex.printStackTrace();
+
+            }
+
+        }
+
+    }
+
+}
+
+// eof
+
diff --git a/guiserver/java/OSXAdapter.java.bak b/guiserver/java/OSXAdapter.java.bak
new file mode 100644
index 0000000..d153d44
--- /dev/null
+++ b/guiserver/java/OSXAdapter.java.bak
@@ -0,0 +1,330 @@
+/*
+File: OSXAdapter.java
+
+Abstract: Hooks existing preferences/about/quit functionality from an
+    existing Java app into handlers for the Mac OS X application menu.
+    Uses a Proxy object to dynamically implement the 
+    com.apple.eawt.ApplicationListener interface and register it with the
+    com.apple.eawt.Application object.  This allows the complete project
+    to be both built and run on any platform without any stubs or 
+    placeholders. Useful for developers looking to implement Mac OS X 
+    features while supporting multiple platforms with minimal impact.
+
+Version: 2.0
+
+Disclaimer: IMPORTANT:  This Apple software is supplied to you by 
+Apple Inc. ("Apple") in consideration of your agreement to the
+following terms, and your use, installation, modification or
+redistribution of this Apple software constitutes acceptance of these
+terms.  If you do not agree with these terms, please do not use,
+install, modify or redistribute this Apple software.
+
+In consideration of your agreement to abide by the following terms, and
+subject to these terms, Apple grants you a personal, non-exclusive
+license, under Apple's copyrights in this original Apple software (the
+"Apple Software"), to use, reproduce, modify and redistribute the Apple
+Software, with or without modifications, in source and/or binary forms;
+provided that if you redistribute the Apple Software in its entirety and
+without modifications, you must retain this notice and the following
+text and disclaimers in all such redistributions of the Apple Software. 
+Neither the name, trademarks, service marks or logos of Apple Inc. 
+may be used to endorse or promote products derived from the Apple
+Software without specific prior written permission from Apple.  Except
+as expressly stated in this notice, no other rights or licenses, express
+or implied, are granted by Apple herein, including but not limited to
+any patent rights that may be infringed by your derivative works or by
+other works in which the Apple Software may be incorporated.
+
+The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
+MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
+THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
+OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
+
+IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
+MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
+AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
+STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+Copyright ยฉ 2003-2007 Apple, Inc., All Rights Reserved
+
+*/
+
+ 
+
+import java.lang.reflect.*;
+import java.util.HashMap;
+
+@SuppressWarnings("unchecked")
+
+public class OSXAdapter implements InvocationHandler {
+    protected Object targetObject;
+    protected Method targetMethod;
+    protected String proxySignature;
+
+    static Object macOSXApplication;
+
+    // Pass this method an Object and Method equipped to perform application shutdown logic
+    // The method passed should return a boolean stating whether or not the quit should occur
+    public static void setQuitHandler(Object target, Method quitHandler) {
+        setHandler(new OSXAdapter("handleQuit", target, quitHandler));
+    }
+
+    // Pass this method an Object and Method equipped to display application info
+    // They will be called when the About menu item is selected from the application menu
+    public static void setAboutHandler(Object target, Method aboutHandler) {
+        boolean enableAboutMenu = (target != null && aboutHandler != null);
+        if (enableAboutMenu) {
+            setHandler(new OSXAdapter("handleAbout", target, aboutHandler));
+        }
+
+        // If we're setting a handler, enable the About menu item by calling
+
+        // com.apple.eawt.Application reflectively
+
+        try {
+
+            Method enableAboutMethod = macOSXApplication.getClass().getDeclaredMethod("setEnabledAboutMenu", new Class[] { boolean.class });
+
+            enableAboutMethod.invoke(macOSXApplication, new Object[] { Boolean.valueOf(enableAboutMenu) });
+
+        } catch (Exception ex) {
+
+            System.err.println("OSXAdapter could not access the About Menu");
+
+            ex.printStackTrace();
+
+        }
+
+    }
+
+    
+
+    // Pass this method an Object and a Method equipped to display application options
+
+    // They will be called when the Preferences menu item is selected from the application menu
+
+    public static void setPreferencesHandler(Object target, Method prefsHandler) {
+
+        boolean enablePrefsMenu = (target != null && prefsHandler != null);
+
+        if (enablePrefsMenu) {
+
+            setHandler(new OSXAdapter("handlePreferences", target, prefsHandler));
+
+        }
+
+        // If we're setting a handler, enable the Preferences menu item by calling
+
+        // com.apple.eawt.Application reflectively
+
+        try {
+
+            Method enablePrefsMethod = macOSXApplication.getClass().getDeclaredMethod("setEnabledPreferencesMenu", new Class[] { boolean.class });
+
+            enablePrefsMethod.invoke(macOSXApplication, new Object[] { Boolean.valueOf(enablePrefsMenu) });
+
+        } catch (Exception ex) {
+
+            System.err.println("OSXAdapter could not access the About Menu");
+
+            ex.printStackTrace();
+
+        }
+
+    }
+
+    
+
+    // Pass this method an Object and a Method equipped to handle document events from the Finder
+
+    // Documents are registered with the Finder via the CFBundleDocumentTypes dictionary in the 
+
+    // application bundle's Info.plist
+
+    public static void setFileHandler(Object target, Method fileHandler) {
+
+        setHandler(new OSXAdapter("handleOpenFile", target, fileHandler) {
+
+            // Override OSXAdapter.callTarget to send information on the
+
+            // file to be opened
+
+            public boolean callTarget(Object appleEvent) {
+
+                if (appleEvent != null) {
+
+                    try {
+
+                        Method getFilenameMethod = appleEvent.getClass().getDeclaredMethod("getFilename", (Class[])null);
+
+                        String filename = (String) getFilenameMethod.invoke(appleEvent, (Object[])null);
+
+                        this.targetMethod.invoke(this.targetObject, new Object[] { filename });
+
+                    } catch (Exception ex) {
+
+                        
+
+                    }
+
+                }
+
+                return true;
+
+            }
+
+        });
+
+    }
+
+    
+
+    // setHandler creates a Proxy object from the passed OSXAdapter and adds it as an ApplicationListener
+
+    public static void setHandler(OSXAdapter adapter) {
+
+        try {
+
+            Class applicationClass = Class.forName("com.apple.eawt.Application");
+
+            if (macOSXApplication == null) {
+
+                macOSXApplication = applicationClass.getConstructor((Class[])null).newInstance((Object[])null);
+
+            }
+
+            Class applicationListenerClass = Class.forName("com.apple.eawt.ApplicationListener");
+
+            Method addListenerMethod = applicationClass.getDeclaredMethod("addApplicationListener", new Class[] { applicationListenerClass });
+
+            // Create a proxy object around this handler that can be reflectively added as an Apple ApplicationListener
+
+            Object osxAdapterProxy = Proxy.newProxyInstance(OSXAdapter.class.getClassLoader(), new Class[] { applicationListenerClass }, adapter);
+
+            addListenerMethod.invoke(macOSXApplication, new Object[] { osxAdapterProxy });
+
+        } catch (ClassNotFoundException cnfe) {
+
+            System.err.println("This version of Mac OS X does not support the Apple EAWT.  ApplicationEvent handling has been disabled (" + cnfe + ")");
+
+        } catch (Exception ex) {  // Likely a NoSuchMethodException or an IllegalAccessException loading/invoking eawt.Application methods
+
+            System.err.println("Mac OS X Adapter could not talk to EAWT:");
+
+            ex.printStackTrace();
+
+        }
+
+    }
+
+ 
+
+    // Each OSXAdapter has the name of the EAWT method it intends to listen for (handleAbout, for example),
+
+    // the Object that will ultimately perform the task, and the Method to be called on that Object
+
+    protected OSXAdapter(String proxySignature, Object target, Method handler) {
+
+        this.proxySignature = proxySignature;
+
+        this.targetObject = target;
+
+        this.targetMethod = handler;
+
+    }
+
+    
+
+    // Override this method to perform any operations on the event 
+
+    // that comes with the various callbacks
+
+    // See setFileHandler above for an example
+
+    public boolean callTarget(Object appleEvent) throws InvocationTargetException, IllegalAccessException {
+
+        Object result = targetMethod.invoke(targetObject, (Object[])null);
+
+        if (result == null) {
+
+            return true;
+
+        }
+
+        return Boolean.valueOf(result.toString()).booleanValue();
+
+    }
+
+    
+
+    // InvocationHandler implementation
+
+    // This is the entry point for our proxy object; it is called every time an ApplicationListener method is invoked
+
+    public Object invoke (Object proxy, Method method, Object[] args) throws Throwable {
+
+        if (isCorrectMethod(method, args)) {
+
+            boolean handled = callTarget(args[0]);
+
+            setApplicationEventHandled(args[0], handled);
+
+        }
+
+        // All of the ApplicationListener methods are void; return null regardless of what happens
+
+        return null;
+
+    }
+
+    
+
+    // Compare the method that was called to the intended method when the OSXAdapter instance was created
+
+    // (e.g. handleAbout, handleQuit, handleOpenFile, etc.)
+
+    protected boolean isCorrectMethod(Method method, Object[] args) {
+
+        return (targetMethod != null && proxySignature.equals(method.getName()) && args.length == 1);
+
+    }
+
+    
+
+    // It is important to mark the ApplicationEvent as handled and cancel the default behavior
+
+    // This method checks for a boolean result from the proxy method and sets the event accordingly
+
+    protected void setApplicationEventHandled(Object event, boolean handled) {
+
+        if (event != null) {
+
+            try {
+
+                Method setHandledMethod = event.getClass().getDeclaredMethod("setHandled", new Class[] { boolean.class });
+
+                // If the target method returns a boolean, use that as a hint
+
+                setHandledMethod.invoke(event, new Object[] { Boolean.valueOf(handled) });
+
+            } catch (Exception ex) {
+
+                System.err.println("OSXAdapter was unable to handle an ApplicationEvent: " + event);
+
+                ex.printStackTrace();
+
+            }
+
+        }
+
+    }
+
+}
+
+// eof
+
diff --git a/guiserver/java/PanelWidget.java b/guiserver/java/PanelWidget.java
new file mode 100644
index 0000000..6a8ec45
--- /dev/null
+++ b/guiserver/java/PanelWidget.java
@@ -0,0 +1,59 @@
+//
+//  PanelWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/13/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked") 
+public class PanelWidget extends gsObject {
+
+JPanel jpanel;
+
+public PanelWidget(StringTokenizer params)
+	{
+	jpanel = new JPanel();
+	container = jpanel;
+	jcomponent = jpanel;
+	component = jpanel;
+	
+	id = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jpanel.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	}
+	
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PanelWidget.java.bak b/guiserver/java/PanelWidget.java.bak
new file mode 100644
index 0000000..24c5571
--- /dev/null
+++ b/guiserver/java/PanelWidget.java.bak
@@ -0,0 +1,59 @@
+//
+//  PanelWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/13/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked") 
+public class PanelWidget extends gsObject {
+
+JPanel jpanel;
+
+public PanelWidget(StringTokenizer params)
+	{
+	jpanel = new JPanel();
+	container = jpanel;
+	jcomponent = jpanel;
+	component = jpanel;
+	
+	id = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jpanel.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	}
+	
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PathShape.java b/guiserver/java/PathShape.java
new file mode 100644
index 0000000..4cd49a0
--- /dev/null
+++ b/guiserver/java/PathShape.java
@@ -0,0 +1,87 @@
+//
+//  PathShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/3/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class PathShape extends Shape {
+
+int pointXd[];
+int pointYd[];
+
+int N;
+
+public PathShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	N = Integer.parseInt(tokens.nextToken());
+	
+	pointXd = new int [N];
+	pointYd = new int [N];
+	
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	pointXd[0] = pointYd[0] = 0;
+	
+	for(int i = 1; i < N; i++)
+		{
+		pointXd[i] = Integer.parseInt(tokens.nextToken()) - X;
+		pointYd[i] = Integer.parseInt(tokens.nextToken()) - Y;
+		}
+		
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+		
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+		
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	
+	int pX[] = new int [N];
+	int pY[] = new int [N];
+	
+	GeneralPath path = new GeneralPath();
+	
+	path.moveTo(X, Y);
+	
+	for(int i = 1; i < N; i++)
+		path.lineTo(pointXd[i] + X, pointYd[i] + Y);
+	
+	g2.draw(path);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PathShape.java.bak b/guiserver/java/PathShape.java.bak
new file mode 100644
index 0000000..61d8601
--- /dev/null
+++ b/guiserver/java/PathShape.java.bak
@@ -0,0 +1,87 @@
+//
+//  PathShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/3/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class PathShape extends Shape {
+
+int pointXd[];
+int pointYd[];
+
+int N;
+
+public PathShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	N = Integer.parseInt(tokens.nextToken());
+	
+	pointXd = new int [N];
+	pointYd = new int [N];
+	
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	pointXd[0] = pointYd[0] = 0;
+	
+	for(int i = 1; i < N; i++)
+		{
+		pointXd[i] = Integer.parseInt(tokens.nextToken()) - X;
+		pointYd[i] = Integer.parseInt(tokens.nextToken()) - Y;
+		}
+		
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+		
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+		
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	
+	int pX[] = new int [N];
+	int pY[] = new int [N];
+	
+	GeneralPath path = new GeneralPath();
+	
+	path.moveTo(X, Y);
+	
+	for(int i = 1; i < N; i++)
+		path.lineTo(pointXd[i] + X, pointYd[i] + Y);
+	
+	g2.draw(path);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PolygonShape.java b/guiserver/java/PolygonShape.java
new file mode 100644
index 0000000..ffb4028
--- /dev/null
+++ b/guiserver/java/PolygonShape.java
@@ -0,0 +1,105 @@
+//
+//  PolygonShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.awt.Polygon;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class PolygonShape extends Shape {
+
+int pointXd[];
+int pointYd[];
+
+int N;
+
+public PolygonShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	N = Integer.parseInt(tokens.nextToken());
+	
+	pointXd = new int [N];
+	pointYd = new int [N];
+	
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	pointXd[0] = pointYd[0] = 0;
+	
+	for(int i = 1; i < N; i++)
+		{
+		pointXd[i] = Integer.parseInt(tokens.nextToken()) - X;
+		pointYd[i] = Integer.parseInt(tokens.nextToken()) - Y;
+		}
+		
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+		
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+		
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+
+/*
+	int pX[] = new int [N];
+	int pY[] = new int [N];
+	
+	for(int i = 0; i < N; i++)
+		{
+		pX[i] = pointXd[i] + X;
+		pY[i] = pointYd[i] + Y;
+		}
+	g2.drawPolygon(pX, pY, N);
+*/
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+
+	g2.draw(polygon);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{	
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+	
+	return(polygon.contains(x, y));
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PolygonShape.java.bak b/guiserver/java/PolygonShape.java.bak
new file mode 100644
index 0000000..7a02180
--- /dev/null
+++ b/guiserver/java/PolygonShape.java.bak
@@ -0,0 +1,105 @@
+//
+//  PolygonShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.awt.Polygon;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class PolygonShape extends Shape {
+
+int pointXd[];
+int pointYd[];
+
+int N;
+
+public PolygonShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	N = Integer.parseInt(tokens.nextToken());
+	
+	pointXd = new int [N];
+	pointYd = new int [N];
+	
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	pointXd[0] = pointYd[0] = 0;
+	
+	for(int i = 1; i < N; i++)
+		{
+		pointXd[i] = Integer.parseInt(tokens.nextToken()) - X;
+		pointYd[i] = Integer.parseInt(tokens.nextToken()) - Y;
+		}
+		
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+		
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+		
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+
+/*
+	int pX[] = new int [N];
+	int pY[] = new int [N];
+	
+	for(int i = 0; i < N; i++)
+		{
+		pX[i] = pointXd[i] + X;
+		pY[i] = pointYd[i] + Y;
+		}
+	g2.drawPolygon(pX, pY, N);
+*/
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+
+	g2.draw(polygon);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{	
+	Polygon polygon = new Polygon();
+	
+	for(int i = 0; i < N; i++)
+		polygon.addPoint(pointXd[i] + X, pointYd[i] + Y);
+	
+	return(polygon.contains(x, y));
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PopupMenuWidget.java b/guiserver/java/PopupMenuWidget.java
new file mode 100644
index 0000000..af93d91
--- /dev/null
+++ b/guiserver/java/PopupMenuWidget.java
@@ -0,0 +1,80 @@
+//
+//  PopupMenuWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/4/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class PopupMenuWidget extends gsObject {
+
+JPopupMenu jpopup;
+
+@SuppressWarnings("unchecked") 
+public PopupMenuWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	String text = params.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	jpopup = new JPopupMenu(text);
+	
+	//jpopup.setLightWeightPopupEnabled(false); only if canvas extends Canvas
+	container = jpopup;
+	jcomponent = jpopup;
+	component = jpopup;
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void addSeparator(StringTokenizer tokens)
+	{
+	jpopup.addSeparator();
+	}
+	
+public void showPopup(StringTokenizer tokens)
+	{ 
+	gsObject gsobject = (gsObject)gsObject.widgets.get(tokens.nextToken());
+	
+	int x = Integer.parseInt(tokens.nextToken());
+	int y = Integer.parseInt(tokens.nextToken());
+	
+	if(gsobject.jcomponent == null)
+		jpopup.show(gsobject.component, x, y);
+	else
+		jpopup.show(gsobject.jcomponent, x, y);
+		
+	jpopup.repaint();
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/PopupMenuWidget.java.bak b/guiserver/java/PopupMenuWidget.java.bak
new file mode 100644
index 0000000..8f9673d
--- /dev/null
+++ b/guiserver/java/PopupMenuWidget.java.bak
@@ -0,0 +1,80 @@
+//
+//  PopupMenuWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/4/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class PopupMenuWidget extends gsObject {
+
+JPopupMenu jpopup;
+
+@SuppressWarnings("unchecked") 
+public PopupMenuWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	String text = params.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	jpopup = new JPopupMenu(text);
+	
+	//jpopup.setLightWeightPopupEnabled(false); only if canvas extends Canvas
+	container = jpopup;
+	jcomponent = jpopup;
+	component = jpopup;
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void addSeparator(StringTokenizer tokens)
+	{
+	jpopup.addSeparator();
+	}
+	
+public void showPopup(StringTokenizer tokens)
+	{ 
+	gsObject gsobject = (gsObject)gsObject.widgets.get(tokens.nextToken());
+	
+	int x = Integer.parseInt(tokens.nextToken());
+	int y = Integer.parseInt(tokens.nextToken());
+	
+	if(gsobject.jcomponent == null)
+		jpopup.show(gsobject.component, x, y);
+	else
+		jpopup.show(gsobject.jcomponent, x, y);
+		
+	jpopup.repaint();
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ProgressBarWidget.java b/guiserver/java/ProgressBarWidget.java
new file mode 100644
index 0000000..e0f397e
--- /dev/null
+++ b/guiserver/java/ProgressBarWidget.java
@@ -0,0 +1,58 @@
+//
+//  ProgressBarWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked") 
+public class ProgressBarWidget extends gsObject {
+
+JProgressBar progressbar;
+
+public ProgressBarWidget(StringTokenizer params)
+	{
+	progressbar = new JProgressBar();
+	jcomponent = progressbar;
+	component = progressbar;
+	container = progressbar;
+	
+	id = params.nextToken();
+	
+	progressbar.setMinimum(Integer.parseInt(params.nextToken()));
+	progressbar.setMaximum(Integer.parseInt(params.nextToken()));
+	progressbar.setValue(Integer.parseInt(params.nextToken()));
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void setValue(StringTokenizer tokens)
+	{
+	progressbar.setValue(Integer.parseInt(tokens.nextToken()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ProgressBarWidget.java.bak b/guiserver/java/ProgressBarWidget.java.bak
new file mode 100644
index 0000000..d644f43
--- /dev/null
+++ b/guiserver/java/ProgressBarWidget.java.bak
@@ -0,0 +1,58 @@
+//
+//  ProgressBarWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked") 
+public class ProgressBarWidget extends gsObject {
+
+JProgressBar progressbar;
+
+public ProgressBarWidget(StringTokenizer params)
+	{
+	progressbar = new JProgressBar();
+	jcomponent = progressbar;
+	component = progressbar;
+	container = progressbar;
+	
+	id = params.nextToken();
+	
+	progressbar.setMinimum(Integer.parseInt(params.nextToken()));
+	progressbar.setMaximum(Integer.parseInt(params.nextToken()));
+	progressbar.setValue(Integer.parseInt(params.nextToken()));
+	
+	gsObject.widgets.put(id, this);
+	}
+
+public void setValue(StringTokenizer tokens)
+	{
+	progressbar.setValue(Integer.parseInt(tokens.nextToken()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RadioButtonWidget.java b/guiserver/java/RadioButtonWidget.java
new file mode 100644
index 0000000..62dca3c
--- /dev/null
+++ b/guiserver/java/RadioButtonWidget.java
@@ -0,0 +1,83 @@
+//
+//  RadioButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import javax.swing.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked") 
+public class RadioButtonWidget extends aButton {
+
+
+public RadioButtonWidget(StringTokenizer params)
+	{
+	abutton = new JRadioButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	
+	if(params.hasMoreTokens())
+		abutton.setSelected(params.nextToken().equals("true"));
+
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(abutton.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	abutton.addActionListener(listener);
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RadioButtonWidget.java.bak b/guiserver/java/RadioButtonWidget.java.bak
new file mode 100644
index 0000000..9270b19
--- /dev/null
+++ b/guiserver/java/RadioButtonWidget.java.bak
@@ -0,0 +1,83 @@
+//
+//  RadioButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import javax.swing.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked") 
+public class RadioButtonWidget extends aButton {
+
+
+public RadioButtonWidget(StringTokenizer params)
+	{
+	abutton = new JRadioButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	
+	if(params.hasMoreTokens())
+		abutton.setSelected(params.nextToken().equals("true"));
+
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(abutton.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	abutton.addActionListener(listener);
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RectangleShape.java b/guiserver/java/RectangleShape.java
new file mode 100644
index 0000000..c1e9f08
--- /dev/null
+++ b/guiserver/java/RectangleShape.java
@@ -0,0 +1,75 @@
+//
+//  RectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class RectangleShape extends Shape {
+
+int width;
+int height;
+
+public RectangleShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawRect(X, Y, width - 1, height - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RectangleShape.java.bak b/guiserver/java/RectangleShape.java.bak
new file mode 100644
index 0000000..088656d
--- /dev/null
+++ b/guiserver/java/RectangleShape.java.bak
@@ -0,0 +1,75 @@
+//
+//  RectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class RectangleShape extends Shape {
+
+int width;
+int height;
+
+public RectangleShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawRect(X, Y, width - 1, height - 1);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RoundRectShape.java b/guiserver/java/RoundRectShape.java
new file mode 100644
index 0000000..c33010e
--- /dev/null
+++ b/guiserver/java/RoundRectShape.java
@@ -0,0 +1,79 @@
+//
+//  RoundRectShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class RoundRectShape extends Shape {
+
+int width;
+int height;
+int arcWidth;
+int arcHeight;
+
+public RoundRectShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RoundRectShape.java.bak b/guiserver/java/RoundRectShape.java.bak
new file mode 100644
index 0000000..77d2e60
--- /dev/null
+++ b/guiserver/java/RoundRectShape.java.bak
@@ -0,0 +1,79 @@
+//
+//  RoundRectShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class RoundRectShape extends Shape {
+
+int width;
+int height;
+int arcWidth;
+int arcHeight;
+
+public RoundRectShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	float alpha;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RoundRectangleShape.java b/guiserver/java/RoundRectangleShape.java
new file mode 100644
index 0000000..15301ea
--- /dev/null
+++ b/guiserver/java/RoundRectangleShape.java
@@ -0,0 +1,78 @@
+//
+//  RoundRectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class RoundRectangleShape extends Shape {
+
+int width;
+int height;
+
+int arcWidth;
+int arcHeight;
+
+public RoundRectangleShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/RoundRectangleShape.java.bak b/guiserver/java/RoundRectangleShape.java.bak
new file mode 100644
index 0000000..6538f65
--- /dev/null
+++ b/guiserver/java/RoundRectangleShape.java.bak
@@ -0,0 +1,78 @@
+//
+//  RoundRectangleShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/2/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class RoundRectangleShape extends Shape {
+
+int width;
+int height;
+
+int arcWidth;
+int arcHeight;
+
+public RoundRectangleShape(StringTokenizer tokens)
+	{
+	float R, G, B;
+	
+	tag = tokens.nextToken();
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	width = Integer.parseInt(tokens.nextToken());
+	height = Integer.parseInt(tokens.nextToken());
+	arcWidth = Integer.parseInt(tokens.nextToken());
+	arcHeight = Integer.parseInt(tokens.nextToken());
+
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+	
+	stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//g2.setComposite(currentComposite);
+	g2.drawRoundRect(X, Y, width - 1, height - 1, arcWidth, arcHeight);
+	}
+
+public boolean hasPoint(int x, int y)
+	{
+	return(new Rectangle(X, Y, width, height).contains(x, y));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ScrollPaneWidget.java b/guiserver/java/ScrollPaneWidget.java
new file mode 100644
index 0000000..751a983
--- /dev/null
+++ b/guiserver/java/ScrollPaneWidget.java
@@ -0,0 +1,76 @@
+//
+//  ScrollPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/23/07.
+//
+//
+//    Copyright (C) 2013 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class ScrollPaneWidget extends gsObject {
+
+JScrollPane jscrollpane;
+
+public ScrollPaneWidget(StringTokenizer params)
+	{	
+	id = params.nextToken();
+	JComponent client  = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+	
+	jscrollpane = new JScrollPane();
+	jscrollpane.setViewportView(client);
+	jcomponent = jscrollpane;
+	component = jscrollpane;
+	container = jscrollpane;
+
+    jscrollpane.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE); // added v10.6.5 
+	
+	// AS_NEEDED is default	
+	//jscrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+	//jscrollpane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+		
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jscrollpane.setPreferredSize(new Dimension(width, height));
+		
+		// FdB added
+		if(params.hasMoreTokens())
+			{
+				JComponent customColumnHeader = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+				JComponent customRowHeader = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+				JComponent customCorner = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+				jscrollpane.setColumnHeaderView(customColumnHeader);
+				jscrollpane.setRowHeaderView(customRowHeader);
+				jscrollpane.setCorner(JScrollPane.UPPER_LEFT_CORNER,customCorner);
+			}
+	}
+
+	gsObject.widgets.put(id, this);
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ScrollPaneWidget.java.bak b/guiserver/java/ScrollPaneWidget.java.bak
new file mode 100644
index 0000000..751a983
--- /dev/null
+++ b/guiserver/java/ScrollPaneWidget.java.bak
@@ -0,0 +1,76 @@
+//
+//  ScrollPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/23/07.
+//
+//
+//    Copyright (C) 2013 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked")
+public class ScrollPaneWidget extends gsObject {
+
+JScrollPane jscrollpane;
+
+public ScrollPaneWidget(StringTokenizer params)
+	{	
+	id = params.nextToken();
+	JComponent client  = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+	
+	jscrollpane = new JScrollPane();
+	jscrollpane.setViewportView(client);
+	jcomponent = jscrollpane;
+	component = jscrollpane;
+	container = jscrollpane;
+
+    jscrollpane.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE); // added v10.6.5 
+	
+	// AS_NEEDED is default	
+	//jscrollpane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+	//jscrollpane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+		
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jscrollpane.setPreferredSize(new Dimension(width, height));
+		
+		// FdB added
+		if(params.hasMoreTokens())
+			{
+				JComponent customColumnHeader = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+				JComponent customRowHeader = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+				JComponent customCorner = ((gsObject)gsObject.widgets.get(params.nextToken())).jcomponent;
+				jscrollpane.setColumnHeaderView(customColumnHeader);
+				jscrollpane.setRowHeaderView(customRowHeader);
+				jscrollpane.setCorner(JScrollPane.UPPER_LEFT_CORNER,customCorner);
+			}
+	}
+
+	gsObject.widgets.put(id, this);
+	}
+
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/Shape.java b/guiserver/java/Shape.java
new file mode 100644
index 0000000..040d06b
--- /dev/null
+++ b/guiserver/java/Shape.java
@@ -0,0 +1,65 @@
+//
+//  Shape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+public class Shape {
+
+String tag;
+Stroke stroke;
+Color paintColor;
+AlphaComposite composite;
+AffineTransform transform = AffineTransform.getScaleInstance(1.0, 1.0);
+//AffineTransform transform = null;
+boolean visible = true;
+int X;
+int Y;
+
+public void drawShape(Graphics2D g2) 
+	{ }
+	
+	
+public boolean hasPoint(int X, int Y)
+	{
+	return false;
+	}
+
+static Color getColorParameter(StringTokenizer tokens)
+	{
+	float R, G, B;
+	
+	R = Float.parseFloat(tokens.nextToken());
+	G = Float.parseFloat(tokens.nextToken());
+	B = Float.parseFloat(tokens.nextToken());
+	
+	return new Color(R, G, B);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/Shape.java.bak b/guiserver/java/Shape.java.bak
new file mode 100644
index 0000000..af53e51
--- /dev/null
+++ b/guiserver/java/Shape.java.bak
@@ -0,0 +1,65 @@
+//
+//  Shape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/9/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+
+public class Shape {
+
+String tag;
+Stroke stroke;
+Color paintColor;
+AlphaComposite composite;
+AffineTransform transform = AffineTransform.getScaleInstance(1.0, 1.0);
+//AffineTransform transform = null;
+boolean visible = true;
+int X;
+int Y;
+
+public void drawShape(Graphics2D g2) 
+	{ }
+	
+	
+public boolean hasPoint(int X, int Y)
+	{
+	return false;
+	}
+
+static Color getColorParameter(StringTokenizer tokens)
+	{
+	float R, G, B;
+	
+	R = Float.parseFloat(tokens.nextToken());
+	G = Float.parseFloat(tokens.nextToken());
+	B = Float.parseFloat(tokens.nextToken());
+	
+	return new Color(R, G, B);
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/SliderWidget.java b/guiserver/java/SliderWidget.java
new file mode 100644
index 0000000..29fd91d
--- /dev/null
+++ b/guiserver/java/SliderWidget.java
@@ -0,0 +1,76 @@
+//
+//  SliderWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked") 
+public class SliderWidget extends gsObject {
+
+final JSlider slider;
+
+public SliderWidget(StringTokenizer params)
+	{
+	slider = new JSlider();
+	jcomponent = slider;
+	component = slider;
+	container = slider;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	
+	if(params.nextToken().equals("vertical"))
+		slider.setOrientation(JSlider.VERTICAL);
+	else 
+		slider.setOrientation(JSlider.HORIZONTAL);
+	
+	slider.setMinimum(Integer.parseInt(params.nextToken()));
+	slider.setMaximum(Integer.parseInt(params.nextToken()));
+	slider.setValue(Integer.parseInt(params.nextToken()));
+	
+	class SliderListener implements ChangeListener {
+		public void stateChanged(ChangeEvent e) {
+			guiserver.out.println("(" + action + " \"" + id + "\" " + slider.getValue() + ")");
+			guiserver.out.flush();
+			}
+		}
+		
+	slider.addChangeListener(new SliderListener());
+	gsObject.widgets.put(id, this);
+	}
+	
+public void setValue(StringTokenizer tokens)
+	{
+	slider.setValue(Integer.parseInt(tokens.nextToken()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/SliderWidget.java.bak b/guiserver/java/SliderWidget.java.bak
new file mode 100644
index 0000000..fe880be
--- /dev/null
+++ b/guiserver/java/SliderWidget.java.bak
@@ -0,0 +1,76 @@
+//
+//  SliderWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked") 
+public class SliderWidget extends gsObject {
+
+final JSlider slider;
+
+public SliderWidget(StringTokenizer params)
+	{
+	slider = new JSlider();
+	jcomponent = slider;
+	component = slider;
+	container = slider;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	
+	if(params.nextToken().equals("vertical"))
+		slider.setOrientation(JSlider.VERTICAL);
+	else 
+		slider.setOrientation(JSlider.HORIZONTAL);
+	
+	slider.setMinimum(Integer.parseInt(params.nextToken()));
+	slider.setMaximum(Integer.parseInt(params.nextToken()));
+	slider.setValue(Integer.parseInt(params.nextToken()));
+	
+	class SliderListener implements ChangeListener {
+		public void stateChanged(ChangeEvent e) {
+			guiserver.out.println("(" + action + " \"" + id + "\" " + slider.getValue() + ")");
+			guiserver.out.flush();
+			}
+		}
+		
+	slider.addChangeListener(new SliderListener());
+	gsObject.widgets.put(id, this);
+	}
+	
+public void setValue(StringTokenizer tokens)
+	{
+	slider.setValue(Integer.parseInt(tokens.nextToken()));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/SoundSystem.java b/guiserver/java/SoundSystem.java
new file mode 100644
index 0000000..b0f51ed
--- /dev/null
+++ b/guiserver/java/SoundSystem.java
@@ -0,0 +1,91 @@
+//
+//  Dispatcher.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 8/13/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.io.File;
+import java.io.IOException;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.DataLine;
+import javax.sound.sampled.LineUnavailableException;
+import javax.sound.sampled.SourceDataLine;
+
+public class SoundSystem
+{
+private static final int	EXTERNAL_BUFFER_SIZE = 64000;
+
+public static void playSound(String filePath)
+	{
+	File soundFile = new File(filePath);
+	AudioInputStream audioInputStream = null;
+
+	try	{ audioInputStream = AudioSystem.getAudioInputStream(soundFile);	}
+	catch (Exception e)	{
+		ErrorDialog.show("play-sound","Unsupported audio file");
+		return;
+		}
+
+	AudioFormat	audioFormat = audioInputStream.getFormat();
+
+	SourceDataLine line = null;
+
+	DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
+	try	{	
+		line = (SourceDataLine) AudioSystem.getLine(info);
+		line.open(audioFormat);
+		}
+	catch (LineUnavailableException e) {
+		System.out.println("Sound data line not available");
+		return;
+		}
+	catch (Exception e)	{
+		ErrorDialog.show("play-sound","Could nor open sound data line");	
+		return;
+		}
+
+	line.start();
+
+	int	nBytesRead = 0;
+	byte[]	abData = new byte[EXTERNAL_BUFFER_SIZE];
+
+	while (nBytesRead != -1)
+		{
+		try	{ nBytesRead = audioInputStream.read(abData, 0, abData.length);	}
+		catch (IOException e) {
+			ErrorDialog.show("play-sound","Could not read audio file");
+			}
+		if (nBytesRead >= 0)
+			{
+			int	nBytesWritten = line.write(abData, 0, nBytesRead);
+			}
+		}
+
+	line.drain();
+	line.close();
+	line = null;
+	}
+
+}
+
+// eof
diff --git a/guiserver/java/SoundSystem.java.bak b/guiserver/java/SoundSystem.java.bak
new file mode 100644
index 0000000..a31b173
--- /dev/null
+++ b/guiserver/java/SoundSystem.java.bak
@@ -0,0 +1,91 @@
+//
+//  Dispatcher.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 8/13/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.io.File;
+import java.io.IOException;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.DataLine;
+import javax.sound.sampled.LineUnavailableException;
+import javax.sound.sampled.SourceDataLine;
+
+public class SoundSystem
+{
+private static final int	EXTERNAL_BUFFER_SIZE = 64000;
+
+public static void playSound(String filePath)
+	{
+	File soundFile = new File(filePath);
+	AudioInputStream audioInputStream = null;
+
+	try	{ audioInputStream = AudioSystem.getAudioInputStream(soundFile);	}
+	catch (Exception e)	{
+		ErrorDialog.show("play-sound","Unsupported audio file");
+		return;
+		}
+
+	AudioFormat	audioFormat = audioInputStream.getFormat();
+
+	SourceDataLine line = null;
+
+	DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
+	try	{	
+		line = (SourceDataLine) AudioSystem.getLine(info);
+		line.open(audioFormat);
+		}
+	catch (LineUnavailableException e) {
+		System.out.println("Sound data line not available");
+		return;
+		}
+	catch (Exception e)	{
+		ErrorDialog.show("play-sound","Could nor open sound data line");	
+		return;
+		}
+
+	line.start();
+
+	int	nBytesRead = 0;
+	byte[]	abData = new byte[EXTERNAL_BUFFER_SIZE];
+
+	while (nBytesRead != -1)
+		{
+		try	{ nBytesRead = audioInputStream.read(abData, 0, abData.length);	}
+		catch (IOException e) {
+			ErrorDialog.show("play-sound","Could not read audio file");
+			}
+		if (nBytesRead >= 0)
+			{
+			int	nBytesWritten = line.write(abData, 0, nBytesRead);
+			}
+		}
+
+	line.drain();
+	line.close();
+	line = null;
+	}
+
+}
+
+// eof
diff --git a/guiserver/java/SplashWindow.java b/guiserver/java/SplashWindow.java
new file mode 100644
index 0000000..d8242a0
--- /dev/null
+++ b/guiserver/java/SplashWindow.java
@@ -0,0 +1,76 @@
+//
+//  SplashWindow.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/16/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked") 
+class SplashWindow extends Window
+{
+public static final long serialVersionUID = 1L;
+int width;
+int height;
+Image splashImage;
+Window splash;
+
+public SplashWindow(Window parent, Image splashImage)
+  {
+  super(parent);
+  splash = this;
+  this.splashImage =  splashImage;
+  width = splashImage.getWidth(this) + 2;
+  height = splashImage.getHeight(this) + 2;
+  setSize(width, height);
+  Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
+  setLocation((screen.width - width)/2, (screen.height - height)/2);
+  if(guiserver.MAC_OS_X)
+	this.setBackground(new Color(0, 0, 0, 0));
+  setVisible(true);
+  addMouseListener(new MouseAdapter () {
+    public void mousePressed(MouseEvent e) { splash.dispose(); }
+    });
+  }
+
+public void paint(Graphics g)
+  {
+  if(guiserver.MAC_OS_X)
+	{
+	g.setColor(new Color(0, 0, 0, 0));
+	g.fillRect(0, 0, width, height);
+	System.out.println("mac os x");
+	}
+  else
+	{
+	g.setColor(Color.lightGray);
+	g.fill3DRect(0, 0, width, height, true);
+	}
+  if(splashImage != null)
+    g.drawImage(splashImage,1,1,this);
+  }
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/SplashWindow.java.bak b/guiserver/java/SplashWindow.java.bak
new file mode 100644
index 0000000..84db1ad
--- /dev/null
+++ b/guiserver/java/SplashWindow.java.bak
@@ -0,0 +1,76 @@
+//
+//  SplashWindow.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/16/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked") 
+class SplashWindow extends Window
+{
+public static final long serialVersionUID = 1L;
+int width;
+int height;
+Image splashImage;
+Window splash;
+
+public SplashWindow(Window parent, Image splashImage)
+  {
+  super(parent);
+  splash = this;
+  this.splashImage =  splashImage;
+  width = splashImage.getWidth(this) + 2;
+  height = splashImage.getHeight(this) + 2;
+  setSize(width, height);
+  Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
+  setLocation((screen.width - width)/2, (screen.height - height)/2);
+  if(guiserver.MAC_OS_X)
+	this.setBackground(new Color(0, 0, 0, 0));
+  setVisible(true);
+  addMouseListener(new MouseAdapter () {
+    public void mousePressed(MouseEvent e) { splash.dispose(); }
+    });
+  }
+
+public void paint(Graphics g)
+  {
+  if(guiserver.MAC_OS_X)
+	{
+	g.setColor(new Color(0, 0, 0, 0));
+	g.fillRect(0, 0, width, height);
+	System.out.println("mac os x");
+	}
+  else
+	{
+	g.setColor(Color.lightGray);
+	g.fill3DRect(0, 0, width, height, true);
+	}
+  if(splashImage != null)
+    g.drawImage(splashImage,1,1,this);
+  }
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/SplitPaneWidget.java b/guiserver/java/SplitPaneWidget.java
new file mode 100644
index 0000000..03206a7
--- /dev/null
+++ b/guiserver/java/SplitPaneWidget.java
@@ -0,0 +1,81 @@
+//
+//  SplitPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/22/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked") 
+public class SplitPaneWidget extends gsObject {
+
+JSplitPane jsplitpane;
+
+public SplitPaneWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	
+	if(params.nextToken().equals("horizontal"))
+		{
+		jsplitpane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true);
+		jsplitpane.setResizeWeight(1.0);
+		}
+	else
+		{
+		jsplitpane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true);
+		jsplitpane.setResizeWeight(0.0);
+		}
+	
+	component = jsplitpane;
+	container = jsplitpane;
+	jcomponent = jsplitpane;
+	
+	if(params.hasMoreTokens())
+		jsplitpane.setResizeWeight(Float.parseFloat(params.nextToken()));
+		
+	if(params.hasMoreTokens())
+		jsplitpane.setDividerLocation(Float.parseFloat(params.nextToken()));
+		
+	if(params.hasMoreTokens())
+		jsplitpane.setDividerSize(Integer.parseInt(params.nextToken()));
+
+	
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jsplitpane.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	}
+	
+		
+}
+
+
+
+ 
+ 
+// eof //
diff --git a/guiserver/java/SplitPaneWidget.java.bak b/guiserver/java/SplitPaneWidget.java.bak
new file mode 100644
index 0000000..6d3fb65
--- /dev/null
+++ b/guiserver/java/SplitPaneWidget.java.bak
@@ -0,0 +1,81 @@
+//
+//  SplitPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/22/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+@SuppressWarnings("unchecked") 
+public class SplitPaneWidget extends gsObject {
+
+JSplitPane jsplitpane;
+
+public SplitPaneWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	
+	if(params.nextToken().equals("horizontal"))
+		{
+		jsplitpane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, true);
+		jsplitpane.setResizeWeight(1.0);
+		}
+	else
+		{
+		jsplitpane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true);
+		jsplitpane.setResizeWeight(0.0);
+		}
+	
+	component = jsplitpane;
+	container = jsplitpane;
+	jcomponent = jsplitpane;
+	
+	if(params.hasMoreTokens())
+		jsplitpane.setResizeWeight(Float.parseFloat(params.nextToken()));
+		
+	if(params.hasMoreTokens())
+		jsplitpane.setDividerLocation(Float.parseFloat(params.nextToken()));
+		
+	if(params.hasMoreTokens())
+		jsplitpane.setDividerSize(Integer.parseInt(params.nextToken()));
+
+	
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jsplitpane.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	}
+	
+		
+}
+
+
+
+ 
+ 
+// eof //
diff --git a/guiserver/java/SyntaxHighlighter.java b/guiserver/java/SyntaxHighlighter.java
new file mode 100644
index 0000000..dfdd642
--- /dev/null
+++ b/guiserver/java/SyntaxHighlighter.java
@@ -0,0 +1,305 @@
+//
+//  SyntaxHighlighter.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/19/07.
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.Pattern;
+import javax.swing.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class SyntaxHighlighter {
+
+static String reserved[] = {
+"!","!=","$","$0","$1","$10","$11","$12","$13","$14","$15","$2","$3","$4","$5","$6","$7","$8","$9","$args",
+"$error-event","$idx","$it","$main-args","$x","%","&","*","+","-","/","<","<<","<=","=",">",">=",">>","?","@","MAIN","NaN?",
+"^","abort","abs","acos","acosh","add","address","amb","and","append","append-file","apply","args","array",
+"array-list","array?","asin","asinh","assoc","atan","atan2","atanh","atom?","base64-dec","base64-enc",
+"bayes-query","bayes-train","begin","beta","betai","bind","binomial","bits","callback","case","catch",
+"ceil","change-dir","char","chop","clean","close","command-event","command-line","cond","cons","constant",
+"context","context?","copy","copy-file","corr","cos","cosh","count","cpymem","crc32","crit-chi2","crit-f","crit-t",
+"crit-z","current-line", "curry","date","date-parse","date-list","date-value","debug","dec","def-new","default","define",
+"define-macro", "delete","delete-file","delete-url","destroy","det","device","difference","directory","directory?","div",
+"do-until","do-while","doargs", "dolist","dostring","dotimes","dotree","dump","dup","empty?","encrypt",
+"ends-with","env","erf","error-event","estack","eval","eval-string","even?","exec","exists","exit","exp","expand",
+"explode","extend","factor","fft","file-info","file?","filter","find","find-all","first","flat","float","float?",
+"floor","flt","for","for-all","fork", "format","fv","gammai","gammaln","gcd","get-char","get-float","get-int",
+"get-long","get-string","get-url", "global","global?","if","if-not","ifft","import","inc","index","inf?","int",
+"integer","integer?","intersect", "invert","irr","join","json-error","json-parse","lambda?","last","last-error",
+"legal?","length","let","letex","letn","list","list?", "load","local","log","lookup","lower-case","macro","macro?",
+"main-args","make-dir","map","mat","match","max","member", "min","mod","mul","multiply","net-accept","net-close",
+"net-connect", "net-error","net-eval", "net-interface", "net-listen","net-local","net-lookup","net-packet","net-ipv", 
+"net-peek", "net-peer","net-ping","net-receive", "net-receive-from", "net-receive-udp","net-select","net-send",
+"net-send-to", "net-send-udp","net-service", "net-sessions","new", "nil","nil?","normal","not","now","nper","npv",
+"nth","null?", "number?","odd?","open","or",
+"ostype","pack","parse", "parse-date","path","peek","pipe","pmt","pop","pop-assoc", "post-url","pow","prefix",
+"pretty-print", "primitive?","print", "println","prob-chi2","prob-f","prob-t","prob-z","process","prompt-event","protected?",
+"push","put-url","pv","quote","quote?","rand", "random","randomize","read","read-buffer","read-char","read-expr",
+"read-file","read-key","read-line","reader-event", "read-utf8", "real-path","receive","ref","ref-all","regex",
+"regex-comp","remove-dir", "rename-file","replace", "replace-assoc","reset", "rest","reverse", "rotate","round",
+"save","search","seed","seek","select","self","semaphore","send", "sequence","series","set", "set-locale",
+"set-ref", "set-ref-all","setq","setf","sgn","share","signal","silent", "sin","sinh","sleep","slice", "sort",
+"source","spawn", "sqrt","starts-with","stats","string","string?","struct","sub","sync","swap","sym","symbol?","symbols", 
+"sys-error","sys-info","t-test","tan", "tanh","term","throw","throw-error","time","time-of-day", "timer","title-case",
+"trace", "trace-highlight","transpose", "trim", "true","true?","unicode","unify","union","unique", "unless","unpack", 
+"until","upper-case","utf8","utf8len", "uuid", "wait-pid","when","while","write","write-buffer", "write-char",
+"write-file", "write-line","xfer-event","xml-error","xml-parse", "xml-type-tags","zero?","|","~" };
+
+static SimpleAttributeSet comment;
+static SimpleAttributeSet keyword;
+static SimpleAttributeSet string;
+static SimpleAttributeSet number;
+static SimpleAttributeSet paren;
+static SimpleAttributeSet quoted;
+static SimpleAttributeSet normal;
+
+static Color normalColor = Color.black;
+static Color commentColor = Color.gray;
+static Color keywordColor = new Color(0, 0, 192);
+static Color stringColor = new Color(0, 128, 0);
+static Color numberColor = new Color(192,128, 0);
+static Color parenColor = new Color(192, 0, 0);
+static Color quotedColor = new Color(96, 96, 192);
+
+static String numberPattern = "^[+-]?\\d+$|^[+-]?\\d+\\.\\d+$|^0x[0-9a-fA-F]+$|^0b[01]+$|^(\\d*(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?$";
+/*                                    lead     hex            octal      decimal                                scientific       binary */
+/* static String numberPattern = "{^(\\s+|\\(|\\))(0x[0-9a-fA-F]+|[+-]?0\\d+|([+-]?(0|[1-9]\\d*)(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?)|0[bB][01]+$} ";*/
+static Pattern compiledPattern;
+
+static StyledDocument doc;
+static String text;
+static String token;
+static Vector topLevels;
+
+static HashSet keys = null;
+static boolean active = false;
+
+@SuppressWarnings("unchecked") 
+static public void color(TextPaneWidget widget, int offset, int length)
+	{
+	int parenCount = 0;
+	int curlCount = 0;
+	int startToken;
+	int idx = offset;
+	int tokenLen;
+	char chr;
+
+	active = true;
+
+	doc = widget.styledDoc;
+	topLevels = widget.shTopLevels;
+	
+	normal = new SimpleAttributeSet();
+	StyleConstants.setForeground(normal, widget.foreground);
+	
+	try { text = doc.getText(0, widget.documentLength); } 
+	catch (Exception e) {text = null;} 	
+	
+	if(keys == null) init();
+	while(idx < length)
+		{
+		chr = text.charAt(idx++);
+		while(chr <= ' ' && idx < length) chr = text.charAt(idx++);		
+		//System.out.println("idx: " + idx + " length: " + length + " text->" + text + "<->");
+		switch(chr)
+			{
+			case ';':
+			case '#':
+				startToken = idx - 1;
+				while(chr != '\n' && idx < length) chr = text.charAt(idx++);
+				doc.setCharacterAttributes(startToken, idx - startToken, comment, false);
+				continue;
+			case '(':
+				++parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case ')':
+				--parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				if(parenCount == 0) // top level
+					{
+					topLevels.addElement(offset);
+					offset = idx;
+					}
+				continue;
+			case '\'':
+ 				startToken = idx - 1;
+				while(chr > ' ' && chr != '(' && chr != ')' && idx < length) chr = text.charAt(idx++);
+				if(chr == ' ' || chr == '(' || chr == ')')
+					{
+					doc.setCharacterAttributes(startToken, idx - startToken - 1, quoted, false);
+					idx--;
+					continue;
+					}
+				else
+					doc.setCharacterAttributes(startToken, idx - startToken, quoted, false);
+					
+				continue;
+			case '"':
+				startToken = idx - 1;
+				while(idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '"') 
+						{
+						doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+						break;
+						}
+					if(chr == '\\')
+						{
+						idx++;
+						continue;
+						}
+					}
+				continue;
+			case '{':
+				startToken = idx - 1;
+				curlCount = 1;
+				while(curlCount != 0 && idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '}') curlCount--;
+					else if(chr == '{') curlCount++;
+					}
+				doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+				continue;
+			case '[':
+				startToken = idx - 1;
+				if(text.startsWith("[text]", startToken))
+					{
+					idx = text.indexOf("[/text]", startToken + 6);
+					if(idx < 0) idx = length;
+					else idx = idx + 7;
+					doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+					continue;
+					}
+				continue;
+			default:
+				startToken = idx - 1;
+				//System.out.println("startToken: " + startToken);
+				while(chr > ' ' && chr != '(' && chr != ')' && chr != '\'' && idx < length) chr = text.charAt(idx++);
+
+				//System.out.println("->" + chr + "<-");	
+					
+				if(chr == '(' || chr == ')' || chr == ' ')
+					token = text.substring(startToken, idx - 1);
+				else
+					token = text.substring(startToken, idx );
+					
+				tokenLen = token.length();
+					
+				//System.out.println("start: " + startToken + "token: " + token + " tokenLen: " + tokenLen);
+
+				if(keys.contains(token))
+					doc.setCharacterAttributes(startToken, tokenLen, keyword, false);
+				else
+					{
+					if(compiledPattern.matcher(token).matches())
+						doc.setCharacterAttributes(startToken, tokenLen, number, false);
+					else
+						doc.setCharacterAttributes(startToken, tokenLen, normal, false);
+					}
+
+				if(chr == '(')
+					{
+					++parenCount;
+					doc.setCharacterAttributes(idx - 1, 1, paren, false);
+					continue;
+					}
+				else if(chr == ')')
+					{
+					--parenCount;
+					doc.setCharacterAttributes(idx - 1, 1, paren, false);
+					if(parenCount == 0) // top level
+						{
+						topLevels.addElement(offset);
+						offset = idx;
+						}
+					continue;
+					}
+				else if(chr == '\'')
+					{
+					doc.setCharacterAttributes(idx - 1, 1, paren, false);
+					continue;
+					}
+			}
+		}
+		
+	active = false;
+	}
+	
+static void init()
+	{
+	if(keys == null)
+		{
+		keys = new HashSet();
+		for(int idx = 0; idx < reserved.length; idx++)
+			keys.add(reserved[idx]);
+		}
+		
+	compiledPattern = Pattern.compile(numberPattern);
+	
+	comment = new SimpleAttributeSet();
+	StyleConstants.setForeground(comment, commentColor);
+	
+	keyword = new SimpleAttributeSet();
+	StyleConstants.setForeground(keyword, keywordColor);
+	
+	string = new SimpleAttributeSet();
+	StyleConstants.setForeground(string, stringColor);
+	
+	number = new SimpleAttributeSet();
+	StyleConstants.setForeground(number, numberColor);
+	
+	quoted = new SimpleAttributeSet();
+	StyleConstants.setForeground(quoted, quotedColor);
+	
+	paren = new SimpleAttributeSet();
+	StyleConstants.setForeground(paren, parenColor);
+	}
+	
+public static void setSyntaxColors(StringTokenizer tokens)
+	{
+	commentColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+
+	keywordColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	stringColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	numberColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	quotedColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	parenColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	init();
+	SyntaxHighlighterC.init();
+	}
+}
+
+// eof
diff --git a/guiserver/java/SyntaxHighlighter.java.bak b/guiserver/java/SyntaxHighlighter.java.bak
new file mode 100644
index 0000000..f79bd44
--- /dev/null
+++ b/guiserver/java/SyntaxHighlighter.java.bak
@@ -0,0 +1,305 @@
+//
+//  SyntaxHighlighter.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 7/19/07.
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.Pattern;
+import javax.swing.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class SyntaxHighlighter {
+
+static String reserved[] = {
+"!","!=","$","$0","$1","$10","$11","$12","$13","$14","$15","$2","$3","$4","$5","$6","$7","$8","$9","$args",
+"$error-event","$idx","$it","$main-args","$x","%","&","*","+","-","/","<","<<","<=","=",">",">=",">>","?","@","MAIN","NaN?",
+"^","abort","abs","acos","acosh","add","address","amb","and","append","append-file","apply","args","array",
+"array-list","array?","asin","asinh","assoc","atan","atan2","atanh","atom?","base64-dec","base64-enc",
+"bayes-query","bayes-train","begin","beta","betai","bind","binomial","bits","callback","case","catch",
+"ceil","change-dir","char","chop","clean","close","command-event","command-line","cond","cons","constant",
+"context","context?","copy","copy-file","corr","cos","cosh","count","cpymem","crc32","crit-chi2","crit-f","crit-t",
+"crit-z","current-line", "curry","date","date-parse","date-list","date-value","debug","dec","def-new","default","define",
+"define-macro", "delete","delete-file","delete-url","destroy","det","device","difference","directory","directory?","div",
+"do-until","do-while","doargs", "dolist","dostring","dotimes","dotree","dump","dup","empty?","encrypt",
+"ends-with","env","erf","error-event","estack","eval","eval-string","even?","exec","exists","exit","exp","expand",
+"explode","extend","factor","fft","file-info","file?","filter","find","find-all","first","flat","float","float?",
+"floor","flt","for","for-all","fork", "format","fv","gammai","gammaln","gcd","get-char","get-float","get-int",
+"get-long","get-string","get-url", "global","global?","if","if-not","ifft","import","inc","index","inf?","int",
+"integer","integer?","intersect", "invert","irr","join","json-error","json-parse","lambda?","last","last-error",
+"legal?","length","let","letex","letn","list","list?", "load","local","log","lookup","lower-case","macro","macro?",
+"main-args","make-dir","map","mat","match","max","member", "min","mod","mul","multiply","net-accept","net-close",
+"net-connect", "net-error","net-eval", "net-interface", "net-listen","net-local","net-lookup","net-packet","net-ipv", 
+"net-peek", "net-peer","net-ping","net-receive", "net-receive-from", "net-receive-udp","net-select","net-send",
+"net-send-to", "net-send-udp","net-service", "net-sessions","new", "nil","nil?","normal","not","now","nper","npv",
+"nth","null?", "number?","odd?","open","or",
+"ostype","pack","parse", "parse-date","path","peek","pipe","pmt","pop","pop-assoc", "post-url","pow","prefix",
+"pretty-print", "primitive?","print", "println","prob-chi2","prob-f","prob-t","prob-z","process","prompt-event","protected?",
+"push","put-url","pv","quote","quote?","rand", "random","randomize","read","read-buffer","read-char","read-expr",
+"read-file","read-key","read-line","reader-event", "read-utf8", "real-path","receive","ref","ref-all","regex",
+"regex-comp","remove-dir", "rename-file","replace", "replace-assoc","reset", "rest","reverse", "rotate","round",
+"save","search","seed","seek","select","self","semaphore","send", "sequence","series","set", "set-locale",
+"set-ref", "set-ref-all","setq","setf","sgn","share","signal","silent", "sin","sinh","sleep","slice", "sort",
+"source","spawn", "sqrt","starts-with","stats","string","string?","struct","sub","sync","swap","sym","symbol?","symbols", 
+"sys-error","sys-info","t-test","tan", "tanh","term","throw","throw-error","time","time-of-day", "timer","title-case",
+"trace", "trace-highlight","transpose", "trim", "true","true?","unicode","unify","union","unique", "unless","unpack", 
+"until","upper-case","utf8","utf8len", "uuid", "wait-pid","when","while","write","write-buffer", "write-char",
+"write-file", "write-line","xfer-event","xml-error","xml-parse", "xml-type-tags","zero?","|","~" };
+
+static SimpleAttributeSet comment;
+static SimpleAttributeSet keyword;
+static SimpleAttributeSet string;
+static SimpleAttributeSet number;
+static SimpleAttributeSet paren;
+static SimpleAttributeSet quoted;
+static SimpleAttributeSet normal;
+
+static Color normalColor = Color.black;
+static Color commentColor = Color.gray;
+static Color keywordColor = new Color(0, 0, 192);
+static Color stringColor = new Color(0, 128, 0);
+static Color numberColor = new Color(192,128, 0);
+static Color parenColor = new Color(192, 0, 0);
+static Color quotedColor = new Color(96, 96, 192);
+
+static String numberPattern = "^[+-]?\\d+$|^[+-]?\\d+\\.\\d+$|^0x[0-9a-fA-F]+$|^0b[01]+$|^(\\d*(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?$";
+/*                                    lead     hex            octal      decimal                                scientific       binary */
+/* static String numberPattern = "{^(\\s+|\\(|\\))(0x[0-9a-fA-F]+|[+-]?0\\d+|([+-]?(0|[1-9]\\d*)(\\.\\d*)?|\\.\\d+)([eE][+-]?\\d+)?)|0[bB][01]+$} ";*/
+static Pattern compiledPattern;
+
+static StyledDocument doc;
+static String text;
+static String token;
+static Vector topLevels;
+
+static HashSet keys = null;
+static boolean active = false;
+
+@SuppressWarnings("unchecked") 
+static public void color(TextPaneWidget widget, int offset, int length)
+	{
+	int parenCount = 0;
+	int curlCount = 0;
+	int startToken;
+	int idx = offset;
+	int tokenLen;
+	char chr;
+
+	active = true;
+
+	doc = widget.styledDoc;
+	topLevels = widget.shTopLevels;
+	
+	normal = new SimpleAttributeSet();
+	StyleConstants.setForeground(normal, widget.foreground);
+	
+	try { text = doc.getText(0, widget.documentLength); } 
+	catch (Exception e) {text = null;} 	
+	
+	if(keys == null) init();
+	while(idx < length)
+		{
+		chr = text.charAt(idx++);
+		while(chr <= ' ' && idx < length) chr = text.charAt(idx++);		
+		//System.out.println("idx: " + idx + " length: " + length + " text->" + text + "<->");
+		switch(chr)
+			{
+			case ';':
+			case '#':
+				startToken = idx - 1;
+				while(chr != '\n' && idx < length) chr = text.charAt(idx++);
+				doc.setCharacterAttributes(startToken, idx - startToken, comment, false);
+				continue;
+			case '(':
+				++parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case ')':
+				--parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				if(parenCount == 0) // top level
+					{
+					topLevels.addElement(offset);
+					offset = idx;
+					}
+				continue;
+			case '\'':
+ 				startToken = idx - 1;
+				while(chr > ' ' && chr != '(' && chr != ')' && idx < length) chr = text.charAt(idx++);
+				if(chr == ' ' || chr == '(' || chr == ')')
+					{
+					doc.setCharacterAttributes(startToken, idx - startToken - 1, quoted, false);
+					idx--;
+					continue;
+					}
+				else
+					doc.setCharacterAttributes(startToken, idx - startToken, quoted, false);
+					
+				continue;
+			case '"':
+				startToken = idx - 1;
+				while(idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '"') 
+						{
+						doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+						break;
+						}
+					if(chr == '\\')
+						{
+						idx++;
+						continue;
+						}
+					}
+				continue;
+			case '{':
+				startToken = idx - 1;
+				curlCount = 1;
+				while(curlCount != 0 && idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '}') curlCount--;
+					else if(chr == '{') curlCount++;
+					}
+				doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+				continue;
+			case '[':
+				startToken = idx - 1;
+				if(text.startsWith("[text]", startToken))
+					{
+					idx = text.indexOf("[/text]", startToken + 6);
+					if(idx < 0) idx = length;
+					else idx = idx + 7;
+					doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+					continue;
+					}
+				continue;
+			default:
+				startToken = idx - 1;
+				//System.out.println("startToken: " + startToken);
+				while(chr > ' ' && chr != '(' && chr != ')' && chr != '\'' && idx < length) chr = text.charAt(idx++);
+
+				//System.out.println("->" + chr + "<-");	
+					
+				if(chr == '(' || chr == ')' || chr == ' ')
+					token = text.substring(startToken, idx - 1);
+				else
+					token = text.substring(startToken, idx );
+					
+				tokenLen = token.length();
+					
+				//System.out.println("start: " + startToken + "token: " + token + " tokenLen: " + tokenLen);
+
+				if(keys.contains(token))
+					doc.setCharacterAttributes(startToken, tokenLen, keyword, false);
+				else
+					{
+					if(compiledPattern.matcher(token).matches())
+						doc.setCharacterAttributes(startToken, tokenLen, number, false);
+					else
+						doc.setCharacterAttributes(startToken, tokenLen, normal, false);
+					}
+
+				if(chr == '(')
+					{
+					++parenCount;
+					doc.setCharacterAttributes(idx - 1, 1, paren, false);
+					continue;
+					}
+				else if(chr == ')')
+					{
+					--parenCount;
+					doc.setCharacterAttributes(idx - 1, 1, paren, false);
+					if(parenCount == 0) // top level
+						{
+						topLevels.addElement(offset);
+						offset = idx;
+						}
+					continue;
+					}
+				else if(chr == '\'')
+					{
+					doc.setCharacterAttributes(idx - 1, 1, paren, false);
+					continue;
+					}
+			}
+		}
+		
+	active = false;
+	}
+	
+static void init()
+	{
+	if(keys == null)
+		{
+		keys = new HashSet();
+		for(int idx = 0; idx < reserved.length; idx++)
+			keys.add(reserved[idx]);
+		}
+		
+	compiledPattern = Pattern.compile(numberPattern);
+	
+	comment = new SimpleAttributeSet();
+	StyleConstants.setForeground(comment, commentColor);
+	
+	keyword = new SimpleAttributeSet();
+	StyleConstants.setForeground(keyword, keywordColor);
+	
+	string = new SimpleAttributeSet();
+	StyleConstants.setForeground(string, stringColor);
+	
+	number = new SimpleAttributeSet();
+	StyleConstants.setForeground(number, numberColor);
+	
+	quoted = new SimpleAttributeSet();
+	StyleConstants.setForeground(quoted, quotedColor);
+	
+	paren = new SimpleAttributeSet();
+	StyleConstants.setForeground(paren, parenColor);
+	}
+	
+public static void setSyntaxColors(StringTokenizer tokens)
+	{
+	commentColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+
+	keywordColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	stringColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	numberColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	quotedColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	parenColor = new Color(Float.parseFloat(tokens.nextToken()),
+		Float.parseFloat(tokens.nextToken()), Float.parseFloat(tokens.nextToken()));
+		
+	init();
+	SyntaxHighlighterC.init();
+	}
+}
+
+// eof
diff --git a/guiserver/java/SyntaxHighlighterC.java b/guiserver/java/SyntaxHighlighterC.java
new file mode 100644
index 0000000..67d7f53
--- /dev/null
+++ b/guiserver/java/SyntaxHighlighterC.java
@@ -0,0 +1,315 @@
+//
+//  SyntaxHighlighterC.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 8/4/07.
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.Pattern;
+import javax.swing.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class SyntaxHighlighterC {
+
+static String reservedC[] = {
+"auto", "break", "byte", "case", "char", "const", "continue", "default", "do", 
+"double", "else", "enum", "extern", "float", "for", "goto", "if", "inline", "int", 
+"long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", 
+"typedef", "union", "unsigned", "void", "volatil", "while"
+};
+
+static String reservedCPP[] = {
+"bool",	"catch", "class", "delete", "friend", "inline", "new", "namespace", 
+"operator",	"private", "protected", "public", "this", "throw", "try", "template"
+}; 
+
+static String reservedJava[] = {
+"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", 
+"class", "const", "continue", "default", "do", "double", "else", "enum", 
+"extends", "final", "finally", "float", "for", "goto", "if", "implements", 
+"import", "instanceof", "int", "interface", "long", "native", "new", "package", 
+"private", "protected", "public", "return", "short", "static", "strictfp", 
+"super", "switch", "synchronized", "this", "throw", "throws", "transient", 
+"try", "void", "volatile", "while"
+};
+ 
+static String reservedPHP[] = {
+"abstract", "and", "array", "as", "break", "case", "catch", "cfunction", 
+"class", "clone", "const", "continue", "declare", "default", "die", "do", 
+"echo", "else", "elseif", "empty", "enddeclare", "endfor", "endforeach", 
+"endif", "endswitch", "endwhile", "eval", "exception", "exit", "extends", 
+"extends", "final", "for", "foreach", "function", "global", "if", "implements", 
+"include", "include_once", "interface", "isset", "list", "new", "old_function", 
+"or", "php_user_filter", "print", "private", "protected", "public", "require", 
+"require_once", "return", "static", "switch", "this", "throw", "try", "unset", 
+"use", "var", "while", "xor"
+};
+ 
+static SimpleAttributeSet comment;
+static SimpleAttributeSet keyword;
+static SimpleAttributeSet string;
+static SimpleAttributeSet number;
+static SimpleAttributeSet paren;
+static SimpleAttributeSet quoted;
+static SimpleAttributeSet normal;
+
+static String numberPattern = "^-?\\d+$|^-?\\d+\\.\\d+$|^0x[0-9a-fA-F]+$";
+static Pattern compiledPattern;
+
+static StyledDocument doc;
+static String text;
+static String token;
+static Vector topLevels;
+
+static HashSet keys = null;
+
+static HashSet keysC;
+static HashSet keysCPP;
+static HashSet keysJava;
+static HashSet keysPHP;
+
+@SuppressWarnings("unchecked") 
+static public void color(TextPaneWidget widget, int offset, int length)
+	{
+	int parenCount = 0;
+	int curlCount = 0;
+	int startToken;
+	int idx = offset;
+	char chr;
+
+	SyntaxHighlighter.active = true;
+
+
+	doc = widget.styledDoc;
+	topLevels = widget.shTopLevels;
+	
+	normal = new SimpleAttributeSet();
+	StyleConstants.setForeground(normal, widget.foreground);
+	
+	try { text = doc.getText(0, widget.documentLength); } 
+	catch (Exception e) {text = null;} 	
+	
+	//if(keys == null) init();
+	
+	while(idx < length)
+		{
+		chr = text.charAt(idx++);
+		while(chr <= ' ' && idx < length) chr = text.charAt(idx++);
+		switch(chr)
+			{
+			case '#':
+				startToken = idx - 1;
+				while(chr != '\n' && idx < length) chr = text.charAt(idx++);
+				doc.setCharacterAttributes(startToken, idx - startToken, quoted, false);
+				continue;
+			case '{':
+				++parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case '}':
+				--parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				if(parenCount == 0) // top level
+					{
+					topLevels.addElement(offset);
+					offset = idx;
+					}
+				continue;
+			case '(':
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case ')':
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case '"':
+				startToken = idx - 1;
+				while(idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '"') 
+						{
+						doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+						break;
+						}
+					if(chr == '\\')
+						{
+						idx++;
+						continue;
+						}
+					}
+				continue;
+			case '\'':
+				startToken = idx - 1;
+				while(idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '\'') 
+						{
+						doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+						break;
+						}
+					if(chr == '\\')
+						{
+						idx++;
+						continue;
+						}
+					}
+				continue;
+			case '/':
+				startToken = idx - 1;
+				if(text.startsWith("/*", startToken))
+					{
+					idx = text.indexOf("*/", startToken + 2);
+					if(idx < 0) idx = length;
+					else idx = idx + 2;
+					doc.setCharacterAttributes(startToken, idx - startToken, comment, false);
+					}
+				else if(text.startsWith("//", startToken))
+					{
+					while(chr != '\n' && idx < length) chr = text.charAt(idx++);
+					doc.setCharacterAttributes(startToken, idx - startToken, comment, false);
+					}
+				continue;
+			default:
+				startToken = idx - 1;
+				while(chr > ' ' && chr != '(' && chr != ')' && 
+						chr != '\'' && chr != '"' && 
+						chr != ':' && chr != ';' && chr != ',' &&
+						chr != '{' && chr != '}' && chr != '[' && chr != ']' &&
+						idx < length) chr = text.charAt(idx++);
+				token = text.substring(startToken, idx - 1);
+
+				if(keys.contains(token))
+					doc.setCharacterAttributes(startToken, idx - startToken - 1, keyword, false);
+				else
+					{
+					//if(token.matches(numberPattern))
+					if(compiledPattern.matcher(token).matches())
+						doc.setCharacterAttributes(startToken, idx - startToken - 1, number, false);
+					else
+						doc.setCharacterAttributes(startToken, idx - startToken - 1, normal, false);
+					}
+					
+				switch(chr)
+					{
+					case '(':
+					case ')':
+					case '[':
+					case ']':
+						doc.setCharacterAttributes(idx - 1, 1, paren, false);
+						continue;
+					case '{':
+						++parenCount;
+						doc.setCharacterAttributes(idx - 1, 1, paren, false);
+						continue;
+					case '}':
+						--parenCount;
+						doc.setCharacterAttributes(idx - 1, 1, paren, false);
+						if(parenCount == 0) // top level
+							{
+							topLevels.addElement(offset);
+							offset = idx;
+							}
+						continue;
+					case ':':
+					case ';':
+					case ',':
+						doc.setCharacterAttributes(idx - 1, 1, normal, false);
+						continue;
+					case '"':
+					case '\'':
+						--idx;
+						continue;
+					}
+			}
+		}
+		
+	SyntaxHighlighter.active  = false;
+	}
+	
+static void setFlavor(int flavor)
+	{
+	if(keys == null) init();
+	switch(flavor)
+		{
+		case TextPaneWidget.SYNTAX_C:
+			keys = keysC;
+			break;
+		case TextPaneWidget.SYNTAX_CPP:
+			keys = keysCPP;
+			break;
+		case TextPaneWidget.SYNTAX_JAVA:
+			keys = keysJava;
+			break;
+		case TextPaneWidget.SYNTAX_PHP:
+			keys = keysPHP;
+			break;
+		}
+	}
+	
+static void init()
+	{
+	if(keys == null)
+		{
+		keysC = new HashSet();
+		for(int idx = 0; idx < reservedC.length; idx++)
+			keysC.add(reservedC[idx]);
+			
+		keysCPP = new HashSet();
+		for(int idx = 0; idx < reservedC.length; idx++)
+			keysCPP.add(reservedC[idx]);
+		for(int idx = 0; idx < reservedCPP.length; idx++)
+			keysCPP.add(reservedCPP[idx]);
+
+		keysJava = new HashSet();
+		for(int idx = 0; idx < reservedJava.length; idx++)
+			keysJava.add(reservedJava[idx]);
+
+		keysPHP = new HashSet();
+		for(int idx = 0; idx < reservedPHP.length; idx++)
+			keysPHP.add(reservedPHP[idx]);
+			
+		keys = keysC;
+		}
+		
+	compiledPattern = Pattern.compile(numberPattern);
+	
+	comment = new SimpleAttributeSet();
+	StyleConstants.setForeground(comment, SyntaxHighlighter.commentColor);
+	
+	keyword = new SimpleAttributeSet();
+	StyleConstants.setForeground(keyword, SyntaxHighlighter.keywordColor);
+	
+	string = new SimpleAttributeSet();
+	StyleConstants.setForeground(string, SyntaxHighlighter.stringColor);
+	
+	number = new SimpleAttributeSet();
+	StyleConstants.setForeground(number, SyntaxHighlighter.numberColor);
+	
+	quoted = new SimpleAttributeSet();
+	StyleConstants.setForeground(quoted, SyntaxHighlighter.quotedColor);
+	
+	paren = new SimpleAttributeSet();
+	StyleConstants.setForeground(paren, SyntaxHighlighter.parenColor);
+	}	
+}
+
+// eof
diff --git a/guiserver/java/SyntaxHighlighterC.java.bak b/guiserver/java/SyntaxHighlighterC.java.bak
new file mode 100644
index 0000000..c5244cf
--- /dev/null
+++ b/guiserver/java/SyntaxHighlighterC.java.bak
@@ -0,0 +1,315 @@
+//
+//  SyntaxHighlighterC.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 8/4/07.
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.Pattern;
+import javax.swing.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class SyntaxHighlighterC {
+
+static String reservedC[] = {
+"auto", "break", "byte", "case", "char", "const", "continue", "default", "do", 
+"double", "else", "enum", "extern", "float", "for", "goto", "if", "inline", "int", 
+"long", "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", 
+"typedef", "union", "unsigned", "void", "volatil", "while"
+};
+
+static String reservedCPP[] = {
+"bool",	"catch", "class", "delete", "friend", "inline", "new", "namespace", 
+"operator",	"private", "protected", "public", "this", "throw", "try", "template"
+}; 
+
+static String reservedJava[] = {
+"abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", 
+"class", "const", "continue", "default", "do", "double", "else", "enum", 
+"extends", "final", "finally", "float", "for", "goto", "if", "implements", 
+"import", "instanceof", "int", "interface", "long", "native", "new", "package", 
+"private", "protected", "public", "return", "short", "static", "strictfp", 
+"super", "switch", "synchronized", "this", "throw", "throws", "transient", 
+"try", "void", "volatile", "while"
+};
+ 
+static String reservedPHP[] = {
+"abstract", "and", "array", "as", "break", "case", "catch", "cfunction", 
+"class", "clone", "const", "continue", "declare", "default", "die", "do", 
+"echo", "else", "elseif", "empty", "enddeclare", "endfor", "endforeach", 
+"endif", "endswitch", "endwhile", "eval", "exception", "exit", "extends", 
+"extends", "final", "for", "foreach", "function", "global", "if", "implements", 
+"include", "include_once", "interface", "isset", "list", "new", "old_function", 
+"or", "php_user_filter", "print", "private", "protected", "public", "require", 
+"require_once", "return", "static", "switch", "this", "throw", "try", "unset", 
+"use", "var", "while", "xor"
+};
+ 
+static SimpleAttributeSet comment;
+static SimpleAttributeSet keyword;
+static SimpleAttributeSet string;
+static SimpleAttributeSet number;
+static SimpleAttributeSet paren;
+static SimpleAttributeSet quoted;
+static SimpleAttributeSet normal;
+
+static String numberPattern = "^-?\\d+$|^-?\\d+\\.\\d+$|^0x[0-9a-fA-F]+$";
+static Pattern compiledPattern;
+
+static StyledDocument doc;
+static String text;
+static String token;
+static Vector topLevels;
+
+static HashSet keys = null;
+
+static HashSet keysC;
+static HashSet keysCPP;
+static HashSet keysJava;
+static HashSet keysPHP;
+
+@SuppressWarnings("unchecked") 
+static public void color(TextPaneWidget widget, int offset, int length)
+	{
+	int parenCount = 0;
+	int curlCount = 0;
+	int startToken;
+	int idx = offset;
+	char chr;
+
+	SyntaxHighlighter.active = true;
+
+
+	doc = widget.styledDoc;
+	topLevels = widget.shTopLevels;
+	
+	normal = new SimpleAttributeSet();
+	StyleConstants.setForeground(normal, widget.foreground);
+	
+	try { text = doc.getText(0, widget.documentLength); } 
+	catch (Exception e) {text = null;} 	
+	
+	//if(keys == null) init();
+	
+	while(idx < length)
+		{
+		chr = text.charAt(idx++);
+		while(chr <= ' ' && idx < length) chr = text.charAt(idx++);
+		switch(chr)
+			{
+			case '#':
+				startToken = idx - 1;
+				while(chr != '\n' && idx < length) chr = text.charAt(idx++);
+				doc.setCharacterAttributes(startToken, idx - startToken, quoted, false);
+				continue;
+			case '{':
+				++parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case '}':
+				--parenCount;
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				if(parenCount == 0) // top level
+					{
+					topLevels.addElement(offset);
+					offset = idx;
+					}
+				continue;
+			case '(':
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case ')':
+				doc.setCharacterAttributes(idx - 1, 1, paren, false);
+				continue;
+			case '"':
+				startToken = idx - 1;
+				while(idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '"') 
+						{
+						doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+						break;
+						}
+					if(chr == '\\')
+						{
+						idx++;
+						continue;
+						}
+					}
+				continue;
+			case '\'':
+				startToken = idx - 1;
+				while(idx < length)
+					{
+					chr = text.charAt(idx++);
+					if(chr == '\'') 
+						{
+						doc.setCharacterAttributes(startToken, idx - startToken, string, false);
+						break;
+						}
+					if(chr == '\\')
+						{
+						idx++;
+						continue;
+						}
+					}
+				continue;
+			case '/':
+				startToken = idx - 1;
+				if(text.startsWith("/*", startToken))
+					{
+					idx = text.indexOf("*/", startToken + 2);
+					if(idx < 0) idx = length;
+					else idx = idx + 2;
+					doc.setCharacterAttributes(startToken, idx - startToken, comment, false);
+					}
+				else if(text.startsWith("//", startToken))
+					{
+					while(chr != '\n' && idx < length) chr = text.charAt(idx++);
+					doc.setCharacterAttributes(startToken, idx - startToken, comment, false);
+					}
+				continue;
+			default:
+				startToken = idx - 1;
+				while(chr > ' ' && chr != '(' && chr != ')' && 
+						chr != '\'' && chr != '"' && 
+						chr != ':' && chr != ';' && chr != ',' &&
+						chr != '{' && chr != '}' && chr != '[' && chr != ']' &&
+						idx < length) chr = text.charAt(idx++);
+				token = text.substring(startToken, idx - 1);
+
+				if(keys.contains(token))
+					doc.setCharacterAttributes(startToken, idx - startToken - 1, keyword, false);
+				else
+					{
+					//if(token.matches(numberPattern))
+					if(compiledPattern.matcher(token).matches())
+						doc.setCharacterAttributes(startToken, idx - startToken - 1, number, false);
+					else
+						doc.setCharacterAttributes(startToken, idx - startToken - 1, normal, false);
+					}
+					
+				switch(chr)
+					{
+					case '(':
+					case ')':
+					case '[':
+					case ']':
+						doc.setCharacterAttributes(idx - 1, 1, paren, false);
+						continue;
+					case '{':
+						++parenCount;
+						doc.setCharacterAttributes(idx - 1, 1, paren, false);
+						continue;
+					case '}':
+						--parenCount;
+						doc.setCharacterAttributes(idx - 1, 1, paren, false);
+						if(parenCount == 0) // top level
+							{
+							topLevels.addElement(offset);
+							offset = idx;
+							}
+						continue;
+					case ':':
+					case ';':
+					case ',':
+						doc.setCharacterAttributes(idx - 1, 1, normal, false);
+						continue;
+					case '"':
+					case '\'':
+						--idx;
+						continue;
+					}
+			}
+		}
+		
+	SyntaxHighlighter.active  = false;
+	}
+	
+static void setFlavor(int flavor)
+	{
+	if(keys == null) init();
+	switch(flavor)
+		{
+		case TextPaneWidget.SYNTAX_C:
+			keys = keysC;
+			break;
+		case TextPaneWidget.SYNTAX_CPP:
+			keys = keysCPP;
+			break;
+		case TextPaneWidget.SYNTAX_JAVA:
+			keys = keysJava;
+			break;
+		case TextPaneWidget.SYNTAX_PHP:
+			keys = keysPHP;
+			break;
+		}
+	}
+	
+static void init()
+	{
+	if(keys == null)
+		{
+		keysC = new HashSet();
+		for(int idx = 0; idx < reservedC.length; idx++)
+			keysC.add(reservedC[idx]);
+			
+		keysCPP = new HashSet();
+		for(int idx = 0; idx < reservedC.length; idx++)
+			keysCPP.add(reservedC[idx]);
+		for(int idx = 0; idx < reservedCPP.length; idx++)
+			keysCPP.add(reservedCPP[idx]);
+
+		keysJava = new HashSet();
+		for(int idx = 0; idx < reservedJava.length; idx++)
+			keysJava.add(reservedJava[idx]);
+
+		keysPHP = new HashSet();
+		for(int idx = 0; idx < reservedPHP.length; idx++)
+			keysPHP.add(reservedPHP[idx]);
+			
+		keys = keysC;
+		}
+		
+	compiledPattern = Pattern.compile(numberPattern);
+	
+	comment = new SimpleAttributeSet();
+	StyleConstants.setForeground(comment, SyntaxHighlighter.commentColor);
+	
+	keyword = new SimpleAttributeSet();
+	StyleConstants.setForeground(keyword, SyntaxHighlighter.keywordColor);
+	
+	string = new SimpleAttributeSet();
+	StyleConstants.setForeground(string, SyntaxHighlighter.stringColor);
+	
+	number = new SimpleAttributeSet();
+	StyleConstants.setForeground(number, SyntaxHighlighter.numberColor);
+	
+	quoted = new SimpleAttributeSet();
+	StyleConstants.setForeground(quoted, SyntaxHighlighter.quotedColor);
+	
+	paren = new SimpleAttributeSet();
+	StyleConstants.setForeground(paren, SyntaxHighlighter.parenColor);
+	}	
+}
+
+// eof
diff --git a/guiserver/java/TabbedPaneWidget.java b/guiserver/java/TabbedPaneWidget.java
new file mode 100644
index 0000000..466a186
--- /dev/null
+++ b/guiserver/java/TabbedPaneWidget.java
@@ -0,0 +1,196 @@
+//
+//  TabbedPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked")
+public class TabbedPaneWidget extends gsObject {
+
+JTabbedPane tabbedpane;
+HashMap tabsHash;
+
+public TabbedPaneWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	String orientation = params.nextToken();
+	if(orientation.equals("bottom")) tabbedpane = new JTabbedPane(JTabbedPane.BOTTOM);
+	else if(orientation.equals("left")) tabbedpane = new JTabbedPane(JTabbedPane.LEFT);
+	else if (orientation.equals("right")) tabbedpane = new JTabbedPane(JTabbedPane.RIGHT);
+	else tabbedpane = new JTabbedPane(JTabbedPane.TOP);
+	
+	component = tabbedpane;
+	jcomponent = tabbedpane;
+	container = tabbedpane;
+	tabsHash = new HashMap();
+	
+	while(params.hasMoreTokens())
+		{
+		String cid = params.nextToken();
+		gsObject gsobject = (gsObject)gsObject.widgets.get(cid);
+
+		String title = params.nextToken();
+	
+		if(guiserver.UTF8)
+			title = Base64Coder.decodeStringUTF8(title);
+		else
+			title = Base64Coder.decodeString(title);
+
+		tabbedpane.addTab(title, gsobject.component);
+		tabsHash.put(gsobject.component, cid);
+		}
+		
+	gsObject.widgets.put(id, this);
+	//guiserver.widgets.put(id, tabbedpane);
+	
+	ChangeListener changelistener = new ChangeListener() {
+		public void stateChanged(ChangeEvent e)
+			{
+			int index = tabbedpane.getSelectedIndex();
+			String title = tabbedpane.getTitleAt(index);
+
+			if(guiserver.UTF8 && title.length() != 0)
+				title = Base64Coder.encodeStringUTF8(title);
+			else
+				title = Base64Coder.encodeString(title);
+
+			//Component cmpnt = tabbedpane.getComponentAt(index);
+			//Object obj = cmpnt;
+			//gsObject gso = (gsObject)obj;
+	
+			String cid = (String)tabsHash.get(tabbedpane.getComponentAt(index));
+			
+			guiserver.out.println("("+ action + " \"" + id +  "\" \"" + cid + "\" \"" + title + "\" " + index + ")");
+			guiserver.out.flush();
+			}
+		};
+		
+	tabbedpane.addChangeListener(changelistener);
+	}
+	
+
+public void insertTab(StringTokenizer tokens)
+	{
+	String scomp = tokens.nextToken();
+	
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	int index = 0;
+	ImageIcon icon = null;
+	
+	if(tokens.hasMoreTokens())
+		index = Integer.parseInt(tokens.nextToken());
+		
+	if(tokens.hasMoreTokens())
+		icon = guiserver.getIconFromPath(Base64Coder.decodeString(tokens.nextToken()), this.getClass());
+		
+	if(index > tabbedpane.getTabCount()) 
+		index = tabbedpane.getTabCount();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(scomp);
+	Component comp = gsobject.component;
+	
+	tabbedpane.insertTab(text, icon, comp, null, index);
+	tabsHash.put(comp, gsobject.id);
+	}
+
+public void removeTab(StringTokenizer tokens)
+	{
+	int index = 0;
+	int tcount = tabbedpane.getTabCount();
+	
+	if(tcount == 1) return;
+	
+	if(tokens.hasMoreTokens())
+		index = Integer.parseInt(tokens.nextToken());
+
+	
+	if(index >= tcount) 
+		index = tcount - 1;
+	if(index < 0) index = 0;
+		
+	Component comp = tabbedpane.getComponentAt(index);
+	tabsHash.remove(comp);
+
+	try { tabbedpane.removeTabAt(index); } catch (IndexOutOfBoundsException ex) {}
+	}
+		
+
+public void setIcon(StringTokenizer tokens)
+	{
+	ImageIcon icon = guiserver.getIconFromPath(Base64Coder.decodeString(tokens.nextToken()), this.getClass());
+	
+	int index = Integer.parseInt(tokens.nextToken());
+
+	if(index >= tabbedpane.getTabCount())
+		index = tabbedpane.getTabCount() - 1;
+	if(index < 0) index = 0;
+	
+	tabbedpane.setIconAt(index, icon);
+	}
+	
+public void setText(StringTokenizer tokens)
+	{
+	String title = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		title = Base64Coder.decodeStringUTF8(title);
+	else
+		title = Base64Coder.decodeString(title);
+
+	int index = Integer.parseInt(tokens.nextToken());
+
+	if(index >= tabbedpane.getTabCount())
+		index = tabbedpane.getTabCount() - 1;
+	if(index < 0) index = 0;
+	
+	tabbedpane.setTitleAt(index, title);
+	}
+	
+	
+public void requestFocus(StringTokenizer tokens)
+	{
+	int index = Integer.parseInt(tokens.nextToken());
+	
+	if(index >= tabbedpane.getTabCount()) 
+		index = tabbedpane.getTabCount() - 1;
+	if(index < 0) index = 0;
+	
+	tabbedpane.setSelectedIndex(index);
+	}
+		
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/TabbedPaneWidget.java.bak b/guiserver/java/TabbedPaneWidget.java.bak
new file mode 100644
index 0000000..74f78c2
--- /dev/null
+++ b/guiserver/java/TabbedPaneWidget.java.bak
@@ -0,0 +1,196 @@
+//
+//  TabbedPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/17/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked")
+public class TabbedPaneWidget extends gsObject {
+
+JTabbedPane tabbedpane;
+HashMap tabsHash;
+
+public TabbedPaneWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	String orientation = params.nextToken();
+	if(orientation.equals("bottom")) tabbedpane = new JTabbedPane(JTabbedPane.BOTTOM);
+	else if(orientation.equals("left")) tabbedpane = new JTabbedPane(JTabbedPane.LEFT);
+	else if (orientation.equals("right")) tabbedpane = new JTabbedPane(JTabbedPane.RIGHT);
+	else tabbedpane = new JTabbedPane(JTabbedPane.TOP);
+	
+	component = tabbedpane;
+	jcomponent = tabbedpane;
+	container = tabbedpane;
+	tabsHash = new HashMap();
+	
+	while(params.hasMoreTokens())
+		{
+		String cid = params.nextToken();
+		gsObject gsobject = (gsObject)gsObject.widgets.get(cid);
+
+		String title = params.nextToken();
+	
+		if(guiserver.UTF8)
+			title = Base64Coder.decodeStringUTF8(title);
+		else
+			title = Base64Coder.decodeString(title);
+
+		tabbedpane.addTab(title, gsobject.component);
+		tabsHash.put(gsobject.component, cid);
+		}
+		
+	gsObject.widgets.put(id, this);
+	//guiserver.widgets.put(id, tabbedpane);
+	
+	ChangeListener changelistener = new ChangeListener() {
+		public void stateChanged(ChangeEvent e)
+			{
+			int index = tabbedpane.getSelectedIndex();
+			String title = tabbedpane.getTitleAt(index);
+
+			if(guiserver.UTF8 && title.length() != 0)
+				title = Base64Coder.encodeStringUTF8(title);
+			else
+				title = Base64Coder.encodeString(title);
+
+			//Component cmpnt = tabbedpane.getComponentAt(index);
+			//Object obj = cmpnt;
+			//gsObject gso = (gsObject)obj;
+	
+			String cid = (String)tabsHash.get(tabbedpane.getComponentAt(index));
+			
+			guiserver.out.println("("+ action + " \"" + id +  "\" \"" + cid + "\" \"" + title + "\" " + index + ")");
+			guiserver.out.flush();
+			}
+		};
+		
+	tabbedpane.addChangeListener(changelistener);
+	}
+	
+
+public void insertTab(StringTokenizer tokens)
+	{
+	String scomp = tokens.nextToken();
+	
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	int index = 0;
+	ImageIcon icon = null;
+	
+	if(tokens.hasMoreTokens())
+		index = Integer.parseInt(tokens.nextToken());
+		
+	if(tokens.hasMoreTokens())
+		icon = guiserver.getIconFromPath(Base64Coder.decodeString(tokens.nextToken()), this.getClass());
+		
+	if(index > tabbedpane.getTabCount()) 
+		index = tabbedpane.getTabCount();
+	
+	gsObject gsobject = (gsObject)gsObject.widgets.get(scomp);
+	Component comp = gsobject.component;
+	
+	tabbedpane.insertTab(text, icon, comp, null, index);
+	tabsHash.put(comp, gsobject.id);
+	}
+
+public void removeTab(StringTokenizer tokens)
+	{
+	int index = 0;
+	int tcount = tabbedpane.getTabCount();
+	
+	if(tcount == 1) return;
+	
+	if(tokens.hasMoreTokens())
+		index = Integer.parseInt(tokens.nextToken());
+
+	
+	if(index >= tcount) 
+		index = tcount - 1;
+	if(index < 0) index = 0;
+		
+	Component comp = tabbedpane.getComponentAt(index);
+	tabsHash.remove(comp);
+
+	try { tabbedpane.removeTabAt(index); } catch (IndexOutOfBoundsException ex) {}
+	}
+		
+
+public void setIcon(StringTokenizer tokens)
+	{
+	ImageIcon icon = guiserver.getIconFromPath(Base64Coder.decodeString(tokens.nextToken()), this.getClass());
+	
+	int index = Integer.parseInt(tokens.nextToken());
+
+	if(index >= tabbedpane.getTabCount())
+		index = tabbedpane.getTabCount() - 1;
+	if(index < 0) index = 0;
+	
+	tabbedpane.setIconAt(index, icon);
+	}
+	
+public void setText(StringTokenizer tokens)
+	{
+	String title = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		title = Base64Coder.decodeStringUTF8(title);
+	else
+		title = Base64Coder.decodeString(title);
+
+	int index = Integer.parseInt(tokens.nextToken());
+
+	if(index >= tabbedpane.getTabCount())
+		index = tabbedpane.getTabCount() - 1;
+	if(index < 0) index = 0;
+	
+	tabbedpane.setTitleAt(index, title);
+	}
+	
+	
+public void requestFocus(StringTokenizer tokens)
+	{
+	int index = Integer.parseInt(tokens.nextToken());
+	
+	if(index >= tabbedpane.getTabCount()) 
+		index = tabbedpane.getTabCount() - 1;
+	if(index < 0) index = 0;
+	
+	tabbedpane.setSelectedIndex(index);
+	}
+		
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/TableWidget.java b/guiserver/java/TableWidget.java
new file mode 100644
index 0000000..928fe98
--- /dev/null
+++ b/guiserver/java/TableWidget.java
@@ -0,0 +1,414 @@
+//
+// TableWidget.java
+//
+//  Created by Unya (see http://newlispfanclub.alh.net/forum/)
+//  Functions for row and column removal by Ferry de Bruin (FdB)
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.table.*;
+import javax.swing.table.DefaultTableModel;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+import java.util.Enumeration;
+
+class LineNumberTable extends JTable
+{
+	public static final long serialVersionUID = 1L;
+	private JTable mainTable;
+ 
+	public LineNumberTable(JTable table)
+	{
+	super();
+	mainTable = table;
+	setAutoCreateColumnsFromModel( false );
+	setModel( mainTable.getModel() );
+	setSelectionModel( mainTable.getSelectionModel() );
+	setAutoscrolls( false );
+ 
+	addColumn( new TableColumn() );
+	getColumnModel().getColumn(0).setCellRenderer( mainTable.getTableHeader().getDefaultRenderer() );
+	getColumnModel().getColumn(0).setPreferredWidth(50);
+	setPreferredScrollableViewportSize(getPreferredSize());
+	}
+
+	public boolean isCellEditable(int row, int column) {
+	return false;
+	}
+ 
+	public int getRowCount() {
+		return mainTable.getRowCount() ;
+	}
+
+	public Object getValueAt(int row, int column) {
+	return new Integer(row + 1);
+	}
+ 
+	public int getRowHeight(int row) {
+	return mainTable.getRowHeight();
+	}
+}
+
+@SuppressWarnings("unchecked")
+public class TableWidget extends gsObject {
+	JScrollPane scrollpane;
+	Vector columnNames ;
+	DefaultTableModel tableModel;
+	JTable mainTable ;
+	JTable table ;
+	TableColumnModel columnModel ;
+	int lastSelectCellRow = -1 ;
+	int lastSelectCellCol = -1 ;
+
+	public TableWidget(StringTokenizer params) {
+	id = params.nextToken() ;
+	action = params.nextToken() ;
+
+	columnModel = new DefaultTableColumnModel() {
+		public static final long serialVersionUID = 1L;
+		boolean first = true;
+
+		public int getRowCount() {
+			TableModel tm = table.getModel() ;
+			return tm.getRowCount() ;
+			}
+
+		public void addColumn(TableColumn tableColumn) {
+			if (first) {
+				tableColumn.setMaxWidth(tableColumn.getPreferredWidth());
+				super.addColumn(tableColumn);
+				tableColumn.setMaxWidth(40);
+
+				DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
+				renderer.setHorizontalAlignment(JLabel.RIGHT) ;
+				tableColumn.setCellRenderer(renderer) ;
+
+				first = false;
+				}
+			}
+		};
+
+	columnNames = makeColumns(params) ;
+
+	tableModel = new DefaultTableModel(columnNames, 0);
+
+	mainTable = new JTable(tableModel);
+
+	table = new LineNumberTable(mainTable) ;
+
+	JScrollPane jsp = new JScrollPane(mainTable);
+	jsp.setRowHeaderView(null) ;
+	jsp.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED) ;
+	//jsp.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+
+	component = jsp ;
+	container = jsp ;
+	jcomponent = jsp ;
+	scrollpane = jsp ;
+
+	mainTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+	mainTable.setCellSelectionEnabled(true);
+
+	mainTable.setShowGrid(true);
+	mainTable.setGridColor(Color.lightGray);
+	table.setShowGrid(true);
+	table.setGridColor(Color.lightGray);
+
+	// row selection change
+	mainTable.getSelectionModel().addListSelectionListener(new cellSelectListener());
+	// column selection change
+	mainTable.getColumnModel().getSelectionModel().addListSelectionListener(new cellSelectListener());
+
+	//mainTable.getModel().addTableModelListener(new TableChangeListener()) ;
+
+	gsObject.widgets.put(id, this);
+	}
+
+	private class cellSelectListener implements ListSelectionListener {
+	  public void valueChanged(ListSelectionEvent event) {
+		if (event.getValueIsAdjusting()) {
+			// The mouse button has not yet been released
+			return;
+			}
+		
+		int row = mainTable.getSelectionModel().getLeadSelectionIndex() ;
+		int col = mainTable.getColumnModel().getSelectionModel().getLeadSelectionIndex() ;
+
+		Object data = "===="; // base 64 for empty string
+
+		if(row < 0 || col < 0) return;
+
+		if (lastSelectCellRow == row && lastSelectCellCol == col) { return ; }
+
+		lastSelectCellRow = row ;
+		lastSelectCellCol = col ;
+
+		data = getCell(row, col);
+		if (action != null) {
+			String text = String.format("(%s \"%s\" %d %d (base64-dec [text]%s[/text]))", 
+				action, id , row, col, data) ;
+			guiserver.out.println(text) ;
+			guiserver.out.flush() ;
+			}	
+		}
+	}
+
+/*
+	private class TableChangeListener implements TableModelListener {
+	public void tableChanged(TableModelEvent e) {
+		switch (e.getType()) {
+			case TableModelEvent.INSERT :
+			case TableModelEvent.UPDATE :
+				int tableRows = mainTable.getRowCount() ;
+				int tableCols = mainTable.getColumnCount() ;
+
+				if (action != null) {
+					String text = String.format("(%s \"%s\" %d %d )", 
+						action, id, tableRows, tableCols) ;
+					guiserver.out.println(text) ;
+					guiserver.out.flush() ;
+
+					// debug
+					System.out.println("guiserver tablechanged listener " + text) ;
+					}
+				break ;
+			default :
+				break ;
+			}
+		}
+	}
+*/
+
+	String getCell(int row, int col) {
+		Object value  = null;
+		int tableRows = mainTable.getRowCount() ;
+		int tableCols = mainTable.getColumnCount() ;
+		String text ;
+
+		if (row >= 0 && col >= 0 && row < tableRows && col < tableCols)
+			value = mainTable.getValueAt(row, col) ;
+
+		if (value == null) value = "" ;
+
+
+		if (guiserver.UTF8)
+			text = Base64Coder.encodeStringUTF8(value.toString()) ;
+		else
+			text = Base64Coder.encodeString(value.toString()) ;
+
+		return text ;
+	}
+
+	// (gs:table-set-cell ID row col Value)
+	public void tableSetCell(StringTokenizer params) {
+		int row = Integer.parseInt(params.nextToken()) ;
+		int col = Integer.parseInt(params.nextToken()) ;
+		String value = Base64Coder.decodeString(params.nextToken()) ;
+		String oldvalue = "====";
+
+		int tableRows = mainTable.getRowCount() ;
+		int tableCols = mainTable.getColumnCount() ;
+
+		if (row >= 0 && col >= 0 && row < tableRows && col < tableCols)
+			{
+			oldvalue = getCell(row, col) ;
+
+			DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+			tm.setValueAt(value, row, col) ;
+			}
+
+		String text = "(set 'gs:table-cell (base64-dec [text]" + oldvalue + "[/text]))" ;
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-get-cell ID row col)
+	public void tableGetCell(StringTokenizer params) {
+		int row = Integer.parseInt(params.nextToken()) ;
+		int col = Integer.parseInt(params.nextToken()) ;
+		String value ;
+		String text ;
+
+		value = getCell(row, col) ;
+
+		text = "(set 'gs:table-cell (base64-dec [text]" + value + "[/text]))" ;
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-get ID)
+	public void tableGetValueAll(StringTokenizer params) {
+		int tableRows = mainTable.getRowCount() ;
+		int tableCols = mainTable.getColumnCount() ;
+
+		String text = "(set 'gs:table-full '(";
+		for(int row = 0 ; row < tableRows ; row++) {
+			text += "(" ;
+			for(int col = 0 ; col < tableCols ; col++) {
+				text += "[text]" + getCell(row, col) + "[/text] " ;
+				}
+			text += ") " ;
+		}
+		text += ") )" ;
+
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-size ID)
+	public void tableGetSize(StringTokenizer params) {
+		String text = String.format("(set 'gs:table-size '(%d %d))"
+				    , mainTable.getRowCount()
+				    , mainTable.getColumnCount()) ;
+
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-add-row ID)
+	// (gs:table-add-row ID ColumnValue0 ColumnValue1 ...)
+	public void tableAddRow(StringTokenizer params) {
+		Vector v = params2vector(params) ;
+
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.addRow(v) ;
+	}
+	
+	//FdB
+	// (gs:table-remove-row ID row)
+	public void tableRemoveRow(StringTokenizer params) {
+		int row = Integer.parseInt(params.nextToken()) ;
+		
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.removeRow(row) ;
+	}
+	
+	//FdB
+	// (gs:table-set-row-count ID row)
+	public void tableSetRowCount(StringTokenizer params) {
+		int count = Integer.parseInt(params.nextToken()) ;
+		
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.setRowCount(count) ;
+	}
+		
+	//FdB
+	// (gs:table-set-column-name ID)
+	// (gs:table-set-column-name ID ColumnName ColumnName ...)
+	public void tableSetColumnIdentifiers(StringTokenizer params) {
+		Vector v = params2vector(params) ;
+		
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.setColumnIdentifiers(v) ;
+	}
+
+	// (gs:table-add-column ID)
+	// (gs:table-add-column ID ColumnName0 ColumnName1 ...)
+	public void tableAddColumn(StringTokenizer params) {
+		while(params.hasMoreTokens()) {
+			String token = params.nextToken() ;
+			String name ;
+
+			if (guiserver.UTF8)
+				name = Base64Coder.decodeStringUTF8(token) ;
+			else
+				name = Base64Coder.decodeString(token) ;
+
+// outcommented for 10.5.7 GS v.1.51, allows to do headerless tables
+//			if (name.length() == 0)
+//				name = String.format("%d", mainTable.getColumnCount() + 1) ;
+			DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+			tm.addColumn(name);
+		}
+	}
+
+	// (gs:table-column ID ColumnNumber Width)
+	// (gs:table-column ID ColumnNumber Width Justification)
+	// Justification : "left"(default) "center" "right"
+	public void tableSetColumn(StringTokenizer params) {
+		int colNumber = Integer.parseInt(params.nextToken()) ;
+		int colWidth = Integer.parseInt(params.nextToken()) ;
+
+		mainTable.getColumnModel().getColumn(colNumber).setPreferredWidth(colWidth) ;
+
+		if (params.hasMoreTokens()) {
+			String strJust = params.nextToken() ;
+
+			DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
+
+			if (strJust.equals("center"))
+				renderer.setHorizontalAlignment(JLabel.CENTER) ;
+			else if (strJust.equals("right"))
+				renderer.setHorizontalAlignment(JLabel.RIGHT) ;
+			else
+				renderer.setHorizontalAlignment(JLabel.LEFT) ;
+
+			mainTable.getColumnModel().getColumn(colNumber).setCellRenderer(renderer) ;
+		}
+	}
+
+	public void tableShowRowNumber(StringTokenizer params) {
+		boolean bHeader = params.nextToken().equals("true") ;
+
+		if (bHeader)
+			scrollpane.setRowHeaderView(table) ;
+		else
+			scrollpane.setRowHeaderView(null) ;
+
+		/*
+		boolean bScrollbar = params.nextToken().equals("true") ;
+		if (bScrollbar)
+			scrollpane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED) ;
+		else
+			scrollpane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER) ;
+		*/
+	}
+
+	Vector makeColumns(StringTokenizer params) {
+		Vector v = params2vector(params) ;
+
+		if (v.isEmpty())
+			v.add("column 0") ;
+		return v ;
+	}
+
+	Vector params2vector(StringTokenizer params) {
+		Vector v = new Vector() ;
+
+		while(params.hasMoreTokens()) {
+			String token = params.nextToken() ;
+			String value ;
+			if (guiserver.UTF8)
+				value = Base64Coder.decodeStringUTF8(token) ;
+			else
+				value = Base64Coder.decodeString(token) ;
+
+			v.add(value) ;
+			}
+		return v ;
+	}
+
+}
+
+// eof
diff --git a/guiserver/java/TableWidget.java.bak b/guiserver/java/TableWidget.java.bak
new file mode 100644
index 0000000..230195e
--- /dev/null
+++ b/guiserver/java/TableWidget.java.bak
@@ -0,0 +1,414 @@
+//
+// TableWidget.java
+//
+//  Created by Unya (see http://newlispfanclub.alh.net/forum/)
+//  Functions for row and column removal by Ferry de Bruin (FdB)
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.table.*;
+import javax.swing.table.DefaultTableModel;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+import java.util.Enumeration;
+
+class LineNumberTable extends JTable
+{
+	public static final long serialVersionUID = 1L;
+	private JTable mainTable;
+ 
+	public LineNumberTable(JTable table)
+	{
+	super();
+	mainTable = table;
+	setAutoCreateColumnsFromModel( false );
+	setModel( mainTable.getModel() );
+	setSelectionModel( mainTable.getSelectionModel() );
+	setAutoscrolls( false );
+ 
+	addColumn( new TableColumn() );
+	getColumnModel().getColumn(0).setCellRenderer( mainTable.getTableHeader().getDefaultRenderer() );
+	getColumnModel().getColumn(0).setPreferredWidth(50);
+	setPreferredScrollableViewportSize(getPreferredSize());
+	}
+
+	public boolean isCellEditable(int row, int column) {
+	return false;
+	}
+ 
+	public int getRowCount() {
+		return mainTable.getRowCount() ;
+	}
+
+	public Object getValueAt(int row, int column) {
+	return new Integer(row + 1);
+	}
+ 
+	public int getRowHeight(int row) {
+	return mainTable.getRowHeight();
+	}
+}
+
+@SuppressWarnings("unchecked")
+public class TableWidget extends gsObject {
+	JScrollPane scrollpane;
+	Vector columnNames ;
+	DefaultTableModel tableModel;
+	JTable mainTable ;
+	JTable table ;
+	TableColumnModel columnModel ;
+	int lastSelectCellRow = -1 ;
+	int lastSelectCellCol = -1 ;
+
+	public TableWidget(StringTokenizer params) {
+	id = params.nextToken() ;
+	action = params.nextToken() ;
+
+	columnModel = new DefaultTableColumnModel() {
+		public static final long serialVersionUID = 1L;
+		boolean first = true;
+
+		public int getRowCount() {
+			TableModel tm = table.getModel() ;
+			return tm.getRowCount() ;
+			}
+
+		public void addColumn(TableColumn tableColumn) {
+			if (first) {
+				tableColumn.setMaxWidth(tableColumn.getPreferredWidth());
+				super.addColumn(tableColumn);
+				tableColumn.setMaxWidth(40);
+
+				DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
+				renderer.setHorizontalAlignment(JLabel.RIGHT) ;
+				tableColumn.setCellRenderer(renderer) ;
+
+				first = false;
+				}
+			}
+		};
+
+	columnNames = makeColumns(params) ;
+
+	tableModel = new DefaultTableModel(columnNames, 0);
+
+	mainTable = new JTable(tableModel);
+
+	table = new LineNumberTable(mainTable) ;
+
+	JScrollPane jsp = new JScrollPane(mainTable);
+	jsp.setRowHeaderView(null) ;
+	jsp.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED) ;
+	//jsp.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+
+	component = jsp ;
+	container = jsp ;
+	jcomponent = jsp ;
+	scrollpane = jsp ;
+
+	mainTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+	mainTable.setCellSelectionEnabled(true);
+
+	mainTable.setShowGrid(true);
+	mainTable.setGridColor(Color.lightGray);
+	table.setShowGrid(true);
+	table.setGridColor(Color.lightGray);
+
+	// row selection change
+	mainTable.getSelectionModel().addListSelectionListener(new cellSelectListener());
+	// column selection change
+	mainTable.getColumnModel().getSelectionModel().addListSelectionListener(new cellSelectListener());
+
+	//mainTable.getModel().addTableModelListener(new TableChangeListener()) ;
+
+	gsObject.widgets.put(id, this);
+	}
+
+	private class cellSelectListener implements ListSelectionListener {
+	  public void valueChanged(ListSelectionEvent event) {
+		if (event.getValueIsAdjusting()) {
+			// The mouse button has not yet been released
+			return;
+			}
+		
+		int row = mainTable.getSelectionModel().getLeadSelectionIndex() ;
+		int col = mainTable.getColumnModel().getSelectionModel().getLeadSelectionIndex() ;
+
+		Object data = "===="; // base 64 for empty string
+
+		if(row < 0 || col < 0) return;
+
+		if (lastSelectCellRow == row && lastSelectCellCol == col) { return ; }
+
+		lastSelectCellRow = row ;
+		lastSelectCellCol = col ;
+
+		data = getCell(row, col);
+		if (action != null) {
+			String text = String.format("(%s \"%s\" %d %d (base64-dec [text]%s[/text]))", 
+				action, id , row, col, data) ;
+			guiserver.out.println(text) ;
+			guiserver.out.flush() ;
+			}	
+		}
+	}
+
+/*
+	private class TableChangeListener implements TableModelListener {
+	public void tableChanged(TableModelEvent e) {
+		switch (e.getType()) {
+			case TableModelEvent.INSERT :
+			case TableModelEvent.UPDATE :
+				int tableRows = mainTable.getRowCount() ;
+				int tableCols = mainTable.getColumnCount() ;
+
+				if (action != null) {
+					String text = String.format("(%s \"%s\" %d %d )", 
+						action, id, tableRows, tableCols) ;
+					guiserver.out.println(text) ;
+					guiserver.out.flush() ;
+
+					// debug
+					System.out.println("guiserver tablechanged listener " + text) ;
+					}
+				break ;
+			default :
+				break ;
+			}
+		}
+	}
+*/
+
+	String getCell(int row, int col) {
+		Object value  = null;
+		int tableRows = mainTable.getRowCount() ;
+		int tableCols = mainTable.getColumnCount() ;
+		String text ;
+
+		if (row >= 0 && col >= 0 && row < tableRows && col < tableCols)
+			value = mainTable.getValueAt(row, col) ;
+
+		if (value == null) value = "" ;
+
+
+		if (guiserver.UTF8)
+			text = Base64Coder.encodeStringUTF8(value.toString()) ;
+		else
+			text = Base64Coder.encodeString(value.toString()) ;
+
+		return text ;
+	}
+
+	// (gs:table-set-cell ID row col Value)
+	public void tableSetCell(StringTokenizer params) {
+		int row = Integer.parseInt(params.nextToken()) ;
+		int col = Integer.parseInt(params.nextToken()) ;
+		String value = Base64Coder.decodeString(params.nextToken()) ;
+		String oldvalue = "====";
+
+		int tableRows = mainTable.getRowCount() ;
+		int tableCols = mainTable.getColumnCount() ;
+
+		if (row >= 0 && col >= 0 && row < tableRows && col < tableCols)
+			{
+			oldvalue = getCell(row, col) ;
+
+			DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+			tm.setValueAt(value, row, col) ;
+			}
+
+		String text = "(set 'gs:table-cell (base64-dec [text]" + oldvalue + "[/text]))" ;
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-get-cell ID row col)
+	public void tableGetCell(StringTokenizer params) {
+		int row = Integer.parseInt(params.nextToken()) ;
+		int col = Integer.parseInt(params.nextToken()) ;
+		String value ;
+		String text ;
+
+		value = getCell(row, col) ;
+
+		text = "(set 'gs:table-cell (base64-dec [text]" + value + "[/text]))" ;
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-get ID)
+	public void tableGetValueAll(StringTokenizer params) {
+		int tableRows = mainTable.getRowCount() ;
+		int tableCols = mainTable.getColumnCount() ;
+
+		String text = "(set 'gs:table-full '(";
+		for(int row = 0 ; row < tableRows ; row++) {
+			text += "(" ;
+			for(int col = 0 ; col < tableCols ; col++) {
+				text += "[text]" + getCell(row, col) + "[/text] " ;
+				}
+			text += ") " ;
+		}
+		text += ") )" ;
+
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-size ID)
+	public void tableGetSize(StringTokenizer params) {
+		String text = String.format("(set 'gs:table-size '(%d %d))"
+				    , mainTable.getRowCount()
+				    , mainTable.getColumnCount()) ;
+
+		guiserver.out.println(text) ;
+		guiserver.out.flush();
+	}
+
+	// (gs:table-add-row ID)
+	// (gs:table-add-row ID ColumnValue0 ColumnValue1 ...)
+	public void tableAddRow(StringTokenizer params) {
+		Vector v = params2vector(params) ;
+
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.addRow(v) ;
+	}
+	
+	//FdB
+	// (gs:table-remove-row ID row)
+	public void tableRemoveRow(StringTokenizer params) {
+		int row = Integer.parseInt(params.nextToken()) ;
+		
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.removeRow(row) ;
+	}
+	
+	//FdB
+	// (gs:table-set-row-count ID row)
+	public void tableSetRowCount(StringTokenizer params) {
+		int count = Integer.parseInt(params.nextToken()) ;
+		
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.setRowCount(count) ;
+	}
+		
+	//FdB
+	// (gs:table-set-column-name ID)
+	// (gs:table-set-column-name ID ColumnName ColumnName ...)
+	public void tableSetColumnIdentifiers(StringTokenizer params) {
+		Vector v = params2vector(params) ;
+		
+		DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+		tm.setColumnIdentifiers(v) ;
+	}
+
+	// (gs:table-add-column ID)
+	// (gs:table-add-column ID ColumnName0 ColumnName1 ...)
+	public void tableAddColumn(StringTokenizer params) {
+		while(params.hasMoreTokens()) {
+			String token = params.nextToken() ;
+			String name ;
+
+			if (guiserver.UTF8)
+				name = Base64Coder.decodeStringUTF8(token) ;
+			else
+				name = Base64Coder.decodeString(token) ;
+
+// outcommented for 10.5.7 GS v.1.51, allows to do headerless tables
+//			if (name.length() == 0)
+//				name = String.format("%d", mainTable.getColumnCount() + 1) ;
+			DefaultTableModel tm = (DefaultTableModel)(mainTable.getModel()) ;
+			tm.addColumn(name);
+		}
+	}
+
+	// (gs:table-column ID ColumnNumber Width)
+	// (gs:table-column ID ColumnNumber Width Justification)
+	// Justification : "left"(default) "center" "right"
+	public void tableSetColumn(StringTokenizer params) {
+		int colNumber = Integer.parseInt(params.nextToken()) ;
+		int colWidth = Integer.parseInt(params.nextToken()) ;
+
+		mainTable.getColumnModel().getColumn(colNumber).setPreferredWidth(colWidth) ;
+
+		if (params.hasMoreTokens()) {
+			String strJust = params.nextToken() ;
+
+			DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
+
+			if (strJust.equals("center"))
+				renderer.setHorizontalAlignment(JLabel.CENTER) ;
+			else if (strJust.equals("right"))
+				renderer.setHorizontalAlignment(JLabel.RIGHT) ;
+			else
+				renderer.setHorizontalAlignment(JLabel.LEFT) ;
+
+			mainTable.getColumnModel().getColumn(colNumber).setCellRenderer(renderer) ;
+		}
+	}
+
+	public void tableShowRowNumber(StringTokenizer params) {
+		boolean bHeader = params.nextToken().equals("true") ;
+
+		if (bHeader)
+			scrollpane.setRowHeaderView(table) ;
+		else
+			scrollpane.setRowHeaderView(null) ;
+
+		/*
+		boolean bScrollbar = params.nextToken().equals("true") ;
+		if (bScrollbar)
+			scrollpane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED) ;
+		else
+			scrollpane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER) ;
+		*/
+	}
+
+	Vector makeColumns(StringTokenizer params) {
+		Vector v = params2vector(params) ;
+
+		if (v.isEmpty())
+			v.add("column 0") ;
+		return v ;
+	}
+
+	Vector params2vector(StringTokenizer params) {
+		Vector v = new Vector() ;
+
+		while(params.hasMoreTokens()) {
+			String token = params.nextToken() ;
+			String value ;
+			if (guiserver.UTF8)
+				value = Base64Coder.decodeStringUTF8(token) ;
+			else
+				value = Base64Coder.decodeString(token) ;
+
+			v.add(value) ;
+			}
+		return v ;
+	}
+
+}
+
+// eof
diff --git a/guiserver/java/TextAreaWidget.java b/guiserver/java/TextAreaWidget.java
new file mode 100644
index 0000000..78667ff
--- /dev/null
+++ b/guiserver/java/TextAreaWidget.java
@@ -0,0 +1,416 @@
+//
+//  TextAreaWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/16/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.event.ActionEvent;
+import java.util.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.text.*;
+
+
+@SuppressWarnings("unchecked")
+public class TextAreaWidget extends aTextWidget {
+
+JTextArea textArea;
+int lastCharCode = 65535;
+int lastDot = 0;
+Process process = null;
+BufferedWriter stdOut;
+BufferedReader stdInput;
+BufferedReader stdError;
+String command = "";
+int historyIndex = 0;
+Vector history;
+String lastShellCommand;
+String lastShellArgs;
+String commandBatch = "";
+boolean isInBatch = false;
+
+public TextAreaWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	textArea = new JTextArea();
+	textArea.setFont(new Font("SansSerif", Font.PLAIN, 12));
+	textArea.setLineWrap(true);
+    textArea.setWrapStyleWord(true);
+	
+    areaScrollPane = new JScrollPane(textArea);
+    areaScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+	
+	container = areaScrollPane;
+	jcomponent = textArea;
+	component = areaScrollPane;
+	textcomp = textArea;
+	isScrollable = true;
+
+	if(params.hasMoreTokens())
+		areaScrollPane.setPreferredSize(
+			new Dimension(Integer.parseInt(params.nextToken()),Integer.parseInt(params.nextToken())));
+		
+	gsObject.widgets.put(id, this);
+		
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyPressed(KeyEvent e)
+			{
+			Character chr = new Character(e.getKeyChar());
+			lastCharCode = chr.hashCode();
+			
+			if(process != null)
+				{
+				if(lastCharCode == 12) // formfeed Ctrl-L
+					{
+					textArea.setText("");
+					lastDot = 0;
+					try {
+						stdOut.write(10);
+						stdOut.flush();
+						}
+					catch (IOException ioex) { System.out.println("clear screen:" + ioex); };	
+					}
+				}				
+			}
+		};
+		
+	CaretListener caretListener = new CaretListener() {
+		public void caretUpdate(CaretEvent ce)
+			{
+			int mark = ce.getMark();
+			int dot = ce.getDot();
+			guiserver.out.println("(" + action + " \"" + id + "\" " + lastCharCode + " " + dot + " " + mark + ")");
+			guiserver.out.flush();
+			lastCharCode = 65535;
+			//System.out.println(":" + lastDot);
+			}
+		};
+		
+	textArea.addCaretListener(caretListener);
+	textArea.addKeyListener(keyListener);
+	}
+
+public void setTabSize(StringTokenizer tokens)
+	{
+	textArea.setTabSize(Integer.parseInt(tokens.nextToken()));
+	}	
+
+public void clearText(StringTokenizer params)
+	{
+	textcomp.setText("");
+	lastCharCode = 65535;
+	lastDot = 0;
+	if(process != null)
+		try {
+			stdOut.write(10);
+			stdOut.flush();
+			}
+		catch (IOException ioex) { System.out.println("clear screen:" + ioex); };
+	}
+
+
+public void runShell(StringTokenizer tokens)
+	{
+	String command;
+    String args;
+	
+	if(tokens == null)
+		{
+		command = lastShellCommand;
+        args = lastShellArgs;
+		}
+	else
+		{
+		command = Base64Coder.decodeString(tokens.nextToken());
+		lastShellCommand = command;
+        args = Base64Coder.decodeString(tokens.nextToken());
+        lastShellArgs = args;
+		}
+	
+	history = new Vector();
+	historyIndex = 0;
+	commandBatch = "";
+	isInBatch = false;
+
+	if(process != null)
+		process.destroy();
+		
+	InputMap im = textArea.getInputMap();
+	ActionMap am = textArea.getActionMap();
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "history-up");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_P, InputEvent.CTRL_MASK), "history-up");
+	am.put("history-up", new HistoryUpAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), "history-down");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_MASK), "history-down");
+	am.put("history-down", new HistoryDownAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "command");
+	am.put("command", new CommandAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_MASK), "bol");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_HOME, 0), "bol");
+	am.put("bol", new BeginningOfLineAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_E, InputEvent.CTRL_MASK), "eol");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_END, 0), "eol");
+	am.put("eol", new EndOfLineAction());
+
+	textArea.setText("");
+	lastCharCode = 65535;
+	lastDot = 0;
+	try { setupShell(command, args); }
+	catch (IOException ioex) {
+		ErrorDialog.show("run-shell", "Could not start " + command + " " + args);
+		process = null;
+		}
+	}
+	
+public void setupShell(String command, String args) throws IOException
+	{
+    String[] cmdArray = {"","","","","","","","","",""};
+
+    cmdArray[0] = command;
+    //System.out.println("--->" + command);
+    String[] argsArray = args.split("\\s");
+    for (int x = 0; x < argsArray.length; x++)
+        {
+        cmdArray[x + 1] = argsArray[x];
+        //System.out.println(argsArray[x]);
+        }
+	process = Runtime.getRuntime().exec(cmdArray);
+
+	if(guiserver.UTF8)
+		{
+		stdInput = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF8"));
+		stdError = new BufferedReader( new InputStreamReader(process.getErrorStream(), "UTF8"));
+		}
+	else
+		{
+		stdInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
+		stdError = new BufferedReader( new InputStreamReader(process.getErrorStream()));
+		}
+
+	stdOut = new BufferedWriter( new OutputStreamWriter(process.getOutputStream()));
+		
+	new Thread(new stdinListener()).start();
+	new Thread(new stderrorListener()).start();
+	}
+	
+public void destroyShell(StringTokenizer params)
+	{
+	if(process != null) process.destroy();
+	process = null;
+	stdOut = null;
+	}
+	
+public void evalShell(StringTokenizer params)
+	{
+	String command = Base64Coder.decodeString(params.nextToken());
+	
+	while(true)
+		{
+		if(process == null)
+			{
+			textArea.append("--- restarting shell ---"); 
+			runShell(null);
+			if(process == null) break;
+			}
+		else
+			{
+			try {
+				textArea.append("\n");
+				stdOut.write(command, 0, command.length());
+				stdOut.flush();
+				break;
+				}
+			catch (IOException ioex) { 
+				textArea.append("--- eval shell: must restart shell ---"); 
+				process = null;
+				};
+			}
+		}
+		
+	}
+	
+class stdinListener implements Runnable
+	{
+	int len;
+	char buff[];
+	String str;
+	String text;
+	
+	stdinListener()
+		{
+		buff = new char[512];
+		}
+		
+	public void run()
+		{
+		try {
+			while((len = stdInput.read(buff, 0, 512)) != -1)
+				{
+				str = new String(buff, 0, len);
+				text = textArea.getText();
+				if(text.length() > 100000)
+					textArea.setText(text.substring(50000));
+					
+				textArea.append(str);
+				lastDot = textArea.getText().length();
+				textArea.setCaretPosition(lastDot);				
+				}
+			}
+		catch (IOException ioex) {};
+		}
+	}
+	
+class stderrorListener implements Runnable
+	{
+	int len;
+	char buff[];
+	String str;
+	String text;
+	
+	stderrorListener()
+		{
+		buff = new char[512];
+		}
+		
+	public void run()
+		{
+		try {
+			while((len = stdError.read(buff, 0, 512)) != -1)
+				{
+				str = new String(buff, 0, len);
+				text = textArea.getText();
+				if(text.length() > 100000)
+					textArea.setText(text.substring(50000));
+					
+				textArea.append(str);
+				lastDot = textArea.getText().length();
+				textArea.setCaretPosition(lastDot);				
+				}
+			}
+		catch (IOException ioex) {};
+		}
+	}
+
+
+private class BeginningOfLineAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(lastDot);
+		}
+	}
+
+private class EndOfLineAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(textArea.getText().length());
+		}
+	}
+
+private class HistoryUpAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(lastDot);
+		textArea.moveCaretPosition(textArea.getText().length());
+		textArea.cut();
+		if(history.size() > 0)
+			{
+			textArea.append((String)history.elementAt(historyIndex));
+			if(historyIndex < (history.size() - 1))
+				historyIndex += 1;
+			}
+		}
+	}
+
+private class HistoryDownAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(lastDot);
+		textArea.moveCaretPosition(textArea.getText().length());
+		textArea.cut();
+		if(history.size() > 0)
+			{
+			textArea.append((String)history.elementAt(historyIndex));
+			if(historyIndex > 0)
+				historyIndex -= 1;
+			}
+		}
+	}
+
+private class CommandAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		String text = textArea.getText();
+		if(text.length() < lastDot) lastDot = text.length();
+		text = text.substring(lastDot);
+			
+		if(guiserver.UTF8)
+			try {
+			text = new String(text.getBytes("UTF-8"));
+			} 
+		catch (UnsupportedEncodingException e) {}
+			
+		command = text;
+		if(command.equals("[cmd]"))
+			isInBatch = true;
+
+		textArea.append("\n");
+						
+		try { 
+			if(isInBatch == false)
+				{
+				stdOut.write(command, 0, command.length());
+				stdOut.write(10);
+				stdOut.flush();
+				}
+			if(command.length() > 0)
+				{
+				history.insertElementAt(new String(command), 0);
+				}
+			historyIndex = 0;
+			}
+		catch (IOException ioex) { 
+			textArea.append("--- cannot execute: restart shell ---"); 
+			};
+
+		if(command.endsWith("\n[/cmd]"))
+			{
+			isInBatch = false;
+			try {
+				stdOut.write(command, 0, command.length());
+				stdOut.write(10);
+				stdOut.flush();
+				}
+			catch (IOException ioex) {
+				textArea.append("--- cannot execute command batch ---");
+				};
+			}
+		}
+	}
+
+}
+
+ 
+// eof //
diff --git a/guiserver/java/TextAreaWidget.java.bak b/guiserver/java/TextAreaWidget.java.bak
new file mode 100644
index 0000000..0e01084
--- /dev/null
+++ b/guiserver/java/TextAreaWidget.java.bak
@@ -0,0 +1,416 @@
+//
+//  TextAreaWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/16/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.event.ActionEvent;
+import java.util.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.text.*;
+
+
+@SuppressWarnings("unchecked")
+public class TextAreaWidget extends aTextWidget {
+
+JTextArea textArea;
+int lastCharCode = 65535;
+int lastDot = 0;
+Process process = null;
+BufferedWriter stdOut;
+BufferedReader stdInput;
+BufferedReader stdError;
+String command = "";
+int historyIndex = 0;
+Vector history;
+String lastShellCommand;
+String lastShellArgs;
+String commandBatch = "";
+boolean isInBatch = false;
+
+public TextAreaWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	textArea = new JTextArea();
+	textArea.setFont(new Font("SansSerif", Font.PLAIN, 12));
+	textArea.setLineWrap(true);
+    textArea.setWrapStyleWord(true);
+	
+    areaScrollPane = new JScrollPane(textArea);
+    areaScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+	
+	container = areaScrollPane;
+	jcomponent = textArea;
+	component = areaScrollPane;
+	textcomp = textArea;
+	isScrollable = true;
+
+	if(params.hasMoreTokens())
+		areaScrollPane.setPreferredSize(
+			new Dimension(Integer.parseInt(params.nextToken()),Integer.parseInt(params.nextToken())));
+		
+	gsObject.widgets.put(id, this);
+		
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyPressed(KeyEvent e)
+			{
+			Character chr = new Character(e.getKeyChar());
+			lastCharCode = chr.hashCode();
+			
+			if(process != null)
+				{
+				if(lastCharCode == 12) // formfeed Ctrl-L
+					{
+					textArea.setText("");
+					lastDot = 0;
+					try {
+						stdOut.write(10);
+						stdOut.flush();
+						}
+					catch (IOException ioex) { System.out.println("clear screen:" + ioex); };	
+					}
+				}				
+			}
+		};
+		
+	CaretListener caretListener = new CaretListener() {
+		public void caretUpdate(CaretEvent ce)
+			{
+			int mark = ce.getMark();
+			int dot = ce.getDot();
+			guiserver.out.println("(" + action + " \"" + id + "\" " + lastCharCode + " " + dot + " " + mark + ")");
+			guiserver.out.flush();
+			lastCharCode = 65535;
+			//System.out.println(":" + lastDot);
+			}
+		};
+		
+	textArea.addCaretListener(caretListener);
+	textArea.addKeyListener(keyListener);
+	}
+
+public void setTabSize(StringTokenizer tokens)
+	{
+	textArea.setTabSize(Integer.parseInt(tokens.nextToken()));
+	}	
+
+public void clearText(StringTokenizer params)
+	{
+	textcomp.setText("");
+	lastCharCode = 65535;
+	lastDot = 0;
+	if(process != null)
+		try {
+			stdOut.write(10);
+			stdOut.flush();
+			}
+		catch (IOException ioex) { System.out.println("clear screen:" + ioex); };
+	}
+
+
+public void runShell(StringTokenizer tokens)
+	{
+	String command;
+    String args;
+	
+	if(tokens == null)
+		{
+		command = lastShellCommand;
+        args = lastShellArgs;
+		}
+	else
+		{
+		command = Base64Coder.decodeString(tokens.nextToken());
+		lastShellCommand = command;
+        args = Base64Coder.decodeString(tokens.nextToken());
+        lastShellArgs = args;
+		}
+	
+	history = new Vector();
+	historyIndex = 0;
+	commandBatch = "";
+	isInBatch = false;
+
+	if(process != null)
+		process.destroy();
+		
+	InputMap im = textArea.getInputMap();
+	ActionMap am = textArea.getActionMap();
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "history-up");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_P, InputEvent.CTRL_MASK), "history-up");
+	am.put("history-up", new HistoryUpAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), "history-down");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_MASK), "history-down");
+	am.put("history-down", new HistoryDownAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "command");
+	am.put("command", new CommandAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_MASK), "bol");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_HOME, 0), "bol");
+	am.put("bol", new BeginningOfLineAction());
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_E, InputEvent.CTRL_MASK), "eol");
+	im.put(KeyStroke.getKeyStroke(KeyEvent.VK_END, 0), "eol");
+	am.put("eol", new EndOfLineAction());
+
+	textArea.setText("");
+	lastCharCode = 65535;
+	lastDot = 0;
+	try { setupShell(command, args); }
+	catch (IOException ioex) {
+		ErrorDialog.show("run-shell", "Could not start " + command + " " + args);
+		process = null;
+		}
+	}
+	
+public void setupShell(String command, String args) throws IOException
+	{
+    String[] cmdArray = {"","","","","","","","","",""};
+
+    cmdArray[0] = command;
+    //System.out.println("--->" + command);
+    String[] argsArray = args.split("\\s");
+    for (int x = 0; x < argsArray.length; x++)
+        {
+        cmdArray[x + 1] = argsArray[x];
+        //System.out.println(argsArray[x]);
+        }
+	process = Runtime.getRuntime().exec(cmdArray);
+
+	if(guiserver.UTF8)
+		{
+		stdInput = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF8"));
+		stdError = new BufferedReader( new InputStreamReader(process.getErrorStream(), "UTF8"));
+		}
+	else
+		{
+		stdInput = new BufferedReader(new InputStreamReader(process.getInputStream()));
+		stdError = new BufferedReader( new InputStreamReader(process.getErrorStream()));
+		}
+
+	stdOut = new BufferedWriter( new OutputStreamWriter(process.getOutputStream()));
+		
+	new Thread(new stdinListener()).start();
+	new Thread(new stderrorListener()).start();
+	}
+	
+public void destroyShell(StringTokenizer params)
+	{
+	if(process != null) process.destroy();
+	process = null;
+	stdOut = null;
+	}
+	
+public void evalShell(StringTokenizer params)
+	{
+	String command = Base64Coder.decodeString(params.nextToken());
+	
+	while(true)
+		{
+		if(process == null)
+			{
+			textArea.append("--- restarting shell ---"); 
+			runShell(null);
+			if(process == null) break;
+			}
+		else
+			{
+			try {
+				textArea.append("\n");
+				stdOut.write(command, 0, command.length());
+				stdOut.flush();
+				break;
+				}
+			catch (IOException ioex) { 
+				textArea.append("--- eval shell: must restart shell ---"); 
+				process = null;
+				};
+			}
+		}
+		
+	}
+	
+class stdinListener implements Runnable
+	{
+	int len;
+	char buff[];
+	String str;
+	String text;
+	
+	stdinListener()
+		{
+		buff = new char[512];
+		}
+		
+	public void run()
+		{
+		try {
+			while((len = stdInput.read(buff, 0, 512)) != -1)
+				{
+				str = new String(buff, 0, len);
+				text = textArea.getText();
+				if(text.length() > 100000)
+					textArea.setText(text.substring(50000));
+					
+				textArea.append(str);
+				lastDot = textArea.getText().length();
+				textArea.setCaretPosition(lastDot);				
+				}
+			}
+		catch (IOException ioex) {};
+		}
+	}
+	
+class stderrorListener implements Runnable
+	{
+	int len;
+	char buff[];
+	String str;
+	String text;
+	
+	stderrorListener()
+		{
+		buff = new char[512];
+		}
+		
+	public void run()
+		{
+		try {
+			while((len = stdError.read(buff, 0, 512)) != -1)
+				{
+				str = new String(buff, 0, len);
+				text = textArea.getText();
+				if(text.length() > 100000)
+					textArea.setText(text.substring(50000));
+					
+				textArea.append(str);
+				lastDot = textArea.getText().length();
+				textArea.setCaretPosition(lastDot);				
+				}
+			}
+		catch (IOException ioex) {};
+		}
+	}
+
+
+private class BeginningOfLineAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(lastDot);
+		}
+	}
+
+private class EndOfLineAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(textArea.getText().length());
+		}
+	}
+
+private class HistoryUpAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(lastDot);
+		textArea.moveCaretPosition(textArea.getText().length());
+		textArea.cut();
+		if(history.size() > 0)
+			{
+			textArea.append((String)history.elementAt(historyIndex));
+			if(historyIndex < (history.size() - 1))
+				historyIndex += 1;
+			}
+		}
+	}
+
+private class HistoryDownAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		textArea.setCaretPosition(lastDot);
+		textArea.moveCaretPosition(textArea.getText().length());
+		textArea.cut();
+		if(history.size() > 0)
+			{
+			textArea.append((String)history.elementAt(historyIndex));
+			if(historyIndex > 0)
+				historyIndex -= 1;
+			}
+		}
+	}
+
+private class CommandAction extends AbstractAction {
+	public static final long serialVersionUID = 1L;
+	public void actionPerformed(ActionEvent ev) {
+		String text = textArea.getText();
+		if(text.length() < lastDot) lastDot = text.length();
+		text = text.substring(lastDot);
+			
+		if(guiserver.UTF8)
+			try {
+			text = new String(text.getBytes("UTF-8"));
+			} 
+		catch (UnsupportedEncodingException e) {}
+			
+		command = text;
+		if(command.equals("[cmd]"))
+			isInBatch = true;
+
+		textArea.append("\n");
+						
+		try { 
+			if(isInBatch == false)
+				{
+				stdOut.write(command, 0, command.length());
+				stdOut.write(10);
+				stdOut.flush();
+				}
+			if(command.length() > 0)
+				{
+				history.insertElementAt(new String(command), 0);
+				}
+			historyIndex = 0;
+			}
+		catch (IOException ioex) { 
+			textArea.append("--- cannot execute: restart shell ---"); 
+			};
+
+		if(command.endsWith("\n[/cmd]"))
+			{
+			isInBatch = false;
+			try {
+				stdOut.write(command, 0, command.length());
+				stdOut.write(10);
+				stdOut.flush();
+				}
+			catch (IOException ioex) {
+				textArea.append("--- cannot execute command batch ---");
+				};
+			}
+		}
+	}
+
+}
+
+ 
+// eof //
diff --git a/guiserver/java/TextFieldWidget.java b/guiserver/java/TextFieldWidget.java
new file mode 100644
index 0000000..661be4b
--- /dev/null
+++ b/guiserver/java/TextFieldWidget.java
@@ -0,0 +1,110 @@
+//
+//  TextFieldWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/16/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class TextFieldWidget extends aTextWidget {
+
+JPasswordField textfield;
+
+public TextFieldWidget(StringTokenizer params)
+	{
+	textfield = new JPasswordField();
+	jcomponent = textfield;
+	component = textfield;
+	container = textfield;
+	textcomp = textfield;
+	isScrollable = false;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	textfield.setColumns(Integer.parseInt(params.nextToken()));
+
+	if (params.hasMoreTokens())
+	    {
+		String covered = Base64Coder.decodeString(params.nextToken()) ;
+		textfield.setEchoChar(covered.charAt(0)) ;
+	    }
+	else
+	    {
+		textfield.setEchoChar((char)0) ;
+	    }
+
+	gsObject.widgets.put(id, this);
+
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{	
+				String param = "\"" + Base64Coder.encodeString(String.valueOf(textfield.getPassword())) + "\"";
+				guiserver.out.println("("+ action + "\"" + id +  "\"" + param + ")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyPressed(KeyEvent e)
+			{
+			Character chr = new Character(e.getKeyChar());
+			if(chr.hashCode() == 27)
+				{
+				guiserver.out.println("("+ action + "\"" + id + "\")");
+				guiserver.out.flush();
+				}
+			} 		
+		};
+		
+	textfield.addKeyListener(keyListener);
+	textfield.addActionListener(listener);
+	}
+
+public void setEchoChar(StringTokenizer params)
+    {
+	if (params.hasMoreTokens())
+	    {
+		String p = params.nextToken() ;
+		String str = Base64Coder.decodeString(p) ;
+
+		textfield.setEchoChar(str.charAt(0)) ;
+	    }
+	else
+	    {
+		textfield.setEchoChar((char)0) ;
+	    }
+
+    }
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/TextFieldWidget.java.bak b/guiserver/java/TextFieldWidget.java.bak
new file mode 100644
index 0000000..faa6b26
--- /dev/null
+++ b/guiserver/java/TextFieldWidget.java.bak
@@ -0,0 +1,110 @@
+//
+//  TextFieldWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/16/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.text.*;
+
+@SuppressWarnings("unchecked")
+public class TextFieldWidget extends aTextWidget {
+
+JPasswordField textfield;
+
+public TextFieldWidget(StringTokenizer params)
+	{
+	textfield = new JPasswordField();
+	jcomponent = textfield;
+	component = textfield;
+	container = textfield;
+	textcomp = textfield;
+	isScrollable = false;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	textfield.setColumns(Integer.parseInt(params.nextToken()));
+
+	if (params.hasMoreTokens())
+	    {
+		String covered = Base64Coder.decodeString(params.nextToken()) ;
+		textfield.setEchoChar(covered.charAt(0)) ;
+	    }
+	else
+	    {
+		textfield.setEchoChar((char)0) ;
+	    }
+
+	gsObject.widgets.put(id, this);
+
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{	
+				String param = "\"" + Base64Coder.encodeString(String.valueOf(textfield.getPassword())) + "\"";
+				guiserver.out.println("("+ action + "\"" + id +  "\"" + param + ")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyPressed(KeyEvent e)
+			{
+			Character chr = new Character(e.getKeyChar());
+			if(chr.hashCode() == 27)
+				{
+				guiserver.out.println("("+ action + "\"" + id + "\")");
+				guiserver.out.flush();
+				}
+			} 		
+		};
+		
+	textfield.addKeyListener(keyListener);
+	textfield.addActionListener(listener);
+	}
+
+public void setEchoChar(StringTokenizer params)
+    {
+	if (params.hasMoreTokens())
+	    {
+		String p = params.nextToken() ;
+		String str = Base64Coder.decodeString(p) ;
+
+		textfield.setEchoChar(str.charAt(0)) ;
+	    }
+	else
+	    {
+		textfield.setEchoChar((char)0) ;
+	    }
+
+    }
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/TextPaneWidget.java b/guiserver/java/TextPaneWidget.java
new file mode 100644
index 0000000..ad39516
--- /dev/null
+++ b/guiserver/java/TextPaneWidget.java
@@ -0,0 +1,621 @@
+//
+//  TextPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/11/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.text.html.*;
+import javax.swing.event.*;
+import javax.swing.undo.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked")
+public class TextPaneWidget extends aTextWidget {
+
+JTextPane textPane;
+String contentType = null;
+
+CaretListener caretListener;
+CaretEvent lastCaretEvent = null;
+int lastCharCode = 65535;
+int lastModifiers = 0;
+int documentLength = 0;
+String undoState = "nil";
+String redoState = "nil";
+
+Color foreground = new Color(0,0,0);
+StyledDocument styledDoc;
+Vector shTopLevels;
+TextPaneWidget widget;
+
+static final int SYNTAX_NONE = 0;
+static final int SYNTAX_NEWLISP = 1;
+static final int SYNTAX_C = 2;
+static final int SYNTAX_CPP = 3;
+static final int SYNTAX_JAVA = 4;
+static final int SYNTAX_PHP = 5;
+
+int syntaxSelected = SYNTAX_NONE;
+
+//undo helpers
+protected UndoAction undoAction;
+protected RedoAction redoAction;
+protected UndoManager undo = new UndoManager();
+MyUndoableEditListener undoableEditListener;
+boolean undoEnabled = true;
+
+public TextPaneWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	textPane = new JTextPane();
+	textPane.setDoubleBuffered(true);
+	
+	Caret caret = new MyCaret();
+	caret.setBlinkRate(500);
+	
+	textPane.setCaret(caret);
+	
+	if(params.hasMoreTokens())
+		contentType = params.nextToken();
+
+	textPane.setContentType(contentType);
+			
+	areaScrollPane = new JScrollPane(textPane);
+    areaScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+	
+	container = areaScrollPane;
+	jcomponent = textPane;
+	component = areaScrollPane;
+	textcomp = textPane;
+	isScrollable = true;
+	
+	widget = this;
+
+	shTopLevels = new Vector();
+
+	if(params.hasMoreTokens())
+		areaScrollPane.setPreferredSize(
+			new Dimension (Integer.parseInt(params.nextToken()),Integer.parseInt(params.nextToken())));
+		
+	gsObject.widgets.put(id, this);
+
+	styledDoc = textPane.getStyledDocument();
+	AbstractDocument doc = (AbstractDocument)styledDoc;
+	//doc.setDocumentFilter(new MyDocumentFilter(1000000));
+	
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyPressed(KeyEvent e)
+			{
+			Character chr = new Character(e.getKeyChar());
+			int code = e.getKeyCode();
+			lastCharCode = chr.hashCode();
+			
+			lastModifiers = e.getModifiersEx();
+			//System.out.println("->" + lastCharCode);
+			if(syntaxSelected != SYNTAX_NONE) colorSyntax();
+					
+			switch(lastCharCode)
+				{
+				case 40:
+					highlightClosingPar('(', ')');
+					break;
+				case 41:
+					highlightOpeningPar('(', ')');
+					break;
+				case 123:
+					highlightClosingPar('{', '}');
+					break;
+				case 125:
+					highlightOpeningPar('{', '}');
+					break;
+				case 91:
+					highlightClosingPar('[', ']');
+					break;
+				case 93:
+					highlightOpeningPar('[', ']');
+					break;
+
+				}
+			}
+		};
+		
+	caretListener = new CaretListener() {
+		public void caretUpdate(CaretEvent ce)
+			{
+			int mark, dot;
+			
+			if(ce == null) return;
+			
+			mark = ce.getMark();
+			dot = ce.getDot();
+			
+			lastCaretEvent = ce;
+			
+			undoAction.updateUndoState();
+			redoAction.updateRedoState();
+			
+			if(undoAction.isEnabled()) undoState = "true";
+			else undoState = "nil";
+			
+			if(redoAction.isEnabled()) redoState = "true";
+			else redoState = "nil";
+			
+			guiserver.out.println("(" + action + " \"" + id + "\" " + lastCharCode + " " + 
+				lastModifiers + " " + dot + " " + mark + " " + documentLength + " " + 
+				undoState + " " + redoState + ")");
+			guiserver.out.flush();
+			
+			lastCharCode = 65535;
+			}
+		};
+	
+	undoAction = new UndoAction();
+	redoAction = new RedoAction();
+	
+	undoableEditListener = new MyUndoableEditListener();
+	
+	
+	// set ctrl-Z and meta-Z undo/redo keys
+	InputMap inputMap = textPane.getInputMap();
+	KeyStroke key;
+	
+	if(guiserver.MAC_OS_X)
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.META_MASK);
+	else
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.CTRL_MASK);
+	inputMap.put(key, undoAction);
+
+	if(guiserver.MAC_OS_X)
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.META_MASK | Event.SHIFT_MASK);
+	else
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.CTRL_MASK | Event.SHIFT_MASK);
+	inputMap.put(key, redoAction);
+	
+	
+	styledDoc.addUndoableEditListener(undoableEditListener);
+	styledDoc.addDocumentListener(new MyDocumentListener());
+
+	textPane.addHyperlinkListener(new Hyperactive());
+	textPane.addCaretListener(caretListener);
+	textPane.addKeyListener(keyListener);
+	}
+	
+public void highlightOpeningPar(char opng, char clsng)
+	{
+	int balance = -1;
+	String text = textPane.getText();
+	int currentPos = textPane.getCaretPosition();
+	int caretPos = 0;
+	int len = text.length();
+
+	caretPos = currentPos - 1; // new
+	// go back looking for matching parenthesis
+	while(balance != 0 && caretPos >= 0)
+		{
+		if(text.charAt(caretPos) == opng) ++balance;
+		else if(text.charAt(caretPos) == clsng) --balance;
+		--caretPos;
+		}
+		
+	++caretPos;
+
+	if(balance == 0) highlightPosition(caretPos, currentPos);
+	}
+	
+public void highlightClosingPar(char opng, char clsng)
+	{
+	int balance = 1;
+	String text = textPane.getText();
+	int currentPos = textPane.getCaretPosition();
+	int caretPos = 0;
+	int len = text.length();	
+	
+	if(len == 0) return;
+		
+	caretPos = currentPos;
+	
+	// go forward to matching parentheseis
+	while(balance != 0 && caretPos < len)
+		{
+		if(text.charAt(caretPos) == opng) ++balance;
+		else if(text.charAt(caretPos) == clsng) --balance;
+		++caretPos;
+		}
+		
+	if(balance == 0) highlightPosition(caretPos, currentPos);
+	}
+	
+public void highlightPosition(int pos, int oldPos)
+	{
+	textPane.setCaretPosition(pos);
+	textPane.getCaret().paint(textPane.getGraphics());
+	textPane.repaint();
+	try {Thread.sleep(400); } catch (InterruptedException ie) {}
+	textPane.setCaretPosition(oldPos);
+	textPane.getCaret().paint(textPane.getGraphics());
+	}
+
+
+public void loadText(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	
+	EditorKit kit = textPane.getEditorKit();
+	
+	System.setProperty("line.separator", "\n");
+	
+	try {
+		if(guiserver.UTF8)
+			kit.read(new FilterFileReader(path, "UTF8"), styledDoc, 0); 
+		else
+			kit.read(new FilterFileReader(path), styledDoc, 0); 			
+		}
+	catch(Exception ex) { ErrorDialog.show("gs:load-text", "Cannot load or decode file: " + path); }
+	}
+	
+	
+public void saveText(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	
+	EditorKit kit = textPane.getEditorKit();
+	
+	try { kit.write(new FileWriter(path), styledDoc, 0, styledDoc.getLength()); }
+	catch(Exception ex) { ErrorDialog.show("gs:save-text", "Cannot save file: " + path); }
+	}
+
+
+public void findText(StringTokenizer tokens)
+	{
+	String findtext = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		findtext = Base64Coder.decodeStringUTF8(findtext);
+	else
+		findtext = Base64Coder.decodeString(findtext);
+
+	String direction = "next";
+	boolean isRegex = false;
+	int dot;
+	
+	String findTextAction = tokens.nextToken();
+	
+	if(tokens.hasMoreTokens())
+		direction = tokens.nextToken();
+				
+	if(tokens.hasMoreTokens())
+		isRegex = tokens.nextToken().equals("true");
+	
+	String text = textPane.getText();
+	
+	int currentCaret = textPane.getCaretPosition();
+	
+	if(direction.equals("previous"))
+		{
+		if(currentCaret > findtext.length() + 1) 
+			currentCaret -= findtext.length() + 1;
+		dot = text.lastIndexOf(findtext, currentCaret);
+		}
+	else
+		dot = text.indexOf(findtext, currentCaret);
+
+	guiserver.out.println("(" + findTextAction + " \"" + id + "\" " + dot + ")");
+	guiserver.out.flush();
+	
+	if(dot < 0)
+		{
+		textPane.setCaretPosition(currentCaret);
+		return;
+		}
+		
+	textPane.setCaretPosition(dot);
+	textPane.moveCaretPosition(dot + findtext.length());
+	}
+
+public void setTabSize(StringTokenizer tokens)
+	{
+	int tabSize = Integer.parseInt(tokens.nextToken());
+			
+	TabSet tabSet = new TabSet(new TabStop[] { 
+		new TabStop(tabSize), new TabStop(2 * tabSize), new TabStop(3 * tabSize), 
+		new TabStop(4 * tabSize), new TabStop(5 * tabSize), new TabStop(6 * tabSize),
+		new TabStop(7 * tabSize), new TabStop(8 * tabSize), new TabStop(9 * tabSize) });
+		
+	SimpleAttributeSet attributes = new SimpleAttributeSet();
+    StyleConstants.setTabSet(attributes, tabSet);
+    styledDoc.setParagraphAttributes(0, documentLength, attributes, false);
+	}
+	
+public void setSyntax(StringTokenizer tokens)
+	{
+	String tkn  = tokens.nextToken();
+	
+	if(tkn.equals("true") || tkn.equals("lsp"))
+		syntaxSelected = SYNTAX_NEWLISP;
+	else if(tkn.equals("c"))
+		syntaxSelected = SYNTAX_C;
+	else if(tkn.equals("cpp"))
+		syntaxSelected = SYNTAX_CPP;
+	else if(tkn.equals("java"))
+		syntaxSelected = SYNTAX_JAVA;
+	else if(tkn.equals("php"))
+		syntaxSelected = SYNTAX_PHP;
+	else syntaxSelected = SYNTAX_NONE;
+
+	if(syntaxSelected == SYNTAX_NONE)
+		{
+		SimpleAttributeSet normal = new SimpleAttributeSet();
+		StyleConstants.setForeground(normal, widget.foreground);
+		styledDoc.setCharacterAttributes(0, documentLength, normal, true);
+		}
+	else
+		{
+		shTopLevels.removeAllElements();
+		if(syntaxSelected == SYNTAX_NEWLISP)
+			SyntaxHighlighter.color(widget, 0, documentLength);
+		else
+			{
+			SyntaxHighlighterC.setFlavor(syntaxSelected);
+			SyntaxHighlighterC.color(widget, 0, documentLength);
+			}
+		}
+			
+	undo.discardAllEdits();
+	}
+	
+public void setForeground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		textPane.setForeground(new Color(red, green, blue, alpha));
+		}
+	else
+		textPane.setForeground(new Color(red, green, blue));
+		
+	widget.foreground = textPane.getForeground();
+	}
+	
+class Hyperactive implements HyperlinkListener {
+         public void hyperlinkUpdate(HyperlinkEvent e) {
+ 	          if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
+ 		      JEditorPane pane = (JEditorPane) e.getSource();
+ 		      if (e instanceof HTMLFrameHyperlinkEvent) {
+ 		          HTMLFrameHyperlinkEvent  evt = (HTMLFrameHyperlinkEvent)e;
+ 		          HTMLDocument doc = (HTMLDocument)pane.getDocument();
+ 		          doc.processHTMLFrameHyperlinkEvent(evt);
+ 		      } else {
+ 		          try {
+ 			      pane.setPage(e.getURL());
+ 		          } catch (Throwable t) {
+ 			      textPane.setText("The page could not be displayed.");
+ 		          }
+ 		      }
+ 	          }
+ 	      }
+     }
+	 
+// undo and redo 
+
+public void undoEnable(StringTokenizer tokens)
+	{
+	undoEnabled = tokens.nextToken().equals("true");
+	}
+	
+public void undoText(StringTokenizer tokens)
+	{
+	undoAction.actionPerformed(new ActionEvent(textPane, Event.ACTION_EVENT, "Undo"));
+	}
+	
+public void redoText(StringTokenizer tokens)
+	{
+	redoAction.actionPerformed(new ActionEvent(textPane, Event.ACTION_EVENT, "Redo"));
+	}
+
+public void colorSyntax() 
+	{
+	int caretPos = textPane.getCaretPosition();
+	int pos = 0;
+	int size = shTopLevels.size();
+	int p, len;
+
+	//System.out.println(".");
+	for(int idx = size - 1; idx >= 0; idx--)
+		{
+		pos = (Integer)shTopLevels.elementAt(idx);
+		if(caretPos > pos) 
+			{
+			for(int i = idx; i < size; i++)
+				{
+				p = (Integer)shTopLevels.elementAt(idx);
+				shTopLevels.removeElementAt(idx);
+				}
+			break;
+			}
+		}
+				
+	if(documentLength > caretPos + 1024)
+		len = caretPos + 1024;
+	else
+		len = documentLength;
+		
+	if(syntaxSelected == SYNTAX_NEWLISP)
+		SyntaxHighlighter.color(widget, pos, len);
+	else
+		SyntaxHighlighterC.color(widget, pos, len);
+	}
+		
+//This one listens for edits that can be undone.
+protected class MyUndoableEditListener implements UndoableEditListener 
+	{
+	public void undoableEditHappened(UndoableEditEvent e) 
+		{
+		//Remember the edit and update the menus.
+		if(SyntaxHighlighter.active || undoEnabled != true) return;
+		undo.addEdit(e.getEdit());
+		undoAction.updateUndoState();
+		redoAction.updateRedoState();
+        }
+    }
+
+// Listens for any changes to the document.
+protected class MyDocumentListener implements DocumentListener 
+	{
+	public void insertUpdate(DocumentEvent e) { updateParams(e);}
+	public void removeUpdate(DocumentEvent e) { updateParams(e);}
+	public void changedUpdate(DocumentEvent e) { updateParams(e);}
+
+	private void updateParams(DocumentEvent e)
+		{
+		Document document = e.getDocument();
+		documentLength = document.getLength();
+		}
+	}
+
+class UndoAction extends AbstractAction 
+	{
+	public static final long serialVersionUID = 1L;
+	public UndoAction() {
+		super("Undo");
+		setEnabled(false);
+		}
+
+	public void actionPerformed(ActionEvent e) 
+		{
+		String pname = undo.getUndoPresentationName();
+		try { undo.undo(); 	} catch (Exception ex) 
+			{
+			Toolkit.getDefaultToolkit().beep();
+			}
+						
+		String qname = undo.getUndoPresentationName();
+		if(pname.equals("Undo addition") && qname.equals("Undo deletion"))
+			{
+			try { undo.undo(); 	} catch (Exception ex) 
+				{
+				Toolkit.getDefaultToolkit().beep();
+				}
+			}
+		
+		updateUndoState();
+		redoAction.updateRedoState();
+		caretListener.caretUpdate(lastCaretEvent);
+		}
+
+	protected void updateUndoState() {
+		if (undo.canUndo()) {
+			setEnabled(true);
+			putValue(Action.NAME, undo.getUndoPresentationName());
+			} 
+		else {
+			setEnabled(false);
+			putValue(Action.NAME, "Undo");
+			}
+		}
+	}
+
+class RedoAction extends AbstractAction 
+	{
+	public static final long serialVersionUID = 1L;
+	public RedoAction() {
+		super("Redo");
+		setEnabled(false);
+		}
+
+	public void actionPerformed(ActionEvent e) 
+		{
+		String pname = undo.getRedoPresentationName();
+		try { undo.redo();} catch (Exception ex) 
+			{
+			Toolkit.getDefaultToolkit().beep();
+			}
+						
+		String qname = undo.getRedoPresentationName();
+		if(pname.equals("Redo deletion") && qname.equals("Redo addition"))
+			{
+			try { undo.redo(); 	} catch (Exception ex) 
+				{
+				Toolkit.getDefaultToolkit().beep();
+				}
+			}
+			
+		updateRedoState();
+		undoAction.updateUndoState();
+		caretListener.caretUpdate(lastCaretEvent);
+		}
+
+	protected void updateRedoState() 
+		{
+		if (undo.canRedo()) {
+			setEnabled(true);
+			putValue(Action.NAME, undo.getRedoPresentationName());
+			} 
+		else {
+			setEnabled(false);
+			putValue(Action.NAME, "Redo");
+			}
+		}	
+	}
+	
+class MyCaret extends DefaultCaret 
+	{
+	public static final long serialVersionUID = 1L;
+	public void paint(Graphics g) {
+    if (!isVisible()) return;
+    try 
+		{
+		JTextComponent c = getComponent();
+		int dot = getDot();
+		Rectangle r = c.modelToView(dot);
+		g.setColor(c.getCaretColor());
+		g.fillRect(r.x, r.y, 2, r.height);
+		}
+	catch (Exception e) { System.err.println("."); }
+	}
+
+	protected synchronized void damage(Rectangle r) 
+		{
+		if (r == null) return;
+		x = r.x;
+		y = r.y;
+		width = 2;
+		height = r.height;
+		repaint();
+		}
+	}
+	
+}
+ 
+// eof //
diff --git a/guiserver/java/TextPaneWidget.java.bak b/guiserver/java/TextPaneWidget.java.bak
new file mode 100644
index 0000000..1fe2956
--- /dev/null
+++ b/guiserver/java/TextPaneWidget.java.bak
@@ -0,0 +1,621 @@
+//
+//  TextPaneWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/11/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.text.html.*;
+import javax.swing.event.*;
+import javax.swing.undo.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked")
+public class TextPaneWidget extends aTextWidget {
+
+JTextPane textPane;
+String contentType = null;
+
+CaretListener caretListener;
+CaretEvent lastCaretEvent = null;
+int lastCharCode = 65535;
+int lastModifiers = 0;
+int documentLength = 0;
+String undoState = "nil";
+String redoState = "nil";
+
+Color foreground = new Color(0,0,0);
+StyledDocument styledDoc;
+Vector shTopLevels;
+TextPaneWidget widget;
+
+static final int SYNTAX_NONE = 0;
+static final int SYNTAX_NEWLISP = 1;
+static final int SYNTAX_C = 2;
+static final int SYNTAX_CPP = 3;
+static final int SYNTAX_JAVA = 4;
+static final int SYNTAX_PHP = 5;
+
+int syntaxSelected = SYNTAX_NONE;
+
+//undo helpers
+protected UndoAction undoAction;
+protected RedoAction redoAction;
+protected UndoManager undo = new UndoManager();
+MyUndoableEditListener undoableEditListener;
+boolean undoEnabled = true;
+
+public TextPaneWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	textPane = new JTextPane();
+	textPane.setDoubleBuffered(true);
+	
+	Caret caret = new MyCaret();
+	caret.setBlinkRate(500);
+	
+	textPane.setCaret(caret);
+	
+	if(params.hasMoreTokens())
+		contentType = params.nextToken();
+
+	textPane.setContentType(contentType);
+			
+	areaScrollPane = new JScrollPane(textPane);
+    areaScrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+	
+	container = areaScrollPane;
+	jcomponent = textPane;
+	component = areaScrollPane;
+	textcomp = textPane;
+	isScrollable = true;
+	
+	widget = this;
+
+	shTopLevels = new Vector();
+
+	if(params.hasMoreTokens())
+		areaScrollPane.setPreferredSize(
+			new Dimension (Integer.parseInt(params.nextToken()),Integer.parseInt(params.nextToken())));
+		
+	gsObject.widgets.put(id, this);
+
+	styledDoc = textPane.getStyledDocument();
+	AbstractDocument doc = (AbstractDocument)styledDoc;
+	//doc.setDocumentFilter(new MyDocumentFilter(1000000));
+	
+	KeyListener keyListener = new KeyAdapter() {
+		public void keyPressed(KeyEvent e)
+			{
+			Character chr = new Character(e.getKeyChar());
+			int code = e.getKeyCode();
+			lastCharCode = chr.hashCode();
+			
+			lastModifiers = e.getModifiersEx();
+			//System.out.println("->" + lastCharCode);
+			if(syntaxSelected != SYNTAX_NONE) colorSyntax();
+					
+			switch(lastCharCode)
+				{
+				case 40:
+					highlightClosingPar('(', ')');
+					break;
+				case 41:
+					highlightOpeningPar('(', ')');
+					break;
+				case 123:
+					highlightClosingPar('{', '}');
+					break;
+				case 125:
+					highlightOpeningPar('{', '}');
+					break;
+				case 91:
+					highlightClosingPar('[', ']');
+					break;
+				case 93:
+					highlightOpeningPar('[', ']');
+					break;
+
+				}
+			}
+		};
+		
+	caretListener = new CaretListener() {
+		public void caretUpdate(CaretEvent ce)
+			{
+			int mark, dot;
+			
+			if(ce == null) return;
+			
+			mark = ce.getMark();
+			dot = ce.getDot();
+			
+			lastCaretEvent = ce;
+			
+			undoAction.updateUndoState();
+			redoAction.updateRedoState();
+			
+			if(undoAction.isEnabled()) undoState = "true";
+			else undoState = "nil";
+			
+			if(redoAction.isEnabled()) redoState = "true";
+			else redoState = "nil";
+			
+			guiserver.out.println("(" + action + " \"" + id + "\" " + lastCharCode + " " + 
+				lastModifiers + " " + dot + " " + mark + " " + documentLength + " " + 
+				undoState + " " + redoState + ")");
+			guiserver.out.flush();
+			
+			lastCharCode = 65535;
+			}
+		};
+	
+	undoAction = new UndoAction();
+	redoAction = new RedoAction();
+	
+	undoableEditListener = new MyUndoableEditListener();
+	
+	
+	// set ctrl-Z and meta-Z undo/redo keys
+	InputMap inputMap = textPane.getInputMap();
+	KeyStroke key;
+	
+	if(guiserver.MAC_OS_X)
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.META_MASK);
+	else
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.CTRL_MASK);
+	inputMap.put(key, undoAction);
+
+	if(guiserver.MAC_OS_X)
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.META_MASK | Event.SHIFT_MASK);
+	else
+		key = KeyStroke.getKeyStroke(KeyEvent.VK_Z, Event.CTRL_MASK | Event.SHIFT_MASK);
+	inputMap.put(key, redoAction);
+	
+	
+	styledDoc.addUndoableEditListener(undoableEditListener);
+	styledDoc.addDocumentListener(new MyDocumentListener());
+
+	textPane.addHyperlinkListener(new Hyperactive());
+	textPane.addCaretListener(caretListener);
+	textPane.addKeyListener(keyListener);
+	}
+	
+public void highlightOpeningPar(char opng, char clsng)
+	{
+	int balance = -1;
+	String text = textPane.getText();
+	int currentPos = textPane.getCaretPosition();
+	int caretPos = 0;
+	int len = text.length();
+
+	caretPos = currentPos - 1; // new
+	// go back looking for matching parenthesis
+	while(balance != 0 && caretPos >= 0)
+		{
+		if(text.charAt(caretPos) == opng) ++balance;
+		else if(text.charAt(caretPos) == clsng) --balance;
+		--caretPos;
+		}
+		
+	++caretPos;
+
+	if(balance == 0) highlightPosition(caretPos, currentPos);
+	}
+	
+public void highlightClosingPar(char opng, char clsng)
+	{
+	int balance = 1;
+	String text = textPane.getText();
+	int currentPos = textPane.getCaretPosition();
+	int caretPos = 0;
+	int len = text.length();	
+	
+	if(len == 0) return;
+		
+	caretPos = currentPos;
+	
+	// go forward to matching parentheseis
+	while(balance != 0 && caretPos < len)
+		{
+		if(text.charAt(caretPos) == opng) ++balance;
+		else if(text.charAt(caretPos) == clsng) --balance;
+		++caretPos;
+		}
+		
+	if(balance == 0) highlightPosition(caretPos, currentPos);
+	}
+	
+public void highlightPosition(int pos, int oldPos)
+	{
+	textPane.setCaretPosition(pos);
+	textPane.getCaret().paint(textPane.getGraphics());
+	textPane.repaint();
+	try {Thread.sleep(400); } catch (InterruptedException ie) {}
+	textPane.setCaretPosition(oldPos);
+	textPane.getCaret().paint(textPane.getGraphics());
+	}
+
+
+public void loadText(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	
+	EditorKit kit = textPane.getEditorKit();
+	
+	System.setProperty("line.separator", "\n");
+	
+	try {
+		if(guiserver.UTF8)
+			kit.read(new FilterFileReader(path, "UTF8"), styledDoc, 0); 
+		else
+			kit.read(new FilterFileReader(path), styledDoc, 0); 			
+		}
+	catch(Exception ex) { ErrorDialog.show("gs:load-text", "Cannot load or decode file: " + path); }
+	}
+	
+	
+public void saveText(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	
+	EditorKit kit = textPane.getEditorKit();
+	
+	try { kit.write(new FileWriter(path), styledDoc, 0, styledDoc.getLength()); }
+	catch(Exception ex) { ErrorDialog.show("gs:save-text", "Cannot save file: " + path); }
+	}
+
+
+public void findText(StringTokenizer tokens)
+	{
+	String findtext = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		findtext = Base64Coder.decodeStringUTF8(findtext);
+	else
+		findtext = Base64Coder.decodeString(findtext);
+
+	String direction = "next";
+	boolean isRegex = false;
+	int dot;
+	
+	String findTextAction = tokens.nextToken();
+	
+	if(tokens.hasMoreTokens())
+		direction = tokens.nextToken();
+				
+	if(tokens.hasMoreTokens())
+		isRegex = tokens.nextToken().equals("true");
+	
+	String text = textPane.getText();
+	
+	int currentCaret = textPane.getCaretPosition();
+	
+	if(direction.equals("previous"))
+		{
+		if(currentCaret > findtext.length() + 1) 
+			currentCaret -= findtext.length() + 1;
+		dot = text.lastIndexOf(findtext, currentCaret);
+		}
+	else
+		dot = text.indexOf(findtext, currentCaret);
+
+	guiserver.out.println("(" + findTextAction + " \"" + id + "\" " + dot + ")");
+	guiserver.out.flush();
+	
+	if(dot < 0)
+		{
+		textPane.setCaretPosition(currentCaret);
+		return;
+		}
+		
+	textPane.setCaretPosition(dot);
+	textPane.moveCaretPosition(dot + findtext.length());
+	}
+
+public void setTabSize(StringTokenizer tokens)
+	{
+	int tabSize = Integer.parseInt(tokens.nextToken());
+			
+	TabSet tabSet = new TabSet(new TabStop[] { 
+		new TabStop(tabSize), new TabStop(2 * tabSize), new TabStop(3 * tabSize), 
+		new TabStop(4 * tabSize), new TabStop(5 * tabSize), new TabStop(6 * tabSize),
+		new TabStop(7 * tabSize), new TabStop(8 * tabSize), new TabStop(9 * tabSize) });
+		
+	SimpleAttributeSet attributes = new SimpleAttributeSet();
+    StyleConstants.setTabSet(attributes, tabSet);
+    styledDoc.setParagraphAttributes(0, documentLength, attributes, false);
+	}
+	
+public void setSyntax(StringTokenizer tokens)
+	{
+	String tkn  = tokens.nextToken();
+	
+	if(tkn.equals("true") || tkn.equals("lsp"))
+		syntaxSelected = SYNTAX_NEWLISP;
+	else if(tkn.equals("c"))
+		syntaxSelected = SYNTAX_C;
+	else if(tkn.equals("cpp"))
+		syntaxSelected = SYNTAX_CPP;
+	else if(tkn.equals("java"))
+		syntaxSelected = SYNTAX_JAVA;
+	else if(tkn.equals("php"))
+		syntaxSelected = SYNTAX_PHP;
+	else syntaxSelected = SYNTAX_NONE;
+
+	if(syntaxSelected == SYNTAX_NONE)
+		{
+		SimpleAttributeSet normal = new SimpleAttributeSet();
+		StyleConstants.setForeground(normal, widget.foreground);
+		styledDoc.setCharacterAttributes(0, documentLength, normal, true);
+		}
+	else
+		{
+		shTopLevels.removeAllElements();
+		if(syntaxSelected == SYNTAX_NEWLISP)
+			SyntaxHighlighter.color(widget, 0, documentLength);
+		else
+			{
+			SyntaxHighlighterC.setFlavor(syntaxSelected);
+			SyntaxHighlighterC.color(widget, 0, documentLength);
+			}
+		}
+			
+	undo.discardAllEdits();
+	}
+	
+public void setForeground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		textPane.setForeground(new Color(red, green, blue, alpha));
+		}
+	else
+		textPane.setForeground(new Color(red, green, blue));
+		
+	widget.foreground = textPane.getForeground();
+	}
+	
+class Hyperactive implements HyperlinkListener {
+         public void hyperlinkUpdate(HyperlinkEvent e) {
+ 	          if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
+ 		      JEditorPane pane = (JEditorPane) e.getSource();
+ 		      if (e instanceof HTMLFrameHyperlinkEvent) {
+ 		          HTMLFrameHyperlinkEvent  evt = (HTMLFrameHyperlinkEvent)e;
+ 		          HTMLDocument doc = (HTMLDocument)pane.getDocument();
+ 		          doc.processHTMLFrameHyperlinkEvent(evt);
+ 		      } else {
+ 		          try {
+ 			      pane.setPage(e.getURL());
+ 		          } catch (Throwable t) {
+ 			      textPane.setText("The page could not be displayed.");
+ 		          }
+ 		      }
+ 	          }
+ 	      }
+     }
+	 
+// undo and redo 
+
+public void undoEnable(StringTokenizer tokens)
+	{
+	undoEnabled = tokens.nextToken().equals("true");
+	}
+	
+public void undoText(StringTokenizer tokens)
+	{
+	undoAction.actionPerformed(new ActionEvent(textPane, Event.ACTION_EVENT, "Undo"));
+	}
+	
+public void redoText(StringTokenizer tokens)
+	{
+	redoAction.actionPerformed(new ActionEvent(textPane, Event.ACTION_EVENT, "Redo"));
+	}
+
+public void colorSyntax() 
+	{
+	int caretPos = textPane.getCaretPosition();
+	int pos = 0;
+	int size = shTopLevels.size();
+	int p, len;
+
+	//System.out.println(".");
+	for(int idx = size - 1; idx >= 0; idx--)
+		{
+		pos = (Integer)shTopLevels.elementAt(idx);
+		if(caretPos > pos) 
+			{
+			for(int i = idx; i < size; i++)
+				{
+				p = (Integer)shTopLevels.elementAt(idx);
+				shTopLevels.removeElementAt(idx);
+				}
+			break;
+			}
+		}
+				
+	if(documentLength > caretPos + 1024)
+		len = caretPos + 1024;
+	else
+		len = documentLength;
+		
+	if(syntaxSelected == SYNTAX_NEWLISP)
+		SyntaxHighlighter.color(widget, pos, len);
+	else
+		SyntaxHighlighterC.color(widget, pos, len);
+	}
+		
+//This one listens for edits that can be undone.
+protected class MyUndoableEditListener implements UndoableEditListener 
+	{
+	public void undoableEditHappened(UndoableEditEvent e) 
+		{
+		//Remember the edit and update the menus.
+		if(SyntaxHighlighter.active || undoEnabled != true) return;
+		undo.addEdit(e.getEdit());
+		undoAction.updateUndoState();
+		redoAction.updateRedoState();
+        }
+    }
+
+// Listens for any changes to the document.
+protected class MyDocumentListener implements DocumentListener 
+	{
+	public void insertUpdate(DocumentEvent e) { updateParams(e);}
+	public void removeUpdate(DocumentEvent e) { updateParams(e);}
+	public void changedUpdate(DocumentEvent e) { updateParams(e);}
+
+	private void updateParams(DocumentEvent e)
+		{
+		Document document = e.getDocument();
+		documentLength = document.getLength();
+		}
+	}
+
+class UndoAction extends AbstractAction 
+	{
+	public static final long serialVersionUID = 1L;
+	public UndoAction() {
+		super("Undo");
+		setEnabled(false);
+		}
+
+	public void actionPerformed(ActionEvent e) 
+		{
+		String pname = undo.getUndoPresentationName();
+		try { undo.undo(); 	} catch (Exception ex) 
+			{
+			Toolkit.getDefaultToolkit().beep();
+			}
+						
+		String qname = undo.getUndoPresentationName();
+		if(pname.equals("Undo addition") && qname.equals("Undo deletion"))
+			{
+			try { undo.undo(); 	} catch (Exception ex) 
+				{
+				Toolkit.getDefaultToolkit().beep();
+				}
+			}
+		
+		updateUndoState();
+		redoAction.updateRedoState();
+		caretListener.caretUpdate(lastCaretEvent);
+		}
+
+	protected void updateUndoState() {
+		if (undo.canUndo()) {
+			setEnabled(true);
+			putValue(Action.NAME, undo.getUndoPresentationName());
+			} 
+		else {
+			setEnabled(false);
+			putValue(Action.NAME, "Undo");
+			}
+		}
+	}
+
+class RedoAction extends AbstractAction 
+	{
+	public static final long serialVersionUID = 1L;
+	public RedoAction() {
+		super("Redo");
+		setEnabled(false);
+		}
+
+	public void actionPerformed(ActionEvent e) 
+		{
+		String pname = undo.getRedoPresentationName();
+		try { undo.redo();} catch (Exception ex) 
+			{
+			Toolkit.getDefaultToolkit().beep();
+			}
+						
+		String qname = undo.getRedoPresentationName();
+		if(pname.equals("Redo deletion") && qname.equals("Redo addition"))
+			{
+			try { undo.redo(); 	} catch (Exception ex) 
+				{
+				Toolkit.getDefaultToolkit().beep();
+				}
+			}
+			
+		updateRedoState();
+		undoAction.updateUndoState();
+		caretListener.caretUpdate(lastCaretEvent);
+		}
+
+	protected void updateRedoState() 
+		{
+		if (undo.canRedo()) {
+			setEnabled(true);
+			putValue(Action.NAME, undo.getRedoPresentationName());
+			} 
+		else {
+			setEnabled(false);
+			putValue(Action.NAME, "Redo");
+			}
+		}	
+	}
+	
+class MyCaret extends DefaultCaret 
+	{
+	public static final long serialVersionUID = 1L;
+	public void paint(Graphics g) {
+    if (!isVisible()) return;
+    try 
+		{
+		JTextComponent c = getComponent();
+		int dot = getDot();
+		Rectangle r = c.modelToView(dot);
+		g.setColor(c.getCaretColor());
+		g.fillRect(r.x, r.y, 2, r.height);
+		}
+	catch (Exception e) { System.err.println("."); }
+	}
+
+	protected synchronized void damage(Rectangle r) 
+		{
+		if (r == null) return;
+		x = r.x;
+		y = r.y;
+		width = 2;
+		height = r.height;
+		repaint();
+		}
+	}
+	
+}
+ 
+// eof //
diff --git a/guiserver/java/TextShape.java b/guiserver/java/TextShape.java
new file mode 100644
index 0000000..4e33baf
--- /dev/null
+++ b/guiserver/java/TextShape.java
@@ -0,0 +1,96 @@
+//
+//  TextShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked")
+public class TextShape extends Shape {
+
+String text;
+Font textShapeFont;
+
+public TextShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	text = Base64Coder.decodeString(tokens.nextToken());
+	if(guiserver.UTF8)
+	try {
+		text = new String(text.getBytes(), "UTF-8");
+		} catch (UnsupportedEncodingException ee) {}
+
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+		
+	//System.out.println("text color:" + 
+			//paintColor.getRed() + " " + paintColor.getGreen() + " " + paintColor.getBlue());
+	
+	if(tokens.hasMoreTokens())
+		{
+		double theta = Float.parseFloat(tokens.nextToken());
+		theta = 2.0 * Math.PI * theta / 360.0;
+		transform = AffineTransform.getRotateInstance(theta, X, Y);
+		}
+		
+	//stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	textShapeFont = CanvasWidget.currentCanvas.currentFont;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	//g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//System.out.println("font draw text with:" + textShapeFont);
+	g2.setFont(textShapeFont);
+	//g2.setComposite(currentComposite);
+	
+	g2.drawString(text, X, Y);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	Component component = CanvasWidget.currentCanvas.component;
+	FontMetrics fm = component.getFontMetrics(textShapeFont);	
+
+	int height = fm.getHeight();
+
+	return(new Rectangle(X, Y - height, fm.stringWidth(text), height).contains(x, y));
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/TextShape.java.bak b/guiserver/java/TextShape.java.bak
new file mode 100644
index 0000000..ded7c98
--- /dev/null
+++ b/guiserver/java/TextShape.java.bak
@@ -0,0 +1,96 @@
+//
+//  TextShape.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/24/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.geom.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+@SuppressWarnings("unchecked")
+public class TextShape extends Shape {
+
+String text;
+Font textShapeFont;
+
+public TextShape(StringTokenizer tokens)
+	{
+	tag = tokens.nextToken();
+	text = Base64Coder.decodeString(tokens.nextToken());
+	if(guiserver.UTF8)
+	try {
+		text = new String(text.getBytes(), "UTF-8");
+		} catch (UnsupportedEncodingException ee) {}
+
+	X = Integer.parseInt(tokens.nextToken());
+	Y = Integer.parseInt(tokens.nextToken());
+	
+	if(tokens.hasMoreTokens())
+		paintColor = Shape.getColorParameter(tokens);
+	else
+		paintColor = CanvasWidget.currentCanvas.currentPaint;
+		
+	//System.out.println("text color:" + 
+			//paintColor.getRed() + " " + paintColor.getGreen() + " " + paintColor.getBlue());
+	
+	if(tokens.hasMoreTokens())
+		{
+		double theta = Float.parseFloat(tokens.nextToken());
+		theta = 2.0 * Math.PI * theta / 360.0;
+		transform = AffineTransform.getRotateInstance(theta, X, Y);
+		}
+		
+	//stroke = CanvasWidget.currentCanvas.currentStroke;
+	
+	textShapeFont = CanvasWidget.currentCanvas.currentFont;
+	
+	CanvasWidget.currentCanvas.drawobjects.add(this);
+	}
+	
+public void drawShape(Graphics2D g2)
+	{
+	//g2.setStroke(stroke);
+	g2.setPaint(paintColor);
+	//System.out.println("font draw text with:" + textShapeFont);
+	g2.setFont(textShapeFont);
+	//g2.setComposite(currentComposite);
+	
+	g2.drawString(text, X, Y);
+	}
+	
+public boolean hasPoint(int x, int y)
+	{
+	Component component = CanvasWidget.currentCanvas.component;
+	FontMetrics fm = component.getFontMetrics(textShapeFont);	
+
+	int height = fm.getHeight();
+
+	return(new Rectangle(X, Y - height, fm.stringWidth(text), height).contains(x, y));
+	}
+	
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ToggleButtonWidget.java b/guiserver/java/ToggleButtonWidget.java
new file mode 100644
index 0000000..ecc25d5
--- /dev/null
+++ b/guiserver/java/ToggleButtonWidget.java
@@ -0,0 +1,83 @@
+//
+//  ToggleButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/20/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class ToggleButtonWidget extends aButton{
+
+@SuppressWarnings("unchecked") 
+public ToggleButtonWidget(StringTokenizer params)
+	{
+	abutton = new JToggleButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	
+	if(params.hasMoreTokens())
+		abutton.setSelected(params.nextToken().equals("true"));
+
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(abutton.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	abutton.addActionListener(listener);
+	}
+		
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ToggleButtonWidget.java.bak b/guiserver/java/ToggleButtonWidget.java.bak
new file mode 100644
index 0000000..a3b214c
--- /dev/null
+++ b/guiserver/java/ToggleButtonWidget.java.bak
@@ -0,0 +1,83 @@
+//
+//  ToggleButtonWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/20/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import javax.swing.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class ToggleButtonWidget extends aButton{
+
+@SuppressWarnings("unchecked") 
+public ToggleButtonWidget(StringTokenizer params)
+	{
+	abutton = new JToggleButton();
+	jcomponent = abutton;
+	component = abutton;
+	container = abutton;
+	
+	id = params.nextToken();
+	action = params.nextToken();
+	
+	if(params.hasMoreTokens())
+		{
+		String text = params.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		abutton.setText(text);
+		}
+	
+	if(params.hasMoreTokens())
+		abutton.setSelected(params.nextToken().equals("true"));
+
+	
+	gsObject.widgets.put(id, this);
+	
+	ActionListener listener = new ActionListener() {
+		public void actionPerformed(ActionEvent e)
+			{	
+			if(action != null)
+				{
+				if(abutton.isSelected())
+					guiserver.out.println("("+ action + " \"" + id + "\" true)");
+				else
+					guiserver.out.println("("+ action + " \"" + id + "\" nil)");
+					
+				guiserver.out.flush();
+				}
+			}
+		};
+
+	abutton.addActionListener(listener);
+	}
+		
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ToolbarWidget.java b/guiserver/java/ToolbarWidget.java
new file mode 100644
index 0000000..d76cf02
--- /dev/null
+++ b/guiserver/java/ToolbarWidget.java
@@ -0,0 +1,67 @@
+//
+//  ToolbarWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/22/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked") 
+public class ToolbarWidget extends gsObject {
+
+JToolBar jtoolbar;
+
+public ToolbarWidget(StringTokenizer params)
+	{
+	jtoolbar = new JToolBar();
+	container = jtoolbar;
+	component = jtoolbar;
+	jcomponent = jtoolbar;
+	
+	id = params.nextToken();
+
+	if(params.hasMoreTokens())
+		jtoolbar.setFloatable(params.nextToken().equals("true"));
+	else	
+		jtoolbar.setFloatable(false);
+	
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jtoolbar.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	}
+
+public void addSeparator(StringTokenizer tokens)
+	{
+	jtoolbar.add(new JToolBar.Separator());
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/ToolbarWidget.java.bak b/guiserver/java/ToolbarWidget.java.bak
new file mode 100644
index 0000000..6e587f9
--- /dev/null
+++ b/guiserver/java/ToolbarWidget.java.bak
@@ -0,0 +1,67 @@
+//
+//  ToolbarWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/22/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+
+
+@SuppressWarnings("unchecked") 
+public class ToolbarWidget extends gsObject {
+
+JToolBar jtoolbar;
+
+public ToolbarWidget(StringTokenizer params)
+	{
+	jtoolbar = new JToolBar();
+	container = jtoolbar;
+	component = jtoolbar;
+	jcomponent = jtoolbar;
+	
+	id = params.nextToken();
+
+	if(params.hasMoreTokens())
+		jtoolbar.setFloatable(params.nextToken().equals("true"));
+	else	
+		jtoolbar.setFloatable(false);
+	
+	if(params.hasMoreTokens())
+		{
+		int width = Integer.parseInt(params.nextToken());
+		int height = Integer.parseInt(params.nextToken());
+		jtoolbar.setPreferredSize(new Dimension(width, height));
+		}
+		
+	gsObject.widgets.put(id, this);
+	}
+
+public void addSeparator(StringTokenizer tokens)
+	{
+	jtoolbar.add(new JToolBar.Separator());
+	}
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/WindowFrame.java b/guiserver/java/WindowFrame.java
new file mode 100644
index 0000000..bc20784
--- /dev/null
+++ b/guiserver/java/WindowFrame.java
@@ -0,0 +1,439 @@
+//
+//  WindowFrame.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/11/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.*;
+
+@SuppressWarnings("unchecked")
+public class WindowFrame extends gsObject  {
+
+JFrame jframe;
+String frameCloseAction = null;
+String frameMoveAction = null;
+String frameResizeAction = null;
+
+
+public WindowFrame(StringTokenizer params)
+	{
+	jframe = new JFrame();
+	
+	id = params.nextToken();
+	container = jframe.getContentPane();
+	component = container;
+
+	int x = Integer.parseInt(params.nextToken());
+	int y = Integer.parseInt(params.nextToken());
+	int width = Integer.parseInt(params.nextToken());
+	int height = Integer.parseInt(params.nextToken());
+	
+	gsObject.widgets.put(id, this); 		
+	
+	jframe.setBounds(x, y, width, height);
+
+	// not visible on OSX, but on Win32 and Linux
+	jframe.setIconImage(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/images/newLISP32.png")));
+	
+	if(params.hasMoreTokens())
+		setText(params);
+		
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			jframe.setVisible(true);	
+		}
+		
+		
+	WindowAdapter listener = new WindowAdapter() {
+		public void windowClosing(WindowEvent w)
+			{
+			if(frameCloseAction != null)
+				{
+				jframe.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+				guiserver.out.println("(" + frameCloseAction + "\"" + id + "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	jframe.addWindowListener(listener);
+	
+	
+	ComponentAdapter componentListener = new ComponentAdapter() {
+		public void componentResized(ComponentEvent re) 
+			{
+			if(frameResizeAction != null)
+				{
+				guiserver.out.println("(" + frameResizeAction + "\"" + id + "\"" + 
+						jframe.getWidth() + " " + jframe.getHeight() +")");
+				guiserver.out.flush();
+				}
+			}
+			
+		public void componentMoved(ComponentEvent me)
+			{
+			if(frameMoveAction != null)
+				{
+				guiserver.out.println("(" + frameMoveAction + "\"" + id + "\"" + 
+						jframe.getLocationOnScreen().x + " " + jframe.getLocationOnScreen().y +")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	jframe.addComponentListener(componentListener);
+		
+	jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+	}
+	
+	
+public void setVisible(StringTokenizer tokens)
+	{
+	//jframe.pack();
+	if(tokens.nextToken().equals("true"))
+		jframe.setVisible(true);
+	else
+		jframe.setVisible(false);
+	}
+
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	jframe.setTitle(text);
+	}
+
+
+public void getText(StringTokenizer tokens)
+	{
+	String action = tokens.nextToken();
+	String text = jframe.getTitle();
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+	
+
+public void clearText(StringTokenizer tokens)
+	{
+	jframe.setTitle("");
+	}
+
+
+public void setResizable(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		jframe.setResizable(true);
+	else
+		jframe.setResizable(false);
+	}
+	
+	
+public void confirmDialog(StringTokenizer tokens)
+	{
+	String action = tokens.nextToken();
+	String title = tokens.nextToken();
+	String message = tokens.nextToken(); 
+
+	if(guiserver.UTF8)
+		{
+		title = Base64Coder.decodeStringUTF8(title);
+		message = Base64Coder.decodeStringUTF8(message);
+		}
+	else
+		{
+		title = Base64Coder.decodeString(title);
+		message = Base64Coder.decodeString(message);
+		}
+	
+	int option = JOptionPane.YES_NO_OPTION;
+	
+	if(tokens.hasMoreTokens())
+		{
+		if(!tokens.nextToken().equals("yes-no"))
+			option = JOptionPane.YES_NO_CANCEL_OPTION;
+		}
+			
+	int result = JOptionPane.showConfirmDialog(jframe, message, title, option);
+	
+	guiserver.out.println("(" + action + " \"" + id + "\" " + result + ")");
+	guiserver.out.flush();
+	}
+
+
+public void messageDialog(StringTokenizer tokens)
+	{
+	String title = tokens.nextToken();
+	String message = tokens.nextToken(); 
+
+	if(guiserver.UTF8)
+		{
+		title = Base64Coder.decodeStringUTF8(title);
+		message = Base64Coder.decodeStringUTF8(message);
+		}
+	else
+		{
+		title = Base64Coder.decodeString(title);
+		message = Base64Coder.decodeString(message);
+		}
+	
+	int option = JOptionPane.PLAIN_MESSAGE;
+	String path;
+	
+	if(tokens.hasMoreTokens())
+		{
+		String soption = tokens.nextToken();
+		if(soption.equals("error")) option = JOptionPane.ERROR_MESSAGE;
+		if(soption.equals("information")) option = JOptionPane.INFORMATION_MESSAGE;
+		if(soption.equals("warning")) option = JOptionPane.WARNING_MESSAGE;
+		if(soption.equals("question")) option = JOptionPane.QUESTION_MESSAGE;
+		}
+		
+	if(tokens.hasMoreTokens())
+		{
+		path = Base64Coder.decodeString(tokens.nextToken());
+		JOptionPane.showMessageDialog(jframe, message, title, option, 
+				guiserver.getIconFromPath(path, this.getClass()));
+		}
+	else
+		JOptionPane.showMessageDialog(jframe, message, title, option);
+	}
+
+
+public void ColorChooser(StringTokenizer tokens)
+	{
+	Color color;
+	String action = tokens.nextToken();
+	String title = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		title = Base64Coder.decodeStringUTF8(title);
+	else
+		title = Base64Coder.decodeString(title);
+	
+	Float red;
+	Float green;
+	Float blue;
+	
+	if(tokens.hasMoreTokens()) // get initial color
+		{
+		red = Float.parseFloat(tokens.nextToken());
+		green = Float.parseFloat(tokens.nextToken());
+		blue = Float.parseFloat(tokens.nextToken());
+		color = new Color(red, green, blue);
+		}
+	else color = Color.white;
+		
+	color = JColorChooser.showDialog(jframe, title, color);
+	
+	if(color == null)
+		{
+		guiserver.out.println("(" + action + " \"" + id + "\" \"color\")");
+		guiserver.out.flush();
+		return;
+		}
+	
+	red = (new Integer(color.getRed())).floatValue();
+	green = (new Integer(color.getGreen())).floatValue();
+	blue = (new Integer(color.getBlue())).floatValue();
+	
+	red = red/255;
+	green = green/255;
+	blue = blue/255;
+	
+	guiserver.out.println("(" + action + " \"" + id + "\" \"color\" " + red +  " " + green + " " + blue + ")");
+	guiserver.out.flush();
+	}
+	
+public void OpenFileChooser(StringTokenizer tokens)
+	{
+	JFileChooser filechooser;
+	String file = null;
+	
+	String action = tokens.nextToken();
+
+	if(tokens.hasMoreTokens())
+		filechooser = new JFileChooser(Base64Coder.decodeString(tokens.nextToken()));
+	else
+		filechooser = new JFileChooser();
+		
+	filechooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
+	
+	if(tokens.hasMoreTokens())
+		{
+		MyFileFilter myfilter = new MyFileFilter();
+		myfilter.extensions = Base64Coder.decodeString(tokens.nextToken());
+		myfilter.description = Base64Coder.decodeString(tokens.nextToken());
+		
+		filechooser.setFileFilter(myfilter);
+		}
+
+	int selected = filechooser.showOpenDialog(container);
+	
+	if(selected == JFileChooser.APPROVE_OPTION)
+		{
+		file = Base64Coder.encodeString(filechooser.getSelectedFile().getAbsolutePath());
+		guiserver.out.println("(" + action + " \"" + id + "\" \"open\" " + "\"" + file + "\")");
+		}
+	else
+		{
+		guiserver.out.println("(" + action + " \"" + id + "\" \"open\")");
+		}
+		
+	guiserver.out.flush();
+	}
+
+
+public void SaveFileChooser(StringTokenizer tokens)
+	{
+	JFileChooser filechooser;
+	String file = null;
+	String initialFile = null;
+	
+	String action = tokens.nextToken();
+
+	if(tokens.hasMoreTokens()) // initial directory
+		filechooser = new JFileChooser(Base64Coder.decodeString(tokens.nextToken()));
+	else
+		filechooser = new JFileChooser();
+		
+	if(tokens.hasMoreTokens()) // initial file name
+		{
+		initialFile = Base64Coder.decodeString(tokens.nextToken());
+		filechooser.setSelectedFile(new File(initialFile));
+		}
+		
+		
+	if(tokens.hasMoreTokens())
+		{
+		MyFileFilter myfilter = new MyFileFilter();
+		myfilter.extensions = Base64Coder.decodeString(tokens.nextToken());
+		myfilter.description = Base64Coder.decodeString(tokens.nextToken());
+		filechooser.setFileFilter(myfilter);
+		}
+
+	int selected = filechooser.showSaveDialog(container);
+	
+	if(selected == JFileChooser.APPROVE_OPTION)
+		{
+		file = Base64Coder.encodeString(filechooser.getSelectedFile().getAbsolutePath());
+		guiserver.out.println("(" + action + " \"" + id + "\" \"save\" " + "\"" + file + "\")");
+		}
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" \"save\")");
+		
+	guiserver.out.flush();
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+		
+public void setToolTip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void dispose(StringTokenizer tokens)
+	{
+	jframe.dispose();
+	}
+		
+public void setPreferredSize(StringTokenizer tokens)
+	{
+	int width = Integer.parseInt(tokens.nextToken());
+	int height = Integer.parseInt(tokens.nextToken());
+	jframe.setSize(new Dimension(width, height));
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jframe.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		jframe.setBackground(new Color(red, green, blue));
+	}
+	
+public void requestFocus(StringTokenizer tokens)
+	{
+	jframe.requestFocus();
+	}
+	
+public void frameCloseEvent(StringTokenizer tokens)
+	{
+	frameCloseAction = tokens.nextToken();
+	}
+	
+public void frameResizeEvent(StringTokenizer tokens)
+	{
+	frameResizeAction = tokens.nextToken();
+	}
+	
+public void frameMoveEvent(StringTokenizer tokens)
+	{
+	frameMoveAction = tokens.nextToken();
+	}
+
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = jframe.getLocationOnScreen().x;
+	y = jframe.getLocationOnScreen().y;
+		
+	width = jframe.getWidth();
+	height = jframe.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/WindowFrame.java.bak b/guiserver/java/WindowFrame.java.bak
new file mode 100644
index 0000000..752dde4
--- /dev/null
+++ b/guiserver/java/WindowFrame.java.bak
@@ -0,0 +1,439 @@
+//
+//  WindowFrame.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/11/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.*;
+
+@SuppressWarnings("unchecked")
+public class WindowFrame extends gsObject  {
+
+JFrame jframe;
+String frameCloseAction = null;
+String frameMoveAction = null;
+String frameResizeAction = null;
+
+
+public WindowFrame(StringTokenizer params)
+	{
+	jframe = new JFrame();
+	
+	id = params.nextToken();
+	container = jframe.getContentPane();
+	component = container;
+
+	int x = Integer.parseInt(params.nextToken());
+	int y = Integer.parseInt(params.nextToken());
+	int width = Integer.parseInt(params.nextToken());
+	int height = Integer.parseInt(params.nextToken());
+	
+	gsObject.widgets.put(id, this); 		
+	
+	jframe.setBounds(x, y, width, height);
+
+	// not visible on OSX, but on Win32 and Linux
+	jframe.setIconImage(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/images/newLISP32.png")));
+	
+	if(params.hasMoreTokens())
+		setText(params);
+		
+	if(params.hasMoreTokens())
+		{
+		if(params.nextToken().equals("true"))
+			jframe.setVisible(true);	
+		}
+		
+		
+	WindowAdapter listener = new WindowAdapter() {
+		public void windowClosing(WindowEvent w)
+			{
+			if(frameCloseAction != null)
+				{
+				jframe.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+				guiserver.out.println("(" + frameCloseAction + "\"" + id + "\")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	jframe.addWindowListener(listener);
+	
+	
+	ComponentAdapter componentListener = new ComponentAdapter() {
+		public void componentResized(ComponentEvent re) 
+			{
+			if(frameResizeAction != null)
+				{
+				guiserver.out.println("(" + frameResizeAction + "\"" + id + "\"" + 
+						jframe.getWidth() + " " + jframe.getHeight() +")");
+				guiserver.out.flush();
+				}
+			}
+			
+		public void componentMoved(ComponentEvent me)
+			{
+			if(frameMoveAction != null)
+				{
+				guiserver.out.println("(" + frameMoveAction + "\"" + id + "\"" + 
+						jframe.getLocationOnScreen().x + " " + jframe.getLocationOnScreen().y +")");
+				guiserver.out.flush();
+				}
+			}
+		};
+		
+	jframe.addComponentListener(componentListener);
+		
+	jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+	}
+	
+	
+public void setVisible(StringTokenizer tokens)
+	{
+	//jframe.pack();
+	if(tokens.nextToken().equals("true"))
+		jframe.setVisible(true);
+	else
+		jframe.setVisible(false);
+	}
+
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	jframe.setTitle(text);
+	}
+
+
+public void getText(StringTokenizer tokens)
+	{
+	String action = tokens.nextToken();
+	String text = jframe.getTitle();
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+	
+
+public void clearText(StringTokenizer tokens)
+	{
+	jframe.setTitle("");
+	}
+
+
+public void setResizable(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		jframe.setResizable(true);
+	else
+		jframe.setResizable(false);
+	}
+	
+	
+public void confirmDialog(StringTokenizer tokens)
+	{
+	String action = tokens.nextToken();
+	String title = tokens.nextToken();
+	String message = tokens.nextToken(); 
+
+	if(guiserver.UTF8)
+		{
+		title = Base64Coder.decodeStringUTF8(title);
+		message = Base64Coder.decodeStringUTF8(message);
+		}
+	else
+		{
+		title = Base64Coder.decodeString(title);
+		message = Base64Coder.decodeString(message);
+		}
+	
+	int option = JOptionPane.YES_NO_OPTION;
+	
+	if(tokens.hasMoreTokens())
+		{
+		if(!tokens.nextToken().equals("yes-no"))
+			option = JOptionPane.YES_NO_CANCEL_OPTION;
+		}
+			
+	int result = JOptionPane.showConfirmDialog(jframe, message, title, option);
+	
+	guiserver.out.println("(" + action + " \"" + id + "\" " + result + ")");
+	guiserver.out.flush();
+	}
+
+
+public void messageDialog(StringTokenizer tokens)
+	{
+	String title = tokens.nextToken();
+	String message = tokens.nextToken(); 
+
+	if(guiserver.UTF8)
+		{
+		title = Base64Coder.decodeStringUTF8(title);
+		message = Base64Coder.decodeStringUTF8(message);
+		}
+	else
+		{
+		title = Base64Coder.decodeString(title);
+		message = Base64Coder.decodeString(message);
+		}
+	
+	int option = JOptionPane.PLAIN_MESSAGE;
+	String path;
+	
+	if(tokens.hasMoreTokens())
+		{
+		String soption = tokens.nextToken();
+		if(soption.equals("error")) option = JOptionPane.ERROR_MESSAGE;
+		if(soption.equals("information")) option = JOptionPane.INFORMATION_MESSAGE;
+		if(soption.equals("warning")) option = JOptionPane.WARNING_MESSAGE;
+		if(soption.equals("question")) option = JOptionPane.QUESTION_MESSAGE;
+		}
+		
+	if(tokens.hasMoreTokens())
+		{
+		path = Base64Coder.decodeString(tokens.nextToken());
+		JOptionPane.showMessageDialog(jframe, message, title, option, 
+				guiserver.getIconFromPath(path, this.getClass()));
+		}
+	else
+		JOptionPane.showMessageDialog(jframe, message, title, option);
+	}
+
+
+public void ColorChooser(StringTokenizer tokens)
+	{
+	Color color;
+	String action = tokens.nextToken();
+	String title = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		title = Base64Coder.decodeStringUTF8(title);
+	else
+		title = Base64Coder.decodeString(title);
+	
+	Float red;
+	Float green;
+	Float blue;
+	
+	if(tokens.hasMoreTokens()) // get initial color
+		{
+		red = Float.parseFloat(tokens.nextToken());
+		green = Float.parseFloat(tokens.nextToken());
+		blue = Float.parseFloat(tokens.nextToken());
+		color = new Color(red, green, blue);
+		}
+	else color = Color.white;
+		
+	color = JColorChooser.showDialog(jframe, title, color);
+	
+	if(color == null)
+		{
+		guiserver.out.println("(" + action + " \"" + id + "\" \"color\")");
+		guiserver.out.flush();
+		return;
+		}
+	
+	red = (new Integer(color.getRed())).floatValue();
+	green = (new Integer(color.getGreen())).floatValue();
+	blue = (new Integer(color.getBlue())).floatValue();
+	
+	red = red/255;
+	green = green/255;
+	blue = blue/255;
+	
+	guiserver.out.println("(" + action + " \"" + id + "\" \"color\" " + red +  " " + green + " " + blue + ")");
+	guiserver.out.flush();
+	}
+	
+public void OpenFileChooser(StringTokenizer tokens)
+	{
+	JFileChooser filechooser;
+	String file = null;
+	
+	String action = tokens.nextToken();
+
+	if(tokens.hasMoreTokens())
+		filechooser = new JFileChooser(Base64Coder.decodeString(tokens.nextToken()));
+	else
+		filechooser = new JFileChooser();
+		
+	filechooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
+	
+	if(tokens.hasMoreTokens())
+		{
+		MyFileFilter myfilter = new MyFileFilter();
+		myfilter.extensions = Base64Coder.decodeString(tokens.nextToken());
+		myfilter.description = Base64Coder.decodeString(tokens.nextToken());
+		
+		filechooser.setFileFilter(myfilter);
+		}
+
+	int selected = filechooser.showOpenDialog(container);
+	
+	if(selected == JFileChooser.APPROVE_OPTION)
+		{
+		file = Base64Coder.encodeString(filechooser.getSelectedFile().getAbsolutePath());
+		guiserver.out.println("(" + action + " \"" + id + "\" \"open\" " + "\"" + file + "\")");
+		}
+	else
+		{
+		guiserver.out.println("(" + action + " \"" + id + "\" \"open\")");
+		}
+		
+	guiserver.out.flush();
+	}
+
+
+public void SaveFileChooser(StringTokenizer tokens)
+	{
+	JFileChooser filechooser;
+	String file = null;
+	String initialFile = null;
+	
+	String action = tokens.nextToken();
+
+	if(tokens.hasMoreTokens()) // initial directory
+		filechooser = new JFileChooser(Base64Coder.decodeString(tokens.nextToken()));
+	else
+		filechooser = new JFileChooser();
+		
+	if(tokens.hasMoreTokens()) // initial file name
+		{
+		initialFile = Base64Coder.decodeString(tokens.nextToken());
+		filechooser.setSelectedFile(new File(initialFile));
+		}
+		
+		
+	if(tokens.hasMoreTokens())
+		{
+		MyFileFilter myfilter = new MyFileFilter();
+		myfilter.extensions = Base64Coder.decodeString(tokens.nextToken());
+		myfilter.description = Base64Coder.decodeString(tokens.nextToken());
+		filechooser.setFileFilter(myfilter);
+		}
+
+	int selected = filechooser.showSaveDialog(container);
+	
+	if(selected == JFileChooser.APPROVE_OPTION)
+		{
+		file = Base64Coder.encodeString(filechooser.getSelectedFile().getAbsolutePath());
+		guiserver.out.println("(" + action + " \"" + id + "\" \"save\" " + "\"" + file + "\")");
+		}
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" \"save\")");
+		
+	guiserver.out.flush();
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+		
+public void setToolTip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void dispose(StringTokenizer tokens)
+	{
+	jframe.dispose();
+	}
+		
+public void setPreferredSize(StringTokenizer tokens)
+	{
+	int width = Integer.parseInt(tokens.nextToken());
+	int height = Integer.parseInt(tokens.nextToken());
+	jframe.setSize(new Dimension(width, height));
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jframe.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		jframe.setBackground(new Color(red, green, blue));
+	}
+	
+public void requestFocus(StringTokenizer tokens)
+	{
+	jframe.requestFocus();
+	}
+	
+public void frameCloseEvent(StringTokenizer tokens)
+	{
+	frameCloseAction = tokens.nextToken();
+	}
+	
+public void frameResizeEvent(StringTokenizer tokens)
+	{
+	frameResizeAction = tokens.nextToken();
+	}
+	
+public void frameMoveEvent(StringTokenizer tokens)
+	{
+	frameMoveAction = tokens.nextToken();
+	}
+
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = jframe.getLocationOnScreen().x;
+	y = jframe.getLocationOnScreen().y;
+		
+	width = jframe.getWidth();
+	height = jframe.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/WindowWidget.java b/guiserver/java/WindowWidget.java
new file mode 100644
index 0000000..0de3faf
--- /dev/null
+++ b/guiserver/java/WindowWidget.java
@@ -0,0 +1,114 @@
+//
+//  WindowWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/16/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+
+@SuppressWarnings("unchecked")
+public class WindowWidget extends gsObject {
+
+Window window;
+Frame frame;
+
+public WindowWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	
+	frame = new Frame();
+	window = new Window(frame);
+	component = window;
+	container = window;
+	
+	int x = Integer.parseInt(params.nextToken());
+	int y = Integer.parseInt(params.nextToken());
+	int width = Integer.parseInt(params.nextToken());
+	int height = Integer.parseInt(params.nextToken());
+
+	window.setBounds(x, y, width, height);
+		
+	gsObject.widgets.put(id, this);
+	}
+	
+
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		component.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		component.setBackground(new Color(red, green, blue));
+	}
+
+public void dispose(StringTokenizer tokens)
+	{
+	window.dispose();
+	frame.dispose();
+	} 
+	
+public void setFont(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+		
+public void setToolTip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setTitledBorder(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setBevelBorder(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = frame.getLocationOnScreen().x;
+	y = frame.getLocationOnScreen().y;
+		
+	width = frame.getWidth();
+	height = frame.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+		
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/WindowWidget.java.bak b/guiserver/java/WindowWidget.java.bak
new file mode 100644
index 0000000..337e07e
--- /dev/null
+++ b/guiserver/java/WindowWidget.java.bak
@@ -0,0 +1,114 @@
+//
+//  WindowWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/16/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.color.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+
+@SuppressWarnings("unchecked")
+public class WindowWidget extends gsObject {
+
+Window window;
+Frame frame;
+
+public WindowWidget(StringTokenizer params)
+	{
+	id = params.nextToken();
+	
+	frame = new Frame();
+	window = new Window(frame);
+	component = window;
+	container = window;
+	
+	int x = Integer.parseInt(params.nextToken());
+	int y = Integer.parseInt(params.nextToken());
+	int width = Integer.parseInt(params.nextToken());
+	int height = Integer.parseInt(params.nextToken());
+
+	window.setBounds(x, y, width, height);
+		
+	gsObject.widgets.put(id, this);
+	}
+	
+
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		component.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		component.setBackground(new Color(red, green, blue));
+	}
+
+public void dispose(StringTokenizer tokens)
+	{
+	window.dispose();
+	frame.dispose();
+	} 
+	
+public void setFont(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+		
+public void setToolTip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setTitledBorder(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setBevelBorder(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = frame.getLocationOnScreen().x;
+	y = frame.getLocationOnScreen().y;
+		
+	width = frame.getWidth();
+	height = frame.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+		
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/aButton.java b/guiserver/java/aButton.java
new file mode 100644
index 0000000..090fe9b
--- /dev/null
+++ b/guiserver/java/aButton.java
@@ -0,0 +1,114 @@
+//
+//  aButton.java  
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/25/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class aButton extends gsObject {
+
+AbstractButton abutton;
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	abutton.setText(text);
+	}
+	
+public void appendText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = abutton.getText();
+	text = oldtext + text;
+
+	abutton.setText(text);
+	}
+
+public void getText(StringTokenizer params)
+	{
+	String action = params.nextToken();
+	String text = abutton.getText();
+
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+
+public void clearText(StringTokenizer tokens)
+	{
+	abutton.setText("");
+	}
+	
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	abutton.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+	
+public void setPressedIcon(StringTokenizer tokens)
+	{	
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	abutton.setPressedIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+	
+public void setSelected(StringTokenizer tokens)
+	{
+	String target;
+	aButton thebutton;
+	
+	abutton.setSelected(tokens.nextToken().equals("true"));
+	
+	while(tokens.hasMoreTokens())
+		{
+		target = tokens.nextToken();
+		thebutton = (aButton)gsObject.widgets.get(target);
+		thebutton.abutton.setSelected(tokens.nextToken().equals("true"));
+		}
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/aButton.java.bak b/guiserver/java/aButton.java.bak
new file mode 100644
index 0000000..7c42683
--- /dev/null
+++ b/guiserver/java/aButton.java.bak
@@ -0,0 +1,114 @@
+//
+//  aButton.java  
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/25/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class aButton extends gsObject {
+
+AbstractButton abutton;
+
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	abutton.setText(text);
+	}
+	
+public void appendText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = abutton.getText();
+	text = oldtext + text;
+
+	abutton.setText(text);
+	}
+
+public void getText(StringTokenizer params)
+	{
+	String action = params.nextToken();
+	String text = abutton.getText();
+
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+
+public void clearText(StringTokenizer tokens)
+	{
+	abutton.setText("");
+	}
+	
+public void setIcon(StringTokenizer tokens)
+	{
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	abutton.setIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+	
+public void setPressedIcon(StringTokenizer tokens)
+	{	
+	String path = Base64Coder.decodeString(tokens.nextToken());
+	abutton.setPressedIcon(guiserver.getIconFromPath(path, this.getClass()));
+	}
+	
+public void setSelected(StringTokenizer tokens)
+	{
+	String target;
+	aButton thebutton;
+	
+	abutton.setSelected(tokens.nextToken().equals("true"));
+	
+	while(tokens.hasMoreTokens())
+		{
+		target = tokens.nextToken();
+		thebutton = (aButton)gsObject.widgets.get(target);
+		thebutton.abutton.setSelected(tokens.nextToken().equals("true"));
+		}
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/aTextWidget.java b/guiserver/java/aTextWidget.java
new file mode 100644
index 0000000..ad9a643
--- /dev/null
+++ b/guiserver/java/aTextWidget.java
@@ -0,0 +1,347 @@
+//
+//  aTextWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/14/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.text.*;
+import java.io.UnsupportedEncodingException;
+
+public class aTextWidget extends gsObject {
+
+JTextComponent textcomp;
+JScrollPane areaScrollPane;
+boolean isScrollable;
+String findTextAction;
+	
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	textcomp.setText(text);
+	}
+
+	
+public void appendText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = textcomp.getText();
+	int len = text.length() + oldtext.length();
+	if(len > 100000)
+			textcomp.setText((oldtext + text).substring(len - 100000));
+	else
+			textcomp.setText(oldtext + text);
+
+	if(isScrollable) scrollUp();
+	textcomp.repaint();
+	}
+	
+public void scrollUp()
+    {
+	// work around for Java bug #4201999
+	try {Thread.sleep(100); } catch (InterruptedException ie) {}
+	//textArea.setCaretPosition(textArea.getText().length() - 1);
+	JScrollBar vbar = areaScrollPane.getVerticalScrollBar();
+    vbar.setValue(vbar.getMaximum());
+    }
+	
+public void gotoText(StringTokenizer params)
+	{
+	int line = Integer.parseInt(params.nextToken());
+	int column = Integer.parseInt(params.nextToken());
+	
+	if(line < 1) line = 1;
+	line--;
+	
+	String text = textcomp.getText();
+	int len = text.length();
+	int pos = 0;
+	int col;
+
+	
+	for(int idx = 0; idx < line; idx++)
+		{
+		pos = text.indexOf("\n", pos) + 1;
+		if(pos >= len) break;
+		}
+		
+	for(col = 0; col < column; col++)
+		{
+		if(pos + col >= len) break;
+		if(text.charAt(pos + col) == '\n') break;
+		}
+		
+	textcomp.setCaretPosition(pos + col);
+	}
+
+public void clearText(StringTokenizer params)
+	{
+	textcomp.setText("");
+	}
+	
+public void getText(StringTokenizer params)
+	{
+	String text = textcomp.getText();
+	if(text == null) text = "";
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+	
+	if(params.hasMoreTokens())
+		{
+		String action = params.nextToken();
+		if(text.length() == 0)
+			guiserver.out.println("(" + action + " \"" + id + "\")");
+		else
+			guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+		}
+	else
+		{
+		if(text.length() == 0)
+			guiserver.out.println("(set 'gs:text {})");
+		else
+			guiserver.out.println("(set 'gs:text (base64-dec [text]" + text + "[/text]))");
+		}
+		
+	guiserver.out.flush();
+	}
+		
+public void getSelection(StringTokenizer params)
+	{
+	String action = params.nextToken();
+	String text = textcomp.getSelectedText();
+	if(text == null) text = "";
+
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+	
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+	
+public void getTextPosition(StringTokenizer tokens)
+	{
+	String text = textcomp.getText();
+	int caret = textcomp.getCaretPosition();
+	int line = 1;
+	int col = 1;
+	
+	for(int i= 0; i < caret; i++)
+		{
+		if(text.charAt(i) == '\n') 
+			{
+			col = 0;
+			++line;
+			}
+		++col;
+		}
+		
+	guiserver.out.println("(set 'gs:text-position '(" + line + " " + col + "))");
+	guiserver.out.flush();
+	}	
+	
+	
+public void setEditable(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		textcomp.setEditable(true);
+	else
+		textcomp.setEditable(false);
+	}
+	
+public void setCaret(StringTokenizer tokens)
+	{
+	int pos = Integer.parseInt(tokens.nextToken());
+	
+	if(pos > textcomp.getText().length())
+		pos = textcomp.getText().length();
+		
+	textcomp.setCaretPosition(pos);
+	textcomp.moveCaretPosition(pos);
+	}
+	
+public void selectText(StringTokenizer tokens)
+	{
+	int toPos;
+	
+	textcomp.setCaretPosition(Integer.parseInt(tokens.nextToken()));
+	if(tokens.hasMoreTokens())
+		toPos = Integer.parseInt(tokens.nextToken());
+	else
+		toPos = textcomp.getText().length();
+		
+	textcomp.moveCaretPosition(toPos);
+	}
+	
+public void copyText(StringTokenizer tokens)
+	{
+	textcomp.copy();
+	}
+
+public void cutText(StringTokenizer tokens)
+	{
+	textcomp.cut();
+	}
+	
+public void pasteText(StringTokenizer tokens)
+	{
+	if(tokens.hasMoreTokens())
+		{
+		String text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		textcomp.replaceSelection(text);
+		}
+	else
+		textcomp.paste();
+	}
+
+	
+public void insertText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = textcomp.getText();
+	int newpos = Integer.parseInt(tokens.nextToken());
+	if(newpos > textcomp.getText().length()) newpos = textcomp.getText().length();
+	textcomp.setText(oldtext.substring(0, newpos) + text + oldtext.substring(newpos));
+	textcomp.update(textcomp.getGraphics());
+	}
+
+public void requestFocus(StringTokenizer tokens)
+	{
+	textcomp.requestFocus();
+	}
+
+public void setFont(StringTokenizer tokens)
+	{
+	int style = 0;
+	int size = 12;
+	String name = tokens.nextToken();
+
+	if(guiserver.UTF8)
+		name = Base64Coder.decodeStringUTF8(name);
+	else
+		name = Base64Coder.decodeString(name);
+
+	if(tokens.hasMoreTokens())
+		size = Integer.parseInt(tokens.nextToken());
+	
+	while(tokens.hasMoreTokens())
+		{
+		String sstyle = tokens.nextToken();
+		if(sstyle.equals("plain")) style = style | Font.PLAIN;
+		if(sstyle.equals("bold")) style = style | Font.BOLD;
+		if(sstyle.equals("italic")) style = style | Font.ITALIC;
+		}
+		
+	Font font = new Font(name, style, size);
+	textcomp.setFont(font);
+	}
+
+
+public void registerMouseEvent(StringTokenizer tokens)
+	{
+	mouseEvent = tokens.nextToken();
+	jcomponent.addMouseListener(new MouseAdapter () {
+		public void mouseClicked(MouseEvent e) { mouseEventOut(e, "clicked"); }	
+		public void mousePressed(MouseEvent e) { mouseEventOut(e, "pressed"); }
+		public void mouseReleased(MouseEvent e) { mouseEventOut(e, "released"); }
+		});
+	}
+	
+private void mouseEventOut(MouseEvent e, String type)
+	{
+	guiserver.out.println("(" + mouseEvent + " \"" + id + "\" \"" + type + "\" " + e.getX() + " " + e.getY() + " " + 
+		e.getButton() + " " + e.getClickCount() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+		
+public static String removeChar(String str, char ch) 
+		{
+		String result = "";
+		for (int i = 0; i < str.length(); i ++) 
+			{
+			if (str.charAt(i) != ch) 
+				result += str.charAt(i);
+			}
+		
+		return result;
+		}
+		
+public void setCaretColor(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+		
+	textcomp.setCaretColor(new Color(red, green, blue));
+	}
+
+
+public void setSelectionColor(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	Float alpha = (float)1.0;
+	
+	if(tokens.hasMoreTokens())
+		alpha = Float.parseFloat(tokens.nextToken());
+		
+	textcomp.setSelectionColor(new Color(red, green, blue, alpha));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/aTextWidget.java.bak b/guiserver/java/aTextWidget.java.bak
new file mode 100644
index 0000000..cd255a5
--- /dev/null
+++ b/guiserver/java/aTextWidget.java.bak
@@ -0,0 +1,347 @@
+//
+//  aTextWidget.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 6/14/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import javax.swing.*;
+import javax.swing.text.*;
+import java.io.UnsupportedEncodingException;
+
+public class aTextWidget extends gsObject {
+
+JTextComponent textcomp;
+JScrollPane areaScrollPane;
+boolean isScrollable;
+String findTextAction;
+	
+public void setText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	textcomp.setText(text);
+	}
+
+	
+public void appendText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = textcomp.getText();
+	int len = text.length() + oldtext.length();
+	if(len > 100000)
+			textcomp.setText((oldtext + text).substring(len - 100000));
+	else
+			textcomp.setText(oldtext + text);
+
+	if(isScrollable) scrollUp();
+	textcomp.repaint();
+	}
+	
+public void scrollUp()
+    {
+	// work around for Java bug #4201999
+	try {Thread.sleep(100); } catch (InterruptedException ie) {}
+	//textArea.setCaretPosition(textArea.getText().length() - 1);
+	JScrollBar vbar = areaScrollPane.getVerticalScrollBar();
+    vbar.setValue(vbar.getMaximum());
+    }
+	
+public void gotoText(StringTokenizer params)
+	{
+	int line = Integer.parseInt(params.nextToken());
+	int column = Integer.parseInt(params.nextToken());
+	
+	if(line < 1) line = 1;
+	line--;
+	
+	String text = textcomp.getText();
+	int len = text.length();
+	int pos = 0;
+	int col;
+
+	
+	for(int idx = 0; idx < line; idx++)
+		{
+		pos = text.indexOf("\n", pos) + 1;
+		if(pos >= len) break;
+		}
+		
+	for(col = 0; col < column; col++)
+		{
+		if(pos + col >= len) break;
+		if(text.charAt(pos + col) == '\n') break;
+		}
+		
+	textcomp.setCaretPosition(pos + col);
+	}
+
+public void clearText(StringTokenizer params)
+	{
+	textcomp.setText("");
+	}
+	
+public void getText(StringTokenizer params)
+	{
+	String text = textcomp.getText();
+	if(text == null) text = "";
+	
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+	
+	if(params.hasMoreTokens())
+		{
+		String action = params.nextToken();
+		if(text.length() == 0)
+			guiserver.out.println("(" + action + " \"" + id + "\")");
+		else
+			guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+		}
+	else
+		{
+		if(text.length() == 0)
+			guiserver.out.println("(set 'gs:text {})");
+		else
+			guiserver.out.println("(set 'gs:text (base64-dec [text]" + text + "[/text]))");
+		}
+		
+	guiserver.out.flush();
+	}
+		
+public void getSelection(StringTokenizer params)
+	{
+	String action = params.nextToken();
+	String text = textcomp.getSelectedText();
+	if(text == null) text = "";
+
+	if(guiserver.UTF8 && text.length() != 0)
+		text = Base64Coder.encodeStringUTF8(text);
+	else
+		text = Base64Coder.encodeString(text);
+	
+	if(text.length() == 0)
+		guiserver.out.println("(" + action + " \"" + id + "\")");
+	else
+		guiserver.out.println("(" + action + " \"" + id + "\" [text]" + text + "[/text])");
+	guiserver.out.flush();
+	}
+	
+public void getTextPosition(StringTokenizer tokens)
+	{
+	String text = textcomp.getText();
+	int caret = textcomp.getCaretPosition();
+	int line = 1;
+	int col = 1;
+	
+	for(int i= 0; i < caret; i++)
+		{
+		if(text.charAt(i) == '\n') 
+			{
+			col = 0;
+			++line;
+			}
+		++col;
+		}
+		
+	guiserver.out.println("(set 'gs:text-position '(" + line + " " + col + "))");
+	guiserver.out.flush();
+	}	
+	
+	
+public void setEditable(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		textcomp.setEditable(true);
+	else
+		textcomp.setEditable(false);
+	}
+	
+public void setCaret(StringTokenizer tokens)
+	{
+	int pos = Integer.parseInt(tokens.nextToken());
+	
+	if(pos > textcomp.getText().length())
+		pos = textcomp.getText().length();
+		
+	textcomp.setCaretPosition(pos);
+	textcomp.moveCaretPosition(pos);
+	}
+	
+public void selectText(StringTokenizer tokens)
+	{
+	int toPos;
+	
+	textcomp.setCaretPosition(Integer.parseInt(tokens.nextToken()));
+	if(tokens.hasMoreTokens())
+		toPos = Integer.parseInt(tokens.nextToken());
+	else
+		toPos = textcomp.getText().length();
+		
+	textcomp.moveCaretPosition(toPos);
+	}
+	
+public void copyText(StringTokenizer tokens)
+	{
+	textcomp.copy();
+	}
+
+public void cutText(StringTokenizer tokens)
+	{
+	textcomp.cut();
+	}
+	
+public void pasteText(StringTokenizer tokens)
+	{
+	if(tokens.hasMoreTokens())
+		{
+		String text = tokens.nextToken();
+	
+		if(guiserver.UTF8)
+			text = Base64Coder.decodeStringUTF8(text);
+		else
+			text = Base64Coder.decodeString(text);
+
+		textcomp.replaceSelection(text);
+		}
+	else
+		textcomp.paste();
+	}
+
+	
+public void insertText(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	String oldtext = textcomp.getText();
+	int newpos = Integer.parseInt(tokens.nextToken());
+	if(newpos > textcomp.getText().length()) newpos = textcomp.getText().length();
+	textcomp.setText(oldtext.substring(0, newpos) + text + oldtext.substring(newpos));
+	textcomp.update(textcomp.getGraphics());
+	}
+
+public void requestFocus(StringTokenizer tokens)
+	{
+	textcomp.requestFocus();
+	}
+
+public void setFont(StringTokenizer tokens)
+	{
+	int style = 0;
+	int size = 12;
+	String name = tokens.nextToken();
+
+	if(guiserver.UTF8)
+		name = Base64Coder.decodeStringUTF8(name);
+	else
+		name = Base64Coder.decodeString(name);
+
+	if(tokens.hasMoreTokens())
+		size = Integer.parseInt(tokens.nextToken());
+	
+	while(tokens.hasMoreTokens())
+		{
+		String sstyle = tokens.nextToken();
+		if(sstyle.equals("plain")) style = style | Font.PLAIN;
+		if(sstyle.equals("bold")) style = style | Font.BOLD;
+		if(sstyle.equals("italic")) style = style | Font.ITALIC;
+		}
+		
+	Font font = new Font(name, style, size);
+	textcomp.setFont(font);
+	}
+
+
+public void registerMouseEvent(StringTokenizer tokens)
+	{
+	mouseEvent = tokens.nextToken();
+	jcomponent.addMouseListener(new MouseAdapter () {
+		public void mouseClicked(MouseEvent e) { mouseEventOut(e, "clicked"); }	
+		public void mousePressed(MouseEvent e) { mouseEventOut(e, "pressed"); }
+		public void mouseReleased(MouseEvent e) { mouseEventOut(e, "released"); }
+		});
+	}
+	
+private void mouseEventOut(MouseEvent e, String type)
+	{
+	guiserver.out.println("(" + mouseEvent + " \"" + id + "\" \"" + type + "\" " + e.getX() + " " + e.getY() + " " + 
+		e.getButton() + " " + e.getClickCount() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+		
+public static String removeChar(String str, char ch) 
+		{
+		String result = "";
+		for (int i = 0; i < str.length(); i ++) 
+			{
+			if (str.charAt(i) != ch) 
+				result += str.charAt(i);
+			}
+		
+		return result;
+		}
+		
+public void setCaretColor(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+		
+	textcomp.setCaretColor(new Color(red, green, blue));
+	}
+
+
+public void setSelectionColor(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	Float alpha = (float)1.0;
+	
+	if(tokens.hasMoreTokens())
+		alpha = Float.parseFloat(tokens.nextToken());
+		
+	textcomp.setSelectionColor(new Color(red, green, blue, alpha));
+	}
+
+}
+ 
+ 
+// eof //
diff --git a/guiserver/java/gsObject.java b/guiserver/java/gsObject.java
new file mode 100644
index 0000000..ed2c10f
--- /dev/null
+++ b/guiserver/java/gsObject.java
@@ -0,0 +1,875 @@
+//
+//  gsObject.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/19/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.font.*;
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.border.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class gsObject {
+
+static HashMap widgets = new HashMap();
+
+String id;
+String action;
+JComponent jcomponent = null;
+Container container = null;
+Component component = null;
+Dispatcher dispatch = null;
+String mouseEvent = null;
+String keyEvent = null;
+
+public void addTo(StringTokenizer tokens)
+	{
+	boolean isBorderLayout = (container.getLayout() instanceof LayoutBorder);
+	while(tokens.hasMoreTokens())
+		{
+		String comp = tokens.nextToken();
+		//System.out.println("adding: " + comp + " to: " + id);
+		gsObject gsobject = (gsObject)gsObject.widgets.get(comp);
+		Component compnt = gsobject.component;
+		if(isBorderLayout)
+			{
+			String direction = tokens.nextToken();
+			if(direction.equals("north")) container.add(compnt, BorderLayout.NORTH);
+			else if(direction.equals("west")) container.add(compnt, BorderLayout.WEST);
+			else if(direction.equals("center")) container.add(compnt, BorderLayout.CENTER);
+			else if(direction.equals("east")) container.add(compnt, BorderLayout.EAST);
+			else if(direction.equals("south")) container.add(compnt, BorderLayout.SOUTH);
+			else container.add(compnt, BorderLayout.CENTER);
+			}
+		else container.add(compnt);
+		}
+	}
+	
+public void removeFrom(StringTokenizer tokens)
+	{
+	String comp = tokens.nextToken();
+	gsObject gsobject = (gsObject)gsObject.widgets.get(comp);
+	Component compnt = gsobject.component;
+	container.remove(compnt);
+	container.update(container.getGraphics());
+	}
+	
+public void layout(StringTokenizer tokens)
+	{
+	container.validate();
+	}
+	
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = component.getX();
+	y = component.getY();
+		
+	width = component.getWidth();
+	height = component.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+	
+	
+public void loadText(StringTokenizer tokens)
+	{
+	}
+	
+public void saveText(StringTokenizer tokens)
+	{
+	}
+	
+public void setText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void appendText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void getText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void getSelection(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void clearText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setCaret(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void selectText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void copyText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void cutText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void pasteText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void undoText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void undoEnable(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void redoText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void clearList(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setVisible(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		component.setVisible(true);
+	else
+		component.setVisible(false);
+	}
+
+
+public void setResizable(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setSize(StringTokenizer tokens)
+	{
+	int width = Integer.parseInt(tokens.nextToken());
+	int height = Integer.parseInt(tokens.nextToken());
+	component.setSize(new Dimension(width, height));
+	}
+	
+public void setPreferredSize(StringTokenizer tokens)
+	{
+	int width = Integer.parseInt(tokens.nextToken());
+	int height = Integer.parseInt(tokens.nextToken());
+	component.setPreferredSize(new Dimension(width, height));
+	}
+	
+public void Enable(StringTokenizer tokens)
+	{
+	gsObject gsobject;
+	
+	component.setEnabled(true);
+	
+	while(tokens.hasMoreTokens())
+		{
+		gsobject = (gsObject)gsObject.widgets.get(tokens.nextToken());
+		gsobject.component.setEnabled(true);
+		}
+	}
+	
+public void Disable(StringTokenizer tokens)
+	{
+	gsObject gsobject;
+	
+	component.setEnabled(false);
+
+	while(tokens.hasMoreTokens())
+		{
+		gsobject = (gsObject)gsObject.widgets.get(tokens.nextToken());
+		gsobject.component.setEnabled(false);
+		}
+	}
+	
+public void setToolTip(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	jcomponent.setToolTipText(text);
+	}
+	
+public void setEchoChar(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setEditable(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setValue(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setSelected(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setTitledBorder(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+		
+	jcomponent.setBorder(BorderFactory.createTitledBorder(text));
+	}
+	
+public void setBevelBorder(StringTokenizer tokens)
+	{
+	int type = BevelBorder.RAISED;
+	
+	if(tokens.hasMoreTokens())
+		{
+		String stype = tokens.nextToken();		
+		if(stype.equals("lowered")) type = BevelBorder.LOWERED;
+		}
+	
+	jcomponent.setBorder(BorderFactory.createBevelBorder(type));
+	}
+	
+public void setIcon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setPressedIcon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void messageDialog(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void confirmationDialog(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void ColorChooser(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void OpenFileChooser(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void SaveFileChooser(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void requestFocus(StringTokenizer tokens)
+	{
+	component.requestFocus();
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	String name = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		name = Base64Coder.decodeStringUTF8(name);
+	else
+		name = Base64Coder.decodeString(name);
+
+	int style = 0;
+	int size = 12;
+	
+	if(tokens.hasMoreTokens())
+		size = Integer.parseInt(tokens.nextToken());
+	
+	while(tokens.hasMoreTokens())
+		{
+		String sstyle = tokens.nextToken();
+		if(sstyle.equals("plain")) style = style | Font.PLAIN;
+		if(sstyle.equals("bold")) style = style | Font.BOLD;
+		if(sstyle.equals("italic")) style = style | Font.ITALIC;
+		}
+		
+	Font font = new Font(name, style, size);
+	jcomponent.setFont(font);
+	}
+	
+public void getFontMetrics(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	FontMetrics fm = component.getFontMetrics(component.getFont());
+	
+	int width = fm.stringWidth(text);
+	int height = fm.getHeight();
+	
+	//System.out.println("width:" + width + " height:" + height);
+	
+	guiserver.out.println("(set 'gs:font-metrics '(" + width + " " + height + "))");
+	guiserver.out.flush();
+	}
+	
+public void setForeground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jcomponent.setForeground(new Color(red, green, blue, alpha));
+		}
+	else
+		jcomponent.setForeground(new Color(red, green, blue));
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jcomponent.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		jcomponent.setBackground(new Color(red, green, blue));
+	}
+
+public void setCaretColor(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+
+public void setSyntax(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setCursor(StringTokenizer tokens)
+	{
+	String shape = tokens.nextToken();
+	Cursor cursor = null;
+	
+	if(shape.equals("crosshair")) cursor = new Cursor(Cursor.CROSSHAIR_CURSOR);
+	else if(shape.equals("text")) cursor = new Cursor(Cursor.TEXT_CURSOR);
+	else if(shape.equals("wait")) cursor = new Cursor(Cursor.WAIT_CURSOR);
+	else if(shape.equals("sw-resize")) cursor = new Cursor(Cursor.SW_RESIZE_CURSOR);
+	else if(shape.equals("se-resize")) cursor = new Cursor(Cursor.SE_RESIZE_CURSOR);
+	else if(shape.equals("nw-resize")) cursor = new Cursor(Cursor.NW_RESIZE_CURSOR);
+	else if(shape.equals("ne-resize")) cursor = new Cursor(Cursor.NE_RESIZE_CURSOR);
+	else if(shape.equals("n-resize")) cursor = new Cursor(Cursor.N_RESIZE_CURSOR);
+	else if(shape.equals("s-resize")) cursor = new Cursor(Cursor.S_RESIZE_CURSOR);
+	else if(shape.equals("w-resize")) cursor = new Cursor(Cursor.W_RESIZE_CURSOR);
+	else if(shape.equals("e-resize")) cursor = new Cursor(Cursor.E_RESIZE_CURSOR);
+	else if(shape.equals("hand")) cursor = new Cursor(Cursor.HAND_CURSOR);
+	else if(shape.equals("move")) cursor = new Cursor(Cursor.MOVE_CURSOR);
+	else cursor = new Cursor(Cursor.DEFAULT_CURSOR);
+	
+	if(this instanceof WindowFrame || this instanceof WindowWidget)
+		component.setCursor(cursor);		
+	else
+		jcomponent.setCursor(cursor);
+	}
+	
+	
+public void dispose(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+
+public void insertTab(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+	
+public void removeTab(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setAccelerator(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void addListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void removeListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void selectListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void addSeparator(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void insertListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void setTabSize(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void setTrace(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void setUTF8(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void setLookAndFeel(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void disposeSplash(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void getProperties(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void getScreen(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void getFonts(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void getVersion(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void getTextPosition(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void showPopup(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void findText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void gotoText(StringTokenizer params)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void frameCloseEvent(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void frameResizeEvent(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void frameMoveEvent(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+// 2D Graphics
+
+public void gsCanvas(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Background(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Font(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Stroke(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Paint(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Export(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Print(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Translation(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Scale(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}		
+	
+public void g2Transform(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Rotation(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Composite(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Clip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void createLine(StringTokenizer tokens)
+	{	
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawLine(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawRectangle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void fillRectangle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawRoundRect(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void fillRoundRect(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawEllipse(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void fillEllipse(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawCircle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void fillCircle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawArc(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void fillArc(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawPolygon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void fillPolygon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawPath(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseEvent(StringTokenizer tokens)
+	{
+	mouseEvent = tokens.nextToken();
+	component.addMouseListener(new MouseAdapter () {
+		public void mouseClicked(MouseEvent e) { mouseEventOut(e, "clicked"); }	
+		public void mousePressed(MouseEvent e) { mouseEventOut(e, "pressed"); }
+		public void mouseReleased(MouseEvent e) { mouseEventOut(e, "released"); }
+		});
+	}
+	
+public void registerKeyEvent(StringTokenizer tokens)
+	{
+	keyEvent = tokens.nextToken();
+	component.addKeyListener(new KeyAdapter () {
+		public void keyTyped(KeyEvent e) { keyEventOut(e, "typed"); }
+		public void keyPressed(KeyEvent e) { keyEventOut(e, "pressed"); }
+		public void keyReleased(KeyEvent e) { keyEventOut(e, "released"); }
+		});
+	}
+	
+public void registerMouseEntered(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseExited(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMousePressed(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseReleased(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseClicked(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseDragged(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void registerMouseMoved(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseWheelMoved(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setAntiAliasing(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void deleteTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void moveTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void	translateTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void rotateTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void scaleTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void shearTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void hideTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void orderTaggedShapes(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void showTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void colorTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void update(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawImage(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+private void mouseEventOut(MouseEvent e, String type)
+	{
+	guiserver.out.println("(" + mouseEvent + " \"" + id + "\" \"" + type + "\" " + e.getX() + " " + e.getY() + " " + 
+		e.getButton() + " " + e.getClickCount() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+	
+private void keyEventOut(KeyEvent e, String type)
+	{
+	guiserver.out.println("(" + keyEvent + " \"" + id + "\" \"" + type + "\" " + 
+			e.getKeyCode() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+	
+public void runShell(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void evalShell(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void destroyShell(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+}
+
+// eof
+ 
+ 
+// eof //
diff --git a/guiserver/java/gsObject.java.bak b/guiserver/java/gsObject.java.bak
new file mode 100644
index 0000000..fdfd90d
--- /dev/null
+++ b/guiserver/java/gsObject.java.bak
@@ -0,0 +1,875 @@
+//
+//  gsObject.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/19/07.
+//
+//
+//    Copyright (C) 2015 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.font.*;
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.border.*;
+import java.util.*;
+import java.io.UnsupportedEncodingException;
+
+public class gsObject {
+
+static HashMap widgets = new HashMap();
+
+String id;
+String action;
+JComponent jcomponent = null;
+Container container = null;
+Component component = null;
+Dispatcher dispatch = null;
+String mouseEvent = null;
+String keyEvent = null;
+
+public void addTo(StringTokenizer tokens)
+	{
+	boolean isBorderLayout = (container.getLayout() instanceof LayoutBorder);
+	while(tokens.hasMoreTokens())
+		{
+		String comp = tokens.nextToken();
+		//System.out.println("adding: " + comp + " to: " + id);
+		gsObject gsobject = (gsObject)gsObject.widgets.get(comp);
+		Component compnt = gsobject.component;
+		if(isBorderLayout)
+			{
+			String direction = tokens.nextToken();
+			if(direction.equals("north")) container.add(compnt, BorderLayout.NORTH);
+			else if(direction.equals("west")) container.add(compnt, BorderLayout.WEST);
+			else if(direction.equals("center")) container.add(compnt, BorderLayout.CENTER);
+			else if(direction.equals("east")) container.add(compnt, BorderLayout.EAST);
+			else if(direction.equals("south")) container.add(compnt, BorderLayout.SOUTH);
+			else container.add(compnt, BorderLayout.CENTER);
+			}
+		else container.add(compnt);
+		}
+	}
+	
+public void removeFrom(StringTokenizer tokens)
+	{
+	String comp = tokens.nextToken();
+	gsObject gsobject = (gsObject)gsObject.widgets.get(comp);
+	Component compnt = gsobject.component;
+	container.remove(compnt);
+	container.update(container.getGraphics());
+	}
+	
+public void layout(StringTokenizer tokens)
+	{
+	container.validate();
+	}
+	
+public void getBounds(StringTokenizer tokens)
+	{
+	int x, y, width, height;
+	
+	x = component.getX();
+	y = component.getY();
+		
+	width = component.getWidth();
+	height = component.getHeight();
+	
+	guiserver.out.println("( set 'gs:bounds '(" + x + " " + y + " " + width + " " + height + "))\n");
+	guiserver.out.flush();
+	}
+	
+	
+public void loadText(StringTokenizer tokens)
+	{
+	}
+	
+public void saveText(StringTokenizer tokens)
+	{
+	}
+	
+public void setText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void appendText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void getText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void getSelection(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void clearText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setCaret(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void selectText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void copyText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void cutText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void pasteText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void undoText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void undoEnable(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void redoText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void clearList(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setVisible(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		component.setVisible(true);
+	else
+		component.setVisible(false);
+	}
+
+
+public void setResizable(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setSize(StringTokenizer tokens)
+	{
+	int width = Integer.parseInt(tokens.nextToken());
+	int height = Integer.parseInt(tokens.nextToken());
+	component.setSize(new Dimension(width, height));
+	}
+	
+public void setPreferredSize(StringTokenizer tokens)
+	{
+	int width = Integer.parseInt(tokens.nextToken());
+	int height = Integer.parseInt(tokens.nextToken());
+	component.setPreferredSize(new Dimension(width, height));
+	}
+	
+public void Enable(StringTokenizer tokens)
+	{
+	gsObject gsobject;
+	
+	component.setEnabled(true);
+	
+	while(tokens.hasMoreTokens())
+		{
+		gsobject = (gsObject)gsObject.widgets.get(tokens.nextToken());
+		gsobject.component.setEnabled(true);
+		}
+	}
+	
+public void Disable(StringTokenizer tokens)
+	{
+	gsObject gsobject;
+	
+	component.setEnabled(false);
+
+	while(tokens.hasMoreTokens())
+		{
+		gsobject = (gsObject)gsObject.widgets.get(tokens.nextToken());
+		gsobject.component.setEnabled(false);
+		}
+	}
+	
+public void setToolTip(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+
+	jcomponent.setToolTipText(text);
+	}
+	
+public void setEchoChar(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setEditable(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setValue(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setSelected(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setTitledBorder(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+		
+	jcomponent.setBorder(BorderFactory.createTitledBorder(text));
+	}
+	
+public void setBevelBorder(StringTokenizer tokens)
+	{
+	int type = BevelBorder.RAISED;
+	
+	if(tokens.hasMoreTokens())
+		{
+		String stype = tokens.nextToken();		
+		if(stype.equals("lowered")) type = BevelBorder.LOWERED;
+		}
+	
+	jcomponent.setBorder(BorderFactory.createBevelBorder(type));
+	}
+	
+public void setIcon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setPressedIcon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void messageDialog(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void confirmationDialog(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void ColorChooser(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void OpenFileChooser(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void SaveFileChooser(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void requestFocus(StringTokenizer tokens)
+	{
+	component.requestFocus();
+	}
+	
+public void setFont(StringTokenizer tokens)
+	{
+	String name = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		name = Base64Coder.decodeStringUTF8(name);
+	else
+		name = Base64Coder.decodeString(name);
+
+	int style = 0;
+	int size = 12;
+	
+	if(tokens.hasMoreTokens())
+		size = Integer.parseInt(tokens.nextToken());
+	
+	while(tokens.hasMoreTokens())
+		{
+		String sstyle = tokens.nextToken();
+		if(sstyle.equals("plain")) style = style | Font.PLAIN;
+		if(sstyle.equals("bold")) style = style | Font.BOLD;
+		if(sstyle.equals("italic")) style = style | Font.ITALIC;
+		}
+		
+	Font font = new Font(name, style, size);
+	jcomponent.setFont(font);
+	}
+	
+public void getFontMetrics(StringTokenizer tokens)
+	{
+	String text = tokens.nextToken();
+	
+	if(guiserver.UTF8)
+		text = Base64Coder.decodeStringUTF8(text);
+	else
+		text = Base64Coder.decodeString(text);
+	
+	FontMetrics fm = component.getFontMetrics(component.getFont());
+	
+	int width = fm.stringWidth(text);
+	int height = fm.getHeight();
+	
+	//System.out.println("width:" + width + " height:" + height);
+	
+	guiserver.out.println("(set 'gs:font-metrics '(" + width + " " + height + "))");
+	guiserver.out.flush();
+	}
+	
+public void setForeground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jcomponent.setForeground(new Color(red, green, blue, alpha));
+		}
+	else
+		jcomponent.setForeground(new Color(red, green, blue));
+	}
+	
+public void setBackground(StringTokenizer tokens)
+	{
+	Float red = Float.parseFloat(tokens.nextToken());
+	Float green = Float.parseFloat(tokens.nextToken());
+	Float blue = Float.parseFloat(tokens.nextToken());
+	if(tokens.hasMoreTokens())
+		{
+		Float alpha = Float.parseFloat(tokens.nextToken());
+		jcomponent.setBackground(new Color(red, green, blue, alpha));
+		}
+	else
+		jcomponent.setBackground(new Color(red, green, blue));
+	}
+
+public void setCaretColor(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+
+public void setSyntax(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setCursor(StringTokenizer tokens)
+	{
+	String shape = tokens.nextToken();
+	Cursor cursor = null;
+	
+	if(shape.equals("crosshair")) cursor = new Cursor(Cursor.CROSSHAIR_CURSOR);
+	else if(shape.equals("text")) cursor = new Cursor(Cursor.TEXT_CURSOR);
+	else if(shape.equals("wait")) cursor = new Cursor(Cursor.WAIT_CURSOR);
+	else if(shape.equals("sw-resize")) cursor = new Cursor(Cursor.SW_RESIZE_CURSOR);
+	else if(shape.equals("se-resize")) cursor = new Cursor(Cursor.SE_RESIZE_CURSOR);
+	else if(shape.equals("nw-resize")) cursor = new Cursor(Cursor.NW_RESIZE_CURSOR);
+	else if(shape.equals("ne-resize")) cursor = new Cursor(Cursor.NE_RESIZE_CURSOR);
+	else if(shape.equals("n-resize")) cursor = new Cursor(Cursor.N_RESIZE_CURSOR);
+	else if(shape.equals("s-resize")) cursor = new Cursor(Cursor.S_RESIZE_CURSOR);
+	else if(shape.equals("w-resize")) cursor = new Cursor(Cursor.W_RESIZE_CURSOR);
+	else if(shape.equals("e-resize")) cursor = new Cursor(Cursor.E_RESIZE_CURSOR);
+	else if(shape.equals("hand")) cursor = new Cursor(Cursor.HAND_CURSOR);
+	else if(shape.equals("move")) cursor = new Cursor(Cursor.MOVE_CURSOR);
+	else cursor = new Cursor(Cursor.DEFAULT_CURSOR);
+	
+	if(this instanceof WindowFrame || this instanceof WindowWidget)
+		component.setCursor(cursor);		
+	else
+		jcomponent.setCursor(cursor);
+	}
+	
+	
+public void dispose(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+
+public void insertTab(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+	
+public void removeTab(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void setAccelerator(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void addListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void removeListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void selectListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void addSeparator(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void insertListItem(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void setTabSize(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void setTrace(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void setUTF8(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void setLookAndFeel(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void disposeSplash(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void getProperties(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void getScreen(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void getFonts(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void getVersion(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void getTextPosition(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void showPopup(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void findText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void gotoText(StringTokenizer params)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void frameCloseEvent(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void frameResizeEvent(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void frameMoveEvent(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+// 2D Graphics
+
+public void gsCanvas(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Background(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Font(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Stroke(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Paint(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Export(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Print(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Translation(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Scale(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}		
+	
+public void g2Transform(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Rotation(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+
+public void g2Composite(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void g2Clip(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}	
+	
+public void createLine(StringTokenizer tokens)
+	{	
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawLine(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawRectangle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void fillRectangle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawRoundRect(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void fillRoundRect(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawEllipse(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void fillEllipse(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawCircle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void fillCircle(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawArc(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void fillArc(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawPolygon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void fillPolygon(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawPath(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void drawText(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseEvent(StringTokenizer tokens)
+	{
+	mouseEvent = tokens.nextToken();
+	component.addMouseListener(new MouseAdapter () {
+		public void mouseClicked(MouseEvent e) { mouseEventOut(e, "clicked"); }	
+		public void mousePressed(MouseEvent e) { mouseEventOut(e, "pressed"); }
+		public void mouseReleased(MouseEvent e) { mouseEventOut(e, "released"); }
+		});
+	}
+	
+public void registerKeyEvent(StringTokenizer tokens)
+	{
+	keyEvent = tokens.nextToken();
+	component.addKeyListener(new KeyAdapter () {
+		public void keyTyped(KeyEvent e) { keyEventOut(e, "typed"); }
+		public void keyPressed(KeyEvent e) { keyEventOut(e, "pressed"); }
+		public void keyReleased(KeyEvent e) { keyEventOut(e, "released"); }
+		});
+	}
+	
+public void registerMouseEntered(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseExited(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMousePressed(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseReleased(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseClicked(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseDragged(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void registerMouseMoved(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void registerMouseWheelMoved(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void setAntiAliasing(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void deleteTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void moveTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void	translateTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void rotateTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void scaleTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void shearTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void hideTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void orderTaggedShapes(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void showTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+public void colorTaggedShape(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void update(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void drawImage(StringTokenizer tokens) 
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+private void mouseEventOut(MouseEvent e, String type)
+	{
+	guiserver.out.println("(" + mouseEvent + " \"" + id + "\" \"" + type + "\" " + e.getX() + " " + e.getY() + " " + 
+		e.getButton() + " " + e.getClickCount() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+	
+private void keyEventOut(KeyEvent e, String type)
+	{
+	guiserver.out.println("(" + keyEvent + " \"" + id + "\" \"" + type + "\" " + 
+			e.getKeyCode() + " " + e.getModifiers() + ")");
+	guiserver.out.flush();
+	}
+	
+public void runShell(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void evalShell(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+	
+public void destroyShell(StringTokenizer tokens)
+	{
+	ErrorDialog.wrongApplication(Dispatcher.cmd, id);
+	}
+
+}
+
+// eof
+ 
+ 
+// eof //
diff --git a/guiserver/java/guiserver.java b/guiserver/java/guiserver.java
new file mode 100644
index 0000000..834d383
--- /dev/null
+++ b/guiserver/java/guiserver.java
@@ -0,0 +1,424 @@
+//
+//  guiserver.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/10/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.lang.reflect.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.font.*;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+import javax.swing.*;
+
+@SuppressWarnings("unchecked") 
+public class guiserver extends gsObject
+	{
+	static BufferedReader in;
+	static PrintWriter out;
+	static boolean listening = true;
+	static boolean debug = false;
+	static boolean MAC_OS_X;
+	static boolean UTF8 = true;
+	static boolean DOUBLE_BUFFERING = true;
+	static boolean connected = false;
+	static SplashWindow splash = null;
+	static Frame frame = null;
+	static double version = 1.66;
+
+    public static void main (String args[]) throws IOException, InterruptedException 
+		{
+		int portIn = 64001;
+		int portOut = 64002;
+		String host = null;
+		String tkn = null;
+		String osName;
+        String newlispPath;
+		Socket socket = null;
+		String splashImagePath = null;
+		
+		osName = System.getProperty("os.name");
+		MAC_OS_X = osName.toLowerCase().startsWith("mac os x");
+
+		System.out.println("newLISP-GS v." + version + " on " + osName);
+	
+		if(args.length == 3) splashImagePath = args[2];
+		
+		// put splash screen first
+		if(splashImagePath != null)
+			{
+			frame = new Frame();
+			MediaTracker mt = new MediaTracker(frame);
+			Image splashImage = guiserver.getImageFromPath(splashImagePath, frame.getClass());
+			mt.addImage(splashImage, 0);
+			try { mt.waitForID(0); } catch(InterruptedException ie) {}
+			splash = new SplashWindow(frame, splashImage);
+			}
+			
+		gsObject gsobject = new guiserver(new StringTokenizer("System"));
+		
+		if(args.length >= 1) 
+			portIn = Integer.parseInt(args[0]);
+		
+		portOut = portIn + 1;
+
+        if(MAC_OS_X) newlispPath = "/usr/local/bin/newlisp ";
+        else newlispPath = "newlisp ";
+			
+		if(args.length >= 2)
+			execCommand(newlispPath + args[1] + " " + portIn + " javastart &");
+			
+		// open listener and connection to remote
+		System.out.println(" listening on " + portIn);
+		ServerSocket ssocket = new ServerSocket(portIn);
+		Socket client = ssocket.accept();
+		host = ssocket.getInetAddress().getHostAddress();
+		System.out.println(" accepted connection from " + host);
+		in = new BufferedReader(new InputStreamReader(client.getInputStream()));
+		ssocket.close();
+		
+		//System.out.println("->" + System.getProperty("line.separator").length());
+		System.setProperty("line.separator", "\n");
+		
+		System.out.println(" connecting to " + host + ":" + portOut);
+
+		int count = 0;
+		while(connected == false)
+		{
+			try { socket = new Socket(host, portOut); connected = true; } catch (IOException ioe)
+				{
+				Thread.sleep(100);
+				if(count == 30)
+					{
+					System.out.println(" server could not connect to " + host + ":" + portOut);
+					System.exit(1);
+					}
+				count = count + 1;
+				System.out.println(" retrying to connect");
+				continue;
+				}
+		}
+		
+		out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
+		System.out.println("server connected");
+
+		Dispatcher.init();
+		
+		String cmd = null;
+		try {
+			while(listening)
+				{
+				cmd = in.readLine();
+				if(cmd == null) { System.out.println("server shutdown"); System.exit(0); }   
+				if(debug) Dispatcher.dispatch(cmd);
+				else
+					{
+					try { Dispatcher.dispatch(cmd);	}
+					catch (Exception e)	{ ErrorDialog.show(cmd, "Missing argument or item not found"); }
+					}
+				}
+			} catch (IOException IOexc) { System.out.println("server shutdown"); System.exit(0); }
+		}
+
+/*
+	public static void disposeSplash()
+		{
+		if(splash != null) splash.dispose();
+		if(frame != null) frame.dispose();
+		}
+*/
+		
+	public static void execCommand(String command) throws IOException
+		{
+		String s;
+		
+		
+		System.out.println("guiserver starting newLISP \"" + command + "\"");
+		Process p = Runtime.getRuntime().exec(command);
+/*
+		BufferedReader stdInput = new BufferedReader(new 
+                 InputStreamReader(p.getInputStream()));
+
+		BufferedReader stdError = new BufferedReader(new 
+                 InputStreamReader(p.getErrorStream()));
+
+            // read the output from the command
+            while ((s = stdInput.readLine()) != null) {
+                System.out.println(s);
+            }
+            
+            // read any errors from the attempted command
+            while ((s = stdError.readLine()) != null) {
+                System.out.println(s);
+            }
+*/
+		System.out.println("guiserver finished exec");
+		}
+		
+		
+	public static Image getImageFromPath(String path,  Class cls)
+		{
+		if(path.startsWith("/local/"))
+			return(Toolkit.getDefaultToolkit().getImage(cls.getClass().getResource("/images" + path.substring(6))));
+		else
+			return(Toolkit.getDefaultToolkit().getImage(path));
+		}
+
+	public static ImageIcon getIconFromPath(String path, Class cls)
+		{
+		if(path.startsWith("/local/"))
+			return(new ImageIcon(Toolkit.getDefaultToolkit().getImage(cls.getClass().getResource("/images" + path.substring(6)))));
+		else
+			return(new ImageIcon(path));
+		}
+	
+		
+	public guiserver(StringTokenizer tokens)
+		{
+		id = tokens.nextToken();
+		
+		gsObject.widgets.put(id, this);
+		
+		if(MAC_OS_X) 
+			{
+			registerForMacOSXEvents();
+			guiserver.DOUBLE_BUFFERING = false; // not necessary on OX X
+			}
+		else
+			{
+			GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+			GraphicsDevice gd = ge.getDefaultScreenDevice();
+			GraphicsConfiguration gc = gd.getDefaultConfiguration();
+			BufferCapabilities bufCap = gc.getBufferCapabilities();
+			if(bufCap.isPageFlipping())
+				System.out.println(" double buffering supported.");
+			else
+				System.out.println(" double buffering not supported.");
+
+			try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } 
+			catch( Exception ex ) { }
+			}
+		}
+
+
+// System object methods
+public void setTrace(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+			guiserver.debug = true;
+		else
+			guiserver.debug = false;
+	}	
+
+public void setLookAndFeel(StringTokenizer tokens)
+	{
+	try { 
+		UIManager.setLookAndFeel(tokens.nextToken()); } 
+	catch(Exception ex) {
+		ErrorDialog.show("set-look-and-feel", "Could not set look and feel");}
+	}	
+	
+public void disposeSplash(StringTokenizer tokens)
+	{
+	if(splash != null) splash.dispose();
+	if(frame != null) frame.dispose();
+	}	
+	
+public void getScreen(StringTokenizer tokens)
+	{
+	Toolkit tk = Toolkit.getDefaultToolkit();
+	
+	double screenW = tk.getScreenSize().getWidth();
+	double screenH = tk.getScreenSize().getHeight();
+	int screenRes = tk.getScreenResolution();
+	
+	guiserver.out.println("(set 'gs:screen '(" + screenW + " " + screenH + " " + screenRes + "))\n");
+	guiserver.out.flush();
+	}
+
+public void getFonts(StringTokenizer tokens)
+{
+    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+    String[] fontNames = ge.getAvailableFontFamilyNames();
+    String item;
+
+    guiserver.out.print("(set 'gs:fonts '( ");
+    for(int i = 0; i < fontNames.length; i++)
+        {
+        item = fontNames[i];
+		if(guiserver.UTF8)
+        	guiserver.out.print("\"" + Base64Coder.encodeStringUTF8(item) + "\" ");
+		else
+        	guiserver.out.print("\"" + Base64Coder.encodeString(item) + "\" ");
+        }
+    guiserver.out.println(")) ");
+    guiserver.out.flush();
+	}
+
+public void getVersion(StringTokenizer tokens)
+	{
+	guiserver.out.println("(set 'gs:version " + guiserver.version + ")\n");
+	guiserver.out.flush();
+	}
+	
+public void setSyntaxColors(StringTokenizer tokens)
+	{
+	SyntaxHighlighter.setSyntaxColors(tokens);
+	}
+	
+public void playSound(StringTokenizer tokens)
+	{
+	SoundSystem.playSound(Base64Coder.decodeString(tokens.nextToken()));
+	}
+
+public void midiInit(StringTokenizer tokens)
+	{
+	MidiSynth.midiInit(tokens);
+	}
+
+public void midiClose(StringTokenizer tokens)
+	{
+	MidiSynth.midiClose();
+	}
+	
+public void playNote(StringTokenizer tokens)
+	{
+	MidiSynth.playNote(tokens);
+	}
+	
+public void playSequence(StringTokenizer tokens)
+	{
+	MidiSynth.playSequence(tokens);
+	}
+
+public void stopSequence(StringTokenizer tokens)
+	{
+	MidiSynth.stopSequence();
+	}
+	
+public void saveSequence(StringTokenizer tokens)
+	{
+	MidiSynth.saveSequence(tokens);
+	}
+
+public void addTrack(StringTokenizer tokens)
+	{
+	MidiSynth.addTrack(tokens);
+	}
+
+public void getInstruments(StringTokenizer tokens)
+	{
+	MidiSynth.getInstruments();
+	}
+	
+public void midiPatch(StringTokenizer tokens)
+	{
+	MidiSynth.midiPatch(tokens);
+	}
+	
+public void channelBend(StringTokenizer tokens)
+	{
+	MidiSynth.channelBend(tokens);
+	}
+
+public void channelReverb(StringTokenizer tokens)
+	{
+	MidiSynth.channelReverb(tokens);
+	}
+
+public void midiBPM(StringTokenizer tokens)
+	{
+	MidiSynth.midiBPM(tokens);
+	}
+	
+public void muteTrack(StringTokenizer tokens)
+	{
+	MidiSynth.muteTrack(tokens);
+	}
+	
+public void soloTrack(StringTokenizer tokens)
+	{
+	MidiSynth.soloTrack(tokens);
+	}
+	
+public void setUTF8(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		guiserver.UTF8 = true;
+	else
+		guiserver.UTF8 = false;
+	}
+	
+// Mac OS X specific methods
+
+    public void registerForMacOSXEvents() {
+        if (MAC_OS_X) {
+            try {
+                // Generate and register the OSXAdapter, passing it a hash of all the methods we wish to
+                // use as delegates for various com.apple.eawt.ApplicationListener methods
+                OSXAdapter.setQuitHandler(this, getClass().getDeclaredMethod("quit", (Class[])null));
+                OSXAdapter.setAboutHandler(this, getClass().getDeclaredMethod("about", (Class[])null));
+                //OSXAdapter.setPreferencesHandler(this, getClass().getDeclaredMethod("preferences", (Class[])null));
+            } catch (Exception e) {
+                System.err.println("Error while loading the OSXAdapter:");
+                e.printStackTrace();
+            }
+        }
+    }
+
+	public void about() 
+		{
+		gsObject gsobject = (gsObject)gsObject.widgets.get("AboutDialog");
+		if(gsobject != null && (gsobject instanceof WindowFrame))
+			((DialogWidget)gsobject).jdialog.setVisible(true);			
+		else
+			JOptionPane.showMessageDialog(null, 
+				"Software: copyright (c) 2016 Lutz Mueller http://newlisp.org\n" +
+				"Icons: copyright (c) 2016 Michael Michaels http://neglook.com\nAll rights reserved.", 
+				"About newLISP-GS v." + version, JOptionPane.PLAIN_MESSAGE,
+				getIconFromPath("/local/newLISP64.png", this.getClass()));
+   		}
+	
+	public void preferences() 
+		{ 
+		gsObject gsobject = (gsObject)gsObject.widgets.get("PreferencesDialog");
+		if(gsobject != null && (gsobject instanceof WindowFrame))
+			((DialogWidget)gsobject).jdialog.setVisible(true);
+		}
+	
+	public int quit() 
+		{
+		int option = JOptionPane.showConfirmDialog(null, 
+			"Are you sure you want to quit?\nPossibility of losing unsaved content.", "Quit?", JOptionPane.YES_NO_OPTION);
+		if (option == JOptionPane.YES_OPTION) 
+			System.exit(0);
+        return option;
+		}
+	}
+	
+	
+// the end
+ 
+ 
+// eof //
diff --git a/guiserver/java/guiserver.java.bak b/guiserver/java/guiserver.java.bak
new file mode 100644
index 0000000..fa8b399
--- /dev/null
+++ b/guiserver/java/guiserver.java.bak
@@ -0,0 +1,423 @@
+//
+//  guiserver.java
+//  guiserver
+//
+//  Created by Lutz Mueller on 5/10/07.
+//
+//
+//    Copyright (C) 2016 Lutz Mueller
+//
+//    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 3 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, see <http://www.gnu.org/licenses/>.
+//
+
+
+import java.lang.*;
+import java.lang.reflect.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.font.*;
+import java.util.*;
+import java.io.*;
+import java.net.*;
+import javax.swing.*;
+
+@SuppressWarnings("unchecked") 
+public class guiserver extends gsObject
+	{
+	static BufferedReader in;
+	static PrintWriter out;
+	static boolean listening = true;
+	static boolean debug = false;
+	static boolean MAC_OS_X;
+	static boolean UTF8 = true;
+	static boolean DOUBLE_BUFFERING = true;
+	static boolean connected = false;
+	static SplashWindow splash = null;
+	static Frame frame = null;
+	static double version = 1.65;
+
+    public static void main (String args[]) throws IOException, InterruptedException 
+		{
+		int portIn = 64001;
+		int portOut = 64002;
+		String host = null;
+		String tkn = null;
+		String osName;
+        String newlispPath;
+		Socket socket = null;
+		String splashImagePath = null;
+		
+		osName = System.getProperty("os.name");
+		MAC_OS_X = osName.toLowerCase().startsWith("mac os x");
+
+		System.out.println("newLISP-GS v." + version + " on " + osName);
+	
+		if(args.length == 3) splashImagePath = args[2];
+		
+		// put splash screen first
+		if(splashImagePath != null)
+			{
+			frame = new Frame();
+			MediaTracker mt = new MediaTracker(frame);
+			Image splashImage = guiserver.getImageFromPath(splashImagePath, frame.getClass());
+			mt.addImage(splashImage, 0);
+			try { mt.waitForID(0); } catch(InterruptedException ie) {}
+			splash = new SplashWindow(frame, splashImage);
+			}
+			
+		gsObject gsobject = new guiserver(new StringTokenizer("System"));
+		
+		if(args.length >= 1) 
+			portIn = Integer.parseInt(args[0]);
+		
+		portOut = portIn + 1;
+
+        if(MAC_OS_X) newlispPath = "/usr/local/bin/newlisp ";
+        else newlispPath = "newlisp ";
+			
+		if(args.length >= 2)
+			execCommand(newlispPath + args[1] + " " + portIn + " javastart &");
+			
+		// open listener and connection to remote
+		System.out.println(" listening on " + portIn);
+		ServerSocket ssocket = new ServerSocket(portIn);
+		Socket client = ssocket.accept();
+		host = ssocket.getInetAddress().getHostAddress();
+		System.out.println(" accepted connection from " + host);
+		in = new BufferedReader(new InputStreamReader(client.getInputStream()));
+		ssocket.close();
+		
+		//System.out.println("->" + System.getProperty("line.separator").length());
+		System.setProperty("line.separator", "\n");
+		
+		System.out.println(" connecting to " + host + ":" + portOut);
+
+		int count = 0;
+		while(connected == false)
+		{
+			try { socket = new Socket(host, portOut); connected = true; } catch (IOException ioe)
+				{
+				Thread.sleep(100);
+				if(count == 30)
+					{
+					System.out.println(" server could not connect to " + host + ":" + portOut);
+					System.exit(1);
+					}
+				count = count + 1;
+				System.out.println(" retrying to connect");
+				continue;
+				}
+		}
+		
+		out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
+		System.out.println("server connected");
+
+		Dispatcher.init();
+		
+		String cmd = null;
+		try {
+			while(listening)
+				{
+				cmd = in.readLine();
+				if(cmd == null) { System.out.println("server shutdown"); System.exit(0); }   
+				if(debug) Dispatcher.dispatch(cmd);
+				else
+					{
+					try { Dispatcher.dispatch(cmd);	}
+					catch (Exception e)	{ ErrorDialog.show(cmd, "Missing argument or item not found"); }
+					}
+				}
+			} catch (IOException IOexc) { System.out.println("server shutdown"); System.exit(0); }
+		}
+
+/*
+	public static void disposeSplash()
+		{
+		if(splash != null) splash.dispose();
+		if(frame != null) frame.dispose();
+		}
+*/
+		
+	public static void execCommand(String command) throws IOException
+		{
+		String s;
+		
+		
+		System.out.println("guiserver starting newLISP \"" + command + "\"");
+		Process p = Runtime.getRuntime().exec(command);
+/*
+		BufferedReader stdInput = new BufferedReader(new 
+                 InputStreamReader(p.getInputStream()));
+
+		BufferedReader stdError = new BufferedReader(new 
+                 InputStreamReader(p.getErrorStream()));
+
+            // read the output from the command
+            while ((s = stdInput.readLine()) != null) {
+                System.out.println(s);
+            }
+            
+            // read any errors from the attempted command
+            while ((s = stdError.readLine()) != null) {
+                System.out.println(s);
+            }
+*/
+		System.out.println("guiserver finished exec");
+		}
+		
+		
+	public static Image getImageFromPath(String path,  Class cls)
+		{
+		if(path.startsWith("/local/"))
+			return(Toolkit.getDefaultToolkit().getImage(cls.getClass().getResource("/images" + path.substring(6))));
+		else
+			return(Toolkit.getDefaultToolkit().getImage(path));
+		}
+
+	public static ImageIcon getIconFromPath(String path, Class cls)
+		{
+		if(path.startsWith("/local/"))
+			return(new ImageIcon(Toolkit.getDefaultToolkit().getImage(cls.getClass().getResource("/images" + path.substring(6)))));
+		else
+			return(new ImageIcon(path));
+		}
+	
+		
+	public guiserver(StringTokenizer tokens)
+		{
+		id = tokens.nextToken();
+		
+		gsObject.widgets.put(id, this);
+		
+		if(MAC_OS_X) 
+			{
+			registerForMacOSXEvents();
+			guiserver.DOUBLE_BUFFERING = false; // not necessary on OX X
+			}
+		else
+			{
+			GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+			GraphicsDevice gd = ge.getDefaultScreenDevice();
+			GraphicsConfiguration gc = gd.getDefaultConfiguration();
+			BufferCapabilities bufCap = gc.getBufferCapabilities();
+			if(bufCap.isPageFlipping())
+				System.out.println(" double buffering supported.");
+			else
+				System.out.println(" double buffering not supported.");
+
+			try { UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } 
+			catch( Exception ex ) { }
+			}
+		}
+
+
+// System object methods
+public void setTrace(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+			guiserver.debug = true;
+		else
+			guiserver.debug = false;
+	}	
+
+public void setLookAndFeel(StringTokenizer tokens)
+	{
+	try { 
+		UIManager.setLookAndFeel(tokens.nextToken()); } 
+	catch(Exception ex) {
+		ErrorDialog.show("set-look-and-feel", "Could not set look and feel");}
+	}	
+	
+public void disposeSplash(StringTokenizer tokens)
+	{
+	if(splash != null) splash.dispose();
+	if(frame != null) frame.dispose();
+	}	
+	
+public void getScreen(StringTokenizer tokens)
+	{
+	Toolkit tk = Toolkit.getDefaultToolkit();
+	
+	double screenW = tk.getScreenSize().getWidth();
+	double screenH = tk.getScreenSize().getHeight();
+	int screenRes = tk.getScreenResolution();
+	
+	guiserver.out.println("(set 'gs:screen '(" + screenW + " " + screenH + " " + screenRes + "))\n");
+	guiserver.out.flush();
+	}
+
+public void getFonts(StringTokenizer tokens)
+{
+    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+    String[] fontNames = ge.getAvailableFontFamilyNames();
+    String item;
+
+    guiserver.out.print("(set 'gs:fonts '( ");
+    for(int i = 0; i < fontNames.length; i++)
+        {
+        item = fontNames[i];
+		if(guiserver.UTF8)
+        	guiserver.out.print("\"" + Base64Coder.encodeStringUTF8(item) + "\" ");
+		else
+        	guiserver.out.print("\"" + Base64Coder.encodeString(item) + "\" ");
+        }
+    guiserver.out.println(")) ");
+    guiserver.out.flush();
+	}
+
+public void getVersion(StringTokenizer tokens)
+	{
+	guiserver.out.println("(set 'gs:version " + guiserver.version + ")\n");
+	guiserver.out.flush();
+	}
+	
+public void setSyntaxColors(StringTokenizer tokens)
+	{
+	SyntaxHighlighter.setSyntaxColors(tokens);
+	}
+	
+public void playSound(StringTokenizer tokens)
+	{
+	SoundSystem.playSound(Base64Coder.decodeString(tokens.nextToken()));
+	}
+
+public void midiInit(StringTokenizer tokens)
+	{
+	MidiSynth.midiInit(tokens);
+	}
+
+public void midiClose(StringTokenizer tokens)
+	{
+	MidiSynth.midiClose();
+	}
+	
+public void playNote(StringTokenizer tokens)
+	{
+	MidiSynth.playNote(tokens);
+	}
+	
+public void playSequence(StringTokenizer tokens)
+	{
+	MidiSynth.playSequence(tokens);
+	}
+
+public void stopSequence(StringTokenizer tokens)
+	{
+	MidiSynth.stopSequence();
+	}
+	
+public void saveSequence(StringTokenizer tokens)
+	{
+	MidiSynth.saveSequence(tokens);
+	}
+
+public void addTrack(StringTokenizer tokens)
+	{
+	MidiSynth.addTrack(tokens);
+	}
+
+public void getInstruments(StringTokenizer tokens)
+	{
+	MidiSynth.getInstruments();
+	}
+	
+public void midiPatch(StringTokenizer tokens)
+	{
+	MidiSynth.midiPatch(tokens);
+	}
+	
+public void channelBend(StringTokenizer tokens)
+	{
+	MidiSynth.channelBend(tokens);
+	}
+
+public void channelReverb(StringTokenizer tokens)
+	{
+	MidiSynth.channelReverb(tokens);
+	}
+
+public void midiBPM(StringTokenizer tokens)
+	{
+	MidiSynth.midiBPM(tokens);
+	}
+	
+public void muteTrack(StringTokenizer tokens)
+	{
+	MidiSynth.muteTrack(tokens);
+	}
+	
+public void soloTrack(StringTokenizer tokens)
+	{
+	MidiSynth.soloTrack(tokens);
+	}
+	
+public void setUTF8(StringTokenizer tokens)
+	{
+	if(tokens.nextToken().equals("true"))
+		guiserver.UTF8 = true;
+	else
+		guiserver.UTF8 = false;
+	}
+	
+// Mac OS X specific methods
+
+    public void registerForMacOSXEvents() {
+        if (MAC_OS_X) {
+            try {
+                // Generate and register the OSXAdapter, passing it a hash of all the methods we wish to
+                // use as delegates for various com.apple.eawt.ApplicationListener methods
+                OSXAdapter.setQuitHandler(this, getClass().getDeclaredMethod("quit", (Class[])null));
+                OSXAdapter.setAboutHandler(this, getClass().getDeclaredMethod("about", (Class[])null));
+                //OSXAdapter.setPreferencesHandler(this, getClass().getDeclaredMethod("preferences", (Class[])null));
+            } catch (Exception e) {
+                System.err.println("Error while loading the OSXAdapter:");
+                e.printStackTrace();
+            }
+        }
+    }
+
+	public void about() 
+		{
+		gsObject gsobject = (gsObject)gsObject.widgets.get("AboutDialog");
+		if(gsobject != null && (gsobject instanceof WindowFrame))
+			((DialogWidget)gsobject).jdialog.setVisible(true);			
+		else
+			JOptionPane.showMessageDialog(null, 
+				"Software: copyright (c) 2016 Lutz Mueller http://newlisp.org\n" +
+				"Icons: copyright (c) 2016 Michael Michaels http://neglook.com\nAll rights reserved.", 
+				"About newLISP-GS v." + version, JOptionPane.PLAIN_MESSAGE,
+				getIconFromPath("/local/newLISP64.png", this.getClass()));
+   		}
+	
+	public void preferences() 
+		{ 
+		gsObject gsobject = (gsObject)gsObject.widgets.get("PreferencesDialog");
+		if(gsobject != null && (gsobject instanceof WindowFrame))
+			((DialogWidget)gsobject).jdialog.setVisible(true);
+		}
+	
+	public void quit() 
+		{
+		int option = JOptionPane.showConfirmDialog(null, 
+			"Are you sure you want to quit?\nPossibility of losing unsaved content.", "Quit?", JOptionPane.YES_NO_OPTION);
+		if (option == JOptionPane.YES_OPTION) 
+			System.exit(0);
+		}
+	}
+	
+	
+// the end
+ 
+ 
+// eof //
diff --git a/guiserver/java/index.cgi b/guiserver/java/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/guiserver/java/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/guiserver/midi-demo.lsp b/guiserver/midi-demo.lsp
new file mode 100644
index 0000000..be44e1c
--- /dev/null
+++ b/guiserver/midi-demo.lsp
@@ -0,0 +1,36 @@
+#!/usr/local/bin/newlisp
+
+;; - midi-demo.lsp -
+;;
+;; using gs:play-note in this demo only one channel can be played at the same time
+;; to play several tracks/channels in parallel use gs:play-track as shown in
+;; the file midi2-demo.lsp
+
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+; initialize guiserver
+(gs:init) 
+
+; initialize MIDI subsystem
+(gs:midi-init)
+; get all instruments into the gs:instruments variable
+; enable this to see a list of instruments in the terminal
+;(gs:get-instruments)
+
+; assign instruments to channels
+(gs:midi-patch "Piano" 0)
+
+;(gs:midi-bpm 240) ;double speed
+
+; play chromatic scale on default instrument (piano)
+; each note 4 ticks - a quarter note fo 16 ticks
+(for (key 24 95) (gs:play-note key 4 95 0))
+
+; wait until play has finished before exiting
+(sleep (+ 3000 (* 72 128)))
+(exit)
+
+;; eof
+
+
diff --git a/guiserver/midi2-demo.lsp b/guiserver/midi2-demo.lsp
new file mode 100644
index 0000000..7021909
--- /dev/null
+++ b/guiserver/midi2-demo.lsp
@@ -0,0 +1,37 @@
+#!/usr/local/bin/newlisp
+
+(load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+(gs:init)
+
+(gs:midi-init)
+
+;(gs:get-instruments)
+
+; set up keys and volume
+(map set '(C C# D D# E F F# G G# A A# B c c# d e f f# g g# a a# b) (sequence 60 82))
+(set 'pp 30 'p 40 'm 64 'f 127) ; set velocity/volume
+
+; attach instruments to channels
+(gs:midi-patch "Piano" 0)
+(gs:midi-patch "Pizzicato Strings" 1)
+(gs:midi-patch "Woodblock" 2)
+
+; modify speed before creating tracks
+;(gs:midi-bpm 140) ; speed up from 120 default
+
+; add tracks to sequence
+(gs:add-track 0 '( (C 24 m) (C# 8 m) (D 32 m) (c 32 f) (D 32 m)) )
+(gs:add-track 1 (dup '(d 8 pp) 16))
+(gs:add-track 2 '( (c 8 p) (c 24 p) (c 8 p) (c 24 p) (c 8 p) (c 24 p)  (c 8 p) (c 24 p)) )
+
+; play 
+(gs:play-sequence)
+;(gs:save-sequence "/Users/lutz/Desktop/midi2-demo.mid")
+
+; wait until play has finished
+(sleep 6000)
+(gs:midi-close)
+
+(exit)
+
+
diff --git a/guiserver/mouse-demo.lsp b/guiserver/mouse-demo.lsp
new file mode 100644
index 0000000..fc1bb85
--- /dev/null
+++ b/guiserver/mouse-demo.lsp
@@ -0,0 +1,75 @@
+#!/usr/local/bin/newlisp
+;;
+;; mouse-demo.lsp - demonstrate mouse handlers and gs:delete-tag
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+(set 'colors (list gs:black gs:blue gs:cyan gs:darkGray gs:gray 
+				gs:green gs:lightGray gs:magenta gs:orange gs:pink gs:red gs:yellow))
+
+;;;; describe the GUI
+(gs:frame 'MouseDemo 100 100 640 640 "Canvas Demo")
+(gs:canvas 'MyCanvas 'MouseDemo)
+(gs:add-to 'MouseDemo 'MyCanvas)
+(gs:set-background 'MyCanvas gs:white)
+(gs:mouse-pressed 'MyCanvas 'mouse-pressed-action true)
+(gs:mouse-released 'MyCanvas 'mouse-released-action true)
+(gs:mouse-clicked 'MyCanvas 'mouse-clicked-action true)
+(gs:mouse-moved 'MyCanvas 'mouse-moved-action)
+(gs:mouse-dragged 'MyCanvas 'mouse-dragged-action)
+(gs:mouse-wheel 'MyCanvas 'mouse-wheel-action)
+(gs:set-anti-aliasing true)
+(println (time-of-day))
+(for (row 0 620 20)
+	(for (col 0 620 20)
+		(let (r (rand (length colors)))
+			(gs:fill-rect (string "R" r) col row 20 20 (colors r))
+		)
+	)
+)
+(println (time-of-day))
+(gs:set-visible 'MouseDemo true)
+
+;; define actions
+
+(define (mouse-pressed-action x y button modifiers tags)
+	(gs:set-text 'MouseDemo 
+		(string "pressed row: " (/ y 20) " col:" (/ x 20) " button: " button " key:" modifiers " tags:" tags))
+)
+
+(define (mouse-released-action x y button modifiers tags)
+	(gs:set-text 'MouseDemo 
+		(string "released row: " (/ y 20) " col:" (/ x 20) " button: " button " key:" modifiers " tags:" tags))
+)
+
+(define (mouse-clicked-action x y button cnt modifiers tags)
+	(gs:set-text 'MouseDemo 
+		(string "clicked row: " (/ y 20) " col:" (/ x 20) 
+			" button: " button " count:" cnt " key:" modifiers " tags:" tags))
+	(if tags (gs:delete-tag (tags 0)))
+)
+
+(define (mouse-moved-action x y)
+	(gs:set-text 'MouseDemo 
+		(string "moved row: " (/ y 20) " col:" (/ x 20)))
+)
+
+(define (mouse-dragged-action x y button modifiers)
+	(gs:set-text 'MouseDemo 
+		(string "dragged row: " (/ y 20) " col:" (/ x 20) " button: " button " key:" modifiers))
+)
+
+(define (mouse-wheel-action x y wheel)
+	(gs:set-text 'MouseDemo 
+		(string "cursor row: " (/ y 20) " col:" (/ x 20) " wheel: " wheel))
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/move-resize-demo.lsp b/guiserver/move-resize-demo.lsp
new file mode 100644
index 0000000..7053e82
--- /dev/null
+++ b/guiserver/move-resize-demo.lsp
@@ -0,0 +1,42 @@
+#!/usr/local/bin/newlisp
+;;
+; move-resize-demo.lsp - demonstrate gs:window-moved and hs:window-resized events
+
+;;;; initialization
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'EventDemo 100 100 300 100 "Move or resize window")
+(gs:set-border-layout 'EventDemo)
+(gs:label 'Position "")
+(gs:label 'Size "")
+(gs:set-font 'Position "Mono Spaced" 24 "bold")
+(gs:set-foreground 'Position 0 0 0.5 )
+(gs:set-font 'Size "Mono Spaced" 24 "bold")
+(gs:set-foreground 'Size 0 0 0.5 )
+
+(gs:add-to 'EventDemo 'Position "north")
+(gs:add-to 'EventDemo 'Size "south")
+
+(gs:window-moved 'EventDemo 'move-action)
+(gs:window-resized 'EventDemo 'resize-action)
+
+;;;; define actions
+
+(define (move-action id x y)
+	(gs:set-text 'Position (string "Position " x ":" y)))
+
+(define (resize-action id width height)
+	(gs:set-text 'Size (string "Size " width ":" height)))
+
+
+(gs:set-visible 'EventDemo true)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/newlisp-edit.lsp b/guiserver/newlisp-edit.lsp
new file mode 100644
index 0000000..8b83296
--- /dev/null
+++ b/guiserver/newlisp-edit.lsp
@@ -0,0 +1,1484 @@
+#!/usr/local/bin/newlisp
+
+; newlisp-edit.lsp - multiple tab LISP editor and support for running code from the editor
+; needs 9.9.2 version minimum to run
+
+; version 1.26 fixed old tab-switching bug when closing a tab
+; version 1.27 took out writing debug edit.txt to Application folder
+; version 1.28 decrementing font size exited editor (missing dec conversion for 10.0)
+; version 1.30 change fonts in both: editor and monitor depending on active window
+; version 1.31 cmd-x/v/z/Z and ctrl-x/v/z/Z did not mark edit buffer as dirty
+; version 1.32 newlispDoc directory configured now depending on NEWLISPDIR on Unix
+; version 1.33 eliminated manuals in help on all but OSX platform
+; version 1.34 fix for OSX Homebrew when NEWLISPENV is not /usr/share/newlisp
+; version 1.50 fix for run-shell for Java 7 update 21 (also runs on previous Java)
+; version 1.51 changes for ostype Windows and guisever/index.html renamed to index-gs.html
+
+(set-locale "C")
+
+;;;; initialization
+(set 'newlispDir (env "NEWLISPDIR"))
+
+(set 'newlispDoc (if (= ostype "Windows")
+   newlispDir (join (reverse (cons "doc/newlisp" (rest (reverse (parse newlispDir "/"))))) "/")))
+
+(load (string newlispDir "/guiserver.lsp"))
+
+(constant (global '$HOME) (or (env "HOME") (env "USERPROFILE") (env "DOCUMENT_ROOT") ""))
+(constant '$TEMP (if (= ostype "Windows") (or (env "TEMP") "C:\\temp") "/tmp"))
+
+(if (= ostype "Windows")
+	(begin
+		(set 'userSettingsDir (string
+			(or (env "APPDATA") (env "HOME") (env "USERPROFILE") (env "DOCUMENT_ROOT")) "/newLISP"))
+		(set 'userSettingsPath (append userSettingsDir "/newlisp-edit.config"))
+		(set 'recentFilesPath (append userSettingsDir "/newlisp-edit-recent"))
+		(if (not (directory userSettingsDir)) (make-dir userSettingsDir))
+	)
+	(begin
+		(set 'userSettingsPath (append $HOME "/.newlisp-edit.conf"))
+		(set 'recentFilesPath (append $HOME "/.newlisp-edit-recent"))
+	)
+)
+
+;; init guiserver
+
+(gs:init 64001 "localhost") ; default port is 64001 but can be changed
+;(gs:set-trace true)
+
+
+;; create default user settings
+
+(gs:get-screen)
+(set 'config:currentAppWidth 800)
+(set 'config:currentAppHeight (- (gs:screen 1) 80))
+(set 'config:currentAppX (/ (- (gs:screen 0) config:currentAppWidth) 3))
+(set 'config:currentAppY (/ (- (gs:screen 1) config:currentAppHeight) 2))
+(set 'config:currentForeground '(0.0 0.0 0.2))
+(set 'config:currentBackground '(1.0 1.0 1.0))
+(set 'config:currentDir $HOME)
+(set 'config:currentFontName (if (= ostype "Windows") "Monospaced" "Lucida Sans Typewriter"))
+(set 'config:currentFontSize (if (= ostype "Windows") 14 13))
+(set 'config:currentMonitorFontName (if (= ostype "Windows") "Monospaced" "Lucida Sans Typewriter"))
+(set 'config:currentMonitorFontSize (if (= ostype "Windows") 14 13))
+(set 'config:currentToolbarFloatable "no")
+(set 'config:currentTabsize 16)
+(set 'config:currentTabsPosition "top")
+(set 'config:currentToolbarShow "yes")
+(set 'config:currentThemeIdx 0)
+(set 'config:currentAltShell "")
+(set 'config:currentMonitorForeground '(0.1 0.1 0.5))
+(set 'config:currentMonitorBackground '(0.95 0.95 0.95))
+(set 'config:currentExtension "")
+
+;; configure themes
+
+; name background, foreground, caret, selection
+; comments, keywords, strings
+; numbers, quoted, parentheses
+
+(set 'config:currentThemes '(
+	("Mozart" (1 1 1) (0 0 0) (0.5 0.5 0.8) (0.7 0.7 1.0)
+		(0.5 0.5 0.5) (0 0 0.75)	(0 0.5 0.0)	
+		(0.50 0.5 0)	(0.350 0.350 0.50)	(0.50 0 0))
+
+	("Herrmann" (0.3242 0.3984 0.4648) (0.6875 0.6992 0.5781) (0.918 0.4961 0.1016) (0.2773 0.3164 0.4258)
+		(0.5 0.5781 0.597)	(0.125 0.2031 0.332)	(0.5547 0.6562 0.6562)	
+		(0.8203 0.6055 0.1953)	(0.8203 0.6055 0.1953)	(0.125 0.2031 0.332))
+
+	("Shostakovich" (0.2 0.2 0.2) (0.9 0.9 0.9) (0.7 0.7 0.7) (0.8 0.8 1.0)
+		(0.6 0.6 0.6)	(0.9 0.9 0.3) (0.4 0.9 0.4) 
+		(0.75 0.75 0.95) (0.5 0.5 0.9) (1.0 0.3 0.3))
+))
+
+;; initialize script list
+(set 'config:currentScripts 
+	(list 
+		(list "Word count" (string newlispDir "/guiserver/word-count.lsp") "content")
+		(list "Uppercase" (string newlispDir "/guiserver/uppercase.lsp") "selection" "F4")
+))
+
+;; menu-item handler for themes
+(define (theme-handler id)
+  ; extract theme index from id string and extract theme from list
+	(letn ( (idx (int (9 id))) (T (config:currentThemes idx)) )
+		(gs:set-background currentEdit (T 1))
+		(set 'currentBackground (T 1))
+		(gs:set-foreground currentEdit (T 2))
+		(set 'currentForeground (T 2))
+		(gs:set-caret-color currentEdit (T 3))
+		(gs:set-selection-color currentEdit (T 4))
+		(gs:set-syntax-colors (T 5) (T 6) (T 7) (T 8) (T 9) (T 10))
+		(gs:set-syntax currentEdit currentSyntaxStatus)
+		(gs:set-selected 'ViewSyntax (true? currentSyntaxStatus))
+		(set 'currentThemeIdx idx)
+		(dotimes (i (length config:currentThemes))
+			(gs:enable (string "ViewTheme" i)))
+		(gs:disable (string "ViewTheme" idx))
+	)
+)
+
+(define (current-file-syntax)
+	(cond
+		((ends-with currentFile ".lsp") "lsp")
+		((ends-with currentFile ".c") "c")
+		((ends-with currentFile ".cpp") "cpp")
+		((ends-with currentFile ".h") "cpp")
+		((ends-with currentFile ".java") "java")
+		((ends-with currentFile ".php") "php")
+		(true nil)
+	)
+)
+
+;; script-handler, saves current edit tab to a temporary file
+;; and passes the file name as an argument to the script
+;; scripts are registered in the settings file
+;; scripts must exit or newlisp-edit will hang.
+(define (script-handler id)
+	(letn ( (idx (int (10 id))) (S (config:currentScripts idx)))
+		(set 'currentScriptFile (S 1))
+		(if (file? currentScriptFile)
+			(begin
+				(set 'currentScriptMode (S 2))
+				(if (= currentScriptMode "selection")
+					(gs:get-selected-text currentEdit 'script-execute)
+				; else "content"
+    			(gs:get-text currentEdit 'script-execute))
+			)
+			(output-monitor (string ";--- could not find script " currentScriptFile " ---\n"))
+		)
+	)
+)
+
+(define (script-execute id text)
+	(if (not text) (set 'text "===="))
+	(let (file (string $TEMP "/" (uuid)))
+		(if (= ostype "Windows")
+			(write-file file (replace "\n" (base64-dec text) "\r\n"))
+			(write-file file (base64-dec text)))
+		(if (= ostype "Windows")
+			(catch (exec (string {newlisp.exe "} currentScriptFile {" } file " > " (string file "out"))) 'result)
+			(catch (exec (string "/usr/local/bin/newlisp " currentScriptFile " " file)) 'result)
+		)
+		(if (list? result)
+			(begin
+				(set 'result (if (= ostype "Windows")
+					(read-file (string file "out"))
+ 					(join result "\n")))
+				(if (= currentScriptMode "selection")
+					(paste-action result)
+					(if (= ostype "Windows")
+						(output-monitor result)
+						(output-monitor (string result "\n")))
+				)
+			)
+			(output-monitor result)
+		)
+		(if (= ostype "Windows") (delete-file (string file "out")))
+		(delete-file file)
+	)
+)
+
+
+
+;; if newlisp-edit.config exists load user-settings
+(if (file? userSettingsPath) 
+	(if (not (catch (load userSettingsPath) 'result))
+		(set 'loadUserSettingsError result))
+	(if (not (catch (save userSettingsPath 'config) 'result))
+		(set 'loadUserSettingsError result))
+)
+
+(if (not	(catch (load recentFilesPath) 'result))
+	(set 'recentFiles '()))
+
+(set 'currentAppX config:currentAppX)
+(set 'currentAppY config:currentAppY)
+(set 'currentAppWidth config:currentAppWidth)
+(set 'currentAppHeight config:currentAppHeight)
+(set 'currentForeground config:currentForeground)
+(set 'currentBackground config:currentBackground)
+(set 'currentDir config:currentDir)
+(set 'currentFile "Untitled.lsp")
+(set 'currentFontName config:currentFontName)
+(set 'currentFontSize config:currentFontSize)
+(set 'currentMonitorFontName config:currentMonitorFontName)
+(set 'currentMonitorFontSize config:currentMonitorFontSize)
+(set 'currentToolbarFloatable config:currentToolbarFloatable)
+(set 'currentTabsPosition config:currentTabsPosition)
+(set 'currentToolbarShow config:currentToolbarShow)
+(set 'currentThemeIdx config:currentThemeIdx)
+(set 'currentAltShell config:currentAltShell)
+(set 'currentMonitorForeground config:currentMonitorForeground)
+(set 'currentMonitorBackground config:currentMonitorBackground)
+(set 'currentExtension config:currentExtension)
+(set 'currentPath (string currentDir "/" currentFile))
+(set 'currentSyntaxStatus "lsp")
+
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.motif.MotifLookAndFeel")
+;(gs:set-look-and-feel "javax.swing.plaf.metal.MetalLookAndFeel")
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.windows.WindowsLookAndFeel")
+;(gs:set-look-and-feel "javax.swing.plaf.mac.MacLookAndFeel")
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.gtk.GTKLookAndFeel")
+
+(define (start-newlisp-shell)
+	(if (= ostype "Windows")
+		(gs:run-shell 'OutputArea 
+			(string newlispDir "/newlisp.exe") (string currentExtension " -C -w \"" $HOME "\""))
+		(gs:run-shell 'OutputArea 
+			(string "/usr/local/bin/newlisp") (string currentExtension " -C -w " $HOME))
+	)
+)
+
+(define (startshell-handler)
+	(gs:run-shell 'OutputArea currentAltShell)
+)
+
+;;;; describe the GUI ;;;;;;;;;;;;;;;;;;;;;;;
+
+(gs:frame 'TheEditor currentAppX currentAppY currentAppWidth currentAppHeight "newLISP edit")
+(gs:frame-closed 'TheEditor 'quitbutton-handler)
+
+(set 'default-currentFontName currentFontName)
+
+(gs:set-border-layout 'TheEditor 0 0)
+(gs:tool-bar 'ToolBar (= currentToolbarFloatable "yes"))
+(gs:set-flow-layout 'ToolBar "left" 16 4)
+(gs:image-button 'NewButton 'newbutton-handler "/local/new32.png" "/local/new-down32.png")
+(gs:image-button 'ClearButton 'clearbutton-handler "/local/clear32.png" "/local/clear-down32.png")
+(gs:image-button 'LoadButton 'loadbutton-handler "/local/folder-opened32.png" "/local/folder-opened-down32.png")
+(gs:image-button 'SaveButton 'savebutton-handler "/local/save32.png" "/local/save-down32.png")
+(gs:image-button 'CutButton 'cutbutton-handler "/local/cut32.png" "/local/cut-down32.png")
+(gs:image-button 'CopyButton 'copybutton-handler "/local/copy32.png" "/local/copy-down32.png")
+(gs:image-button 'PasteButton 'pastebutton-handler "/local/paste32.png" "/local/paste-down32.png")
+(gs:image-button 'FindButton 'findbutton-handler "/local/search32.png" "/local/search-down32.png")
+(gs:image-button 'ExecButton 'process-or-execbutton-handler "/local/run32.png" "/local/run-down32.png")
+(gs:image-button 'RestartButton 'start-newlisp-shell "/local/restart32.png" "/local/restart-down32.png")
+(gs:image-button 'FontBookButton 'fontbookbutton-handler "/local/font-book32.png" "/local/font-book-down32.png")
+(gs:set-tool-tip 'NewButton "Open a new tab")
+(gs:set-tool-tip 'LoadButton  "Load file into editor")
+(gs:set-tool-tip 'SaveButton "Save file in editor")
+(gs:set-tool-tip 'ClearButton "Clear editor panel")
+(gs:set-tool-tip 'CutButton "Cut selection to clipboard")
+(gs:set-tool-tip 'CopyButton "Copy selection to clipboard")
+(gs:set-tool-tip 'PasteButton "Paste from clipboard")
+(gs:set-tool-tip 'FindButton "Find")
+
+(gs:set-tool-tip 'ExecButton "Run editor content")
+(gs:set-tool-tip 'RestartButton "Restart auxiliary newLISP process")
+(gs:set-tool-tip 'FontBookButton "Select editor font")
+
+(gs:add-to 'ToolBar 'NewButton 'LoadButton 'SaveButton)
+(gs:add-separator 'ToolBar)
+(gs:add-to 'ToolBar 'ClearButton 'CutButton 'CopyButton 'PasteButton)
+(gs:add-separator 'ToolBar)
+(gs:add-to 'ToolBar 'FindButton)
+(gs:add-separator 'ToolBar)
+(gs:add-to 'ToolBar 'ExecButton 'RestartButton)
+(gs:add-separator 'ToolBar)
+(gs:add-to 'ToolBar 'FontBookButton)
+
+(gs:panel 'FontPanel 46 18)
+(gs:set-grid-layout 'FontPanel 1 3)
+(gs:label 'FontSmallerLabel "A" "center")
+(gs:label 'FontSizeLabel (string currentFontSize) "center")
+(gs:label 'FontBiggerLabel "A" "center")
+(gs:set-tool-tip 'FontSizeLabel "Font size" "right")
+(gs:set-font 'FontSmallerLabel "Lucida Sans Regular" 10 "italic")
+(gs:set-font 'FontSizeLabel "Lucida Sans Regular" 10 "plain")
+(gs:set-font 'FontBiggerLabel "Lucida Sans Regular" 13 "italic")
+(gs:add-to 'FontPanel 'FontSmallerLabel 'FontSizeLabel 'FontBiggerLabel)
+
+(gs:add-to 'ToolBar 'FontPanel)
+
+(gs:mouse-event 'FontBiggerLabel 'fontpanel-event)
+(gs:mouse-event 'FontSmallerLabel 'fontpanel-event)
+
+(gs:set-tool-tip 'FontBiggerLabel "Bigger font")
+(gs:set-tool-tip 'FontSmallerLabel "Smaller font")
+
+;; disable Cut- and Copy- buttons until selection is make
+;; SaveButton util content in EditArea
+(gs:disable 'CutButton 'CopyButton 'SaveButton)
+
+(if (= currentToolbarShow "yes")
+	(gs:add-to 'TheEditor 'ToolBar "north"))
+
+(set 'tabs-stack '())
+
+;; configure text area
+(define (make-editor-tab dir file-name)
+	(let (edit-tab (append "tab-" (uuid)) )
+		(push (list edit-tab dir file-name (list true 0 0 (current-file-syntax))) tabs-stack -1)
+		(gs:text-pane edit-tab 'editarea-handler "text/plain")
+		(gs:mouse-event edit-tab 'editarea-mouse-handler)
+		(gs:set-foreground edit-tab currentForeground)
+		(gs:set-background edit-tab currentBackground) 
+		(gs:set-tab-size edit-tab config:currentTabsize)
+		(gs:set-font edit-tab currentFontName currentFontSize "plain")
+	edit-tab)
+)
+
+(set 'currentDot 0 'currentMark 0)
+(set 'edit-buffer-clean true)
+(set 'currentEdit (make-editor-tab currentDir currentFile))
+(gs:set-syntax currentEdit (ends-with currentFile ".lsp"))
+(set 'currentTabIndex 0)
+(gs:set-text 'TheEditor (string "newLISP edit - " currentPath))
+
+(set 'editUndoCount 0)
+
+(gs:tabbed-pane 'EditorTabs 'editortabs-handler currentTabsPosition
+	currentEdit "Untitled.lsp")
+
+(gs:set-icon 'EditorTabs "/local/green10.png" currentTabIndex)
+
+; configure output area
+(gs:text-area 'OutputArea 'gs:no-action)
+(gs:mouse-event 'OutputArea 'outputarea-mouse-handler)
+(gs:set-background 'OutputArea currentMonitorBackground)
+(gs:set-foreground 'OutputArea currentMonitorForeground)
+;(gs:set-font 'OutputArea "Monospaced" currentMonitorFontSize "plain")
+(gs:set-font 'OutputArea currentMonitorFontName currentMonitorFontSize "plain")
+(gs:split-pane 'TextPanel "horizontal" 0.70 0.5 5)
+(gs:add-to 'TextPanel 'EditorTabs 'OutputArea)
+(gs:add-to 'TheEditor  'TextPanel "center")
+
+;; configure main menu
+(gs:menu 'FileMenu "File")
+(gs:menu-item 'FileClear 'clearbutton-handler "Clear tab" true)
+(gs:menu-item 'FileNew 'newbutton-handler "New tab")
+(gs:menu-item 'FileOpen 'loadbutton-handler "Open ...")
+(gs:menu-item 'FileClose 'fileclose-handler "Close tab")
+(gs:menu-item 'FileSave 'savebutton-handler "Save")
+(gs:menu-item 'FileSaveAs 'saveasbutton-handler "Save As ...")
+(gs:menu-item 'FileSettings 'savesettings-handler "Save Settings")
+(gs:menu-item 'FileQuit 'quitbutton-handler (if (= ostype "Windows") "Exit" "Quit"))
+
+(gs:menu 'FileRecent "Recent Files")
+
+
+(if recentFiles (dolist (f recentFiles)
+	(if (file? (f 1))
+		(begin
+			(gs:menu-item (f 0) 'recentfiles-handler (f 1))
+			(gs:add-to 'FileRecent (f 0)))
+		(replace f recentFiles))
+))
+
+(gs:menu 'EditMenu "Edit")
+(gs:menu-item 'EditUndo 'undo-handler "Undo")
+(gs:menu-item 'EditRedo 'redo-handler "Redo")
+(gs:menu-item 'EditCut 'cutbutton-handler "Cut")
+(gs:menu-item 'EditCopy 'copybutton-handler "Copy")
+(gs:menu-item 'EditPaste 'pastebutton-handler "Paste")
+(gs:menu-item 'EditGoto 'goto-handler "Goto Line")
+(gs:menu-item 'EditPosition 'position-handler "Get Position")
+(gs:menu-item 'EditGotoEditor 'switchwindow-handler "Goto Editor")
+(gs:menu-item 'EditGotoShell 'switchwindow-handler "Goto Shell")
+(gs:menu-item 'EditFind 'findbutton-handler "Find")
+(gs:menu-item 'EditFindNext 'findtextnext-action "Find next")
+(gs:menu-item 'EditFindPrevious 'findtextprevious-action "Find Previous")
+(gs:menu-item 'EditReplace 'findtextreplace-action "Replace Selection")
+;(gs:menu-item 'EditReplaceNext 'findtextreplace-action "Replace Next")
+(gs:menu-item 'EditFindDispose 'finddispose-handler "Find Dispose")
+
+(gs:menu-popup 'EditMenuPopup "Edit")
+(gs:menu-item 'EditCutP 'cutbutton-handler "Cut")
+(gs:menu-item 'EditCopyP 'copybutton-handler "Copy")
+(gs:menu-item 'EditPasteP 'pastebutton-handler "Paste")
+
+(gs:menu 'ViewMenu "View")
+(gs:menu-item 'ViewClearMonitor 'viewclearmonitor-handler "Clear monitor")
+(gs:menu-item-check 'ViewToolbar 'viewtoolbar-handler "Toolbar" (= currentToolbarShow "yes"))
+(gs:menu-item-check 'ViewSyntax 'viewsyntax-handler "Syntax coloring" true)
+(dolist (T config:currentThemes)
+	(gs:menu-item (string "ViewTheme" $idx) 'theme-handler (T 0)))
+(gs:menu-item 'ViewFontBook 'fontbookbutton-handler "Font faces ...")
+(gs:menu-item 'ViewFontSmaller 'viewfontsmaller-handler "Font smaller")
+(gs:menu-item 'ViewFontBigger 'viewfontbigger-handler "Font bigger")
+
+
+(gs:menu 'ToolMenu "Tools")
+(gs:menu-item 'ToolEditSettings 'tooleditsettings-handler "Edit Settings")
+(dolist (T config:currentScripts)
+	(gs:menu-item (string "ToolScript" $idx) 'script-handler (T 0))
+	(if (= 4 (length T)) 
+		(gs:set-accelerator (string "ToolScript" $idx) (T 3)))
+)
+
+(gs:menu 'HelpMenu "Help")
+(unless (= ostype "OSX") ; on OSX use about option in top frame menu
+	(gs:menu-item 'HelpAbout 'helpabout-handler "About newLISP-GS"))
+(gs:menu-item 'HelpDemos 'opendemos-handler "Open Demo Folder")
+(when (= ostype "OSX")
+	(gs:menu-item 'HelpManual 'helpmanual-handler "newLISP Manual and Reference")
+	(gs:menu-item 'HelpGuiserver 'helpguiserver-handler "GS Manual"))
+
+(gs:menu 'RunMenu "Run")
+(gs:menu-item 'RunRun 'process-or-execbutton-handler "Run")
+(gs:set-icon 'RunRun "/local/run16.png")
+(gs:menu-item 'RunRestart 'start-newlisp-shell "Restart")
+(gs:menu-item 'RunShell 'startshell-handler "Alternate shell")
+
+(gs:menu-popup 'SyntaxMenu "Syntax")
+(gs:menu-item 'SyntaxNewlisp 'syntaxmenu-handler "newLISP syntax")
+(gs:menu-item 'SyntaxC 'syntaxmenu-handler "C syntax")
+(gs:menu-item 'SyntaxCPP 'syntaxmenu-handler "C++ syntax")
+(gs:menu-item 'SyntaxJava 'syntaxmenu-handler "Java syntax")
+(gs:menu-item 'SyntaxPHP 'syntaxmenu-handler "PHP syntax")
+(gs:add-to 'SyntaxMenu 'SyntaxNewlisp 'SyntaxC 'SyntaxCPP 'SyntaxJava 'SyntaxPHP)
+
+(if (= ostype "OSX")
+	(begin ;; MacOS X keyboard
+		(gs:set-accelerator 'FileClear "shift meta N")
+		(gs:set-accelerator 'FileNew "meta N")
+		(gs:set-accelerator 'FileOpen "meta O")
+		(gs:set-accelerator 'FileClose "meta W")
+		(gs:set-accelerator 'FileSave "meta S")
+		(gs:set-accelerator 'FileSaveAs "shift meta S")
+		(gs:set-accelerator 'EditUndo "meta Z")
+		(gs:set-accelerator 'EditRedo "shift meta Z")
+		(gs:set-accelerator 'EditCut "meta X")
+		(gs:set-accelerator 'EditCopy "meta C")
+		(gs:set-accelerator 'EditPaste "meta V")
+		(gs:set-accelerator 'EditGoto "meta L")
+		(gs:set-accelerator 'EditPosition "shift meta L")
+		(gs:set-accelerator 'EditGotoEditor "meta 1")
+		(gs:set-accelerator 'EditGotoShell "meta 2")
+		(gs:set-accelerator 'EditFind "meta F")
+		(gs:set-accelerator 'EditFindDispose "meta D")
+		(gs:set-accelerator 'EditFindPrevious "shift meta G")
+		(gs:set-accelerator 'EditFindNext "meta G")
+		(gs:set-accelerator 'EditReplace "meta J")
+;		(gs:set-accelerator 'EditReplaceNext "shift meta J")
+		(gs:set-accelerator 'RunRun "meta R")
+		(gs:set-accelerator 'RunRestart "shift meta R")
+		(gs:set-accelerator 'ViewClearMonitor "meta M")
+		(gs:set-accelerator 'ViewFontBook "meta T")
+		(gs:set-accelerator 'ViewFontSmaller "meta MINUS")
+		(gs:set-accelerator 'ViewFontBigger "shift meta EQUALS")
+		(gs:set-accelerator 'ViewSyntax "meta Y")
+	)
+	(begin ;; PC keyboard 
+		(gs:set-accelerator 'FileClear "ctrl N")
+		(gs:set-accelerator 'FileNew "shift ctrl N")
+		(gs:set-accelerator 'FileOpen "ctrl O")
+		(gs:set-accelerator 'FileClose "ctrl W")
+		(gs:set-accelerator 'FileSave "ctrl S")
+		(gs:set-accelerator 'FileSaveAs "shift ctrl S")
+		(gs:set-accelerator 'EditUndo "ctrl Z")
+		(gs:set-accelerator 'EditRedo "shift ctrl Z")
+		(gs:set-accelerator 'EditCopy "ctrl C")
+		(gs:set-accelerator 'EditCut "ctrl X")
+		(gs:set-accelerator 'EditPaste "ctrl V")
+		(gs:set-accelerator 'EditGoto "alt L")
+		(gs:set-accelerator 'EditPosition "shift alt L")
+		(gs:set-accelerator 'EditGotoEditor "alt 1")
+		(gs:set-accelerator 'EditGotoShell "alt 2")
+		(gs:set-accelerator 'EditFind "ctrl F")
+		(gs:set-accelerator 'EditFindPrevious "shift ctrl G")
+		(gs:set-accelerator 'EditFindNext "ctrl G")
+		(gs:set-accelerator 'EditFindDispose "ctrl D")
+		(gs:set-accelerator 'EditReplace "ctrl J")
+;		(gs:set-accelerator 'EditReplaceNext "shift ctrl J")
+		(gs:set-accelerator 'RunRun "alt R")
+		(gs:set-accelerator 'RunRestart "shift alt R")
+		(gs:set-accelerator 'ViewClearMonitor "ctrl M")
+		(gs:set-accelerator 'ViewFontBook "ctrl T")
+		(gs:set-accelerator 'ViewFontSmaller "ctrl MINUS")
+		(gs:set-accelerator 'ViewFontBigger "ctrl EQUALS")
+		(gs:set-accelerator 'ViewSyntax "alt Y")
+	)
+)
+
+;; disable Save and SaveAs until content in EditArea
+(gs:disable 'FileSave 'FileSaveAs)
+;; disable Cut and Copy menu items until selection is made
+(gs:disable 'EditUndo 'EditRedo 'EditCut 'EditCutP 'EditCopy 'EditCopyP)
+;; disable various find dialog options until dialog is up first
+(gs:disable 'EditFindPrevious 'EditFindNext 'EditReplace 'EditFindDispose)
+;; disable monitor clear until something is in it
+;(gs:disable 'ViewClearMonitor)
+
+; File menu
+(gs:add-to 'FileMenu 'FileClear 'FileNew 'FileClose)
+(gs:add-separator 'FileMenu)
+(gs:add-to 'FileMenu 'FileRecent)
+(gs:add-separator 'FileMenu)
+(gs:add-to 'FileMenu 'FileOpen 'FileSave 'FileSaveAs)
+(gs:add-separator 'FileMenu)
+(gs:add-to 'FileMenu 'FileSettings)
+(gs:add-separator 'FileMenu)
+(gs:add-to 'FileMenu 'FileQuit)
+
+; Edit menun
+(gs:add-to 'EditMenu 'EditUndo 'EditRedo)
+(gs:add-separator 'EditMenu)
+(gs:add-to 'EditMenu 'EditCut 'EditCopy 'EditPaste)
+(gs:add-separator 'EditMenu)
+(gs:add-to 'EditMenu 'EditGoto 'EditPosition 'EditGotoEditor 'EditGotoShell)
+(gs:add-separator 'EditMenu)
+(gs:add-to 'EditMenu 'EditFind 'EditFindNext 'EditFindPrevious 'EditReplace)
+(gs:add-separator 'EditMenu)
+(gs:add-to 'EditMenu 'EditFindDispose)
+(gs:disable 'EditFindDispose)
+; edit area popup
+(gs:add-to 'EditMenuPopup 'EditCutP 'EditCopyP 'EditPasteP)
+
+; View menu
+(gs:add-to 'ViewMenu 'ViewClearMonitor)
+(gs:add-separator 'ViewMenu)
+(gs:add-to 'ViewMenu 'ViewToolbar 'ViewSyntax)
+(gs:add-separator 'ViewMenu)
+(dolist (T config:currentThemes)
+	(gs:add-to 'ViewMenu (string "ViewTheme" $idx)))
+(gs:add-separator 'ViewMenu)
+(gs:add-to 'ViewMenu 'ViewFontBook 'ViewFontSmaller 'ViewFontBigger)
+
+(if (empty? currentAltShell)
+	(gs:add-to 'RunMenu 'RunRun 'RunRestart)
+	(gs:add-to 'RunMenu 'RunRun 'RunRestart 'RunShell))
+
+; Tool menu
+(gs:add-to 'ToolMenu 'ToolEditSettings)
+(gs:add-separator 'ToolMenu)
+(dolist (T config:currentScripts)
+	(gs:add-to 'ToolMenu (string "ToolScript" $idx)))
+
+; Help menu
+; manuals are only added on Mac OSX, other platforms block
+; the IDE from working when the browser is opened until the 
+; it is closed again
+(when (= ostype "OSX")
+	(gs:add-to 'HelpMenu 'HelpManual 'HelpGuiserver)
+	(gs:add-separator 'HelpMenu))
+
+(gs:add-to 'HelpMenu 'HelpDemos)
+
+(unless (= ostype "OSX")
+	(gs:add-separator 'HelpMenu)
+	(gs:add-to 'HelpMenu 'HelpAbout))
+
+
+(gs:menu-bar 'TheEditor 'FileMenu 'EditMenu 'RunMenu 'ViewMenu 'ToolMenu 'HelpMenu)
+
+(gs:set-visible 'TheEditor true)
+(gs:dispose-splash)
+
+; start auxiliary shell newLISP process for evaluation of edit area in OutputArea
+(start-newlisp-shell)
+
+(gs:request-focus currentEdit) ; set focus on editarea
+
+; check if user settings where loaded succesfully
+(if loadUserSettingsError
+	(gs:message-dialog 'TheEditor (string "Problem loading: " userSettingsPath ".")
+		loadUserSettingsError "warning")
+)
+
+;;;; define actions
+
+(define (clear-current-tab)
+	(gs:clear-text currentEdit)
+	(set 'currentDir $HOME)
+	(set 'currentFile "Untitled.lsp")
+	(set 'currentPath (string currentDir "/" currentFile))
+	(set 'currentDot 0 'currentMark 0)
+	(update-current-tab)
+	(gs:disable 'SaveButton 'CutButton 'CopyButton 'FileSave 'EditCut 'EditCutP 'EditCopy 'EditCopyP)
+	(gs:set-icon 'EditorTabs "/local/green10.png" currentTabIndex)
+	(gs:set-text 'EditorTabs currentFile currentTabIndex)
+	(gs:set-text 'TheEditor (string "newLISP edit - " currentPath))
+)
+		
+(define (fileclose-handler)
+	(if (not edit-buffer-clean)
+		(gs:confirm-dialog 'TheEditor 'fileclose-action "Close file tab" 
+			(string "Abandon unsaved " currentFile "?") "yes-no")
+		(fileclose-action 'TheEditor 0)
+	)	
+)
+
+(define (fileclose-action id result)
+;(println "in fileclose-action")
+	(if (= result 0)
+		(if (> (length tabs-stack) 1)
+			(begin
+				(gs:remove-tab 'EditorTabs currentTabIndex)
+;(println "currentTabIndex before pop:" currentTabIndex)
+;(println (assoc currentEdit tabs-stack))
+				(pop-assoc currentEdit tabs-stack)
+;(println "currentTabIndex after pop:" currentTabIndex)
+				(if (= currentTabIndex (length tabs-stack)) ; it was the right most tab
+					(dec currentTabIndex)
+					(begin ; its was not the most right which was removed
+						(set 'currentEdit (first (tabs-stack currentTabIndex)))
+						(switch-to-tab currentEdit)
+					)
+				)
+			)
+			(clear-current-tab)
+		)
+	)
+)
+
+(define (newbutton-handler)
+	(update-current-tab)
+	(set 'currentDir $HOME)
+	(set 'currentFile "Untitled.lsp")
+	(set 'currentPath (string currentDir "/" currentFile))
+	(set 'currentDot 0 'currentMark 0)
+	(set 'edit-buffer-clean true)
+	(set 'currentEdit (make-editor-tab currentDir currentFile))
+	(gs:insert-tab 'EditorTabs currentEdit currentFile (length tabs-stack))
+	(gs:request-focus 'EditorTabs (length tabs-stack))
+	(gs:request-focus currentEdit) ; set focus in edit area
+	(theme-handler (string "ViewTheme" currentThemeIdx))
+)
+
+(define (recentfiles-handler id)
+	(update-current-tab)
+	(let (file (lookup id recentFiles))
+		(if (not (file? file))
+			(gs:message-dialog 'TheEditor "Loading file" (append "Cannot find: " file))
+			(begin
+				(set 'currentPath (lookup id recentFiles))
+				(open-currentpath-in-tab)
+			)
+		)
+	)
+)
+
+(define (loadbutton-handler id)
+	(gs:open-file-dialog 'TheEditor 'openfile-action  currentDir 
+		".lsp .c .h .txt .java .htm .html .css .php .pl .py .rb .lisp .el .cl .cpp .tcl .config .cgi .js .py .pl .sh:" 
+		"Various text formats")
+)
+
+(define (openfile-action id  op file)
+	(if file
+		(begin
+			(update-current-tab)
+			(set 'currentPath (base64-dec file))
+			(open-currentpath-in-tab)
+		)
+	)
+)
+
+(define (open-currentpath-in-tab)
+	(set 'currentDir (join (chop (parse currentPath {\\|/} 0)) "/" ))
+	(set 'currentFile (last (parse currentPath {\\|/} 0)))
+	(set 'currentEdit (make-editor-tab currentDir currentFile))
+	(set 'edit-buffer-clean true)
+	(set 'currentDot 0 'currentMark 0)
+	(gs:insert-tab 'EditorTabs currentEdit currentFile (length tabs-stack))
+	(gs:request-focus 'EditorTabs (length tabs-stack))
+	(gs:request-focus currentEdit) ; set focus in edit area
+	(gs:set-cursor currentEdit "wait")
+
+	(gs:set-text 'TheEditor (string "newLISP edit - " currentPath))
+	(gs:enable 'FileSaveAs)
+
+	(gs:load-text currentEdit currentPath)
+	(set 'currentSyntaxStatus (current-file-syntax))
+	(theme-handler (string "ViewTheme" currentThemeIdx))
+	(gs:set-cursor currentEdit "default")
+)
+
+(define (savebutton-handler id)
+	(if (= currentFile "Untitled.lsp")
+		(saveasbutton-handler id)
+		(savefile-action id op (base64-enc currentPath) true)
+	)
+)
+
+(define (saveasbutton-handler id) 
+	(gs:save-file-dialog 'TheEditor 'savefile-action currentDir currentFile)
+)
+
+(define (savefile-action id op file no-check)
+	(set 'save-file-candidate file)
+	(if file (if no-check 
+		(writefile-prepare file)
+		(begin
+			(if (file? (base64-dec file))
+				(gs:confirm-dialog 'TheEditor 'confirmsave-action "Save As ..." 
+					(append "Overwrite " (base64-dec file) "?") "yes-no-cancel")
+				(writefile-prepare file)
+			)
+		))
+	)
+)
+
+(define (confirmsave-action id result)
+	(if (= result 0) 
+		(writefile-prepare save-file-candidate))
+	(if (= result 1)
+		(saveasbutton-handler 'FileSaveAs))
+)	
+
+(define (writefile-prepare file)
+	(set 'currentPath (base64-dec file))
+	(set 'currentDir (join (chop (parse currentPath {\\|/} 0)) "/" ))
+	(set 'currentFile (last (parse currentPath {\\|/} 0)))
+
+	(gs:set-text 'TheEditor (string "newLISP edit - " currentPath))
+	(gs:set-text 'EditorTabs currentFile currentTabIndex)
+	(gs:disable 'FileSave 'SaveButton)
+	(gs:set-icon 'EditorTabs "/local/green10.png" currentTabIndex)
+	(set 'edit-buffer-clean true)
+
+	(gs:get-text currentEdit 'writefile-action)
+)
+
+(define (writefile-action id text)
+	(local (bytes)
+		(if text
+			(if (= ostype "Windows")
+				(set 'bytes (write-file currentPath (replace "\n" (base64-dec text) "\r\n")))
+				(set 'bytes (write-file currentPath (base64-dec text)) ) ))
+		(save-recent-list)
+		(if (not bytes)
+			(gs:message-dialog 'TheEditor "Saving file" (append "Could not save " currentPath))
+			(output-monitor (string ";--- " bytes " bytes saved to " currentPath " ---\n"))
+		)
+	)
+)
+
+(define (save-recent-list)
+	(if (ref currentPath recentFiles)
+		(push (pop recentFiles (first (ref currentPath recentFiles))) recentFiles)
+		(push (list (uuid) currentPath) recentFiles))
+	(set 'recentFiles (0 12 recentFiles))
+	(save recentFilesPath 'recentFiles)
+)
+
+(define (savesettings-handler)
+	(pretty-print 256) ; force one lone line for themes
+	(gs:get-bounds 'TheEditor)
+	(set 'currentAppX (gs:bounds 0))
+	(set 'currentAppY (gs:bounds 1))
+	(set 'currentAppWidth (gs:bounds 2))
+	(set 'currentAppHeight (gs:bounds 3))
+	(set 'config:currentAppX currentAppX)
+	(set 'config:currentAppY currentAppY)
+	(set 'config:currentAppWidth currentAppWidth)
+	(set 'config:currentAppHeight currentAppHeight)
+	(set 'config:currentForeground currentForeground)
+	(set 'config:currentBackground currentBackground)	
+	(set 'config:currentDir currentDir)
+	(set 'config:currentFontName currentFontName)
+	(set 'config:currentFontSize currentFontSize)
+	(set 'config:currentMonitorFontName currentMonitorFontName)
+	(set 'config:currentMonitorFontSize currentMonitorFontSize)
+	(set 'config:currentToolbarFloatable currentToolbarFloatable)
+	(set 'config:currentTabsPosition currentTabsPosition)
+	(set 'config:currentToolbarShow currentToolbarShow)
+	(set 'config:currentThemeIdx currentThemeIdx)
+	(set 'config:currentThemeHelp
+			{background foreground caret selection comments keywords strings numbers quoted parentheses})
+	(set 'config:currentAltShell currentAltShell)
+	(set 'config:currentMonitorForeground currentMonitorForeground)
+	(set 'config:currentMonitorBackground currentMonitorBackground)
+	(save userSettingsPath 'config)
+	(output-monitor 
+		(string ";--- saved settings in: " userSettingsPath " ---\n"))
+)
+
+(define (tooleditsettings-handler)
+	(set 'currentPath userSettingsPath)
+	(open-currentpath-in-tab)
+)
+
+(define (opendemos-handler)
+	(gs:open-file-dialog 'TheEditor 'openfile-action  (string newlispDir "/guiserver")
+		".lsp" "newLISP files")
+)
+
+(define (quitbutton-handler)
+	(let (is-clean-tabs true)
+		(dolist (tab tabs-stack)
+			(if (not (tab 3 0)) (set 'is-clean-tabs nil)))
+		(if (and is-clean-tabs edit-buffer-clean)
+			(quitconfirm-action nil 0)
+;			(gs:confirm-dialog 'TheEditor 'quitconfirm-action
+;				"Quit newLISP edit" "You really want to quit?" "yes-no")
+			(gs:confirm-dialog 'TheEditor 'quitconfirm-action
+				"Quit newLISP edit" "Quit and lose unsaved content?" "yes-no")
+		)
+	)
+)
+
+(define (quitconfirm-action id result)
+	(if (= result 0) 
+		(begin
+			;(println "destroying shell")
+			(gs:destroy-shell 'OutputArea)
+			(exit))
+	)
+)
+
+(define (clearbutton-handler)
+	(if (not edit-buffer-clean)
+		(gs:confirm-dialog 'TheEditor 'clearconfirm-action 
+			"New edit" (string "Abandon unsaved content in " currentFile) "yes-no")
+		(clearbutton-action)
+	)
+)
+
+(define (clearconfirm-action id result)
+	(if (= result 0)
+		(clearbutton-action))
+)
+
+(define (clearbutton-action)
+	(set 'currentPath (string currentDir "/" currentFile))
+	(gs:set-text 'TheEditor (string "newLISP edit - " currentPath))
+	(gs:clear-text currentEdit)
+	(gs:set-icon 'EditorTabs "/local/green10.png" currentTabIndex)
+	(set 'edit-buffer-clean true)
+	(gs:disable 'SaveButton 'FileSave))
+
+(define (undo-handler)
+	(gs:undo-text currentEdit ))
+
+(define (redo-handler)
+	(gs:redo-text currentEdit))
+
+(define (copybutton-handler)
+	(gs:copy-text currentEdit))
+
+(define (cutbutton-handler)
+	(set-buffer-dirty)
+	(gs:cut-text currentEdit)
+	(gs:request-focus 'CutButton))
+
+(define (pastebutton-handler)
+	(paste-action))
+
+; text can be 'nil' to take from clipboard
+(define (paste-action text)
+	(set-buffer-dirty)
+	(gs:paste-text currentEdit text))
+
+(define (set-buffer-dirty)
+	(gs:enable 'FileSave 'FileSaveAs 'SaveButton)
+	(gs:set-icon 'EditorTabs "/local/red10.png" currentTabIndex)
+	(set 'edit-buffer-clean nil))
+
+;; goto line
+
+(define (goto-handler)
+	(gs:dialog 'GotoDialog 'TheEditor "Goto Line" 200 60 nil nil)
+	(gs:set-resizable 'GotoDialog nil)
+	(gs:set-flow-layout 'GotoDialog "center")
+	(gs:label 'GotoTextLabel "Line:")
+	(gs:text-field 'GotoTextField 'gotoline-action 4)
+	(gs:button 'GotoButton 'gotogettext-action "Goto")
+	(gs:add-to 'GotoDialog 'GotoTextLabel 'GotoTextField 'GotoButton)
+	(gs:set-visible 'GotoDialog true)
+)
+
+(define (gotoline-action id text)
+	(if text
+		(let (line (int (base64-dec text) 0))
+			(gs:goto-text currentEdit line 0))	)
+	(gs:dispose 'GotoDialog)
+	(gs:request-focus currentEdit)
+)
+
+(define (gotogettext-action)
+	(gs:get-text 'GotoTextField 'gotoline-action)
+)
+
+(define (position-handler)
+	(gs:get-text-position currentEdit)
+	(output-monitor (string ";--- line: " (gs:text-position 0) " column: " (gs:text-position 1) " ---\n"))
+)
+
+(define (switchwindow-handler id)
+	(when (= id "MAIN:EditGotoEditor")
+		(set 'cursor-in-outputarea nil)
+		(gs:set-text 'FontSizeLabel (string currentFontSize))
+		(gs:request-focus currentEdit))
+	(unless (= id "MAIN:EditGotoEditor")
+		(set 'cursor-in-outputarea true)
+		(gs:set-text 'FontSizeLabel (string currentMonitorFontSize))
+		(gs:request-focus 'OutputArea)
+		(gs:set-caret 'OutputArea 100000))
+	
+)
+
+;;;;;;;;;;;;; find text ;;;;;;;;;;;;;;;
+
+(define (findbutton-handler)
+	(if findDialogOpen 
+		(begin
+			(gs:request-focus 'FindTextField)
+			(gs:select-text 'FindTextField 0))
+		(openFindDialog)
+	)
+)
+
+(define (openFindDialog)
+	(gs:dialog 'FindDialog 'TheEditor "Find text" 460 200 nil nil)
+	(gs:set-resizable 'FindDialog nil)
+	(gs:frame-closed 'FindDialog 'finddialogclose-handler)
+	(gs:set-grid-layout 'FindDialog 4 1)
+	
+	(gs:panel 'FindPanel)
+	(gs:label 'FindTextLabel "Find:")
+	(gs:text-field 'FindTextField 'findtextnext-action 24)
+	(gs:add-to 'FindPanel 'FindTextLabel 'FindTextField)
+	
+	(gs:panel 'ReplacePanel)
+	(gs:label 'FindReplaceLabel "Replace:")
+	(gs:text-field 'FindReplaceField 'findtextnext-action 24)
+	(gs:add-to 'ReplacePanel 'FindReplaceLabel 'FindReplaceField)
+	(if (not (null? currentSearchText)) (gs:set-text 'FindTextField currentSearchText))
+	(if (not (null? currentReplaceText)) (gs:set-text 'FindReplaceField currentReplaceText))
+
+	(gs:panel 'ButtonPanel-1)
+	(gs:button 'FindTextPreviousButton 'findtextprevious-action "Previous")
+	(gs:button 'FindTextNextButton 'findtextnext-action "Next")
+	(gs:button 'FindTextReplaceButton 'findtextreplace-action "Replace")
+	(gs:add-to 'ButtonPanel-1 'FindTextPreviousButton 'FindTextNextButton 'FindTextReplaceButton)
+	(gs:panel 'ButtonPanel-2)
+	(gs:button 'FindTextReplaceNextButton 'findtextreplacenext-action "Replace and Next")
+	(gs:button 'FindTextUndoPrevButton 'findtextundoprev-action "Undo Previous")
+	(gs:add-to 'ButtonPanel-2 'FindTextReplaceNextButton 'FindTextUndoPrevButton)
+
+	(gs:set-tool-tip 'FindTextPreviousButton "Find previous occurrence of the find text")
+	(gs:set-tool-tip 'FindTextNextButton "Find next occurrence of the find text")
+	(gs:set-tool-tip 'FindTextReplaceButton "Replace selected text with replacement text")
+	(gs:set-tool-tip 'FindTextReplaceNextButton "Replace next occurence")
+	(gs:set-tool-tip 'FindTextUndoPrevButton "Undo previous replacement")
+
+	(gs:add-to 'FindDialog 'FindPanel 'ReplacePanel 'ButtonPanel-1 'ButtonPanel-2)
+	(gs:set-visible 'FindDialog true)
+	(gs:disable 'FindTextReplaceButton 'FindTextReplaceNextButton 'FindTextUndoPrevButton)
+	(gs:enable 'EditFindPrevious 'EditFindNext 'EditReplace 'EditFindDispose)
+	(gs:select-text 'FindTextField 0)
+	(set 'findDialogOpen true)
+)
+
+(define (finddispose-handler)
+	(gs:dispose 'FindDialog)
+	(gs:disable 'EditFindDispose)
+	(set 'findDialogOpen nil)
+)
+
+(define (finddialogclose-handler id)
+	(gs:enable 'FindButton 'EditFind)
+	(gs:disable 'EditFindDispose)
+	(set 'findDialogOpen nil)
+)
+
+(define (findtextcheckbox-action id flag)
+	(println id " " flag)
+)
+
+;; find next, this handler is enterd first by all
+;; FindDialog events, text-field(s) and button(s)
+
+(define (findtextnext-action id text)
+	(if (and (or (= id "MAIN:FindTextField") (= id "MAIN:FindReplaceField")) (not text)) 
+		(finddispose-handler) ; ESC key was pressed
+		(begin
+			(set 'currentSearchDirection "next")
+			(gs:get-text 'FindTextField 'getfindtext-action)
+		)
+	)
+)
+
+;; find previous
+
+(define (findtextprevious-action)
+	(set 'currentSearchDirection "previous")
+	(gs:get-text 'FindTextField 'getfindtext-action)
+)
+
+
+;; retrieve search field text
+
+(define (getfindtext-action id text)
+	(if text
+		(begin
+			(set 'currentSearchText (base64-dec text))
+			(gs:get-text 'FindReplaceField 'getreplacetext-action)
+		)
+		(gs:request-focus currentEdit)
+	)
+)
+
+;; rertrieve replace field text
+
+(define (getreplacetext-action id text)
+	(set 'currentReplaceText (if text (base64-dec text) ""))
+	(if (not (null? currentSearchText))
+		(gs:find-text currentEdit currentSearchText 'findtextresult-action currentSearchDirection))
+)
+
+(define (findtextresult-action id result)
+	(if (= result -1)
+		(begin
+			(gs:set-text 'FindDialog "Not found")
+			(gs:disable 'FindTextReplaceNextButton)
+			(when (and (= currentDot currentMark) (= currentSearchDirection "next"))
+				(set 'currentMark (inc currentDot))
+				(gs:set-caret currentEdit currentMark)
+			)
+		)
+		(begin
+			(gs:set-text 'FindDialog "Find text")
+			(gs:enable 'FindTextReplaceButton 'FindTextReplaceNextButton)
+			(gs:request-focus currentEdit)
+		)
+	)
+)
+
+;; replace
+
+(define (findtextreplace-action)
+	(gs:undo-enable currentEdit nil)
+	(if (!= currentMark currentDot)
+		(gs:paste-text currentEdit currentReplaceText))
+	;(gs:request-focus currentEdit)
+	(gs:disable 'FindTextReplaceButton 'FindTextReplaceNextButton)
+	(gs:enable 'FindTextUndoPrevButton)
+	(gs:set-icon 'EditorTabs "/local/red10.png" currentTabIndex)
+	(set 'edit-buffer-clean nil)
+	(gs:enable 'FileSave 'FileSaveAs 'SaveButton 'EditUndo)
+	(gs:undo-enable currentEdit true)
+)
+	
+;; replace and next
+
+(define (findtextreplacenext-action)
+	(gs:undo-enable currentEdit nil)
+	(gs:paste-text currentEdit currentReplaceText)
+	(gs:disable 'FindTextReplaceButton)
+	(gs:enable 'FindTextReplaceNextButton 'FindTextUndoPrevButton)
+	(gs:set-icon 'EditorTabs "/local/red10.png" currentTabIndex)
+	(set 'edit-buffer-clean nil)
+	(gs:enable 'FileSave 'FileSaveAs 'SaveButton 'EditUndo)
+	(set 'currentSearchDirection "next")
+	(gs:get-text 'FindTextField 'getfindtext-action)
+	(gs:undo-enable currentEdit true)
+)
+
+; previous and undo
+(define (findtextundoprev-action)
+	(gs:undo-enable currentEdit nil)
+	(gs:find-text currentEdit currentReplaceText 'findpreviousresult-action "previous")
+	(gs:undo-enable currentEdit true)
+)
+
+(define (findpreviousresult-action id result)
+	(if (= result -1)
+		(begin
+			(gs:set-text 'FindDialog "Not found for undo")
+			(gs:disable 'FindTextUndoPrevButton 'FindTextReplaceButton 'FindTextReplaceNextButton)
+		)
+		(begin
+			(gs:paste-text currentEdit currentSearchText)
+			(gs:request-focus currentEdit)
+		)
+	)
+)
+
+;; view menu fonts bigger/smaller handlers
+
+(define (viewfontsmaller-handler)
+	(if cursor-in-outputarea
+		(begin 
+			(dec currentMonitorFontSize)
+			(gs:set-text 'FontSizeLabel (string currentMonitorFontSize))
+			(gs:set-font 'OutputArea currentMonitorFontName currentMonitorFontSize "plain"))
+		(begin 
+			(dec currentFontSize)
+			(gs:set-text 'FontSizeLabel (string currentFontSize))
+			(gs:set-font currentEdit currentFontName currentFontSize "plain"))
+	)
+)
+	
+
+(define (viewfontbigger-handler)
+	(if cursor-in-outputarea
+		(begin 
+			(inc currentMonitorFontSize)
+			(gs:set-text 'FontSizeLabel (string currentMonitorFontSize))
+			(gs:set-font 'OutputArea currentMonitorFontName currentMonitorFontSize "plain"))
+		(begin 
+			(inc currentFontSize)
+			(gs:set-text 'FontSizeLabel (string currentFontSize))
+			(gs:set-font currentEdit currentFontName currentFontSize "plain"))
+	)
+)
+	
+
+;; 
+
+(define (fontbookbutton-handler)
+	(gs:dialog 'FontBookSelection 'TheEditor "Click on a font name to select it" 300 200 nil nil)
+	(gs:set-background 'FontBookSelection 1 1 1)
+	(gs:get-fonts)
+	(gs:panel 'FontPanel)
+	(gs:set-grid-layout 'FontPanel (length gs:fonts) 1 0 0)
+	(dolist (font gs:fonts)
+		(set 'font-label (string "label-" $idx))
+		(gs:label font-label font)
+		(if cursor-in-outputarea
+			(if (= font currentMonitorFontName)
+				(gs:set-foreground font-label 0.8 0.5 0.0))
+			(if (= font currentFontName)
+				(gs:set-foreground font-label 0.8 0.5 0.0))
+		)
+		(gs:set-size font-label 100 30)
+		(gs:set-font font-label font 24 "plain")
+		(gs:mouse-event font-label 'mouse-action)
+		(gs:add-to 'FontPanel font-label))
+
+	(gs:scroll-pane 'Scroll 'FontPanel)
+	(gs:add-to 'FontBookSelection 'Scroll)
+	(gs:set-visible 'FontBookSelection true)
+)
+
+;; handle mouse clicks in font book
+(define (mouse-action id type x y button cnt mods)
+	(if (= type "pressed")
+		(gs:set-foreground id 0.8 0.5 0.0)
+		(if cursor-in-outputarea
+			(begin
+				(set 'currentMonitorFontName (gs:fonts (int (last (parse id "-")) 0)))
+				(gs:set-font 'OutputArea currentMonitorFontName currentMonitorFontSize "plain")
+				(gs:set-foreground id 0 0 0))
+			(begin
+				(set 'currentFontName (gs:fonts (int (last (parse id "-")) 0)))
+				(gs:set-font currentEdit currentFontName currentFontSize "plain")
+				(gs:set-foreground id 0 0 0))
+		)
+	)
+)
+
+;; font panel mouse click handler
+
+(define (fontpanel-event id  type x y button cnt modifiers)
+	(if (= type "clicked") 
+		(case id
+			("MAIN:FontBiggerLabel" (viewfontbigger-handler))
+			("MAIN:FontSmallerLabel" (viewfontsmaller-handler))
+		)
+	)
+)
+
+;; initialize syntax for first tab
+(theme-handler (string "ViewTheme" currentThemeIdx))
+;;;;;;;;;;;; exec  newlisp over editor contents ;;;;;;;;;;
+
+(define (process-or-execbutton-handler)
+	(if (not (directory? $TEMP))
+		(gs:message-dialog 'TheEditor "Cannot find temporal directory" 
+				(append "Need to create a directory " $TEMP) "information")
+		(begin
+			(disable-main-tools)
+;			(gs:get-text currentEdit 'exec-handler)
+			(gs:get-text currentEdit 'auxiliary-process-handler)
+			(gs:enable 'ViewClearMonitor)
+		)
+	)
+)
+
+; evaluates content of editor area in the auxiliary newLISP
+; process, as output is generated it is displayed in the
+; monitor area
+(define (auxiliary-process-handler id text)
+	(if text
+		(begin
+			(set 'text (base64-dec text))
+			;;(write-file "editor.txt" text)
+			(gs:eval-shell 'OutputArea (string "[cmd]\n" text "\n[/cmd]\n"))))
+	(after-exec-or-process)
+)
+
+; after the exec or auxiliary process execution
+; enable buttons, menus and edit area
+(define (after-exec-or-process)
+	(gs:enable 'FileMenu 'EditMenu 'ViewMenu 'RunMenu)
+	(gs:enable 'NewButton 'ClearButton 'PasteButton 
+				'LoadButton 'ExecButton 'RestartButton 'FindButton 'FontBookButton)
+	(gs:set-editable  currentEdit true)
+	(if (not edit-buffer-clean) (gs:enable 'SaveButton))
+	(gs:request-focus currentEdit)
+	(gs:select-text currentEdit currentDot currentMark)
+	(if is-selection 
+		(gs:enable 'CutButton 'CopyButton))
+)
+
+; disable main menus and toolbar
+(define (disable-main-tools)
+		(gs:disable 'FileMenu 'EditMenu 'ViewMenu 'RunMenu)
+		(gs:disable 'NewButton 'ClearButton 'LoadButton 'SaveButton 
+				'CutButton 'CopyButton 'PasteButton 
+				'ExecButton 'RestartButton 'FindButton 'FontBookButton)
+		(gs:set-editable  currentEdit nil)
+)
+
+;;;;;;;;;;;;;;;;;;;;;;;; end auxiliary process handling ;;;;;;;;;;;;;;;;;;;;;;;
+
+;; clear bottom monitor area
+(define (viewclearmonitor-handler)
+	(gs:clear-text 'OutputArea)
+	;(gs:disable 'ViewClearMonitor)
+)
+
+;; output to monitor area
+(define (output-monitor str)
+	(gs:append-text 'OutputArea str)
+	(gs:enable 'ViewClearMonitor)
+	(gs:eval-shell 'OutputArea "\n")
+)
+
+;; dtach/attach toolbar
+(define (viewtoolbar-handler id flag)
+	(if flag
+		(begin
+			(set 'currentToolbarShow "yes")
+			(gs:add-to 'TheEditor 'ToolBar "north")
+			; if the toolbar was not visible on startup
+			; it will not be visible now, inspite of layout
+			; this forces components of the container to be redrawn
+			(gs:set-visible 'TheEditor true)
+			(gs:layout 'TheEditor)
+		)
+		(begin
+			(set 'currentToolbarShow "no")
+			(gs:remove-from 'TheEditor 'ToolBar)	
+			(gs:layout 'TheEditor)
+		)
+	)
+)
+
+;; syntax highlighting and themes 1,2,3
+;; for menu-item theme-handler function
+;; see beginning of file
+
+(define (viewsyntax-handler id flag)
+	(if flag
+		(begin
+			(set 'currentSyntaxStatus (current-file-syntax))
+			(if (not currentSyntaxStatus)
+					(begin
+						(gs:set-selected 'ViewSyntax nil)
+						(gs:show-popup 'SyntaxMenu 'TheEditor 100 100))
+					(gs:set-syntax currentEdit currentSyntaxStatus)))
+		(begin
+			(set 'currentSyntaxStatus nil)
+			(gs:set-syntax currentEdit nil))
+	)
+)
+
+(define (syntaxmenu-handler id idx)
+	(gs:set-syntax currentEdit (set 'currentSyntaxStatus 
+		(case id
+			("MAIN:SyntaxNewlisp" "lsp")
+			("MAIN:SyntaxC" "c")
+			("MAIN:SyntaxCPP" "cpp")
+			("MAIN:SyntaxJava" "java")
+			("MAIN:SyntaxPHP" "php")
+		))
+	)
+	(gs:set-selected 'ViewSyntax (true? currentSyntaxStatus))
+)
+
+;; handle character and caret events from edit area
+(define (editarea-handler id code mods dot mark len undo redo)
+	(if undo (gs:enable 'EditUndo) (gs:disable 'EditUndo))
+	(if redo (gs:enable 'EditRedo) (gs:disable 'EditRedo))
+	(set 'currentDot dot 'currentMark mark)
+	;(println code ":" mods)
+	(if (= code 65535) ; crtl or meta keys with or w/o shift
+		(begin
+			; caret movement only
+			(if (not is-selection)
+				(when (!= dot mark) ; selection started
+						(gs:enable 'CutButton 'CopyButton 'EditCut 'EditCutP 'EditCopy 'EditCopyP)
+						(set 'is-selection true))
+				(when (= dot mark)  ; de-selected
+						(gs:disable 'CutButton 'CopyButton 'EditCut 'EditCutP 'EditCopy 'EditCopyP)
+						(set 'is-selection nil))
+			)
+			; cmd-z or cmd-Z (undo, redo)
+			(if (or (= code 256) (= code 320) (= code 128) (= code 192))
+				(set-buffer-dirty))	
+		)
+		; character typed
+		(if edit-buffer-clean
+			(when (or 	(<  mods 128) 
+						(and (= mods 256) (or (= code 118) (= code 120)))
+						(and (= mods 128) (or (= code 24) (= code 22))))
+				(set-buffer-dirty)))
+	)			
+)
+
+;; handle mouse clicks from editeara for popup menu
+(define (editarea-mouse-handler id type x y button cnt modifiers)
+	(gs:set-text 'FontSizeLabel (string currentFontSize))
+	(set 'cursor-in-outputarea nil)
+	(if (or (= button 3) (= modifiers 18)); right button or ctrl click
+		(gs:show-popup 'EditMenuPopup currentEdit x y)
+	)
+)
+
+
+(define (outputarea-mouse-handler)
+	(gs:set-text 'FontSizeLabel (string currentMonitorFontSize))
+	(set 'cursor-in-outputarea true)
+)
+
+;; tabs have switched or a new tab has been inserted
+(define (editortabs-handler id tab title idx)
+;(println "id:" id " tab:" tab " title:" title " idx:" idx)
+	; update statis of previous tab if it still exists
+	(if (assoc tab tabs-stack) (update-current-tab))
+	(set 'currentTabIndex idx)
+	; get new tab edit area settings
+	(switch-to-tab tab)
+)
+
+(define (switch-to-tab tab)
+;(println "in switch-to-tab")
+;(println "currentTabIndex:" currentTabIndex)
+	(set 'currentEdit tab)
+;(println (assoc currentEdit tabs-stack))
+	(set 'currentDir (lookup currentEdit tabs-stack 1))
+	(set 'currentFile (lookup currentEdit tabs-stack 2)) 
+	(set 'currentPath (string currentDir "/" currentFile))
+	(set 'currentStatus (lookup currentEdit tabs-stack 3))
+	(set 'edit-buffer-clean (currentStatus 0))
+	(if edit-buffer-clean
+		(begin
+			(gs:set-icon 'EditorTabs "/local/green10.png" currentTabIndex)
+			(gs:disable 'FileSave 'SaveButton)
+		)
+		(begin
+			(gs:set-icon 'EditorTabs "/local/red10.png" currentTabIndex)
+			(gs:enable 'FileSave 'SaveButton)
+		)
+	)
+	(set 'currentDot (currentStatus 1))
+	(set 'currentMark (currentStatus 2))
+	(set 'currentSyntaxStatus (currentStatus 3))
+	(if (= currentDot currentMark) 
+		(begin
+			(set 'is-selection nil)
+			(gs:disable 'CutButton 'CopyButton 'EditCut 'EditCutP 'EditCopy 'EditCopyP)
+			(gs:request-focus currentEdit) )
+		(begin
+			(set 'is-selection true)
+			(gs:enable 'CutButton 'CopyButton 'EditCut 'EditCutP 'EditCopy 'EditCopyP)
+			(gs:request-focus currentEdit)
+			(gs:select-text currentEdit currentDot currentMark) )
+	)
+	(gs:set-text 'TheEditor (string "newLISP edit - " currentPath))
+	(theme-handler (string "ViewTheme" currentThemeIdx))
+	(gs:set-font currentEdit currentFontName currentFontSize "plain")
+)
+
+(define (update-current-tab)
+	(set 'currentStatus (list edit-buffer-clean currentDot currentMark currentSyntaxStatus))
+	; save previous tab edit area settings
+	(if (assoc currentEdit tabs-stack)
+		(setf (assoc currentEdit tabs-stack) 
+			(list currentEdit currentDir currentFile currentStatus)) )
+)
+
+;; help about box
+;; on Mac OS X the built-in about box is shown (contained in guiserver.jar)
+;; selectable from the Apple system menu
+;; On other OSs the Help menu contains the following (identical loooking)
+;; about box
+
+(define (helpabout-handler)
+	(if (!= ostype "OSX")
+		(begin
+			(gs:get-version)
+			(gs:message-dialog 'TheEditor (string "newLISP-GS v." gs:version)
+				(string "Software: copyright (c) 2007-15 Lutz Mueller http://newlisp.org\n" 
+						"Icons: copyright (c) 2007-15 Michael Michaels http://neglook.com\n"
+						"All rights reserved.")
+				"information" "/local/newLISP64.png" )
+		)
+	)
+)
+
+;; show newLISP Users Manual and Reference
+
+(define (helpmanual-handler)
+	(load-platform-help "/manual_frame.html")
+)
+
+;; show GS Manual
+
+(define (helpguiserver-handler)
+	(load-platform-help "/guiserver/index-gs.html")
+)
+
+; help menu items for HTNL documentaion have been taken out because
+; only on Mac OSX they will not block the IDE. On Windows and Linux
+; the IDE stops working until the browser window is closed.
+
+(define (load-platform-help file-name , prog files)
+	(if (not (file? (string newlispDoc file-name)))
+		(gs:message-dialog 'TheEditor "Display documentation"
+				(string "Cannot find file: " newlispDoc file-name)
+                "warning"))
+	(cond
+		; Mac OS X
+		((= ostype "OSX")
+			(exec (string "open file://" newlispDoc file-name))
+		)
+		; MS Windows
+		((= ostype "Windows")
+			(begin
+				(set 'prog (string "cmd /c \"" (env "PROGRAMFILES") "/Internet Explorer/IEXPLORE.EXE\""))
+				;(println "->" prog "<-")
+				(exec (string prog " file://" newlispDoc file-name)))
+		)
+		; all other UNIX
+		(true 
+			(set 'files '(
+					"/usr/bin/sensible-browser"
+					"/usr/bin/x-www-browser"
+					"/usr/bin/mozilla"
+					"/usr/bin/firefox"
+					"/usr/bin/konqueror"
+				))
+			(set 'prog (find true (map file? files)))
+			(if prog
+				(exec (string (files prog) " file://" newlispDoc file-name))
+				(gs:message-dialog 'TheEditor "Display documentation"
+						"Cannot find browser to display documentation" "warning")
+			)
+		)
+	)
+)
+
+;; start listening for GUI events and output from auxiliary newLISP process
+;; append out put from newLISP process to monitor area
+
+(while (gs:check-event 10000)
+	(if (and console (net-select console "read" 10000))
+		(begin
+			(if (> (net-peek console) 0) (begin
+				(net-receive console response 10024)
+				(output-monitor (or response ""))
+				(sleep 100)
+				))
+			(check-status)
+		)
+	)
+)
+
+;; eof
diff --git a/guiserver/newlisp-gs.nsi b/guiserver/newlisp-gs.nsi
new file mode 100644
index 0000000..1d3f376
--- /dev/null
+++ b/guiserver/newlisp-gs.nsi
@@ -0,0 +1,481 @@
+; newlisp-gs.nsi
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The name of the installer
+Name "newLISP-GS"
+
+; The file to write
+OutFile "c:\WinDev\newlisp\newlisp-10700-win-gs-166.exe"
+
+; The default installation directory
+InstallDir $PROGRAMFILES\newlisp
+
+; The text to prompt the user to enter a directory
+DirText "This will install newLISP v.10.7.0 and Guiserver 1.66 on your computer. IF NOT INSTALLING IN THE DEFAULT DIRECTORY REBOOT AFTER INSTALL."
+
+;;;;;;; subroutines for PATH change in MS Windows environment ;;;;;;;;;
+!verbose 3
+!include "WinMessages.NSH"
+!verbose 4
+
+; AddToPath - Adds the given dir to the search path.
+;        Input - head of the stack
+;        Note - Win9x systems requires reboot
+
+Function AddToPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+
+  # don't add if the path doesn't exist
+  IfFileExists "$0\*.*" "" AddToPath_done
+
+  ReadEnvStr $1 PATH
+  Push "$1;"
+  Push "$0;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$0\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  GetFullPathName /SHORT $3 $0
+  Push "$1;"
+  Push "$3;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$3\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+
+  Call IsNT
+  Pop $1
+  StrCmp $1 1 AddToPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" a
+    FileSeek $1 -1 END
+    FileReadByte $1 $2
+    IntCmp $2 26 0 +2 +2 # DOS EOF
+      FileSeek $1 -1 END # write over EOF
+    FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
+    FileClose $1
+    SetRebootFlag true
+    Goto AddToPath_done
+
+  AddToPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $2 $1 1 -1 # copy last char
+    StrCmp $2 ";" 0 +2 # if last char == ;
+      StrCpy $1 $1 -1 # remove last char
+    StrCmp $1 "" AddToPath_NTdoIt
+      StrCpy $0 "$1;$0"
+    AddToPath_NTdoIt:
+      WriteRegExpandStr HKCU "Environment" "PATH" $0
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  AddToPath_done:
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+; RemoveFromPath - Remove a given dir from the path
+;     Input: head of the stack
+
+Function un.RemoveFromPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+  Push $4
+  Push $5
+  Push $6
+
+  IntFmt $6 "%c" 26 # DOS EOF
+
+  Call un.IsNT
+  Pop $1
+  StrCmp $1 1 unRemoveFromPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" r
+    GetTempFileName $4
+    FileOpen $2 $4 w
+    GetFullPathName /SHORT $0 $0
+    StrCpy $0 "SET PATH=%PATH%;$0"
+    Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoop:
+      FileRead $1 $3
+      StrCpy $5 $3 1 -1 # read last char
+      StrCmp $5 $6 0 +2 # if DOS EOF
+        StrCpy $3 $3 -1 # remove DOS EOF so we can compare
+      StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "" unRemoveFromPath_dosLoopEnd
+      FileWrite $2 $3
+      Goto unRemoveFromPath_dosLoop
+      unRemoveFromPath_dosLoopRemoveLine:
+        SetRebootFlag true
+        Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoopEnd:
+      FileClose $2
+      FileClose $1
+      StrCpy $1 $WINDIR 2
+      Delete "$1\autoexec.bat"
+      CopyFiles /SILENT $4 "$1\autoexec.bat"
+      Delete $4
+      Goto unRemoveFromPath_done
+
+  unRemoveFromPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $5 $1 1 -1 # copy last char
+    StrCmp $5 ";" +2 # if last char != ;
+      StrCpy $1 "$1;" # append ;
+    Push $1
+    Push "$0;"
+    Call un.StrStr ; Find $0; in $1
+    Pop $2 ; pos of our dir
+    StrCmp $2 "" unRemoveFromPath_done
+      ; else, it is in path
+      # $0 - path to add
+      # $1 - path var
+      StrLen $3 "$0;"
+      StrLen $4 $2
+      StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
+      StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
+      StrCpy $3 $5$6
+
+      StrCpy $5 $3 1 -1 # copy last char
+      StrCmp $5 ";" 0 +2 # if last char == ;
+        StrCpy $3 $3 -1 # remove last char
+
+      WriteRegExpandStr HKCU "Environment" "PATH" $3
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  unRemoveFromPath_done:
+    Pop $6
+    Pop $5
+    Pop $4
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+###########################################
+#            Utility Functions            #
+###########################################
+
+; IsNT
+; no input
+; output, top of the stack = 1 if NT or 0 if not
+;
+; Usage:
+;   Call IsNT
+;   Pop $R0
+;  ($R0 at this point is 1 or 0)
+
+!macro IsNT un
+Function ${un}IsNT
+  Push $0
+  ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
+  StrCmp $0 "" 0 IsNT_yes
+  ; we are not NT.
+  Pop $0
+  Push 0
+  Return
+
+  IsNT_yes:
+    ; NT!!!
+    Pop $0
+    Push 1
+FunctionEnd
+!macroend
+!insertmacro IsNT ""
+!insertmacro IsNT "un."
+
+; StrStr
+; input, top of stack = string to search for
+;        top of stack-1 = string to search in
+; output, top of stack (replaces with the portion of the string remaining)
+; modifies no other variables.
+;
+; Usage:
+;   Push "this is a long ass string"
+;   Push "ass"
+;   Call StrStr
+;   Pop $R0
+;  ($R0 at this point is "ass string")
+
+!macro StrStr un
+Function ${un}StrStr
+Exch $R1 ; st=haystack,old$R1, $R1=needle
+  Exch    ; st=old$R1,haystack
+  Exch $R2 ; st=old$R1,old$R2, $R2=haystack
+  Push $R3
+  Push $R4
+  Push $R5
+  StrLen $R3 $R1
+  StrCpy $R4 0
+  ; $R1=needle
+  ; $R2=haystack
+  ; $R3=len(needle)
+  ; $R4=cnt
+  ; $R5=tmp
+  loop:
+    StrCpy $R5 $R2 $R3 $R4
+    StrCmp $R5 $R1 done
+    StrCmp $R5 "" done
+    IntOp $R4 $R4 + 1
+    Goto loop
+done:
+  StrCpy $R1 $R2 "" $R4
+  Pop $R5
+  Pop $R4
+  Pop $R3
+  Pop $R2
+  Exch $R1
+FunctionEnd
+!macroend
+!insertmacro StrStr ""
+!insertmacro StrStr "un."
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; end subroutines for PATH change ====================
+
+LicenseText License
+LicenseData c:\newlisp\COPYING
+
+ComponentText Select components
+
+ShowInstDetails show
+
+; The stuff to install
+Section "newLISP program (required) and DLL"
+  CreateDirectory $INSTDIR\guiserver
+  CreateDirectory $INSTDIR\modules
+  CreateDirectory $INSTDIR\util
+  ; Set output path to the installation directories.
+  ; since 10.3.5 newlisp.dll is back in the newlisp directory
+
+  SetOutPath $INSTDIR
+  File "c:\newlisp\newlisp.exe"
+  File "c:\newlisp\newlisp.dll"  
+  File "c:\newlisp\md5-checksums.txt"
+  File "c:\newlisp\newlisp_manual.html"
+  File "c:\newlisp\newlisp_index.html"
+  File "c:\newlisp\manual_frame.html"
+  File "c:\newlisp\CodePatterns.html"
+  File "c:\newlisp\newLISPdoc.html"
+  File "c:\newlisp\newLISP-10.7.0-Release.html"
+  File "c:\newlisp\COPYING"
+  File "c:\newlisp\guiserver.lsp"
+  File "c:\newlisp\guiserver.jar"
+  File "c:\newlisp\newlisp-edit.lsp"
+  File "c:\newlisp\newlisp-win.ico"
+
+  SetOutPath $INSTDIR\guiserver
+  File "c:\newlisp\guiserver\index-gs.html"
+  File "c:\newlisp\guiserver\guiserver.lsp.html"
+  File "c:\newlisp\guiserver\newlispdoc.css"
+  File "c:\newlisp\guiserver\allfonts-demo.lsp"
+  File "c:\newlisp\guiserver\animation-demo.lsp"
+  File "c:\newlisp\guiserver\border-layout-demo.lsp"
+  File "c:\newlisp\guiserver\button-demo.lsp"
+  File "c:\newlisp\guiserver\clipboard-demo.lsp"
+  File "c:\newlisp\guiserver\cursor-demo.lsp"
+  File "c:\newlisp\guiserver\drag-demo.lsp"
+  File "c:\newlisp\guiserver\font-demo.lsp"
+  File "c:\newlisp\guiserver\frameless-demo.lsp"
+  File "c:\newlisp\guiserver\html-demo.lsp"
+  File "c:\newlisp\guiserver\image-demo.lsp"
+  File "c:\newlisp\guiserver\midi-demo.lsp"
+  File "c:\newlisp\guiserver\midi2-demo.lsp"
+  File "c:\newlisp\guiserver\mouse-demo.lsp"
+  File "c:\newlisp\guiserver\move-resize-demo.lsp"
+  File "c:\newlisp\guiserver\pinballs-demo.lsp"
+  File "c:\newlisp\guiserver\properties-demo.lsp"
+  File "c:\newlisp\guiserver\rotation-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\shapes-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\sound-demo.lsp"
+  File "c:\newlisp\guiserver\stroke-demo.lsp"
+  File "c:\newlisp\guiserver\tabs-demo.lsp"
+  File "c:\newlisp\guiserver\table-demo.lsp"
+  File "c:\newlisp\guiserver\textrot-demo.lsp"
+  File "c:\newlisp\guiserver\widgets-demo.lsp"
+  File "c:\newlisp\guiserver\word-count.lsp"
+  File "c:\newlisp\guiserver\uppercase.lsp"
+
+  SetOutPath $INSTDIR\modules
+  File "c:\newlisp\modules\canvas.lsp"
+  File "c:\newlisp\modules\cgi.lsp"
+  File "c:\newlisp\modules\crypto.lsp"
+  File "c:\newlisp\modules\ftp.lsp"
+  File "c:\newlisp\modules\gsl.lsp"
+  File "c:\newlisp\modules\infix.lsp"
+  File "c:\newlisp\modules\mysql.lsp"
+  File "c:\newlisp\modules\odbc.lsp"
+  File "c:\newlisp\modules\plot.lsp"
+  File "c:\newlisp\modules\pop3.lsp"
+  File "c:\newlisp\modules\postgres.lsp"
+  File "c:\newlisp\modules\postscript.lsp"
+  File "c:\newlisp\modules\smtp.lsp"
+  File "c:\newlisp\modules\smtpx.lsp"
+  File "c:\newlisp\modules\sqlite3.lsp"
+  File "c:\newlisp\modules\stat.lsp"
+  File "c:\newlisp\modules\unix.lsp"
+  File "c:\newlisp\modules\xmlrpc-client.lsp" 
+  File "c:\newlisp\modules\zlib.lsp"
+
+  SetOutPath $INSTDIR\util
+  File "c:\newlisp\util\newlispdoc"
+  File "c:\newlisp\util\newlisp.vim"
+  File "c:\newlisp\util\syntax.cgi"
+
+  SetOutPath $INSTDIR
+
+  ; Write the installation path into the registry
+  WriteRegStr HKLM SOFTWARE\newLISP "Install_Dir" "$INSTDIR"
+
+  ; Write envionment variable intor registry
+  WriteRegStr HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "NEWLISPDIR" "$INSTDIR"
+
+  ; Write the uninstall keys for Windows
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "DisplayName" "newLISP (remove only)"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "UninstallString" '"$INSTDIR\uninstall.exe"'
+
+  WriteUninstaller "uninstall.exe"
+  ; make menu in startmenus
+  CreateDirectory "$SMPROGRAMS\newLISP"
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP.lnk" "$INSTDIR\newlisp.exe" "" "$INSTDIR\newlisp.exe" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Release Notes.lnk" "$INSTDIR\newLISP-10.7.0-Release.html" "" "$INSTDIR\newLISP-10.7.0-Release.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Manual and Reference.lnk" "$INSTDIR\manual_frame.html" "" "$INSTDIR\manual_frame.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Code Patterns.lnk" "$INSTDIR\CodePatterns.html" "" "$INSTDIR\CodePatterns.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\GS Manual and Reference.lnk" "$INSTDIR\guiserver\index-gs.html" "" "$INSTDIR\guiserver\index-gs.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Uninstall.lnk" "$INSTDIR\uninstall.exe" "" "$INSTDIR\uninstall.exe" 0
+
+SectionEnd ; end the section
+
+Section "Add to path"
+  Push $INSTDIR
+  Call AddToPath
+SectionEnd
+
+Section "Create desktop shortcut"
+  CreateShortCut "$DESKTOP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+SectionEnd
+
+; uninstall stuff
+UninstallText "This will uninstall newLISP. Hit next to continue."
+
+; special uninstall section.
+Section "Uninstall"
+
+  ; remove registry keys
+  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP"
+  DeleteRegKey HKLM SOFTWARE\newLISP
+
+  ; remove files
+  Delete $INSTDIR\newlisp.exe
+  Delete $INSTDIR\newlisp.dll
+  Delete $INSTDIR\editor.txt
+  Delete $INSTDIR\util\newlispdoc
+  Delete $INSTDIR\util\newlisp.vim
+  Delete $INSTDIR\util\syntax.cgi
+  Delete $INSTDIR\md5-checksums.txt
+  Delete $INSTDIR\newlisp_manual.html
+  Delete $INSTDIR\newlisp_index.html
+  Delete $INSTDIR\manual_frame.html
+  Delete $INSTDIR\CodePatterns.html
+  Delete $INSTDIR\newLISPdoc.html
+  Delete $INSTDIR\newLISP-10.7.0-Release.html
+  Delete $INSTDIR\COPYING
+  Delete $INSTDIR\guiserver.lsp
+  Delete $INSTDIR\guiserver.jar
+  Delete $INSTDIR\newlisp-edit.lsp
+  Delete $INSTDIR\newlisp-win.ico
+
+  Delete $INSTDIR\guiserver\index-gs.html
+  Delete $INSTDIR\guiserver\guiserver.lsp.html
+  Delete $INSTDIR\guiserver\newlispdoc.css
+  Delete $INSTDIR\guiserver\allfonts-demo.lsp
+  Delete $INSTDIR\guiserver\animation-demo.lsp
+  Delete $INSTDIR\guiserver\border-layout-demo.lsp
+  Delete $INSTDIR\guiserver\button-demo.lsp
+  Delete $INSTDIR\guiserver\clipboard-demo.lsp
+  Delete $INSTDIR\guiserver\cursor-demo.lsp
+  Delete $INSTDIR\guiserver\drag-demo.lsp
+  Delete $INSTDIR\guiserver\font-demo.lsp
+  Delete $INSTDIR\guiserver\frameless-demo.lsp
+  Delete $INSTDIR\guiserver\html-demo.lsp
+  Delete $INSTDIR\guiserver\image-demo.lsp
+  Delete $INSTDIR\guiserver\midi-demo.lsp
+  Delete $INSTDIR\guiserver\midi2-demo.lsp
+  Delete $INSTDIR\guiserver\mouse-demo.lsp
+  Delete $INSTDIR\guiserver\move-resize-demo.lsp
+  Delete $INSTDIR\guiserver\pinballs-demo.lsp
+  Delete $INSTDIR\guiserver\properties-demo.lsp
+  Delete $INSTDIR\guiserver\rotation-demo.lsp
+  Delete $INSTDIR\guiserver\shapes-demo.lsp
+  Delete $INSTDIR\guiserver\scroll-pane-demo.lsp
+  Delete $INSTDIR\guiserver\sound-demo.lsp
+  Delete $INSTDIR\guiserver\stroke-demo.lsp
+  Delete $INSTDIR\guiserver\tabs-demo.lsp
+  Delete $INSTDIR\guiserver\table-demo.lsp
+  Delete $INSTDIR\guiserver\textrot-demo.lsp
+  Delete $INSTDIR\guiserver\widgets-demo.lsp
+  Delete $INSTDIR\guiserver\word-count.lsp
+  Delete $INSTDIR\guiserver\uppercase.lsp
+
+  Delete $INSTDIR\modules\canvas.lsp
+  Delete $INSTDIR\modules\cgi.lsp
+  Delete $INSTDIR\modules\crypto.lsp
+  Delete $INSTDIR\modules\ftp.lsp
+  Delete $INSTDIR\modules\gsl.lsp
+  Delete $INSTDIR\modules\infix.lsp
+  Delete $INSTDIR\modules\mysql.lsp
+  Delete $INSTDIR\modules\odbc.lsp
+  Delete $INSTDIR\modules\plot.lsp
+  Delete $INSTDIR\modules\pop3.lsp
+  Delete $INSTDIR\modules\postgres.lsp
+  Delete $INSTDIR\modules\postscript.lsp
+  Delete $INSTDIR\modules\smtp.lsp
+  Delete $INSTDIR\modules\smtpx.lsp
+  Delete $INSTDIR\modules\sqlite3.lsp
+  Delete $INSTDIR\modules\stat.lsp
+  Delete $INSTDIR\modules\unix.lsp
+  Delete $INSTDIR\modules\xmlrpc-client.lsp 
+  Delete $INSTDIR\modules\zlib.lsp
+  ; remove start menu entries
+  Delete "$DESKTOP\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP\*.*"
+  RMDir "$SMPROGRAMS\newLISP"
+
+  ; remove uninstaller, links and install dir
+  Delete $INSTDIR\uninstall.exe
+  RMDir "$INSTDIR\guiserver"
+  RMDir "$INSTDIR\modules"
+  RMDir "$INSTDIR\util"
+  RMDir "$INSTDIR"
+
+  Push $INSTDIR
+  Call un.RemoveFromPath
+
+SectionEnd
+
+; eof
diff --git a/guiserver/newlisp-gs.nsi.bak b/guiserver/newlisp-gs.nsi.bak
new file mode 100644
index 0000000..dad0107
--- /dev/null
+++ b/guiserver/newlisp-gs.nsi.bak
@@ -0,0 +1,481 @@
+; newlisp-gs.nsi
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The name of the installer
+Name "newLISP-GS"
+
+; The file to write
+OutFile "c:\WinDev\newlisp\newlisp-10700-win-gs-165.exe"
+
+; The default installation directory
+InstallDir $PROGRAMFILES\newlisp
+
+; The text to prompt the user to enter a directory
+DirText "This will install newLISP v.10.6.5 and Guiserver 1.64 on your computer. IF NOT INSTALLING IN THE DEFAULT DIRECTORY REBOOT AFTER INSTALL."
+
+;;;;;;; subroutines for PATH change in MS Windows environment ;;;;;;;;;
+!verbose 3
+!include "WinMessages.NSH"
+!verbose 4
+
+; AddToPath - Adds the given dir to the search path.
+;        Input - head of the stack
+;        Note - Win9x systems requires reboot
+
+Function AddToPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+
+  # don't add if the path doesn't exist
+  IfFileExists "$0\*.*" "" AddToPath_done
+
+  ReadEnvStr $1 PATH
+  Push "$1;"
+  Push "$0;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$0\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  GetFullPathName /SHORT $3 $0
+  Push "$1;"
+  Push "$3;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$3\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+
+  Call IsNT
+  Pop $1
+  StrCmp $1 1 AddToPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" a
+    FileSeek $1 -1 END
+    FileReadByte $1 $2
+    IntCmp $2 26 0 +2 +2 # DOS EOF
+      FileSeek $1 -1 END # write over EOF
+    FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
+    FileClose $1
+    SetRebootFlag true
+    Goto AddToPath_done
+
+  AddToPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $2 $1 1 -1 # copy last char
+    StrCmp $2 ";" 0 +2 # if last char == ;
+      StrCpy $1 $1 -1 # remove last char
+    StrCmp $1 "" AddToPath_NTdoIt
+      StrCpy $0 "$1;$0"
+    AddToPath_NTdoIt:
+      WriteRegExpandStr HKCU "Environment" "PATH" $0
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  AddToPath_done:
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+; RemoveFromPath - Remove a given dir from the path
+;     Input: head of the stack
+
+Function un.RemoveFromPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+  Push $4
+  Push $5
+  Push $6
+
+  IntFmt $6 "%c" 26 # DOS EOF
+
+  Call un.IsNT
+  Pop $1
+  StrCmp $1 1 unRemoveFromPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" r
+    GetTempFileName $4
+    FileOpen $2 $4 w
+    GetFullPathName /SHORT $0 $0
+    StrCpy $0 "SET PATH=%PATH%;$0"
+    Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoop:
+      FileRead $1 $3
+      StrCpy $5 $3 1 -1 # read last char
+      StrCmp $5 $6 0 +2 # if DOS EOF
+        StrCpy $3 $3 -1 # remove DOS EOF so we can compare
+      StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "" unRemoveFromPath_dosLoopEnd
+      FileWrite $2 $3
+      Goto unRemoveFromPath_dosLoop
+      unRemoveFromPath_dosLoopRemoveLine:
+        SetRebootFlag true
+        Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoopEnd:
+      FileClose $2
+      FileClose $1
+      StrCpy $1 $WINDIR 2
+      Delete "$1\autoexec.bat"
+      CopyFiles /SILENT $4 "$1\autoexec.bat"
+      Delete $4
+      Goto unRemoveFromPath_done
+
+  unRemoveFromPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $5 $1 1 -1 # copy last char
+    StrCmp $5 ";" +2 # if last char != ;
+      StrCpy $1 "$1;" # append ;
+    Push $1
+    Push "$0;"
+    Call un.StrStr ; Find $0; in $1
+    Pop $2 ; pos of our dir
+    StrCmp $2 "" unRemoveFromPath_done
+      ; else, it is in path
+      # $0 - path to add
+      # $1 - path var
+      StrLen $3 "$0;"
+      StrLen $4 $2
+      StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
+      StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
+      StrCpy $3 $5$6
+
+      StrCpy $5 $3 1 -1 # copy last char
+      StrCmp $5 ";" 0 +2 # if last char == ;
+        StrCpy $3 $3 -1 # remove last char
+
+      WriteRegExpandStr HKCU "Environment" "PATH" $3
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  unRemoveFromPath_done:
+    Pop $6
+    Pop $5
+    Pop $4
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+###########################################
+#            Utility Functions            #
+###########################################
+
+; IsNT
+; no input
+; output, top of the stack = 1 if NT or 0 if not
+;
+; Usage:
+;   Call IsNT
+;   Pop $R0
+;  ($R0 at this point is 1 or 0)
+
+!macro IsNT un
+Function ${un}IsNT
+  Push $0
+  ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
+  StrCmp $0 "" 0 IsNT_yes
+  ; we are not NT.
+  Pop $0
+  Push 0
+  Return
+
+  IsNT_yes:
+    ; NT!!!
+    Pop $0
+    Push 1
+FunctionEnd
+!macroend
+!insertmacro IsNT ""
+!insertmacro IsNT "un."
+
+; StrStr
+; input, top of stack = string to search for
+;        top of stack-1 = string to search in
+; output, top of stack (replaces with the portion of the string remaining)
+; modifies no other variables.
+;
+; Usage:
+;   Push "this is a long ass string"
+;   Push "ass"
+;   Call StrStr
+;   Pop $R0
+;  ($R0 at this point is "ass string")
+
+!macro StrStr un
+Function ${un}StrStr
+Exch $R1 ; st=haystack,old$R1, $R1=needle
+  Exch    ; st=old$R1,haystack
+  Exch $R2 ; st=old$R1,old$R2, $R2=haystack
+  Push $R3
+  Push $R4
+  Push $R5
+  StrLen $R3 $R1
+  StrCpy $R4 0
+  ; $R1=needle
+  ; $R2=haystack
+  ; $R3=len(needle)
+  ; $R4=cnt
+  ; $R5=tmp
+  loop:
+    StrCpy $R5 $R2 $R3 $R4
+    StrCmp $R5 $R1 done
+    StrCmp $R5 "" done
+    IntOp $R4 $R4 + 1
+    Goto loop
+done:
+  StrCpy $R1 $R2 "" $R4
+  Pop $R5
+  Pop $R4
+  Pop $R3
+  Pop $R2
+  Exch $R1
+FunctionEnd
+!macroend
+!insertmacro StrStr ""
+!insertmacro StrStr "un."
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; end subroutines for PATH change ====================
+
+LicenseText License
+LicenseData c:\newlisp\COPYING
+
+ComponentText Select components
+
+ShowInstDetails show
+
+; The stuff to install
+Section "newLISP program (required) and DLL"
+  CreateDirectory $INSTDIR\guiserver
+  CreateDirectory $INSTDIR\modules
+  CreateDirectory $INSTDIR\util
+  ; Set output path to the installation directories.
+  ; since 10.3.5 newlisp.dll is back in the newlisp directory
+
+  SetOutPath $INSTDIR
+  File "c:\newlisp\newlisp.exe"
+  File "c:\newlisp\newlisp.dll"  
+  File "c:\newlisp\md5-checksums.txt"
+  File "c:\newlisp\newlisp_manual.html"
+  File "c:\newlisp\newlisp_index.html"
+  File "c:\newlisp\manual_frame.html"
+  File "c:\newlisp\CodePatterns.html"
+  File "c:\newlisp\newLISPdoc.html"
+  File "c:\newlisp\newLISP-10.6.5-Release.html"
+  File "c:\newlisp\COPYING"
+  File "c:\newlisp\guiserver.lsp"
+  File "c:\newlisp\guiserver.jar"
+  File "c:\newlisp\newlisp-edit.lsp"
+  File "c:\newlisp\newlisp-win.ico"
+
+  SetOutPath $INSTDIR\guiserver
+  File "c:\newlisp\guiserver\index-gs.html"
+  File "c:\newlisp\guiserver\guiserver.lsp.html"
+  File "c:\newlisp\guiserver\newlispdoc.css"
+  File "c:\newlisp\guiserver\allfonts-demo.lsp"
+  File "c:\newlisp\guiserver\animation-demo.lsp"
+  File "c:\newlisp\guiserver\border-layout-demo.lsp"
+  File "c:\newlisp\guiserver\button-demo.lsp"
+  File "c:\newlisp\guiserver\clipboard-demo.lsp"
+  File "c:\newlisp\guiserver\cursor-demo.lsp"
+  File "c:\newlisp\guiserver\drag-demo.lsp"
+  File "c:\newlisp\guiserver\font-demo.lsp"
+  File "c:\newlisp\guiserver\frameless-demo.lsp"
+  File "c:\newlisp\guiserver\html-demo.lsp"
+  File "c:\newlisp\guiserver\image-demo.lsp"
+  File "c:\newlisp\guiserver\midi-demo.lsp"
+  File "c:\newlisp\guiserver\midi2-demo.lsp"
+  File "c:\newlisp\guiserver\mouse-demo.lsp"
+  File "c:\newlisp\guiserver\move-resize-demo.lsp"
+  File "c:\newlisp\guiserver\pinballs-demo.lsp"
+  File "c:\newlisp\guiserver\properties-demo.lsp"
+  File "c:\newlisp\guiserver\rotation-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\shapes-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\sound-demo.lsp"
+  File "c:\newlisp\guiserver\stroke-demo.lsp"
+  File "c:\newlisp\guiserver\tabs-demo.lsp"
+  File "c:\newlisp\guiserver\table-demo.lsp"
+  File "c:\newlisp\guiserver\textrot-demo.lsp"
+  File "c:\newlisp\guiserver\widgets-demo.lsp"
+  File "c:\newlisp\guiserver\word-count.lsp"
+  File "c:\newlisp\guiserver\uppercase.lsp"
+
+  SetOutPath $INSTDIR\modules
+  File "c:\newlisp\modules\canvas.lsp"
+  File "c:\newlisp\modules\cgi.lsp"
+  File "c:\newlisp\modules\crypto.lsp"
+  File "c:\newlisp\modules\ftp.lsp"
+  File "c:\newlisp\modules\gsl.lsp"
+  File "c:\newlisp\modules\infix.lsp"
+  File "c:\newlisp\modules\mysql.lsp"
+  File "c:\newlisp\modules\odbc.lsp"
+  File "c:\newlisp\modules\plot.lsp"
+  File "c:\newlisp\modules\pop3.lsp"
+  File "c:\newlisp\modules\postgres.lsp"
+  File "c:\newlisp\modules\postscript.lsp"
+  File "c:\newlisp\modules\smtp.lsp"
+  File "c:\newlisp\modules\smtpx.lsp"
+  File "c:\newlisp\modules\sqlite3.lsp"
+  File "c:\newlisp\modules\stat.lsp"
+  File "c:\newlisp\modules\unix.lsp"
+  File "c:\newlisp\modules\xmlrpc-client.lsp" 
+  File "c:\newlisp\modules\zlib.lsp"
+
+  SetOutPath $INSTDIR\util
+  File "c:\newlisp\util\newlispdoc"
+  File "c:\newlisp\util\newlisp.vim"
+  File "c:\newlisp\util\syntax.cgi"
+
+  SetOutPath $INSTDIR
+
+  ; Write the installation path into the registry
+  WriteRegStr HKLM SOFTWARE\newLISP "Install_Dir" "$INSTDIR"
+
+  ; Write envionment variable intor registry
+  WriteRegStr HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "NEWLISPDIR" "$INSTDIR"
+
+  ; Write the uninstall keys for Windows
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "DisplayName" "newLISP (remove only)"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "UninstallString" '"$INSTDIR\uninstall.exe"'
+
+  WriteUninstaller "uninstall.exe"
+  ; make menu in startmenus
+  CreateDirectory "$SMPROGRAMS\newLISP"
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP.lnk" "$INSTDIR\newlisp.exe" "" "$INSTDIR\newlisp.exe" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Release Notes.lnk" "$INSTDIR\newLISP-10.6.5-Release.html" "" "$INSTDIR\newLISP-10.6.5-Release.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Manual and Reference.lnk" "$INSTDIR\manual_frame.html" "" "$INSTDIR\manual_frame.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Code Patterns.lnk" "$INSTDIR\CodePatterns.html" "" "$INSTDIR\CodePatterns.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\GS Manual and Reference.lnk" "$INSTDIR\guiserver\index-gs.html" "" "$INSTDIR\guiserver\index-gs.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Uninstall.lnk" "$INSTDIR\uninstall.exe" "" "$INSTDIR\uninstall.exe" 0
+
+SectionEnd ; end the section
+
+Section "Add to path"
+  Push $INSTDIR
+  Call AddToPath
+SectionEnd
+
+Section "Create desktop shortcut"
+  CreateShortCut "$DESKTOP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+SectionEnd
+
+; uninstall stuff
+UninstallText "This will uninstall newLISP. Hit next to continue."
+
+; special uninstall section.
+Section "Uninstall"
+
+  ; remove registry keys
+  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP"
+  DeleteRegKey HKLM SOFTWARE\newLISP
+
+  ; remove files
+  Delete $INSTDIR\newlisp.exe
+  Delete $INSTDIR\newlisp.dll
+  Delete $INSTDIR\editor.txt
+  Delete $INSTDIR\util\newlispdoc
+  Delete $INSTDIR\util\newlisp.vim
+  Delete $INSTDIR\util\syntax.cgi
+  Delete $INSTDIR\md5-checksums.txt
+  Delete $INSTDIR\newlisp_manual.html
+  Delete $INSTDIR\newlisp_index.html
+  Delete $INSTDIR\manual_frame.html
+  Delete $INSTDIR\CodePatterns.html
+  Delete $INSTDIR\newLISPdoc.html
+  Delete $INSTDIR\newLISP-10.6.5-Release.html
+  Delete $INSTDIR\COPYING
+  Delete $INSTDIR\guiserver.lsp
+  Delete $INSTDIR\guiserver.jar
+  Delete $INSTDIR\newlisp-edit.lsp
+  Delete $INSTDIR\newlisp-win.ico
+
+  Delete $INSTDIR\guiserver\index-gs.html
+  Delete $INSTDIR\guiserver\guiserver.lsp.html
+  Delete $INSTDIR\guiserver\newlispdoc.css
+  Delete $INSTDIR\guiserver\allfonts-demo.lsp
+  Delete $INSTDIR\guiserver\animation-demo.lsp
+  Delete $INSTDIR\guiserver\border-layout-demo.lsp
+  Delete $INSTDIR\guiserver\button-demo.lsp
+  Delete $INSTDIR\guiserver\clipboard-demo.lsp
+  Delete $INSTDIR\guiserver\cursor-demo.lsp
+  Delete $INSTDIR\guiserver\drag-demo.lsp
+  Delete $INSTDIR\guiserver\font-demo.lsp
+  Delete $INSTDIR\guiserver\frameless-demo.lsp
+  Delete $INSTDIR\guiserver\html-demo.lsp
+  Delete $INSTDIR\guiserver\image-demo.lsp
+  Delete $INSTDIR\guiserver\midi-demo.lsp
+  Delete $INSTDIR\guiserver\midi2-demo.lsp
+  Delete $INSTDIR\guiserver\mouse-demo.lsp
+  Delete $INSTDIR\guiserver\move-resize-demo.lsp
+  Delete $INSTDIR\guiserver\pinballs-demo.lsp
+  Delete $INSTDIR\guiserver\properties-demo.lsp
+  Delete $INSTDIR\guiserver\rotation-demo.lsp
+  Delete $INSTDIR\guiserver\shapes-demo.lsp
+  Delete $INSTDIR\guiserver\scroll-pane-demo.lsp
+  Delete $INSTDIR\guiserver\sound-demo.lsp
+  Delete $INSTDIR\guiserver\stroke-demo.lsp
+  Delete $INSTDIR\guiserver\tabs-demo.lsp
+  Delete $INSTDIR\guiserver\table-demo.lsp
+  Delete $INSTDIR\guiserver\textrot-demo.lsp
+  Delete $INSTDIR\guiserver\widgets-demo.lsp
+  Delete $INSTDIR\guiserver\word-count.lsp
+  Delete $INSTDIR\guiserver\uppercase.lsp
+
+  Delete $INSTDIR\modules\canvas.lsp
+  Delete $INSTDIR\modules\cgi.lsp
+  Delete $INSTDIR\modules\crypto.lsp
+  Delete $INSTDIR\modules\ftp.lsp
+  Delete $INSTDIR\modules\gsl.lsp
+  Delete $INSTDIR\modules\infix.lsp
+  Delete $INSTDIR\modules\mysql.lsp
+  Delete $INSTDIR\modules\odbc.lsp
+  Delete $INSTDIR\modules\plot.lsp
+  Delete $INSTDIR\modules\pop3.lsp
+  Delete $INSTDIR\modules\postgres.lsp
+  Delete $INSTDIR\modules\postscript.lsp
+  Delete $INSTDIR\modules\smtp.lsp
+  Delete $INSTDIR\modules\smtpx.lsp
+  Delete $INSTDIR\modules\sqlite3.lsp
+  Delete $INSTDIR\modules\stat.lsp
+  Delete $INSTDIR\modules\unix.lsp
+  Delete $INSTDIR\modules\xmlrpc-client.lsp 
+  Delete $INSTDIR\modules\zlib.lsp
+  ; remove start menu entries
+  Delete "$DESKTOP\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP\*.*"
+  RMDir "$SMPROGRAMS\newLISP"
+
+  ; remove uninstaller, links and install dir
+  Delete $INSTDIR\uninstall.exe
+  RMDir "$INSTDIR\guiserver"
+  RMDir "$INSTDIR\modules"
+  RMDir "$INSTDIR\util"
+  RMDir "$INSTDIR"
+
+  Push $INSTDIR
+  Call un.RemoveFromPath
+
+SectionEnd
+
+; eof
diff --git a/guiserver/newlisp-win.ico b/guiserver/newlisp-win.ico
new file mode 100644
index 0000000..7f8d392
Binary files /dev/null and b/guiserver/newlisp-win.ico differ
diff --git a/guiserver/newlisp64-gs.nsi b/guiserver/newlisp64-gs.nsi
new file mode 100644
index 0000000..b5aba87
--- /dev/null
+++ b/guiserver/newlisp64-gs.nsi
@@ -0,0 +1,481 @@
+; newlisp-gs.nsi
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The name of the installer
+Name "newLISP-GS"
+
+; The file to write
+OutFile "c:\WinDev\newlisp\newlisp-10700-win64-gs-166.exe"
+
+; The default installation directory
+InstallDir $PROGRAMFILES\newlisp
+
+; The text to prompt the user to enter a directory
+DirText "This will install newLISP v.10.7.0 and Guiserver 1.66 on your computer. IF NOT INSTALLING IN THE DEFAULT DIRECTORY REBOOT AFTER INSTALL."
+
+;;;;;;; subroutines for PATH change in MS Windows environment ;;;;;;;;;
+!verbose 3
+!include "WinMessages.NSH"
+!verbose 4
+
+; AddToPath - Adds the given dir to the search path.
+;        Input - head of the stack
+;        Note - Win9x systems requires reboot
+
+Function AddToPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+
+  # don't add if the path doesn't exist
+  IfFileExists "$0\*.*" "" AddToPath_done
+
+  ReadEnvStr $1 PATH
+  Push "$1;"
+  Push "$0;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$0\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  GetFullPathName /SHORT $3 $0
+  Push "$1;"
+  Push "$3;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$3\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+
+  Call IsNT
+  Pop $1
+  StrCmp $1 1 AddToPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" a
+    FileSeek $1 -1 END
+    FileReadByte $1 $2
+    IntCmp $2 26 0 +2 +2 # DOS EOF
+      FileSeek $1 -1 END # write over EOF
+    FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
+    FileClose $1
+    SetRebootFlag true
+    Goto AddToPath_done
+
+  AddToPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $2 $1 1 -1 # copy last char
+    StrCmp $2 ";" 0 +2 # if last char == ;
+      StrCpy $1 $1 -1 # remove last char
+    StrCmp $1 "" AddToPath_NTdoIt
+      StrCpy $0 "$1;$0"
+    AddToPath_NTdoIt:
+      WriteRegExpandStr HKCU "Environment" "PATH" $0
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  AddToPath_done:
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+; RemoveFromPath - Remove a given dir from the path
+;     Input: head of the stack
+
+Function un.RemoveFromPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+  Push $4
+  Push $5
+  Push $6
+
+  IntFmt $6 "%c" 26 # DOS EOF
+
+  Call un.IsNT
+  Pop $1
+  StrCmp $1 1 unRemoveFromPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" r
+    GetTempFileName $4
+    FileOpen $2 $4 w
+    GetFullPathName /SHORT $0 $0
+    StrCpy $0 "SET PATH=%PATH%;$0"
+    Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoop:
+      FileRead $1 $3
+      StrCpy $5 $3 1 -1 # read last char
+      StrCmp $5 $6 0 +2 # if DOS EOF
+        StrCpy $3 $3 -1 # remove DOS EOF so we can compare
+      StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "" unRemoveFromPath_dosLoopEnd
+      FileWrite $2 $3
+      Goto unRemoveFromPath_dosLoop
+      unRemoveFromPath_dosLoopRemoveLine:
+        SetRebootFlag true
+        Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoopEnd:
+      FileClose $2
+      FileClose $1
+      StrCpy $1 $WINDIR 2
+      Delete "$1\autoexec.bat"
+      CopyFiles /SILENT $4 "$1\autoexec.bat"
+      Delete $4
+      Goto unRemoveFromPath_done
+
+  unRemoveFromPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $5 $1 1 -1 # copy last char
+    StrCmp $5 ";" +2 # if last char != ;
+      StrCpy $1 "$1;" # append ;
+    Push $1
+    Push "$0;"
+    Call un.StrStr ; Find $0; in $1
+    Pop $2 ; pos of our dir
+    StrCmp $2 "" unRemoveFromPath_done
+      ; else, it is in path
+      # $0 - path to add
+      # $1 - path var
+      StrLen $3 "$0;"
+      StrLen $4 $2
+      StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
+      StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
+      StrCpy $3 $5$6
+
+      StrCpy $5 $3 1 -1 # copy last char
+      StrCmp $5 ";" 0 +2 # if last char == ;
+        StrCpy $3 $3 -1 # remove last char
+
+      WriteRegExpandStr HKCU "Environment" "PATH" $3
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  unRemoveFromPath_done:
+    Pop $6
+    Pop $5
+    Pop $4
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+###########################################
+#            Utility Functions            #
+###########################################
+
+; IsNT
+; no input
+; output, top of the stack = 1 if NT or 0 if not
+;
+; Usage:
+;   Call IsNT
+;   Pop $R0
+;  ($R0 at this point is 1 or 0)
+
+!macro IsNT un
+Function ${un}IsNT
+  Push $0
+  ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
+  StrCmp $0 "" 0 IsNT_yes
+  ; we are not NT.
+  Pop $0
+  Push 0
+  Return
+
+  IsNT_yes:
+    ; NT!!!
+    Pop $0
+    Push 1
+FunctionEnd
+!macroend
+!insertmacro IsNT ""
+!insertmacro IsNT "un."
+
+; StrStr
+; input, top of stack = string to search for
+;        top of stack-1 = string to search in
+; output, top of stack (replaces with the portion of the string remaining)
+; modifies no other variables.
+;
+; Usage:
+;   Push "this is a long ass string"
+;   Push "ass"
+;   Call StrStr
+;   Pop $R0
+;  ($R0 at this point is "ass string")
+
+!macro StrStr un
+Function ${un}StrStr
+Exch $R1 ; st=haystack,old$R1, $R1=needle
+  Exch    ; st=old$R1,haystack
+  Exch $R2 ; st=old$R1,old$R2, $R2=haystack
+  Push $R3
+  Push $R4
+  Push $R5
+  StrLen $R3 $R1
+  StrCpy $R4 0
+  ; $R1=needle
+  ; $R2=haystack
+  ; $R3=len(needle)
+  ; $R4=cnt
+  ; $R5=tmp
+  loop:
+    StrCpy $R5 $R2 $R3 $R4
+    StrCmp $R5 $R1 done
+    StrCmp $R5 "" done
+    IntOp $R4 $R4 + 1
+    Goto loop
+done:
+  StrCpy $R1 $R2 "" $R4
+  Pop $R5
+  Pop $R4
+  Pop $R3
+  Pop $R2
+  Exch $R1
+FunctionEnd
+!macroend
+!insertmacro StrStr ""
+!insertmacro StrStr "un."
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; end subroutines for PATH change ====================
+
+LicenseText License
+LicenseData c:\newlisp\COPYING
+
+ComponentText Select components
+
+ShowInstDetails show
+
+; The stuff to install
+Section "newLISP program (required) and DLL"
+  CreateDirectory $INSTDIR\guiserver
+  CreateDirectory $INSTDIR\modules
+  CreateDirectory $INSTDIR\util
+  ; Set output path to the installation directories.
+  ; sincd 10.3.5 newlisp.dll is back in the newlisp directory
+
+  SetOutPath $INSTDIR
+  File "c:\newlisp\newlisp.exe"
+  File "c:\newlisp\newlisp.dll"  
+  File "c:\newlisp\md5-checksums.txt"
+  File "c:\newlisp\newlisp_manual.html"
+  File "c:\newlisp\newlisp_index.html"
+  File "c:\newlisp\manual_frame.html"
+  File "c:\newlisp\CodePatterns.html"
+  File "c:\newlisp\newLISPdoc.html"
+  File "c:\newlisp\newLISP-10.7.0-Release.html"
+  File "c:\newlisp\COPYING"
+  File "c:\newlisp\guiserver.lsp"
+  File "c:\newlisp\guiserver.jar"
+  File "c:\newlisp\newlisp-edit.lsp"
+  File "c:\newlisp\newlisp-win.ico"
+
+  SetOutPath $INSTDIR\guiserver
+  File "c:\newlisp\guiserver\index-gs.html"
+  File "c:\newlisp\guiserver\guiserver.lsp.html"
+  File "c:\newlisp\guiserver\newlispdoc.css"
+  File "c:\newlisp\guiserver\allfonts-demo.lsp"
+  File "c:\newlisp\guiserver\animation-demo.lsp"
+  File "c:\newlisp\guiserver\border-layout-demo.lsp"
+  File "c:\newlisp\guiserver\button-demo.lsp"
+  File "c:\newlisp\guiserver\clipboard-demo.lsp"
+  File "c:\newlisp\guiserver\cursor-demo.lsp"
+  File "c:\newlisp\guiserver\drag-demo.lsp"
+  File "c:\newlisp\guiserver\font-demo.lsp"
+  File "c:\newlisp\guiserver\frameless-demo.lsp"
+  File "c:\newlisp\guiserver\html-demo.lsp"
+  File "c:\newlisp\guiserver\image-demo.lsp"
+  File "c:\newlisp\guiserver\midi-demo.lsp"
+  File "c:\newlisp\guiserver\midi2-demo.lsp"
+  File "c:\newlisp\guiserver\mouse-demo.lsp"
+  File "c:\newlisp\guiserver\move-resize-demo.lsp"
+  File "c:\newlisp\guiserver\pinballs-demo.lsp"
+  File "c:\newlisp\guiserver\properties-demo.lsp"
+  File "c:\newlisp\guiserver\rotation-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\shapes-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\sound-demo.lsp"
+  File "c:\newlisp\guiserver\stroke-demo.lsp"
+  File "c:\newlisp\guiserver\tabs-demo.lsp"
+  File "c:\newlisp\guiserver\table-demo.lsp"
+  File "c:\newlisp\guiserver\textrot-demo.lsp"
+  File "c:\newlisp\guiserver\widgets-demo.lsp"
+  File "c:\newlisp\guiserver\word-count.lsp"
+  File "c:\newlisp\guiserver\uppercase.lsp"
+
+  SetOutPath $INSTDIR\modules
+  File "c:\newlisp\modules\canvas.lsp"
+  File "c:\newlisp\modules\cgi.lsp"
+  File "c:\newlisp\modules\crypto.lsp"
+  File "c:\newlisp\modules\ftp.lsp"
+  File "c:\newlisp\modules\gsl.lsp"
+  File "c:\newlisp\modules\infix.lsp"
+  File "c:\newlisp\modules\mysql.lsp"
+  File "c:\newlisp\modules\odbc.lsp"
+  File "c:\newlisp\modules\plot.lsp"
+  File "c:\newlisp\modules\pop3.lsp"
+  File "c:\newlisp\modules\postgres.lsp"
+  File "c:\newlisp\modules\postscript.lsp"
+  File "c:\newlisp\modules\smtp.lsp"
+  File "c:\newlisp\modules\smtpx.lsp"
+  File "c:\newlisp\modules\sqlite3.lsp"
+  File "c:\newlisp\modules\stat.lsp"
+  File "c:\newlisp\modules\unix.lsp"
+  File "c:\newlisp\modules\xmlrpc-client.lsp" 
+  File "c:\newlisp\modules\zlib.lsp"
+
+  SetOutPath $INSTDIR\util
+  File "c:\newlisp\util\newlispdoc"
+  File "c:\newlisp\util\newlisp.vim"
+  File "c:\newlisp\util\syntax.cgi"
+
+  SetOutPath $INSTDIR
+
+  ; Write the installation path into the registry
+  WriteRegStr HKLM SOFTWARE\newLISP "Install_Dir" "$INSTDIR"
+
+  ; Write envionment variable intor registry
+  WriteRegStr HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "NEWLISPDIR" "$INSTDIR"
+
+  ; Write the uninstall keys for Windows
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "DisplayName" "newLISP (remove only)"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "UninstallString" '"$INSTDIR\uninstall.exe"'
+
+  WriteUninstaller "uninstall.exe"
+  ; make menu in startmenus
+  CreateDirectory "$SMPROGRAMS\newLISP"
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP.lnk" "$INSTDIR\newlisp.exe" "" "$INSTDIR\newlisp.exe" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Release Notes.lnk" "$INSTDIR\newLISP-10.7.0-Release.html" "" "$INSTDIR\newLISP-10.7.0-Release.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Manual and Reference.lnk" "$INSTDIR\manual_frame.html" "" "$INSTDIR\manual_frame.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Code Patterns.lnk" "$INSTDIR\CodePatterns.html" "" "$INSTDIR\CodePatterns.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\GS Manual and Reference.lnk" "$INSTDIR\guiserver\index-gs.html" "" "$INSTDIR\guiserver\index-gs.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Uninstall.lnk" "$INSTDIR\uninstall.exe" "" "$INSTDIR\uninstall.exe" 0
+
+SectionEnd ; end the section
+
+Section "Add to path"
+  Push $INSTDIR
+  Call AddToPath
+SectionEnd
+
+Section "Create desktop shortcut"
+  CreateShortCut "$DESKTOP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+SectionEnd
+
+; uninstall stuff
+UninstallText "This will uninstall newLISP. Hit next to continue."
+
+; special uninstall section.
+Section "Uninstall"
+
+  ; remove registry keys
+  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP"
+  DeleteRegKey HKLM SOFTWARE\newLISP
+
+  ; remove files
+  Delete $INSTDIR\newlisp.exe
+  Delete $INSTDIR\newlisp.dll
+  Delete $INSTDIR\editor.txt
+  Delete $INSTDIR\util\newlispdoc
+  Delete $INSTDIR\util\newlisp.vim
+  Delete $INSTDIR\util\syntax.cgi
+  Delete $INSTDIR\md5-checksums.txt
+  Delete $INSTDIR\newlisp_manual.html
+  Delete $INSTDIR\newlisp_index.html
+  Delete $INSTDIR\manual_frame.html
+  Delete $INSTDIR\CodePatterns.html
+  Delete $INSTDIR\newLISPdoc.html
+  Delete $INSTDIR\newLISP-10.7.0-Release.html
+  Delete $INSTDIR\COPYING
+  Delete $INSTDIR\guiserver.lsp
+  Delete $INSTDIR\guiserver.jar
+  Delete $INSTDIR\newlisp-edit.lsp
+  Delete $INSTDIR\newlisp-win.ico
+
+  Delete $INSTDIR\guiserver\index-gs.html
+  Delete $INSTDIR\guiserver\guiserver.lsp.html
+  Delete $INSTDIR\guiserver\newlispdoc.css
+  Delete $INSTDIR\guiserver\allfonts-demo.lsp
+  Delete $INSTDIR\guiserver\animation-demo.lsp
+  Delete $INSTDIR\guiserver\border-layout-demo.lsp
+  Delete $INSTDIR\guiserver\button-demo.lsp
+  Delete $INSTDIR\guiserver\clipboard-demo.lsp
+  Delete $INSTDIR\guiserver\cursor-demo.lsp
+  Delete $INSTDIR\guiserver\drag-demo.lsp
+  Delete $INSTDIR\guiserver\font-demo.lsp
+  Delete $INSTDIR\guiserver\frameless-demo.lsp
+  Delete $INSTDIR\guiserver\html-demo.lsp
+  Delete $INSTDIR\guiserver\image-demo.lsp
+  Delete $INSTDIR\guiserver\midi-demo.lsp
+  Delete $INSTDIR\guiserver\midi2-demo.lsp
+  Delete $INSTDIR\guiserver\mouse-demo.lsp
+  Delete $INSTDIR\guiserver\move-resize-demo.lsp
+  Delete $INSTDIR\guiserver\pinballs-demo.lsp
+  Delete $INSTDIR\guiserver\properties-demo.lsp
+  Delete $INSTDIR\guiserver\rotation-demo.lsp
+  Delete $INSTDIR\guiserver\shapes-demo.lsp
+  Delete $INSTDIR\guiserver\scroll-pane-demo.lsp
+  Delete $INSTDIR\guiserver\sound-demo.lsp
+  Delete $INSTDIR\guiserver\stroke-demo.lsp
+  Delete $INSTDIR\guiserver\tabs-demo.lsp
+  Delete $INSTDIR\guiserver\table-demo.lsp
+  Delete $INSTDIR\guiserver\textrot-demo.lsp
+  Delete $INSTDIR\guiserver\widgets-demo.lsp
+  Delete $INSTDIR\guiserver\word-count.lsp
+  Delete $INSTDIR\guiserver\uppercase.lsp
+
+  Delete $INSTDIR\modules\canvas.lsp
+  Delete $INSTDIR\modules\cgi.lsp
+  Delete $INSTDIR\modules\crypto.lsp
+  Delete $INSTDIR\modules\ftp.lsp
+  Delete $INSTDIR\modules\gsl.lsp
+  Delete $INSTDIR\modules\infix.lsp
+  Delete $INSTDIR\modules\mysql.lsp
+  Delete $INSTDIR\modules\odbc.lsp
+  Delete $INSTDIR\modules\plot.lsp
+  Delete $INSTDIR\modules\pop3.lsp
+  Delete $INSTDIR\modules\postgres.lsp
+  Delete $INSTDIR\modules\postscript.lsp
+  Delete $INSTDIR\modules\smtp.lsp
+  Delete $INSTDIR\modules\smtpx.lsp
+  Delete $INSTDIR\modules\sqlite3.lsp
+  Delete $INSTDIR\modules\stat.lsp
+  Delete $INSTDIR\modules\unix.lsp
+  Delete $INSTDIR\modules\xmlrpc-client.lsp 
+  Delete $INSTDIR\modules\zlib.lsp
+  ; remove start menu entries
+  Delete "$DESKTOP\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP\*.*"
+  RMDir "$SMPROGRAMS\newLISP"
+
+  ; remove uninstaller, links and install dir
+  Delete $INSTDIR\uninstall.exe
+  RMDir "$INSTDIR\guiserver"
+  RMDir "$INSTDIR\modules"
+  RMDir "$INSTDIR\util"
+  RMDir "$INSTDIR"
+
+  Push $INSTDIR
+  Call un.RemoveFromPath
+
+SectionEnd
+
+; eof
diff --git a/guiserver/newlisp64-gs.nsi.bak b/guiserver/newlisp64-gs.nsi.bak
new file mode 100644
index 0000000..3b64721
--- /dev/null
+++ b/guiserver/newlisp64-gs.nsi.bak
@@ -0,0 +1,481 @@
+; newlisp-gs.nsi
+;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The name of the installer
+Name "newLISP-GS"
+
+; The file to write
+OutFile "c:\WinDev\newlisp\newlisp-10700-win64-gs-164.exe"
+
+; The default installation directory
+InstallDir $PROGRAMFILES\newlisp
+
+; The text to prompt the user to enter a directory
+DirText "This will install newLISP v.10.6.4 and Guiserver 1.64 on your computer. IF NOT INSTALLING IN THE DEFAULT DIRECTORY REBOOT AFTER INSTALL."
+
+;;;;;;; subroutines for PATH change in MS Windows environment ;;;;;;;;;
+!verbose 3
+!include "WinMessages.NSH"
+!verbose 4
+
+; AddToPath - Adds the given dir to the search path.
+;        Input - head of the stack
+;        Note - Win9x systems requires reboot
+
+Function AddToPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+
+  # don't add if the path doesn't exist
+  IfFileExists "$0\*.*" "" AddToPath_done
+
+  ReadEnvStr $1 PATH
+  Push "$1;"
+  Push "$0;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$0\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  GetFullPathName /SHORT $3 $0
+  Push "$1;"
+  Push "$3;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+  Push "$1;"
+  Push "$3\;"
+  Call StrStr
+  Pop $2
+  StrCmp $2 "" "" AddToPath_done
+
+  Call IsNT
+  Pop $1
+  StrCmp $1 1 AddToPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" a
+    FileSeek $1 -1 END
+    FileReadByte $1 $2
+    IntCmp $2 26 0 +2 +2 # DOS EOF
+      FileSeek $1 -1 END # write over EOF
+    FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
+    FileClose $1
+    SetRebootFlag true
+    Goto AddToPath_done
+
+  AddToPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $2 $1 1 -1 # copy last char
+    StrCmp $2 ";" 0 +2 # if last char == ;
+      StrCpy $1 $1 -1 # remove last char
+    StrCmp $1 "" AddToPath_NTdoIt
+      StrCpy $0 "$1;$0"
+    AddToPath_NTdoIt:
+      WriteRegExpandStr HKCU "Environment" "PATH" $0
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  AddToPath_done:
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+; RemoveFromPath - Remove a given dir from the path
+;     Input: head of the stack
+
+Function un.RemoveFromPath
+  Exch $0
+  Push $1
+  Push $2
+  Push $3
+  Push $4
+  Push $5
+  Push $6
+
+  IntFmt $6 "%c" 26 # DOS EOF
+
+  Call un.IsNT
+  Pop $1
+  StrCmp $1 1 unRemoveFromPath_NT
+    ; Not on NT
+    StrCpy $1 $WINDIR 2
+    FileOpen $1 "$1\autoexec.bat" r
+    GetTempFileName $4
+    FileOpen $2 $4 w
+    GetFullPathName /SHORT $0 $0
+    StrCpy $0 "SET PATH=%PATH%;$0"
+    Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoop:
+      FileRead $1 $3
+      StrCpy $5 $3 1 -1 # read last char
+      StrCmp $5 $6 0 +2 # if DOS EOF
+        StrCpy $3 $3 -1 # remove DOS EOF so we can compare
+      StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
+      StrCmp $3 "" unRemoveFromPath_dosLoopEnd
+      FileWrite $2 $3
+      Goto unRemoveFromPath_dosLoop
+      unRemoveFromPath_dosLoopRemoveLine:
+        SetRebootFlag true
+        Goto unRemoveFromPath_dosLoop
+
+    unRemoveFromPath_dosLoopEnd:
+      FileClose $2
+      FileClose $1
+      StrCpy $1 $WINDIR 2
+      Delete "$1\autoexec.bat"
+      CopyFiles /SILENT $4 "$1\autoexec.bat"
+      Delete $4
+      Goto unRemoveFromPath_done
+
+  unRemoveFromPath_NT:
+    ReadRegStr $1 HKCU "Environment" "PATH"
+    StrCpy $5 $1 1 -1 # copy last char
+    StrCmp $5 ";" +2 # if last char != ;
+      StrCpy $1 "$1;" # append ;
+    Push $1
+    Push "$0;"
+    Call un.StrStr ; Find $0; in $1
+    Pop $2 ; pos of our dir
+    StrCmp $2 "" unRemoveFromPath_done
+      ; else, it is in path
+      # $0 - path to add
+      # $1 - path var
+      StrLen $3 "$0;"
+      StrLen $4 $2
+      StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
+      StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
+      StrCpy $3 $5$6
+
+      StrCpy $5 $3 1 -1 # copy last char
+      StrCmp $5 ";" 0 +2 # if last char == ;
+        StrCpy $3 $3 -1 # remove last char
+
+      WriteRegExpandStr HKCU "Environment" "PATH" $3
+      SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
+
+  unRemoveFromPath_done:
+    Pop $6
+    Pop $5
+    Pop $4
+    Pop $3
+    Pop $2
+    Pop $1
+    Pop $0
+FunctionEnd
+
+###########################################
+#            Utility Functions            #
+###########################################
+
+; IsNT
+; no input
+; output, top of the stack = 1 if NT or 0 if not
+;
+; Usage:
+;   Call IsNT
+;   Pop $R0
+;  ($R0 at this point is 1 or 0)
+
+!macro IsNT un
+Function ${un}IsNT
+  Push $0
+  ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
+  StrCmp $0 "" 0 IsNT_yes
+  ; we are not NT.
+  Pop $0
+  Push 0
+  Return
+
+  IsNT_yes:
+    ; NT!!!
+    Pop $0
+    Push 1
+FunctionEnd
+!macroend
+!insertmacro IsNT ""
+!insertmacro IsNT "un."
+
+; StrStr
+; input, top of stack = string to search for
+;        top of stack-1 = string to search in
+; output, top of stack (replaces with the portion of the string remaining)
+; modifies no other variables.
+;
+; Usage:
+;   Push "this is a long ass string"
+;   Push "ass"
+;   Call StrStr
+;   Pop $R0
+;  ($R0 at this point is "ass string")
+
+!macro StrStr un
+Function ${un}StrStr
+Exch $R1 ; st=haystack,old$R1, $R1=needle
+  Exch    ; st=old$R1,haystack
+  Exch $R2 ; st=old$R1,old$R2, $R2=haystack
+  Push $R3
+  Push $R4
+  Push $R5
+  StrLen $R3 $R1
+  StrCpy $R4 0
+  ; $R1=needle
+  ; $R2=haystack
+  ; $R3=len(needle)
+  ; $R4=cnt
+  ; $R5=tmp
+  loop:
+    StrCpy $R5 $R2 $R3 $R4
+    StrCmp $R5 $R1 done
+    StrCmp $R5 "" done
+    IntOp $R4 $R4 + 1
+    Goto loop
+done:
+  StrCpy $R1 $R2 "" $R4
+  Pop $R5
+  Pop $R4
+  Pop $R3
+  Pop $R2
+  Exch $R1
+FunctionEnd
+!macroend
+!insertmacro StrStr ""
+!insertmacro StrStr "un."
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; end subroutines for PATH change ====================
+
+LicenseText License
+LicenseData c:\newlisp\COPYING
+
+ComponentText Select components
+
+ShowInstDetails show
+
+; The stuff to install
+Section "newLISP program (required) and DLL"
+  CreateDirectory $INSTDIR\guiserver
+  CreateDirectory $INSTDIR\modules
+  CreateDirectory $INSTDIR\util
+  ; Set output path to the installation directories.
+  ; sincd 10.3.5 newlisp.dll is back in the newlisp directory
+
+  SetOutPath $INSTDIR
+  File "c:\newlisp\newlisp.exe"
+  File "c:\newlisp\newlisp.dll"  
+  File "c:\newlisp\md5-checksums.txt"
+  File "c:\newlisp\newlisp_manual.html"
+  File "c:\newlisp\newlisp_index.html"
+  File "c:\newlisp\manual_frame.html"
+  File "c:\newlisp\CodePatterns.html"
+  File "c:\newlisp\newLISPdoc.html"
+  File "c:\newlisp\newLISP-10.6.4-Release.html"
+  File "c:\newlisp\COPYING"
+  File "c:\newlisp\guiserver.lsp"
+  File "c:\newlisp\guiserver.jar"
+  File "c:\newlisp\newlisp-edit.lsp"
+  File "c:\newlisp\newlisp-win.ico"
+
+  SetOutPath $INSTDIR\guiserver
+  File "c:\newlisp\guiserver\index-gs.html"
+  File "c:\newlisp\guiserver\guiserver.lsp.html"
+  File "c:\newlisp\guiserver\newlispdoc.css"
+  File "c:\newlisp\guiserver\allfonts-demo.lsp"
+  File "c:\newlisp\guiserver\animation-demo.lsp"
+  File "c:\newlisp\guiserver\border-layout-demo.lsp"
+  File "c:\newlisp\guiserver\button-demo.lsp"
+  File "c:\newlisp\guiserver\clipboard-demo.lsp"
+  File "c:\newlisp\guiserver\cursor-demo.lsp"
+  File "c:\newlisp\guiserver\drag-demo.lsp"
+  File "c:\newlisp\guiserver\font-demo.lsp"
+  File "c:\newlisp\guiserver\frameless-demo.lsp"
+  File "c:\newlisp\guiserver\html-demo.lsp"
+  File "c:\newlisp\guiserver\image-demo.lsp"
+  File "c:\newlisp\guiserver\midi-demo.lsp"
+  File "c:\newlisp\guiserver\midi2-demo.lsp"
+  File "c:\newlisp\guiserver\mouse-demo.lsp"
+  File "c:\newlisp\guiserver\move-resize-demo.lsp"
+  File "c:\newlisp\guiserver\pinballs-demo.lsp"
+  File "c:\newlisp\guiserver\properties-demo.lsp"
+  File "c:\newlisp\guiserver\rotation-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\shapes-demo.lsp"
+  File "c:\newlisp\guiserver\scroll-pane-demo.lsp"
+  File "c:\newlisp\guiserver\sound-demo.lsp"
+  File "c:\newlisp\guiserver\stroke-demo.lsp"
+  File "c:\newlisp\guiserver\tabs-demo.lsp"
+  File "c:\newlisp\guiserver\table-demo.lsp"
+  File "c:\newlisp\guiserver\textrot-demo.lsp"
+  File "c:\newlisp\guiserver\widgets-demo.lsp"
+  File "c:\newlisp\guiserver\word-count.lsp"
+  File "c:\newlisp\guiserver\uppercase.lsp"
+
+  SetOutPath $INSTDIR\modules
+  File "c:\newlisp\modules\canvas.lsp"
+  File "c:\newlisp\modules\cgi.lsp"
+  File "c:\newlisp\modules\crypto.lsp"
+  File "c:\newlisp\modules\ftp.lsp"
+  File "c:\newlisp\modules\gsl.lsp"
+  File "c:\newlisp\modules\infix.lsp"
+  File "c:\newlisp\modules\mysql.lsp"
+  File "c:\newlisp\modules\odbc.lsp"
+  File "c:\newlisp\modules\plot.lsp"
+  File "c:\newlisp\modules\pop3.lsp"
+  File "c:\newlisp\modules\postgres.lsp"
+  File "c:\newlisp\modules\postscript.lsp"
+  File "c:\newlisp\modules\smtp.lsp"
+  File "c:\newlisp\modules\smtpx.lsp"
+  File "c:\newlisp\modules\sqlite3.lsp"
+  File "c:\newlisp\modules\stat.lsp"
+  File "c:\newlisp\modules\unix.lsp"
+  File "c:\newlisp\modules\xmlrpc-client.lsp" 
+  File "c:\newlisp\modules\zlib.lsp"
+
+  SetOutPath $INSTDIR\util
+  File "c:\newlisp\util\newlispdoc"
+  File "c:\newlisp\util\newlisp.vim"
+  File "c:\newlisp\util\syntax.cgi"
+
+  SetOutPath $INSTDIR
+
+  ; Write the installation path into the registry
+  WriteRegStr HKLM SOFTWARE\newLISP "Install_Dir" "$INSTDIR"
+
+  ; Write envionment variable intor registry
+  WriteRegStr HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment" "NEWLISPDIR" "$INSTDIR"
+
+  ; Write the uninstall keys for Windows
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "DisplayName" "newLISP (remove only)"
+  WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP" "UninstallString" '"$INSTDIR\uninstall.exe"'
+
+  WriteUninstaller "uninstall.exe"
+  ; make menu in startmenus
+  CreateDirectory "$SMPROGRAMS\newLISP"
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP.lnk" "$INSTDIR\newlisp.exe" "" "$INSTDIR\newlisp.exe" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Release Notes.lnk" "$INSTDIR\newLISP-10.6.4-Release.html" "" "$INSTDIR\newLISP-10.6.4-Release.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Manual and Reference.lnk" "$INSTDIR\manual_frame.html" "" "$INSTDIR\manual_frame.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Code Patterns.lnk" "$INSTDIR\CodePatterns.html" "" "$INSTDIR\CodePatterns.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\GS Manual and Reference.lnk" "$INSTDIR\guiserver\index-gs.html" "" "$INSTDIR\guiserver\index-gs.html" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+  CreateShortCut "$SMPROGRAMS\newLISP\Uninstall.lnk" "$INSTDIR\uninstall.exe" "" "$INSTDIR\uninstall.exe" 0
+
+SectionEnd ; end the section
+
+Section "Add to path"
+  Push $INSTDIR
+  Call AddToPath
+SectionEnd
+
+Section "Create desktop shortcut"
+  CreateShortCut "$DESKTOP\newLISP-GS.lnk" "$INSTDIR\guiserver.jar" "64001 newlisp-edit.lsp /local/newLISPsplash.png" "$INSTDIR\newlisp-win.ico" 0
+SectionEnd
+
+; uninstall stuff
+UninstallText "This will uninstall newLISP. Hit next to continue."
+
+; special uninstall section.
+Section "Uninstall"
+
+  ; remove registry keys
+  DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\newLISP"
+  DeleteRegKey HKLM SOFTWARE\newLISP
+
+  ; remove files
+  Delete $INSTDIR\newlisp.exe
+  Delete $INSTDIR\newlisp.dll
+  Delete $INSTDIR\editor.txt
+  Delete $INSTDIR\util\newlispdoc
+  Delete $INSTDIR\util\newlisp.vim
+  Delete $INSTDIR\util\syntax.cgi
+  Delete $INSTDIR\md5-checksums.txt
+  Delete $INSTDIR\newlisp_manual.html
+  Delete $INSTDIR\newlisp_index.html
+  Delete $INSTDIR\manual_frame.html
+  Delete $INSTDIR\CodePatterns.html
+  Delete $INSTDIR\newLISPdoc.html
+  Delete $INSTDIR\newLISP-10.6.4-Release.html
+  Delete $INSTDIR\COPYING
+  Delete $INSTDIR\guiserver.lsp
+  Delete $INSTDIR\guiserver.jar
+  Delete $INSTDIR\newlisp-edit.lsp
+  Delete $INSTDIR\newlisp-win.ico
+
+  Delete $INSTDIR\guiserver\index-gs.html
+  Delete $INSTDIR\guiserver\guiserver.lsp.html
+  Delete $INSTDIR\guiserver\newlispdoc.css
+  Delete $INSTDIR\guiserver\allfonts-demo.lsp
+  Delete $INSTDIR\guiserver\animation-demo.lsp
+  Delete $INSTDIR\guiserver\border-layout-demo.lsp
+  Delete $INSTDIR\guiserver\button-demo.lsp
+  Delete $INSTDIR\guiserver\clipboard-demo.lsp
+  Delete $INSTDIR\guiserver\cursor-demo.lsp
+  Delete $INSTDIR\guiserver\drag-demo.lsp
+  Delete $INSTDIR\guiserver\font-demo.lsp
+  Delete $INSTDIR\guiserver\frameless-demo.lsp
+  Delete $INSTDIR\guiserver\html-demo.lsp
+  Delete $INSTDIR\guiserver\image-demo.lsp
+  Delete $INSTDIR\guiserver\midi-demo.lsp
+  Delete $INSTDIR\guiserver\midi2-demo.lsp
+  Delete $INSTDIR\guiserver\mouse-demo.lsp
+  Delete $INSTDIR\guiserver\move-resize-demo.lsp
+  Delete $INSTDIR\guiserver\pinballs-demo.lsp
+  Delete $INSTDIR\guiserver\properties-demo.lsp
+  Delete $INSTDIR\guiserver\rotation-demo.lsp
+  Delete $INSTDIR\guiserver\shapes-demo.lsp
+  Delete $INSTDIR\guiserver\scroll-pane-demo.lsp
+  Delete $INSTDIR\guiserver\sound-demo.lsp
+  Delete $INSTDIR\guiserver\stroke-demo.lsp
+  Delete $INSTDIR\guiserver\tabs-demo.lsp
+  Delete $INSTDIR\guiserver\table-demo.lsp
+  Delete $INSTDIR\guiserver\textrot-demo.lsp
+  Delete $INSTDIR\guiserver\widgets-demo.lsp
+  Delete $INSTDIR\guiserver\word-count.lsp
+  Delete $INSTDIR\guiserver\uppercase.lsp
+
+  Delete $INSTDIR\modules\canvas.lsp
+  Delete $INSTDIR\modules\cgi.lsp
+  Delete $INSTDIR\modules\crypto.lsp
+  Delete $INSTDIR\modules\ftp.lsp
+  Delete $INSTDIR\modules\gsl.lsp
+  Delete $INSTDIR\modules\infix.lsp
+  Delete $INSTDIR\modules\mysql.lsp
+  Delete $INSTDIR\modules\odbc.lsp
+  Delete $INSTDIR\modules\plot.lsp
+  Delete $INSTDIR\modules\pop3.lsp
+  Delete $INSTDIR\modules\postgres.lsp
+  Delete $INSTDIR\modules\postscript.lsp
+  Delete $INSTDIR\modules\smtp.lsp
+  Delete $INSTDIR\modules\smtpx.lsp
+  Delete $INSTDIR\modules\sqlite3.lsp
+  Delete $INSTDIR\modules\stat.lsp
+  Delete $INSTDIR\modules\unix.lsp
+  Delete $INSTDIR\modules\xmlrpc-client.lsp 
+  Delete $INSTDIR\modules\zlib.lsp
+  ; remove start menu entries
+  Delete "$DESKTOP\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP-GS.lnk"
+  Delete "$SMPROGRAMS\newLISP\*.*"
+  RMDir "$SMPROGRAMS\newLISP"
+
+  ; remove uninstaller, links and install dir
+  Delete $INSTDIR\uninstall.exe
+  RMDir "$INSTDIR\guiserver"
+  RMDir "$INSTDIR\modules"
+  RMDir "$INSTDIR\util"
+  RMDir "$INSTDIR"
+
+  Push $INSTDIR
+  Call un.RemoveFromPath
+
+SectionEnd
+
+; eof
diff --git a/guiserver/newlispdoc.css b/guiserver/newlispdoc.css
new file mode 100644
index 0000000..a4a71d0
--- /dev/null
+++ b/guiserver/newlispdoc.css
@@ -0,0 +1,28 @@
+<!-- this file should reside in the same directory, where HTML
+     files generated with newlispdoc reside -->
+
+span.arw {
+	color:#666666;
+	font-size: 100%;
+	}
+	
+body, p {
+	font-family: Georgia, Times New Roman, Times, serif;
+	line-height: 115%;
+ 	}
+
+h1, h2, h3, h4 {
+	font-family: Georgia, Times New Roman, Times, serif;
+   	font-size: 110%;
+	}
+
+pre {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+   	font-size: 100%;
+	}
+
+tt {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+	font-size: 100%;
+	}
+
diff --git a/guiserver/pinballs-demo.lsp b/guiserver/pinballs-demo.lsp
new file mode 100644
index 0000000..238ad21
--- /dev/null
+++ b/guiserver/pinballs-demo.lsp
@@ -0,0 +1,117 @@
+#!/usr/local/bin/newlisp
+;; pinballs-demo.lsp - demos animations and gs:check-event function
+
+;; GS 1.05+
+;; v0.3 replaced deprecated set-assoc with (setf (assoc ...) ...) 
+;; v0.4 changes for 10.0 in 'inc'
+;;
+;; PinBalls, Cormullion wanted collision, Cormullion got collision ;-)
+;;
+;;
+;; There are different ways to detect collisions with figures, here is an
+;; example that uses a circle.
+;;
+;; In the current GS there is not x,y tag detection nor the option to draw
+;; a circle using floats. So you have to be inventive ;-)
+;;
+;; This example uses gs:draw-circle and stores a imagionary boundry in BOUNDS
+;; per circle/BALL. These are the collision boundry's.
+;;
+;; The calculation is done on the edge of the BALL calls CIRCLE-DOTS. The
+;; more CIRCLE-DOTS the more detection. The more BALLS's the more calculations.
+;;
+;; you can change the quoted line in the code that draws its own circle!
+;; if you use that you will see that GS is unable to do floats because the
+;; BALL looks a little eaten. (takes more performance too!)
+;;
+;; Change the RADIUS to change to size of the BALL.
+;;
+;; BALL collision is done in 4 quadrants, this is easier then calculate them
+;; on every 360 dgr. Here we take a default of 4 x 4 for speed angle.
+;;
+;; behaviour can change per system, if you run GS with your webbrowser open
+;; (that uses JAVA or flash) you could notice stottering of the applet.
+;;
+;; Enjoy, Norman. (c) 2007
+;; (some changes for addition to demos by L.M.)
+
+(set-locale "C")
+(seed ((now) 6))
+(load (append (env "NEWLISPDIR") "/guiserver.lsp"))
+
+(gs:init)
+(gs:get-screen)
+(set 'ww 600 'wh 600 'sw (gs:screen 0) 'sh (gs:screen 1))
+(gs:frame 'F  (- (div sw 2) (div ww 2)) (- (div sh 2) (div wh 2)) ww (+ wh 20) "PinBalls")
+(gs:canvas 'C)
+(gs:set-resizable 'F nil)
+(gs:set-font 'C "Monospaced" 8 "bold")
+(gs:set-background 'C gs:black) 
+(gs:add-to 'F 'C)
+(gs:set-visible 'F true)
+
+;; set variables
+(set 'RADIUS 40 'CIRCLE-DOTS 256 'BALLS 8)
+(define (rcolor) (list (random) (random) (random)))
+(gs:set-stroke 3)
+
+;; updates the current circle bounds
+(define (update-circle c x y, r)
+(set (sym c) '())
+ (dotimes (r CIRCLE-DOTS)
+  (push (list (+ x (mul RADIUS (cos r))) (+ y (mul RADIUS (sin r)))) (eval (sym c)) -1))
+   (push (eval (sym c)) BOUNDS -1))
+
+;; needs to draws my own circle
+(dotimes (t BALLS)
+(set 'x (+ RADIUS (rand 400)) 'y (+ RADIUS (rand 400)))
+ (update-circle (string "O" t) x y)
+    (gs:draw-circle (string "C" t) x y RADIUS (rcolor))
+    (gs:draw-circle (string "C" t) x y ( - RADIUS 5) (rcolor))
+    (gs:draw-text (string "C" t) (string t) (- x 1) y gs:white)
+    (push (list (string "C" t) x y 0 3 (string "O" t)) CIRCLE -1))
+
+;; define pseudo hit-angle action
+(set 'M '(-3 -2 -1) 'P (map abs M))
+(define (flip) (apply amb (append M P)))
+(define (flap) (apply amb M))
+(define (flop) (apply amb P))
+
+(while (gs:check-event 10) ; timeout is small, because no events are expected
+	(dolist (L CIRCLE) 
+		(set 'tx (L 1))
+		(set 'ty (L 2))
+		(set  'X (L 3))
+		(set  'Y (L 4))
+		(set  'B (BOUNDS 0))
+
+		;; check wall bounds
+		(and (>= tx (- ww  RADIUS )) (set 'X (flap) 'Y (flip)) )
+		(and (<= tx        RADIUS )  (set 'X (flop) 'Y (flip)) )
+		(and (>= ty (- wh  RADIUS )) (set 'X (flip) 'Y (flap)) )
+		(and (<= ty        RADIUS )  (set 'X (flip) 'Y (flop)) )    
+
+		;; with every movement update the circle boundary
+		(pop BOUNDS)
+
+		(dolist (BB BOUNDS) 
+	  	(and (intersect B BB)
+				(or (and (<= ((BB 0) 0) tx) (<= ((BB 0) 1) ty) (set 'X  4 'Y  4 ))
+					(and (>= ((BB 0) 0) tx) (<= ((BB 0) 1) ty) (set 'X -4 'Y  4 ))
+					(and (<= ((BB 0) 0) tx) (>= ((BB 0) 1) ty) (set 'X  4 'Y -4 ))
+					(and (>= ((BB 0) 0) tx) (>= ((BB 0) 1) ty) (set 'X -4 'Y -4 ))
+				)
+			)
+		)
+	
+		(gs:move-tag (L 0) X Y 0 nil)
+		(update-circle (L 5) tx ty)		
+
+		;; update the "per" CIRCLE data	
+		(setf (assoc (L 0) CIRCLE) (list (L 0) (inc tx X) (inc ty Y) X Y (L 5)))
+	)
+	(gs:update)
+)
+
+(exit)
+
diff --git a/guiserver/properties-demo.lsp b/guiserver/properties-demo.lsp
new file mode 100644
index 0000000..8c97bbb
--- /dev/null
+++ b/guiserver/properties-demo.lsp
@@ -0,0 +1,33 @@
+#!/usr/local/bin/newlisp
+;;
+;; property-demo.lsp - demonstrate gs:get-screen and gs:get-version
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;;;; describe the GUI
+
+(gs:get-screen)
+(set 'x (/ (- (gs:screen 0) 450) 2))
+(set 'y (/ (- (gs:screen 1) 400) 2))
+
+(gs:frame 'PropertyDemo x y 450 400 "Properties")
+(gs:text-area 'Output 'gs:no-action')
+(gs:set-editable 'Output nil)
+(gs:add-to 'PropertyDemo 'Output) 
+(gs:set-visible 'PropertyDemo true)
+
+(gs:set-text 'Output (join (map string (gs:get-fonts)) "\n"))
+(gs:set-text 'PropertyDemo 
+	(string "GUI-server v." (gs:get-version) 
+			" screen: " (gs:screen 0) "x" (gs:screen 1)
+			", " (gs:screen 2) " dots/inch"))
+
+;;;; listen for incoming action requests and dispatch
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/rotation-demo.lsp b/guiserver/rotation-demo.lsp
new file mode 100644
index 0000000..7a04945
--- /dev/null
+++ b/guiserver/rotation-demo.lsp
@@ -0,0 +1,66 @@
+#!/usr/local/bin/newlisp
+;;
+;; rotationn-demo.lsp - demonstrate gs:rotate-tag, gs:translate-tag and  gs:scale-tag
+;; and the mouse-wheel rotating an object
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'RotationDemo  100 100 600 600 "Image demo")
+(gs:set-border-layout 'RotationDemo)
+;(gs:set-resizable 'RotationDemo nil)
+(gs:canvas 'MyCanvas)
+(gs:set-background 'MyCanvas gs:white)
+(gs:panel 'Select)
+(gs:radio-button 'ZoomButton 'zoom-action "zoom")
+(gs:radio-button 'TurnButton 'turn-action "turn")
+(gs:set-selected 'TurnButton true)
+(set 'turn-flag true)
+(gs:add-to 'Select 'ZoomButton 'TurnButton)
+(gs:add-to 'RotationDemo 'MyCanvas "center" 'Select "south")
+(gs:mouse-wheel 'MyCanvas 'mouse-wheel-action)
+
+;(gs:set-scale 0.5 0.5) ; only for testing
+
+(gs:set-font 'MyCanvas "Lucida Sans Oblique" 14 "plain")
+(gs:draw-text 'T "turn mouse wheel to turn or zoom image" 20 50 gs:darkGray)
+(gs:fill-circle 'C 0 0 50 gs:red)
+(gs:fill-circle 'C -40 -40 30 gs:black)
+(gs:fill-circle 'C 40 -40 30 gs:black)
+(gs:fill-circle 'C 0 10 8 gs:yellow)
+(gs:translate-tag 'C 300 300)
+
+(gs:set-visible 'RotationDemo true)
+
+;; actions
+
+(define (zoom-action id flag)
+	(gs:set-selected 'TurnButton (not flag))
+	(set 'turn-flag (not flag))
+)
+
+(define (turn-action id flag)
+	(gs:set-selected 'ZoomButton (not flag))
+	(set 'turn-flag flag)
+)
+
+(define (mouse-wheel-action x y wheel)
+	(if turn-flag
+		(gs:rotate-tag 'C wheel 0 0)
+		(if (< wheel 0)
+				(gs:scale-tag 'C 0.9 0.9)
+				(gs:scale-tag 'C 1.1 1.1)
+		)
+	)
+)
+
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/scroll-pane-demo.lsp b/guiserver/scroll-pane-demo.lsp
new file mode 100644
index 0000000..b9384f3
--- /dev/null
+++ b/guiserver/scroll-pane-demo.lsp
@@ -0,0 +1,55 @@
+; Demo to show three extra parameters in gs:scroll-pane 
+; you can add three extra components, first is used as column header,
+; second as row header, third as componenet in upper left corner
+
+
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+(gs:init)
+
+(gs:table 'col-table 'gs:no-action "Col Header 1" "Col Header 2" "Col Header 3")
+(gs:table-add-row 'col-table '("newLisp" "Java" "Assembler"))
+(gs:table-add-row 'col-table '("fun!" "work" "...")) 
+(gs:set-size 'col-table 500 50)
+
+(gs:table 'row-table 'gs:no-action "N" "char+65")
+(dotimes (row 40) 
+	(gs:table-add-row 'row-table (string row) (char (+ row 65))))
+(gs:set-size 'row-table 200 540)
+
+(gs:table 'data-table 'gs:no-action "N/10" "Sinus" "Cosinus")
+(dotimes (row 40) 
+	(gs:table-add-row 'data-table (string (div row 10)) (string (sin row)) (string (cos row))))
+(gs:set-size 'data-table 500 540)
+
+(gs:canvas 'Canvas)
+(gs:set-background 'Canvas 0.98 0.98 .98)
+(gs:button 'Hide 'Hide-action "Hide Headers" 120 18)
+(gs:button 'Show 'Show-action "Show Headers" 120 18)
+(gs:add-to 'Canvas 'Hide  'Show)
+
+;new parameters for scroll-pane
+(gs:scroll-pane 'scroll 'data-table 500 350 'col-table 'row-table 'Canvas)
+
+(gs:frame 'Frame 100 100 500 350 "Scroll Pane Demo")
+(gs:set-border-layout 'Frame)
+(gs:add-to 'Frame 'scroll "center")
+(gs:set-visible 'Frame true)
+
+(define (Hide-action)
+	(gs:table-set-column-name 'row-table "" "")
+	(gs:table-set-column-name 'col-table "" "" "")
+	(gs:table-set-column-name 'data-table "" "" "")
+)
+
+(define (Show-action)
+	(gs:table-set-column-name 'row-table "Row Header 1" "Row Header 2")
+	(gs:table-set-column-name 'col-table "Col Header 1" "Col Header 2" "Col Header 3")
+	(gs:table-set-column-name 'data-table "Data Header 1" "Data Header 2" "Data Header 3")
+)
+
+(gs:listen)
+(exit)
+
+ 
+
+
diff --git a/guiserver/shapes-demo.lsp b/guiserver/shapes-demo.lsp
new file mode 100644
index 0000000..66678e7
--- /dev/null
+++ b/guiserver/shapes-demo.lsp
@@ -0,0 +1,125 @@
+#!/usr/local/bin/newlisp
+;;
+;; shapes-demo.lsp - demonstrate different lines, outlines and shapes
+;; v.1.0
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+;; subroutines for random shapes
+
+(define (random-draw-line)
+	(gs:draw-line 'L (rand 640) (rand 640) (rand 640) (rand 640) (list (random) (random) (random))))
+
+(define (random-draw-rect)
+	(gs:draw-rect 'R (rand 640) (rand 640) (rand 100) (rand 100) (list (random) (random) (random))))
+
+(define (random-fill-rect)
+	(gs:fill-rect 'R (rand 640) (rand 640) (rand 100) (rand 100) (list (random) (random) (random))))
+
+(define (random-draw-round-rect)
+	(gs:draw-round-rect 'R (rand 640) (rand 640) (rand 100) (rand 100) 
+			(rand 40) (rand 40) (list (random) (random) (random))))
+
+(define (random-fill-round-rect)
+	(gs:fill-round-rect 'R (rand 640) (rand 640) (rand 100) (rand 100) 
+			(rand 40) (rand 40) (list (random) (random) (random))))
+
+(define (random-draw-circle)
+	(gs:draw-circle 'C (rand 640) (rand 640) (rand 100)  (list (random) (random) (random))))
+
+(define (random-fill-circle)
+	(gs:fill-circle 'C (rand 640) (rand 640) (rand 100)  (list (random) (random) (random))))
+
+(define (random-draw-ellipse)
+	(gs:draw-ellipse 'E (rand 640) (rand 640) (rand 100)  (rand 100) (list (random) (random) (random))))
+
+(define (random-fill-ellipse)
+	(gs:fill-ellipse 'E (rand 640) (rand 640) (rand 100)  (rand 100) (list (random) (random) (random))))
+
+(define (random-draw-arc)
+	(gs:draw-arc 'A (rand 640) (rand 640) (rand 100) (rand 100) (rand 360) (rand 360) (list (random) (random) (random))))
+
+(define (random-fill-arc)
+	(gs:fill-arc 'A (rand 640) (rand 640) (rand 100) (rand 100) (rand 360) (rand 360) (list (random) (random) (random))))
+
+(gs:init) 
+;(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'ShapesDemo 100 100 640 640 "Random lines, rectangles, circles, ellipses and arcs Demo")
+(gs:set-border-layout 'ShapesDemo)
+(gs:canvas 'MyCanvas 'ShapesDemo)
+(gs:panel 'Selection)
+(gs:label 'HelpText "show or hide shapes:")
+(gs:check-box 'LineSelect 'select-action "lines") 
+(gs:check-box 'RectangleSelect 'select-action "rectangles") 
+(gs:check-box 'CircleSelect 'select-action "circles") 
+(gs:check-box 'EllipseSelect 'select-action "ellipse") 
+(gs:check-box 'ArcSelect 'select-action "arcs") 
+(gs:set-selected 'LineSelect true 'RectangleSelect true 'CircleSelect true 'EllipseSelect true 'ArcSelect true)
+(gs:add-to 'Selection 'HelpText 'LineSelect 'RectangleSelect 'CircleSelect 'EllipseSelect 'ArcSelect)
+(gs:add-to 'ShapesDemo 'MyCanvas "center" 'Selection "south")
+(gs:set-background 'MyCanvas gs:white)
+
+; default color if not specified in shape or text
+(gs:set-paint gs:darkGray) 
+
+;(gs:set-translation 100 100) ;only for test, will shift everything
+;(gs:set-scale 0.5 0.5) ; only for testing scrinks or zooms
+;(gs:set-rotation 10) ; only for testing tilts by 10 degree
+
+(set 'N 20)
+
+(set 'N-shapes (* N 11))
+
+(set 'start (time-of-day))
+(dotimes (i N)
+	(random-draw-line)
+	(random-draw-rect)
+	(random-fill-rect)
+	(random-draw-round-rect)
+	(random-fill-round-rect)
+	(random-draw-circle)
+	(random-fill-circle)
+	(random-draw-ellipse)
+	(random-fill-ellipse)
+	(random-draw-arc)
+	(random-fill-arc)
+)
+
+(println N-shapes " shapes " (div (- (time-of-day) start) N-shapes) "ms per shape")
+
+(gs:set-font 'MyCanvas "Lucida Sans Regular" 40 "italic")
+(gs:draw-text 'T "Random"  60 100)
+(gs:set-font 'MyCanvas "Monospaced" 40 "plain")
+(gs:draw-text 'T "Shapes and Outlines"  60 160 gs:green -15)
+;(gs:draw-text 'T "Third text line"  60 220) ; only for testing
+
+(gs:set-visible 'ShapesDemo true)
+
+;; action handler
+
+(define (select-action id flag)
+	(let (tag (case id
+			("MAIN:LineSelect" 'L)
+			("MAIN:RectangleSelect" 'R)
+			("MAIN:CircleSelect" 'C)
+			("MAIN:EllipseSelect" 'E)
+			("MAIN:ArcSelect" 'A)))
+		(if flag 
+			(gs:show-tag tag) 
+			(gs:hide-tag tag))
+	)
+)
+
+(gs:add-to 'Selection 'HelpText 'LineSelect 'RectangleSelect 'CircleSelect 'EllipseSelect 'ArcSelect)
+;;;; listen for incoming action requests and dispatch
+
+;(gs:export "shapes.png") ; just for testing
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/sound-demo.lsp b/guiserver/sound-demo.lsp
new file mode 100644
index 0000000..9e0615c
--- /dev/null
+++ b/guiserver/sound-demo.lsp
@@ -0,0 +1,35 @@
+#!/usr/local/bin/newlisp
+;;
+; button-demo.lsp - demonstrate the button control
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+
+(constant (global 'home-dir) (or (env "HOME") (env "USERPROFILE") (env "DOCUMENT_ROOT") ""))
+
+;;;; describe the GUI
+(gs:frame 'SoundDemo 100 100 200 100 "Sound Demo")
+(gs:set-flow-layout 'SoundDemo "center" 20 20)
+(gs:button 'aSound 'button-action "Choose Sound File")
+(gs:add-to 'SoundDemo 'aSound)
+(gs:set-visible 'SoundDemo true)
+
+;;;; define actions
+(define (button-action)
+	(gs:open-file-dialog 'SoundDemo 'openfile-action  home-dir
+		".aif .wav" "Sound files .wav and .aif")
+)
+
+(define (openfile-action id  op file)
+	(if file (gs:play-sound (base64-dec file)))
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/stroke-demo.lsp b/guiserver/stroke-demo.lsp
new file mode 100644
index 0000000..8b3d81c
--- /dev/null
+++ b/guiserver/stroke-demo.lsp
@@ -0,0 +1,100 @@
+#!/usr/local/bin/newlisp
+;;
+;; strokes-demo.lsp - demonstrate strokes with round endings in different lines and outlines
+;; v. 1.0
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+;; subroutines for random shapes
+
+
+(define (random-draw-line)
+	(gs:draw-line 'L (rand 640) (rand 640) (rand 640) (rand 640) (list (random) (random) (random))))
+
+(define (random-draw-rect)
+	(gs:draw-rect 'R (rand 640) (rand 640) (rand 100) (rand 100) (list (random) (random) (random))))
+
+(define (random-draw-round-rect)
+	(gs:draw-round-rect 'R (rand 640) (rand 640) (rand 100) (rand 100) 
+			(rand 40) (rand 40) (list (random) (random) (random))))
+
+(define (random-draw-circle)
+	(gs:draw-circle 'C (rand 640) (rand 640) (rand 100)  (list (random) (random) (random))))
+
+(define (random-draw-ellipse)
+	(gs:draw-ellipse 'E (rand 640) (rand 640) (rand 100)  (rand 100) (list (random) (random) (random))))
+
+(define (random-draw-arc)
+	(gs:draw-arc 'A (rand 640) (rand 640) (rand 100) (rand 100) (rand 360) (rand 360) (list (random) (random) (random))))
+
+(gs:init) 
+;(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'StrokesDemo 100 100 640 640 "Random lines, rectangles, circles, ellipses and arcs Demo")
+(gs:set-border-layout 'StrokesDemo)
+(gs:canvas 'MyCanvas 'StrokesDemo)
+(gs:panel 'Selection)
+(gs:label 'HelpText "show or hide shapes:")
+(gs:check-box 'LineSelect 'select-action "lines") 
+(gs:check-box 'RectangleSelect 'select-action "rectangles") 
+(gs:check-box 'CircleSelect 'select-action "circles") 
+(gs:check-box 'EllipseSelect 'select-action "ellipse") 
+(gs:check-box 'ArcSelect 'select-action "arcs") 
+(gs:set-selected 'LineSelect true 'RectangleSelect true 'CircleSelect true 'EllipseSelect true 'ArcSelect true)
+(gs:add-to 'Selection 'HelpText 'LineSelect 'RectangleSelect 'CircleSelect 'EllipseSelect 'ArcSelect)
+(gs:add-to 'StrokesDemo 'MyCanvas "center" 'Selection "south")
+(gs:set-background 'MyCanvas gs:white)
+
+; default color if not specified in shape or text
+(gs:set-paint gs:darkGray) 
+
+;(gs:set-translation 100 100) ;only for test, will shift everything
+;(gs:set-scale 0.5 0.5) ; only for testing scrinks or zooms
+
+(println (time-of-day))
+(dotimes (i 25)
+	(gs:set-stroke (rand 16) "round")
+	(random-draw-line)
+	(random-draw-rect)
+	(random-draw-round-rect)
+	(random-draw-circle)
+	(random-draw-ellipse)
+	(random-draw-arc)
+)
+(println (time-of-day))
+
+(gs:set-font 'MyCanvas "Lucida Sans Regular" 40 "italic")
+(gs:draw-text 'T "Random"  60 100)
+(gs:set-font 'MyCanvas "Monospaced" 40 "plain")
+(gs:draw-text 'T "Outlines and strokes"  60 160 gs:green -15)
+;(gs:draw-text 'T "Third text line"  60 220) ; only for testing
+
+(gs:set-visible 'StrokesDemo true)
+
+;; action handler
+
+(define (select-action id flag)
+	(let (tag (case id
+			("MAIN:LineSelect" 'L)
+			("MAIN:RectangleSelect" 'R)
+			("MAIN:CircleSelect" 'C)
+			("MAIN:EllipseSelect" 'E)
+			("MAIN:ArcSelect" 'A)))
+		(if flag 
+			(gs:show-tag tag) 
+			(gs:hide-tag tag))
+	)
+)
+
+(gs:add-to 'Selection 'HelpText 'LineSelect 'RectangleSelect 'CircleSelect 'EllipseSelect 'ArcSelect)
+;;;; listen for incoming action requests and dispatch
+
+;(gs:export "shapes.png") ; just for testing
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/table-demo.lsp b/guiserver/table-demo.lsp
new file mode 100644
index 0000000..e7e0078
--- /dev/null
+++ b/guiserver/table-demo.lsp
@@ -0,0 +1,97 @@
+#!/usr/local/bin/newlisp
+
+; table-demo.lsp - demo of the table UI
+
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+; initialization
+(gs:init)
+;(gs:set-trace true)
+
+; the main window frame
+(gs:frame 'Frame 100 100 400 500 "Table")
+(gs:set-grid-layout 'Frame 2 1 10 5)
+
+; the table 
+(gs:table 'Table 'action-handler "col1")
+(gs:table-add-column 'Table "col2")
+(gs:table-set-column 'Table 1 80 "right")
+
+(gs:table-add-row 'Table "r0 c0" "r0 c1")
+(gs:table-add-row 'Table "r1 c0" "r1 c1")
+(gs:table-add-row 'Table "0" "1")
+
+; buttons, cell contents, text area
+(gs:panel 'ButtonPanel)
+(gs:check-box 'rowNumber 'rownumber-action "row number")
+(gs:button 'addRow 'addrow-action "add row")
+(gs:button 'addCol 'addcol-action "add column")
+(gs:button 'deleteRow 'deleterow-action "delete row 0")
+(gs:button 'setCol 'delcol-action "set 3 columns")
+(gs:button 'setRows 'setrows-action "10 rows")
+(gs:text-field 'cellContents 'null-action 18)
+(gs:set-editable 'cellContents nil)
+(gs:add-to 'ButtonPanel 'rowNumber 'addRow 'addCol 'deleteRow 'setCol 'setRows 'cellContents)
+
+(gs:text-area 'textArea 'null-action)
+(gs:set-editable 'textArea nil)
+
+(gs:panel 'Panel)
+(gs:set-grid-layout 'Panel 2 1 10 5)
+(gs:add-to 'Panel 'ButtonPanel 'textArea)
+
+(gs:add-to 'Frame 'Table 'Panel)
+(gs:set-visible 'Frame true)
+
+
+(define (report-table-data id)
+    (gs:table-get id)
+	(gs:table-get-size id)
+	(gs:set-text 'textArea (string "Table size(row,col) = " gs:table-size "\n"))
+	(gs:append-text 'textArea (string "Table Value = " gs:table-full))
+)
+
+(define (action-handler id row col data)
+	;(println "action-handler=>" id " " row " " col " " data)
+    (gs:set-text 'cellContents data)
+	(report-table-data id)
+)
+
+(define (addrow-action id)
+	(gs:table-add-row 'Table)
+	(report-table-data 'Table)
+)
+
+(define (deleterow-action id)
+	(gs:table-remove-row 'Table 0)
+	(report-table-data 'Table)
+)
+
+
+(define (addcol-action id)
+	(gs:table-add-column 'Table "")
+	(report-table-data 'Table)
+)
+
+(define (delcol-action id)
+	(gs:table-set-column-name 'Table "first column" "second column" "third column")
+	(report-table-data 'Table)
+)
+
+(define (setrows-action id)
+	(gs:table-set-row-count 'Table 10)
+	(report-table-data 'Table)
+)
+
+
+(define (rownumber-action id flag)
+	(gs:table-show-row-number 'Table flag)
+)
+
+(define (null-action) nil)
+
+(gs:listen)
+
+(exit)
+
+; eof
diff --git a/guiserver/tabs-demo.lsp b/guiserver/tabs-demo.lsp
new file mode 100644
index 0000000..b6d6b75
--- /dev/null
+++ b/guiserver/tabs-demo.lsp
@@ -0,0 +1,101 @@
+#!/usr/local/bin/newlisp
+;;
+;; tabs-demo.lsp - demonstrate tabs and icons
+;; for 10.6.3 ideprecated gs:table-set-row-number was replaced with gs:table-show-row-number
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+(gs:get-screen)
+(set 'x (/ (- (gs:screen 0) 450) 2)) 
+(set 'y (/ (- (gs:screen 1) 580) 2))
+
+;;;; describe the GUI
+
+(gs:frame 'TheFrame x y 450 580 "Tabbed Pane Demo")
+;; When mapping gs:xxx functions the quote before gs:xxx is important
+;; so the functions get executed woth gs as the current context which makes
+;; the names from wigets be prefixed with their proper context name.
+(map 'gs:panel '(first second third icons))
+(gs:set-color 'first 1 0 0)
+(gs:set-color 'second 0 1 0)
+(gs:set-color 'third 0 0 1)
+(gs:set-color 'icons 0 0 1 0.1)
+(gs:set-flow-layout 'icons "center" 30 50)
+
+(gs:label 'new "new")
+(gs:label 'edit "edit")
+(gs:label 'cut "cut")
+(gs:label 'copy "copy")
+(gs:label 'paste "paste")
+(gs:label 'folder "folder")
+(gs:label 'openfolder "openfolder")
+(gs:label 'save "save")
+(gs:label 'info "info")
+(gs:label 'run "run")
+(gs:label 'restart "restart")
+(gs:label 'stop "stop")
+(gs:label 'fontbook "fontbook")
+(gs:label 'clear "clear")
+(gs:label 'search "search")
+
+;; if an icon path is prefixed with /local/ it means that this
+;; icon is built-in to guiserver.jar. Other paths to user
+;; supplied external icon images can be used instead (gif, jpg, png)
+(gs:set-icon 'new "/local/new32.png")
+(gs:set-icon 'edit "/local/edit32.png")
+(gs:set-icon 'cut "/local/cut32.png")
+(gs:set-icon 'copy "/local/copy32.png")
+(gs:set-icon 'paste "/local/paste32.png")
+(gs:set-icon 'folder "/local/folder-closed32.png")
+(gs:set-icon 'openfolder "/local/folder-opened32.png")
+(gs:set-icon 'save "/local/save32.png")
+(gs:set-icon 'info "/local/info32.png")
+(gs:set-icon 'run "/local/run32.png")
+(gs:set-icon 'restart "/local/restart32.png")
+(gs:set-icon 'stop "/local/stop32.png")
+(gs:set-icon 'fontbook "/local/font-book32.png")
+(gs:set-icon 'clear "/local/clear32.png")
+(gs:set-icon 'search "/local/search32.png")
+
+; an alternative way to make labels with icons
+(gs:image-label 'newLISP "/local/newLISP32.png")
+(gs:set-text 'newLISP "newLISP")
+(gs:image-label 'newLISPlogo "/local/newLISP128.png")
+
+(gs:add-to 'icons 'new 'edit 'cut 'copy 'paste 'folder 'openfolder 'save)
+(gs:add-to 'icons 'info 'run 'restart 'stop 'fontbook 'clear 'search 'newLISP 'newLISPlogo)
+
+(gs:tabbed-pane 'MyTabs 'tabs-action "top"
+			'first "first tab"
+			'second "second tab"
+			'third "third tab")
+
+(gs:insert-tab 'MyTabs 'icons "icons tab" 3 "/local/newLISP16.png")
+;(gs:remove-tab 'MyTabs 0) ; just for test
+
+(gs:table 'Table 'gs:no-action "A" "B" "C")
+(gs:table-show-row-number 'Table true)
+(gs:table-add-row 'Table "1 A" "1 B" "1 C")
+(gs:table-add-row 'Table "2 A" "2 B" "2 C")
+(gs:table-add-row 'Table "3 A" "3 B" "3 C")
+(gs:table-add-row 'Table "4 A" "4 B" "4 C")
+(gs:insert-tab 'MyTabs 'Table "Table tab" 4)
+
+(gs:request-focus 'MyTabs 3)
+(gs:add-to 'TheFrame 'MyTabs) 
+(gs:set-visible 'TheFrame true)
+
+;;;; define actions
+
+(define (tabs-action id cid tab)
+	(println id " " cid " " (base64-dec tab)))
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/textfield-demo.lsp b/guiserver/textfield-demo.lsp
new file mode 100644
index 0000000..0744b17
--- /dev/null
+++ b/guiserver/textfield-demo.lsp
@@ -0,0 +1,43 @@
+#!/usr/local/bin/newlisp
+;;
+; textfield-demo.lsp - demonstrate the test-field widget
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'TextDemo 100 100 400 200 "Enter text with or without password cover")
+(gs:label 'aLabel "..." "center" 300 50)
+(gs:set-background 'aLabel '(0 1 0) 0.2)
+(gs:text-field 'aTextField 'textfield-action 15)
+
+;; as an alternative specify the password character in the text field
+;; parameters and leave the check box unchecked, or don't use it at all
+;(gs:text-field 'aTextField 'textfield-action 15 "*")
+;(gs:check-box 'aCheckBox 'checkbox-action "password" true)
+
+(gs:check-box 'aCheckBox 'checkbox-action "password" nil)
+(gs:set-flow-layout 'TextDemo "center" 2 15)
+(gs:add-to 'TextDemo 'aLabel 'aTextField 'aCheckBox)
+(gs:set-visible 'TextDemo true)
+
+;;;; define actions
+(define (textfield-action id text)
+	(when text
+		(gs:set-text 'aLabel (base64-dec text))))
+
+(define (checkbox-action id flag)
+	(if flag 
+		(gs:set-echo-char 'aTextField "*")  
+		(gs:set-echo-char 'aTextField)) 
+) 
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/textrot-demo.lsp b/guiserver/textrot-demo.lsp
new file mode 100644
index 0000000..fe54ce6
--- /dev/null
+++ b/guiserver/textrot-demo.lsp
@@ -0,0 +1,42 @@
+#!/usr/local/bin/newlisp
+;;
+;; textrot-demo.lsp - demonstrate gs:rotate-tag on text
+;; and the mouse-wheel rotating an object
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+;(gs:set-trace true)
+
+;;;; describe the GUI
+(gs:frame 'RotationDemo 100 100 400 300 "Rotate text and widgets on a canvas")
+(gs:set-resizable 'RotationDemo nil)
+(gs:canvas 'MyCanvas 'RotationDemo)
+(gs:button 'TheButton 'button-action "Exit")
+(gs:set-background 'TheButton gs:white)
+(gs:add-to 'MyCanvas 'TheButton)
+(gs:set-stroke 3.0)
+(gs:set-background 'MyCanvas gs:white)
+(gs:mouse-wheel 'MyCanvas 'mouse-wheel-action)
+(gs:add-to 'RotationDemo 'MyCanvas)
+
+(gs:set-font 'MyCanvas "Lucida Sans Oblique" 36 "plain")
+(gs:fill-rect 'R 200 100 60 60 gs:lightGray 0.1)
+(gs:draw-text 'T "turn mouse wheel" 50 130 gs:red -15)
+(gs:fill-rect 'R 100 100 60 60 gs:lightGray 0.1)
+
+(gs:set-visible 'RotationDemo true)
+
+(define (mouse-wheel-action x y wheel)
+	(gs:rotate-tag 'T wheel 50 130)
+)
+
+(define (button-action)
+	(exit 0))
+
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/uppercase.lsp b/guiserver/uppercase.lsp
new file mode 100644
index 0000000..7174cd7
--- /dev/null
+++ b/guiserver/uppercase.lsp
@@ -0,0 +1,6 @@
+;; demo script: uppercase.lsp
+;; this script is registered in the Tool menu of newlisp-edit.lsp
+
+(print (upper-case (read-file (main-args 2))))
+
+(exit)
diff --git a/guiserver/widgets-demo-jp.lsp b/guiserver/widgets-demo-jp.lsp
new file mode 100644
index 0000000..c8af744
--- /dev/null
+++ b/guiserver/widgets-demo-jp.lsp
@@ -0,0 +1,162 @@
+#!/usr/local/bin/newlisp
+;;
+;; widgets-demo.lsp - demonstrate all widgets
+
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;(gs:set-trace true)
+
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.motif.MotifLookAndFeel")
+;(gs:set-look-and-feel "javax.swing.plaf.metal.MetalLookAndFeel")
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.windows.WindowsLookAndFeel") ;????
+;(gs:set-look-and-feel "javax.swing.plaf.mac.MacLookAndFeel") ; ????
+
+;;;; describe the GUI
+(gs:frame 'WidgetsDemo 200 40 800 640 "ใ‚ฆใ‚ฃใ‚ธใƒƒใƒˆใƒ‡ใƒข")
+(gs:set-grid-layout 'WidgetsDemo 5 1 10 1)
+
+;; the monitor area
+(gs:text-area 'MonitorArea 'action-handler)
+(gs:set-editable 'MonitorArea nil)
+(gs:set-background 'MonitorArea 0.5 0.5 0.5)
+(gs:set-font 'MonitorArea "Monospaced" 12 "plain")
+(gs:set-foreground 'MonitorArea 1 1 0.0)
+
+;; the button panel
+(gs:panel 'ButtonPanel)
+(gs:set-flow-layout 'ButtonPanel "left" 10 10)
+(gs:set-titled-border 'ButtonPanel "ใƒœใ‚ฟใƒณ")
+(gs:button 'TheButton 'button-handler "ใƒœใ‚ฟใƒณ")
+;(gs:set-color 'TheButton 1 0 0) ; just for testing
+(gs:image-button 'TheImageButton 'action-handler "/local/newLISP32.png")
+(gs:toggle-button 'TheToggleButton 'action-handler "ใƒˆใ‚ฐใƒซใƒœใ‚ฟใƒณ")
+;(gs:set-selected 'TheToggleButton true)
+(gs:radio-button 'TheRadioButton 'action-handler "ใƒฉใ‚ธใ‚ชใƒœใ‚ฟใƒณ")
+;(gs:set-selected 'TheRadioButton true)
+(gs:check-box 'TheCheckBox 'action-handler "ใƒใ‚งใƒƒใ‚ฏใƒœใƒƒใ‚ฏใ‚น")
+(gs:set-selected 'TheCheckBox true)
+(gs:button 'TheMessage 'action-handler "ๆŠผใ—ใฆ")
+(gs:add-to 'ButtonPanel 'TheButton 'TheImageButton 'TheToggleButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+
+;; list and combo boxes
+(gs:panel 'ListPanel)
+(gs:set-flow-layout 'ListPanel "center"  50 1)
+(gs:set-titled-border 'ListPanel "ใ‚ณใƒณใƒœใƒœใƒƒใ‚ฏใ‚นใจใƒชใ‚นใƒˆใƒœใƒƒใ‚ฏใ‚น")
+(gs:combo-box 'TheComboBox 'action-handler "๏ผ‘" "๏ผ’" "๏ผ“")
+(gs:select-list-item 'TheComboBox "2 ")
+(gs:set-background 'TheComboBox 1.0 0.9 0.9)
+(gs:set-foreground 'TheComboBox 0 0 1)
+(gs:set-font 'TheComboBox "Lucida Serif Typewriter" 14 "plain")
+(gs:list-box 'TheListBox 'action-handler "็ฌฌไธ€ใ‚จใƒณใƒˆใƒชใƒผ" "็ฌฌไบŒใ‚จใƒณใƒˆใƒชใƒผ" "็ฌฌไธ‰ใ‚จใƒณใƒˆใƒชใƒผ")
+(gs:set-background 'TheListBox 1.0 0.9 0.9)
+(gs:set-foreground 'TheListBox 0 0 1)
+(gs:set-size 'TheListBox 200 80)
+(gs:add-list-item 'TheListBox "็ฌฌๅ››ใ‚จใƒณใƒˆใƒชใƒผ" "็ฌฌๅ…ญใ‚จใƒณใƒˆใƒชใƒผ" "็ฌฌไธƒใ‚จใƒณใƒˆใƒชใƒผ")
+(gs:add-list-item 'TheListBox "eight entry")
+(gs:insert-list-item 'TheListBox "ใƒ€ใƒ–ใƒซใ‚ฏใƒชใƒƒใ‚ฏใ—ใฆ" 2)
+;(gs:remove-list-item 'TheListBox 2) ; just for testing
+(gs:add-to 'ListPanel 'TheComboBox 'TheListBox )
+
+;; text entry widgets
+(gs:panel 'TextPanel)
+(gs:set-flow-layout 'TextPanel "left" 10 1)
+(gs:set-titled-border 'TextPanel "ใƒ†ใ‚ญใ‚นใƒˆใƒ•ใ‚ฃใƒผใƒซใƒ‰ใจใƒ†ใ‚ญใ‚นใƒˆใ‚จใƒชใ‚ข")
+(gs:text-field 'TheTextField 'textfield-handler 8)
+(gs:set-background 'TheTextField 0.7 0.8 0.8)
+(gs:text-area 'TheTextArea 'textarea-handler 120 80)
+(gs:set-background 'TheTextArea 0.7 0.8 0.8)
+(gs:button 'GetTextFieldButton 'gettextfield-handler "ใƒ†ใ‚ญใ‚นใƒˆใƒ•ใ‚ฃใƒผใƒซใƒ‰ใ‹ใ‚‰ใฎๅ–ใ‚Šๅ‡บใ—")
+(gs:button 'GetTextAreaButton 'gettextarea-handler "ใƒ†ใ‚ญใ‚นใƒˆใ‚จใƒชใ‚ขใ‹ใ‚‰ใฎๅ–ใ‚Šๅ‡บใ—")
+(gs:add-to 'TextPanel 'TheTextField 'GetTextFieldButton 'TheTextArea 'GetTextAreaButton)
+
+;; slider, progress-bar and scroll-area
+(gs:panel 'SlidePanel)
+(gs:set-titled-border 'SlidePanel "ใ‚นใƒฉใ‚คใƒ€ใƒผใ€ใƒ—ใƒญใ‚ฐใƒฌใ‚นใƒใƒผใ€ใ‚นใ‚ฏใƒญใƒผใƒซใƒ‘ใƒณ")
+(gs:set-flow-layout 'SlidePanel "left" 20 1)
+(gs:slider 'TheSlider 'slider-handler "horizontal" 1 100 30)
+(gs:label 'SliderStatus "30" "right" 30 10)
+(gs:progress-bar 'TheProgress 1 100 30)
+(gs:image-label 'TheLogo "/local/newLISP128.png")
+(gs:scroll-pane 'TheScrollPane 'TheLogo 100 90)
+
+(gs:add-to 'SlidePanel 'TheSlider 'SliderStatus 'TheProgress 'TheScrollPane)
+
+
+;; add all panels to the grid laount in the main frame
+(gs:add-to 'WidgetsDemo 'MonitorArea 'ButtonPanel 'ListPanel 'TextPanel 'SlidePanel)
+
+(gs:set-visible 'WidgetsDemo true)
+
+;;;; define actions
+
+(define (button-handler)
+	(gs:dialog 'TheDialog 'WidgetsDemo "A Dialog Window" 300 200 true true))
+
+
+;; several widgets can be served by one handler
+;; the first parameter is always the source of the event
+(define (action-handler)
+	(if (= "MAIN:TheToggleButton" (args 0))
+		(if (true? (args 1))
+			(gs:disable 'TheButton 'TheImageButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+			(gs:enable 'TheButton 'TheImageButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+		))
+
+	(if (= "MAIN:TheImageButton" (args 0))
+		(gs:color-dialog 'WidgetsDemo 'action-handler "Choose a color" 1 1 1))
+
+	(if (= "MAIN:TheMessage" (args 0))
+		(gs:confirm-dialog 'WidgetsDemo 'action-handler 
+				"ใƒกใƒƒใ‚ปใƒผใ‚ธ" "ใ‚จใƒณใ‚ธใƒงใ‚ค๏ผง๏ผต๏ผฉ ๏ผณ๏ฝ…๏ฝ’๏ฝ–๏ฝ…๏ฝ’"
+				"yes-no"
+				;(amb "error" "informaton" "warning" "question" "plain")
+		))
+
+	(let ( (out-text (list (string (args 0)))) (len (length (args))))
+		(if (> len 1) (push (string (args 1)) out-text -1))
+		(if (> len 2) (push (base64-dec (string (args 2))) out-text -1))
+		(if (> len 3) (push (string (args 3)) out-text -1))
+		(push "\n" out-text -1)
+		(gs:append-text 'MonitorArea (join out-text " ")))
+)
+
+(define (textfield-handler id text)
+	(gs:append-text 'MonitorArea (base64-dec text))
+	(gs:append-text 'MonitorArea "\n")
+	(gs:add-list-item 'TheListBox (base64-dec text))
+	(gs:add-list-item 'TheComboBox (base64-dec text))
+)
+
+(define (textarea-handler)) ; not interested in keystrokes
+
+(define (gettextarea-handler id text)
+	(gs:get-text 'TheTextArea 'gettextcallback-handler)
+)
+
+(define (gettextfield-handler id text)
+	(gs:get-text 'TheTextField 'gettextcallback-handler)
+)
+
+(define (gettextcallback-handler id text)
+	(if text
+		(begin
+			(gs:append-text 'MonitorArea (base64-dec text))
+			(gs:append-text 'MonitorArea "\n"))
+	)
+)
+
+(define (slider-handler id value)
+	(gs:set-text 'SliderStatus (string value))
+	(gs:set-value 'TheProgress value)
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/widgets-demo-ru.lsp b/guiserver/widgets-demo-ru.lsp
new file mode 100644
index 0000000..88412a4
--- /dev/null
+++ b/guiserver/widgets-demo-ru.lsp
@@ -0,0 +1,162 @@
+#!/usr/local/bin/newlisp
+;;
+;; widgets-demo.lsp - demonstrate all widgets
+
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;(gs:set-trace true)
+
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.motif.MotifLookAndFeel")
+;(gs:set-look-and-feel "javax.swing.plaf.metal.MetalLookAndFeel")
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.windows.WindowsLookAndFeel") ;????
+;(gs:set-look-and-feel "javax.swing.plaf.mac.MacLookAndFeel") ; ????
+
+;;;; describe the GUI
+(gs:frame 'WidgetsDemo 200 40 640 640 "ะดะตะผะพ ะ“ะฃะ˜-ัะปะตะผะตะฝั‚ะพะฒ")
+(gs:set-grid-layout 'WidgetsDemo 5 1 10 1)
+
+;; the monitor area
+(gs:text-area 'MonitorArea 'action-handler)
+(gs:set-editable 'MonitorArea nil)
+(gs:set-background 'MonitorArea 0.5 0.5 0.5)
+(gs:set-font 'MonitorArea "Monospaced" 12 "plain")
+(gs:set-foreground 'MonitorArea 1 1 0.0)
+
+;; the button panel
+(gs:panel 'ButtonPanel)
+(gs:set-flow-layout 'ButtonPanel "left" 10 10)
+(gs:set-titled-border 'ButtonPanel "ะบะฝะพะฟะบะธ")
+(gs:button 'TheButton 'button-handler "ะบะฝะพะฟะบะฐ")
+;(gs:set-color 'TheButton 1 0 0) ; just for testing
+(gs:image-button 'TheImageButton 'action-handler "/local/newLISP32.png")
+(gs:toggle-button 'TheToggleButton 'action-handler "ั‚ัƒะผะฑะปะตั€")
+;(gs:set-selected 'TheToggleButton true)
+(gs:radio-button 'TheRadioButton 'action-handler "ะฒั‹ะฑั€ะฐั‚ัŒ")
+;(gs:set-selected 'TheRadioButton true)
+(gs:check-box 'TheCheckBox 'action-handler "ะพั‚ะผะตั‚ะธั‚ัŒ")
+(gs:set-selected 'TheCheckBox true)
+(gs:button 'TheMessage 'action-handler "ะฝะฐะถะฐั‚ัŒ")
+(gs:add-to 'ButtonPanel 'TheButton 'TheImageButton 'TheToggleButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+
+;; list and combo boxes
+(gs:panel 'ListPanel)
+(gs:set-flow-layout 'ListPanel "center"  50 1)
+(gs:set-titled-border 'ListPanel "ะบะพะผะฑะพ ะธ ัะฟะธัะบะธ")
+(gs:combo-box 'TheComboBox 'action-handler "ะพะดะธะฝ" "ะดะฒะฐ" "ั‚ั€ะธ")
+(gs:select-list-item 'TheComboBox "ะดะฒะฐ")
+(gs:set-background 'TheComboBox 1.0 0.9 0.9)
+(gs:set-foreground 'TheComboBox 0 0 1)
+(gs:set-font 'TheComboBox "Lucida Serif Typewriter" 14 "plain")
+(gs:list-box 'TheListBox 'action-handler "ะฟะตั€ะฒะพะต" "ะฒั‚ะพั€ะพะต" "ั‚ั€ะตั‚ัŒะต")
+(gs:set-background 'TheListBox 1.0 0.9 0.9)
+(gs:set-foreground 'TheListBox 0 0 1)
+(gs:set-size 'TheListBox 200 80)
+(gs:add-list-item 'TheListBox "ั‡ะตั‚ะฒะตั€ั‚ะพะต" "ะฟัั‚ะพะต" "ัˆะตัั‚ะพะต" "ัะตะดัŒะผะพะต")
+(gs:add-list-item 'TheListBox "ะฒะพััŒะผะพะต")
+(gs:insert-list-item 'TheListBox "ั‰ะตะปะบะฝัƒั‚ัŒ ะดะฒะฐะถะดั‹" 2)
+;(gs:remove-list-item 'TheListBox 2) ; just for testing
+(gs:add-to 'ListPanel 'TheComboBox 'TheListBox )
+
+;; text entry widgets
+(gs:panel 'TextPanel)
+(gs:set-flow-layout 'TextPanel "left" 10 1)
+(gs:set-titled-border 'TextPanel "ั‚ะตะบัั‚ะพะฒะพะต ะฟะพะปะต ะธ ั‚ะตะบัั‚ะพะฒั‹ะน ะฒะฒะพะด")
+(gs:text-field 'TheTextField 'textfield-handler 10)
+(gs:set-background 'TheTextField 0.7 0.8 0.8)
+(gs:text-area 'TheTextArea 'textarea-handler 160 80)
+(gs:set-background 'TheTextArea 0.7 0.8 0.8)
+(gs:button 'GetTextFieldButton 'gettextfield-handler "ะฟะพะปัƒั‡ะธั‚ัŒ ั‚ะตะบัั‚")
+(gs:button 'GetTextAreaButton 'gettextarea-handler "ะฟะพะปัƒั‡ะธั‚ัŒ ั‚ะตะบัั‚")
+(gs:add-to 'TextPanel 'TheTextField 'GetTextFieldButton 'TheTextArea 'GetTextAreaButton)
+
+;; slider, progress-bar and scroll-area
+(gs:panel 'SlidePanel)
+(gs:set-titled-border 'SlidePanel "ะดะฒะธะถะพะบ, ะธะฝะดะธะบะฐั‚ะพั€ ะทะฐะณั€ัƒะทะบะธ, ะฟั€ะพะบั€ัƒั‚ะบะธ ะฟะฐะฝะตะปะธ")
+(gs:set-flow-layout 'SlidePanel "left" 20 1)
+(gs:slider 'TheSlider 'slider-handler "ะณะพั€ะธะทะพะฝั‚ะฐะปัŒะฝั‹" 1 100 30)
+(gs:label 'SliderStatus "30" "right" 30 10)
+(gs:progress-bar 'TheProgress 1 100 30)
+(gs:image-label 'TheLogo "/local/newLISP128.png")
+(gs:scroll-pane 'TheScrollPane 'TheLogo 100 90)
+
+(gs:add-to 'SlidePanel 'TheSlider 'SliderStatus 'TheProgress 'TheScrollPane)
+
+
+;; add all panels to the grid laount in the main frame
+(gs:add-to 'WidgetsDemo 'MonitorArea 'ButtonPanel 'ListPanel 'TextPanel 'SlidePanel)
+
+(gs:set-visible 'WidgetsDemo true)
+
+;;;; define actions
+
+(define (button-handler)
+	(gs:dialog 'TheDialog 'WidgetsDemo "ะพะบะฝะพ-ะดะธะฐะปะพะณ" 300 200 true true))
+
+
+;; several widgets can be served by one handler
+;; the first parameter is always the source of the event
+(define (action-handler)
+	(if (= "MAIN:TheToggleButton" (args 0))
+		(if (true? (args 1))
+			(gs:disable 'TheButton 'TheImageButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+			(gs:enable 'TheButton 'TheImageButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+		))
+
+	(if (= "MAIN:TheImageButton" (args 0))
+		(gs:color-dialog 'WidgetsDemo 'action-handler "ะฒั‹ะฑะตั€ะธั‚ะต ั†ะฒะตั‚" 1 1 1))
+
+	(if (= "MAIN:TheMessage" (args 0))
+		(gs:confirm-dialog 'WidgetsDemo 'action-handler 
+				"ัะพะพะฑั‰ะตะฝะธะต" "ะฟั€ะธัั‚ะฝะพะณะพ ะฟะพะปัŒะทะพะฒะฐะฝะธั ะ“ะฃะ˜-ัะตั€ะฒะตั€ะพะผ" 
+				"ะดะฐ-ะฝะตั‚"
+				;(amb "error" "informaton" "warning" "question" "plain")
+		))
+
+	(let ( (out-text (list (string (args 0)))) (len (length (args))))
+		(if (> len 1) (push (string (args 1)) out-text -1))
+		(if (> len 2) (push (base64-dec (string (args 2))) out-text -1))
+		(if (> len 3) (push (string (args 3)) out-text -1))
+		(push "\n" out-text -1)
+		(gs:append-text 'MonitorArea (join out-text " ")))
+)
+
+(define (textfield-handler id text)
+	(gs:append-text 'MonitorArea (base64-dec text))
+	(gs:append-text 'MonitorArea "\n")
+	(gs:add-list-item 'TheListBox (base64-dec text))
+	(gs:add-list-item 'TheComboBox (base64-dec text))
+)
+
+(define (textarea-handler)) ; not interested in keystrokes
+
+(define (gettextarea-handler id text)
+	(gs:get-text 'TheTextArea 'gettextcallback-handler)
+)
+
+(define (gettextfield-handler id text)
+	(gs:get-text 'TheTextField 'gettextcallback-handler)
+)
+
+(define (gettextcallback-handler id text)
+	(if text
+		(begin
+			(gs:append-text 'MonitorArea (base64-dec text))
+			(gs:append-text 'MonitorArea "\n"))
+	)
+)
+
+(define (slider-handler id value)
+	(gs:set-text 'SliderStatus (string value))
+	(gs:set-value 'TheProgress value)
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/widgets-demo.lsp b/guiserver/widgets-demo.lsp
new file mode 100644
index 0000000..f7a6152
--- /dev/null
+++ b/guiserver/widgets-demo.lsp
@@ -0,0 +1,161 @@
+#!/usr/local/bin/newlisp
+;;
+;; widgets-demo.lsp - demonstrate all widgets
+
+
+;;;; initialization
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(gs:init) 
+
+;(gs:set-trace true)
+
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.motif.MotifLookAndFeel")
+;(gs:set-look-and-feel "javax.swing.plaf.metal.MetalLookAndFeel")
+;(gs:set-look-and-feel "com.sun.java.swing.plaf.windows.WindowsLookAndFeel") ;????
+;(gs:set-look-and-feel "javax.swing.plaf.mac.MacLookAndFeel") ; ????
+
+;;;; describe the GUI
+(gs:frame 'WidgetsDemo 200 40 640 640 "Widgets Demo")
+(gs:set-grid-layout 'WidgetsDemo 5 1 10 1)
+
+;; the monitor area
+(gs:text-area 'MonitorArea 'action-handler)
+(gs:set-editable 'MonitorArea nil)
+(gs:set-background 'MonitorArea 0.5 0.5 0.5)
+(gs:set-font 'MonitorArea "Monospaced" 12 "plain")
+(gs:set-foreground 'MonitorArea 1 1 0.0)
+
+;; the button panel
+(gs:panel 'ButtonPanel)
+(gs:set-flow-layout 'ButtonPanel "left" 10 10)
+(gs:set-titled-border 'ButtonPanel "buttons")
+(gs:button 'TheButton 'button-handler "button")
+;(gs:set-color 'TheButton 1 0 0) ; just for testing
+(gs:image-button 'TheImageButton 'action-handler "/local/newLISP32.png")
+(gs:toggle-button 'TheToggleButton 'action-handler "toggle")
+;(gs:set-selected 'TheToggleButton true)
+(gs:radio-button 'TheRadioButton 'action-handler "radio button")
+;(gs:set-selected 'TheRadioButton true)
+(gs:check-box 'TheCheckBox 'action-handler "check box")
+(gs:set-selected 'TheCheckBox true)
+(gs:button 'TheMessage 'action-handler "press")
+(gs:add-to 'ButtonPanel 'TheButton 'TheImageButton 'TheToggleButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+
+;; list and combo boxes
+(gs:panel 'ListPanel)
+(gs:set-flow-layout 'ListPanel "center"  50 1)
+(gs:set-titled-border 'ListPanel "combox-box and list-box")
+(gs:combo-box 'TheComboBox 'action-handler "one" "two" "three")
+(gs:select-list-item 'TheComboBox "two")
+(gs:set-background 'TheComboBox 1.0 0.9 0.9)
+(gs:set-foreground 'TheComboBox 0 0 1)
+(gs:set-font 'TheComboBox "Lucida Serif Typewriter" 14 "plain")
+(gs:list-box 'TheListBox 'action-handler "first entry" "second entry" "third entry")
+(gs:set-background 'TheListBox 1.0 0.9 0.9)
+(gs:set-foreground 'TheListBox 0 0 1)
+(gs:set-size 'TheListBox 200 80)
+(gs:add-list-item 'TheListBox "fourth entry" "fifth entry" "sixth entry" "seventh entry")
+(gs:add-list-item 'TheListBox "eight entry")
+(gs:insert-list-item 'TheListBox "double-click me" 2)
+;(gs:remove-list-item 'TheListBox 2) ; just for testing
+(gs:add-to 'ListPanel 'TheComboBox 'TheListBox )
+
+;; text entry widgets
+(gs:panel 'TextPanel)
+(gs:set-flow-layout 'TextPanel "left" 10 1)
+(gs:set-titled-border 'TextPanel "text-field and text-area")
+(gs:text-field 'TheTextField 'textfield-handler 10)
+(gs:set-background 'TheTextField 0.7 0.8 0.8)
+(gs:text-area 'TheTextArea 'textarea-handler 160 80)
+(gs:set-background 'TheTextArea 0.7 0.8 0.8)
+(gs:button 'GetTextFieldButton 'gettextfield-handler "get text field")
+(gs:button 'GetTextAreaButton 'gettextarea-handler "get text area")
+(gs:add-to 'TextPanel 'TheTextField 'GetTextFieldButton 'TheTextArea 'GetTextAreaButton)
+
+;; slider, progress-bar and scroll-area
+(gs:panel 'SlidePanel)
+(gs:set-titled-border 'SlidePanel "slider, progress-bar and scroll-pane")
+(gs:set-flow-layout 'SlidePanel "left" 20 1)
+(gs:slider 'TheSlider 'slider-handler "horizontal" 1 100 30)
+(gs:label 'SliderStatus "30" "right" 30 10)
+(gs:progress-bar 'TheProgress 1 100 30)
+(gs:image-label 'TheLogo "/local/newLISP128.png")
+(gs:scroll-pane 'TheScrollPane 'TheLogo 100 90)
+
+(gs:add-to 'SlidePanel 'TheSlider 'SliderStatus 'TheProgress 'TheScrollPane)
+
+
+;; add all panels to the grid laount in the main frame
+(gs:add-to 'WidgetsDemo 'MonitorArea 'ButtonPanel 'ListPanel 'TextPanel 'SlidePanel)
+
+(gs:set-visible 'WidgetsDemo true)
+
+;;;; define actions
+
+(define (button-handler)
+	(gs:dialog 'TheDialog 'WidgetsDemo "A Dialog Window" 300 200 true true))
+
+
+;; several widgets can be served by one handler
+;; the first parameter is always the source of the event
+(define (action-handler)
+	(if (= "MAIN:TheToggleButton" (args 0))
+		(if (true? (args 1))
+			(gs:disable 'TheButton 'TheImageButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+			(gs:enable 'TheButton 'TheImageButton 'TheRadioButton 'TheCheckBox 'TheMessage)
+		))
+
+	(if (= "MAIN:TheImageButton" (args 0))
+		(gs:color-dialog 'WidgetsDemo 'action-handler "Choose a color" 1 1 1))
+
+	(if (= "MAIN:TheMessage" (args 0))
+		(gs:confirm-dialog 'WidgetsDemo 'action-handler 
+				"A Message" "Enjoy GUI server" 
+				"yes-no"
+		))
+
+	(let ( (out-text (list (string (args 0)))) (len (length (args))))
+		(if (> len 1) (push (string (args 1)) out-text -1))
+		(if (> len 2) (push (base64-dec (string (args 2))) out-text -1))
+		(if (> len 3) (push (string (args 3)) out-text -1))
+		(push "\n" out-text -1)
+		(gs:append-text 'MonitorArea (join out-text " ")))
+)
+
+(define (textfield-handler id text)
+	(gs:append-text 'MonitorArea (base64-dec text))
+	(gs:append-text 'MonitorArea "\n")
+	(gs:add-list-item 'TheListBox (base64-dec text))
+	(gs:add-list-item 'TheComboBox (base64-dec text))
+)
+
+(define (textarea-handler)) ; not interested in keystrokes
+
+(define (gettextarea-handler id text)
+	(gs:get-text 'TheTextArea 'gettextcallback-handler)
+)
+
+(define (gettextfield-handler id text)
+	(gs:get-text 'TheTextField 'gettextcallback-handler)
+)
+
+(define (gettextcallback-handler id text)
+	(if text
+		(begin
+			(gs:append-text 'MonitorArea (base64-dec text))
+			(gs:append-text 'MonitorArea "\n"))
+	)
+)
+
+(define (slider-handler id value)
+	(gs:set-text 'SliderStatus (string value))
+	(gs:set-value 'TheProgress value)
+)
+
+;;;; listen for incoming action requests and dispatch
+(gs:listen)
+
+;; eof
+
diff --git a/guiserver/word-count.lsp b/guiserver/word-count.lsp
new file mode 100644
index 0000000..c57ac87
--- /dev/null
+++ b/guiserver/word-count.lsp
@@ -0,0 +1,11 @@
+;; demo script: word-count.lsp
+;; this script is registered in the Tool menu of newlisp-edit.lsp
+
+(set 'content (read-file (main-args 2)))
+
+(println 
+	"Words: " (length (find-all "\\w+" content))
+  " Bytes: " ((file-info (main-args 2)) 0))
+
+(exit)
+
diff --git a/index.cgi b/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/makefile_aixILP32_utf8_gcc b/makefile_aixILP32_utf8_gcc
new file mode 100644
index 0000000..8021488
--- /dev/null
+++ b/makefile_aixILP32_utf8_gcc
@@ -0,0 +1,20 @@
+#================== makefile_aixLP32_utf8_gcc (ILP32 memory model) ============
+# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU 
+# 
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+        nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o 
+
+# use following for UTF-8 support and add nl-utf8.o to the OBJS line 
+CFLAGS = -maix32 -Wall -pedantic -fno-strict-aliasing -Wno-uninitialized -Wno-long-long -c -O2 -DSUPPORT_UTF8 -DAIX 
+CC = gcc 
+
+default: $(OBJS) 
+	$(CC) $(OBJS) -maix32 -lm  -ldl -lrt -lnsl -o newlisp 
+
+.c.o: 
+	$(CC) $(CFLAGS) $< 
+
+$(OBJS): primes.h protos.h makefile_aixILP32_utf8_gcc 
+# 
+#==============================================================================
+
diff --git a/makefile_aixLP64_utf8_gcc b/makefile_aixLP64_utf8_gcc
new file mode 100644
index 0000000..1f5c6da
--- /dev/null
+++ b/makefile_aixLP64_utf8_gcc
@@ -0,0 +1,20 @@
+#================== makefile_aixLP64_utf8_gcc (64bit)==========================
+# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU 
+# 
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+        nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o 
+
+# use following for UTF-8 support and add nl-utf8.o to the OBJS line 
+CFLAGS = -maix64 -Wall -pedantic -fno-strict-aliasing -Wno-uninitialized -Wno-long-long -c -O2 -DNEWLISP64 -DSUPPORT_UTF8 -DAIX 
+CC = gcc 
+
+default: $(OBJS) 
+	$(CC) $(OBJS) -maix64 -lm  -ldl -lrt -lnsl -o newlisp 
+
+.c.o: 
+	$(CC) $(CFLAGS) $< 
+
+$(OBJS): primes.h protos.h makefile_aixLP64_utf8_gcc 
+# 
+#==============================================================================
+
diff --git a/makefile_aixLP64_utf8_xlc b/makefile_aixLP64_utf8_xlc
new file mode 100644
index 0000000..a6f9f2b
--- /dev/null
+++ b/makefile_aixLP64_utf8_xlc
@@ -0,0 +1,20 @@
+#======================= makefile_aixLP64_utf8_xlc (xlc_r 64bit) ====================== 
+# 
+# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU
+# 
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+        nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o 
+
+# use following for UTF-8 support and add nl-utf8.o to the OBJS line 
+CFLAGS = -q64 -c -g -O2 -DNEWLISP64 -DSUPPORT_UTF8 -DAIX 
+CC = xlc_r 
+
+
+default: $(OBJS) 
+	OBJECT_MODE=64 $(CC) $(OBJS) -lm  -ldl -lrt -lnsl -o newlisp 
+
+.c.o: 
+	$(CC) $(CFLAGS) $< 
+
+$(OBJS): primes.h protos.h makefile_aixLP64_utf8_xlc
+#=====================================================================================
diff --git a/makefile_aix_utf8_gcc b/makefile_aix_utf8_gcc
new file mode 100644
index 0000000..97ee53f
--- /dev/null
+++ b/makefile_aix_utf8_gcc
@@ -0,0 +1,19 @@
+#==================== makefile_aix_utf8_gcc (32bit)============================
+# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU 
+# 
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+        nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o 
+
+# use following for UTF-8 support and add nl-utf8.o to the OBJS line 
+CFLAGS = -Wall -pedantic -fno-strict-aliasing -Wno-uninitialized -Wno-long-long -c -O2 -DSUPPORT_UTF8 -DAIX 
+CC = gcc 
+
+default: $(OBJS) 
+	$(CC) $(OBJS) -lm  -ldl -lrt -lnsl -o newlisp 
+
+.c.o: 
+	$(CC) $(CFLAGS) $< 
+
+$(OBJS): primes.h protos.h makefile_aix_utf8_gcc 
+# 
+#==============================================================================
diff --git a/makefile_aix_utf8_xlc b/makefile_aix_utf8_xlc
new file mode 100644
index 0000000..c270260
--- /dev/null
+++ b/makefile_aix_utf8_xlc
@@ -0,0 +1,21 @@
+#========================= makefile_aix_utf8_xlc I 32-bit ============================= 
+# 
+# makefile for newLISP v. 10.x.x on AIX with UTF-8 support on PowerPC CPU
+# 
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+        nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o 
+
+
+# use following for UTF-8 support and add nl-utf8.o to the OBJS line 
+CFLAGS = -c -g -O2 -DSUPPORT_UTF8 -DAIX 
+CC = xlc_r 
+
+default: $(OBJS) 
+	$(CC) $(OBJS) -lm  -ldl -lrt -lnsl -o newlisp 
+
+.c.o: 
+	$(CC) $(CFLAGS) $< 
+
+$(OBJS): primes.h protos.h makefile_aix_utf8_xlc
+#=====================================================================================
+
diff --git a/makefile_amal_darwin_utf8_ffi b/makefile_amal_darwin_utf8_ffi
new file mode 100644
index 0000000..bfc237e
--- /dev/null
+++ b/makefile_amal_darwin_utf8_ffi
@@ -0,0 +1,30 @@
+# amalgamation makefile for newLISP v. 10.x.x on Mac OSX with readline support
+# Concats all newLISP source files into one big file. At least on gcc v.4.0.1
+# on Mac OS X there is no speed advantage through better optimization of the
+# compiler. But other platforms compilers may show different results.
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+
+OBJS = newlisp-amal.o pcre.o
+
+CFLAGS = -Wall -m32 -O1 -I/usr/include -c -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DFFI
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -lffi -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+newlisp-amal.c:
+	cat newlisp.c nl-symbol.c nl-math.c nl-list.c nl-liststr.c nl-string.c nl-filesys.c \
+    nl-sock.c nl-import.c nl-xml-json.c nl-web.c nl-matrix.c nl-debug.c nl-utf8.c > newlisp-amal.c
+
+
+$(OBJS): newlisp.h primes.h protos.h makefile_amal_darwin_utf8_ffi
+
+
diff --git a/makefile_bsd b/makefile_bsd
new file mode 100644
index 0000000..fd09d96
--- /dev/null
+++ b/makefile_bsd
@@ -0,0 +1,25 @@
+# makefile for newLISP v. 10.x.x on BSDs: FreeBSD, OpenBSD and NetBSD
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+# the option -fno-strict-aliasing may not be available on some BSD versions 
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -DREADLINE -D_BSD
+# or without readline lib
+#CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -O2 -c -g -D_BSD
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -lreadline -lncurses -o newlisp
+# or without readline lib
+#	$(CC) $(OBJS) -m32 -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsd
+
diff --git a/makefile_bsdLP64 b/makefile_bsdLP64
new file mode 100644
index 0000000..525abd7
--- /dev/null
+++ b/makefile_bsdLP64
@@ -0,0 +1,25 @@
+# makefile for newLISP v. 10.x.x on BSDs: FreeBSD, OpenBSD and NetBSD
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+# the option -fno-strict-aliasing may not be available on some BSD versions 
+
+CFLAGS = -m64 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -DREADLINE -DNEWLISP64 -D_BSD
+# or without readline lib
+#CFLAGS = -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -O2 -c -g -DNEWLISP64 -D_BSD
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -lreadline -lncurses -o newlisp
+# or without readline lib
+#	$(CC) $(OBJS) -m64 -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsdLP64
+
diff --git a/makefile_bsdLP64_utf8 b/makefile_bsdLP64_utf8
new file mode 100644
index 0000000..bbbeeec
--- /dev/null
+++ b/makefile_bsdLP64_utf8
@@ -0,0 +1,25 @@
+# makefile for newLISP v. 10.x.x on BSDs: FreeBSD, OpenBSD and NetBSD with UTF8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+# the option -fno-strict-aliasing may not be available on some BSD versions 
+
+CFLAGS = -m64 -Wall -Wno-strict-aliasing -O2 -c -g -I/usr/local/include -DREADLINE -DNEWLISP64 -DSUPPORT_UTF8 -D_BSD
+# or without readline lib
+#CFLAGS = -m64 -Wall -Wno-strict-aliasing -O2 -c -g -DNEWLISP64 -D_BSD
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -lreadline -lncurses -o newlisp
+# or without readline lib
+#	$(CC) $(OBJS) -m64 -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsdLP64_utf8
+
diff --git a/makefile_bsdLP64_utf8_ffi b/makefile_bsdLP64_utf8_ffi
new file mode 100644
index 0000000..63cc0c5
--- /dev/null
+++ b/makefile_bsdLP64_utf8_ffi
@@ -0,0 +1,25 @@
+# makefile for newLISP v. 10.x.x on BSDs: FreeBSD, OpenBSD and NetBSD with UTF8 support
+# and with <libffi support
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+# the option -fno-strict-aliasing may not be available on some BSD versions 
+CFLAGS = -m64 -Wall -fno-strict-aliasing -O2 -c -g -I/usr/local/include -DREADLINE -DNEWLISP64 -DSUPPORT_UTF8 -D_BSD -DFFI
+
+# or without readline lib and libffi
+#CFLAGS = -m64 -Wall -Wno-strict-aliasing -O2 -c -g -DNEWLISP64 -D_BSD
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -lreadline -lncurses -L/usr/local/lib -lffi -o newlisp
+# or without readline lib
+#	$(CC) $(OBJS) -m64 -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsdLP64_utf8_ffi
+
diff --git a/makefile_bsdLP64_utf8_lib b/makefile_bsdLP64_utf8_lib
new file mode 100644
index 0000000..7905582
--- /dev/null
+++ b/makefile_bsdLP64_utf8_lib
@@ -0,0 +1,18 @@
+# makefile for newLISP v. 10.x.x on BSD as a 64-bit shared library - newlisp.so -
+#
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o unix-lib.o
+
+CFLAGS = -m64 -fPIC -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -D_BSD -DNEWLISP64 -DSUPPORT_UTF8 -DLIBRARY
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -lm -shared -o newlisp.so
+	strip newlisp.so
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsdLP64_utf8_lib
+
diff --git a/makefile_bsd_lib b/makefile_bsd_lib
new file mode 100644
index 0000000..8292fe1
--- /dev/null
+++ b/makefile_bsd_lib
@@ -0,0 +1,18 @@
+# makefile for newLISP v. 10.x.x on BSD as a shared library - newlisp.so -
+#
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o unix-lib.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -D_BSD
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -shared -o newlisp.so
+	strip newlisp.so
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsd_lib
+
diff --git a/makefile_bsd_utf8 b/makefile_bsd_utf8
new file mode 100644
index 0000000..c12ba76
--- /dev/null
+++ b/makefile_bsd_utf8
@@ -0,0 +1,23 @@
+# makefile for newLISP v. 10.x.x on BSDs: FreeBSD, OpenBSD and NetBSD with UTF8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -DREADLINE -D_BSD -DSUPPORT_UTF8
+# or without readline lib
+#CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -D_BSD -DSUPPORT_UTF8
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -lreadline -lncurses -o newlisp
+# or without readline lib
+#	$(CC) $(OBJS) -m32 -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsd_utf8
+
diff --git a/makefile_bsd_utf8_ffi b/makefile_bsd_utf8_ffi
new file mode 100644
index 0000000..28d807e
--- /dev/null
+++ b/makefile_bsd_utf8_ffi
@@ -0,0 +1,24 @@
+# makefile for newLISP v. 10.x.x on BSDs: FreeBSD, OpenBSD and NetBSD with UTF8 and libffi support
+# must have $(HOME)/include/ffi.h $(HOME)/include/ffitarget.h and $(HOME)/lib/libffi.a
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -I/usr/local/include -DREADLINE -D_BSD -DSUPPORT_UTF8 -DFFI
+# or without readline lib
+#CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -D_BSD -DSUPPORT_UTF8
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -lreadline -lncurses -L/usr/local/lib -lffi -o newlisp
+# or without readline lib
+#	$(CC) $(OBJS) -m32 -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsd_utf8_ffi
+
diff --git a/makefile_bsd_utf8_lib b/makefile_bsd_utf8_lib
new file mode 100644
index 0000000..d1478ce
--- /dev/null
+++ b/makefile_bsd_utf8_lib
@@ -0,0 +1,18 @@
+# makefile for newLISP v. 10.x.x on BSD as a shared library - newlisp.so -
+#
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o unix-lib.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -fno-strict-aliasing -O2 -c -g -D_BSD -DSUPPORT_UTF8 -DLIBRARY
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -shared -o newlisp.so
+	strip newlisp.so
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_bsd_utf8_lib
+
diff --git a/makefile_cygwin b/makefile_cygwin
new file mode 100644
index 0000000..50f151c
--- /dev/null
+++ b/makefile_cygwin
@@ -0,0 +1,36 @@
+# makefile for newLISP v.10.x.x on Cygwin with readline support
+#
+# support for CYGWIN was dropped with version 8.6 in 2005
+# nl-sock.c needs a GNU version of icmp6.h
+#
+# to use extended FFI add -lff to the $(CC) line and -DFFI to CFLAGS
+#
+# to use the semaphore function install cygserver:
+# http://cygwin.com/cygwin-ug-net/using-cygserver.html
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+# To install, install the normal Win32 version of newLISP first, 
+# then copy the newlisp.exe into $(NEWLISPDIR), which is normally 
+# defined as "C:\Program Files\newlisp" after the Win32 install. 
+# at least one CYGWIN library must be installed too
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m32 -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DCYGWIN
+#CFLAGS = -m32 -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DFFI -DCYGWIN
+
+CC = gcc
+
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -o newlisp.exe
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lffi -o newlisp.exe
+	strip newlisp.exe
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_cygwin
+
diff --git a/makefile_cygwinLP64 b/makefile_cygwinLP64
new file mode 100644
index 0000000..abaff04
--- /dev/null
+++ b/makefile_cygwinLP64
@@ -0,0 +1,36 @@
+# makefile for newLISP v.10.x.x on Cygwin with readline support
+#
+# support for CYGWIN was dropped with version 8.6 in 2005
+# nl-sock.c needs a GNU version of icmp6.h
+#
+# to use extended FFI add -lff to the $(CC) line and -DFFI to CFLAGS
+#
+# to use the semaphore function install cygserver:
+# http://cygwin.com/cygwin-ug-net/using-cygserver.html
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+# To install, install the normal Win32 version of newLISP first, 
+# then copy the newlisp.exe into $(NEWLISPDIR), which is normally 
+# defined as "C:\Program Files\newlisp" after the Win32 install. 
+# at least one CYGWIN library must be installed too
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m64 -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DCYGWIN
+#CFLAGS = -m64 -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DFFI -DCYGWIN
+
+CC = gcc
+
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -o newlisp.exe
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lffi -o newlisp.exe
+	strip newlisp.exe
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_cygwin
+
diff --git a/makefile_darwin b/makefile_darwin
new file mode 100644
index 0000000..022e3ed
--- /dev/null
+++ b/makefile_darwin
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o
+
+CFLAGS = -m32 -Wall -O1 -c -DREADLINE -DMAC_OSX
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin
+
+
diff --git a/makefile_darwinLP64 b/makefile_darwinLP64
new file mode 100644
index 0000000..60b41bb
--- /dev/null
+++ b/makefile_darwinLP64
@@ -0,0 +1,23 @@
+# makefile for newLISP v. 10.x.x on Mac OSX LP64 memory model with readline support
+#
+# for OS X 10.5/Leopard, Leopard comes standard with libreadline
+#
+# needs a G5 or core 2 duo to run. Passes 'make test' on intel core 2 duo
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m64 -Wall -O1 -c -g -DREADLINE -DMAC_OSX -DNEWLISP64
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): newlisp.h primes.h protos.h makefile_darwinLP64
+
+
diff --git a/makefile_darwinLP64_utf8 b/makefile_darwinLP64_utf8
new file mode 100644
index 0000000..2284c1a
--- /dev/null
+++ b/makefile_darwinLP64_utf8
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Mac OSX LP64 memory model with readline support and UTF8
+#
+# for OS X 10.4 and later
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -m64 -Wall -Oz -c -g -DREADLINE -DMAC_OSX -DNEWLISP64 -DSUPPORT_UTF8
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): newlisp.h primes.h protos.h makefile_darwinLP64_utf8
+
+
diff --git a/makefile_darwinLP64_utf8_ffi b/makefile_darwinLP64_utf8_ffi
new file mode 100644
index 0000000..feee913
--- /dev/null
+++ b/makefile_darwinLP64_utf8_ffi
@@ -0,0 +1,23 @@
+# makefile for newLISP v. 10.x.x on Mac OSX LP64 memory model with readline support, UTF8, FFI
+#
+# for OS X 10.6 and later
+# this is the makefile used to make Mac OS X package for OS X 10.6 Snow Leopard and after
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -m64 -mmacosx-version-min=10.6 -Wall -Oz -c -DREADLINE -DMAC_OSX -DNEWLISP64 -DSUPPORT_UTF8 -DFFI
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -mmacosx-version-min=10.6 -lm -lreadline -lffi -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): newlisp.h primes.h protos.h makefile_darwinLP64_utf8_ffi
+
+
diff --git a/makefile_darwinLP64_utf8_lib b/makefile_darwinLP64_utf8_lib
new file mode 100644
index 0000000..99ae917
--- /dev/null
+++ b/makefile_darwinLP64_utf8_lib
@@ -0,0 +1,21 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline  and UTF-8 support
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o unix-lib.o
+
+CFLAGS = -m64 -Wall -O1 -c -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DLIBRARY -DNEWLISP64
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -lm -lreadline -bundle -o newlisp.dylib
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwinLP64_utf8_lib
+
+
diff --git a/makefile_darwin_package b/makefile_darwin_package
new file mode 100644
index 0000000..2b0c50e
--- /dev/null
+++ b/makefile_darwin_package
@@ -0,0 +1,112 @@
+# prepare Mac OSX package root directory in ../Package_contents
+
+VERSION=10.7.0
+
+datadir=Package_contents/usr/local/share
+bindir=Package_contents/usr/local/bin
+mandir=Package_contents/usr/local/share/man
+appdir=Package_contents/Applications
+
+GUISERVER = ../Package_contents/usr/local/share/newlisp/guiserver
+
+darwin-package:
+	-mkdir Package_contents
+	-mkdir Package_contents/usr/
+	-mkdir Package_contents/usr/local
+	-mkdir Package_contents/usr/local/bin
+	-mkdir Package_contents/usr/local/share
+	-mkdir Package_contents/usr/local/share/man
+	-mkdir Package_contents/usr/local/share/man/man1
+	-mkdir Package_contents/Applications
+	# identical from install section in main Makefile except for $(bindir)/newlisp
+	# which installed versioned and linked when installing with 'make install'
+	-install -d $(datadir)/newlisp
+	-install -d $(datadir)/newlisp/modules
+	-install -d $(datadir)/newlisp/util
+	-install -d $(datadir)/doc/newlisp
+	-install -m 755 newlisp $(bindir)/newlisp
+	-install -m 755 util/newlispdoc $(bindir)/newlispdoc
+	-install -m 644 util/syntax.cgi $(datadir)/newlisp/util/syntax.cgi
+	-install -m 644 util/newlisp.vim $(datadir)/newlisp/util/newlisp.vim
+	-install -m 644 doc/COPYING $(datadir)/doc/newlisp/COPYING
+	-install -m 644 doc/CREDITS $(datadir)/doc/newlisp/CREDITS
+	-install -m 644 doc/newlisp_manual.html $(datadir)/doc/newlisp/newlisp_manual.html
+	-install -m 644 doc/newlisp_index.html $(datadir)/doc/newlisp/newlisp_index.html
+	-install -m 644 doc/manual_frame.html $(datadir)/doc/newlisp/manual_frame.html
+	-install -m 644 doc/CodePatterns.html $(datadir)/doc/newlisp/CodePatterns.html
+	-install -m 644 doc/newLISPdoc.html $(datadir)/doc/newlisp/newLISPdoc.html
+	-install -m 644 doc/newLISP-$(VERSION)-Release.html $(datadir)/doc/newlisp/newLISP-$(VERSION)-Release.html
+	-install -m 644 doc/newlisp.1 $(mandir)/man1/newlisp.1
+	-install -m 644 doc/newlispdoc.1 $(mandir)/man1/newlispdoc.1
+	-install -m 644 modules/canvas.lsp $(datadir)/newlisp/modules/canvas.lsp
+	-install -m 644 modules/cgi.lsp $(datadir)/newlisp/modules/cgi.lsp
+	-install -m 644 modules/crypto.lsp $(datadir)/newlisp/modules/crypto.lsp
+	-install -m 644 modules/ftp.lsp $(datadir)/newlisp/modules/ftp.lsp
+	-install -m 644 modules/getopts.lsp $(datadir)/newlisp/modules/getopts.lsp
+	-install -m 644 modules/gsl.lsp $(datadir)/newlisp/modules/gsl.lsp
+	-install -m 644 modules/infix.lsp $(datadir)/newlisp/modules/infix.lsp
+	-install -m 644 modules/mysql.lsp $(datadir)/newlisp/modules/mysql.lsp
+	-install -m 644 modules/odbc.lsp $(datadir)/newlisp/modules/odbc.lsp
+	-install -m 644 modules/plot.lsp $(datadir)/newlisp/modules/plot.lsp
+	-install -m 644 modules/pop3.lsp $(datadir)/newlisp/modules/pop3.lsp
+	-install -m 644 modules/postgres.lsp $(datadir)/newlisp/modules/postgres.lsp
+	-install -m 644 modules/postscript.lsp $(datadir)/newlisp/modules/postscript.lsp
+	-install -m 644 modules/smtp.lsp $(datadir)/newlisp/modules/smtp.lsp
+	-install -m 644 modules/smtpx.lsp $(datadir)/newlisp/modules/smtpx.lsp
+	-install -m 644 modules/sqlite3.lsp $(datadir)/newlisp/modules/sqlite3.lsp
+	-install -m 644 modules/stat.lsp $(datadir)/newlisp/modules/stat.lsp
+	-install -m 644 modules/unix.lsp $(datadir)/newlisp/modules/unix.lsp
+	-install -m 644 modules/xmlrpc-client.lsp $(datadir)/newlisp/modules/xmlrpc-client.lsp
+	-install -m 644 modules/zlib.lsp $(datadir)/newlisp/modules/zlib.lsp
+	# GUI-Server install
+	-install -d $(datadir)/newlisp/guiserver
+	-install -d $(datadir)/doc/newlisp/guiserver
+	-install -m 755 guiserver/newlisp-edit.lsp $(bindir)/newlisp-edit
+	-install -m 644 guiserver/guiserver.jar $(datadir)/newlisp/guiserver.jar
+	-install -m 644 guiserver/guiserver.lsp $(datadir)/newlisp/guiserver.lsp
+	-install -m 644 guiserver/images/newLISP128.png $(datadir)/newlisp/newLISP128.png
+	-install -m 644 guiserver/COPYING $(datadir)/doc/newlisp/guiserver/COPYING
+	-install -m 644 guiserver/index-gs.html $(datadir)/doc/newlisp/guiserver/index-gs.html
+	-install -m 644 guiserver/guiserver.lsp.html $(datadir)/doc/newlisp/guiserver/guiserver.lsp.html
+	-install -m 644 util/newlispdoc.css $(datadir)/doc/newlisp/guiserver/newlispdoc.css
+	-install -m 644 guiserver/allfonts-demo.lsp $(datadir)/newlisp/guiserver/allfonts-demo.lsp
+	-install -m 644 guiserver/animation-demo.lsp $(datadir)/newlisp/guiserver/animation-demo.lsp
+	-install -m 644 guiserver/border-layout-demo.lsp $(datadir)/newlisp/guiserver/border-layout-demo.lsp
+	-install -m 644 guiserver/button-demo.lsp $(datadir)/newlisp/guiserver/button-demo.lsp
+	-install -m 644 guiserver/clipboard-demo.lsp $(datadir)/newlisp/guiserver/clipboard-demo.lsp
+	-install -m 644 guiserver/cursor-demo.lsp $(datadir)/newlisp/guiserver/cursor-demo.lsp
+	-install -m 644 guiserver/drag-demo.lsp $(datadir)/newlisp/guiserver/drag-demo.lsp
+	-install -m 644 guiserver/font-demo.lsp $(datadir)/newlisp/guiserver/font-demo.lsp
+	-install -m 644 guiserver/frameless-demo.lsp $(datadir)/newlisp/guiserver/frameless-demo.lsp
+	-install -m 644 guiserver/html-demo.lsp $(datadir)/newlisp/guiserver/html-demo.lsp
+	-install -m 644 guiserver/image-demo.lsp $(datadir)/newlisp/guiserver/image-demo.lsp
+	-install -m 644 guiserver/midi-demo.lsp $(datadir)/newlisp/guiserver/midi-demo.lsp
+	-install -m 644 guiserver/midi2-demo.lsp $(datadir)/newlisp/guiserver/midi2-demo.lsp
+	-install -m 644 guiserver/mouse-demo.lsp $(datadir)/newlisp/guiserver/mouse-demo.lsp
+	-install -m 644 guiserver/move-resize-demo.lsp $(datadir)/newlisp/guiserver/move-resize-demo.lsp
+	-install -m 644 guiserver/pinballs-demo.lsp $(datadir)/newlisp/guiserver/pinballs-demo.lsp
+	-install -m 644 guiserver/properties-demo.lsp $(datadir)/newlisp/guiserver/properties-demo.lsp
+	-install -m 644 guiserver/rotation-demo.lsp $(datadir)/newlisp/guiserver/rotation-demo.lsp
+	-install -m 644 guiserver/scroll-pane-demo.lsp $(datadir)/newlisp/guiserver/scroll-pane-demo.lsp
+	-install -m 644 guiserver/shapes-demo.lsp $(datadir)/newlisp/guiserver/shapes-demo.lsp
+	-install -m 644 guiserver/sound-demo.lsp $(datadir)/newlisp/guiserver/sound-demo.lsp
+	-install -m 644 guiserver/stroke-demo.lsp $(datadir)/newlisp/guiserver/stroke-demo.lsp
+	-install -m 644 guiserver/tabs-demo.lsp $(datadir)/newlisp/guiserver/tabs-demo.lsp
+	-install -m 644 guiserver/table-demo.lsp $(datadir)/newlisp/guiserver/table-demo.lsp
+	-install -m 644 guiserver/textrot-demo.lsp $(datadir)/newlisp/guiserver/textrot-demo.lsp
+	-install -m 644 guiserver/widgets-demo.lsp $(datadir)/newlisp/guiserver/widgets-demo.lsp
+	-install -m 644 guiserver/word-count.lsp $(datadir)/newlisp/guiserver/word-count.lsp
+	-install -m 644 guiserver/uppercase.lsp $(datadir)/newlisp/guiserver/uppercase.lsp
+
+	# get OS X applications package
+	sudo cp -R /Applications/newLISP-GS.app/ $(appdir)/newLISP-GS.app
+	# make and fill image directory
+	-mkdir newLISP-image
+	cp doc/newLISP-$(VERSION)-Release.html newLISP-image/
+	cp util/newLISP-OSX-README.rtf newLISP-image/
+	cp util/uninstall.command newLISP-image/
+	pkgbuild --identifier com.nuevatec.newlisp.newlisp.pkg --version $(VERSION) \
+		--root Package_contents newLISP-image/newLISPpackage.pkg
+
+# eof
+
diff --git a/makefile_darwin_universal_utf8_compat b/makefile_darwin_universal_utf8_compat
new file mode 100644
index 0000000..23a04b5
--- /dev/null
+++ b/makefile_darwin_universal_utf8_compat
@@ -0,0 +1,47 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline support
+# thanks to Greg Slepak for configuring this makefile
+#
+# for OS X 10.4/Tiger, Tiger comes standard with libreadline
+#
+# needs readline library and headerfiles installed (X tools)
+# use the Mac OS X lipo utitlity to extract one or the other ppc/intel
+# example: lipo newlisp-universal -output newlisp-ppc -thin ppc7400
+# note: architecture id for ppc on Tiger: ppc on Leopard: ppc7400
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+# NOTE: To run this makefile you must be using 10.5
+#       or later with the 10.4 SDK installed!
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+# it's possible to make it work on all systems by reading in
+# and parsing the value for ProductVersion in this file:
+#
+#     /System/Library/CoreServices/SystemVersion.plist
+
+# this does not seem necessary (but if there are problems try uncommenting it)
+# export MACOSX_DEPLOYMENT_TARGET=10.4
+
+# to run on 10.4 we must use gcc-4.0
+CC = /usr/bin/gcc-4.0
+SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk
+
+# additional CFLAGS not needed if CC path is set correctly
+# -I$(SDKROOT)/usr/lib/gcc/powerpc-apple-darwin8/4.0.1/include 
+# -I$(SDKROOT)/usr/lib/gcc/i686-apple-darwin8/4.0.1/include/
+
+CFLAGS = -Wall -arch i386 -arch ppc -Os -c -g -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -isysroot $(SDKROOT) 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+default: $(OBJS)
+	$(CC) $(OBJS) -mmacosx-version-min=10.4 -arch i386 -arch ppc -g -lm -lreadline -o newlisp-universal
+	strip newlisp-universal
+#   lipo newlisp-universal -output newlisp-intel -thin i386
+#   lipo newlisp-universal -output newlisp-ppc -thin ppc
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_universal_utf8_compat
+
diff --git a/makefile_darwin_utf8 b/makefile_darwin_utf8
new file mode 100644
index 0000000..0be629e
--- /dev/null
+++ b/makefile_darwin_utf8
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline  and UTF-8 support
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o
+
+CFLAGS = -m32 -Wall -O1 -c -DREADLINE -DMAC_OSX -DSUPPORT_UTF8
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8
+
+
diff --git a/makefile_darwin_utf8_ffi b/makefile_darwin_utf8_ffi
new file mode 100644
index 0000000..9431872
--- /dev/null
+++ b/makefile_darwin_utf8_ffi
@@ -0,0 +1,23 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline, UTF-8, FFI support
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o
+
+CFLAGS = -m32 -Wall -O1 -c -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DFFI
+
+CC = cc
+#CC = gcc 
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -lffi -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8_ffi
+
+
diff --git a/makefile_darwin_utf8_leopardIntel b/makefile_darwin_utf8_leopardIntel
new file mode 100644
index 0000000..6cbebd2
--- /dev/null
+++ b/makefile_darwin_utf8_leopardIntel
@@ -0,0 +1,30 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline support INTEL
+#
+# for OS X 10.5/Leopard on INTEL
+#
+# developer tools 10.5 or later required
+
+# this does not seem necessary (but if there are problems try uncommenting it)
+# export MACOSX_DEPLOYMENT_TARGET=10.4
+
+# to run on 10.4 we must use gcc-4.0
+#CC = /usr/bin/gcc-4.0
+#SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk
+
+CC = /usr/bin/gcc-4.2
+SDKROOT = /Developer/SDKs/MacOSX10.5.sdk
+
+CFLAGS = -Wall -arch i386 -Os -c -g -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -isysroot $(SDKROOT) 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+default: $(OBJS)
+	$(CC) $(OBJS) -mmacosx-version-min=10.5 -arch i386 -g -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8_leopardIntel
+
diff --git a/makefile_darwin_utf8_leopardIntel_ffi b/makefile_darwin_utf8_leopardIntel_ffi
new file mode 100644
index 0000000..7379f0a
--- /dev/null
+++ b/makefile_darwin_utf8_leopardIntel_ffi
@@ -0,0 +1,30 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline support INTEL and FFI
+#
+# for OS X 10.5/Leopard on INTEL
+#
+# developer tools 10.5 or later required
+
+# this does not seem necessary (but if there are problems try uncommenting it)
+# export MACOSX_DEPLOYMENT_TARGET=10.4
+
+# to run on 10.4 we must use gcc-4.0
+#CC = /usr/bin/gcc-4.0
+#SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk
+
+CC = /usr/bin/gcc-4.2
+SDKROOT = /Developer/SDKs/MacOSX10.5.sdk
+
+CFLAGS = -Wall -arch i386 -Os -c -g -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DFFI -isysroot $(SDKROOT) 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+default: $(OBJS)
+	$(CC) $(OBJS) -mmacosx-version-min=10.5 -arch i386 -g -lm -lreadline -lffi -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8_leopardIntel_ffi
+
diff --git a/makefile_darwin_utf8_leopardPPC b/makefile_darwin_utf8_leopardPPC
new file mode 100644
index 0000000..0c423b4
--- /dev/null
+++ b/makefile_darwin_utf8_leopardPPC
@@ -0,0 +1,35 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline support PPC
+#
+# for minimum OS X 10.5/Leopard on PPC
+#
+# needs readline library and headerfiles installed (X tools)
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+# NOTE: To run this makefile you must be using 10.5
+#       or later with the 10.4 SDK installed!
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+# this does not seem necessary (but if there are problems try uncommenting it)
+# export MACOSX_DEPLOYMENT_TARGET=10.4
+
+# to run on 10.4 we must use gcc-4.0
+#CC = /usr/bin/gcc-4.0
+CC = /usr/bin/gcc-4.2
+
+# SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk
+SDKROOT = /Developer/SDKs/MacOSX10.5.sdk
+
+CFLAGS = -Wall -arch ppc -Os -c -g -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -isysroot $(SDKROOT) 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+default: $(OBJS)
+	$(CC) $(OBJS) -mmacosx-version-min=10.5 -arch ppc -g -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8_leopardPPC
+
diff --git a/makefile_darwin_utf8_leopardPPC_ffi b/makefile_darwin_utf8_leopardPPC_ffi
new file mode 100644
index 0000000..3757073
--- /dev/null
+++ b/makefile_darwin_utf8_leopardPPC_ffi
@@ -0,0 +1,35 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline support PPC and FFI
+#
+# for minimum OS X 10.5/Leopard on PPC
+#
+# needs readline library and headerfiles installed (X tools)
+
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+# NOTE: To run this makefile you must be using 10.5
+#       or later with the 10.4 SDK installed!
+# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+# this does not seem necessary (but if there are problems try uncommenting it)
+# export MACOSX_DEPLOYMENT_TARGET=10.4
+
+# to run on 10.4 we must use gcc-4.0
+#CC = /usr/bin/gcc-4.0
+CC = /usr/bin/gcc-4.2
+
+# SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk
+SDKROOT = /Developer/SDKs/MacOSX10.5.sdk
+
+CFLAGS = -m32 -Wall -arch ppc -Os -c -g -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DFFI -isysroot $(SDKROOT) 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -mmacosx-version-min=10.5 -arch ppc -g -lm -lreadline -lffi -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8_leopardPPC_ffi
+
diff --git a/makefile_darwin_utf8_lib b/makefile_darwin_utf8_lib
new file mode 100644
index 0000000..be4355b
--- /dev/null
+++ b/makefile_darwin_utf8_lib
@@ -0,0 +1,21 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline  and UTF-8 support
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o unix-lib.o
+
+CFLAGS = -m32 -Wall -O1 -c -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DLIBRARY
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -bundle -o newlisp.dylib
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin_utf8_lib
+
+
diff --git a/makefile_emscripten_lib_utf8 b/makefile_emscripten_lib_utf8
new file mode 100644
index 0000000..b3ec177
--- /dev/null
+++ b/makefile_emscripten_lib_utf8
@@ -0,0 +1,41 @@
+# makefile for newLISP v. 10.5.x and after with UTF8 support for the Emscripten SDK
+#
+# With Emscripten version v1.22.0 all execption handling related problems
+# known have been solved. (November 2014)
+#
+# see also: https://github.com/kripken/emscripten/wiki
+#
+# Uses custom random() and srandom() in nl-filesys.c
+#
+# Does not implement the newLISP functions:
+#   semaphore, net-packet, net-service, fork, spawn, sync, abort
+#
+# Will not do file and network I/O functions in the sandboxed JavaScript 
+# environment
+#
+# Generates newlisp-js-lib.js and newlisp-js-lib.html.
+# The html file can be discarded use newlisp-js/newlisp-js.html instead
+#
+# this makefile has been tested on a MAC OSX 10.9/10 platforms
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-web.o nl-xml-json.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o unix-lib.o
+
+CFLAGS = -m32 -Wall -c -DMAC_OSX -DLIBRARY -DEMSCRIPTEN  -DSUPPORT_UTF8
+
+CC = emcc
+
+default: $(OBJS)
+	cp qa-specific-tests/qa-bench newlisp-js
+	cp modules/canvas.lsp newlisp-js
+	$(CC) $(OBJS) -m32 -O2 -o newlisp-js-lib.html -s EXPORTED_FUNCTIONS="['_newlispEvalStr']" \
+	-s MAX_SETJMPS=100 -s TOTAL_MEMORY=33554432 --closure 1 \
+	--embed-file newlisp-js/readme.txt --embed-file newlisp-js/qa-bench --embed-file newlisp-js/canvas.lsp
+	rm newlisp-js/qa-bench newlisp-js/canvas.lsp
+
+.c.o:
+	$(CC) -O2 --closure 1 $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_emscripten_lib_utf8
+
+
diff --git a/makefile_linux b/makefile_linux
new file mode 100644
index 0000000..5ef676a
--- /dev/null
+++ b/makefile_linux
@@ -0,0 +1,25 @@
+# makefile for newLISP v.10.x.x on LINUX with readline support
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+#CFLAGS = -m32 -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DLINUX
+CFLAGS = -m32 -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DLINUX 
+
+CC = gcc
+
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux
+
diff --git a/makefile_linuxLP64 b/makefile_linuxLP64
new file mode 100644
index 0000000..3b100b0
--- /dev/null
+++ b/makefile_linuxLP64
@@ -0,0 +1,23 @@
+# makefile for newLISP 64bit v.10.x.x on 64 bit LINUX tested on Intel Core Duo 2
+#
+# Note, that readline support may require different libraries on different OSs
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -fPIC -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DNEWLISP64 -DLINUX
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linuxLP64
diff --git a/makefile_linuxLP64_ffi b/makefile_linuxLP64_ffi
new file mode 100644
index 0000000..b3bb23b
--- /dev/null
+++ b/makefile_linuxLP64_ffi
@@ -0,0 +1,23 @@
+# makefile for newLISP 64bit v.10.x.x on 64 bit LINUX tested on Intel Core Duo 2
+# and FFI
+# Note, that readline support may require different libraries on different OSs
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -fPIC -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DNEWLISP64 -DLINUX -DFFI -I/usr/local/lib/libffi-3.0.13/include 
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lffi -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linuxLP64_ffi
diff --git a/makefile_linuxLP64_lib b/makefile_linuxLP64_lib
new file mode 100644
index 0000000..dde5f65
--- /dev/null
+++ b/makefile_linuxLP64_lib
@@ -0,0 +1,20 @@
+# makefile for newLISP 64bit v.10.x.x on 64 bit LINUX tested on Intel Dual Core 2 as a shared library
+#
+# Note, that readline support may require different libraries on different OSs
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o unix-lib.o
+
+CFLAGS = -fPIC -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DLINUX -DNEWLISP64 -DLIBRARY
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -shared -o newlisp.so
+	strip newlisp.so
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linuxLP64_lib
diff --git a/makefile_linuxLP64_redhat_utf8_ffi b/makefile_linuxLP64_redhat_utf8_ffi
new file mode 100644
index 0000000..1f4bf21
--- /dev/null
+++ b/makefile_linuxLP64_redhat_utf8_ffi
@@ -0,0 +1,21 @@
+# makefile for newLISP 64bit UTF-8 v.10.x.x on 64 bit on LINUX RedHat CentOS with FFI
+#
+# don't use this make file directly. Use ./configure to detect and replace the correct
+# libffi version oer define LIBFFI_VERSION in the OS environment.
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -fPIC -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DNEWLISP64 -DLINUX -DFFI -ILIBFFI_VERSION
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lffi -o newlisp # for RedHat CentOS
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linuxLP64_redhat_utf8_ffi
+
diff --git a/makefile_linuxLP64_utf8 b/makefile_linuxLP64_utf8
new file mode 100644
index 0000000..f5fd1a9
--- /dev/null
+++ b/makefile_linuxLP64_utf8
@@ -0,0 +1,23 @@
+# makefile for newLISP 64bit UTF-8 v.10.x.x on 64 bit LINUX tested on Intel Core Duo 2
+#
+# Note, that readline support may require different libraries on different OSs
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -fPIC -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DNEWLISP64 -DLINUX
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linuxLP64_utf8
diff --git a/makefile_linuxLP64_utf8_ffi b/makefile_linuxLP64_utf8_ffi
new file mode 100644
index 0000000..d7d6446
--- /dev/null
+++ b/makefile_linuxLP64_utf8_ffi
@@ -0,0 +1,26 @@
+# makefile for newLISP 64bit UTF-8 v.10.x.x on 64 bit LINUX tested on Intel Core Duo 2
+# and FFI
+# Note, that readline support may require different libraries on different OSs
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -fPIC -m64 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DNEWLISP64 -DLINUX -DFFI -I/usr/local/lib/libffi-3.0.13/include 
+
+# replace -O2 with -Oz when using clang/llvm
+#CC = clang 
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lffi -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m64 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linuxLP64_utf8_ffi
diff --git a/makefile_linux_ffi b/makefile_linux_ffi
new file mode 100644
index 0000000..9d985aa
--- /dev/null
+++ b/makefile_linux_ffi
@@ -0,0 +1,25 @@
+# makefile for newLISP v.10.x.x on LINUX with readline support and FFI
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m32 -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DLINUX -DFFI -I/usr/local/lib/libffi-3.0.13/include 
+
+CC = gcc
+
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lffi -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_ffi
+
diff --git a/makefile_linux_lib b/makefile_linux_lib
new file mode 100644
index 0000000..12623ce
--- /dev/null
+++ b/makefile_linux_lib
@@ -0,0 +1,23 @@
+# makefile for newLISP v.10.x.x on LINUX as a shared library - newlisp.so -
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o unix-lib.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -DLINUX -DLIBRARY
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -ldl -shared -o newlisp.so
+	strip newlisp.so
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_lib
+
+
+
diff --git a/makefile_linux_lib_utf8 b/makefile_linux_lib_utf8
new file mode 100644
index 0000000..dfa171f
--- /dev/null
+++ b/makefile_linux_lib_utf8
@@ -0,0 +1,23 @@
+# makefile for newLISP v.10.x.x on LINUX as a shared library - newlisp.so -
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o unix-lib.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -DLIBRARY -DSUPPORT_UTF8 -DLINUX
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -ldl -shared -o newlisp.so
+	strip newlisp.so
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_lib_utf8
+
+
+
diff --git a/makefile_linux_maemo_utf8 b/makefile_linux_maemo_utf8
new file mode 100644
index 0000000..29ccae4
--- /dev/null
+++ b/makefile_linux_maemo_utf8
@@ -0,0 +1,26 @@
+# makefile for newLISP v.10.x.x on MAEMO ARMEL LINUX with readline support
+# Note, that readline support may require different libraries on different OSs
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+#CFLAGS = -Wall -Wno-uninitialized -c -O2 -g -DLINUX
+CFLAGS = -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DLINUX
+
+CC = gcc
+
+
+default: $(OBJS)
+	$(CC) $(OBJS) -g -lm -ldl -lreadline -o newlisp # for UBUNTU Debian
+#    $(CC) $(OBJS) -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#    $(CC) $(OBJS) -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#    $(CC) $(OBJS) -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_maemo_utf8
+
+
diff --git a/makefile_linux_openwrt b/makefile_linux_openwrt
new file mode 100644
index 0000000..925fbe3
--- /dev/null
+++ b/makefile_linux_openwrt
@@ -0,0 +1,27 @@
+# makefile for newLISP v.10.x.x on Openwrt LINUX without readline support
+# contributed by dexter (see newLISP Forum)
+# upx is used to compress 
+# no readline support, add -DSUPPORT_UTF8 to CFLAGS for UTF8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -Wall -Wl,--gc-sections  -ffunction-sections -fdata-sections  -c -Os  -fno-threadsafe-statics  -DLINUX -I$(TARGET_DIR)/usr/include/
+LDFLAGS = -L$(TARGET_DIR)/usr/lib/  -W1,--gc-sections -lm -ldl
+CC = mips-openwrt-linux-gcc
+LD = mips-openwrt-linux-ld
+
+
+default: $(OBJS)
+	$(CC) $(OBJS)  -o newlisp $(LDFLAGS)   #for openwrt
+	$(STRIP) newlisp
+	upx --best -o newlisp_s newlisp
+	rm newlisp
+	mv newlisp_s newlisp
+
+.c.o:
+   	$(CC) $(CFLAGS) $<
+	$(OBJS): primes.h protos.h makefile_linux_openwrt
+
+
diff --git a/makefile_linux_redhat_utf8_ffi b/makefile_linux_redhat_utf8_ffi
new file mode 100644
index 0000000..fe61157
--- /dev/null
+++ b/makefile_linux_redhat_utf8_ffi
@@ -0,0 +1,23 @@
+# makefile for newLISP v.10.x.x on LINUX RedHat CentOS with readline, UTF-8, FFI support
+#
+# don't use this make file directly. Use ./configure to detect and replace the correct
+# libffi version
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -m32 -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DLINUX -DFFI -ILIBFFI_VERSION
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lffi -o newlisp # for RedHat CentOS 
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_redhat_utf8_ffi
+
+
+
diff --git a/makefile_linux_utf8 b/makefile_linux_utf8
new file mode 100644
index 0000000..bfcadd9
--- /dev/null
+++ b/makefile_linux_utf8
@@ -0,0 +1,26 @@
+# makefile for newLISP v.10.x.x on LINUX with readline and UTF-8 support
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -m32 -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DLINUX
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_utf8
+
+
+
diff --git a/makefile_linux_utf8_ffi b/makefile_linux_utf8_ffi
new file mode 100644
index 0000000..9b020e7
--- /dev/null
+++ b/makefile_linux_utf8_ffi
@@ -0,0 +1,26 @@
+# makefile for newLISP v.10.x.x on LINUX with readline, UTF-8, FFI support
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -fPIC -m32 -Wall -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DREADLINE -DSUPPORT_UTF8 -DLINUX -DFFI -I/usr/local/lib/libffi-3.0.13/include
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lffi -o newlisp # for UBUNTU Debian
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -ltermcap -o newlisp # slackware
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -lreadline -lncurses -o newlisp # other Linux Dist
+#	$(CC) $(OBJS) -m32 -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_linux_utf8_ffi
+
+
+
diff --git a/makefile_mingw b/makefile_mingw
new file mode 100644
index 0000000..4e30c76
--- /dev/null
+++ b/makefile_mingw
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on MinGW
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o
+
+CFLAGS = -m32 -Wall -c -O1 -g -DWINDOWS
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m32 $(OBJS) -lws2_32 -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw
+
+
diff --git a/makefile_mingw64 b/makefile_mingw64
new file mode 100644
index 0000000..bdd1f7f
--- /dev/null
+++ b/makefile_mingw64
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Windows with 64-bit
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o  \
+	win-util.o win-path.o
+
+CFLAGS = -m64 -Wall -c -O1 -g -DNEWLISP64 -DWINDOWS
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m64 $(OBJS) -lws2_32 -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw64
+
+
diff --git a/makefile_mingw64_ffi b/makefile_mingw64_ffi
new file mode 100644
index 0000000..0a650ec
--- /dev/null
+++ b/makefile_mingw64_ffi
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Windows with FFI 64-bit
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o
+
+CFLAGS = -m64 -Wall -c -O1 -g -DNEWLISP64 -DWINDOWS -DFFI 
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m64 $(OBJS) -lws2_32 -lffi -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw64_ffi
+
+
diff --git a/makefile_mingw64_utf8 b/makefile_mingw64_utf8
new file mode 100644
index 0000000..12a90b4
--- /dev/null
+++ b/makefile_mingw64_utf8
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Windows with UTF8  64-bit
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o  \
+	nl-utf8.o win-util.o win-path.o
+
+CFLAGS = -m64 -Wall -c -O1 -g -DNEWLISP64 -DWINDOWS -DSUPPORT_UTF8 
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m64 $(OBJS) -lws2_32 -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw64_utf8
+
+
diff --git a/makefile_mingw64_utf8_ffi b/makefile_mingw64_utf8_ffi
new file mode 100644
index 0000000..f036cae
--- /dev/null
+++ b/makefile_mingw64_utf8_ffi
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Windows with UTF8 FFI 64-bit
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o  \
+	nl-utf8.o win-util.o win-path.o
+
+CFLAGS = -m64 -Wall -c -O1 -g -DNEWLISP64 -DWINDOWS -DSUPPORT_UTF8 -DFFI
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m64 $(OBJS) -lws2_32 -lffi -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw64_utf8_ffi
+
+
diff --git a/makefile_mingw64dll b/makefile_mingw64dll
new file mode 100644
index 0000000..0ad5f55
--- /dev/null
+++ b/makefile_mingw64dll
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on Windows DLL LLP64 64-bit
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m64 -Wall -c -O1 -DNEWLISP64 -DWINDOWS -DLIBRARY 
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m64 -shared *.o -Wl,--output-def win64-dll.def -lws2_32 -o newlisp.dll 
+	$(CC) -m64 -shared *.o -Wl,--kill-at -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingw64dll
+
+
diff --git a/makefile_mingw64dll_ffi b/makefile_mingw64dll_ffi
new file mode 100644
index 0000000..1cb64b5
--- /dev/null
+++ b/makefile_mingw64dll_ffi
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on MinGW DLL and FFI 64-bit
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m64 -Wall -c -O1 -DLIBRARY -DFFI -DWINDOWS
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m64 -shared *.o -Wl,--output-def win64-dll.def -lffi -lws2_32 -o newlisp.dll 
+	$(CC) -m64 -shared *.o -Wl,--kill-at -lffi -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingw64dll_ffi
+
+
diff --git a/makefile_mingw64dll_utf8 b/makefile_mingw64dll_utf8
new file mode 100644
index 0000000..8563bc9
--- /dev/null
+++ b/makefile_mingw64dll_utf8
@@ -0,0 +1,24 @@
+# makefile for newLISP 64-bit v. 10.x.x on MinGW DLL with UTF-8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m64 -Wall -c -O1 -DLIBRARY -DSUPPORT_UTF8 -DNEWLISP64 -DWINDOWS
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m64 -shared *.o -Wl,--output-def win64-dll.def -lws2_32 -o newlisp.dll 
+	$(CC) -m64 -shared *.o -Wl,--kill-at -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingw64dll_utf8
+
+
diff --git a/makefile_mingw64dll_utf8_ffi b/makefile_mingw64dll_utf8_ffi
new file mode 100644
index 0000000..9119f1a
--- /dev/null
+++ b/makefile_mingw64dll_utf8_ffi
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on Windows DLL FFI UTF8 LLP64 
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m64 -Wall -c -O1 -DNEWLISP64 -DWINDOWS -DSUPPORT_UTF8 -DFFI -DLIBRARY 
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m64 -shared *.o -Wl,--output-def win64-dll.def -lffi -lws2_32 -o newlisp.dll 
+	$(CC) -m64 -shared *.o -Wl,--kill-at -lffi -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingw64dll_utf8_ffi
+
+
diff --git a/makefile_mingw_ffi b/makefile_mingw_ffi
new file mode 100644
index 0000000..d3bed84
--- /dev/null
+++ b/makefile_mingw_ffi
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on MinGW with FFI
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o
+
+CFLAGS = -m32 -Wall -c -O1 -g -DWINDOWS -DFFI
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m32 $(OBJS) -lws2_32 -lffi -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw_ffi
+
+
diff --git a/makefile_mingw_utf8 b/makefile_mingw_utf8
new file mode 100644
index 0000000..c303669
--- /dev/null
+++ b/makefile_mingw_utf8
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on MinGW with UTF-8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	nl-utf8.o win-util.o win-path.o
+
+CFLAGS = -m32 -Wall -c -O1 -g -DWINDOWS -DSUPPORT_UTF8 
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m32 $(OBJS) -lws2_32 -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw_utf8
+
+
diff --git a/makefile_mingw_utf8_ffi b/makefile_mingw_utf8_ffi
new file mode 100644
index 0000000..bde5b78
--- /dev/null
+++ b/makefile_mingw_utf8_ffi
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on MinGW with UTF-8 support and FFI
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	nl-utf8.o win-util.o win-path.o
+
+CFLAGS = -m32 -Wall -c -O1 -DSUPPORT_UTF8 -DWINDOWS -DFFI
+
+CC = gcc
+STRIP = strip
+
+default: $(OBJS)
+	$(CC) -m32 $(OBJS) -lws2_32 -lffi -o newlisp.exe
+	$(STRIP) newlisp.exe 
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h newlisp.h makefile_mingw_utf8_ffi
+
+
diff --git a/makefile_mingwdll b/makefile_mingwdll
new file mode 100644
index 0000000..851372d
--- /dev/null
+++ b/makefile_mingwdll
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on MinGW DLL 
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m32 -Wall -c -O1 -DLIBRARY -DWINDOWS
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m32 -shared *.o -Wl,--output-def win-dll.def -lws2_32 -o newlisp.dll 
+	$(CC) -m32 -shared *.o -Wl,--kill-at -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingwdll
+
+
diff --git a/makefile_mingwdll_ffi b/makefile_mingwdll_ffi
new file mode 100644
index 0000000..439732f
--- /dev/null
+++ b/makefile_mingwdll_ffi
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on MinGW DLL and FFI
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m32 -Wall -c -O1 -DLIBRARY -DFFI -DWINDOWS
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+	$(CC) -m32 -shared *.o -Wl,--output-def win-dll.def -lffi -lws2_32 -o newlisp.dll 
+	$(CC) -m32 -shared *.o -Wl,--kill-at -lffi -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingwdll_ffi
+
+
diff --git a/makefile_mingwdll_utf8 b/makefile_mingwdll_utf8
new file mode 100644
index 0000000..1edef6e
--- /dev/null
+++ b/makefile_mingwdll_utf8
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on MinGW DLL UTF8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m32 -Wall -c -O1 -DLIBRARY -DWINDOWS
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m32 -shared *.o -Wl,--output-def win-dll.def -lws2_32 -o newlisp.dll 
+	$(CC) -m32 -shared *.o -Wl,--kill-at -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingwdll_utf8
+
+
diff --git a/makefile_mingwdll_utf8_ffi b/makefile_mingwdll_utf8_ffi
new file mode 100644
index 0000000..a9db0fc
--- /dev/null
+++ b/makefile_mingwdll_utf8_ffi
@@ -0,0 +1,24 @@
+# makefile for newLISP  DLL v. 10.x.x on MinGW DLL with FFI and UTF8 support
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o \
+	win-util.o win-path.o win-dll.o
+
+CFLAGS = -m32 -Wall -c -O1 -DLIBRARY -DSUPPORT_UTF8 -DFFI -DWINDOWS
+
+CC = gcc
+STRIP = strip
+WRAP = dllwrap
+
+default: $(OBJS)
+#	$(CC) -m32 -shared *.o -Wl,--output-def win-dll.def -lffi -lws2_32 -o newlisp.dll 
+	$(CC) -m32 -shared *.o -Wl,--kill-at -lffi -lws2_32 -o newlisp.dll 
+	$(STRIP) newlisp.dll
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_mingwdll_utf8_ffi
+
+
diff --git a/makefile_netbsd b/makefile_netbsd
new file mode 100644
index 0000000..15980be
--- /dev/null
+++ b/makefile_netbsd
@@ -0,0 +1,24 @@
+# makefile for newLISP v. 10.x.x on BSDs: NetBsd
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -O2 -c -g -DREADLINE -D_BSD
+# without readline support
+#CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -O2 -c -g -D_BSD
+
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -g -lm -lreadline -lncurses -o newlisp
+# to compile wihtout readline support 
+#	$(CC) $(OBJS) -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_netbsd
+
diff --git a/makefile_netbsd_utf8 b/makefile_netbsd_utf8
new file mode 100644
index 0000000..0487c77
--- /dev/null
+++ b/makefile_netbsd_utf8
@@ -0,0 +1,24 @@
+# makefile for newLISP v. 10.x.x on BSDs: NetBsd
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+# for readline support use following line
+CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -O2 -c -g -DREADLINE -DSUPPORT_UTF8 -D_BSD
+# without readline support
+#CFLAGS = -m32 -Wall -Wno-uninitialized -Wno-strict-aliasing -O2 -c -g -DSUPPORT_UTF8 -D_BSD
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -g -lm -lreadline -lncurses -o newlisp
+# without readline support
+#	$(CC) $(OBJS) -g -lm -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_netbsd_utf8
+
diff --git a/makefile_opensolaris b/makefile_opensolaris
new file mode 100644
index 0000000..ccb35e8
--- /dev/null
+++ b/makefile_opensolaris
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on SOLARIS (32 bit app)
+#
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m32 -Wall -pedantic -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -c -O2 -DSOLARIS 
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -lm -ldl -lrt -lsocket -lnsl -o newlisp
+	@echo ""
+	@echo "do not use 'make install' install files manually; see Makefile for details"
+	@echo "for a minimum install just put newlisp into /usr/bin/newlisp
+	@echo ""
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_solaris
diff --git a/makefile_original_install b/makefile_original_install
new file mode 100644
index 0000000..1801aa2
--- /dev/null
+++ b/makefile_original_install
@@ -0,0 +1,181 @@
+#
+
+VERSION=10.7.0
+
+# NOTE when changing PREFIX, then newlisp should only run
+# run in an environment, where NEWLISPDIR is predefined,
+# else NEWLISPDIR will be defined during newlisp startup
+# as /usr/share/newlisp which is hardcoded in newlisp.c
+prefix=/usr/local
+datadir=$(prefix)/share
+bindir=$(prefix)/bin
+mandir=$(prefix)/share/man
+
+# if prefix is not /usr/local then several places in the file 
+# guiserver/newlisp-edit.lsp must change too
+GUISERVER = $(prefix)/share/newlisp/guiserver
+
+# this is the standard install in /usr/local/bin and /usr/local/share
+# which as to be done as 'root' with supersuser permissions
+# for an install in your home directory use make install_home
+#
+# One-line description for distribution packages: 
+# newLISP is a LISP like, general purpose scripting language. 
+#
+# Longer description for distribution packages: 
+# newLISP is a scripting language for developing web applications and programs 
+# in general and in the domains of artificial intelligence (AI) and statistics.
+
+install:
+	-install -d $(datadir)/newlisp
+	-install -d $(datadir)/newlisp/modules
+	-install -d $(datadir)/newlisp/util
+	-install -d $(datadir)/doc/newlisp
+	-rm $(bindir)/newlisp
+	-install -m 755  newlisp $(bindir)/newlisp-$(VERSION)
+	-ln -s $(bindir)/newlisp-$(VERSION) $(bindir)/newlisp
+	-install -m 755 util/newlispdoc $(bindir)/newlispdoc
+	-install -m 644 util/syntax.cgi $(datadir)/newlisp/util/syntax.cgi
+	-install -m 644 util/newlisp.vim $(datadir)/newlisp/util/newlisp.vim
+	-install -m 644 doc/COPYING $(datadir)/doc/newlisp/COPYING
+	-install -m 644 doc/CREDITS $(datadir)/doc/newlisp/CREDITS
+	-install -m 644 doc/newlisp_manual.html $(datadir)/doc/newlisp/newlisp_manual.html
+	-install -m 644 doc/newlisp_index.html $(datadir)/doc/newlisp/newlisp_index.html
+	-install -m 644 doc/manual_frame.html $(datadir)/doc/newlisp/manual_frame.html
+	-install -m 644 doc/CodePatterns.html $(datadir)/doc/newlisp/CodePatterns.html
+	-install -m 644 doc/newLISPdoc.html $(datadir)/doc/newlisp/newLISPdoc.html
+	-install -m 644 doc/newLISP-$(VERSION)-Release.html $(datadir)/doc/newlisp/newLISP-$(VERSION)-Release.html
+	-install -m 644 doc/newlisp.1 $(mandir)/man1/newlisp.1
+	-install -m 644 doc/newlispdoc.1 $(mandir)/man1/newlispdoc.1
+	-install -m 644 modules/canvas.lsp $(datadir)/newlisp/modules/canvas.lsp
+	-install -m 644 modules/cgi.lsp $(datadir)/newlisp/modules/cgi.lsp
+	-install -m 644 modules/crypto.lsp $(datadir)/newlisp/modules/crypto.lsp
+	-install -m 644 modules/ftp.lsp $(datadir)/newlisp/modules/ftp.lsp
+	-install -m 644 modules/getopts.lsp $(datadir)/newlisp/modules/getopts.lsp
+	-install -m 644 modules/gsl.lsp $(datadir)/newlisp/modules/gsl.lsp
+	-install -m 644 modules/infix.lsp $(datadir)/newlisp/modules/infix.lsp
+	-install -m 644 modules/mysql.lsp $(datadir)/newlisp/modules/mysql.lsp
+	-install -m 644 modules/odbc.lsp $(datadir)/newlisp/modules/odbc.lsp
+	-install -m 644 modules/plot.lsp $(datadir)/newlisp/modules/plot.lsp
+	-install -m 644 modules/pop3.lsp $(datadir)/newlisp/modules/pop3.lsp
+	-install -m 644 modules/postgres.lsp $(datadir)/newlisp/modules/postgres.lsp
+	-install -m 644 modules/postscript.lsp $(datadir)/newlisp/modules/postscript.lsp
+	-install -m 644 modules/smtp.lsp $(datadir)/newlisp/modules/smtp.lsp
+	-install -m 644 modules/smtpx.lsp $(datadir)/newlisp/modules/smtpx.lsp
+	-install -m 644 modules/sqlite3.lsp $(datadir)/newlisp/modules/sqlite3.lsp
+	-install -m 644 modules/stat.lsp $(datadir)/newlisp/modules/stat.lsp
+	-install -m 644 modules/unix.lsp $(datadir)/newlisp/modules/unix.lsp
+	-install -m 644 modules/xmlrpc-client.lsp $(datadir)/newlisp/modules/xmlrpc-client.lsp
+	-install -m 644 modules/zlib.lsp $(datadir)/newlisp/modules/zlib.lsp
+	# GUI-Server install
+	-install -d $(datadir)/newlisp/guiserver
+	-install -d $(datadir)/doc/newlisp/guiserver
+	-install -m 755 guiserver/newlisp-edit.lsp $(bindir)/newlisp-edit
+	-install -m 644 guiserver/guiserver.jar $(datadir)/newlisp/guiserver.jar
+	-install -m 644 guiserver/guiserver.lsp $(datadir)/newlisp/guiserver.lsp
+	-install -m 644 guiserver/images/newLISP128.png $(datadir)/newlisp/newLISP128.png
+	-install -m 644 guiserver/COPYING $(datadir)/doc/newlisp/guiserver/COPYING
+	-install -m 644 guiserver/index-gs.html $(datadir)/doc/newlisp/guiserver/index-gs.html
+	-install -m 644 guiserver/guiserver.lsp.html $(datadir)/doc/newlisp/guiserver/guiserver.lsp.html
+	-install -m 644 util/newlispdoc.css $(datadir)/doc/newlisp/guiserver/newlispdoc.css
+	-install -m 644 guiserver/allfonts-demo.lsp $(datadir)/newlisp/guiserver/allfonts-demo.lsp
+	-install -m 644 guiserver/animation-demo.lsp $(datadir)/newlisp/guiserver/animation-demo.lsp
+	-install -m 644 guiserver/border-layout-demo.lsp $(datadir)/newlisp/guiserver/border-layout-demo.lsp
+	-install -m 644 guiserver/button-demo.lsp $(datadir)/newlisp/guiserver/button-demo.lsp
+	-install -m 644 guiserver/clipboard-demo.lsp $(datadir)/newlisp/guiserver/clipboard-demo.lsp
+	-install -m 644 guiserver/cursor-demo.lsp $(datadir)/newlisp/guiserver/cursor-demo.lsp
+	-install -m 644 guiserver/drag-demo.lsp $(datadir)/newlisp/guiserver/drag-demo.lsp
+	-install -m 644 guiserver/font-demo.lsp $(datadir)/newlisp/guiserver/font-demo.lsp
+	-install -m 644 guiserver/frameless-demo.lsp $(datadir)/newlisp/guiserver/frameless-demo.lsp
+	-install -m 644 guiserver/html-demo.lsp $(datadir)/newlisp/guiserver/html-demo.lsp
+	-install -m 644 guiserver/image-demo.lsp $(datadir)/newlisp/guiserver/image-demo.lsp
+	-install -m 644 guiserver/midi-demo.lsp $(datadir)/newlisp/guiserver/midi-demo.lsp
+	-install -m 644 guiserver/midi2-demo.lsp $(datadir)/newlisp/guiserver/midi2-demo.lsp
+	-install -m 644 guiserver/mouse-demo.lsp $(datadir)/newlisp/guiserver/mouse-demo.lsp
+	-install -m 644 guiserver/move-resize-demo.lsp $(datadir)/newlisp/guiserver/move-resize-demo.lsp
+	-install -m 644 guiserver/pinballs-demo.lsp $(datadir)/newlisp/guiserver/pinballs-demo.lsp
+	-install -m 644 guiserver/properties-demo.lsp $(datadir)/newlisp/guiserver/properties-demo.lsp
+	-install -m 644 guiserver/rotation-demo.lsp $(datadir)/newlisp/guiserver/rotation-demo.lsp
+	-install -m 644 guiserver/scroll-pane-demo.lsp $(datadir)/newlisp/guiserver/scroll-pane-demo.lsp
+	-install -m 644 guiserver/shapes-demo.lsp $(datadir)/newlisp/guiserver/shapes-demo.lsp
+	-install -m 644 guiserver/sound-demo.lsp $(datadir)/newlisp/guiserver/sound-demo.lsp
+	-install -m 644 guiserver/stroke-demo.lsp $(datadir)/newlisp/guiserver/stroke-demo.lsp
+	-install -m 644 guiserver/tabs-demo.lsp $(datadir)/newlisp/guiserver/tabs-demo.lsp
+	-install -m 644 guiserver/table-demo.lsp $(datadir)/newlisp/guiserver/table-demo.lsp
+	-install -m 644 guiserver/textfield-demo.lsp $(datadir)/newlisp/guiserver/textfield-demo.lsp
+	-install -m 644 guiserver/textrot-demo.lsp $(datadir)/newlisp/guiserver/textrot-demo.lsp
+	-install -m 644 guiserver/widgets-demo.lsp $(datadir)/newlisp/guiserver/widgets-demo.lsp
+	-install -m 644 guiserver/word-count.lsp $(datadir)/newlisp/guiserver/word-count.lsp
+	-install -m 644 guiserver/uppercase.lsp $(datadir)/newlisp/guiserver/uppercase.lsp
+
+
+uninstall:
+	-rm  $(bindir)/newlisp
+	-rm  $(bindir)/newlispdoc
+	-rm  $(bindir)/newlisp-edit
+	-rm  -rf $(datadir)/newlisp
+	-rm  -rf $(datadir)/doc/newlisp
+	-rm  $(mandir)/man1/newlisp.1
+	-rm  $(mandir)/man1/newlispdoc.1
+
+# installs newLISP in home directory, but without guiserver files except
+# documentation. To make guiserver run from ~/share/newlisp. The loading
+# from guiserver.lsp at the beginning of a guiserver app and loading
+# of guiserver.jar from inside of guiserver.lsp have to be changed.
+
+install_home:
+	-install -d $(HOME)/bin
+	-install -d $(HOME)/share/newlisp
+	-install -d $(HOME)/share/newlisp/modules
+	-install -d $(HOME)/share/newlisp/util
+	-install -d $(HOME)/share/doc/newlisp/
+	-install -d $(HOME)/share/doc/newlisp/guiserver
+	-install -d $(HOME)/share/man/man1
+	-install -m 755 newlisp $(HOME)/bin/newlisp
+	-install -m 755 util/newlispdoc $(HOME)/bin/newlispdoc
+	-install -m 644 util/syntax.cgi $(HOME)/share/newlisp/util/syntax.cgi
+	-install -m 644 util/newlisp.vim $(HOME)/share/newlisp/util/newlisp.vim
+	-install -m 644 guiserver/index-gs.html $(HOME)/share/doc/newlisp/guiserver/index-gs.html
+	-install -m 644 guiserver/guiserver.lsp.html $(HOME)/share/doc/newlisp/guiserver/guiserver.lsp.html
+	-install -m 644 doc/COPYING $(HOME)/share/doc/newlisp/COPYING
+	-install -m 644 doc/COPYING $(HOME)/share/doc/newlisp/guiserver/COPYING
+	-install -m 644 doc/CREDITS $(HOME)/share/doc/newlisp/CREDITS
+	-install -m 644 doc/newlisp_manual.html $(HOME)/share/doc/newlisp/newlisp_manual.html
+	-install -m 644 doc/newlisp_index.html $(HOME)/share/doc/newlisp/newlisp_index.html
+	-install -m 644 doc/manual_frame.html $(HOME)/share/doc/newlisp/manual_frame.html
+	-install -m 644 doc/CodePatterns.html $(HOME)/share/doc/newlisp/CodePatterns.html
+	-install -m 644 doc/newLISPdoc.html $(HOME)/share/doc/newlisp/newLISPdoc.html
+	-install -m 644 doc/newLISP-$(VERSION)-Release.html $(HOME)/share/doc/newlisp/newLISP-$(VERSION)-Release.html
+	-install -m 644 doc/newlisp.1 $(HOME)/share/man/man1/newlisp.1
+	-install -m 644 doc/newlispdoc.1 $(HOME)/share/man/man1/newlispdoc.1
+	-install -m 644 modules/canvas.lsp $(HOME)/share/newlisp/modules/canvas.lsp
+	-install -m 644 modules/cgi.lsp $(HOME)/share/newlisp/modules/cgi.lsp
+	-install -m 644 modules/crypto.lsp $(HOME)/share/newlisp/modules/crypto.lsp
+	-install -m 644 modules/ftp.lsp $(HOME)/share/newlisp/modules/ftp.lsp
+	-install -m 644 modules/getopts.lsp $(HOME)/share/newlisp/modules/getopts.lsp
+	-install -m 644 modules/gsl.lsp $(HOME)/share/newlisp/modules/gsl.lsp
+	-install -m 644 modules/infix.lsp $(HOME)/share/newlisp/modules/infix.lsp
+	-install -m 644 modules/macro.lsp $(HOME)/share/newlisp/modules/macro.lsp
+	-install -m 644 modules/mysql.lsp $(HOME)/share/newlisp/modules/mysql.lsp
+	-install -m 644 modules/plot.lsp $(HOME)/share/newlisp/modules/plot.lsp
+	-install -m 644 modules/odbc.lsp $(HOME)/share/newlisp/modules/odbc.lsp
+	-install -m 644 modules/pop3.lsp $(HOME)/share/newlisp/modules/pop3.lsp
+	-install -m 644 modules/postgres.lsp $(HOME)/share/newlisp/modules/postgres.lsp
+	-install -m 644 modules/postscript.lsp $(HOME)/share/newlisp/modules/postscript.lsp
+	-install -m 644 modules/smtp.lsp $(HOME)/share/newlisp/modules/smtp.lsp
+	-install -m 644 modules/smtpx.lsp $(HOME)/share/newlisp/modules/smtpx.lsp
+	-install -m 644 modules/sqlite3.lsp $(HOME)/share/newlisp/modules/sqlite3.lsp
+	-install -m 644 modules/stat.lsp $(HOME)/share/newlisp/modules/stat.lsp
+	-install -m 644 modules/unix.lsp $(HOME)/share/newlisp/modules/unix.lsp
+	-install -m 644 modules/xmlrpc-client.lsp $(HOME)/share/newlisp/modules/xmlrpc-client.lsp
+	-install -m 644 modules/zlib.lsp $(HOME)/share/newlisp/modules/zlib.lsp
+
+
+uninstall_home:
+	-rm  -rf $(HOME)/share/newlisp
+	-rm  -rf $(HOME)/share/doc/newlisp
+	-rm  $(HOME)/share/man/man1/newlisp.1
+	-rm  $(HOME)/share/man/man1/newlispdoc.1
+	-rm $(HOME)/bin/newlisp
+	-rm $(HOME)/bin/newlispdoc
+
diff --git a/makefile_os2 b/makefile_os2
new file mode 100644
index 0000000..005de8c
--- /dev/null
+++ b/makefile_os2
@@ -0,0 +1,21 @@
+# makefile for newLISP v. 10.x.x on OS/2 (tested on eComstation)
+#
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -Wall -pedantic -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -s -DREADLINE -DOS2
+#CFLAGS = -Wall -pedantic -Wno-uninitialized -Wno-strict-aliasing -Wno-long-long -c -O2 -s -DOS2
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -Zomf -Zmt -lm -lreadline -lncurses -ldl -o newlisp.exe
+	#$(CC) $(OBJS) -Zomf -Zmt -lm -ldl -o newlisp.exe
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_os2
+
diff --git a/makefile_raspberrypi b/makefile_raspberrypi
new file mode 100644
index 0000000..8c51683
--- /dev/null
+++ b/makefile_raspberrypi
@@ -0,0 +1,28 @@
+# makefile for newLISP v.10.x.x on LINUX raspberry PI 
+#
+# Note, that readline support may require different libraries on different OSs
+#
+# USAGE: sb2 make -f makefile_raspberrypi
+# RUNNING and TEST: sb2 make testall
+# sb2 is an ARM emulator
+# 
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -mcpu=arm1176jzf-s -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DLINUX
+#CFLAGS = -mcpu=arm1176jzf-s -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DLINUX -DREADLINE
+
+CC = gcc
+
+
+default: $(OBJS)
+#	$(CC) $(OBJS) -g -lm -ldl -lreadline -o newlisp # with readline support 
+	$(CC) $(OBJS) -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_raspberrypi
+
diff --git a/makefile_raspberrypi_utf8 b/makefile_raspberrypi_utf8
new file mode 100644
index 0000000..1d0d8c3
--- /dev/null
+++ b/makefile_raspberrypi_utf8
@@ -0,0 +1,27 @@
+# makefile for newLISP v.10.x.x on LINUX raspberry PI 
+#
+# Note, that readline support may require different libraries on different OSs
+# 
+# USAGE: sb2 make -f makefile_raspberrypi_utf8
+# RUNNING and TEST: sb2 make testall
+# sb2 is an ARM emulator
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+CFLAGS = -mcpu=arm1176jzf-s -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DLINUX -DSUPPORT_UTF8
+#CFLAGS = -mcpu=arm1176jzf-s -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -g -DLINUX -DSUPPORT_UTF8  -DREADLINE
+
+CC = gcc
+
+
+default: $(OBJS)
+#	$(CC) $(OBJS) -g -lm -ldl -lreadline -o newlisp #  with readline support
+	$(CC) $(OBJS) -g -lm -ldl -o newlisp # without readline support
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_raspberrypi_utf8
+
diff --git a/makefile_sunos b/makefile_sunos
new file mode 100644
index 0000000..9fc361b
--- /dev/null
+++ b/makefile_sunos
@@ -0,0 +1,18 @@
+# makefile for newLISP v. 10.x.x on SunOS 32-bit with UTF-8 support on Sparc CPU
+#
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m32 -Wall -pedantic -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -c -O2 -DREADLINE -DSUNOS
+
+CC = gcc 
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -ldl -lrt -lsocket -lnsl -lreadline -lncurses -o newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_sunos
diff --git a/makefile_sunosLP64 b/makefile_sunosLP64
new file mode 100644
index 0000000..909badb
--- /dev/null
+++ b/makefile_sunosLP64
@@ -0,0 +1,19 @@
+# makefile for newLISP v. 10.x.x on SUNOS 64-bit app on Sparc CPU
+#
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+CFLAGS = -m64 -Wall -pedantic -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -c -O2 \
+	-DSUNOS -DNEWLISP64 -DREADLINE
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -lm -ldl -lrt -lsocket -lnsl -lreadline -lncurses -o newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_sunosLP64
diff --git a/makefile_sunosLP64_utf8 b/makefile_sunosLP64_utf8
new file mode 100644
index 0000000..bb33ca3
--- /dev/null
+++ b/makefile_sunosLP64_utf8
@@ -0,0 +1,19 @@
+# makefile for newLISP v. 10.x.x on SUNOS 64-bit app on Sparc CPU
+#
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-utf8.o nl-debug.o pcre.o
+
+CFLAGS = -m64 -Wall -pedantic -Wno-uninitialized -Wno-long-long -fno-strict-aliasing -c -O2 \
+	-DSUNOS -DNEWLISP64 -DREADLINE -DSUPPORT_UTF8
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m64 -lm -ldl -lrt -lsocket -lnsl -lreadline -lncurses -o newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_sunosLP64
diff --git a/makefile_sunos_utf8 b/makefile_sunos_utf8
new file mode 100644
index 0000000..5f6718f
--- /dev/null
+++ b/makefile_sunos_utf8
@@ -0,0 +1,21 @@
+# makefile for newLISP v. 10.x.x on SUNOS with UTF-8 support on Sparc CPU
+#
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o nl-utf8.o pcre.o
+
+
+# use following for UTF-8 support and add nl-utf8.o to the OBJS line
+CFLAGS = -m32 -Wall -pedantic -Wno-uninitialized -Wno-long-long -c -O2 -DREADLINE -DSUPPORT_UTF8 -DSUNOS
+
+CC = gcc
+
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -ldl -lrt -lsocket -lnsl -lreadline -lncurses -o newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_sunos_utf8
diff --git a/makefile_tru64 b/makefile_tru64
new file mode 100644
index 0000000..be083fa
--- /dev/null
+++ b/makefile_tru64
@@ -0,0 +1,25 @@
+# makefile for newLISP v. 10.x.x on HP Tru64Unix
+#
+# tesetd on Compaq Alpha hardware platform
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o
+
+# CFLAGS = -I/usr/local/include -ieee -pedantic -c -O3 -DREADLINE -DSOLARIS -DTRU64 -DNEWLISP64 -D_POSIX_PII_SOCKET
+CFLAGS = -ieee -pedantic -c -O3 -DTRU64 -DNEWLISP64 -D_POSIX_PII_SOCKET
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -lm -lrt -ldb -lbsd -o newlisp
+	strip newlisp
+
+readline: $(OBJS)
+	$(CC) $(OBJS) -lm -lrt -ldb -lbsd -lreadline -ltermcap -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_tru64
+
diff --git a/makefile_wings b/makefile_wings
new file mode 100644
index 0000000..19ad85b
--- /dev/null
+++ b/makefile_wings
@@ -0,0 +1,90 @@
+# this packages the Win32 binary distribution
+# this makefile is executed from a MinGW MSYS shell
+
+VERSION=10.7.0
+
+win-gui:
+	-mkdir /c/newlisp
+	-mkdir /c/newlisp/guiserver
+	-mkdir /c/newlisp/modules
+	-mkdir /c/newlisp/util
+	cp newlisp.exe /c/newlisp
+	cp newlisp.dll /c/newlisp
+	cp util/newlispdoc /c/newlisp/util
+	cp util/newlisp.vim /c/newlisp/util
+	cp util/syntax.cgi /c/newlisp/util
+	cp doc/newlisp_manual.html /c/newlisp
+	cp doc/newlisp_index.html /c/newlisp
+	cp doc/manual_frame.html /c/newlisp
+	cp doc/CodePatterns.html /c/newlisp
+	cp doc/newLISPdoc.html /c/newlisp
+	cp doc/newLISP-$(VERSION)-Release.html /c/newlisp
+	cp doc/COPYING /c/newlisp
+	cp guiserver/guiserver.lsp /c/newlisp
+	cp guiserver/guiserver.jar /c/newlisp	
+	cp guiserver/newlisp-edit.lsp /c/newlisp
+
+	# guiserver sub directory
+	cp guiserver/index-gs.html /c/newlisp/guiserver
+	cp guiserver/guiserver.lsp.html /c/newlisp/guiserver
+	cp util/newlispdoc.css /c/newlisp/guiserver
+	cp guiserver/allfonts-demo.lsp /c/newlisp/guiserver
+	cp guiserver/animation-demo.lsp /c/newlisp/guiserver
+	cp guiserver/border-layout-demo.lsp /c/newlisp/guiserver
+	cp guiserver/button-demo.lsp /c/newlisp/guiserver
+	cp guiserver/clipboard-demo.lsp /c/newlisp/guiserver
+	cp guiserver/cursor-demo.lsp /c/newlisp/guiserver
+	cp guiserver/drag-demo.lsp /c/newlisp/guiserver
+	cp guiserver/font-demo.lsp /c/newlisp/guiserver
+	cp guiserver/frameless-demo.lsp /c/newlisp/guiserver
+	cp guiserver/html-demo.lsp /c/newlisp/guiserver
+	cp guiserver/image-demo.lsp /c/newlisp/guiserver
+	cp guiserver/midi-demo.lsp /c/newlisp/guiserver
+	cp guiserver/midi2-demo.lsp /c/newlisp/guiserver
+	cp guiserver/mouse-demo.lsp /c/newlisp/guiserver
+	cp guiserver/move-resize-demo.lsp /c/newlisp/guiserver
+	cp guiserver/pinballs-demo.lsp /c/newlisp/guiserver
+	cp guiserver/properties-demo.lsp /c/newlisp/guiserver
+	cp guiserver/rotation-demo.lsp /c/newlisp/guiserver
+	cp guiserver/scroll-pane-demo.lsp /c/newlisp/guiserver
+	cp guiserver/shapes-demo.lsp /c/newlisp/guiserver
+	cp guiserver/sound-demo.lsp /c/newlisp/guiserver
+	cp guiserver/stroke-demo.lsp /c/newlisp/guiserver
+	cp guiserver/tabs-demo.lsp /c/newlisp/guiserver
+	cp guiserver/table-demo.lsp /c/newlisp/guiserver
+	cp guiserver/textrot-demo.lsp /c/newlisp/guiserver
+	cp guiserver/widgets-demo.lsp /c/newlisp/guiserver
+	cp guiserver/word-count.lsp /c/newlisp/guiserver
+	cp guiserver/uppercase.lsp /c/newlisp/guiserver
+	# modules sub directory
+	cp modules/canvas.lsp /c/newlisp/modules
+	cp modules/cgi.lsp /c/newlisp/modules
+	cp modules/crypto.lsp /c/newlisp/modules
+	cp modules/ftp.lsp /c/newlisp/modules
+	cp modules/gsl.lsp /c/newlisp/modules
+	cp modules/infix.lsp /c/newlisp/modules
+	cp modules/mysql.lsp /c/newlisp/modules
+	cp modules/odbc.lsp /c/newlisp/modules
+	cp modules/plot.lsp /c/newlisp/modules
+	cp modules/pop3.lsp /c/newlisp/modules
+	cp modules/postgres.lsp /c/newlisp/modules
+	cp modules/postscript.lsp /c/newlisp/modules
+	cp modules/smtp.lsp /c/newlisp/modules
+	cp modules/smtpx.lsp /c/newlisp/modules
+	cp modules/sqlite3.lsp /c/newlisp/modules
+	cp modules/stat.lsp /c/newlisp/modules
+	cp modules/unix.lsp /c/newlisp/modules
+	cp modules/xmlrpc-client.lsp /c/newlisp/modules
+	cp modules/zlib.lsp /c/newlisp/modules
+	cp guiserver/newlisp-win.ico /c/newlisp
+	# prepare pack program
+	cp guiserver/newlisp-gs.nsi /NSIS
+	cp guiserver/newlisp-win.ico /NSIS
+	echo 'md5sum /c/newlisp/*.exe /c/newlisp/*.dll > /c/newlisp/md5-checksums.txt' >> pack-gui
+	echo 'cd /NSIS/' >> pack-gui
+	echo './makensis newlisp-gs.nsi' >> pack-gui
+	chmod 755 pack-gui
+	# pack everything
+	./pack-gui
+	rm ./pack-gui
+	rm -rf /c/newlisp
diff --git a/makefile_wings64 b/makefile_wings64
new file mode 100644
index 0000000..08991e2
--- /dev/null
+++ b/makefile_wings64
@@ -0,0 +1,90 @@
+# this packages the Win64 binary distribution
+# this makefile is executed from a MinGW MSYS shell
+
+VERSION=10.7.0
+
+win-gui:
+	-mkdir /c/newlisp
+	-mkdir /c/newlisp/guiserver
+	-mkdir /c/newlisp/modules
+	-mkdir /c/newlisp/util
+	cp newlisp.exe /c/newlisp
+	cp newlisp.dll /c/newlisp
+	cp util/newlispdoc /c/newlisp/util
+	cp util/newlisp.vim /c/newlisp/util
+	cp util/syntax.cgi /c/newlisp/util
+	cp doc/newlisp_manual.html /c/newlisp
+	cp doc/newlisp_index.html /c/newlisp
+	cp doc/manual_frame.html /c/newlisp
+	cp doc/CodePatterns.html /c/newlisp
+	cp doc/newLISPdoc.html /c/newlisp
+	cp doc/newLISP-$(VERSION)-Release.html /c/newlisp
+	cp doc/COPYING /c/newlisp
+	cp guiserver/guiserver.lsp /c/newlisp
+	cp guiserver/guiserver.jar /c/newlisp	
+	cp guiserver/newlisp-edit.lsp /c/newlisp
+
+	# guiserver sub directory
+	cp guiserver/index-gs.html /c/newlisp/guiserver
+	cp guiserver/guiserver.lsp.html /c/newlisp/guiserver
+	cp util/newlispdoc.css /c/newlisp/guiserver
+	cp guiserver/allfonts-demo.lsp /c/newlisp/guiserver
+	cp guiserver/animation-demo.lsp /c/newlisp/guiserver
+	cp guiserver/border-layout-demo.lsp /c/newlisp/guiserver
+	cp guiserver/button-demo.lsp /c/newlisp/guiserver
+	cp guiserver/clipboard-demo.lsp /c/newlisp/guiserver
+	cp guiserver/cursor-demo.lsp /c/newlisp/guiserver
+	cp guiserver/drag-demo.lsp /c/newlisp/guiserver
+	cp guiserver/font-demo.lsp /c/newlisp/guiserver
+	cp guiserver/frameless-demo.lsp /c/newlisp/guiserver
+	cp guiserver/html-demo.lsp /c/newlisp/guiserver
+	cp guiserver/image-demo.lsp /c/newlisp/guiserver
+	cp guiserver/midi-demo.lsp /c/newlisp/guiserver
+	cp guiserver/midi2-demo.lsp /c/newlisp/guiserver
+	cp guiserver/mouse-demo.lsp /c/newlisp/guiserver
+	cp guiserver/move-resize-demo.lsp /c/newlisp/guiserver
+	cp guiserver/pinballs-demo.lsp /c/newlisp/guiserver
+	cp guiserver/properties-demo.lsp /c/newlisp/guiserver
+	cp guiserver/rotation-demo.lsp /c/newlisp/guiserver
+	cp guiserver/scroll-pane-demo.lsp /c/newlisp/guiserver
+	cp guiserver/shapes-demo.lsp /c/newlisp/guiserver
+	cp guiserver/sound-demo.lsp /c/newlisp/guiserver
+	cp guiserver/stroke-demo.lsp /c/newlisp/guiserver
+	cp guiserver/tabs-demo.lsp /c/newlisp/guiserver
+	cp guiserver/table-demo.lsp /c/newlisp/guiserver
+	cp guiserver/textrot-demo.lsp /c/newlisp/guiserver
+	cp guiserver/widgets-demo.lsp /c/newlisp/guiserver
+	cp guiserver/word-count.lsp /c/newlisp/guiserver
+	cp guiserver/uppercase.lsp /c/newlisp/guiserver
+	# modules sub directory
+	cp modules/canvas.lsp /c/newlisp/modules
+	cp modules/cgi.lsp /c/newlisp/modules
+	cp modules/crypto.lsp /c/newlisp/modules
+	cp modules/ftp.lsp /c/newlisp/modules
+	cp modules/gsl.lsp /c/newlisp/modules
+	cp modules/infix.lsp /c/newlisp/modules
+	cp modules/mysql.lsp /c/newlisp/modules
+	cp modules/odbc.lsp /c/newlisp/modules
+	cp modules/plot.lsp /c/newlisp/modules
+	cp modules/pop3.lsp /c/newlisp/modules
+	cp modules/postgres.lsp /c/newlisp/modules
+	cp modules/postscript.lsp /c/newlisp/modules
+	cp modules/smtp.lsp /c/newlisp/modules
+	cp modules/smtpx.lsp /c/newlisp/modules
+	cp modules/sqlite3.lsp /c/newlisp/modules
+	cp modules/stat.lsp /c/newlisp/modules
+	cp modules/unix.lsp /c/newlisp/modules
+	cp modules/xmlrpc-client.lsp /c/newlisp/modules
+	cp modules/zlib.lsp /c/newlisp/modules
+	cp guiserver/newlisp-win.ico /c/newlisp
+	# prepare pack program
+	cp guiserver/newlisp64-gs.nsi /NSIS
+	cp guiserver/newlisp-win.ico /NSIS
+	echo 'md5sum /c/newlisp/*.exe /c/newlisp/*.dll > /c/newlisp/md5-checksums.txt' >> pack-gui
+	echo 'cd /NSIS/' >> pack-gui
+	echo './makensis newlisp64-gs.nsi' >> pack-gui
+	chmod 755 pack-gui
+	# pack everything
+	./pack-gui
+	rm ./pack-gui
+	rm -rf /c/newlisp
diff --git a/modules/README.txt b/modules/README.txt
new file mode 100644
index 0000000..f8c36ae
--- /dev/null
+++ b/modules/README.txt
@@ -0,0 +1,19 @@
+To generate HTML documentation for the modules in this directory, simply
+execute the following statement inside the newlisp-x.x.x/modules directory:
+
+   newlispdoc -s -d *.lsp
+
+or on Windows
+
+   newlisp newlispdoc -s -d *.lsp
+
+This will genereate an index page index.html and one html file each
+for each module of the form name.lsp.html, where name is the name of the module.
+For additional conversion options see newlisp-x.x.x/doc/newLISPdoc.html .
+
+The newlispdoc utility can be found in newlisp-x.x.x/util/newlispdoc .
+
+Documentation on how to format newLISP source files for this program can be found 
+in newlisp-x.x.x/doc/newLISPdoc.html or in /usr/share/doc/newlisp/newLISPdoc.html.
+
+
diff --git a/modules/canvas.lsp b/modules/canvas.lsp
new file mode 100644
index 0000000..b43d372
--- /dev/null
+++ b/modules/canvas.lsp
@@ -0,0 +1,1121 @@
+;; @module canvas.lsp
+;; @description Routines for creating HTML canvas tag graphics
+;; @version 1.0 initial release
+;; @version 1.1 doc changes only
+;; @version 1.21 doc changes only
+;; @version 1.3 compatibility pre and post 10.2.0 for new extend
+;; @version 1.32 doc formatting, spelling
+;; @version 1.33 took out license
+;; @version 1.4 cv:petal was broken (JavaScript change?)
+;; @version 1.44 doc corrections
+;; @version 1.45 cv:render works on Emscripten newLISP
+;; @version 1.52 changed Win32 to Windows and spelling
+;; @version 1.6 sign error in shape caused incompatibility with postscript.lsp
+;; @version 1.61 eliminated canvas-15.tgz link
+;; @version 1.7 fixed ellipse, petal, pie, polygon, shape fill first the stroke
+;; @version 1.71 fixed documentation for cv:clip
+;; @author Lutz Mueller, March 2009, June 2012, January 2014, 2015
+;; <h2>Turtle graphics for the HTML-5 canvas tag</h2>
+;; This module generates HTML pages suited for browsers which recognize
+;; the HTML-5 canvas tag. 
+
+;; <h3>Example program</h3>
+;; The following is a simple example how to create an HTML page
+;; with one or more embedded graphics. 
+;;
+;; @example
+;; (module "canvas.lsp") ; does a load from standard location
+;;
+;; (cv:html "&lt;h2&gt;First canvas&lt;/h2&gt;") ; optional mixed in HTML
+;; (cv:canvas "FirstCanvas" 300 100) ; required canvas creation
+;; (cv:fill-color 1.0 0.0 0.0)
+;; (cv:rectangle 100 80 true) ; one or more drawing statements
+;; (cv:html "&lt;h2&gt;Second canvas&lt;/h2&gt;")
+;;
+;; (cv:canvas "SecondCanvas" 300 100)
+;; (cv:fill-color 0.0 1.0 0.0)
+;; (cv:rectangle 200 80 true)
+;; (cv:render "page.html") ; required rendering of the page
+;; (exit)
+
+;; All canvas functions are prefixed with 'cv' and emit the JavaScript
+;; code necessary to the &lt;script&gt;&lt/script&gt; section in the
+;; header section of the HTML page. Only the function 'html' is not
+;; prefixed and outputs strings directoy to the &lt;body&gt;&lt/body&gt;
+;; tagged section of the HTML page.
+;;
+;; @example
+;; (html "&lt;p&gt;This is a parapgraph of text.&lt;/p&gt;")
+
+;; Sometimes it is necessary to output JavaScript explicity to the
+;; script section of the page, e.g. to use canvas features not implemented
+;; in this module. This can be done via the 'cv' default functor:
+;;
+;; @example
+;; (cv "document.write('this is a test');")
+
+;; Most functions in the canvas 'cv' module work the same as in the older
+;; postscript 'ps' modul, and some functions in the postscript module
+;; have been changed to achieve more compatibility between both modules. 
+;; The following example shows how name-space prefix switching can be used to
+;; to run a <tt>postscript.lsp</tt> based program with <tt>canvas</tt>:
+;;
+;; @example
+;; (module "canvas.lsp")
+;; 
+;; (html "<center>")
+;; (cv:canvas "TheCanvas" 200 200)
+;; ; reuse postrcipt.lsp code
+;; (set 'ps cv) ; switch prefix
+;;
+;; (ps:goto 120 132)
+;; (ps:line-color  1 0 0.6)
+;; (ps:line-width 3.0)
+;; (ps:angle 15)
+;; (dotimes (i 12)
+;;     (cv:turn 30)
+;;     (cv:bezier -20 75 40 75 20 0))
+;; ; end postscript snippet
+;;
+;; (html "</center>")
+;; (cv:render "rose.html")
+;; (exit)
+
+;; A package with more demo files can be downloaded from 
+;; @link http://www.newlisp.org/canvas/canvas-15.tgz www.newlisp.org/canvas/canvas-15.tgz .
+;; The demo files assume the Safari (4.0 beta) browser on Mac OS X and Windows or
+;; The Firefox browser (3.1. beta 3) on Linux and start the browser automatically.
+;; Change the last 'cv:render' line in each of the demo file to manually load
+;; the generated page-file spciefied in the 'cv:render' statement.
+ 
+;; <h2>Using JavaScript directly</h2>
+;; Complex graphics with many looping statements can generate huge HTML files which
+;; may be slow to load over an internet connection. The newLISP program itself
+;; may be small, but the JavaScript it generates may fill hundreds of kilobytes
+;; because of repeated output of JavaScript statements. The <tt>cv</tt> function 
+;; can be used to to emit JavaScript directly. For most <tt>cv:xxx</tt> (but not all) 
+;; -functions a similar named JavaScript function exists in <tt>canvas.lsp</tt>.
+;; The following example generates the same graphic twice, first as a looping
+;; newLISP script, then as an explicitly written JavaScript script:
+;;
+;; @example
+;; (module "canvas.lsp")
+;; 
+;; (html "<h3>Indirect draw</h3>")
+;; 
+;; (cv:canvas "CanvasOne" 400 200)
+;; (cv:line-color 0 0.5 0.5)
+;; 
+;; (cv:angle -90)
+;; (dotimes (i 180)
+;;     (cv:goto 200 0)
+;;     (cv:draw 300)
+;;     (cv:turn 1))
+;; 
+;; (html "<h3>Direct draw</h3>")
+;; 
+;; (cv:canvas "CanvasTwo" 400 200)
+;; (cv:line-color 0 0.5 0.5)
+;; 
+;; (cv [text]
+;; Angle(-90);
+;; for(var i = 0; i < 180; i++) {
+;;     Goto(200, 0);
+;;     Draw(300);
+;;     Turn(1);
+;;     }
+;; [/text])
+;;
+;; (cv:render) ; render page automatically in browser on OS X (Safari 4.0)
+;; ; as an alternative specify the HTML filename
+;; (cv:render "direct.html") ; renders to file specified
+;; (exit)
+
+;; <h2>Differences to the postscript module</h2>
+;; Differences between the <tt>canvas.lsp</tt> and <tt>postscript.lsp</tt> modules
+;; are mainly in the treatment of text colors and fonts.
+;; <ul>
+;; <li>The text color for 'cv:text' is set by 'cv:fill-color' with 'canvas.lsp', but
+;; with 'ps:line-color' when using 'postscript.lsp' and 'ps:text', except for outlined
+;; text, which is drawn with 'line-color' in both modules.</li>
+;; <li>The 'cv:font' parameters are different from the 'ps:font'
+;; parameters. See the function reference for details.</li>
+;; <li>Canvas graphics need the 'cv:canvas' statement at the beginning
+;; to specify the canvas size. In Postscript the drawing area depends
+;; on the printer driver settings. To port 'postscript.lsp' graphics
+;; to 'canvas.lsp' use a width of 612 and height of 792 in the 'cv:canvas'
+;; statement. The numbers correspond to a 8 1/2 by 11 inch US paper page
+;; with translation of points to pixels.</li>
+;; <li>Cipping with outlined text is not available yet in 'canvas.lsp'.
+;; Current implementations are browser-specific and not part of the HTML-5
+;; canvas tag specification.</li>
+;; <li>Text drawn with 'cv:textoutline' or 'cv:textarcoutline' cannot be filled
+;; with color as possible with 'ps:textoutline' and 'ps:textarcoutline' in the postscript
+;; module.
+;; <li>'canvas.lsp' has a 'cv:header' function to specify tags in the 
+;; HTML header section.</li>
+;; </ul>
+ 
+
+;; <h2>Summary of functions</h2>
+;; Return values from functions are not used when programming with canvas functions
+;; and are not mentioned in the documentation.
+;; <h3>Turtle coordinate positioning and turning</h3>
+;; <pre>
+;; cv:goto  - move turtle to position x, y
+;; cv:move  - move turtle a distance s forward from the current position
+;; cv:turn  - turn the turtle degress dg left (negative) or right (positive)
+;; cv:angle - set the turtle orientation to dg degrees
+;; </pre>
+;; <h3>Line drawing</h3>
+;; <pre>
+;; cv:draw   - draw distance s forward from current position
+;; cv:drawto - draw to the absolute position x,y from the current position
+;; cv:line   - draw a multipart line consisting of line and bezier curve segments
+;; cv:bezier - draw a Bezier curve 
+;; </pre>
+;; <h3>Closed shapes, filling and clipping</h3>
+;; <pre>
+;; cv:rectangle - draw a rectangle
+;; cv:polygon   - draw a polygon with radius rad and n number of sides
+;; cv:circle    - draw a circle
+;; cv:ellipse   - draw an open or closed ellipse with x-rad and y-rad radius
+;; cv:pie       - draw a pie piece with radius rad and width
+;; cv:petal     - draw a petal shape from Bezier curves
+;; cv:shape     - draw a shape defined by a list of line and bezier segments
+;; cv:clip      - define a clipping path using line and Bezier segments
+;; </pre>
+;; <h3>Text output and clipping</h3>
+;; <pre>
+;; cv:text           - draw a solid text string
+;; cv:textoutline    - draw text in outline shape
+;; cv:textarc        - draw text around an arc
+;; cv:textarcoutline - draw text in outline shape around an arc
+;; </pre>
+;; <h3>Global settings</h3>
+;; <pre>
+;; cv:translate  - move coordinate origin
+;; cv:scale      - scale output
+;; cv:rotate     - rotate output
+;; cv:gsave      - save current graphics state (translation, scale, rotation)
+;; cv:grestore   - restore current graphics state
+;; cv:font       - set font specifications
+;; cv:line-witdh - set line width in pixels
+;; cv:line-cap   - set line termination shape
+;; cv:line-join  - set line join mode
+;; cv:line-color - set line color
+;; cv:fill-color - set fill color
+;; </pre>
+;; <h3>Rendering and output</h3>
+;; <pre>
+;; cv:render     - render HTML output to CGI or a file
+;; </pre>
+
+
+;; @syntax (cv:angle <num-dg>) 
+;; @param <num-dg> Angle degrees from 0 to 360.
+;; <br>
+;; Set the turtle angle to <num-dg> degrees.
+;; Upwards is 0, right 90, downwards 180 and left 270 degrees.
+;; The turtle position is saved on the graphics state stack when using 
+;; '(cv:gsave)'.
+
+;; @syntax (cv:bezier <num-x1> <num-y1> <num-x2> <num-y2> <num-x3> <num-y3>) 
+;; @param  <num-x1,num-y1> Bezier coordinates of <p1> relative to <p0> = 0,0
+;; @param  <num-x2,num-y2> Bezier coordinates of <p2> relative to <p0> = 0,0
+;; @param  <num-x3,num-y3> Bezier coordinates of <p3> relative to <p0> = 0,0
+;; <br>
+;; Draw a Bezier curve.
+;; The Bezier curve starts at point <p0> which is the current
+;; turtle position and stops at point <p3> which is at offset
+;; <num-x3> and <num-y3> relative to starting point. The turtle orientation
+;; after the drawing the Bezier curve is perpendicular
+;; to the Bezier curve baseline <p0> to <p3> and the position is <p3>.
+
+;; @syntax (cv:circle <num-rad> [<bool-fill>])
+;; @param <num-rad> Radius of the circle.
+;; @param <bool-fill> Optional fill flag.
+;; <br>
+;; Draw a circle with radius <num-rad>. The optional <num-fill> flag 
+;; with either 'true' or 'nil' (default) indicates if the circle
+;; is filled with the fill color specified by 'cv:fill-color'.
+;; The circle is drawn around the current turtle position.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (cv:clip <list-of-lists>) 
+;; @param <list-of-lists> A list of turtle movements and/or Bezier curves.
+;; <br>
+;; Define a clipping path using turtle movements (<degree> <distance>) and
+;; Bezier curves (<x1> <y1> <x2> <y2> <x3> <y3>) starting from the 
+;; last turtle coordinates <x0>, <y0> and finishing at <x3>, <y3>. 
+;; All Bezier coordinates are relative to the previous turtle position and
+;; orientation.
+;;
+;; Before redefining the clipping area '(cv:gsave)' should
+;; be used to save the old graphics state parameters, after
+;; clipping and drawing in the clipped area the graphics
+;; state should be restored using '(cv:grestore)'.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (cv:draw <num-s>) 
+;; @param <num-s> Distance to draw.
+;; <br>
+;; Draw going forward distance <num-s>. Moves the turtle forward by 
+;; the amount of pixels specified in <num-s> and draws with the current 
+;; line color set by 'cv:line-color'.
+;;
+
+;; @syntax (cv:drawto <x> <y>) 
+;; @param <x> The x coordinate to draw to.
+;; @param <y> The y coordinate to draw to.
+;; <br>
+;; Draw a line to point <x>, <y>. Moves the turtle to point 
+;; <x>, <y> like '(cv:goto x y)', but also draws a line from 
+;; the old to the new position. The turtle position is changed to the
+;; new point <x>, <y> and the orientation is changed to the orientaion of 
+;; the line drawn.
+
+;; @syntax (cv:ellipse <num-x-rad> <num-y-rad> <num-start> <num-end> [<bool-fill>]) 
+;; @param <num-x-rad> The x axis radius.
+;; @param <num-y-rad> The y axis radius.
+;; @param <num-start> The start angle in 0 to 360 degrees.
+;; @param <end-num> The end angle in 0 to 360 degrees.
+;; <br>
+;; Draw an ellipse with optional <bool-fill> either 'true' or 'nil' (default).
+;; The ellipse is drawn around the current turtle position
+;; with the Y axis oriented like the turtle.
+;; For <num-start>, <num-end> set to 0, 360 an ellipse is drawn.
+;; For a partial radius the opening is closed by a line
+;; resulting in segment shape, i.e. -90, 90  would result
+;; in a half circle from the left to the right of the turtle.
+;; When <num-x-rad> and <num-y-rad> are of equal size a full circle
+;; can be drawn. The turtle position or orientation is not changed.
+
+;; @syntax (cv:fill-color <float-R> <float-G> <float-B>) 
+;; @param <float-R> The red color value.
+;; @param <float-G> The green color value.
+;; @param <float-B> The blue color value.
+;;
+;; Set color for shape filling.
+;; Color values assume the following value:
+;;
+;; <pre>
+;;    R - value for red 0.0 to 1.0
+;;    B - value for green 0.0 to 1.0
+;;    G - value for blue 0.0 to 1.0
+;; </pre>
+;;
+;; @syntax (cv:fill-color <str-hex>)
+;; @param <str-hex> A hex string specifying the line color.
+;; <br>
+;; In an alternative syntax color values can be specified in a
+;; hex string:
+;;
+;; <str-hex> is a hex string constant '"000000"' to '"FFFFFF"'
+;; Colors are specified as usual in HTML coding.
+;; Each two hex digits define a color: 'rrggbb'.  
+
+;; @syntax (cv:font <str-name>) 
+;; @param <str-name> The font name.
+;; <br>
+;; The current font is set for all subsequent text operations.
+;; Depending on the browser and OS installed, different fonts are available.
+;;
+;; @example
+;; (cv:font "normal 14px sans-serif") ; Helvetica
+;; (cv:font "bold 20px serif") ; Times
+;; (cv:font "italic 32px sans-serif") ; Cursive
+
+;; @syntax (cv:goto <num-x> <num-y>)
+;; @param <num-x> The new x coordinate.
+;; @param <num-y> The new y coordinate.
+;; <br>
+;; Moves to position <num-x>, <num-y>. 
+;; The turtle position can be
+;; saved on the graphics state stack when using '(cv:gsave)'.
+
+;; @syntax (cv:grestore)
+;; Restores the graphics state from the stack.
+
+;; @syntax (cv:gsave)
+;; Saves the current graphics state. The function pushes the 
+;; current graphics state on a special stack, from where it
+;; can be resored using '(cv:grestore)'. States saved are:
+;; The turtle position X, Y and  orientation, the transformation
+;; scaling and rotation factors, the line cap and join value and
+;; the colors set.
+
+;; @syntax (cv:line <list-of-lists>) 
+;; @param <list-of-lists> A list of turtle movements or Bezier curves.
+;; <br>
+;; Draw a multipart line.  <lists> are turtle movements (<num-dg> <num-s>),
+;; or Bezier curves (<x1> <y1> <x2> <y2> <x3> <y3>) starting
+;; from the last turtle coordinates <x0>, <y0> and
+;; finishing at <x3>, <y3>. All Bezier coordinates are
+;; relative to the previous turtle position and
+;; orientation.
+;;
+;; The turtle position and orientation are changed after
+;; drawing the line.
+
+;; @syntax (cv:line-cap <num-mode | str-mode>) 
+;; @param <mode> The line termination shape mode as a string or number
+;; <br>
+;; Sets the line termination shape as either a number or string:
+;; <pre>
+;;    0 or "butt"
+;;    1 or "round"
+;;    2 or "square"
+;; </pre>
+
+;; @syntax (cv:line-color <float-R> <float-G> <float-B>) 
+;; @param <float-R> The red color value.
+;; @param <float-G> The green color value.
+;; @param <float-B> The blue color value.
+;; <br>
+;; Set color for line drawing.
+;; Color values assume the following value:
+;; <pre>
+;;    R - value for red 0.0 to 1.0
+;;    G - value for green 0.0 to 1.0
+;;    B - value for blue 0.0 to 1.0
+;; </pre>
+;;
+;; @syntax (cv:line-color <str-hex>)
+;; @param <str-hex> A hex string specifying the line color.
+;; <br>
+;; In an alternative syntax color values can be specified in a
+;; hex string:
+;;
+;; <str-hex> is a hex string constant '"000000"' to '"FFFFFF"'
+;; Colors are specified as usual in HTML coding.
+;; Each to two hex digits define a color: 'rrggbb'.  
+
+;; @syntax (cv:line-join <num-mode> | <str-mode>)
+;; @param <mode> The line join mode.
+;; <br>
+;; Sets the line join mode as either a number or string:
+;; <pre>
+;;    0 or "miter"
+;;    1 or "round"
+;;    2 or "bevel"
+;; </pre>
+
+;; @syntax (cv:line-width <int-pixels>)
+;; @param <int-pixels> The line width in pixels.
+;; <br>
+;; Sets the line width in pixels for line drawing and the
+;; outlines drawn by shapes and text outlines.
+
+;; @syntax (cv:move <num-s>) 
+;; @param <num-s> The distance to move the pen.
+;; <br>
+;; Move turtle the forward distance <s> without drawing.
+
+;; @syntax (cv:petal <num-width> <num-height> [<bool-fill>]) 
+;; @param <num-width> The 'x1' coordinate of the  underlying Bezier curve <p0> to <p1> <p2> <p3>.
+;; @param <num-height> The 'y1' coordinate of the  underlying Bezier curve <p0> to <p1> <p2> <p3>.
+;; @param <bool-fill> An optional fill flag for color fill.
+;; <br>
+;; Draws a petal using a Bezier curve with optional <num-fill> either 'true' or 'nil' (default).
+;; The <num-height> and <num-width> parameters are relative to to the current position.
+;; The petal is drawn with the tip at the current turtle
+;; position and oriented in the direction of the turtle.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (cv:pie <num-rad> <num-width> [<bool-fill>])
+;; @param <num-rad> The radius of the pie.
+;; @param <num-width> The width of the pie slice as an angle.
+;; @param <bool-fill> An optional fill flag for color fill, 'true' or 'nil' (default).
+;; <br>
+;; Draw a pie slice with optional <bool-fill> either 'true' or 'nil' (default).
+;; The left edge of the pie is in turtle orientation.
+;; The width angle spreads clockwise. The pie is drawn around the current
+;; turtle position. The turtle position or orientation is not changed.
+
+;; @syntax (cv:polygon <num-rad> <num-n> [<bool-fill>])
+;; @param <num-rad> Radius.
+;; @param <num-n> Number of sides.
+;; @param <fill> Optional fill flag.
+;; <br>
+;; Draw a polygon with radius <num-rad> and <num-n> sides.
+;; <num-fill> is 'true' or 'nil' (default) for optional color fill
+;; The polygon is drawn around the current turtle position.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (cv:rectangle <num-width> <num-height> [<bool-fill>])
+;; @param <num-width> The width of the rectangle.
+;; @param <num-height> The height of the rectangle.
+;; @param <bool-fill> An optional flag to draw a filled rectangle.
+;; <br>
+;; A rectangle is drawn at the current turtle position.
+;; The width of the rectangle will be perpendicular to
+;; the turtle orientation. If the turtle never turned or
+;; the turtle angle never was set then the width of the
+;; rectangle will lie horizontally.
+;;
+;; The position or orientation of the turtle will not change.
+
+;; @syntax (cv:render [<HTML-file-name>])
+;; @param  <HTML-file-name> Optionam HTML file-name to save to.
+;; <br>
+;; On Mac OX X system when using the function without a file-name,
+;; the default HTML browser is opened automatically and a temporary
+;; file <tt>/tmp/noname.html</tt> is shown. This is the best mode for
+;; interactive development.
+;;
+;; On Windows 'cv:render' tries to open 'c:\Program Files\Safari\Safari.exe'.
+;; The function 'cv:render' at the end of the source in 'canvas.lsp'
+;; can be modified for a different browser.
+;;
+;; When a file-name is supplied, then 'cv:render' generates a HTML
+;; file. When the file-name is specified as <tt>"cgi"</tt>, then
+;; output is directed to standard out. This is useful for writing CGI
+;; programs. The CGI program must take care to emit a content-type header 
+;; first using:
+;;
+;; <pre>(print "Content-Type: text/html\r\n\r\n")</pre>
+
+;; @syntax (cv:rotate <num-deg>) 
+;; @param <num-deg> The degrees of rotation: -360 to 0 to 360.
+;; <br>
+;; Rotate the coordinate space. 
+;; The coordinate space is rotated to the right for
+;; positive angles and to the left for negative angles.
+;; The current rotation angle is 0 (upwards) by default.
+;; The rotation angle is part of the graphics state saved by
+;; the 'cv:gsave' function and restored by 'cv:grestore'.
+
+;; @syntax (cv:scale <num-x> <num-y>) 
+;; @param <num-x> The new x scale factor.
+;; @param <num-y> The new y scale factor.
+;; <br>
+;; Scale the coordinate space.
+;; Scaling factors are 1.0 by default and compress for
+;; factors less 1.0 or expand for factors bigger than 1.0.
+;; With a scaling factor for x = 2.0 each point position
+;; specified would cover the double of horizontal distance
+;; on the page. Previou scaling factors can be saved on the graphics
+;; state stack using the function 'cv:gsave' and restored using 'cv:grestore'.
+
+;; @syntax (cv:shape <list-of-num-lists> [<bool-fill>])
+;; @param <list-of-num-lists> A list of turtle movements and/or Bezier curves.
+;; @param <bool-fill> An optional fill flag for color fill.
+;; <br>
+;; Draws a shape with optional <bool-fill> or eiher 'true' or 'nil' (default).
+;; <num-lists> is either a turtle movement  (<degree> <distance>) or a Bezier curve 
+;; (<x1> <y1> <x2> <y2> <x3> <y3>) starting from the last turtle coordinates 
+;; <x0>, <y0> and finishing at <x3>, <y3>. All Bezier coordinates
+;; are relative to the previous turtle position and orientation
+;; The turtle position or orientation is not changed.
+
+;; @syntax (cv:text <str-text>)
+;; @param <str-text> The text to draw.
+;; <br>
+;; Draws text. Before drawing, a font can be specified, the default font after loading 
+;; the 'canvas.lsp' modules is the default font of the canvas tag. The text color
+;; is the current 'cv:fill-color'.
+;;
+;; The turtle position is changed to the baseline after the last character.
+;; The turtle orientation stays the same.
+
+;; @syntax (cv:textarc <str-text> <num-rad>)
+;; @param <str-text> The text to draw. 
+;; @param <num-rad> The radius of an imaginary circle path for <str-text>.
+;; <br>
+;; Draw text around a circle.
+;; The text is drawn out side of an imaginary circle starting at 
+;; turtle position and orientation and drawing at the current tangent.
+;; For a positive radius text goes outside
+;; the circle and clockwise. For a negative radius text goes inside the
+;; circle and counter lock wise. The turtle position and orientation
+;; move along the radius.
+
+;; @syntax (cv:textarcoutline <str-text> <num-rad>) 
+;; @param <str-text> The text to draw.
+;; @param <num-rad> The radius of imaginary circle path for text.
+;; <br>
+;; Draw text around a circle.
+;; Same as 'cv:textarc' but the text is drawn as ane outline.
+;; The color of the text outline is the current 'cv:line-color'.
+;; The turtle position and orientation move along the radius.
+
+;; @syntax (cv:textoutline <str-text>)
+;; @param <str-text> The text to draw. 
+;; <br>
+;; Draw a text outline
+;; Before drawing a font can be specified
+;; the default font after loading 'canvas.lsp' is the font
+;; of the HTML canvas tag.
+;;
+;; The turtle position is changed to the baseline after the last character.
+;; The turtle orientation stays the same.
+
+;; @syntax (cv:translate <num-dx> <num-dy>) 
+;; @syntax (cv:translate) 
+;; @param <num-dx> Move the current x-origin  by 'dx'.
+;; @param <num-y> Move the current y-origin by 'dy'.
+;; <br>
+;; Move the coordinate origin.
+;; By default the origin 0,0 is in the bottom left corner
+;; of the page. The <num-dx> and <num-dy> values extend to the right and top. 
+;; When no <num-x>, <num-y> values are specified, the coordinate origin
+;; is moved to the current position of the turtle. Previous translation
+;; offsets can be saved on the graphics state stack using the
+;; function 'cv:gsave' and restored using 'cv:grestore'.
+
+;; @syntax (cv:turn <num-dg>)
+;; @param <num-dg>  The degrees to turn: -360 to 0 to 360.
+;; <br>
+;; Turn the turtle pen by <num-dg> degrees. The degrees are specified in angles
+;; from -380 to 0 to 360. For turning clockwise specifiy positive values.
+;; Negative degrees turn the turtle pen counter clockwise. The turtle
+;; position is aved on the graphics state stack when using '(cv:gsave)'.
+
+(when (< (sys-info -2) 10110)
+	(constant (global 'extend) write-buffer))
+
+(define (html:html str) (extend cv:body-html str))
+
+(context 'cv)
+
+; global values and constants
+
+(set 'pi (mul 2 (acos 0)))
+(set 'pi/2 (acos 0))
+
+(set 'line-feed (if (> (& 0xF (sys-info -1)) 5) "\r\n" "\n"))
+(set 'header-tags "") ; header tags from cv:header go here
+(set 'canvas-script "") ; graphics statements go here
+(set 'body-html "") ; body html written with cv:html goes here
+
+(set 'canvas-width 1000) ; current canvas
+(set 'canvas-height 1000) ; current canvas
+
+(set 'turtle-x 0)
+(set 'turtle-y canvas-height)
+(set 'turtle-orient (add pi 0.0000001))
+
+(set 'line-color "#000000") ; for strokeStyle()
+(set 'line-width 1) ; 
+(set 'fill-color '(0xff 0 0 0)) ; for fillStyle()
+
+(set 'template-header [text]<!-- newLISP generated page -->
+<html>
+<head>
+<!-- header -->
+%s[/text])
+
+(set 'script-header [text]<script type="text/javascript">
+
+var canvasWidth, canvasHeight;
+var xpos, ypos, orient;
+var turtleStack = new Array();
+var xsave, ysave, orientsave;
+var ctx;
+
+function Ctx(c) { ctx = c; }
+
+function Gsave() { 
+	PushTurtle(); ctx.save(); 
+	}
+
+function Grestore() { 
+	ctx.restore(); PopTurtle(); 
+	}
+
+function PushTurtle() {
+	turtleStack.push(canvasHeight, xpos, ypos, orient);
+	}
+
+function PopTurtle() {
+	orient = turtleStack.pop();
+	ypos = turtleStack.pop();
+	xpos = turtleStack.pop();
+	canvasHeight = turtleStack.pop();
+	}
+
+function Scale(x, y) {
+	ctx.scale(x, y);
+	canvasHeight = canvasHeight / y;
+	}
+	
+function Turn(dg) {
+	orient = orient - Math.PI * dg / 180;
+	}
+
+function Goto(x, y) { xpos = x; ypos = canvasHeight - y; }
+
+function Angle(dg) {
+	orient = Math.PI - Math.PI * dg / 180;
+	}
+
+function Move(s) {
+	xpos = xpos + s *  Math.sin(orient);
+	ypos = ypos + s *  Math.cos(orient);
+	}
+
+function Draw(s) {
+	ctx.beginPath();
+	ctx.moveTo(xpos, ypos);
+	xpos = xpos + s *  Math.sin(orient);
+	ypos = ypos + s *  Math.cos(orient);
+	ctx.lineTo(xpos, ypos);
+	ctx.stroke();
+	}
+
+function Drawto(x, y) {
+	ctx.beginPath(); ctx.moveTo(xpos, ypos);
+	y = canvasHeight - y;
+	ctx.lineTo(x, y); ctx.stroke();
+	orient = Math.PI / 2 - Math.atan2(y - ypos, x - xpos); 
+	xpos = x; ypos = y;
+	}
+
+function Line(lst) {
+	Path(lst); ctx.stroke();
+	}
+	
+function Shape(lst, flag) {
+	turtleStack.push(xpos, ypos, orient);
+	Path(lst);
+	ctx.closePath(); 
+	if(flag == true) { ctx.fill(); }
+    ctx.stroke();
+	orient = turtleStack.pop();
+	ypos = turtleStack.pop();
+	xpos = turtleStack.pop();
+	}
+
+function Clip(lst, flag) {
+	turtleStack.push(xpos, ypos, orient);
+	Path(lst); ctx.closePath();
+	if(flag == true) ctx.stroke(); 
+	ctx.clip();
+	orient = turtleStack.pop();
+	ypos = turtleStack.pop();
+	xpos = turtleStack.pop();
+	}
+
+function Path(lst) {
+	var x1, y1, x2, y2, x3, y3;
+	var type, dg, dist, phi;
+	
+	ctx.beginPath(); ctx.moveTo(xpos, ypos);
+
+	for (var i = 0; i < lst.length; ) {
+		if(lst[i] == "B")
+			{
+			x1 = lst[i + 1]; y1 = -lst[i + 2]; 
+			x2 = lst[i + 3]; y2 = -lst[i + 4]; 
+			x3 = lst[i + 5]; y3 = -lst[i + 6]; 
+			PathBezier(x1, y1, x2, y2, x3, y3);
+			phi = Math.atan2(y3, x3);
+			orient = orient - 0.5 * Math.PI - phi; // turn 90 right + phi
+			if(phi == 0) Move(x3); else Move(y3 / Math.sin(phi)); 
+			orient = orient + 0.5 * Math.PI; // turn 90 left
+			i += 7;
+			}
+		else {
+			if(lst[i] == "L") {
+				dg = lst[i + 1];
+				dist = lst[i + 2];
+				orient = orient - Math.PI * dg / 180;
+				xpos = xpos + dist *  Math.sin(orient);
+				ypos = ypos + dist *  Math.cos(orient);
+				ctx.lineTo(xpos, ypos);
+				i += 3;
+				}
+			// else invalid format
+			}
+		}
+	}
+	
+function Bezier(x1, y1, x2, y2, x3, y3) {
+	var phi = Math.atan2(y3, x3);
+	ctx.beginPath(); 
+	PathBezier(x1, -y1, x2, -y2, x3, -y3); 
+	orient += phi;
+	orient = orient - Math.PI * 0.5; // turn 90
+	if (phi == 0) { Move(x3); } else { Move(y3 / Math.sin(phi));}
+	orient = orient + Math.PI * 0.5; // turn -90
+	}
+		
+function PathBezier(x1, y1, x2, y2, x3, y3) {
+	ctx.save(); 
+	ctx.translate(xpos, ypos); ctx.rotate(Math.PI - orient);
+	ctx.moveTo(0, 0); ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+	ctx.restore();
+	}
+
+function Polygon(rad, n, flag) {
+	var orientinc = 2 * Math.PI / n;
+	ctx.save();
+	ctx.translate(xpos, ypos); ctx.rotate(-orient);
+	ctx.beginPath(); ctx.moveTo(0, rad);
+	for (var angle = 0; angle < 2 * Math.PI; angle += orientinc) {
+		ctx.lineTo(Math.sin(angle) * rad, Math.cos(angle) * rad);
+		}
+	ctx.closePath(); 
+	if (flag == true) ctx.fill();
+    ctx.stroke();
+	ctx.restore();
+	}
+
+function Pie(rad, height, flag) {
+	var start = Math.PI / 2 - orient;
+	var end = start + (Math.PI / 2) * (height / 90);
+	ctx.beginPath(); ctx.moveTo(xpos, ypos);
+	ctx.arc(xpos, ypos, rad, start, end, false); 
+	ctx.closePath();
+	if (flag == true) ctx.fill();
+    ctx.stroke();
+	}
+
+function Circle(rad, flag) {
+	ctx.beginPath(); ctx.moveTo(xpos + rad, ypos);
+	ctx.arc(xpos, ypos, rad, 0, 6.39, 0);
+	if (flag == true) ctx.fill();
+	ctx.stroke();
+	}
+
+function Ellipse(xrad, yrad, start, end, flag) {
+	ctx.save();
+	ctx.translate(xpos, ypos);
+	ctx.rotate(Math.PI - orient);
+	ctx.beginPath();
+	ctx.scale(1, yrad/xrad);
+	start = Math.PI * start / 180 - Math.PI/2;
+	end =  Math.PI * end / 180 - Math.PI/2;
+	ctx.arc(0, 0, xrad, start, end, 0);
+	ctx.closePath();
+	if (flag == true) ctx.fill();
+    ctx.stroke();
+	ctx.restore();
+	}   
+
+function Text(str) {
+	ctx.save(); ctx.translate(xpos, ypos); ctx.rotate(Math.PI / 2 - orient);
+	ctx.fillText(str, 0, 0);
+	var txt = ctx.measureText(str);	 
+	ctx.restore();
+	Move(txt.width);
+	}
+
+function TextOutline(str) {
+	ctx.save(); ctx.translate(xpos, ypos); ctx.rotate(Math.PI / 2 - orient);
+	ctx.strokeText(str, 0, 0);
+	var txt = ctx.measureText(str);	
+	ctx.restore();
+	Move(txt.width);
+	}
+
+function TextArc(str, radius) {
+	var ainc;
+	for(var i = 0; i < str.length; i++) {
+		ainc =  ctx.measureText(str[i]).width / (2 * radius);
+		orient -= ainc; Text(str[i]); orient -= ainc;
+		}
+	}
+
+function TextArcOutline(str, radius) {
+	var ainc;
+	for(var i = 0; i < str.length; i++) {
+		ainc =  ctx.measureText(str[i]).width / (2 * radius);
+		orient -= ainc; TextOutline(str[i]); orient -= ainc;
+		}
+	}
+
+function drawAllCanvas() { try
+	{
+	// if(!ctx.fillText) document.write('function fillText() not suppported on this browser');
+[/text])
+
+(set 'script-template [text]
+	var canvas=document.getElementById('%s');
+	var ctx=canvas.getContext('2d'); Ctx(ctx);
+	canvasWidth = %g; canvasHeight = %g;
+	xpos = 0; ypos = canvasHeight;
+	orient = Math.PI;
+	turtleStack = new Array();
+	ctx.lineWidth = 1;
+	ctx.strokeStyle = 'rgb(0, 0, 0)';
+	ctx.fillStyle = 'rgb(0, 0, 0)';
+
+<!-- start generated JavaScript -->
+[/text])
+
+(define (cv:cv str) (write-line canvas-script str))
+
+(set 'script-close [text]
+<!-- end generated JavaScript -->
+
+	} catch (er) {    }
+} 
+</script></head><body onload="drawAllCanvas();">
+[/text])
+
+; same definition as html:html
+(define (cv:html str) (write-line body-html str))
+
+(set 'canvas-template [text]<canvas id="%s" width="%d" height="%d"></canvas>[/text])
+
+(set 'body-close "</body></html>\n")
+
+; user functions
+
+(define (cv:header tags )
+	(set 'header-tags tags)
+)
+
+(define (cv:canvas canvas-name (width 300)  (height 200))
+	(cv (format script-template canvas-name width height))
+	(html (format canvas-template canvas-name width height))
+)
+
+(define (cv:goto x y)
+	(cv (format "Goto(%g, %g);" x y))
+)
+
+
+(define (cv:move s)
+	(cv (format "Move(%g);" s))
+)
+
+
+(define (cv:turn dg)
+	(cv (format "Turn(%g);" dg))
+)
+
+
+(define (cv:angle dg)
+	(cv (format "Angle(%g);" dg))
+)
+
+
+(define (cv:draw s)
+	(cv (format "Draw(%g);" s))
+)
+
+
+(define (cv:drawto x y)
+	(cv (format "Drawto(%g, %g);" x y))
+)
+
+	
+(define (cv:line lst)
+	(cv (format "Line(new Array(%s));" (list-path lst)))
+)
+
+
+(define (list-path lst)
+	(let ( (buff "") (rec nil))
+		(while (set 'rec (pop lst))
+			(if (= (length rec) 6)
+				(extend buff (string ",'B'," (join (map string rec) ","))))
+			(if (= (length rec) 2)
+				(extend buff (string ",'L'," (rec 0) "," (rec 1)))))
+		(1 buff)
+) )
+	
+
+(define (cv:bezier x1 y1 x2 y2 x3 y3)
+	(cv (format "Bezier(%g, %g, %g, %g, %g, %g); ctx.stroke();"
+			 x1 y1 x2 y2 x3 y3))
+)
+
+
+(define (cv:polygon rad n flag)
+	(cv (format "Polygon(%g, %g, %s);"
+		rad n (if flag "true" "false")))
+)
+
+
+(define (cv:circle rad flag)
+	(cv (format "Circle(%g, %s);" rad (if flag "true" "false")))
+)
+
+
+(define (cv:ellipse xr yr start end mode)
+	(cv (format "Ellipse(%g, %g, %g, %g, %s);"
+			xr yr start end (if mode "true" "false")))	
+)
+
+
+(define (cv:rectangle width height flag)
+	(shape (list (list 0 height) (list 90 width) (list 90 height) (list 90 width)) flag)
+)
+
+
+(define (cv:pie rad width flag)
+	(cv (format "Pie(%g, %g, %s);" rad width (if flag "true" "false")))
+)
+
+
+(define (cv:petal width height flag)
+    ; x3 (offset from x1) cannot be 0 or the Bezier does not get drawn
+	(bezier (sub width) height width height 0.001 0 flag)
+	(cv (format "Bezier(%g, %g, %g, %g, %g, %g);"
+			 (sub width) height width height 0.001 0))
+	(cv "ctx.closPath")
+	(if flag (cv "ctx.fill();"))
+    (cv "ctx.stroke();")
+)
+
+
+(define (cv:shape lst flag) 
+	(cv (format "Shape(new Array(%s), %s);" 
+			(list-path lst)
+			(if flag "true" "false")))
+)
+
+
+(define (cv:clip lst flag) 
+	(cv (format "Clip(new Array(%s), %s);" 
+		(list-path lst)  (if flag "true" "false")))
+)
+
+
+(define (cv:text str)
+	(cv (format {Text("%s");} str))
+)
+
+(define (textoutline str)
+	(cv (format {TextOutline("%s");} str))
+)
+
+
+(define (cv:textarc str radius)
+	(cv (format {TextArc("%s", %g);} str radius))
+) 
+
+
+(define (cv:textarcoutline str radius)
+	(cv (format {TextArcOutline("%s", %g);} str radius))
+) 
+
+
+(define (cv:translate x y)
+	(if (and x y)
+		(cv (format "ctx.translate(%g, -%g);" x y))
+		(cv "ctx.translate(xpos, - (canvasHeight - ypos));")
+	)
+)
+
+
+(define (cv:scale x y)
+	(cv (format "Scale(%g, %g);" x y))
+)
+
+
+(define (cv:rotate dg)
+	(cv (format "ctx.rotate(%g);" (mul pi/2 (div dg 90))))
+)
+
+
+(define (cv:gsave) (cv "Gsave();"))
+
+
+(define (cv:grestore) (cv "Grestore();"))
+
+
+(define (cv:font spec) (cv (format {ctx.font = "%s";} spec)))
+
+
+(define (cv:line-cap mode) 
+	(if (number? mode) (set 'mode (nth mode '("but" "round" "square"))))
+	(cv (format "ctx.lineCap = '%s';" mode)))
+
+
+(define (cv:line-join mode)
+	(if (number? mode) (set 'mode (nth mode '("miter" "round" "bevel")))) 
+	(cv (format "ctx.lineJoin = '%s';" mode)))
+
+
+(define (line-color red green blue alpha)
+    (if (string? red)
+        (let (color red)
+          (set 'red (div (int (append "0x" (0 2 color)) 0 16) 255))
+          (set 'green (div (int (append "0x" (2 2 color)) 0) 255))
+          (set 'blue (div (int (append "0x" (4 2 color)) 0) 255))))
+
+	(if alpha
+   	  (cv (format "ctx.strokeStyle = 'rgba(%d, %d, %d, %g)';" 
+			(mul red 255) (mul green 255) (mul blue 255) alpha))
+   	  (cv (format "ctx.strokeStyle = 'rgb(%d, %d, %d)';" 
+			(mul red 255) (mul green 255) (mul blue 255) )))
+)
+
+
+(define (cv:line-width width)
+	(cv (format "ctx.lineWidth = %g;" width))
+)
+
+(define (fill-color red green blue alpha)
+    (if (string? red)
+        (let (color red)
+          (set 'red (div (int (append "0x" (0 2 color)) 0 16) 255))
+          (set 'green (div (int (append "0x" (2 2 color)) 0) 255))
+          (set 'blue (div (int (append "0x" (4 2 color)) 0) 255))))
+
+	(if alpha
+   	  (cv (format "ctx.fillStyle = 'rgba(%d, %d, %d, %g)';" 
+			(mul red 255) (mul green 255) (mul blue 255) alpha))
+   	  (cv (format "ctx.fillStyle = 'rgb(%d, %d, %d)';" 
+			(mul red 255) (mul green 255) (mul blue 255) )))
+)
+
+(define (cv:render mode)
+	(let (page (append (format template-header header-tags)
+				script-header
+				canvas-script
+				script-close
+				body-html
+				body-close)) 
+		(cond 	
+			( 	(nil? mode) 
+                ; on Emscripten open tab 
+                (if eval-string-js 
+                    (display-html page true)
+                    (show-in-browser)))
+
+	 		( 	(= (upper-case mode) "CGI") 
+				(println page))
+
+			( true 
+				(write-file mode page))
+		)
+	)
+)
+
+(define cv:save cv:render) ; compatibility with older postscript.lsp code
+				
+(define (show-in-browser)
+(write-file "/tmp/noname.html" page)
+  (cond
+    ( (= ostype "OSX")
+      (exec "open /tmp/noname.html"))
+    ( (= ostype "Windows")
+      (set 'prog (string "cmd /c \"" (env "PROGRAMFILES") 
+;                 Use either Firefox or Safari 4.0
+;                 "/Mozilla Firefox 3.1 Beta 2/firefox.exe\""))
+                  "/Safari/Safari.exe\""))
+;     (println "->" prog "<-")
+      (exec (string prog " file://c:/tmp/noname.html")))
+    ( true // all Linux and other unix
+      (set 'files '(
+            "/usr/bin/sensible-browser"
+            "/usr/bin/x-www-browser"
+            "/usr/bin/mozilla"
+            "/usr/bin/firefox"
+            "/usr/bin/konqueror"
+            ))
+      (set 'prog (find true (map file? files)))
+      (if prog
+        (exec (string (files prog) " file:///tmp/noname.html"))
+        (println "Cannot find browser to display documentation" "warning")) )
+  ) ; cond
+) ; define
+
+(context MAIN)
+; eof
diff --git a/modules/cgi.lsp b/modules/cgi.lsp
new file mode 100644
index 0000000..f7acc0c
--- /dev/null
+++ b/modules/cgi.lsp
@@ -0,0 +1,218 @@
+;; @module cgi.lsp
+;; @description Basic CGI processing tools for GET and POST requests
+;; @version v 2.2 - comments redone for automatic documentation
+;; @version v 2.3 - a fix in CGI:url-translate when translating utf-8 strings
+;; @version v 2.4 - check for empty string when aquiring HTTP_COOKIE environment
+;; @version v 2.5 - cleanup put-page for 10.0
+;; @version v 2.6 - help text corrections
+;; @version v 2.72 - help text corrections
+;; @version v 2.8 - check for and use CONTENT_LENGTH when reading POST data
+;; @version v 2.9 - eliminate deprecated integer -> int
+;; @version v 2.91 - minor code cleanup in CONTENT_LENGTH handling
+;; @version v 3.0 - handle multipart POST data. Added by Unya, Oct 2012
+;; @version v 3.2 - fixed for large POST data
+;; @author Lutz Mueller, Unya 2002-2012
+;;
+;; This module defines basic CGI processing tools for processing
+;; CGI GET and POST requests and cookies.
+;;
+;; Include this file at the beginning of each file performing CGI processing using
+;; either one of the following lines:
+;; <pre>
+;; (load "/usr/share/newlisp/cgi.lsp")
+;; ; or as a shorter alternative
+;; (module "cgi.lsp")
+;; </pre>
+;; <center><h2>Overview</h2></center>
+;; On loading 'cgi.lsp' will retrieve 'GET', 'POST' and cookie
+;; parameters via standard input and the environment variables: 
+;; 'QUERY_STRING' and 'HTTP_COOKIE'. These environment variables are set
+;; by the webserver (tested with Apache 1.3). The webserver is receiving information
+;; back from 'cgi.lsp' via std I/O channels.
+;; 
+;; After having loaded this file all parameters from either 'GET' or 'POST'
+;; method are stored as an association list and in 'CGI:params'
+;; and individual parameters can be accessed using 'CGI:get'.
+;;
+;; All cookies can be accessed in an association list 'CGI:cookies' and
+;; are accessed similar to the 'GET' and 'PUT' parameters using 'CGI:get-cookie'.
+;; A function 'CGI:set-cookie' is available for setting cookies.
+;;
+;; The function 'CGI:put-page' outputs a HTML page to the webserver after
+;; processing newLISP source embedded in '&lt;%' and '%&gt;' tags.
+;;
+;; 'CGI:params' and 'CGI:cookies' contain the empty list '()' when no
+;; parameters or cookies are present
+;;
+;; The function 'CGI:put-page' can be used to output web pages containing
+;; newLISP source embedded in &lt;%, %&gt; tags. Inside these tags are newLISP
+;; statements printing output/HTML to the webpage.
+
+(context 'CGI)
+
+;; @syntax (CGI:put-page <str-file-name>)
+;; @param <str-file-name> The HTML file containing '&lt;%' and '%&gt;' tags.
+;; @return The page output to standard out.
+;; Processes an HTML page by evaluating newLISP source
+;; embedded into the HTML text between '&lt;%' and '%&gt;' tags.
+;; The newLISP source typically contains 'print' and 'println'
+;; statements to output strings to standard out.
+;;
+;; @example
+;; <html>
+;; <body>
+;; <% (set 'site "example.com") %>
+;; <a href="http://<% (print site) %>"><% (print site) %></a>
+;; </body>
+;; </html>
+;; 
+;; - will output -
+;; 
+;; <html>
+;; <body>
+;; <a href="http://example.com">example.com</a>
+;; </body>
+;; </html>
+
+(define (put-page file-name , page start end)
+    (set 'page (read-file file-name))
+    (set 'start (find "<%" page))
+    (set 'end (find "%>" page))
+    (while (and start end)
+        (print (slice page 0 start))
+        (eval-string (slice page (+ start 2) (- end start 2)) MAIN)
+        (set 'page (slice page (+ end 2)))
+        (set 'start (find "<%" page))
+        (set 'end (find "%>" page)))
+    (print page))
+
+;; @syntax (CGI:url-translate <str-url-format>)
+;; @param <str-url-format> The URL formatted string to translate.
+;; @return An ASCII formatted string.
+;; Translates all URL formatted characters to ASCII. Translates '+' into spaces 
+;; and '%nn' hexdigits into characters. 'nn' is a 2-nibble hex number. 
+;;
+;; @example
+;; (CGI:url-translate "What+time+is+it%3f")  => "What time is it?"
+
+(define (url-translate str)
+   (replace "+" str " ")
+   (replace "%([0-9A-F][0-9A-F])" str (format "%c" (int (append "0x" $1))) 1))
+
+
+; This is not an user function, but used internally.
+;
+; get-vars returns all parameter value pairs in an association list
+; i.e.: ( ("name" "johndoe") ("password" "secret") )
+; they can than be accessed using:
+;     (assoc "name" params) => "johndoe"
+; where params is the return value from get-vars
+ 
+(define (get-vars input , var value var-value)
+    (set 'vars (parse input "&"))
+    (dolist (elmnt vars) 
+	(if (find "=" elmnt) 
+	    (begin
+              (set 'var (first (parse elmnt "=")))
+              (set 'value ((+ (find "=" elmnt) 1) elmnt)))
+	    (begin
+	      (set 'var elmnt)
+	      (set 'value "")))
+	(push (list var (url-translate value)) var-value))
+    var-value) ; no necessary after v.9.9.5
+
+
+; get QUERY_STRING parameters from GET method if present
+;
+(set 'params (env "QUERY_STRING"))
+(if (not params) (set 'params ""))
+(if params
+	(set 'params (get-vars params)))
+
+; get POST data if present, use CONTENT_LENGTH variable
+; if available
+(if (env "CONTENT_LENGTH")
+    (when (= (env "REQUEST_METHOD") "POST")
+        (set 'post-data "")
+        (while (read (device) buffer (int (env "CONTENT_LENGTH")))
+            (write post-data buffer))
+
+        (let (boundary (when (regex "multipart/form-data; boundary=(.*)"
+                (env "CONTENT_TYPE")) (append "--" $1)))
+        ; handle multi part form data
+          (if boundary
+             (let (data (parse (url-translate post-data) boundary))
+                (while data
+                    (let (line (first data))
+                        (setq data (rest data))
+                        (when
+                            (regex "Content-Disposition: form-data; name=\"(.*)\"\r\n\r\n(.*)$" line 4)
+                                (push (list $1 (chop $2 2)) params) )
+                    ) ) )
+              (set 'params (get-vars post-data)))
+		) )
+    (begin
+        (set 'inline (read-line))
+        (when inline 
+        (set 'params (get-vars inline)))
+    )
+)
+ 
+(if (not params) (set 'params '()))
+
+
+; get cookies
+;
+(if (and (env "HTTP_COOKIE") (not (empty? (env "HTTP_COOKIE"))))
+    (dolist (elmnt (parse (env "HTTP_COOKIE") ";"))
+		(set 'var (trim (first (parse elmnt "="))))
+		(set 'value (slice elmnt (+ 1 (find "=" elmnt))))
+		(push (list var value) cookies))
+    (set 'cookies '()))
+
+;; @syntax (CGI:set-cookie <str-var> <str-value> <str-domain> <str-path>)
+;; @param <str-var> The cookie variable name as a string.
+;; @param <str-value> The cookie value as a string.
+;; @param <str-domain> The domain where to set the cookie.
+;; @param <str-path> The path for the domain.
+;; @return The string sent to standard out by 'CGI:set-cookie'.
+;; This function should be called immedeately before
+;; closing the header with '(print "Content-Type: text/html\r\n\r\n")',
+;; which is typically the first statement in a CGI script written in
+;; newLISP after the '(module "cgi.lsp")' statement.
+;;
+;; @example
+;; (module "cgi.lsp")
+;;
+;; (CGI:set-cookie "password" "secret" "asite.com" "/somedir")
+;; (print "Content-Type: text/html\r\n\r\n")
+;; ...
+
+(define (set-cookie var value domain path)
+    (set 'value (string value))
+    (print (format "Set-Cookie: %s=%s; domain=.%s; path=%s;\n" var value domain path)))
+
+
+;; @syntax (CGI:get-cookie <str-key>)
+;; @param <str-key> The string for the cookie variable name.
+;; @return The string for the cookie value.
+;; @example
+;; (CGI:get-cookie "login")   =>  "somebody" 
+
+(define (get-cookie keystr)
+	(lookup keystr cookies) )
+
+;; @syntax (CGI:get <str-key>)
+;; @param The name of the 'GET' or 'POST' variable as a string.
+;; @return The value string of the 'GET' or 'POST' variable.
+
+(define (get keystr)
+   (lookup keystr params))
+
+;; @example
+;; (CGI:get "city") => "San Francisco"
+
+
+(context 'MAIN)
+
+; eof ;
diff --git a/modules/crypto.lsp b/modules/crypto.lsp
new file mode 100644
index 0000000..26d7bda
--- /dev/null
+++ b/modules/crypto.lsp
@@ -0,0 +1,183 @@
+;; @module crypto.lsp 
+;; @description SSL crypto functions for MD5 and SHA-1 hashing
+;; @version 1.01 - initial release
+;; @version 1.02 - renamed to crypto, new lib detection
+;; @version 1.04 - added hmac encryption from amazon.com query API
+;; @version 1.05 - added added gnuwin32/bin/libeay32.dll for crypto on Win32
+;; @version 1.06 - added ripemd160
+;; @version 1.07 - added libcrypto for OpenBSD and tested for 64-bit
+;; @version 1.08 - help text corrections
+;; @version 1.09 - added lib path for Windows 7
+;; @version 1.10 - added SHA256
+;; @version 1.11 - added  path for UBUNTU Linux 13.04
+;; @version 1.12 - added  path for UBUNTU Linux 12.04 and CentOS, removed old
+;; @version 1.13 - fix for crypto:hmac. Thanks Cormullion, March 2014
+;; @version 1.14 - starting v10.6.3 import using "cdecl" on Windows
+;; @version 1.15 - added path for Debian Jessie
+;; @author Lutz Mueller 2007, Martin Quiroga 2007, Norman Deppenbroek 2009, 
+;; @author Marc Hildman, 2011
+;;
+;; <h2>Module for SSL lib crypto  bindings</h2>
+;; This modules imports functions for the MD5 and SHA-1 hashing algorithms described
+;; here: @link http://www.ietf.org/rfc/rfc3174.txt http://www.ietf.org/rfc/rfc3174.txt .
+;; The crypto library is part of the @link http://www.openssl.org/ OpenSSL libraries.
+;; 
+;; To use this module include the following 'load' statement at the
+;; beginning of the program file:
+;; <pre>
+;; (load "/usr/share/newlisp/modules/crypto.lsp")
+;; ; or as a shorter alternative
+;; (module "crypto.lsp")
+;; </pre>
+;; <h2>Requirements:</h2> 
+;; On Mac OS X, UBUNTU and many other Linux, BSDs and other UNIX installations
+;; <tt>libcrypto.so</tt> is installed by default as part of the OpenSSL
+;; libraries in <tt>usr/lib/libcrypto.so</tt>. If loading this module 
+;; finishes with an error message the path of the library should be corrected.
+;; For MS Windows a library is available at 
+;; @link http://gnuwin32.sourceforge.net/ http://gnuwin32.sourceforge.net/ .
+;; 
+;; This module has been tested on Mac OS X, UBUNTU Linux and FreeBSD.
+
+(context 'crypto)
+
+; set library to path-name of the library on your platform OS
+;
+(set 'files '(
+              "C:/Program Files/gnuwin32/bin/libeay32.dll" ; XP
+              "C:/Program Files (x86)/gnuwin32/bin/libeay32.dll" ; 7
+              "/usr/lib/x86_64-linux-gnu/libcrypto.so" ; Ubuntu 12.04 LTS
+              "/usr/lib/i386-linux-gnu/libcrypto.so"; Ubuntu 12.04
+              "/lib/i386-linux-gnu/libcrypto.so.1.0.0" ; UBUNTU Linux 13.04
+              "/usr/lib64/libcrypto.so" ; Fedora, CentOS 6.x
+              "/usr/lib/x86_64-linux-gnu/libcrypto.so.1.0.0" ; Debian jessie
+              "/usr/lib/libcrypto.so"
+              "/usr/lib/libcrypto.so.4"
+              "/usr/lib/libcrypto.so.18.0" ; OpenBSD 4.6
+              "/usr/lib/libcrypto.so.19.0" ; OpenBSD 5.0
+              "/usr/lib/libcrypto.dylib"
+              ))
+
+(set 'library (files (or
+                      (find true (map file? files))
+                      (throw-error "cannot find crypto library"))))
+
+(set 'option (if (= ostype "Windows") "cdecl"))
+
+(import library "MD5" option)
+(import library "RIPEMD160" option)
+(import library "SHA1" option)
+(import library "SHA256" option)
+
+;; @syntax (crypto:md5 <string> <bool-raw>)
+;; @param <string> The string buffer for which to calculate a MD5 hash
+;; @param <bool-raw> Return the raw binay buffer when 'true'.
+;; @return The 16 Byte MD5 hash as a 32 Byte long hex string or as a 16 byte binary buffer.
+;; @example
+;; (crypto:md5 "ABC") => "902fbdd2b1df0c4f70b4a5d23525e932"
+;;
+;; (crypto:md5 (read-file "newlisp-9.1.0.tgz")) => "46c79c93e904df35c6a8474ace406c92"
+
+(define (md5 str raw-flag)
+  (if raw-flag
+      (let (buff (dup "\000" 16))
+        (cpymem (MD5 str (length str) 0) buff 16)
+        buff)
+    (join
+     (map (lambda (x) (format "%02x" (& x 0xff))) 
+          (unpack (dup "c" 16) (MD5 str (length str) 0))))
+    )
+  )
+
+;; @syntax (crypto:sha1 <string> <bool-raw>)
+;; @param <string> The string buffer for which to calculate a SHA-1 hash
+;; @param <bool-raw> Return the raw binay buffer when 'true'.
+;; @return The 20 Byte SHA-1 hash as a 40 Byte long hex string or as a 20 byte binary buffer.
+;; @example
+;; (crypto:sha1 "ABC") => "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8"
+;;
+;; (crypto:sha1 (read-file "newlisp-9.1.0.tgz")) => "2127a9c487f338b00f36cfd60b5f33d27b8d0010"
+
+(define (sha1 str raw-flag)
+  (if raw-flag
+      (let (buff (dup "\000" 20))
+        (cpymem (SHA1 str (length str) 0) buff 20)
+        buff)
+    (join
+     (map (lambda (x) (format "%02x" (& x 0xff))) 
+          (unpack (dup "c" 20) (SHA1 str (length str) 0)))
+     )
+    )
+  )
+
+;; @syntax (crypto:sha256 <string> <bool-raw>)
+;; @param <string> The string buffer for which to calculate a SHA-256 hash
+;; @param <bool-raw> Return the raw binay buffer when 'true'.
+;; @return The 32 Byte SHA-1 hash as a 64 Byte long hex string or as a 32 byte binary buffer.
+;; @example
+;; (crypto:sha256 "ABC") => "b5d4045c3f466fa91fe2cc6abe79232a1a57cdf104f7a26e716e0a1e2789df78" 
+;;
+(define (sha256 str raw-flag)
+  (if raw-flag
+      (let (buff (dup "\000" 32))
+        (cpymem (SHA256 str (length str) 0) buff 32)
+        buff)
+    (join
+     (map (lambda (x) (format "%02x" (& x 0xff))) 
+          (unpack (dup "c" 32) (SHA256 str (length str) 0)))
+     )
+    )
+  )
+
+
+;; @syntax (crypto:hmac <func-hash> <str-message> <str-key>)
+;; @param <func-hash> The hash function to use.
+;; @param <str-message> The message to encrypt.
+;; @param <str-key> The encryption key.
+;;
+;; This function is part of the amazon.com
+;; @link http://docs.amazonwebservices.com/AWSEC2/2007-08-29/DeveloperGuide/using-query-api.html Query-API
+;; and based on @link http://www.faqs.org/rfcs/rfc2104.html RFC2104 - HMAC: Keyed-Hashing for Message Authentication.
+;;
+;; @example
+;; (set 'output (crypto:hmac crypto:md5 "Hello World" "secret"))
+;; (unpack (dup "c" (length output)) output)
+;; => (107 59 -76 66 117 -119 -35 -31 -7 -121 90 55 -109 -68 32 98)
+
+(define (hmac hash_fn msg_str key_str , blocksize opad ipad)
+  (set 'blocksize 64)
+  (set 'opad (dup "\x5c" blocksize))
+  (set 'ipad (dup "\x36" blocksize))
+  (if (> (length key_str) blocksize)
+      ;; (set 'key_str (get-true-str (hash_fn key_str))) 
+      (set 'key_str (hash_fn key_str true))
+    )
+  (set 'key_str (append key_str (dup "\000" (- blocksize (length key_str))))) ;; padding key with binary zeros
+  (set 'opad (encrypt opad key_str))
+  (set 'ipad (encrypt ipad key_str))
+  (hash_fn (append opad (hash_fn (append ipad msg_str) true)) true)
+  )
+
+
+;; @syntax (crypto:ripemd160 <string> <bool-raw>) 
+;; @param <string> The string buffer for which to calculate a RIPEMD160 hash 
+;; @param <bool-raw> Return the raw binay buffer when 'true'. 
+;; @return The 20 Byte RIPEMD160 hash as a 40 Byte long hex string or as a 20 byte binary buffer. 
+;; @example 
+;; (crypto:ripemd160 "ABC") => "df62d400e51d3582d53c2d89cfeb6e10d32a3ca6" 
+;; 
+;; (crypto:ripemd160 (read-file "newlisp.exe")) => "9c1185a5c5e9fc54612808977ee8f548b2258d31" 
+
+(define (ripemd160 str raw-flag) 
+  (if raw-flag 
+    (let (buff (dup "\000" 20)) 
+      (cpymem (RIPEMD160 str (length str) 0) buff 20) 
+      buff) 
+    (join 
+     (map (lambda (x) (format "%02x" (& x 0xff))) 
+          (unpack (dup "c" 20) (RIPEMD160 str (length str) 0))) 
+     ) 
+    ) 
+  )
+
+; eof ;
diff --git a/modules/ftp.lsp b/modules/ftp.lsp
new file mode 100644
index 0000000..cc2e05a
--- /dev/null
+++ b/modules/ftp.lsp
@@ -0,0 +1,147 @@
+;; @module ftp.lsp
+;; @description FTP file transfer routines
+;; @version 1.4 - comments redone for automatic documentation
+;; @version 1.5 - change in read-buffer for v.10.0
+;; @version 1.6 - change in net-receive for v.10.0
+;; @version 1.7 - doc changes
+;; @version 1.8 - <tt>write</tt>, <tt>read</tt> and compatibility with pre v10.1.11
+;; @author Eddie Rucker, Lutz Mueller, 2003-2010
+;; <h2>FTP file transfer routines</h2>
+;; To use the module put a 'load' statement at beginning of your
+;; program file:
+;; <pre>
+;; (load "/usr/local/share/newlisp/modules/ftp.lsp")
+;; ; or shorter
+;; (module "ftp.lsp")
+;; </pre>
+;; In case of failure the functions return 'nil' and further detail
+;; may be found in the variable 'FTP:result'.
+;;
+;; To set debug mode, which shows all dialog with the server, set
+;; 'FTP:debug-flag':
+;; 
+;; <tt>(set 'FTP:debug-flag true)</tt>
+
+; compatibility with versions older than 10.1.11
+(when (< (sys-info -2) 10111)
+	(constant (global 'write) write-buffer)
+	(constant (global 'read) read-buffer))
+
+(context 'FTP)
+
+; debugging mode
+(set 'debug-mode nil)
+
+; mode of transfer
+(define GET 1)
+(define PUT 2)
+
+;; @syntax (FTP:get <str-user-id> <str-password> <str-host> <str-dir> <str-file-name>)
+;; @param <str-user-id> The user ID for logon.
+;; @param <str-password> The password for the user ID.
+;; @param <str-host> The remote host name or IP as a string.
+;; @param <str-dir> The subdirectory on the host.
+;; @param <str-file-name> The name of the file to transfer.
+;; @return 'true' on success, 'nil' on failure.
+;; @example
+;; (FTP:get "somebody" "secret" "host.com" "subdir" "aFile.tgz")  ;; download
+;; (FTP:get "somebody" "secret" "192.168.1.120" "" "myfile.txt")  ;; download
+
+;; When leaving the string for the sub directory empty, the current directory "."
+;; is assumed on the host.
+
+(define (get user-id password host subdir file-name)
+    (transfer user-id password host subdir file-name GET))
+
+;; @syntax (FTP:put <str-user-id> <str-password> <str-host> <str-dir> <str-file-name>)
+;; @param <str-user-id> The user ID for logon.
+;; @param <str-password> The password for the user ID.
+;; @param <str-host> The remote host name or IP as a string.
+;; @param <str-dir> The sub directory on the host.
+;; @param <str-file-name> The name of the file to transfer.
+;; @return 'true' on success, 'nil' on failure.
+;; @example
+;; (FTP:put "somebody" "secret" "host.com" "subdir" "file")  ;; upload
+
+(define (put user-id password host subdir file-name)
+    (transfer user-id password host subdir file-name PUT))
+
+(define (transfer user-id password host subdir file-name mode)
+  (if (= subdir "") (set 'subdir "."))
+  (and
+    (connect-to host 21)
+    (send-get-result (append "USER " user-id "\r\n") "3")
+    (send-get-result (append "PASS " password "\r\n") "2")
+    (send-get-result (append "CWD " subdir "\r\n") "2")
+    (send-get-result "TYPE I\r\n" "2")
+    (set 'buff (send-get-result "PASV\r\n" "2"))
+    (regex {(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)} buff)
+    (set 'port (+ (* 256 (int $5)) (int $6)))
+    (set 'ip (string $1 "." $2 "." $3 "." $4))
+    (set 'socket2 (net-connect ip port))
+
+    (if (= mode PUT)
+        (and
+            (check-file file-name)
+            (net-send socket (append "STOR " file-name "\r\n"))
+            (send-get-result "STAT\r\n" "1")
+            (set 'fle (open file-name "r"))
+            (while (> (read fle buffer 512) 0)
+                (if debug-mode (print "."))
+                (net-send socket2 buffer 512))
+            (close fle)) true)
+
+    (if (= mode GET)
+        (and
+            (net-send socket (append "RETR " file-name "\r\n"))
+            (send-get-result "STAT\r\n" "1")
+            (set 'fle (open file-name "w"))
+            (while (net-receive socket2 buffer 512)
+                (if debug-mode (print "."))
+                (write fle buffer))
+            (close fle)) true)
+
+    (or (net-close socket2) true)
+    (net-send socket "QUIT\r\n")
+    (or (net-close socket) true)))
+
+(define (send-get-result str code)
+    (net-send socket str)
+    (if debug-mode (println "sent:" str))
+    (net-receive socket result 256 "\r\n")
+    (if debug-mode (println result))
+    (if (starts-with result code) result))
+
+(define (connect-to host port)
+    (set 'FTP:result nil)
+    (set 'socket (net-connect host port))
+    (if socket
+        (net-receive socket result 256 "\r\n")
+        (begin
+            (set 'result "could not connect")
+            nil)))    
+    
+(define (check-file file-name)
+    (if (file? file-name)
+        true
+        (begin
+            (set 'result (append file-name " does not exist"))
+            nil)))
+
+(context 'MAIN)
+
+; test
+;
+;(set 'FTP:debug-mode true)
+;
+;(FTP:put "userid" "password" "site.com" "tmp" "testfile")
+;
+;(FTP:get "userid" "password" "site.com" "tmp" "testfile")
+;
+;(exit)
+
+
+
+; eof
+
+
diff --git a/modules/getopts.lsp b/modules/getopts.lsp
new file mode 100644
index 0000000..4343063
--- /dev/null
+++ b/modules/getopts.lsp
@@ -0,0 +1,174 @@
+;; @module getopts.lsp
+;; @description Parse short and long command line options according to POSIX rules
+;; @version 1.0 initial release
+;; @author Ted Walther, July 2011
+;;
+;; POSIX options come in 4 types; long and short, with or without an extra argument.
+;;
+;; Short options are just a single letter with a <tt>-</tt> in front. '-a -v -h' are single options.  Short options can be collapsed together.  '-a -v -h' is the same thing as '-avh'
+;;
+;; A short option that takes an argument can take the following two forms: '-fmyletter.txt' is the same as '-f myletter.txt'
+;;
+;; Long options start with '--'.  '--quiet' and '--help' are good examples.
+;;
+;; A long option that takes an argument can be in the following two forms: '--file=myletter.txt' is the same as '--file myletter.txt'
+;;
+;; Here is an example of how to use this module.  It includes a bunch of standard options that every GNU program should support.
+;; 
+;; @example
+;;
+;; (module "getopts.lsp")
+;; 
+;; (setq version-string "Version: 1.0 (2011)")
+;;
+;; (shortopt "V" (getopts:die version-string) nil "Print version string")
+;; (shortopt "v" (++ verbosity) nil "Increase verbosity")
+;; (shortopt "q" (setq verbosity 0) nil "Quiet")
+;; (shortopt "?" (getopts:usage) nil "Print this help message")
+;; (shortopt "h" (getopts:usage) nil "Print this help message")
+;; (shortopt "o" (setq output-file getopts:arg) "file" "Output file")
+;; (longopt "help" (getopts:usage) nil "Print this help message")
+;; (longopt "quiet" (setq verbosity 0) nil "Quiet")
+;; (longopt "verbose" (++ verbosity) nil)
+;; (longopt "version" (getopts:die version-string) nil "Print version string")
+;; (longopt "output" (setq output-file getopts:arg) "file" "Output file")
+;; 
+;; (println (main-args))
+;; (println (getopts (2 (main-args))))
+;; (println "Verbosity: " verbosity)
+;; (println "Output To: " output-file)
+;; (exit)
+
+;; @syntax (shortopt <opt> <action> <arg?> <desc>)
+;; @param <opt> The single letter option
+;; @param <action> The code to execute when the option is found
+;; @param <arg?> 'nil' if the option doesn't take an argument, otherwise a string that describes the type of argument the option takes.
+;; @param <desc> A string that describes the option.  This is used by the 'usage' function.
+;; @example
+;; (shortopt "o" (setq output-file getopts:arg) "file" "Output file")
+;; ...
+;; $ ./myscript.lsp -ofoo.txt -q
+;; $ ./myscript.lsp -qofoo.txt
+;; $ ./myscript.lsp -o foo.txt -q
+;; $ ./myscript.lsp -qo foo.txt
+(define-macro (shortopt opt action arg? desc)
+  (if (assoc opt getopts:short)
+      (setf (assoc opt getopts:short) (list opt (list action arg? (or desc ""))))
+    (push (list opt (list action arg? (or desc ""))) getopts:short)))
+
+;; @syntax (longopt <opt> <action> <arg?> <desc>)
+;; @param <opt> The long option
+;; @param <action> The code to execute when the option is found
+;; @param <arg?> 'nil' if the option doesn't take an argument, otherwise a string that describes the type of argument the option takes.
+;; @param <desc> A string that describes the option.  This is used by the 'usage' function.
+;; @example
+;; (longopt "output" (setq output-file getopts:arg) "file" "Output file")
+;; ...
+;; $ ./myscript.lsp --output=foo.txt --quiet
+;; $ ./myscript.lsp --verbose --output foo.txt
+(define-macro (longopt opt action arg? desc)
+  (if (assoc opt getopts:long)
+      (setf (assoc opt getopts:long) (list opt (list action arg? (or desc ""))))
+    (push (list opt (list action arg? (or desc ""))) getopts:long)))
+
+;; @syntax getopts:arg
+;;
+;; The variable <getopts:arg> holds the argument to the option, for those options
+;; which take an argument.  This is useful inside the <action> code, so you can make
+;; use of the argument.  For instance, '--prefix=/usr/bin' on the command line, would
+;; leave the value '/usr/bin' in <getopts:arg>, and your <action> code could store the
+;; value or act on it in some other way.
+
+(context 'getopts)
+
+(define short (list))
+(define long (list))
+
+;; @syntax (getopts:usage)
+;; @return Exits script with a value of 0
+;; Prints out every command line option that has been registered with the getopts module.
+;;
+;; @example
+;; (shortopt "?" (getopts:usage) nil "Print this help message")
+;; ...
+;; $ ./myscript.lsp -?
+;; ==>
+;; Usage: ./myscript.lsp [options]
+;; 	 -o file           	Output file
+;; 	 -h                	Print this help message
+;; 	 -?                	Print this help message
+;; 	 -q                	Quiet
+;; 	 -v                	Increase verbosity
+;; 	--output file           	Output file
+;; 	--verbose                	
+;; 	--quiet                	Quiet
+;; 	--help                	Print this help message
+;;
+
+(define (usage)
+  (println "Usage: " (main-args 1) " [options]")
+  (dolist (o short) (println (format "\t -%s %-15s\t%s" (o 0) (or (o 1 1) "") (o 1 2))))
+  (dolist (o long) (println (format "\t--%s %-15s\t%s" (o 0) (or (o 1 1) "") (o 1 2))))
+  (exit 0))
+
+;; @syntax (getopts:die <format-string> [<format options...>])
+;; @return Exits script with a value of 1
+;; Prints an error message, then exits.  Syntax is exactly the same as the 'format' function.
+
+(define-macro (die)
+  (println (eval (append (list 'format) (args)))) (exit 1))
+
+(define (getopts:getopts arglst)
+  (let (unoption-args (list))
+    (while arglst
+      (let (a (pop arglst))
+	(cond
+	 ((regex "^--$" a)
+	  (setq unoption-args (append unoption-args arglst) arglst nil))
+	 ((regex "^--([^=]+)=(.*)$" a)
+	  (let (opt $1 arg $2)
+	    (unless (lookup opt long)
+	      (die {Unrecognized option "%s" {%s}} opt a))
+	    (unless ((lookup opt long) 1)
+	      (die {Option "%s" doesn't take an argument! {%s}} opt a))
+	    (when (empty? arg)
+	      (die {No argument supplied for option "%s" {%s}} opt a))
+	    (eval (first (lookup opt long)))))
+	 ((regex "^--([^=]+)$" a)
+	  (let (opt $1 arg nil)
+	    (unless (lookup opt long)
+	      (die {Unrecognized option "%s" {%s}} opt a))
+	    (when ((lookup opt long) 1)
+	      (unless arglst 
+		(die {No argument supplied for option "%s" {%s}} opt a))
+	      (setq arg (pop arglst)))
+	    (eval (first (lookup opt long)))))
+	 ((regex "^-([^-]+)$" a)
+	  (let (options $1)
+	    (while (not (empty? options))
+	      (let (opt (pop options) arg nil)
+		(unless (lookup opt short)
+		  (die {Unrecognized option "%s" {%s}} opt a))
+		(when ((lookup opt short) 1)
+		  (if (not (empty? options))
+		      (setq arg options options "")
+		    (if arglst
+			(setq arg (pop arglst))
+		      (die {No argument supplied for option "%s" {%s}} opt a))))
+		(eval (first (lookup opt short)))))))
+	 (true (push a unoption-args -1))
+	 )
+	)
+      )
+    unoption-args
+    )
+  )
+
+(context MAIN)
+
+;; @syntax (getopts <arglist>)
+;; @param <arglist> A list of strings, typically a subset of (main-args)
+;; @return The list of all command line arguments that were NOT options.
+;; After you have set up all the options using 'shortopt' and 'longopt', call 'getopts' to parse the commandline.
+
+
diff --git a/modules/gsl.lsp b/modules/gsl.lsp
new file mode 100644
index 0000000..3df1601
--- /dev/null
+++ b/modules/gsl.lsp
@@ -0,0 +1,521 @@
+;; @module gsl.lsp 
+;; @description Selected functions from the GNU Scientific Library
+;; @version 1.0 - initial release. Minimum newLISP version is 10.4.0.
+;; @version 1.1 - added check for extended ffi enabled version.
+;; @version 1.2 - changed ostype Win32 to Windows
+;; @author Lutz Mueller 2012
+
+;; <h2>Module GSL For The GNU Scientific Library</h2>
+;; The @link http://www.gnu.org/software/gsl/ GSL GNU Scientific Library
+;; implements over a 1000 functions from different subject areas. In this 
+;; release of the 'gsl.lsp' module only a few linear algebra functions
+;; are implemented.
+
+;; To use this module, the main GSL library 'libgsl' and  a supporting
+;; library 'libgslcblas' must be installed. 
+;;
+;; This module requires newLISP version 10.4.0 as a minimum. For 64-bit
+;; newLISP on Mac OSX, Linux and other Unix, 10.4.2 is the minimum. 
+;; 
+;; Precompiled 32-bit libraries for the binary distributions of newLISP 
+;; versions are available in the
+;; @link http://www.nuevatec.com/GSL/ http://www.nuevatec.com/GSL/
+;; directory. See the 'INSTALL.txt' file in that directory for instructions how
+;; to install the library files.
+;;
+;; The module contains <tt>(test-gsl)</tt> to test all implemented functions.
+
+;; @syntax (gsl:CholeskyD <matrix-A>)
+;; @param <matrix-A> A square matrix of m row vectors with n = m column elements each.
+;; @return The matrix L .
+;; The function performs a Cholesky decomposition of <matrix-A>. The matrix A must
+;; be symmetric and positive definite square.
+;;
+;; A = L * Lt
+;;
+;; Lt is the transposition of L. 
+;;
+;; @example
+;; (gsl:CholeskyD '((4 2 -2) (2 10 2) (-2 2 5)))
+;;
+;; gsl:Cholesky-L => 
+;;
+;; (  ( 2 0 0 )
+;;    ( 1 3 0 )
+;;    (-1 1 1.732050808)  )
+;;
+
+;; @syntax (gsl:Cholesky-solve <matrix-A> <vector-b>)
+;; @param <matrix-A> A square matrix of m row vectors with n = m column elements each.
+;; @params <vector-b> A vector of n elements.
+;; @return Vector x containing a solution for Ax = b .
+;;
+;; @example
+;; (gsl:Cholesky-solve '((4 2 -2) (2 10 2) (-2 2 5)) '(1 2 3)) 
+;; 
+;; => (0.8333333333 -0.1666666667 1)
+;;
+
+;; @syntax (gsl:QRD <matrix-A>)
+;; @param <matrix-A> A list of m row vector lists with n column elements each.
+;; @return Vector <em>tau</em> of k = min(n, m) elements.
+;; The function does QR decomposition of a matrix A.
+;;
+;; A = Q * R
+;;
+;; The function works for both, square and rectangular matrices.
+;; The number of rows m in A must be equal to or greater than the number of columns n.
+;; The orthogonal m * m matrix Q can be found in the variable 'gsl:QR-Q'.
+;; The m * n matrix R can be found in the variable 'gsl:QR-R'.
+;;
+;; @example
+;; (gsl:QRD '((12 -51 4) (6 167 -68) (-4 24 -41)) ) => (1.857142857 1.993846154 0)
+;;
+;; gsl:QR-Q => 
+;;
+;; (  ( 0.8571428571 -0.3942857143 -0.3314285714 )
+;;    ( 0.4285714286  0.9028571429  0.03428571429)
+;;    (-0.2857142857  0.1714285714 -0.9428571429 )  )
+;;
+;; gsl:QR-R => 
+;;
+;; (  (14  21 -14 )
+;;    ( 0 175 -70 )
+;;    ( 0   0  35 )  )
+
+;; @syntax (gsl:QR-solve <matrix-A> <vector-b>)
+;; @param <matrix-A> A matrix of m row vectors with n column elements each.
+;; @params <vector-b> A vector of n elements.
+;; @return Vector x containing a solution for Ax = b .
+;; Matrix A is either square or overdetermined with m > n, more rows than columns.
+;; When m > n, then the variable 'gsl:QR-residual' contains a vector of residuals.
+;; For a square matrix A this vector contains 0's.
+;;
+;; @example
+;; (gsl:QR-solve '((12 -51 4) (6 167 -68) (-4 24 -41)) '(1 2 3))
+;; 
+;; => (0.009387755102 -0.02432653061 -0.08832653061)
+;;
+;; (gsl:QR-solve '((1 2) (3 4) (5 6) (7 8)) '(1 2 3 4))
+;; => (9.690821045e-16 0.5)
+;;
+;; gsl:QR-residual 
+;; => (2.512815377e-17 1.103917396e-16 -2.961679405e-16 1.606480472e-16)
+
+;; @syntax (gsl:SVD <matrix-A>)
+;; @param <matrix-A> A matrix of m row vectors with n column elements each.
+;; @return A vector of diagonal elements from the S matrix.
+;; The function does a SVD (Singular Value Decomposition) of the <matrix-A> into
+;; its components U, S and V. Matrix U is orthogonal m*n. S is a diagonal
+;; square matrix of n singular values. V is a n*n square orthogonal matrix.
+;; The function works for both, square and rectangular matrices.
+;;
+;; A = U * S * Vt 
+;;
+;; Vt is the transposition of V.
+;;
+;; The number of rows m in A must be equal to or greater than the number of columns n.
+;; The m*n matrix U can be found in the variable 'gsl:SVD-U'.
+;; The diagonal elements of matrix S can be found in the vector variable 'gsl:SVD-S'.
+;; The n*n matrix V can be found in the variable 'gsl:SVD-V'.
+;;
+;; @example
+;; (gsl:SVD '((1 2) (3 4) (5 6) (7 8))) => (14.2690955 0.6268282324)
+;;
+;; gsl:SVD-U =>
+;; (  (-0.1524832333 -0.8226474722 )
+;;    (-0.3499183718 -0.4213752877 )
+;;    (-0.5473535103 -0.02010310314)
+;;    (-0.7447886488  0.3811690814 )  )
+;;  
+;; gsl:SVD-S => 
+;;
+;; (14.2690955 0.6268282324)
+;;
+;; gsl:SVD-V => 
+;;
+;; (  (-0.641423028   0.7671873951)
+;;    (-0.7671873951 -0.641423028 )  )
+
+;; @syntax (gsl:SVD-solve <matrix-A> <vector-b>)
+;; @param <matrix-A> A matrix of m row vectors with n column elements each.
+;; @params <vector-b> A vector of n elements
+;; @return a vector x containing a solution for Ax = b .
+;; The number of rows m in A must be equal to or greater than the number n of columns.
+;;
+;; @example
+;; (gsl:SV-solve '((1 2) (3 4) (5 6) (7 8)) '(1 2 3 4))
+;; 
+;; => (5.551115123e-16 0.5 0 0)
+;; 
+
+; on Mac OSX when using 32-bit newLISP from the normal binary Mac OSX installer
+; use the following to make the libraries:
+;
+; ./configure CFLAGS="-O2 -m32"
+; make
+; sudo make install
+;
+; install needs the root password
+;
+
+(when (!= 1024 (& 1024 (sys-info -1)))
+    (println "This module needs newLISP compiled for extended ffi.")
+    (println "Must exit")
+    (exit))
+
+; the following assumes the libararies installed in the system library path
+(set 'LIB 
+	(if 
+		(= ostype "Windows") "libgsl-0.dll" ; 32-bit or 64-bit
+		(= ostype "OSX")   "libgsl.dylib" ; 32-bit or 64-bit
+		(= ostype "Linux") "/usr/local/lib/libgsl.so" ; 32-bit or 64-bit
+	))
+
+; load libgslcblas which contans functions referenced by libgsl
+; the symbol cblas_sdsdot is not needed but newLISP versions before
+; 10.4.2 can not use the 'import' statement without a function name
+; libgslcblas is mainly needed internally by libgsl.
+; On windows the library is automatically loaded by libgsl-0.dll.
+(if 
+    (= ostype "OSX") (import "libgslcblas.dylib" "cblas_sdsdot")
+    (= ostype "Linux") (import "/usr/local/lib/libgslcblas.so" "cblas_sdsdot")
+)
+    
+; structs are defined but only needed for debugging, instead use "void*"
+(struct 'complex "double" "double") ; complex numbers
+(struct 'block "long" "void*") ; vectors and matrices allocation block, size data-ptr
+(struct 'vector "long" "long" "void*" "block" "int") ; size stride data block owner
+(struct 'matrix "long" "long" "long" "void*" "block" "int") ; size1 size2 tda data block owner 
+
+(import LIB "gsl_set_error_handler_off" "void*") ; turn of error handler
+(import LIB "gsl_strerror" "char*" "int") ; get error text
+
+; pointers are only used passed around internally
+; for debugging (unpack vector vptr) can always be used
+(import LIB "gsl_vector_alloc" "void*" "long") 
+(import LIB "gsl_vector_calloc" "void*" "long") 
+(import LIB "gsl_vector_free" "void" "void*") 
+(import LIB "gsl_vector_get" "double" "void*" "long")
+(import LIB "gsl_vector_set" "void" "void*" "long" "double")
+
+; in matrix functions "void*" can be used instead of struct "matrix"
+; because pointers are only used passed around internally
+; for debugging (unpack matrix Xptr) can always be used
+(import LIB "gsl_matrix_alloc" "void*" "long" "long")
+(import LIB "gsl_matrix_calloc" "void*" "long" "long")
+(import LIB "gsl_matrix_free" "void" "void*") 
+(import LIB "gsl_matrix_get" "double" "void*" "long" "long")
+(import LIB "gsl_matrix_set" "void" "void*" "long" "long" "double")
+(import LIB "gsl_matrix_scale" "int" "void*" "double")
+
+; linear algebra functions
+(import LIB "gsl_linalg_cholesky_decomp" "int" "void*")
+(import LIB "gsl_linalg_cholesky_solve" "int" "void*" "void*" "void*")
+(import LIB "gsl_linalg_QR_decomp" "int" "void*" "void*")
+(import LIB "gsl_linalg_QR_unpack" "int" "void*" "void*" "void*" "void*")
+(import LIB "gsl_linalg_QR_solve" "int" "void*" "void*" "void*" "void*")
+(import LIB "gsl_linalg_QR_lssolve" "int" "void*" "void*" "void*" "void*" "void*")
+(import LIB "gsl_linalg_SV_decomp" "int" "void*" "void*" "void*" "void*")
+(import LIB "gsl_linalg_SV_solve" "int" "void*" "void*" "void*" "void*" "void*")
+
+; turn of error handler
+; instead check return values from gsl_xxx_xxx functions
+; and do 'throw-error' retrieving error text with 'gsl_strerror'
+(gsl_set_error_handler_off) 
+
+; helper functions for translating C-arrays and vectors to lists and back
+
+(define (get-vector-from-list x)
+    (when (array? x) (set 'x (array-list x)))
+    (letn (m (length x) xptr (gsl_vector_calloc m))
+        (dotimes (i m) (gsl_vector_set xptr i (pop x)))
+        (list xptr m))
+)
+        
+(define (get-matrix-from-list X)
+    (when (array? X) (set 'X (array-list X)))
+    (let (m (length X) n (length (X 0)) Xptr 0)
+        (set 'Xptr (gsl_matrix_calloc m n))
+        (dotimes (i m) (set 'row (pop X)) ; row
+            (dotimes (j n) (gsl_matrix_set Xptr i j (pop row)))) ; col
+        (list Xptr m n))
+)
+
+(define (get-list-from-vector xr)
+	(let (xptr (xr 0) n (xr 1) result nil)
+		(dotimes (i n)
+			(push (gsl_vector_get xptr i) result -1))
+	result
+	)
+)
+
+(define (get-list-from-matrix Xr)
+    (let (row nil col nil result nil Xptr (Xr 0) m (Xr 1) n (Xr 2))
+        (dotimes (i m) 
+            (set 'row nil)
+            (dotimes (j n)
+                (push (gsl_matrix_get Xptr i j) row -1))
+            (push row result -1))
+    result
+    )
+)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; API functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(define (gsl:CholeskyD A)
+    (letn   (
+            Ar (get-matrix-from-list A)
+            Aptr (Ar 0)
+            m (Ar 1)
+            n (Ar 2)
+            result 0
+            )
+        (set 'result (gsl_linalg_cholesky_decomp Aptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        ; zero the triangle above diagonal
+        (for (i 0 (- m 2)) 
+            (for (j (+ i 1) (- n 1)) 
+                (gsl_matrix_set Aptr i j 0.0)))
+        (set 'result (get-list-from-matrix Ar))
+        (gsl_matrix_free Aptr)
+    result) ; matix L of A = LLt
+)            
+
+(define (gsl:Cholesky-solve A b)
+    (letn   (
+            Ar (get-matrix-from-list A)
+            Aptr (Ar 0)
+            m (Ar 1)
+            n (Ar 2)
+            br (get-vector-from-list b)
+            bptr (br 0)
+            xptr (gsl_vector_calloc n)
+            result 0
+            )
+        (set 'result (gsl_linalg_cholesky_decomp Aptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        (set 'result (gsl_linalg_cholesky_solve Aptr bptr xptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        (set 'result (get-list-from-vector (list xptr n)))
+        (gsl_matrix_free Aptr)
+        (gsl_vector_free bptr)
+        (gsl_vector_free xptr)
+        result)
+)
+
+(define (gsl:QRD A flag)
+    (letn   (
+            Ar (get-matrix-from-list A)
+            Aptr (Ar 0)
+            m (Ar 1)
+            n (Ar 2)
+            nt (min m n)
+            Tptr (gsl_vector_calloc nt)
+            Qptr (gsl_matrix_calloc m m)
+            Rptr (gsl_matrix_calloc m n)
+            result 0
+            )
+        (set 'result (gsl_linalg_QR_decomp Aptr Tptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        ; Aptr contains QR
+        (set 'result (gsl_linalg_QR_unpack Aptr Tptr Qptr Rptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        (set 'gsl:QR-tau (get-list-from-vector (list Tptr nt)))
+        ; Q and R have reverse signs compared with published
+        ; examples but values are the same and verify A = QR.
+        ; reverse signs for Q and R unless flag set true
+        (unless flag
+            (gsl_matrix_scale Qptr -1)
+            (gsl_matrix_scale Rptr -1)
+            ; avoid -0 in lower triangular
+            (for (i 1 (- m 1)) (for (j 0 (- i 1)) 
+                (gsl_matrix_set Rptr i j 0))))
+        (set 'gsl:QR-Q (get-list-from-matrix (list Qptr m m)))
+        (set 'gsl:QR-R (get-list-from-matrix (list Rptr m n)))
+        (gsl_matrix_free Aptr)
+        (gsl_vector_free Tptr)
+        (gsl_matrix_free Qptr)
+        (gsl_matrix_free Rptr)
+        gsl:QR-tau); vector tau 
+)
+
+(define (gsl:QR-solve A b)
+    (letn   (
+            Ar (get-matrix-from-list A)
+            Aptr (Ar 0)
+            m (Ar 1)
+            n (Ar 2)
+            nt (min m n)
+            tptr (gsl_vector_calloc nt)
+            br (get-vector-from-list b)
+            bptr (br 0)
+            xptr (gsl_vector_calloc n)
+            resptr (gsl_vector_calloc m)
+            result 0
+            )
+        (set 'result (gsl_linalg_QR_decomp Aptr tptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        ; Aptr contains QR
+        (if (> m n) ; more rows than cols
+            (set 'result (gsl_linalg_QR_lssolve Aptr tptr bptr xptr resptr))
+            (set 'result (gsl_linalg_QR_solve Aptr tptr bptr xptr)) )
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        (set 'result (get-list-from-vector (list xptr n)))
+        (set 'gsl:QR-residual (get-list-from-vector (list resptr m)))
+        (gsl_matrix_free Aptr)
+        (gsl_vector_free tptr)
+        (gsl_vector_free bptr)
+        (gsl_vector_free xptr)
+        (gsl_vector_free resptr)
+        result)
+)
+
+(define (gsl:SVD A)
+    (letn   (
+            Ar (get-matrix-from-list A)
+            Aptr (Ar 0)
+            m (Ar 1)
+            n (Ar 2)
+            Sptr (gsl_vector_calloc n)
+            Vptr (gsl_matrix_calloc n n)
+            work (gsl_vector_calloc n)
+            result 0)
+        (set 'result (gsl_linalg_SV_decomp Aptr Vptr Sptr work))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+		(set 'gsl:SVD-U (get-list-from-matrix Ar))
+		(set 'gsl:SVD-S (get-list-from-vector (list Sptr n)))
+		(set 'gsl:SVD-V (get-list-from-matrix (list Vptr n n)))
+        (gsl_matrix_free Aptr)
+        (gsl_vector_free Sptr)
+        (gsl_matrix_free Vptr)
+        (gsl_vector_free work)
+        gsl:SVD-S) ; vector of diagonals of S of A = USVt
+)
+
+(define (gsl:SV-solve A b)
+    (letn   (
+            Ar (get-matrix-from-list A)
+            Aptr (Ar 0)
+            m (Ar 1)
+            n (Ar 2)
+            Sptr (gsl_vector_calloc n)
+            Vptr (gsl_matrix_calloc n n)
+            work (gsl_vector_calloc n) 
+            xptr (gsl_vector_calloc n) 
+            br (get-vector-from-list b)
+            bptr (br 0)
+            result 0)
+        (set 'result (gsl_linalg_SV_decomp Aptr Vptr Sptr work))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        (set 'result (gsl_linalg_SV_solve Aptr Vptr Sptr bptr xptr))
+        (unless (zero? result)
+            (throw-error (gsl_strerror result)))
+        (set 'result (get-list-from-vector (list xptr n)))
+        (gsl_matrix_free Aptr)
+        (gsl_vector_free Sptr)
+        (gsl_matrix_free Vptr)
+        (gsl_vector_free work)
+        (gsl_vector_free bptr)
+        (gsl_vector_free xptr)
+        result)
+)        
+
+; User helper functions
+
+(define (gsl:diagonal x flag)
+    (when (array? x) (set 'x (array-list x)))
+    (letn (len (length x) A (array len len (dup 0 len)))
+        (dotimes (i len) (setf (A i i) (pop x)))
+        (unless flag A (array-list A)))
+)
+
+(context MAIN)
+
+;;;;;;;;;;;;;;;;;;;; tests ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (test-gsl)
+    ; Cholesky decomp
+    (println)
+    (println "========== Cholesky example A = L * Lt")
+    (println "(gsl:CholeskyD '((4 2 -2) (2 10 2) (-2 2 5)))" )
+    (set 'L (gsl:CholeskyD '((4 2 -1) (2 10 2) (-2 2 5))))
+    (println)
+    (println "L -> ") (map println L)
+    (println)
+    (println "verify LLt ->") (map println (multiply L (transpose L)))
+    (println)
+    (println "(gsl:Cholesky-solve '((4 2 -2) (2 10 2) (-2 2 5)) '(1 2 3))")
+    (set 'x (gsl:Cholesky-solve '((4 2 -2) (2 10 2) (-2 2 5)) '(1 2 3)))
+    (println)
+    (println "x -> " x)
+    (println "Ax -> " (multiply '((4 2 -2) (2 10 2) (-2 2 5)) (transpose (list x))))
+
+    ; QR decomp example
+    (println)
+    (println "========== QR example A = Q * R")
+    (println "(gsl:QRD '((12 -51 4) (6 167 -68) (-4 24 -41)) ) tau vector ===> " 
+        (gsl:QRD '((12 -51 4) (6 167 -68) (-4 24 -41)) ))
+
+    (println)
+    (println "Q -> ") (map println gsl:QR-Q)
+    (println)
+    (println "R -> ") (map println gsl:QR-R)
+    (println)
+    (println "verify QR -> ") (map println (multiply gsl:QR-Q gsl:QR-R))
+    (println)
+    (println "(gsl:QR-solve '((12 -51 4) (6 167 -68) (-4 24 -41)) '(1 2 3))")
+    (set 'x (gsl:QR-solve '((12 -51 4) (6 167 -68) (-4 24 -41)) '(1 2 3)))
+    (println)
+    (println "x -> " x)
+    (println "Ax -> " (multiply '((12 -51 4) (6 167 -68) (-4 24 -41)) (transpose (list x))))
+    (println "residual -> " gsl:QR-residual)
+    (println)
+    (println "(gsl:QR-solve '((1 2) (3 4) (5 6) (7 8)) '(1 2 3 4))")
+    (set 'x (gsl:QR-solve '((1 2) (3 4) (5 6) (7 8)) '(1 2 3 4)))
+    (println)
+    (println "x -> " x)
+    (println "Ax -> " (multiply '((1 2) (3 4) (5 6) (7 8)) (transpose (list x))))
+    (println "residual -> " gsl:QR-residual)
+
+    ; SV decomp example
+    (println)
+    (println "========== SVD example A = U * S * Vt")
+    (println "(gsl:SVD '((1 2) (3 4) (5 6) (7 8))) => " (gsl:SVD '((1 2) (3 4) (5 6) (7 8))))
+    (println)
+    (println "U -> ") (map println gsl:SVD-U)        
+    (println)
+    (println "diagonal of S -> ") (println gsl:SVD-S)        
+    (println)
+    (println "V -> ") (map println gsl:SVD-V)        
+    (println)
+    (println "verify USVt -> ") (map println
+        (multiply (multiply gsl:SVD-U (gsl:diagonal gsl:SVD-S)) (transpose gsl:SVD-V)))
+    (println)
+    (println "(gsl:SV-solve '((1 2) (3 4) (5 6) (7 8)) '(1 2 3 4))")
+    (set 'x (gsl:SV-solve '((1 2) (3 4) (5 6) (7 8)) '(1 2 3 4)))
+    (println)
+    (println "x -> " x)
+    (println "Ax -> " (multiply '((1 2) (3 4) (5 6) (7 8)) (transpose (list x))))
+    (println)
+    (println "(gsl:SV-solve '((12 -51 4) (6 167 -68) (-4 24 -41)) '(1 2 3))")
+    (set 'x (gsl:SV-solve '((12 -51 4) (6 167 -68) (-4 24 -41)) '(1 2 3)))
+    (println)
+    (println "x -> " x)
+    (println "Ax -> " (multiply '((12 -51 4) (6 167 -68) (-4 24 -41)) (transpose (list x))))
+    true
+)
+
+;(test-gsl) (exit)
+
+; eof ;
diff --git a/modules/index.cgi b/modules/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/modules/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/modules/infix.lsp b/modules/infix.lsp
new file mode 100644
index 0000000..91f0478
--- /dev/null
+++ b/modules/infix.lsp
@@ -0,0 +1,146 @@
+;; @module infix.lsp
+;; @description Infix expression parser
+;; @version 2.1 - comments redone for automatic documentation
+;; @version 2.2 - fixed bug for trailing lower priority ops
+;; @version 2.3 - doc changes
+;; @version 2.3 - doc changes
+;; @author Lutz Mueller 2006-2015
+;; <h2>Infix expression parser</h2>
+;; Parses infix, prefix or postfix expressions given in strings and returns a
+;; newLISP expressions, which can be evaluated; captures syntax errors.
+;;
+;; At the beginning od the program using this module include the following
+;; statement:
+;; <pre>
+;; (load "/usr/local/share/newlisp/modules/infix.lsp")
+;; ; or shorter
+;; (module "infix.lsp")
+;; </pre>
+
+;; @syntax (INFIX:xlate <str-expression> [<context-target>])
+;; @param <str-expression> The infix expression in a string
+;; @param <context-target> An optional context as compile taret.
+;; @return A newLISP expression or 'nil' on failure.
+;; When 'nil' is returned then the error message is in 'result'.
+;; As an optional second parameter a target context can be passed, 
+;; if not used, MAIN is assumed.
+;;
+;; Note that the parser requires operators, variables and constants surrounded
+;; by spaces except where parenthesis are used.
+;;        
+;; @example
+;; (INFIX:xlate "3 + 4") => (add 3 4) ;; parses infix
+;; (INFIX:xlate "+ 3 4") => (add 3 4) ;; parses prefix s-expressions
+;; (INFIX:xlate "3 4 +") => (add 2 4) ;; parses postfix
+;;
+;; (INFIX:xlate "3 + * 4") => "ERR: missing argument for +"
+;;
+;; (eval (INFIX:xlate "3 + 4")) => 7
+;;
+;; (INFIX:xlate "(3 + 4) * (5 - 2)")  => (mul (add 3 4) (sub 5 2))
+;;
+;; (INFIX:xlate "(a + b) ^ 2 + (a - b) ^ 2") => (add (pow (add a b) 2) (pow (sub a b) 2))
+;;
+;; (INFIX:xlate "x = (3 + sin(20)) * (5 - 2)")  => (setq x (mul (add 3 (sin 20)) (sub 5 2)))
+;;
+;; (INFIX:xlate "x = (3 + sin(10 - 2)) * (5 - 2)")  
+;;         => (setq x (mul (add 3 (sin (sub 10 2))) (sub 5 2)))
+
+; operator priority table
+; (token operator arg-count priority)
+;
+(context 'INFIX)
+
+(set 'operators '(
+  ("=" setq 2 2) 
+  ("+" add 2 3) 
+  ("-" sub 2 3) 
+  ("*" mul 2 4) 
+  ("/" div 2 4)
+  ("^" pow 2 5)
+  ("abs" abs 1 9)
+  ("acos" acos 1 9)
+  ("asin" asin 1 9)
+  ("atan" atan 1 9)
+  ("sin" sin 1 9)
+  ("sqrt" sqrt 1 9)
+  ("tan" tan 1 9)
+  ("cos" cos 1 9)
+; add what else is needed
+  ))
+
+(set 'targetContext MAIN)
+
+(define (xlate str ctx)
+  (if ctx (set 'targetContext ctx))
+  (if (catch (infix-xlate str) 'result)
+    result                     ; if starts with ERR: is error else result
+    (append "ERR: " result)))  ; newLISP error has ocurred
+
+
+(define (infix-xlate str)
+  (set 'tokens (parse str))
+  (set 'varstack '())
+  (set 'opstack '())
+  (dolist (tkn tokens)
+	(case tkn
+        ("(" (push tkn opstack))
+        (")" (close-parenthesis))
+        (true (if (assoc tkn operators)
+                  (process-op tkn)
+                  (push tkn varstack)))))
+  (while (not (empty? opstack))
+        (make-expression))
+
+  (set 'result (first varstack))
+  (if (or (> (length varstack) 1) (not (list? result)))
+    (throw "ERR: wrong syntax")
+    result))
+
+
+; pop all operators and make expressions
+; until an open parenthesis is found
+;
+(define (close-parenthesis)
+ (while (not (= (first opstack) "("))
+    (make-expression))
+ (pop opstack))
+  
+
+; pop all operator, which have higher/equal priority
+; and make expressions
+;
+(define (process-op tkn)
+  (while (and opstack
+              (<= (lookup tkn operators 3) (lookup (first opstack) operators 3)))
+        (make-expression))
+  (push tkn opstack))
+
+; pops an operator from the opstack and makes/returns an
+; newLISP expression
+;
+(define (make-expression)
+  (set 'expression '())
+  (if (empty? opstack) 
+        (throw "ERR: missing parenthesis"))
+  (set 'ops (pop opstack))
+  (set 'op (lookup ops operators 1))
+  (set 'nops (lookup ops operators 2))
+  (dotimes (n nops)
+    (if (empty? varstack) (throw (append "ERR: missing argument for " ops)))
+    (set 'vars (pop varstack))
+    (if (atom? vars)
+            (if (not (or (set 'var (float vars))
+                         (and (legal? vars) (set 'var (sym vars targetContext))) ))
+                (throw (append vars "ERR: is not a variable"))
+                (push var expression))
+            (push vars expression)))
+  (push op expression)
+  (push expression varstack))
+
+(context 'MAIN)
+    
+; eof ;
+
+  
+  
diff --git a/modules/mysql.lsp b/modules/mysql.lsp
new file mode 100644
index 0000000..d2b8093
--- /dev/null
+++ b/modules/mysql.lsp
@@ -0,0 +1,395 @@
+;; @module mysql.lsp 
+;; @description MySQL v.5.x interface (tested on MySQL 5.0 and 5.1)
+;; @version 2.61 - addition for mysql_escape_string (Jeff Ober)
+;; @version 2.62 - fix for mysql_escape_string (Tim Johnson)
+;; @version 3.0  - module now independent of C-structure offsets
+;; @version 3.1  - module now senses if running 64-bit version of newLISP
+;; @version 3.2  - a fix when fetch-all has an empty result
+;; @version 3.3  - typo in fetch-all didn't delete old fetches
+;; @version 3.4  - documentaion error for load path
+;; @version 3.41  - library load path for Fedora Linux
+;; @version 3.42  - library load path upgraded for OpenBSD 4.9
+;; @version 3.43  - library load path upgraded for CentOS 6.x 
+;; @version 3.44  - library load path upgraded for CentOS 6.x 
+;; @version 3.45  - library load path upgraded for UBUNTU Linux 12.04
+;; @version 3.46  - add UTF-8 handling in documentation (Csfreebird July/2014)
+;; @version 3.47  changed references to /usr/ to /usr/local/
+;; @author Lutz Mueller 2003-2015, Gordon Fischer 2005, Jeff Ober 2007
+;;
+;; This MySQL 5.x interface module has been tested on versions 5.0 and 5.1
+;; of mysql from @link http://www.mysql.com www.mysql.com
+;;
+;; An alternate implementation of a MySQL module with more features 
+;; is available at @link http://static.artfulcode.net/newlisp/index.html ArtfulCode.
+;;
+;; <h3>Requirements</h3>
+;; At the beginning of the program file include a 'load' statement for the module:
+;; <pre>
+;; (load "/usr/local/share/newlisp/modules/mysql.lsp")
+;; ; or shorter
+;; (module "mysql.lsp")
+;; </pre>
+;;
+;; A version of 'libmysqlclient' for a specific platform is required:
+;;  
+;; on LINUX/UNIX: '/usr/local/mysql/lib/libmysqlclient.so' <br>
+;; on Mac OS X:   '/usr/local/mysql/lib/libmysqlclient.dylib'
+;;
+;; This library is installed when using the Mac OS X x86 installer .dmg package
+;; from @link http://www.mysql.com http://www.mysql.com
+;;
+;; To compile MySQL with client libraries use:
+;;
+;; './configure --prefix=/usr/local --enable-shared'
+;;
+;; This library might be in a different location on a particular
+;; installation of MySQL or have a different name.
+;; Change accordingly in the code at the beginning.
+;;
+;; The MySQL server itself may reside on a different machine
+;; on the network. The library 'libmysqlclient' will communicate
+;; with that server. The correct connection is created using
+;; the 'MySQL:connect' call.
+;;
+;; At the bottom of the module file 'mysql51.lsp' a test routine 'test-mysql'
+;; is included to test for correct installation of MySQL.
+;;
+;; In the 'MySQL:connect' call of that test routine the correct parameters 
+;; for the MySQL server location and user and password have to be inserted.
+;;
+;; <h3>Functions available</h3>
+;; <pre>
+;; MySQL:init ................ get a database handle MYSQL
+;; MySQL:connect ............. connect to a database
+;; MySQL:query ............... execute a SQL statement
+;; MySQL:num-rows ............ rows in result of query
+;; MySQL:num-fields .......... columns in result of query
+;; MySQL:fetch-row ........... get row from the query result
+;; MySQL:fetch-all ........... get all rows from the last query
+;; MySQL:database ............ return all database names
+;; MySQL:tables .............. return all tables names
+;; MySQL:fields .............. return all fields in a table
+;; MySQL:data-seek ........... position in result for fetching
+;; MySQL:affected-rows ....... number of affected rows from operation
+;; MySQL:inserted-id ......... last value of auto increment id operation
+;; MySQL:escape .............. escapes SQL input string using mysql_real_escape_string
+;; MySQL:error ............... get error message
+;; MySQL:close-db ............ close database connection
+;; </pre>
+;; <h3>A typical MySQL session</h3>
+;; The following code piece outlines a typical MySQL session:
+;;
+;; @example
+;; (module "mysql.lsp) ; load the module file
+;; 
+;; (MySQL:init)       ; initialize
+;; (MySQL:connect "192.168.1.10" "auser" "secret" "mydb") ; logon
+;; (MySQL:query "select ...;") ; SQL query
+;; (MySQL:query "insert ...;") ; SQL query
+;;        ...
+;; (MySQL:close-db)
+
+;; The database server is listening on IP 192.168.1.10. The program
+;; connects with username '"auser"' password '"secret"' to a database with 
+;; the name '"mydb"'. After connecting SQL statements are performed and
+;; finally the program disconnects from the server.
+
+;; <h3>UTF-8 character encoding</h3>
+;; When using newLISP compiled for UTF-8, the following statements
+;; may be necessary at the beginning:
+;; <pre>
+;; (MySQL:query "SET character_set_client = utf8;")
+;; (MySQL:query "SET character_set_connection = utf8;")
+;; (MySQL:query "SET character_set_results = utf8;")
+;; </pre>
+;; To see all MySQL character variables:
+;; <pre>
+;; (MySQL:query "SHOW VARIABLES LIKE 'character%';")
+;; (dotimes (x (MySQL:num-rows)) (println (MySQL:fetch-row)))
+;; </pre>
+
+
+(context 'MySQL)
+
+; fetch-row and keep-type functions depend on this
+(set 'NEWLISP64 (not (zero? (& (sys-info -1) 256))))
+
+(set 'files '(
+    "/usr/local/lib/libmysqlclient.so.20.0" ; OpenBSD 4.9
+    "/usr/lib/libmysqlclient.so" ; Linux, UNIX
+    "/usr/lib/mysql/libmysqlclient.so" ; Linux Fedora
+    "/usr/lib64/mysql/libmysqlclient.so" ; Linux Fedora CentOS 6.x
+    "/usr/lib/x86_64-linux-gnu/libmysqlclient.so" ; Ubuntu 12.04 LTS
+    "/usr/local/mysql/lib/libmysqlclient.so" ; Linux, UNIX
+    "/usr/local/mysql/lib/libmysqlclient.dylib" ; MacOS X
+    "/usr/lib/libmysqlclient.dylib" ; MacOS X
+))
+
+(set 'library (files (or 
+		       (find true (map file? files)) 
+		       (throw-error "cannot find libmysqlclient library"))))
+
+(import library "mysql_init")
+(import library "mysql_real_connect")
+(import library "mysql_get_host_info")
+(import library "mysql_real_escape_string")
+(import library "mysql_query")
+(import library "mysql_real_query")
+(import library "mysql_store_result")
+(import library "mysql_free_result")
+(import library "mysql_data_seek")
+(import library "mysql_fetch_row")
+(import library "mysql_close")
+(import library "mysql_fetch_field_direct")
+(import library "mysql_insert_id")
+(import library "mysql_num_rows")
+(import library "mysql_num_fields")
+(import library "mysql_affected_rows")
+(import library "mysql_error")
+
+; check endianess of the host CPU 
+(set 'big-endian (= (pack ">ld" 1) (pack "ld" 1)))
+
+;; @syntax (MySQL:init)
+;; @return 'true' on success, 'nil' on failure.
+
+(define (init)
+  (set 'MYSQL (mysql_init 0))
+  (if (= MYSQL 0) (set 'MYSQL nil))
+  (not (= MYSQL nil)))
+
+;; @syntax (MySQL:connect <str-server> <str-userID> <str-password> <str-db>)
+;; @param <str-server> The host name or IP address or <tt>0</tt> for localhost.
+;; @param <str-userID> The user ID for authentication.
+;; @param <str-password> The password for authentication.
+;; @param <str-db> The name of the database to connect to.
+;; @return 'true' for success or 'nil' for failure.
+;; Connects to a database on server and authenticates a user ID.
+;; '(MySQL:init)' must have been called previously.
+
+(define (connect host user passw database)
+  (not(= (mysql_real_connect MYSQL host user passw database 0 0 0) 0)))
+
+;; @syntax (MySQL:query <str-sql>)
+;; @param <str-sql> A valid SQL query string.
+;; @return For 'insert' queries rerturns the inserted ID else 'true' for success or 'nil' for failure.
+;; Sends a SQL query string to the database server for evaluation.
+
+(define (MySQL:query sql)
+  (if MYSQL_RES (mysql_free_result MYSQL_RES))
+  (set 'result  (= (mysql_query MYSQL sql) 0))
+  (set 'MYSQL_RES (mysql_store_result MYSQL)) 
+  (if (= MYSQL_RES 0) (set 'MYSQL_RES nil))
+  (if (and result (find "insert into" sql 1)) (set 'result (inserted-id)))
+  result)
+
+;; @syntax (MySQL:num-rows)
+;; @return Number of rows from last query.
+
+(define (num-rows)
+  (if MYSQL_RES (mysql_num_rows MYSQL_RES)))
+
+;; @syntax (MySQL:num-fields)
+;; @return Number of columns from last query.
+
+(define (num-fields)
+  (if MYSQL_RES (mysql_num_fields MYSQL_RES)))
+
+
+; format the result based on the field type.
+;
+
+(define (keep-type res_ptr field_addr column_num, data)
+  (set 'type_ptr (mysql_fetch_field_direct res_ptr (int column_num)))
+  ; The field type is the 20th field of the MySQL_FIELD structure
+  ; since fields 1-19 are all 4 byte fields we get the enum value
+  ; like so
+  (if NEWLISP64
+  	(set 'data (get-long (int (+ type_ptr (* 19 8)))))
+  	(set 'data (get-int (int (+ type_ptr (* 19 4))))) )
+  ; Consult 'enum_field_types' in mysql_com.h for values
+  (if (= data 1) ;; boolean
+        (get-string field_addr)
+      (= data 3) ;; integer
+        (int (get-string field_addr))
+      (= data 12) ;; datetime
+        (apply date-value (map int (parse (get-string field_addr) "[-: ]" 0)))
+      (= data 4) ;; float
+        (float (get-string field_addr))
+      ; else (will handle TEXT type 252)
+      (get-string field_addr)
+  )
+)
+
+;; @syntax (MySQL:fetch-row)
+;; @return A list of field elements.
+;; Fetches a row from a previous SQL 'MySQL:query'  'select' statement.
+;; Subsequent calls fetch row by row from the result table until the
+;; end of the table is reached.
+
+(define (fetch-row)
+  (if MYSQL_RES
+    (set 'rdata (mysql_fetch_row MYSQL_RES))
+    (set 'rdata 0))
+  (if (!= rdata 0)
+    (begin
+      (set 'row '())
+      (dotimes (field (num-fields))
+            (if NEWLISP64
+              (set 'field_addr (get-long (int (+ rdata (* field 8)))))
+              (set 'field_addr (get-int (int (+ rdata (* field 4))))) )
+            (if (= field_addr 0)
+              (push nil row -1) ;; what to do when the field contains NULL
+              (push (keep-type MYSQL_RES field_addr field) row -1)))
+    row))) ; not necessary starting v 9.9.5, because push returns the list
+
+;; @syntax (MySQL:fetch-all)
+;; @return All rows/fields from the last query.
+;; The whole result set from the query is returned at once as a list of row lists.
+
+(define (fetch-all , (all '()))
+  (dotimes (x (num-rows)) (push (fetch-row) all -1)))
+
+;; @syntax (MySQL:databases)
+;; @return A list of databases.
+;; Performs a 'show databases;' query.
+
+(define (databases)
+  (query "show databases;")
+  (fetch-all))
+
+;; @syntax (MySQL:tables)
+;; @return A list of tables in the database.
+;; Performs a 'show tables;' query.
+
+(define (tables)
+  (query "show tables;")
+  (fetch-all))
+
+;; @syntax (MySQL:fields <str-table>)
+;; @param <str-table> The name of the table.
+;; @return A list of field description lists.
+;; For each field name in the table a list of specifications
+;; for that field is returned. The list starts with the name
+;; for the field followed by the type size/precision and
+;; other optional field descriptions.
+
+(define (fields table)
+  (query (append "show fields from " table ";"))
+  (fetch-all))
+  
+;; @syntax (MySQL:data-seek <num-offset>)
+;; @param <num-offset> The <tt>0</tt> based offset to position inside the data set.
+;; @return Always 'true'. 
+;; Positions in the result set at a zero based offset
+;; for a subsequent 'MySQL:fetch-row' call. If the offset
+;; is out of the allowed range for the result set a subsequent
+;; fetch-row will return 'nil'.
+ 
+(define (data-seek offset)
+  (if MYSQL_RES
+    (if big-endian
+    	(mysql_data_seek MYSQL_RES  0 (int offset))
+        (mysql_data_seek MYSQL_RES (int offset) 0)))
+  true
+)
+
+;; @syntax (MySQL:error)
+;; @return Text info about the last error which occured.
+
+(define (error)
+  (if MYSQL (get-string (mysql_error MYSQL)))) 
+
+;; @syntax (MySQL:affected-rows)
+;; @return Number of affected rows by the last 'MySQL:query' operation.
+
+(define (affected-rows)
+  (if MYSQL (mysql_affected_rows MYSQL)))
+
+;; @syntax (MySQL:inserted-id)
+;; @return Last insert ID from an auto increment field.
+
+(define (inserted-id)
+  (if MYSQL (mysql_insert_id MYSQL)))
+
+;; @syntax (MySQL:escape <str-sql>)
+;; @return escaped string
+;; This function will escape special characters in <str-sql>, so that it 
+;; is safe to place it in a MySQL query.
+(define (escape value , safe-value) 
+  (set 'safe-value (dup " " (+ 1 (* 2 (length value)))))
+  (MySQL:mysql_real_escape_string MySQL:MYSQL safe-value value (length value)) 
+  safe-value)
+
+;; @syntax (MySQL:close-db)
+;; @return Always 'true'.
+;; Closes database access. For new database acess, both 'MySQL:init' and 
+;; 'MySQL:connect' functions have to be called.
+
+(define (close-db)
+  (if MYSQL_RES (mysql_free_result MYSQL_RES))
+  (if MYSQL (mysql_close MYSQL))
+  (set 'MYSQL nil)
+  (set 'MYSQL_RES nil)
+  true)
+
+(context 'MAIN)
+
+; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; test data base functions
+;
+
+(define (test-mysql)
+  (MySQL:init)
+  (unless (MySQL:connect 0 "" 0 "test")
+    (println "Could not connect to MySQL")
+	(exit))
+  
+  (println "databases:")
+  (MySQL:query "show databases;")
+
+  (dotimes (x (MySQL:num-rows)) (println (MySQL:fetch-row)))
+  (println)
+  
+  (MySQL:query "create table fruits (name TEXT(2000), 
+                                     qty INT(3),
+                                     num INT(4) AUTO_INCREMENT UNIQUE);")
+  
+  (MySQL:query "insert into fruits values ('apples', 11, null);")
+  (println "inserted-id: " (MySQL:inserted-id))
+  (MySQL:query "insert into fruits values ('oranges', 22, null);")
+  (println "inserted-id: " (MySQL:inserted-id))
+  (MySQL:query "insert into fruits values ('bananas', 33, null);")
+  (println "inserted-id: " (MySQL:inserted-id))
+
+  (println "inserted into fruits:")
+  (MySQL:query "select * from fruits;")
+  (println "\n" (MySQL:affected-rows) " affected rows in query select")
+  (dotimes (x (MySQL:num-rows)) (println (MySQL:fetch-row)))
+
+  (println "no rows = " (MySQL:num-rows) " no fields = " (MySQL:num-fields))
+  (println "fields = " (MySQL:fields "fruits"))
+  (println)
+  
+  (println "tables:")
+  (MySQL:query "show tables;")
+  (dotimes (x (MySQL:num-rows)) (println (MySQL:fetch-row)))
+  (println)
+  
+  (MySQL:query "select * from fruits;")
+  (MySQL:data-seek 2)
+
+  (println "data-seek to offset 2:")
+  (println (MySQL:fetch-row))
+  (println)
+  
+  (println "fetch-all:")
+  (println (MySQL:query "select * from fruits;"))
+  (println (MySQL:fetch-all))   
+  
+  (MySQL:query "drop table fruits;")
+  (MySQL:close-db)
+)
+
+; eof
diff --git a/modules/odbc.lsp b/modules/odbc.lsp
new file mode 100644
index 0000000..784736e
--- /dev/null
+++ b/modules/odbc.lsp
@@ -0,0 +1,524 @@
+;; @module odbc.lsp 
+;; @description ODBC database interface
+;; @version 1.7 - comments redone for automatic documentation
+;; @version 1.8 - doc changes
+;; @author Lutz Mueller, 2003-2010
+;;
+;; <h2>OCBC Interface functions</h2>
+;; This module has only been tested on Win32 but should work on UNIX too
+;; with few modifications. At the beginning of the program file include
+;; a 'load' statement for the module:
+;; <pre>
+;; (load "c:/Program Files/newlisp/modules/odbc.lsp")
+;; ; or shorter
+;; (module "odbc.lsp")
+;; </pre>
+;; Some of the code assumes Intel (low -> high) little-endian byte order.
+;;
+;; See the end of file for a test function 'test-odbc', which demonstrates the 
+;; usage of the module and can be used to test a correct ODBC installation and 
+;; data source setup.
+;; <h2>Requirements</h2>
+;; On Win32 platforms required 'odbc32.dll' is part of the OS's installations. 
+;; There is no UNIX function import tested or adapted for this ODBC module.
+;; <h2>Function overview</h2>
+;; <pre>
+;;  (ODBC:connect data-source-name-str user-name-str password-str) ; connect to a data source
+;;  (ODBC:query sql-str)          ; perform a SQL statement
+;;  (ODBC:num-cols)               ; number of columns in a query result set from 'select'
+;;  (ODBC:column-atts col)        ; retrieve columns attributes
+;;  (ODBC:fetch-row)              ; fetch a row of data after a sql query with 'select'
+;;  (ODBC:affected-rows)          ; number of rows affected by a sql query: 'delete', 'update' etc.
+;;  (ODBC:tables)                 ; return a list of tables in the current database
+;;  (ODBC:columns table-name)     ; return an array of column attributes in table-name
+;;  (ODBC:close-db)               ; close database connection
+;; </pre>
+
+(context 'ODBC)
+
+; ----------------- import functions from DLL -------------------
+
+
+; set to the appropiate library on Unix or Win32
+(define ODBC-library "odbc32.dll")
+
+; Constants used, make sure these constants are Ok on your Operating System or Platform.
+; Note, that (define var value) is the same as as saying (set 'var value), it is here more
+; of a visual distinction, documenting that values are constants and shouldn't be changed.
+; Most of these are defned in sql.h, sqltypes.h and sqlext.h of your platform.
+; The following definitions come from c:\Borland\BCC\Include
+
+(define SQL_HANDLE_ENV          1)
+(define SQL_HANDLE_DBC          2)
+(define SQL_HANDLE_STMT         3)
+(define SQL_HANDLE_DESC         4)
+
+(define SQL_NULL_HANDLE         0)
+
+(define SQL_SUCCESS             0)
+(define SQL_SUCCESS_WITH_INFO   1)
+
+(define SQL_OV_ODBC3            3)
+(define SQL_ATTR_ODBC_VERSION	200)
+
+(define SQL_LOGIN_TIMEOUT     103)
+
+(define SQL_NTS                -3)
+
+(define SQL_CHAR                1)
+(define SQL_C_CHAR       SQL_CHAR)
+
+
+; Import functions
+; there are many more, which are not used here, goto microsoft.com and unixodbc.org for
+; more information on ODBC SQLxxx API
+
+
+(set 'funcs '(
+	"SQLAllocHandle"
+	"SQLSetEnvAttr"
+	"SQLFreeHandle"
+	"SQLSetConnectAttr"
+	"SQLConnect"
+	"SQLDisconnect"
+	"SQLGetDiagRec"
+	"SQLExecDirect"
+	"SQLNumResultCols"
+	"SQLRowCount"
+	"SQLBindCol"
+	"SQLFetch"
+	"SQLDescribeCol"
+	"SQLTables"
+	"SQLColumns"))
+
+(dolist (fun funcs)
+	(import ODBC-library fun))
+
+; ------------------------------- reserve space for global pointers ----------------------------
+
+(set 'ptr-odbc-env "    ")     ; pointer to environment handle
+(set 'ptr-odbc-conn "    ")    ; pointer to connection handle
+(set 'ptr-result-cols "    ")  ; pointer to number of columns in result
+(set 'ptr-odbc-stmt "    ")    ; pointer to handle for sql statement
+(set 'ptr-result-rows "    ")  ; pointer to number of affected rows from sql statement
+
+(set 'odbc-stmt nil)           ; statement handle
+(set 'odbc-conn nil)           ; connection handle
+(set 'result-cols 0)           ; contains the number of rows resulting from a 'select' qery
+
+; -------------------------------------- AUXILIARY ROUTINES ------------------------------------
+
+; check result code
+
+(define (is-error-result)
+	;result is 16bit, disregard upper 16 bits
+	(set 'odbc-result (& 0xFFFF odbc-result))
+	(and (!= odbc-result SQL_SUCCESS) (!= odbc-result SQL_SUCCESS_WITH_INFO)))
+
+; initialize and make connection
+
+(define (init)
+	(and
+		; get environment handle
+		(set 'odbc-result (SQLAllocHandle SQL_HANDLE_ENV SQL_NULL_HANDLE ptr-odbc-env))
+
+		(if (is-error-result)
+			(begin
+				(println "Error allocating env handle")
+				nil) true)
+
+		(set 'odbc-env (get-int ptr-odbc-env))
+
+		; register version
+		(set 'odbc-result (SQLSetEnvAttr odbc-env SQL_ATTR_ODBC_VERSION SQL_OV_ODBC3 0))
+
+		(if (is-error-result)
+			(begin
+				(println "Error setting ODBC environment")
+				(SQLFreeHandle SQL_HANDLE_ENV odbc-env)
+				nil) true))
+	)
+
+; get diagnostic record 
+;
+; retrieve error info after last failed ODBC request
+;
+; type is one of the following:
+;
+; SQL_HANDLE_ENV, SQL_HANDLE_DBC, SQL_HANDLE_STMT, SQL_HANDLE_DESC 
+;
+
+(define (error type)
+	(set 'diag-status "          ")
+	(set 'diag-err  "    ")
+	(set 'diag-mlen "    ")
+	(set 'diag-message "                                                                ")
+	(SQLGetDiagRec type odbc-conn 1 diag-status diag-err diag-message 64 diag-mlen)
+	(string diag-message " " diag-status (get-int diag-err)))
+
+; bind all columns to string output 
+;
+; before fetching rows string variables are configured with sufficient long string buffers
+; for the 'fetch' statement.
+;
+
+(set 'vars '(var0  var1  var2  var3  var4  var5  var6  var7  var8  var9 
+             var10 var11 var12 var13 var14 var15 var16 var17 var18 var19 
+             var20 var21 var22 var23 var24 var25 var26 var27 var28 var29
+             var30 var32 var32 var33 var34 var35 var36 var37 var38 var39
+             var40 var41 var42 var43 var44 var45 var46 var47 var48 var49
+             var50 var51 var52 var53 var54 var55 var56 var57 var58 var59
+             var60 var51 var62 var63 var64))
+
+
+(define (bind-columns)
+	(set 'ptr-result-err "    ")
+	(for (v 1 result-cols)
+		(set 'w (+ (last (column-atts v)) 1))
+		(set (nth v vars) (format (string "%" w "s") ""))
+		(SQLBindCol odbc-stmt (int v) SQL_C_CHAR (eval (nth v vars)) w ptr-result-err))
+	
+	true)
+
+
+;====================================  USER ROUTINES ========================================
+
+
+;; @syntax (ODBC:connect <str-data-source> <str-user> <str-password>)
+;; @param <str-data-source> The ODBC dara source.
+;; @param <str-user> The user name.
+;; @param <str-password> The password of the user.
+;; @return 'true' on success, 'nil' on failure.
+;; Connect to a data-source with a user name and password.
+;; The data-source name must be configured first via ODBC
+;; administrative tools, i.e. a control applet on Win32.
+;;
+;; @example 
+;; (ODBC:connect "mydatabase" "johndoe" "secret")
+
+(define (ODBC:connect data-source user password)
+
+	(and
+		(init)
+
+		; allocate connection handle
+		(set 'odbc-result (SQLAllocHandle SQL_HANDLE_DBC odbc-env ptr-odbc-conn))
+
+		(if (is-error-result)
+			(begin
+				(println "Error allocating conn handle")
+				(SQLFreeHandle SQL_HANDLE_ENV odbc-env)
+				nil) true)
+
+		(set 'odbc-conn (get-int ptr-odbc-conn))
+
+		; set timeout for connection
+		(SQLSetConnectAttr odbc-conn SQL_LOGIN_TIMEOUT 5 0)
+
+		; connect to a data source
+		(set 'odbc-result (SQLConnect odbc-conn data-source SQL_NTS
+                                                      user SQL_NTS
+                                                      password SQL_NTS))
+
+		(if (is-error-result)
+			(begin
+				(println "Could not connect")
+				(SQLFreeHandle SQL_HANDLE_DBC odbc-conn)
+				(SQLFreeHandle SQL_HANDLE_ENV odbc-env)
+				nil) true))
+	)
+
+
+;; @syntax (ODBC:query <str-sql>)
+;; @param <str-sql> The SQL statement string.
+;; @return 'true' on success, 'nil' on failure.
+;; Send and SQL string for database manipulation
+;;
+;; @example
+;; (query "select * from someTable")
+;; (query "delete from addresses")
+;; (query "insert into fruits values ('apples', 11)")
+
+(define (ODBC:query sql-string)
+	(and 
+		; is stmt handle exists free it
+		(if odbc-stmt (begin 
+			(SQLFreeHandle SQL_HANDLE_STMT odbc-stmt)
+			(set 'odbc-stmt nil)
+			true)	true)
+
+		; allocate statement handle
+		(set 'odbc-result (SQLAllocHandle SQL_HANDLE_STMT odbc-conn ptr-odbc-stmt))
+
+		(if (is-error-result)
+			(begin
+				(println "could not allocate statement handle")
+				nil)
+			(set 'odbc-stmt (get-int ptr-odbc-stmt)))
+
+		; do the query
+		(set 'odbc-result (SQLExecDirect odbc-stmt sql-string SQL_NTS))
+		(if (is-error-result)
+			(begin
+				(println "query failed")
+				nil)
+			true)
+
+		; find number of columns in result set
+		(SQLNumResultCols odbc-stmt ptr-result-cols)
+		(set 'result-cols (& 0xFFFF (get-int ptr-result-cols)))
+
+		; bind colums to string vars for fetching
+		(if (not (= result-cols 0)) (bind-columns) true)
+		true
+		)
+		
+	)
+
+
+;; @syntax (ODBC:num-cols)
+;; @return Number of columns in the result set.
+
+(define (num-cols) result-cols)
+
+
+;; @syntax (ODBC:columns-atts <num-col>)
+;; @param <num-col> The number of the column, starting witth 1 for the first.
+;; @return A list of attributes for a column in a result set.
+;; Returns a list with the columname SQL, data type number and required column size
+;; when displaying in a string. For the data type number and SQL data type see
+;; the file 'sql.h' on your platform OS, i.e. 'SQL_VARCHAR', 'SQL_INTEGER' etc.
+;;
+;; before using 'ODBC:column-atts' a query has to be performed.
+;;
+;; @example
+;; (ODBC:column-atts 1)  => ("name" 12 20)
+
+;; The first column has the header '"name"' with data type 'SQL_VARCHAR' (12)
+;; and a maximum display width of 20 characters.
+
+(define (column-atts col)
+	(set 'col-name-out "                                ")
+	(set 'ptr-name-len "    ")
+	(set 'ptr-data-type "    ")
+	(set 'ptr-col-size "    ")
+	(set 'ptr-dec-dig "    ")
+	(set 'ptr-nullable "    ")
+
+	(set 'odbc-result (& 0xFFFF (SQLDescribeCol odbc-stmt (int col)
+                                                col-name-out 32
+                                                ptr-name-len
+                                                ptr-data-type
+                                                ptr-col-size
+                                                ptr-dec-dig
+                                                ptr-nullable)))
+	(list col-name-out (& 0xFFFF (get-int ptr-data-type)) (get-int ptr-col-size)))
+
+
+
+;; @syntax (ODBC:fetch-row)
+;; @return A list of items of a result set row.
+;; Fetches a row of data after a previously executed 'ODBC:query'. Each data is formatted as
+;; a string, and can be converted using newLISP conversion functions 
+;; like: 'int', 'float' or 'string'.
+;;
+;; If data types are unknown then 'ODBC:column-atts' can be used to retrieve the data type
+;; number.
+;;
+;; @example
+;; (ODBC:fetch-row) => ("apples" "11")
+
+(define (fetch-row , row)
+	(bind-columns)
+	(set 'odbc-result (& 0xFFFF (SQLFetch odbc-stmt)))
+	(if (is-error-result) 
+		nil
+		(begin
+			(for (x result-cols 1) (push (eval (nth x vars)) row))
+			row))) ; not necessary starting 9.9.5 because push returns the list
+
+
+;; @syntax (ODBC:affected-rows)
+;; @return Number of rows affected by the last SQL statement.
+;; Returns the number of rows affected by an 'insert', 'update' or 'delete', 'ODBX:query'
+;; operation. After a 'select' operation the number -1 will be returned.
+
+(define (affected-rows)	
+	(set 'odbc-result (& 0xFFFF (SQLRowCount odbc-stmt ptr-result-rows)))
+	(if (is-error-result) 0	(get-int ptr-result-rows)))
+
+
+;; @syntax (ODBC:tables)
+;; @return A list of tables in the current database connection.
+
+(define (tables)
+    (if (and
+        ; is stmt handle exists free it
+        (if odbc-stmt (begin
+            (SQLFreeHandle SQL_HANDLE_STMT odbc-stmt)
+            (set 'odbc-stmt nil)
+            true)   true)
+
+        ; allocate statement handle
+        (set 'odbc-result (SQLAllocHandle SQL_HANDLE_STMT odbc-conn ptr-odbc-stmt))
+        (if (is-error-result)
+            (begin
+                (println "could not allocate statement handle")
+                nil)
+            (set 'odbc-stmt (get-int ptr-odbc-stmt)))
+
+        ; do the query
+        (set 'odbc-result (SQLTables odbc-stmt 0 SQL_NTS 0 SQL_NTS "%" SQL_NTS 0 SQL_NTS))
+        (if (is-error-result)
+            (begin
+                (println "query failed")
+                nil)
+            true)
+
+        ;; find number of columns in result set
+        (SQLNumResultCols odbc-stmt ptr-result-cols)
+        (set 'result-cols (& 0xFFFF (get-int ptr-result-cols)))
+
+        ;; bind colums to string vars for fetching
+        (if (not (= result-cols 0)) (bind-columns) true)
+
+        (begin
+           (set 'names nil)
+           (while (set 'row (ODBC:fetch-row))
+               (push (nth 2 row) names -1))
+           true)
+        ) names)
+    )
+
+;; @syntax (ODBC:columns <str-table-name>)
+;; @param <str-table-name> The name of the table.
+;; @return A list of list of columns and their attributes.
+
+(define (ODBC:columns table)
+    (if (and
+        ; is stmt handle exists free it
+        (if odbc-stmt (begin
+            (SQLFreeHandle SQL_HANDLE_STMT odbc-stmt)
+            (set 'odbc-stmt nil)
+            true)   true)
+
+        ; allocate statement handle
+        (set 'odbc-result (SQLAllocHandle SQL_HANDLE_STMT odbc-conn ptr-odbc-stmt))
+
+        (if (is-error-result)
+            (begin
+                (println "could not allocate statement handle")
+                nil)
+            (set 'odbc-stmt (get-int ptr-odbc-stmt)))
+
+        ; do the query
+        (set 'odbc-result (SQLColumns odbc-stmt 0 SQL_NTS 0 SQL_NTS
+                          table SQL_NTS 0 SQL_NTS))
+        (if (is-error-result)
+            (begin
+                (println "query failed")
+                nil)
+            true)
+
+        ; find number of columns in result set
+        (SQLNumResultCols odbc-stmt ptr-result-cols)
+        (set 'result-cols (& 0xFFFF (get-int ptr-result-cols)))
+
+        ; bind colums to string vars for fetching
+        (if (not (= result-cols 0)) (bind-columns) true)
+
+        (begin
+           (set 'names nil)
+           (while (set 'col (ODBC:fetch-row))
+               (set 'attr (list (nth 3 col) (nth 5 col) (nth 6 col) (nth 8 col)))
+               (push attr names -1))
+           true)
+        ) names)
+    )
+
+
+;; @syntax (ODBC:close-db)
+;; @return 'true' on success, 'nil' on failure.
+;; Closes a database connection.
+
+(define (close-db)
+	(if odbc-stmt (SQLFreeHandle SQL_HANDLE_STMT odbc-stmt))
+	(set 'odbc-stmt nil)
+	(if odbc-conn (begin
+		(SQLDisconnect odbc-conn)
+		(SQLFreeHandle SQL_HANDLE_DBC odbc-conn)
+		(set 'odbc-conn nil)))
+	true)
+    
+
+(context 'MAIN)
+;=================================== test =================================================
+;
+; Note: before performing this test a database with name 'test'
+; and data source name 'test' should be created. The data base
+; should contain a table described by the following SQL statement:
+;
+;      create table fruits (name CHAR(20), qty INT(3))
+;
+; For this configure an Access database: 'test-db' with table 'fruits' 
+; and a text field 'name' width 20 and field 'qty' as type integer. 
+; Make the 'User Data Source' connection with the ODBC control applet 
+; in control-panel/administrative-tools for the MS Access *.mdb driver
+; and pick as a data source name and database location the test-db.mdb i
+; created. 
+;
+; On some systems the table can also be created with an SQL statement
+;     (ODBC:query "create ....")
+; On MS-Acces this will not work and the table has to be created
+; manually.
+;
+; A sample of test-db.mdb can be found at: 
+;     http://newlisp.org/downloads/Other/
+;
+; example:
+;          (test-odbc)
+;
+
+
+
+(define (test-odbc)
+
+	; Note, on MS-Access must create table fruits manually first
+	; else you could do:
+	;   (ODBC:query "create table fruits (name CHAR(20), qty INT(3))")
+	; for "aUser" and "secret" you may just put empty strings ""
+	; i.e. (ODBC:connect "test" "" "")
+	; when on Windows on the same machine
+
+	(if (not (ODBC:connect "test-db" "" "")) (exit))
+
+	(println "connected ...")
+
+	(ODBC:query "insert into fruits values ('apples', 11)")
+	(ODBC:query "insert into fruits values ('oranges', 22)")
+	(ODBC:query "insert into fruits values ('bananas', 33)")
+
+	(println "inserted 3 records")
+
+	(ODBC:query "select * from fruits")
+
+	(println "performed a query")
+
+	(println (ODBC:num-cols) " columns in result set")
+	(println "fetching rows ...")
+	(while (set 'row (ODBC:fetch-row)) 
+		(set 'row (map trim row))
+		(println row))
+	(println)
+
+
+	(ODBC:query "delete from fruits")
+	(println "rows deleted: " (ODBC:affected-rows))
+	
+	(println "\nclosing database")
+	(ODBC:close-db)
+	)
+
+
+
+; eof ;
diff --git a/modules/plot.lsp b/modules/plot.lsp
new file mode 100644
index 0000000..6dc640f
--- /dev/null
+++ b/modules/plot.lsp
@@ -0,0 +1,463 @@
+;; @module plot.lsp
+;; @description Routines for creating data plots.
+;; @version 1.1 initial release
+;; @version 1.2 allow different length data vectors
+;; @version 2.0 added plotXY for plotting data points -> (x, y)
+;; @version 2.1 added plot:reset for resetting optional labels and settings
+;; @version 2.2 option plot:data-min, plot:data-max did not work
+;; @author Lutz Mueller, September 2011, April 2012
+;;
+;; In its initial release the <tt>plot.lsp</tt> module can draw
+;; simple line plots from one to five data sets. In its simplest
+;; form only the <tt>plot</tt> command is necessary. A group of
+;; parameters can be set to further customize the plot. Plots can
+;; be save to a graphics file.
+;;
+;; Load the module using:
+;; <pre>(load "plot.lsp")</pre>
+;; This module runs the newLISP Java based Guiserver. The file
+;; <tt>guiserver.jar</tt> is installed by one of the newLISP binary
+;; installers in a standard location. Executing <tt>(test-plot)</tt>
+;; will generate a test plots which can be seen here:
+;; @link http://newlisp.org/code/example-line-plot.png line-plot
+;; and 
+;; @link http://newlisp.org/code/example-xy-plot.png XY-plot  .
+;; 
+;; Several variables can be set optionally to change the size,
+;; and positioning of the plot area in the image.
+;; Other variables can be set to control the partioning of the grid,
+;; labeling of the horizontal axis and legend.
+;; The following list shows all parameters with their default
+;; values:
+;; <pre>
+;; ; mandatory and preset with default values
+;; plot:wwidth        640 ; window width in pixels
+;; plot:wheight       420 ; window height in pixels
+;; plot:origin-x       64 ; top left x of plot area
+;; plot:origin-y       64 ; top left y of plot area
+;; plot:pwidth        520 ; width of plot area
+;; plot:pheight       280 ; height of plot area<br/>
+;; ; optional
+;; plot:data-min      nil ; minimum value on the Y axis 
+;; plot:data-max      nil ; maximum value on the Y axis 
+;; plot:title         nil ; top centered main title
+;; plot:sub-title     nil ; sub title under main title
+;; plot:unit-y        nil ; a unit label centered left to the Y axis
+;; plot:labels        nil ; a list of string labels for vertical grid
+;; plot:legend        nil ; a list of string labels<br/>
+;; ; optional for plotXY only
+;; plot:data-x-min    nil ; minimum value on the X axis 
+;; plot:data-x-max    nil ; maximum value on the X axis 
+;; plot:data-y-min    nil ; minimum value on the Y axis 
+;; plot:data-y-max    nil ; maximum value on the Y axis 
+;; plot:unit-x        nil ; a unit label centered under the X axis
+;; </pre>
+;;
+;; Only the the first group of variables is mandatory and preset to
+;; the values shown above. Options in the second group will be either
+;; suppressed or set automatically.
+
+;; @syntax (plot <list-data> [<list-data> . . . ])
+;; @param <list-data> One to five lists of data points.
+;; <br>
+;; The function draws one or more horizontal data lines from up
+;; to five data sets in <list-data>. Colors are chosen in the sequence
+;; red, green, blue, yellow and purple.
+;; <br><br>
+;; The following example doesn't set any extra options and plots to random
+;; data sets. Scale and labels on the vertical and horizontal axis
+;; will be set automatically. No title, sub-title and legends will
+;; be printed. 
+;;
+;; @example
+;; (plot (random 10 5 50) (normal 10 0.5 50))
+
+;; The following example sets several options then plots and 
+;; exports the image to a PNG graphics file:
+;;
+;; @example
+;; (set 'plot:title "The Example Plot")
+;; (set 'plot:sub-title "several random data sets")
+;; (set 'plot:labels '("1" "" "20" "" "40" "" "60" "" "80" "" "100"))
+;; (set 'plot:legend  '("first" "second" "third" "fourth"))
+;;
+;; ; display plot image
+;; (plot (random 10 5 100) 
+;;       (normal 10 0.5 100)
+;;       (normal 8 2 100) 
+;;       (normal 5 1 100) )
+;;
+;; ; save the displayed image to a file
+;; (plot:export "example-plot.png")
+;; 
+
+;; @syntax (plot:XY <list-data-X> <list-data-Y>)
+;; @param <list-data-X> List of X coordinates of data points.
+;; @param <list-data-X> List of Y coordinates of data points.
+;; <br>
+;; Draws data points of data in <list-data-X> and <list-data-Y>.
+;;
+
+;; @syntax (plot:export <str-file-name>)
+;; @param <str-file-name> The name of the file.
+;;
+;; Exports the current plot shown to a file in PNG format.
+;;
+;; @example
+;; (plot:export "example-plot.png")
+
+;; See the example plot
+;; @link http://newlisp.org/code/example-plot.png here .
+
+;; @syntax (plot:reset)
+;; <br>
+;; Resets all optional labels and sizes to 'nil'.
+
+(define (plot:export file-name)
+    (gs:export file-name))
+
+
+(set-locale "C")
+(load (append (env "NEWLISPDIR") "/guiserver.lsp")) 
+
+(context 'plot)
+
+(set 'wwidth 640)
+(set 'wheight 420)
+
+(set 'origin-x 64)
+(set 'origin-y 64)
+
+(set 'pwidth 520)
+(set 'pheight 280)
+
+(set 'title nil)
+(set 'sub-title nil)
+
+(set 'unit-x nil)
+(set 'unit-y nil)
+(set 'data-min nil)
+(set 'data-max nil)
+(set 'labels nil)
+(set 'legend nil)
+
+; colors
+(set 'background-color '(0.3 0.3 0.3))
+(set 'text-color '(0.9 0.9 0.9))
+(set 'grid-color '(0.5 0.5 0.5))
+(set 'frame-color '(0.7 0.7 0.7))
+
+(set 'line-color (array 5 '(
+    (1.0 0.35 0.35) ; 0 red
+    (0.0 0.9 0.0)   ; 1 green
+    (0.6 0.6 1.0)   ; 2 blue
+    (0.9 0.7 0.0)   ; 3 orange
+    (0.9 0.3 0.9)   ; 4 purple
+)))
+
+
+; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; auxiliary functions ;;;;;;;;;;;;;;;;;;;;;;
+
+; round to 3 digits precision
+; calculate rounding digits from (sub max min)
+; then apply to all numbers
+(define (rnd num)
+     (round num (- (log num 10) 2)))
+
+; setup the main window and plot area
+(define (setup-window)
+    (gs:init) 
+    ;; describe the GUI
+    (gs:frame 'PlotWindow 100 100 wwidth wheight "Plot")
+    (gs:set-resizable 'PlotWindow nil)
+    (gs:canvas 'PlotCanvas)
+    (gs:set-background 'PlotCanvas background-color)
+    (gs:add-to 'PlotWindow 'PlotCanvas)
+    (gs:set-translation  origin-x origin-y)
+
+    (gs:set-visible 'PlotWindow true)
+    ; draw title
+    (when title 
+        (gs:set-font 'PlotCanvas "Lucida Sans Typewriter Regular" 18 "bold")        
+        (gs:draw-text 'title title 
+            (/ (- pwidth (* (length title) 11)) 2) -34 text-color)
+    )
+    ; draw sub title
+    (when sub-title
+        (gs:set-font 'PlotCanvas "Lucida Sans Typewriter Regular" 12 "plain")       
+        (gs:draw-text 'title sub-title 
+            (/ (- pwidth (* (length sub-title) 7)) 2) -18 text-color)
+    )
+)
+
+(define (draw-grid L)
+    ; draw horizontal grid lines
+    (gs:set-stroke 1.0)
+    (for (i 1 4)
+        (let (y (/ (* i pheight) 5) )
+            (gs:draw-line 'Grid 0 y pwidth y grid-color))
+    )
+
+    (if labels
+        (set 'L (- (length labels) 1))
+        (unless L 
+            (set 'L (if (< N 50) (- N 1) 10)))
+    )
+
+    ; draw vertical grid lines
+    (gs:set-stroke 1.0)
+    (for (i 1 (- L 1))
+        (let (x (/ (* i pwidth) L) )
+             (gs:draw-line 'Grid x 0 x pheight grid-color)
+        )
+    )
+
+)
+
+(define (draw-grid-frame)
+    (gs:set-stroke 1.0)
+    (gs:draw-rect 'GridFrame 0 0 pwidth pheight)
+    (gs:color-tag 'GridFrame frame-color)
+    (gs:set-stroke 5.0)
+    (gs:draw-rect 'GridMask -3 -3 (+ pwidth 6) (+ pheight 6))
+    (gs:color-tag 'GridMask background-color)
+)
+
+
+(define (draw-labels) ; only used for line plot
+    ; draw labels for x-range under vertical grid lines
+    (gs:set-font 'PlotCanvas "Monospaced" 12 "plain")
+    (if labels
+      (let (step (div pwidth (- (length labels) 1))
+          cnt 0 )
+         (dolist (t labels)
+           (unless (empty? t)
+             (gs:draw-text 'Grid t (int (sub (mul step cnt) (mul (length t) 3.5)))  
+                (+ pheight 14) text-color))
+           (inc cnt))
+      )
+      ; else if no labels
+      (begin
+        (gs:draw-text 'Grid (format "%5d" 1) -32 (+ pheight 15) text-color)
+        (gs:draw-text 'Grid (format "%5d" N) (- pwidth 26) (+ pheight 15) text-color)
+      )
+    )
+)
+
+(define (draw-y-numbers range, y-format step)
+    ; draw y labels as of y-range left to horizontal grid lines
+    (gs:set-font 'PlotCanvas "Monospaced" 12 "plain")
+    (set 'y-format (if 
+            (< range 1)   "%8.3f"
+            (< range 10)  "%8.2f"  
+            (< range 100) "%8.1f"
+            true            "%8.0f"))
+
+    (set 'step (rnd (div range 5)))
+    (dotimes (i 6)
+        (let (y (- pheight -4 (* i (/ pheight 5))))
+            (gs:draw-text 'Grid 
+            (format y-format (add ymin (mul i step))) 
+                   -64 y text-color))
+    )
+ 
+    ; draw unit label to left center of grid
+    (when unit-y
+        (gs:draw-text 'Grid unit-y -50 (+ (/ pheight 2) 4) text-color))
+)
+
+(define (draw-x-numbers n range xmin, x-format x-offset L step)
+    ; draw numbers for x-range under vertical grid lines
+    (gs:set-font 'PlotCanvas "Monospaced" 12 "plain")
+
+    (set 'x-format (if 
+            (< range 1)   "%8.3f"
+            (< range 10)  "%8.2f"  
+            (< range 100) "%8.1f"
+            true            "%8.0f"))
+
+    (set 'x-offset (if 
+            (< range 1)   20
+            (< range 10)  14  
+            (< range 100)  8 
+            true             2 ))
+
+
+    (set 'L 10)
+    (set 'step (rnd (div range L)))
+    
+    (for (i 0 (- L 1))
+        (let ( x (+ (* i  (/ pwidth L)) x-offset) )
+             (gs:draw-text 'Grid  
+                (format x-format (add xmin (mul (+ i 1) step)))
+                x (+ pheight 15) text-color)
+        )
+    )
+    ; unit label
+    (when unit-x
+        (gs:draw-text 'Grid unit-x (- (/ pwidth 2) 30) (+ pheight 30) text-color))
+)
+
+; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; user functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; take one or more data vectors (lists) as arguments
+(define (plot:plot)
+    (setup-window)
+    ; set data min, max and range over all plot vectors
+    (set 'M (length (args)))
+    (set 'N 0)
+    (dotimes (m M)
+        (set 'data (args m) )
+        (set 'N (max N (length data)))
+        (unless (and data-min data-max)
+            (if (= 0 m)
+                (begin
+                    (set 'ymin (apply min data))
+                    (set 'ymax (apply max data)) )
+                (begin
+                    (set 'ymin (min ymin (apply min data)))
+                    (set 'ymax (max ymax (apply max data))))
+            )
+        )
+    )
+
+    ; overwrite ymin and ymax if data-min/mx are defined
+    (when (and data-min data-max)
+        (set 'ymin data-min)
+        (set 'ymax data-max))
+
+    (set 'y-range (sub ymax ymin))
+    (draw-grid)
+    (draw-labels)
+    (draw-y-numbers y-range)
+
+    ; for each data vector draw data
+    (gs:set-stroke 1.5)
+    (dotimes (m M)
+        (set 'data (args m))
+        ; draw data
+        (set 'last-x nil 'last-y nil)
+        (dotimes (i (length data))
+            (let (x (div (mul i pwidth) (- N 1)) 
+                  y (div (mul (sub (pop data) ymin) pheight) y-range))
+                (when last-x 
+                    (gs:draw-line 'seg last-x (- pheight last-y) 
+                        (int x) (int (- pheight y)) (line-color m)))
+                (set 'last-x (int x) 'last-y (int y))
+            )
+        )
+    )
+
+    ; draw legend depending on the number of plot lines
+    ; style below 
+    (dotimes (m M)
+        (let (x (* m (/ pwidth 5)))
+            (when (and (list? legend) (= M (length  legend))) 
+                (gs:draw-line 'legend x (+ pheight 30) (+ x 25) (+ pheight 30) (line-color m))
+                (gs:draw-text 'legend (legend m) (+ x 1 30) (+ pheight 33) text-color)
+            )
+        )
+    )
+
+    (draw-grid-frame)
+    (gs:set-visible 'PlotWindow true)
+)
+
+(define (plot:XY data-x data-y (idx-color 3) , N, xmin, xmax, ymin, ymax)
+    ; set data min, max and range over the two data vectors
+    (set 'N (length data-x))
+    (when (!= N (length data-y))
+        (throw-error "X vecor and Y vector must be of equal length"))
+
+    (setup-window)
+
+    (set 'xmin (apply min data-x))
+    (set 'xmax (apply max data-x)) 
+    (set 'ymin (apply min data-y))
+    (set 'ymax (apply max data-y)) 
+
+    (when (and data-x-min data-x-max)
+        (set 'xmin data-x-min)
+        (set 'xmax data-x-max))
+    
+    (when (and data-y-min data-y-max)
+        (set 'ymin data-y-min)
+        (set 'ymax data-y-max))
+
+    (set 'x-range (sub xmax xmin))
+    (set 'y-range (sub ymax ymin))
+
+    (draw-grid 10)
+    (draw-y-numbers y-range)
+    (draw-x-numbers N x-range xmin)
+
+    ; draw XY data points in (line-color idx-color)
+    (gs:set-stroke 1.5)
+    (dotimes (i N)
+        (let (x (div (mul (sub (pop data-x) xmin) pwidth) x-range)
+              y (div (mul (sub (pop data-y) ymin) pheight) y-range))
+            (if (and (< x pwidth) (< y pheight) (>= x 0) (>= y 0))
+                (gs:draw-circle 'xy-points (int x) (int (- pheight y)) 3 (line-color idx-color)))
+        )
+    )
+
+    (draw-grid-frame)
+    (gs:set-visible 'PlotWindow true)
+)
+
+(define (plot:reset)
+    (setq
+        data-min      nil ; minimum value on the Y axis 
+        data-max      nil ; maximum value on the Y axis 
+        title         nil ; top centered main title
+        sub-title     nil ; sub title under main title<br>
+        unit-y        nil ; a unit label centered left to the Y axis
+        labels        nil ; a list of string labels for vertical grid
+        legend        nil ; a list of string labels
+        data-x-min    nil ; minimum value on the X axis 
+        data-x-max    nil ; maximum value on the X axis 
+        data-y-min    nil ; minimum value on the Y axis 
+        data-y-max    nil ; maximum value on the Y axis 
+        unit-x        nil ; a unit label centered under the X axis
+    )
+)
+;; </pre>
+
+(context MAIN)
+
+; test
+(define (test-plot)
+    ; optional title, sub-title, labels and legend, data min/max for Y
+    (set 'plot:title "The Example Line Plot")
+    (set 'plot:sub-title "several random data sets")
+    (set 'plot:labels '("1" "" "20" "" "40" "" "60" "" "80" "" "100"))
+    (set 'plot:legend  '("first" "second" "third" "fourth"))
+    ;(set 'plot:data-min 0 'plot:data-max 20)
+
+    (set 'plot:unit-y "unit y")
+    ; display plot - only required statement
+    (plot (random 10 5 100) 
+          (normal 10 0.5 100)
+          (normal 8 2 100) 
+          (normal 5 1 100) )
+
+    ; optionally save the display to a file
+    (plot:export "example-line-plot.png")
+
+    ; test XY plot
+    (plot:reset)
+    (set 'plot:title "The Example XY Plot")
+    (set 'plot:sub-title "1000 normal distributed data points")
+    (set 'plot:unit-x "unit x")
+
+    (plot:XY (normal 10 3 1000) (normal 0 1 1000) )
+    (plot:export "example-xy-plot.png")
+
+)
+
+
+;(plot (random 10 5 50) (normal 10 0.5 50))
+
+;(test-plot)
+;(exit)
+
diff --git a/modules/pop3.lsp b/modules/pop3.lsp
new file mode 100644
index 0000000..e0ad151
--- /dev/null
+++ b/modules/pop3.lsp
@@ -0,0 +1,323 @@
+;; @module pop3.lsp
+;; @description POP3 mail retrieval routines
+;; @version 2.0 - eliminated old net-send syntax
+;; @version 2.1 - changes for 10.0
+;; @version 2.3 - three fixes by winger 2012-08-29 (search: winger's fix)
+;; @version 2.4 - changes references to /usr/ to /usr/local/
+; Do not fully understand winger's 'net-receive-blank' , couldn't 'net-flush'
+; be used instead? The problem seems to be trailing spaces after "+OK".
+; Can somebody with access to a pop3 server verify?
+;; @author Lutz Mueller et al., 2001, 2002, 2008, 2010, 2012
+;;
+;;
+;; <h2>POP3 mail retrieval routines</h2>
+;; Only the module 'pop3.lsp' is required, not other libraries need to be
+;; present. Not all mailservers support all functions.
+;;
+;; To use the module put a 'load' statement at the top of your file:
+;; <pre>
+;; (load "/usr/local/share/newlisp/modules/pop3.lsp")
+;; ; or shorter
+;; (module "pop3")
+;; </pre>
+;;
+;; <h2>Function overview</h2>
+;; Load down all messages and put them in a directory 'messages/':
+;; <pre>
+;; (POP3:get-all-mail "user" "password" "pop.my-isp.com" "messages/")
+;; </pre>
+;; Load down only new messages:
+;; <pre>
+;; (POP3:get-new-mail "user" "password" "pop.my-isp.com" "messages/")
+;; </pre>
+;; Delete messages, which have not been read:
+;; <pre>
+;; (POP3:delete-old-mail "user" "password" "pop.my-isp.com")
+;; </pre>
+;; Delete all messages:
+;; <pre>
+;; (POP3:delete-all-mail "user" "password" "pop.my-isp.com")
+;; </pre>
+;; Get a list of status numbers '(<totalMessages>, <totalBytes>, <lastRead>)':
+;; <pre>
+;; (POP3:get-mail-status "user" "password" "pop.my-isp.com")
+;; </pre>
+;; Get error message for failed all/new/status function:
+;; <pre>
+;; (POP3:get-error-text)
+;; </pre>
+;; All functions return 'nil' on error and 'POP3:get-error-text' can be used to
+;; retrieve the error text.
+;;
+;; The variable 'POP3:debug-flag' can be set to 'true' to display all of the
+;; dialog with the pop2 mail server.
+
+(context 'POP3)
+
+(set 'debug-flag nil)
+
+;; @syntax (POP3:get-all-mail <str-user> <str-password> <str-server> <str-dir>)
+;; @param <str-user> The user ID.
+;; @param <str-password> The password for the user ID.
+;; @param <str-dir> The local directory for the retrieved mail.
+;; @return On success 'true' else 'nil'.
+
+(define (get-all-mail userName password pop3server mail-dir)
+    (and
+        (connect pop3server)
+        (logon userName password)
+        (set 'status (get-status))
+        (set 'no-msgs (nth 2 status))
+        (if (> no-msgs 0)
+          (get-messages 1 no-msgs mail-dir)
+          true)
+        (log-off)))
+
+;; @syntax (POP3:get-new-mail <str-user> <str-password> <str-server> <str-dir>)
+;; @param <str-user> The user ID.
+;; @param <str-password> The password for the user ID.
+;; @param <str-dir> The local directory for the retrieved mail.
+;; @return On success returns 'true' else 'nil'.
+;; On failure use 'POP3:get-error-text' to retrieve the text of
+;; the last error which occured.
+
+(define (get-new-mail userName password pop3server mail-dir)
+    (and
+        (connect pop3server)
+        (logon userName password)
+        (set 'status (get-status true))
+        (if (<= (first status) (nth 2 status))
+            ; winger's fix1 "messages are counted from 1"
+            (get-messages (++ (first status)) (nth 2 status) mail-dir)
+            ; (get-messages (first status) (nth 2 status) mail-dir);
+            true)
+        (log-off)
+    ) )
+
+;; @syntax (POP3:get-mail-status <str-user> <str-password> <str-server>)
+;; @param <str-user> The user ID.
+;; @param <str-password> The password for the user ID.
+;; @return A list of status information.
+;; The list of status information returned contains the following items:
+;; (<totalMessages>, <totalBytes>, <lastRead>)
+
+(define (get-mail-status userName password pop3server)
+    (and
+        (connect pop3server)
+        (logon userName password)
+        (set 'status (get-status true))
+        (log-off)
+        status))
+
+;; @syntax (POP3:delete-old-mail <str-user> <str-password> <str-server>)
+;; @param <str-user> The user ID.
+;; @param <str-password> The password for the user ID.
+;; @return The number of messages left on the server.
+
+(define (delete-old-mail userName password pop3server)
+    (and
+        (connect pop3server)
+        (logon userName password)
+        (set 'status (get-status true))
+        (if (> (first status) 1)
+            (for (msg 1 (- (first status) 1) ) (delete-message msg))
+            true)
+        (log-off)
+        (first status)))
+
+;; @syntax (POP3:delete-all-mail <str-user> <str-password> <str-server>)
+;; @param <str-user> The user ID.
+;; @param <str-password> The password for the user ID.
+;; @return The number of the message last read.
+(define (delete-all-mail userName password pop3server)
+    (and
+        (connect pop3server)
+        (logon userName password)
+        (set 'status (get-status))
+        (if (> (last status) 0)
+            (for (msg 1 (last status) ) (delete-message msg))
+            true)
+        (log-off)
+        (last status)))
+
+; receive request answer and verify
+;
+(define (net-confirm-request)
+    (if (net-receive socket rcvbuff 512 "+OK")
+        (begin
+        (if debug-flag (println rcvbuff))
+            (if (find "-ERR" rcvbuff)
+                (finish rcvbuff)
+                true))
+        nil))
+
+; winger's fix2 bypass " " of "+OK "
+(define-macro (net-receive-blank int_socket sym-buffer max-bytes wait-string)
+    (letex (int_socket (eval int_socket)
+            sym-buffer sym-buffer
+            max-bytes max-bytes)
+        (if (and (net-receive int_socket sym-buffer max-bytes) (= " " sym-buffer))
+            (net-receive int_socket sym-buffer max-bytes) )
+    )
+)
+
+(define (net-flush)
+    (if socket
+        (while (> (net-peek socket) 0)
+            (net-receive socket junk 256)
+            (if debug-flag (println junk) )))
+    true)
+
+; connect to server
+;
+(define (connect server)
+    (set 'socket (net-connect pop3server 110))
+    (if (and debug-flag socket) (println "connected on: " socket) )
+    (if (and socket (net-confirm-request))
+        (net-flush)
+        (finish "could not connect")))
+
+;
+(define (logon userName password)
+    (and
+        (set 'sndbuff (append "USER " userName "\r\n"))
+        (net-send socket sndbuff)
+        (if debug-flag (println "sent: " sndbuff) true)
+        (net-confirm-request)
+        (net-flush)
+        (set 'sndbuff (append "PASS " password "\r\n"))
+        (net-send socket sndbuff)
+        (if debug-flag (println "sent: " sndbuff) true)
+        (net-confirm-request)
+        (net-flush)
+        (if debug-flag (println "logon successful") true)))
+
+
+; get status and last read
+;
+(define (get-status last-flag)
+    (and
+        (set 'sndbuff "STAT\r\n")
+        (net-send socket sndbuff)
+        (if debug-flag (println "sent: " sndbuff) true)
+        (net-confirm-request)
+        ; (net-receive socket status 256) ; old in 2.1 (10.4.3)
+        (net-receive-blank socket status 256) ; new in 2.3 (10.4.4)
+        (if debug-flag (println "status: " status) true)
+        (net-flush)
+        (if last-flag
+            (begin
+                (set 'sndbuff "LAST\r\n")
+                (net-send socket sndbuff)
+                (if debug-flag (println "sent: " sndbuff) true)
+                (net-confirm-request)
+                ; (net-receive socket last-read 256) ; old
+                (net-receive-blank socket last-read 256) ; new
+                (if debug-flag (println "last read: " last-read) true)
+                (net-flush))
+            (set 'last-read "0"))
+        (set 'result (list (int (first (parse status)))))
+        (if debug-flag (println "parsed status: " result) true)
+        (push (int (nth 1 (parse status))) result)
+        (push (int (first (parse last-read))) result)
+        result)) ; not necessary starting 9.9.5 because push returns the list
+
+
+; get a message
+;
+(define (retrieve-message , message)
+    (set 'finished nil)
+    (set 'message "")
+    (while (not finished)
+        (net-receive socket rcvbuff 16384)
+        (set 'message (append message rcvbuff))
+        (if (find "\r\n.\r\n" message) (set 'finished true)))
+    (if debug-flag (println "received message") true)
+    message)
+
+
+; get all messages
+;
+; v 1.4: modified file name generation to improve uniqueness. (CaveGuy)
+;        file name now created using last SMTP or ESMTP ID from header.
+; v 1.5: changed file type to ".pop3" to reflect the context that created it.
+;        (get-messages now forces the directory, if it does not exsist.
+; v 1.6: make sure directory? doesn't have trailing slash in arg
+;
+(define (get-messages from to mail-dir)
+   (if (ends-with mail-dir "/") (set 'mail-dir (chop mail-dir)))
+   (if (if (not (directory? mail-dir)) (make-dir mail-dir) true)
+       (begin
+          (set 'mail-dir (append mail-dir "/")) 
+          (for (msg from to)
+               (if debug-flag (println "getting message " msg) true)
+               (set 'sndbuff (append "RETR " (string msg) "\r\n"))
+               (net-send socket sndbuff)
+               (if debug-flag (println "sent: " sndbuff) true)
+               (set 'message (retrieve-message))
+               (if debug-flag (println (slice message 1 200)) true)
+               (set 'istr (get-message-id message))
+               (set 'istr (append mail-dir "ME-" istr))
+               (if debug-flag (println "saving " istr) true)
+               (write-file istr message)
+               (if (not (rename-file istr (append istr ".pop3")))
+               (delete-file istr)))))
+    true) ; other parts of pop3 rely on 'true' return
+
+; delete messages
+;
+(define (delete-message msg)
+    (and
+        (set 'sndbuff (append "DELE " (string msg) "\r\n"))
+        (net-send socket sndbuff)
+        (if debug-flag (println "sent: " sndbuff) true)
+        (net-confirm-request)))
+
+; get-message-date was
+; changed to get-message-id
+; v 1.4: CaveGuy
+
+(define (get-message-id message)
+    (set 'ipos (+ (find "id <| id |\tid " message 1) 5)
+         ; winger's fix3 delete char '>'
+         'iend (-- (find "@|;|\n|\r| |\t" (slice message ipos) 1)))
+         ; 'iend (find "@|;|\n|\r| |\t" (slice message ipos) 1));
+    (if debug-flag
+    (print "Message ID: " (slice message ipos iend) "\n"))
+    (set 'istr (slice message ipos iend)) )
+
+
+; log off
+;
+(define (log-off)
+    (set 'sndbuff "QUIT\r\n")
+    (net-send socket sndbuff)
+    (if debug-flag (println "sent: " sndbuff) true)
+    (net-receive socket rcvbuff 256)
+    (if debug-flag (println rcvbuff) true)
+    true)
+
+; report error and finish
+;
+(define (finish message)
+    (if (ends-with message "+OK")
+      (set 'message (chop message 3)))
+    ;(print "<h3>" message "</h3>")
+    (set 'mail-error-text message)
+    (if debug-flag (println "ERROR: " message) true)
+    (if socket (net-flush))
+    (if socket (log-off))
+    nil)
+
+;; @syntax (POP3:get-error-text)
+;; @return The text of the last error occurred.
+
+(define (get-error-text) mail-error-text)
+
+(context 'MAIN)
+
+
+; test
+;(if (not(POP3:get-all-mail "user" "password" "my-isp.com" "mail"))
+;    (print (POP3:get-error-text)) true)
+;(exit)
diff --git a/modules/postgres.lsp b/modules/postgres.lsp
new file mode 100644
index 0000000..0fe5ec5
--- /dev/null
+++ b/modules/postgres.lsp
@@ -0,0 +1,832 @@
+;; @module postgres.lsp 
+;; @description PostgreSQL interface (tested on PostgreSQL 9.4, should work on all supported versions)
+;; @version 1.02  - feature complete
+;; @version 1.03  - doc formatting
+;; @version 2.00  - replaced <tt>inc</tt> with <tt>++</tt>
+;; @version 2.10  - new <tt>fnumber</tt> and <tt>fetch-value</tt>
+;; @version 2.11  - new <tt>query</tt> with optional parameters
+;; @version 2.12  - add MacPorts path, Fix bugs (error), (affected-rows), (fields ...), test against PostgreSQL 9.4
+;; @version 3.00  - add new postgreSQL imports, use pg_config to find libpq header, improve test coverage
+;; @author Jeremy Cowgar 2006, Ted Walther 2009, Lutz Mueller 2010, Unya 2012, Neil Tiffin 2015
+;;
+;; <h3>Requirements</h3>
+;; At the beginning of the program file include a 'load' statement for the module:
+;; <pre>
+;; (load "/usr/share/newlisp/modules/postgres.lsp")
+;; ; or
+;; (module "postgres.lsp") ; loads from (env "NEWLISPDIR") / modules
+;; </pre>
+;;
+;; A version of 'libpq' for a specific platform is required:
+;;  
+;; on LINUX/UNIX: 'libpq.so' <br>
+;; on Mac OS X:   'libpq.dylib' <br>
+;; on Windows:    'libpq.dll'
+;;
+;; This library is installed when using the install
+;; package @link http://www.postgresql.org/download/ .
+;; Unix, Linux, and Mac each have package installers that can be used
+;; to install the PostgreSQL client (libpq) & server.
+;;
+;; Libpq might be in a different location on a particular
+;; installation of PostgreSQL or have a different extension.
+;; This module attempts to find libpq using pg_config.  If you can execute
+;; pg_config at the command line and see its results then everything should just
+;; work.  If not, then
+;; you may have to edit the manual search code below to find your specific libpq.
+;;
+;; If you are using PostgreSQL from a Linux distribution you will need to install the
+;; development headers for libpq, usually called libpq-dev.
+;;
+;; The PostgreSQL server itself may reside on a different machine
+;; on the network. The library 'libpq' will communicate
+;; with that server. The correct connection is created using
+;; the 'PgSQL:connect' call.
+;;
+;; At the bottom of the module file 'postgres.lsp' a test routine 'test-pgsql'
+;; is included to test for correct installation of PostgreSQL.  You call it
+;; with the same arguments you would pass to ':connect'
+;;
+;; <h3>Functions available</h3>
+;; <pre>
+;;   Connect
+;;     PgSQL:connect ............. connect to a database
+;;     PgSQL:close-db ............ close database connection
+;;     PgSQL:error-conn .......... get connection error message *
+;;
+;;   Query
+;;     PgSQL:query ............... execute a SQL statement
+;;
+;;   Query Results
+;;     PgSQL:affected-rows ....... number of affected rows from operation
+;;     PgSQL:data-seek ........... position in result for fetching
+;;     PgSQL:error ............... get query error message
+;;     PgSQL:fetch-all ........... get all rows from the last query
+;;     PgSQL:fetch-row ........... get row from the query result
+;;     PgSQL:fetch-value ......... get value from the query result
+;;     PgSQL:fnumber ............. column number of query
+;;     PgSQL:num-fields .......... columns in result of query
+;;     PgSQL:num-rows ............ rows in result of query
+;;
+;;   Info
+;;     PgSQL:database ............ return all database names
+;;     PgSQL:fields .............. return all fields in a table
+;;     PgSQL:tables .............. return all tables names
+;;
+;;   Misc
+;;     PgSQL:escape .............. escapes single quote in input string 
+;;     PgSQL:escape-literal ...... escapes literal for PostgreSQL *
+;;     PgSQL:escape-identifier ... escapes identifier for PostgreSQL *
+;;
+;; * API may be specific to PostgreSQL
+;; </pre>
+;;
+;; <h3>Differences from the MySQL module</h3>
+;;
+;; The function ':inserted-id' isn&#039;t supported because PostgreSQL
+;; doesn&#039;t support it.  Instead, use the 'RETURNING' clause in your 'INSERT'
+;; statement, then use ':fetch-row' or ':fetch-all' to
+;; find the value.  'INSERT&nbsp;RETURNING' is a PostreSQL idiom
+;; documented @link http://www.postgresql.org/docs/9.4/static/sql-insert.html here.
+;;
+;; There is no ':init' function because it isn't needed by the underlying
+;; library.  Just call ':connect'.
+;;
+;; <h3>A typical PgSQL session</h3>
+;; The following code piece outlines a typical PgSQL session:
+;;
+;; @example
+;; (module "postgres.lsp") ; load the module file
+;;
+;; (PgSQL:connect "192.168.1.10" "auser" "secret" "mydb") ; logon
+;; (PgSQL:query "select ...;") ; SQL query
+;; (PgSQL:query "insert ...;") ; SQL query
+;;        ...
+;; (PgSQL:close-db)
+
+;; The database server is listening on IP 192.168.1.10. The program
+;; connects with username '"auser"' password '"secret"' to a database with 
+;; the name '"mydb"'. After connecting SQL statements are performed and
+;; finally the program disconnects from the server.
+;; 
+;; If the database server is running locally then "localhost" may be used for
+;; the host name.
+;;
+;; <h3>Bugs</h3>
+;;
+;; This module doesn't support connections through a Unix socket.
+;;
+;; <h3>Implementation Notes</h3>
+;; As of 19 March 2015.
+;; On Windows only works with x86 (32bit) PostgreSQL install.
+;; pg_config must be in the path.
+;; Tested on OSX 10.10.2, Linux SMP Debian 3.16.7-ckt7-1, Windows 8.1 [version 6.3.9600]
+
+; make this module compatible with version less than 10.1.11
+(when (< (sys-info -2) 10110)
+	(constant (global '++) inc))
+
+(context 'PgSQL)
+
+; get pg_config if available  
+(set 'pg_lib_dir (exec "pg_config --libdir"))
+
+(if pg_lib_dir
+  (set 'files
+    (list 
+      (append (first pg_lib_dir) "/libpq.dylib")  ; shared Mac OS X libs
+      (append (first pg_lib_dir) "/libpq.so")   ; loadable elf libs Posix Unix Linux
+      (append (first pg_lib_dir) "/libpq.dll")  ; Windows lib
+  ))
+  (set 'files '(
+    "/usr/local/lib/libpq.so.5.1" ; OpenBSD 4.6
+    "/usr/lib/libpq.so" ; CentOS or other Linux
+    "/usr/lib64/libpq.so" ; Linux 64bit
+    "/usr/lib/libpq.so.5.1" ; Debian
+    "/usr/local/pgsql/lib/libpq.dylib" ; Mac OS X
+    "c:/Program Files/PostgreSQL/8.3/bin/libpq.dll" ; Win32
+  )))
+
+; find the library file
+(set 'library (files (or
+  (find true (map file? files))
+  (throw-error "Cannot find libpq library!"))))
+
+; done with these
+(delete 'pg_config)
+(delete 'pg_lib_dir)
+(delete 'files)
+
+; import functions and throw error if not found
+(define (pg_import fun_name)
+  (import library fun_name "cdecl"))
+
+; import functions and print warning if not found
+(define (pg_import_warn fun_name)
+  (unless (catch (import library fun_name "cdecl") 'pg_load_error)
+    (println "libpq import WARNING: " pg_load_error)))
+
+; import functions available in libpq for 8.4 or earlier
+; These are core functions and will throw an error if not found.
+(map pg_import (list 
+	"PQcancel"
+	"PQclear"
+	"PQcmdStatus"
+	"PQcmdTuples"
+	"PQconnectdb"
+	;"PQconnectionNeedsPassword"	; PostgreSQL 8.3
+	;"PQconnectionUsedPassword"		; PostgreSQL 8.3
+	"PQconsumeInput"
+	"PQdb"
+	"PQdescribePortal"				; PostgreSQL 8.2
+	"PQdescribePrepared"			; PostgreSQL 8.2
+	;"PQencryptPassword"				; PostgreSQL 8.2
+	"PQerrorMessage"
+	"PQexec"
+	"PQexecParams"
+	"PQexecPrepared"					; PostgreSQL 7.4
+	"PQfinish"
+	"PQflush"
+	"PQfname"
+	"PQfnumber"
+	"PQfreeCancel"
+	"PQfreemem"								; PostgreSQL 7.4
+	"PQgetCancel"
+	"PQgetisnull"
+	"PQgetvalue"
+	"PQhost"
+	"PQinstanceData"					; PostgreSQL 8.4
+	"PQisBusy"
+	"PQisnonblocking"
+	"PQisthreadsafe"					; PostgreSQL 8.2
+	"PQnfields"
+	"PQnotifies"
+	"PQntuples"
+	"PQoptions"
+	"PQpass"
+	"PQport"
+	"PQprepare"								; PostgreSQL 8.0
+	"PQprotocolVersion"
+	"PQregisterEventProc"			; PostgreSQL 8.4
+	"PQresultErrorMessage"
+	"PQresultInstanceData"		; PostgreSQL 8.4
+	"PQresultSetInstanceData"	; PostgreSQL 8.4
+	"PQresultStatus"
+	"PQresStatus"
+	"PQsendQueryPrepared"			; PostgreSQL 7.4
+	"PQserverVersion"					; PostgreSQL 8.0
+	"PQsetInstanceData"				; PostgreSQL 8.4
+	"PQsetnonblocking"
+	"PQsetNoticeProcessor"
+	"PQsetNoticeReceiver"
+	"PQstatus"
+	"PQuser"
+))
+
+; Try to import new libpq functions and print warning (do not throw error) if not found.
+; if any of these functions are used then the code in this module should verify
+; that the respective function was actually loaded before use.
+(map pg_import_warn (list 
+	"PQconninfo"					; PostgreSQL 9.3
+	"PQescapeIdentifier"	; PostgreSQL 9.1
+	"PQescapeLiteral"			; PostgreSQL 9.1
+	"PQlibVersion"				; PostgreSQL 9.0
+	"PQping"							; PostgreSQL 9.0
+	"PQpingParams"				; PostgreSQL 9.0
+	"PQsetSingleRowMode"	; PostgreSQL 9.2
+))
+
+(delete 'pg_import_warn)
+(delete 'pg_import)
+
+
+; On some wierd platforms NULL may equal something else, we'll worry about that when we bump into it.
+(define NULL 0)
+(define (NULL? n) (= 0 n))
+
+(setq
+  CONNECTION_OK 0
+  PGRES_FATAL_ERROR 7)
+
+(set 'PQPING_STATUS '(
+	"PQPING_OK"
+	"PQPING_REJECT"
+	"PQPING_NO_RESPONSE"
+	"PQPING_NO_ATTEMPT"))
+
+; module variables
+(setq PG_CONN nil)			; pg connection structure
+(setq PG_RESULT nil)		; pg query result structure
+(setq PG_ROWX 0)				; current row
+(setq PG_COLX 0)				; current column
+
+;; @syntax (PgSQL:connect <str-server> <str-userID> <str-password> <str-db>)
+;; @param <str-server> The host name or IP address or <tt>0</tt> for localhost.
+;; @param <str-userID> The user ID for authentication.
+;; @param <str-password> The password for authentication.
+;; @param <str-db> The name of the database to connect to.
+;; @return 'true' for success or 'nil' for failure.
+;; Connects to a database on server and authenticates a user ID.
+
+(define (connect host user passw dbname)
+  (connectdb (string
+	(if (> (length host) 0) (string "host=" host) "")
+	(if (> (length user) 0) (string " user=" user) "")
+	(if (> (length passw) 0) (string " password=" passw) "")
+	(if (> (length dbname) 0) (string " dbname=" dbname) "")
+	)) )
+
+;; @syntax (PgSQL:connectdb <str-conninfo>)
+;; @param <str-conninfo> PostgreSQL Connection Parameters, To write an empty value or a value containing spaces, surround it with single quotes, e.g., keyword = 'a value'. keyword is 'host', 'hostaddr, 'port', 'dbname', 'user', 'password', 'connect_timeout', 'client_encoding', 'options', 'application_name', 'fallback_application_name', 'keepalives', 'keepalives_idle', 'keepalives_interval', 'keepalives_count', 'tty', 'sslmode', 'sslcompression', 'sslcert', 'sslkey', 'sslrootcert', 'sslcrl', 'requirepeer', 'krbsrvname', 'gsslib', 'service' in PostgreSQL 9.4.
+;; @return 'true' for success or nil on failure.
+;; Connects to a database on server.
+
+(define (connectdb conninfo)
+  (close-db)
+  (setq PG_CONN (PQconnectdb conninfo))
+  (if (NULL? PG_CONN)
+    nil
+    (if (= (PQstatus PG_CONN) CONNECTION_OK)
+      true
+      (PQfinish PG_CONN)
+      (setq PG_CONN nil))))
+
+
+;; @syntax (PgSQL:query <str-sql> [<param> ...])
+;; @param <str-sql> A valid SQL query string. If parameters are used, they are referred to in the command string as $1, $2, etc.
+;; @param <param> Specifies the actual values of the parameters.
+;; @return Returns a numeric status code
+;; Sends a SQL query string to the database server for evaluation.
+;; The return value will be an integer representing one of the following enumerated types: PGRES_EMPTY_QUERY,
+;; PGRES_COMMAND_OK, PGRES_TUPLES_OK, PGRES_COPY_OUT, PGRES_COPY_IN,
+;; PGRES_BAD_RESPONSE, PGRES_FATAL_ERROR.
+;;
+;; The numeric status code can be converted to a string using (PgSQL:result-str <status-code>).  
+;; The numeric status code should not be used directly.
+;;
+;; From the libpq documentation:
+;; <blockquote>
+;;     If the result status is PGRES_TUPLES_OK, then the functions described
+;;     below can be used to retrieve the rows returned by the query. Note that
+;;     a SELECT command that happens to retrieve zero rows still shows
+;;     PGRES_TUPLES_OK. PGRES_COMMAND_OK is for commands that can never return
+;;     rows (INSERT, UPDATE, etc.). A response of PGRES_EMPTY_QUERY might
+;;     indicate a bug in the client software. 
+;; </blockquote>
+;;
+
+;; @example
+;;
+;; (PgSQL:query "select $1||$2" "abc" "def")
+;; (PgSQL:fetch-all) ; -> (("abcdef"))
+;;
+;; (PgSQL:query "select $1 + $2" 10 20)
+;; (PgSQL:fetch-all) ; -> (("30"))
+;;
+;; (PgSQL:query "select $1::timestamp + $2::interval" "2012-10-01 00:00:00" "123456 seconds")
+;; (PgSQL:fetch-all) ; -> (("2012-10-02 10:17:36"))
+;;
+;; (PgSQL:query "create table tbl (a integer, b integer)")
+;; (dotimes (i 10) (PgSQL:query "insert into tbl values ($1, $2)" i (* i 2)))
+;; ;    a | b
+;; ;   ---+----
+;; ;    0 |  0
+;; ;    1 |  2
+;; ;    2 |  4
+;; ;    ...
+;; ;    9 | 18
+;;
+;; (PgSQL:query "select * from tbl where a=$1 or a=$2" 2 9)
+;; (PgSQL:fetch-all) ; -> (("2" "4") ("9" "18"))
+
+(define (query sql)
+  (clear-result)
+  (letn ((nParams (length (args)))
+	 (params (map (lambda (argv) (string argv)) (args)))
+	 (ptr-fmt (if (= (& (sys-info 9) 256) 0)
+		      "lu" "Lu"))
+	 (paramValues (if params
+			 (pack (dup ptr-fmt nParams) params)
+			 0)))
+    (setq PG_RESULT
+	  (PQexecParams PG_CONN sql nParams 0 paramValues 0 0 0))
+    (if (not (NULL? PG_RESULT))
+       (PQresultStatus PG_RESULT)
+       PGRES_FATAL_ERROR)) )
+
+;; @syntax (PgSQL:num-rows)
+;; @return Number of rows from last query.
+
+(define (num-rows)
+  (PQntuples PG_RESULT))
+
+;; @syntax (PgSQL:num-fields)
+;; @return Number of columns from last query.
+
+(define (num-fields)
+  (PQnfields PG_RESULT))
+
+;; @syntax (PgSQL:fnumber <str-column>)
+;; @param <str-column> The column name.
+;; @return the column number associated with the given column name. return nil when not found column name.
+
+(define (fnumber name)
+  (let (n (PQfnumber PG_RESULT name))
+    (if (< n 0)
+			nil
+			n)))
+
+;; @syntax (PgSQL:fname <int-column>)
+;; @param <int-column> The integer column number.
+;; @return the column name associated with the given column number. return nil when not found column name.
+
+(define (fname column)
+	(let (s1 (PQfname PG_RESULT (int column)))
+		(if (= s1 0)
+			nil
+			(let (s2 (get-string s1))
+				(if (= s2 "")
+					nil
+					s2)))))
+
+;; @syntax (PgSQL:fetch-value <num-row> <col>)
+;; @param <num-row> row number
+;; @param <col> column number or column name string.
+;; @return A single value
+;; Fetches the single value in the row and column specified.  Used by the
+;; ':fetch-row' and ':fetch-all' functions.  A field containing the 'NULL'
+;; value will return the symbol 'NULL'
+
+(define (fetch-value row column)
+  (if (string? column)
+      (setq column (fnumber column)))
+  (when column
+    (let (s1 (PQgetvalue PG_RESULT row column))
+      (if (NULL? s1)
+	  nil
+	  (let (s2 (get-string s1))
+	    (if (= 1 (PQgetisnull PG_RESULT row column))
+		'NULL s2))))) )
+
+;; @syntax (PgSQL:fetch-row)
+;; @return A list of field elements.
+;; Fetches a row from a previous SQL 'PgSQL:query'  'select' statement.
+;; Subsequent calls fetch row by row from the result table until the
+;; end of the table is reached.
+
+(define (fetch-row)
+  (when (and (> (num-rows) 0) (> (num-rows) PG_ROWX))
+    (let (row (map (fn (x) (fetch-value PG_ROWX x)) (sequence 0 (- (num-fields) 1))))
+      (++ PG_ROWX)
+      row)))
+
+;; @syntax (PgSQL:fetch-all)
+;; @return All rows/fields from the last query, or 'nil'
+;; The whole result set from the query is returned at once as a list of row lists.
+
+(define (fetch-all)
+  (when (> (num-rows) 0)
+    (data-seek 0)
+    (map fetch-row (sequence 0 (- (num-rows) 1)))))
+
+;; @syntax (PgSQL:databases)
+;; @return A list of databases.
+;; Performs the query 'SELECT datname FROM pg_database' which shows all the
+;; database schemas hosted by the connected server.
+
+(define (databases)
+  (when (= "PGRES_TUPLES_OK" (result-status-str (query {SELECT datname FROM pg_database})))
+    (map (fn (x) (x 0)) (fetch-all))))
+
+;; @syntax (PgSQL:tables)
+;; @return A list of tables in the database, or 'nil'
+;; Performs the query 'SELECT table_name FROM information_schema.tables WHERE table_schema = &#039;public&#039;'
+
+(define (tables)
+  (when (= "PGRES_TUPLES_OK" (result-status-str (query {SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'})))
+    (map (fn (x) (x 0)) (fetch-all))))
+
+;; @syntax (PgSQL:fields <str-table>)
+;; @param <str-table> The name of the table.
+;; @return A list of fields in the table, or 'nil'
+;; Unlike the equivalent function in the MySQL module, this function only shows
+;; the names of all the fields in the given table.  It does not show the field
+;; specification, which you would need to recreate the table.
+
+(define (fields str-table)
+  (let (sql (format {SELECT column_name FROM information_schema.columns WHERE table_name = %s} (escape-literal str-table)))
+    (when (= "PGRES_TUPLES_OK" (result-status-str (query sql)))
+      (map (fn (x) (x 0)) (fetch-all)))))
+
+;; @syntax (PgSQL:data-seek <num-offset>)
+;; @param <num-offset> The '0' based offset to position inside the data set.
+;; @return Always 'true'. 
+;; Sets a position in the result set which will be used by the next
+;; 'PgSQL:fetch-row' call. If the offset is out of the allowed range for the
+;; result set a subsequent fetch-row will return 'nil'.
+
+(define (data-seek n) (setq PG_ROWX n) true)
+
+;; @syntax (PgSQL:error)
+;; @return A string containing the query result error message.
+;; If there was no error, this function returns 'nil'.
+
+(define (error)
+  (if (= PG_RESULT nil)
+    (throw-error "Results are not available.")
+    (let (s1 (PQresultErrorMessage PG_RESULT))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:affected-rows)
+;; @return Number of rows affected by the last 'PgSQL:query' operation, or 'nil'
+;; This function will only return a value following the execution of an INSERT,
+;; UPDATE, DELETE, MOVE, FETCH, or COPY statement, or an EXECUTE of a prepared
+;; query that contains an INSERT, UPDATE, or DELETE statement. It will return
+;; 'nil' after all other queries.
+
+(define (affected-rows)
+  (if (= PG_RESULT nil)
+    nil
+		(let (s1 (PQcmdTuples PG_RESULT))
+			(if (NULL? s1)
+				nil
+				(let (s2 (get-string s1))
+					(if (= s2 "")
+						nil
+						(int s2)))))))
+
+;; @syntax (PgSQL:error-conn)
+;; @return error message string
+;; Returns the error message most recently generated by an operation on the connection.
+
+(define (error-conn)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not available.")
+    (let (s1 (PQerrorMessage PG_CONN))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:escape <str-sql>)
+;; @return escaped string
+;; This function only escapes the ' character in <str-sql>, as per the SQL standard.
+;; Depending on whether you
+;; are using binary data or have configured Postgres to allow C escapes
+;; you may need more advanced escaping than this function provides.
+
+(define (escape)
+  (replace {'} (apply string (args)) {''}))
+
+;; @syntax (PgSQL:escape-literal <str>)
+;; @param <str> string to be escaped
+;; @return escaped string
+;; This function escapes a string for use within an SQL command. This is
+;; useful when inserting data values as literal constants in SQL commands. Certain
+;; characters (such as quotes and backslashes) must be escaped to prevent them from
+;; being interpreted specially by the SQL parser. escape-literal performs this
+;; operation.  This function was added in PostgreSQL 9.1 and will throw an error if
+;; you are using an older libpq.
+
+(define (escape-literal x)
+  (if (primitive? PQescapeLiteral)
+		(if (= PG_CONN nil)
+			(throw-error "Must be connected to a database.")
+			(let (pg_raw_result (PQescapeLiteral PG_CONN x (length (get-string x))))
+			(if (= pg_raw_result nil)
+				(throw-error (error-conn))
+				(let (pg_result (get-string pg_raw_result))
+					(PQfreemem pg_raw_result)
+					pg_result))))
+  	(throw-error "PQescapeLiteral not available.")))
+
+;; @syntax (PgSQL:escape-identifier <str>)
+;; @param <str> string to be escaped
+;; @return escaped string
+;; This function escapes a string for use as an SQL identifier, such as a
+;; table, column, or function name. This is useful when a user-supplied identifier
+;; might contain special characters that would otherwise not be interpreted as part
+;; of the identifier by the SQL parser, or when the identifier might contain upper
+;; case characters whose case should be preserved. This function was added in 
+;; PostgreSQL 9.1 and will throw an error if you are using an older libpq.
+
+(define (escape-identifier x)
+  (if (primitive? PQescapeIdentifier)
+		(if (= PG_CONN nil)
+			(throw-error "Must be connected to a database.")
+			(let (pg_raw_result (PQescapeIdentifier PG_CONN x (length (get-string x))))
+			(if (= pg_raw_result nil)
+				(throw-error (error-conn))
+				(let (pg_result (get-string pg_raw_result))
+					(PQfreemem pg_raw_result)
+					pg_result))))
+  	(throw-error "PQescapeIdentifier not available.")))
+
+(define (clear-result)
+  (when (and PG_RESULT (not (NULL? PG_RESULT)))
+    (PQclear PG_RESULT))
+  (setq PG_RESULT nil PG_ROWX 0 PG_COLX 0))
+
+;; @syntax (PgSQL:close-db)
+;; @return Always 'true'.
+;; Closes the database connection and frees associated resources.
+
+(define (close-db)
+  (clear-result)
+  (when (and PG_CONN (not (NULL? PG_CONN)))
+    (PQfinish PG_CONN))
+  (setq PG_CONN nil)
+  true)
+
+;; @syntax (PgSQL:host)
+;; @return connected host name string
+(define (host)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (let (s1 (PQhost PG_CONN))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:port)
+;; @return connected port name string
+(define (port)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (let (s1 (PQport PG_CONN))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:db)
+;; @return connected database name string
+(define (db)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (let (s1 (PQdb PG_CONN))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:options)
+;; @return connected options string
+(define (options)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (let (s1 (PQoptions PG_CONN))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:user)
+;; @return connected user name string
+(define (user)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (let (s1 (PQuser PG_CONN))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2))))))
+
+;; @syntax (PgSQL:result-str <int-status-code>)
+;; @param <int-status-code> An integer query result status code
+;; @return string for the given integer status code
+;; The return value will be one of the following strings "PGRES_EMPTY_QUERY",
+;; "PGRES_COMMAND_OK", "PGRES_TUPLES_OK", "PGRES_COPY_OUT", "PGRES_COPY_IN",
+;; "PGRES_BAD_RESPONSE", "PGRES_FATAL_ERROR".
+
+(define (result-status-str status-code)
+    (let (s1 (PQresStatus status-code))
+      (if (NULL? s1)
+        nil
+        (let (s2 (get-string s1))
+          (if (= s2 "")
+            nil
+            s2)))))
+	
+; verify that the constant PGRES_FATAL_ERROR has the correct integer value
+(if (!= "PGRES_FATAL_ERROR" (result-status-str PGRES_FATAL_ERROR) )
+	(throw-error 
+	  (append "PGRES_FATAL_ERROR defined as " 
+	    (string PGRES_FATAL_ERROR) 
+	    ", but PostgreSQL has that defined as "
+	    (result-status-str PGRES_FATAL_ERROR) )))
+
+;; @syntax (PgSQL:lib-version)
+;; @return libpq version as string (e.g. "9.1.1")
+(define (lib-version)
+  (if (= PQlibVersion nil)
+    "Not Available - Pre 9.0"
+    (begin
+      (regex {(\d+?)(\d\d)(\d\d)$} (string (PQlibVersion)))
+      (append $1 "." $2 "." $3))))
+
+;; @syntax (PgSQL:protocol-version)
+;; @return protocol version "2", or "3" as string, "0" bad connection.
+;; Interrogates the frontend/backend protocol being used.
+(define (protocol-version)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (string (PQprotocolVersion PG_CONN))))
+
+;; @syntax (PgSQL:server-version)
+;; @return backend server version as string (e.g. "9.1.1")
+(define (server-version)
+  (if (= PG_CONN nil)
+    (throw-error "Connection is not established.")
+    (begin
+      (regex {(\d+?)(\d\d)(\d\d)$} (string (PQserverVersion PG_CONN)))
+      (append $1 "." $2 "." $3))))
+	
+(context MAIN)
+
+
+; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;
+; test data base functions
+;
+; Check PgSQL Test Coverage 
+;   Function NOT Tested: PgSQL:clear-result
+;   Percent PgSQL Coverage: 96.9
+
+(define (test-pgsql host user passw dbname)
+  (unless (PgSQL:connect host user passw dbname)
+    (println "PgSQL: couldn't connect 1st try.")
+    (exit 0))
+
+  ; clean up in case the previous test failed
+  (PgSQL:query "DROP TABLE fruits")
+
+  (unless (PgSQL:connectdb (format {host='%s' user='%s' password='%s' dbname='%s'} (PgSQL:escape host) (PgSQL:escape user) (PgSQL:escape passw) (PgSQL:escape dbname)))
+    (println "PgSQL: couldn't connect 2nd try.")
+    (exit 0))
+
+  (if (not (PgSQL:NULL? 0))
+  	(throw-error "NULL not valid."))
+  (if (PgSQL:NULL? 5)
+  	(throw-error "NULL not valid."))
+  
+  (println "\nTest Connection Info Retrieval:")
+  (println "    database: " (PgSQL:db))
+  (println "        user: " (PgSQL:user))
+  (println "        host: " (PgSQL:host))
+  (println "        port: " (PgSQL:port))
+  (println "     options: " (PgSQL:options))
+  (println "   libpq ver: " (PgSQL:lib-version))
+  (println "  server ver: " (PgSQL:server-version))
+  (println "protocol ver: " (PgSQL:protocol-version))
+
+  (println "\nTest List Databases:")
+  (println (join (PgSQL:databases) ", "))
+  
+  (println "\nTest Create Test Data")
+  (PgSQL:query "CREATE TABLE fruits (name varchar, qty int, num serial NOT NULL)")
+  
+  (set 'test_data (list (list "apples" 11) (list "oranges" 22) (list "bananas" 33) (list "pears" 44)))  
+  (println test_data)
+  
+  (dolist (x test_data)
+  	(println "Insert result: " (PgSQL:result-status-str (PgSQL:query "INSERT INTO fruits VALUES ($1, $2)" (nth 0 x) (nth 1 x))) " - " (nth 0 x) ", " (nth 1 x))
+  	(let (myCount (PgSQL:affected-rows))
+			(if (or (nil? myCount) (zero? myCount))
+				(throw-error "Insert did not work."))))
+  
+  (println "\nTest Inserted into fruits:")
+  (setq q "SELECT * FROM fruits ORDER BY name;")
+  (setq q-status (PgSQL:query q))
+  (println "         select query: " q)
+
+  (println "  select query result: " (PgSQL:result-status-str q-status))
+	(if (!= "PGRES_TUPLES_OK" (PgSQL:result-status-str q-status))
+		(throw-error "query result not ok."))
+		
+  (println "        rows returned: " (PgSQL:num-rows))
+  (if (!= 4 (PgSQL:num-rows))
+  	(throw-error "Wrong number of rows." ))
+  	
+  (println "     columns returned: " (PgSQL:num-fields))
+  (if (!= 3 (PgSQL:num-fields))
+  	(throw-error "Wrong number of columns." ))
+
+  (println "  'qty' column number: " (PgSQL:fnumber "qty"))
+	(if (!= 1 (PgSQL:fnumber "qty"))
+		(throw-error "column number not correct."))
+	
+  ; gather column names from result
+  (set 'column_names (let (x -1)
+  										(collect (PgSQL:fname (inc x)) (PgSQL:num-fields))))							
+  (println "column names returned: " (join column_names ", "))
+
+  (dotimes (x (PgSQL:num-rows)) (println "                  row: " (PgSQL:fetch-row)))
+  (println "   table column names: " (join (PgSQL:fields "fruits") ", "))
+
+
+  (println "\nTest List Tables:")
+  (println (join (PgSQL:tables) ", "))
+
+  (println "\nTest fetch-row and data-seek to offset 2:")
+  (PgSQL:query "SELECT * FROM fruits")
+  (PgSQL:data-seek 2)
+  (println (PgSQL:fetch-row))
+  
+  (println "\nTest fetch-all:")
+  (PgSQL:query "SELECT * FROM fruits")
+  (println (PgSQL:fetch-all))
+
+  (println "\nTest Fetching Out of Range Values:")
+  (println "invalid data access (row 5, column 5): " (PgSQL:fetch-value 5 5))
+  
+  ; clean up after DB tests
+  (PgSQL:query "DROP TABLE fruits")
+  
+  (println "\nTest PG Error Retrieval:")
+  (PgSQL:query "SELECT * FROM fruittyyyy")
+  (println "Should show result error on next line.\n" (PgSQL:error))
+  (println "Should show connection error (same as above) on next line.\n" (PgSQL:error-conn))
+  
+  (println "\nTest Text Escaping:")
+  (println "   Check escape literal: " (PgSQL:escape-literal "group's"))
+  (println "Check escape identifier: " (PgSQL:escape-identifier "group's"))
+
+  (println "\nTest Query PG Result Conversion to String:")
+  (println "result 0: " (PgSQL:result-status-str 0))
+  (println "result 1: " (PgSQL:result-status-str 1))
+  (println "result 2: " (PgSQL:result-status-str 2))
+  (println "result 3: " (PgSQL:result-status-str 3))
+  (println "result 4: " (PgSQL:result-status-str 4))
+  (println "result 5: " (PgSQL:result-status-str 5))
+  (println "result 6: " (PgSQL:result-status-str 6))
+  (println "result 7: " (PgSQL:result-status-str 7))
+  (println "result 8: " (PgSQL:result-status-str 8))
+  (println "result 9: " (PgSQL:result-status-str 9))
+
+  (PgSQL:close-db)
+  
+	(println)
+  (println "Tests Completed.")
+	(println)
+)
+
+; eof
diff --git a/modules/postscript.lsp b/modules/postscript.lsp
new file mode 100644
index 0000000..7eb298d
--- /dev/null
+++ b/modules/postscript.lsp
@@ -0,0 +1,1038 @@
+;; @module postscript.lsp
+;; @description Routines for creating postscript files
+;; @version 2.0 - bugfixes and documentation overhaul.
+;; @version 2.1 - doc changes
+;; @version 2.2 - formatting
+;; @version 2.3 - documentation
+;; @version 2.4 - replaced if-not with unless
+;; @version 2.45 - doc corrections
+;; @version 2.5 - eliminated link to postscript-24.tgz
+;; @author Lutz Mueller, July 2006, 2009, 2010, 2012, 2013, 2015
+;;
+;; <h2>Routines for creating postscript files</h2>
+;; To use this module include the following 'load' statement at
+;; the beginning of the program file:
+;; <pre>
+;; (load "/usr/share/newlisp/modules/postscript.lsp")
+;; ; or shorter
+;; (module "postscript.lsp")
+;; </pre>
+;;
+;; See @link http://newlisp.org/index.cgi?Postscript http://newlisp.org/index.cgi?Postscript
+;; for many examples with source code.
+;;
+;; Postscript files can be viewed using: 'open filename.ps' on Mac OS X
+;; or using the Ghostscript program on Unix's or Win32 to convert
+;; to PDF or any graphics file format. Best quality is achieved
+;; on Mac OS X when using the Preview.app viewer for loading the 
+;; postscript files and converting to PDF or bitmapped formats like 
+;; JPEG, PNG, GIF by re-saving.
+;;
+;; If not using Mac OS X look for Ghostscript here:
+;;    @link http://www.ghostscript.com/ www.ghostscript.com and
+;;    here: @link http://www.cs.wisc.edu/~ghost/ www.cs.wisc.edu/~ghost/
+;;
+;; NOTE! on some Mac OS X installations it is necessary to quit out of
+;; the Preview.app completely before viewing a '.ps' file for the first
+;; time. Subsequent views of '.ps' documents are fine.
+;;
+;; On Linux/UNIX systems the following command can be used to convert
+;; a '.ps' file to a '.pdf' file:
+;; <pre>
+;;   gs -sDEVICE=pdfwrite -dBATCH -sOutputFile=aFile.pdf -r300 aFile.ps
+;; </pre>
+;; Most functions work like in <turtle graphics> relative to the
+;; current position of an imaginary drawing pen with an
+;; orientation of 0 to 360 degree starting streight up: 0 and
+;; moving clockwise right 90, down 180, left 270, up and 360 degrees.
+;; Other functions work on absolute X,Y coordinates.
+;;
+;; The coordinate system starts on the bottom left with 0,0 and
+;; extends on a 8 1/2 x 11 inch letter page to 'x': 612, 'y': 792,
+;; 72 points for each inch. The functions 'ps:transpose' and 'ps:scale'
+;; can be used to move the origin point '<x=0, y=0>' or scale from points to
+;; other measurements.
+;;
+;; Return value from 'ps:xxx' functions are not used and not mentioned in
+;; the documentation.
+;;
+;; <h2>Summary of functions</h2>
+;; <h3>Turtle coordinate positioning and turning</h3>
+;; <pre>
+;; ps:goto  - move turtle to position x, y
+;; ps:move  - move turtle a distance s forward from the current position
+;; ps:turn  - turn the turtle degress dg left (negative) or right (positive)
+;; ps:angle - set the turtle orientation to dg degrees
+;; </pre>
+;; <h3>Line drawing</h3>
+;; <pre>
+;; ps:draw   - draw distance s forward from current position
+;; ps:drawto - draw to the absolute position x,y from the current position
+;; ps:line   - draw a multipart line consisting of line and bezier curve segments
+;; ps:bezier - draw a Bezier curve 
+;; </pre>
+;; <h3>Closed shapes, filling and clipping</h3>
+;; <pre>
+;; ps:rectangle - draw a rectangle
+;; ps:polygon   - draw a polygon with radius rad and n number of sides
+;; ps:circle    - draw a circle
+;; ps:ellipse   - draw an open or closed ellipse with x-rad and y-rad radius
+;; ps:pie       - draw a pie piece with radius rad and width
+;; ps:petal     - draw a petal shape from Bezier curves
+;; ps:shape     - draw a shape defined by a list of line and Bezier segments
+;; ps:clip      - define a clipping path using line and Bezier segments
+;; </pre>
+;; <h3>Text output and clipping</h3>
+;; <pre>
+;; ps:text           - draw a solid text string
+;; ps:textoutline    - draw text in outline shape
+;; ps:textarc        - draw text around an arc
+;; ps:textarcoutline - draw text in outline shape around an arc
+;; ps:textclip       - use a textoutline as clipping path
+;; </pre>
+;; <h3>Global settings</h3>
+;; <pre>
+;; ps:translate  - move coordinate origin
+;; ps:scale      - scale postscript output
+;; ps:rotate     - rotate postscript output
+;; ps:gsave      - save current graphics state (X, Y, orientation, translation, scale, rotation)
+;; ps:grestore   - restore current graphics state
+;; ps:font       - set font family and size
+;; ps:line-witdh - set line width in points
+;; ps:line-cap   - set line termination shape
+;; ps:line-join  - set line join mode
+;; ps:line-color - set line color
+;; ps:fill-color - set fill color
+;; </pre>
+;; <h3>Rendering and output</h3>
+;; <pre>
+;; ps:render     - render output to a monitor
+;; ps:save       - deprecated, use ps:render with file-name instead
+;; </pre>
+
+;; @syntax (ps:angle <num-dg>) 
+;; @param <num-dg> Angle degrees from 0 to 360.
+;; <br>
+;; Set the turtle angle to <num-dg> degrees.
+;; Upwards is 0, right 90, downwards 180 and left 270 degrees.
+;; The turtle position is saved on the graphics state stack when using 
+;; '(ps:gsave)'.
+
+;; @syntax (ps:bezier <num-x1> <num-y1> <num-x2> <num-y2> <num-x3> <num-y3>) 
+;; @param  <num-x1,num-y1> Bezier coordinates of <p1> relative to <p0> = 0,0
+;; @param  <num-x2,num-y2> Bezier coordinates of <p2> relative to <p0> = 0,0
+;; @param  <num-x3,num-y3> Bezier coordinates of <p3> relative to <p0> = 0,0
+;; <br>
+;; Draw a Bezier curve.
+;; The Bezier curve starts at point <p0> which is the current
+;; turtle position and stops at point <p3> which is at offset
+;; <num-x3> and <num-y3> relative to starting point. The turtle orientation
+;; after the drawing the Bezier curve is perpendicular
+;; to the Bezier curve baseline <p0> to <p3> and the position is <p3>.
+
+;; @syntax (ps:circle <num-rad> [<bool-fill>])
+;; @param <num-rad> Radius of the circle.
+;; @param <bool-fill> Optional fill flag.
+;; <br>
+;; Draw a circle with radius <num-rad>. The optional <num-fill> flag 
+;; with either 'true' or 'nil' (default) indicates if the circle
+;; is filled with the fill color specified by 'ps:fill-color'.
+;; The circle is drawn around the current turtle position.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (ps:clip <list-of-num-lists>) 
+;; @param <list-of-num-lists> A list of turtle movements and/or Bezier curves.
+;; Define a clipping path using turtle movements (<degree> <distance>) and
+;; <br>
+;; Bezier curves (<x1> <y1> <x2> <y2> <x3> <y3>) starting from the 
+;; last turtle coordinates <x0>, <y0> and finishing at <x3>, <y3>. 
+;; All Bezier coordinates are relative to the previous turtle position and
+;; orientation.
+;;
+;; Before redefining the clipping area '(ps:gsave)' should
+;; be used to save the old graphics state parameters, after
+;; clipping and drawing in the clipped area the graphics
+;; state should be restored using '(ps:grestore)'.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (ps:draw <num-s>) 
+;; @param <num-s> Distance to draw.
+;; <br>
+;; Draw going forward distance <num-s>. Moves the turtle forward by 
+;; the amount of points specified in <num-s> and draws with the current 
+;; line color set by 'ps:line-color'.
+;;
+
+;; @syntax (ps:drawto <x> <y>) 
+;; @param <x> The x coordinate to draw to.
+;; @param <y> The y coordinate to draw to.
+;; <br>
+;; Draw a line to point <x>, <y>. Moves the turtle to point 
+;; <x>, <y> like '(ps:goto x y)', but also draws a line from 
+;; the old to the new position. The turtle position is changed to the
+;; new point <x>, <y> and the orientation is changed to the orientaion of 
+;; the line drawn.
+
+;; @syntax (ps:ellipse <num-x-rad> <num-y-rad> <num-start> <num-end> [<bool-fill>]) 
+;; @param <num-x-rad> The x axis radius.
+;; @param <num-y-rad> The y axis radius.
+;; @param <num-start> The start angle in 0 to 360 degrees.
+;; @param <end-num> The end angle in 0 to 360 degrees.
+;; <br>
+;; Draw an ellipse with optional <bool-fill> either 'true' or 'nil' (default).
+;; The ellipse is drawn around the current turtle position
+;; with the Y axis oriented like the turtle.
+;; For <num-start>, <num-end> set to 0, 360 an ellipse is drawn.
+;; For a partial radius the opening is closed by a line
+;; resulting in segment shape, i.e. -90, 90  would result
+;; in a half circle from the left to the right of the turtle.
+;; When <num-x-rad> and <num-y-rad> are of equal size a full circle
+;; can be drawn. The turtle position or orientation is not changed.
+
+;; @syntax (ps:fill-color <float-R> <float-G> <float-B>) 
+;; @param <float-R> The red color value.
+;; @param <float-G> The green color value.
+;; @param <float-B> The blue color value.
+;; <br>
+;; Set color for shape filling.
+;; Color values assume the following value:
+;; <pre>
+;;    R - value for red 0.0 to 1.0
+;;    B - value for green 0.0 to 1.0
+;;    G - value for blue 0.0 to 1.0
+;; </pre>
+;;
+;; @syntax (ps:fill-color <str-hex>)
+;; @param <str-hex> A hex string specifying the line color.
+;; <br>
+;; In an alternative syntax color values can be specified in a
+;; hex string:
+;;
+;; <str-hex> is a hex string constant '"000000"' to '"FFFFFF"'
+;; Colors are specified as usual in HTML coding.
+;; Each two hex digits define a color: 'rrggbb'.  
+
+;; @syntax (ps:font <str-name> <num-size>) 
+;; @param <str-name> The font name.
+;; @param <num-size> The size of the font in points.
+;; <br>
+;; The current font is set for all subsequent text operations.
+;; Depending on the version of the Postsrcipt viewer or device
+;; installed different fonts are available.
+  
+
+;; @syntax (ps:goto <num-x> <num-y>)
+;; @param <num-x> The new x coordinate.
+;; @param <num-y> The new y coordinate.
+;; <br>
+;; Moves to position <num-x>, <num-y>. On a US letter page of 612 by 792 
+;; point positions are defined with 72 points per inch. The turtle position
+;; is saved on the graphics state stack when using '(ps:gsave)'.
+
+;; @syntax (ps:grestore)
+;; <br>
+;; Restores the graphics state from the stack.
+
+;; @syntax (ps:gsave)
+;; <br>
+;; Saves the current graphics state. The function pushes the 
+;; current graphics state on a special stack, from where it
+;; can be resored using '(ps:grestore)'. States saved are:
+;; The turtle position X, Y and  orientation and transformation
+;; scaling and rotation factors.
+
+;; @syntax (ps:line <list-of-lists>) 
+;; @param <list-of-lists> A list of turtle movements or Bezier curves.
+;; <br>
+;; Draw a multipart line.  <lists> are turtle movements (<num-dg> <num-s>),
+;; or Bezier curves (<x1> <y1> <x2> <y2> <x3> <y3>) starting
+;; from the last turtle coordinates <x0>, <y0> and
+;; finishing at <x3>, <y3>. All Bezier coordinates are
+;; relative to the previous turtle position and
+;; orientation.
+;;
+;; The turtle position and orientation are changed after
+;; drawing the line.
+
+;; @syntax (ps:line-cap <num-mode | str-mode>) 
+;; @param <mode> The line termination shape mode as a string or number
+;; <br>
+;; Sets the line termination shape as either a number or string:
+;; <pre>
+;;    0 or "butt"
+;;    1 or "round"
+;;    2 or "square"
+;; </pre>
+
+;; @syntax (ps:line-color <float-R> <float-G> <float-B>) 
+;; @param <float-R> The red color value.
+;; @param <float-G> The green color value.
+;; @param <float-B> The blue color value.
+;; <br>
+;; Set color for line drawing.
+;; Color values assume the following value:
+;; <pre>
+;;    R - value for red 0.0 to 1.0
+;;    G - value for green 0.0 to 1.0
+;;    B - value for blue 0.0 to 1.0
+;; </pre>
+;;
+;; @syntax (ps:line-color <str-hex>)
+;; @param <str-hex> A hex string specifying the line color.
+;; <br>
+;; In an alternative syntax color values can be specified in a
+;; hex string:
+;;
+;; <str-hex> is a hex string constant '"000000"' to '"FFFFFF"'
+;; Colors are specified as usual in HTML coding.
+;; Each to two hex digits define a color: 'rrggbb'.  
+
+;; @syntax (ps:line-join <num-mode> | <str-mod>)
+;; @param <mode> The line join mode.
+;; <br>
+;; Sets the line join mode as either a number or string:
+;; <pre>
+;;    0 or "miter"
+;;    1 or "round"
+;;    2 or "bevel"
+;; </pre>
+
+;; @syntax (ps:line-width <points>)
+;; @param <points> The line width in points.
+;; <br>
+;; Sets the line width in points for line drawing and the
+;; outlines drawn by shapes and text outlines.
+
+;; @syntax (ps:move <num-s>) 
+;; @param <num-s> The distance to move the pen.
+;; <br>
+;; Move the turtle forward distance <s> without drawing.
+
+;; @syntax (ps:petal <num-width> <num-height> [<bool-fill>]) 
+;; @param <num-width> The 'x1' coordinate of the  underlying Bezier curve <p0> to <p1> <p2> <p3>.
+;; @param <num-height> The 'y1' coordinate of the  underlying Bezier curve <p0> to <p1> <p2> <p3>.
+;; @param <bool-fill> An optional fill flag for color fill.
+;; <br>
+;; Draws a petal using a Bezier curve with optional <num-fill> either 'true' or 'nil' (default).
+;; The <num-height> and <num-width> parameters are relative to to the current position.
+;; The petal is drawn with the tip at the current turtle
+;; position and oriented in the direction of the turtle.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (ps:pie <num-rad> <num-width> [<bool-fill>])
+;; @param <num-rad> The radius of the pie.
+;; @param <num-width> The width of the pie slice as an angle.
+;; @param <bool-fill> An optional fill flag for color fill, 'true' or 'nil' (default).
+;; <br>
+;; Draw a pie slice with optional <bool-fill> either 'true' or 'nil' (default).
+;; The left edge of the pie is in turtle orientation.
+;; The width angle spreads clockwise. The pie is drawn around the current
+;; turtle position. The turtle position or orientation is not changed.
+
+
+;; @syntax (ps:polygon <num-rad> <num-n> [<bool-fill>])
+;; @param <num-rad> Radius.
+;; @param <num-n> Number of sides.
+;; @param <fill> Optional fill flag.
+;; <br>
+;; Draw a polygon with radius <num-rad> and <num-n> sides.
+;; <num-fill> is 'true' or 'nil' (default) for optional color fill
+;; The polygon is drawn around the current turtle position.
+;; The turtle position or orientation is not changed.
+
+;; @syntax (ps:rectangle <num-width> <num-height> [<bool-fill>])
+;; @param <num-width> The width of the rectangle.
+;; @param <num-height> The height of the rectangle.
+;; @param <bool-fill> An optional flag to draw a filled rectangle.
+;; <br>
+;; A rectangle is drawn at the current turtle position.
+;; The width of the rectangle will be perpendicular to
+;; the turtle orientation. If the turtle never turned or
+;; the turtle angle never was set then the width of the
+;; rectangle will lie horizontally.
+;;
+;; The position or orientation of the turtle will not change.
+
+;; @syntax (ps:render [<filename>]) 
+;; <br>
+;; Without the filename parameter, <tt>render</tt> creates a file <tt>noname.ps</tt>
+;; and on Mac OS X the file is shown on the monitor using the Mac OS X Preview
+;; application. 
+;;
+;; Specify the <filename> parameter
+;; to save the postscript file and convert and view
+;; it using ghostscript from @link http://www.ghostscript.com/ www.ghostscript.com/
+;; and @link http://www.cs.wisc.edu/~ghost/ www.cs.wisc.edu/~ghost .
+;;
+
+;; @syntax (ps:rotate <num-deg>) 
+;; @param <num-deg> The degrees of rotation: -360 to 0 to 360.
+;; <br>
+;; Rotate the coordinate space. 
+;; The coordinate space is rotated to the right for
+;; positive angles and to the left for negative angles.
+;; The current rotation angle is 0 by default.
+;; The rotation angle is part of the graphics state saved by
+;; the 'ps:gsave' function and restored by 'ps:grestore'.
+
+;; @syntax (ps:save <str-filename>) 
+;; @param <str-filename> The filename. 
+;; <br>
+;; Save to <str-filename>. This function is deprecated use 'ps:render'
+;; instead.
+
+;; @syntax (ps:scale <num-x> <num-y>) 
+;; @param <num-x> The new x scale factor.
+;; @param <num-y> The new y scale factor.
+;; <br>
+;; Scale the coordinate space.
+;; Scaling factors are 1.0 by default and compress for
+;; factors less 1.0 or expand for factors bigger than 1.0.
+;; With a scaling factor for x = 2.0 each point position
+;; specified would cover the double of horizontal distance
+;; on the page. Previous scaling factors can be saved on the graphics
+;; state stack using the function 'ps:gsave' and restored using 'ps:grestore'.
+
+;; @syntax (ps:shape <list-of-num-lists> [<bool-fill>])
+;; @param <list-of-num-lists> A list of turtle movements and/or Bezier curves.
+;; @param <bool-fill> An optional fill flag for color fill.
+;; <br>
+;; Draws a shape with optional <bool-fill> or eiher 'true' or 'nil' (default).
+;; <num-lists> is either a turtle movement  (<degree> <distance>) or a Bezier curve 
+;; (<x1> <y1> <x2> <y2> <x3> <y3>) starting from the last turtle coordinates 
+;; <x0>, <y0> and finishing at <x3>, <y3>. All Bezier coordinates
+;; are relative to the previous turtle position and orientation
+;; The turtle position or orientation is not changed.
+
+;; @syntax (ps:text <str-text>)
+;; @param <str-text> The text to draw.
+;; <br>
+;; Draws text. <tt>(...)</tt> parenthesis in text should be escaped with
+;; double <tt>\\</tt> characters as in in <tt>\\(</tt> or <tt>\\)</tt>, when limiting the string
+;; with double quotes <tt>"</tt>. When limiting the string with <tt>{,}</tt> braces
+;; a single <tt>\</tt> character is enough as in <tt>\(</tt> and <tt>\)</tt>.
+;; Before drawing, a font can be specified, the default font after loading 
+;; the 'postscript.lsp' modules is Helvetica 12 points and using
+;; the current 'ps:line-color' for drawing.
+;;
+;; The turtle position is changed to the baseline after the last character.
+;; The turtle orientation stays the same.
+
+;; @syntax (ps:textarc <str-text> <num-rad>)
+;; @param <str-text> The text to draw. 
+;; @param <num-rad> The radius of imaginary circle path for text.
+;; <br>
+;; Draw text around a circle.
+;; The text is drawn out side of an imaginary circle starting at 
+;; turtle position and orientation and drawing at the current tangent.
+;; For a positive radius text goes outside
+;; the circle and clockwise. For a negative radius text goes inside the
+;; circle and counter lock wise. The turtle position and orientation
+;; move along the radius.
+
+;; @syntax (ps:textarcoutline <str-text> <num-rad> [<bool-fill>]) 
+;; @param <str-text> The text to draw.
+;; @param <num-rad> The radius of imaginary circle path for text.
+;; @param <bool-fill> An optional fill flag for color fill.
+;; <br>
+;; Draw text around a circle.
+;; Same as 'ps:textarc' but the text is drawn as ane outline
+;; and can be filled with ps:fill-color when specifying the optional
+;; fill flag. The turtle position and orientation move along the radius.
+
+;; @syntax (ps:textoutline <str-text> [<bool-fill>])
+;; @param <str-text> The text to draw. 
+;; @param <bool-fill> An optional fill flag for color fill.
+;; <br>
+;; Draw a text outline with optional color <bool-fill> specified by
+;; either 'true' or 'nil' (default).
+;; Before drawing a font can be specified
+;; the default font after loading 'postscript.lsp' is
+;; Helvetica 12 points, the text is drawn using the current
+;; line color.
+;;
+;; The turtle position is changed to the baseline after the last character.
+;; The turtle orientation stays the same.
+
+;; @syntax (ps:textclip <str-text>)
+;; @param <str-text> The text used as a clipping shape.
+;; <br>
+;; A text outline is used as a clipping path.
+;; Before redefining the clipping area '(ps:gsave)' should
+;; be used to save the old graphics state parameters, after
+;; clipping and drawing in the clipped area the graphics
+;; state should be restored using '(ps:grestore)'.
+;; The turtle moves with the text shape clipped.
+
+;; @syntax (ps:translate <num-dx> <num-dy>) 
+;; @syntax (ps:translate) 
+;; @param <num-dx> Moves the 'x' origin  by 'dx'.
+;; @param <num-y> Move the 'y' origin by 'dy'.
+;; <br>
+;; Move the coordinate origin.
+;; By default the origin 0,0 is in the bottom left corner
+;; of the page. The <num-dx> and <num-dy> values extend to the right and top. 
+;; When no <num-x>, <num-y> values are specified the coordinate origin
+;; is moved to the current position of the turtle. Previous translation
+;; offsets can be saved on the graphics state stack using the
+;; function 'ps:gsave' and restored using 'ps:grestore'.
+
+;; @syntax (ps:turn <num-dg>)
+;; @param <num-dg>  The degrees to turn: -360 to 0 to 360.
+;; <br>
+;; Turn the turtle pen by <num-dg> degrees. The degrees are specified in angles
+;; from 0 to 360. For turning clockwise specifiy positive values.
+;; Negative degrees turn the turtle pen counter clockwise. The turtle
+;; position is aved on the graphics state stack when using '(ps:gsave)'.
+
+(context 'ps)
+
+(set 'prolog [text]%!PS-Adobe-2.0
+%%Creator: newLISP
+
+%% ---------- SETUP ----------
+
+/orient 0 def
+/xpos 0 def
+/ypos 0 def
+/pi 3.141592654 def
+
+/fillcolor {0.8 0.8 0.8} def
+/Helvetica findfont 12 scalefont setfont
+
+/turtlestack [0 0 0] def
+
+/pushturtle
+	{	
+	turtlestack length /len exch def 
+	turtlestack aload pop 
+	xpos ypos orient len 3 add array astore
+	/turtlestack exch def
+	} def
+
+/popturtle
+	{
+	turtlestack length /len exch def
+	len 3 gt {
+		turtlestack aload pop
+		/orient exch def
+		/ypos exch def
+		/xpos exch def
+		len 3 sub array astore
+		/turtlestack exch def
+		} if
+	} def
+
+%% ---------- NAVIGATION ----------
+
+% x y -
+/goto
+  {
+  /ypos exch def
+  /xpos exch def
+  xpos ypos moveto
+  } def
+
+% points -
+/move
+  {
+  /len exch def
+  /xpos xpos orient sin len mul add def
+  /ypos ypos orient cos len mul add def
+  xpos ypos moveto
+  } def
+  
+% degree -
+/turn
+  {
+  /orient exch orient add def
+  } def
+  
+% degree -
+/angle
+  {
+  /orient exch def
+  } def
+  
+%% ---------- LINE DRAWING ----------
+
+% turtle position is changed
+  
+% points -
+/draw
+  {
+  /len exch def
+  newpath
+  xpos ypos moveto
+  /xpos xpos orient sin len mul add def
+  /ypos ypos orient cos len mul add def
+  xpos ypos lineto stroke
+  } def  
+
+% points -
+/drawtolen
+  {
+  /len exch def
+  /xpos xpos orient sin len mul add def
+  /ypos ypos orient cos len mul add def
+  xpos ypos lineto
+  } def  
+  
+% x y
+/drawto
+  {
+  /newy exch def
+  /newx exch def
+  newpath
+  xpos ypos moveto
+  newx newy lineto
+  stroke
+  newy ypos sub newx xpos sub atan neg 90 add /orient exch def
+  /xpos newx def
+  /ypos newy def
+  } def
+  
+% x1 y1 x2 y2 x3 y3
+/bezier
+  {
+  newpath
+  curve
+  stroke
+  } def
+
+/curve
+  {
+  /y3 exch def
+  /x3 exch def
+  /y2 exch def
+  /x2 exch def
+  /y1 exch def
+  /x1 exch def
+  matrix currentmatrix
+  x1 y1 x2 y2 x3 y3
+  xpos ypos translate
+  orient neg rotate
+  0 0 moveto
+  rcurveto
+  setmatrix
+  y3 x3 atan neg /angleinc exch def
+  /len x3 angleinc cos div def
+  /orient orient angleinc add def
+  /xpos xpos orient 90 add sin len mul add def
+  /ypos ypos orient 90 add cos len mul add def
+  } def
+
+% save turtle position and orientation
+
+/turtlesave
+  {
+  /xpossave xpos def
+  /ypossave ypos def
+  /orientsave orient def
+  } def
+  
+% restore turtle position and orientation
+
+/turtlerestore
+  {
+  /xpos xpossave def
+  /ypos ypossave def
+  /orient orientsave def
+  xpos ypos moveto
+  } def
+
+% x1 y1 x2 y2 -
+/fromto
+  {
+  /ypos exch def
+  /xpos exch def
+  newpath
+  moveto
+  xpos ypos lineto
+  stroke
+  } def
+
+%% ---------- SHAPES ----------
+
+% shapes are closed and do not change the turtle position
+
+% radius sides fillflag -
+/polygon
+  {
+  /fillflag exch def
+  360 exch div /orientinc exch def
+  /radius exch def
+  gsave
+  newpath
+  xpos ypos translate
+  orient neg rotate
+  % 0 sin radius mul
+  % 0 cos radius mul moveto
+  0 radius moveto
+  0 orientinc 360
+   {
+   dup
+   sin radius mul exch
+   cos radius mul
+   lineto
+   } for
+  closepath
+  fillflag {fillshape} if
+  stroke
+  grestore
+  } def
+  
+% radius fillflag -
+/circle
+  {
+  /fillflag exch def
+  /radius exch def
+  newpath
+  xpos ypos radius 0 360 arc
+  fillflag {fillshape} if
+  stroke
+  } def
+  
+  
+% radius width fillflag
+/pie
+  {
+  /fillflag exch def
+  /width exch def
+  90 orient sub width sub /start exch def
+  start width add /end exch def
+  /radius exch def
+  newpath
+  xpos ypos moveto
+  xpos ypos radius start end arc
+  fillflag {fillshape} if
+  closepath
+  stroke
+  } def
+  
+% width height fill
+/petal
+  {
+  /fillflag exch def
+  /y exch def
+  /x exch def
+  gsave
+  xpos ypos translate
+  orient neg rotate
+  newpath
+  0 0 moveto
+  x neg y x y 0 0 
+  rcurveto
+  fillflag {fillshape} if
+  closepath
+  stroke
+  grestore
+  } def
+  
+% xradius yradius start end flag -
+/ellipse
+  {
+  /fillflag exch def
+  % swap start/end and x/y
+  neg /startangle exch def
+  neg /endangle exch def
+  /xrad exch def
+  /yrad exch def
+ 
+  gsave
+  xpos ypos translate
+  orient 90 sub neg rotate
+  newpath
+  xrad yrad scale
+  0 0 1 startangle endangle arc
+  fillflag {fillshape} if
+  1 xrad div 1 yrad div scale
+  closepath
+  stroke
+  grestore
+  } def
+
+/fillshape
+  {
+  gsave
+  fillcolor setrgbcolor
+  fill 
+  grestore
+  } def
+   
+%% ---------- text ----------
+
+/text
+  {
+  /str exch def
+  gsave
+  xpos ypos translate
+  newpath
+  0 0 moveto
+  orient 89.9999 sub neg rotate
+  str show
+  grestore
+  str stringwidth pop move
+  } def
+  
+/textoutline
+  {
+  /fillflag exch def
+  /str exch def
+  gsave
+  xpos ypos translate
+  newpath
+  0 0 moveto
+  orient 89.9999 sub neg rotate
+  str true charpath
+  fillflag {fillshape} if
+  stroke
+  grestore
+  str stringwidth pop move
+  } def
+  
+/textclip
+  {
+  /str exch def
+  matrix currentmatrix
+  xpos ypos translate
+  newpath
+  0 0 moveto
+  orient 89.9999 sub neg rotate
+  str true charpath
+  clip
+  setmatrix
+  } def
+
+/textarc
+  {
+  /str exch def
+  2 mul pi mul /circum exch def
+  
+  str stringwidth pop /len exch def
+  circum len div 360 exch div turn
+  str text
+  } def
+  
+/textarcoutline
+  {
+  /fillflag exch def
+  /str exch def
+  2 mul pi mul /circum exch def
+  
+  str stringwidth pop /len exch def
+  circum len div 360 exch div turn
+  str fillflag textoutline
+  } def
+  
+% --------------------------
+[/text])
+
+; ---------- setup ---------- 
+
+(set 'buffer "")
+(set 'line-feed (if (> (& 0xF (sys-info -1)) 5) "\r\n" "\n"))
+
+; ---------- USER FUNCTIONS ----------
+
+; ---------- output pure postscript ---------- 
+
+(define (ps:ps str) (write-line buffer str) true)
+	
+; navigation - changes position or orient of the turtle
+	
+(define (goto x y)
+	(ps (format "%g %g goto" x y)))
+	
+(define (turn deg)
+	(ps (format "%g turn" deg)))
+	
+(define (move dist)
+	(ps (format "%g move" dist)))
+	
+(define (angle deg)
+	(ps (format "%g angle" deg)))
+	
+; line graphics changes position and/or orient of the turtle
+	
+(define (draw dist)
+	(ps (format "%g draw" dist)))
+	
+(define (drawto x y)
+	(ps (format "%g %g drawto" x y)))
+	
+(define (bezier x1 y1 x2 y2 x3 y3)
+	(if (zero? x3) (set 'x3 1e-7))
+	(ps (format "%g %g %g %g %g %g bezier" x1 y1 x2 y2 x3 y3)))
+	
+(define (line lst)
+	(let (rec nil)
+		(ps "% new shape")
+		(ps "newpath")
+		(ps "xpos ypos moveto")
+		(while (set 'rec (pop lst))
+			(if (= (length rec) 6)
+				(ps (format "%g %g %g %g %g %g curve"
+						(rec 0) (rec 1) (rec 2)
+						(rec 3) (rec 4) (rec 5)))
+				(begin
+					(ps (format "%g turn" (rec 0)))
+					(ps (format "%g drawtolen" (rec 1))))))
+		(ps "stroke")))
+	
+; shapes do not change the position or orient of the turtle
+; which stays in the curcle center of the shape
+
+(define (polygon radius sides flag)
+	(set 'flag (if flag "true" "false"))
+	(ps (format "%g %g %s polygon" radius sides flag)))
+
+(define (rectangle width height flag)
+	(shape (list (list 0 height) (list 90 width) (list 90 height) (list 90 width)) flag))
+
+(define (circle radius flag)
+	(set 'flag (if flag "true" "false"))
+	(ps (format "%g %s circle" radius flag)))
+	
+(define (ellipse xradius yradius start end flag)
+	(set 'flag (if flag "true" "false"))
+	(ps (format "%g %g %g %g %s ellipse" xradius yradius start end flag)))
+	
+(define (pie radius width flag)
+	(set 'flag (if flag "true" "false"))
+	(ps (format "%g %g %s pie" radius width flag)))
+	
+(define (petal width height flag)
+	(set 'flag (if flag "true" "false"))
+	(ps (format "%g %g %s petal" width height flag)))
+	
+(define (shape lst flag)
+	(let (rec nil)
+		(ps "% new shape")
+		(ps "turtlesave")
+		(ps "newpath")
+		(ps "xpos ypos moveto")
+		(while (set 'rec (pop lst))
+			(if (= (length rec) 6)
+				(ps (format "%g %g %g %g %g %g curve"
+						(rec 0) (rec 1) (rec 2)
+						(rec 3) (rec 4) (rec 5)))
+				(begin
+					(ps (format "%g turn" (rec 0)))
+					(ps (format "%g drawtolen" (rec 1))))))
+		(ps "closepath")
+		(if flag (ps "fillshape")) 
+		(ps "stroke")
+		(ps "turtlerestore")))
+
+(define (clip lst)
+	(let (rec nil)
+		(ps "% new clipping shape")
+		(ps "turtlesave")
+		(ps "newpath")
+		(ps "xpos ypos moveto")
+		(while (set 'rec (pop lst))
+			(if (= (length rec) 6)
+				(ps (format "%g %g %g %g %g %g curve"
+						(rec 0) (rec 1) (rec 2)
+						(rec 3) (rec 4) (rec 5)))
+				(begin
+					(ps (format "%g turn" (rec 0)))
+					(ps (format "%g drawtolen" (rec 1))))))
+		(ps "closepath")
+		(ps "clip"))
+		(ps "turtlerestore"))
+		
+; text output 
+
+(define (text str)
+	(ps (format "(%s) text" str)))
+	
+(define (textoutline str flag)
+	(set 'flag (if flag "true" "false"))
+	(ps (format "(%s) %s textoutline" str flag)))
+	
+(define (textclip str)
+	(ps (format "(%s) textclip" str)))
+		
+(define (textarc str radius)
+	(dotimes (i (length str))
+		(ps (format "%g (%s) textarc" radius (str i)))))
+	
+(define (textarcoutline str radius flag)
+	(set 'flag (if flag "true" "false"))
+	(dotimes (i (length str))
+		(ps (format "%g (%s) %s textarcoutline" radius (str i) flag))))
+	
+; rendering and saving
+
+(define (render filename)
+	(let (page (append prolog buffer "showpage" line-feed))
+		(if filename
+			(write-file filename page)
+			(begin
+				(write-file "/tmp/noname.ps" page)
+				(exec "open /tmp/noname.ps")))))
+
+(define ps:save render)
+	
+(define (clear)
+	(set 'buffer ""))
+
+; replaced by ps:render with filename	
+(define (ps:save file-name)
+	(write-file file-name (append prolog buffer "showpage" line-feed)))
+	
+; global parameters 
+
+(define (translate x y)
+	(if (and x y)
+		(ps (format "%g %g translate" x y))
+		(ps "xpos ypos translate 0 0 moveto")))
+	
+(define (scale x y)
+	(ps (format "%g %g scale" x y)))
+	
+(define (ps:rotate deg)
+	(ps (format "%g rotate" deg)))
+
+(define (gsave)
+	(ps "pushturtle gsave"))
+	
+(define (grestore)
+	(ps "grestore popturtle"))
+	
+(define (line-width points)
+	(ps (format "%g setlinewidth" points)))
+	
+(define (line-cap mode)
+	(if (string? mode) (set 'mode (find mode '("butt" "round" "square"))))
+	(unless mode (throw-error "Not a valid line-cap mode"))
+	(ps (format "%g setlinecap" mode)))
+
+(define (line-join mode)
+	(if (string? mode) (set 'mode (find mode '("miter" "round" "bevel"))))
+	(ps (format "%g setlinejoin" mode)))
+	
+(define (line-color red green blue)
+    (if (string? red)
+    	(let (color red)
+    	  (set 'red (div (int (append "0x" (0 2 color)) 0 16) 255))
+    	  (set 'green (div (int (append "0x" (2 2 color)) 0) 255))
+    	  (set 'blue (div (int (append "0x" (4 2 color)) 0) 255))))
+	(ps (format "%g %g %g setrgbcolor" red green blue)))
+	
+(define (fill-color red green blue)
+    (if (string? red)
+    	(let (color red)
+    	  (set 'red (div (int (append "0x" (0 2 color)) 0 16) 255))
+    	  (set 'green (div (int (append "0x" (2 2 color)) 0) 255))
+    	  (set 'blue (div (int (append "0x" (4 2 color)) 0) 255))))
+	(ps (format "/fillcolor {%g %g %g} def" red green blue)))
+	
+(define (font fname size)
+	(ps (format "/%s findfont %g scalefont setfont" fname size)))
+	
+(context MAIN)
+
+; eof ;
diff --git a/modules/smtp.lsp b/modules/smtp.lsp
new file mode 100644
index 0000000..70d6204
--- /dev/null
+++ b/modules/smtp.lsp
@@ -0,0 +1,125 @@
+;; @module smtp.lsp 
+;; @description Send mail using SMTP protocol
+;; @version 2.0 - March 2008, Cormullion added AUTH PLAIN authentication 
+;; @version 2.1 - changes for 10.0
+;; @version 2.2 - doc changes
+;; @version 2.3 - fix in mail-send-body, thanks to Alessandro
+;; @version 2.31 - removed spurious apostrophe
+;; @author Lutz Mueller 2001-2010, Cormullion 2008
+;; <h2>Routines for sending mail</h2> 
+;; This module implements routines to communicate with a SMTP mail server 
+;; for sending email. To use this module include the following 'load' statement 
+;; at the beginning of the program file: 
+;; <pre> 
+;; (load "/usr/share/newlisp/modules/smtp.lsp") 
+;; ; or shorter
+;; (module "smtp.lsp")
+;; </pre> 
+;; To see debugging information: <br><br>
+;; <tt>(set 'debug-flag true)</tt>
+
+(context 'SMTP) 
+
+(set 'debug-flag nil) 
+
+;; @syntax (SMTP:send-mail <str-from> <str-to> <str-subject> <str-message> <str-server>i [<str-usr> str-pass>]])
+;; @param <str-from> The email address of the sender.
+;; @param <str-to> The email address of the recipient.
+;; @param <str-subject> The subject line of the email.
+;; @param <str-message> The message part of the email.
+;; @param <str-server> The address of the SMTP server.
+;; @param <str-user> Optional user name for authentication.
+;; @param <str-pass> Optional password for authentication.
+;; @return On success 'true', on failure 'nil'.
+;; In case the function fails returning 'nil', the function
+;; 'SMTP:get-error-text' can be used to receive the error text.
+;;
+;; @example 
+;;(SMTP:send-mail "jdoe@asite.com" "somebody@isp.com" "Greetings" 
+;;   "How are you today? - john doe -" "smtp.asite.com" "jdoe" "secret") 
+
+;; This logs in to the server, tries to authenticate using the username 'jdoe' and password 'secret' (if supplied), 
+;; and sends an email with the format: 
+;; <pre> 
+;;  From:    jdoe@asite.com 
+;;  To:      somebody@isp.com 
+;;  Subject: Greetings 
+;;  Message: How are you today? - John Doe - 
+;; </pre> 
+
+
+(context 'SMTP) 
+
+(set 'debug-flag nil) 
+
+(define (send-mail mail-from mail-to mail-subject mail-body SMTP-server (user-name "") (password "")) 
+    (and 
+        (set 'from-hostname (nth 1 (parse mail-from "@"))) 
+        (set 'socket (net-connect SMTP-server 25)) 
+        (confirm-request "2") 
+        (net-send-get-result (append "HELO " from-hostname) "2") 
+        (unless (and (empty?  user-name) (empty? password)) 
+           (mail-authorize user-name password) true) 
+        (net-send-get-result (append "MAIL FROM: <" mail-from ">") "2") 
+        (net-send-get-result (append "RCPT TO: <" mail-to ">") "2") 
+        (net-send-get-result "DATA" "3") 
+        (mail-send-header) 
+        (mail-send-body) 
+        (confirm-request "2") 
+        (net-send-get-result "QUIT" "2") 
+        (or (net-close socket) true))) 
+
+(define (confirm-request conf)
+    (net-receive socket recvbuff 256 "\r\n")
+    (if debug-flag (println recvbuff) true)
+    ; Empty out pipe. According to SMTP spec, last line has valid code.
+    ; added for 1.8 for newLISP 9.2.0
+    (while (< 0 (net-peek socket))
+        (net-receive socket recvbuff 256 "\r\n")
+        (if debug-flag (println recvbuff)))
+    (starts-with recvbuff conf))
+ 
+(define (net-send-get-result str conf) 
+   (set 'send-str (append str "\r\n")) 
+   (if debug-flag (println "sent: " send-str)) 
+   (net-send socket send-str) 
+   (if conf (confirm-request conf) true)) 
+
+(define (mail-authorize user-name password) 
+   (net-send-get-result 
+       (append "AUTH PLAIN " 
+               (base64-enc (append "\000" user-name "\000" password))) "235")) 
+
+(define (mail-send-header) 
+    (net-send-get-result (append "TO: " mail-to)) 
+    (net-send-get-result (append "FROM: " mail-from)) 
+    (net-send-get-result (append "SUBJECT: " mail-subject)) 
+    (net-send-get-result (append "X-Mailer: newLISP v." (string (nth -2 (sys-info)))))) 
+
+(define (mail-send-body ) 
+    (net-send-get-result "") 
+    (dolist (lne (parse mail-body "\r\n")) 
+        (if (starts-with lne ".") 
+            (net-send-get-result (append "." lne)) 
+            (net-send-get-result lne))) 
+    (net-send-get-result ".")) 
+
+(define (get-error-text) 
+    recvbuff) 
+
+(context 'MAIN) 
+
+;  test
+
+; (set 'SMTP:debug-flag true) 
+
+; (SMTP:send-mail 
+;  "from@example.com" 
+;  "to@example.com" 
+;  "title" 
+;  "body" 
+;  "smtp.example.com" 
+;  "user.name" 
+;  "password")) 
+
+; eof
diff --git a/modules/smtpx.lsp b/modules/smtpx.lsp
new file mode 100644
index 0000000..07396a1
--- /dev/null
+++ b/modules/smtpx.lsp
@@ -0,0 +1,216 @@
+;; @module smtpx.lsp
+;; @description Send mail using SMTP protocol
+;; @version 3.1 - "\'"real name\" <mail@domain.com>" now supported in <str-from> 
+;;              -  added Date to (send-mail-header) using a gettimezone hack to avoid DATE_MISSING spam test
+;;              -  Fixed "Bare lf's in body" error to make servers using RFC822 Spam filtering happy
+;;        Note: -  My quick hack at (gettimezone) needs to be improved to work world-wide :)
+;; @version 3.0 - Partial rewrite for Dragonfly. Addition attachments, custom port and proper utf8 encoding for subject/message/attachments
+;; @version 2.3 - fix in mail-send-body, thanks to Alessandro
+;; @version 2.2 - doc changes
+;; @version 2.1 - changes for 10.0
+;; @version 2.0 - March 2008, Cormullion added AUTH PLAIN authentication
+;; @author Lutz Mueller 2001-2009, Cormullion 2008, Greg Slepak 2009-2010 
+;;
+(context 'SMTP)
+;;
+;; @syntax (SMTP:send-mail <str-from> <str-to> <str-subject> <str-message> [<str-server> [<str-usr> <str-pass> [<int-port>]]])
+;; @param <str-from> The email address of the sender. "\"real name\"<mailname@domain.com>" support added in 3.x
+;; @param <str-to> The email address of the recipient.
+;; @param <str-subject> The subject line of the email.
+;; @param <str-message> The message part of the email.
+;; @param <str-server> The address of the SMTP server (default: "localhost")
+;; @param <str-user> Optional user name for authentication.
+;; @param <str-pass> Optional password for authentication.
+;; @param <int-port> Optional port to communicate on (default: 25)
+;; @return On success 'true', on failure 'nil'.
+;; In case the function fails returning 'nil', the function
+;; 'SMTP:get-error-text' can be used to receive the error text.
+;;
+;; @example
+;; (SMTP:send-mail "jdoe@asite.com" "somebody@isp.com" "Greetings"
+;;   "How are you today? - john doe -" "smtp.asite.com" "jdoe" "secret")
+;;
+;; This logs in to the server, tries to authenticate using the username 'jdoe' and password 'secret' (if supplied),
+;; and sends an email with the format:
+;;
+;;  From:    jdoe@asite.com
+;;  To:      somebody@isp.com
+;;  Subject: Greetings
+;;  Message: How are you today? - John Doe -
+(define (send-mail mail-from mail-to mail-subject mail-body (SMTP-server "localhost") user-name password (port 25))
+    (and
+        (set 'from-hostname (nth 1 (parse mail-from "@")))
+        (replace ">" from-hostname "")   ; 
+        (set 'socket (net-connect SMTP-server port))
+        (confirm-request "2")
+        (net-send-get-result (string "HELO " from-hostname) "2")
+        (if (or (null? user-name) (null? password)) 
+           true (mail-authorize user-name password))
+        (net-send-get-result (string "MAIL FROM: " mail-from ) "2")
+        (net-send-get-result (string "RCPT TO: <" mail-to ">") "2")
+        (net-send-get-result "DATA" "3")
+        (mail-send-header)
+        (mail-send-body)
+        (confirm-request "2")
+        (net-send-get-result "QUIT" "2")
+        (or (net-close socket) true)))
+
+(define (confirm-request conf)
+    (net-receive socket recvbuff 256 "\r\n")
+    ; Empty out pipe. According to SMTP spec, last line has valid code.
+    ; added for 1.8 for newLISP 9.2.0
+    (while (< 0 (net-peek socket))
+        (net-receive socket recvbuff 256 "\r\n") )
+    (starts-with recvbuff conf))
+
+(define (net-send-get-result str conf)
+   (set 'send-str (string str "\r\n"))
+   (net-send socket send-str)
+   (if conf (confirm-request conf) true))
+
+; DANGER! We *must* use 'append' here instead of 'string' as the two treat "\000" differently!
+(define (mail-authorize user-name password)
+   (net-send-get-result
+       (string "AUTH PLAIN "
+               (base64-enc (append "\000" user-name "\000" password))) "235"))
+
+; ;old functions, we have our own.
+; (define (mail-send-header)
+;     (net-send-get-result (string "TO: " mail-to))
+;     (net-send-get-result (string "FROM: " mail-from))
+;     (net-send-get-result (string "SUBJECT: " mail-subject))
+;    ;(net-send-get-result headers)
+;     (net-send-get-result (string "X-Mailer: newLISP v." (nth -2 (sys-info)))))
+;
+; (define (mail-send-body )
+;     (net-send-get-result "")
+;     (dolist (lne (parse mail-body "\r\n"))
+;         (if (starts-with lne ".")
+;             (net-sent-get-result (string "." lne))
+;             (net-send-get-result lne)))
+;     (net-send-get-result "."))
+
+;; @syntax (SMTP:get-error-text)
+;; <p>Call this to get the reason 'send-mail' returned 'nil'.</p>
+(define (get-error-text)
+    recvbuff)
+
+; ---------------------------------------------------------------
+; !Attachments - Public API
+; ---------------------------------------------------------------
+
+;; @syntax (SMTP:clear-attachments)
+(define (clear-attachments)
+   (setf attachments '()) )
+
+;; @syntax (SMTP:attach-document <str-content> <str-filename> [<str-disposition> [<str-mime-type> [<str-encoding>]]])
+;; @param <str-content> The attachment data.
+;; @param <str-filename> How you'd like your attachment to appear named in the email.
+;; @param <str-disposition> "attachment" or "inline". default is "attachment".
+;; @param <str-mime-type> default is "application/octet-stream".
+;; @param <str-encoding> default is "base64". If 'encoding' is "base64" it will be automatically transformed using 'encode64-widthsafe'
+(define (attach-document content filename (disposition "attachment") (mime-type "application/octet-stream") (encoding "base64"))
+   (push (list content filename disposition mime-type encoding) attachments -1) )
+
+; ---------------------------------------------------------------
+; !UTF-8 encoding support for non-ASCII characters
+; ---------------------------------------------------------------
+
+;; @syntax (SMTP:encode64-widthsafe <buff-data>)
+;; <p>Useful for attaching binary data such as images. Converts the data into base64
+;; and chops it up so that the lines are not longer than 76 characters long, making
+;; it safe to include in the body of emails.</p>
+;; <p>If the attachment's encoding to "base64" (which it is by default), this function
+;; will automatically applied to the <str-content> of the email.</p>
+;; Fixed "bare lf's in body" error to make servers using RFC822 Spam filtering happy V3.x
+;
+(define (encode64-widthsafe data)
+   (join (explode (base64-enc data) 76) "\r\n")  )
+
+;; @syntax (SMTP:encode64-line <str-line>)
+;; <p>Creates a base64 UTF-8 compatible string, suitable for including foreign characters
+;; in the subjects of emails. This is used by 'send-mail' automatically on the filename
+;; of any attachments, as well as the subject of the email.</p>
+(define (encode64-line str)
+   (string "=?UTF-8?B?" (base64-enc str) "?=") )
+
+; ---------------------------------------------------------------
+; !Attachments - Private API
+; ---------------------------------------------------------------
+
+(setf boundary (string "newLISP-" (nth -2 (sys-info)) "--65z64F4n654"))
+(setf headers (string "MIME-Version: 1.0\r\nContent-Type: multipart/mixed; boundary=" boundary))
+
+(setf mail-body-wrapper (string
+{--} boundary {
+Content-Type: text/plain; charset=utf-8
+Content-Transfer-Encoding: base64
+
+%s
+   
+--} boundary {%s}))
+
+; filename madness. We actually do not need the *=utf-8 weirdness
+; if we're using the encode64-line func instead of utf8-urlencode
+
+(setf attachment-wrapper (string
+;{Content-Disposition: %s; filename*=utf-8''%s
+{Content-Disposition: %s; filename="%s"
+Content-Type: %s; name="%s"
+Content-Transfer-Encoding: %s
+
+%s
+
+--} boundary {%s}))
+
+(setf attachments '()) ; the list of attachments is placed here
+
+(define (prepared-body)
+   (format mail-body-wrapper (encode64-widthsafe mail-body)
+      ; indicate this is the last boundary if no attachments
+      (if (zero? (length attachments)) "--" "")) )
+;
+; This crude gettimezone hack only works for USA on Win32
+; someone else can fix it for the rest of the world
+; Removed (encode64-line on subject to reduce SpamAssasin value
+;
+(define (gettimezone ,tmp)
+   (set 'tmp (now)
+        'tmp (/ (+ (tmp 9) (tmp 10)) 60))
+   (string "-0" tmp "00") )
+;
+; Removed (encode64-line on Subject to to improve sanity and get by some spam filters:)
+; Added Date using a gettimezone hack to avoid DATE_MISSING spam test
+;
+(define (mail-send-header)
+    (net-send-get-result (string "TO: " mail-to) )
+    (net-send-get-result (string "FROM: " mail-from) )
+    (net-send-get-result (string "DATE: " (date (date-value) 0 "%a, %d %b %Y %X ") (gettimezone)) )
+#;    (net-send-get-result (string "SUBJECT: " (encode64-line mail-subject)))
+    (net-send-get-result (string "SUBJECT: " mail-subject))
+    (net-send-get-result headers)
+    (net-send-get-result (string "X-Mailer: newLISP v." (nth -2 (sys-info)) "\r\n")) )
+
+(define (mail-send-body)
+   (net-send-get-result "")
+   (net-send-get-result (prepared-body))
+   (send-attachments)
+   (net-send-get-result ".") )
+
+(define (send-attachments , encoding filename)
+   (dolist (attachment attachments)
+      (set 'encoding (attachment 4) 'filename (attachment 1))
+      (net-send-get-result (format attachment-wrapper
+         (attachment 2)
+         (encode64-line filename)
+         (attachment 3)
+         (encode64-line filename)
+         encoding
+         (if (= encoding "base64")
+            (encode64-widthsafe (attachment 0))
+            (attachment 0) )
+         ; indicate this is the last boundary if no more
+         (if (= (+ 1 $idx) (length attachments)) "--" "")
+      ))))
+(context MAIN)
+
diff --git a/modules/sqlite3.lsp b/modules/sqlite3.lsp
new file mode 100644
index 0000000..0fa574d
--- /dev/null
+++ b/modules/sqlite3.lsp
@@ -0,0 +1,524 @@
+;; @module sqlite3.lsp 
+;; @description SQLite3 database interface routines
+;; @version 1.6 - comments redone for automatic documentation
+;; @version 1.7 - D.C. fixed getting types when null values are present
+;; @version 1.8 - D.C. made 64-Bit integers work
+;; @version 1.9 - new library detection routine
+;; @version 2.0 - added documentation for close
+;; @version 2.1 - use default functor for query
+;; @version 2.2 - detection for NEWLISP64, lib path for OpenBSD, tested for 64-bit 
+;; @version 2.3 - C.H. added parameter binding for safer SQL (guard against SQL-injection)
+;; @version 2.4 - doc changes
+;; @version 2.5 - changed sqlite3_bind_blob to sqlite3_bind_text in function bind-parameter
+;; @version 2.61 - added function  <tt>sql3:colnames</tt>.
+;; @version 2.7 - changed deprecated <tt>name</tt> to <tt>term</tt>, <tt>inc</tt> to <tt>++</tt>
+;; @version 2.71 - minor doc changes
+;; @version 2.72 - add support for CentOS 6 Linux 64Bit
+;; @version 2.73 - doc additions
+;; @version 2.83- added sqlite3 library path for UBUNTU 12.04/10 64-bit and others
+;; @author Lutz Mueller 2004-2013, Dmitri Cherniak 2007, Clemens Hintze 2009
+;;
+;; <h2>Module for SQLite3 database bindings</h2>
+;; To use this module include the following 'load'  or 'module' statement at the
+;; beginning of the program file:
+;; <pre>
+;; (load "/usr/share/newlisp/modules/sqlite3.lsp")
+;; ; or shorter
+;; (module "sqlite3.lsp")
+;; </pre>
+;; Test the module:
+;; <pre>
+;; (test-sqlite3)
+;; </pre>
+;; This function, located at the and of the module file, exercises
+;; most of the functions.
+;;
+;; SQLite version 3.0 introduced a new database format and is incompatible
+;; whith the previous 2.1 to 2.8 format. Old SQLite 2.x based databases can
+;; be converted  using the old and new sqlite client application:
+;;
+;;    sqlite OLD.DB .dump | sqlite3 NEW.DB
+;;
+;; While in sqlite 2.8 all returned fields where of string type, SQLite3
+;; returns, text, integer or float. Blobs are returned as text and NULLs
+;; are returned as nil.
+;;
+;; See also the documentation at @link http://sqlite.org sqlite.org
+;;
+;; <h2>Requirements:</h2> 
+;; One of the libraries sqlite3.dll for MS Windows or libsqlite3.so for UNIX like
+;; operating systems is required from http://www.sqlite.org.
+;;
+;; SQLite is an <in-process> database. The library contains the whole database
+;; system. An extra database server is not required. SQLite also has limited
+;; mutiuser capabilities for accessing a common database from several programs
+;; at the same time. See the documentation at @link http://sqlite.org sqlite.org 
+;; for details.
+;;
+;; The following is a short example how to use SQLite3:
+;;
+;; @example
+;; (sql3:open "MYDB")      ; opens/creates a database returns a handle (ignore)
+;;                         ; or 'nil' on failure
+;;
+;; (sql3:sql "select * from mytable;")	; make a SQL query, return result
+;; (sql3 "select * from mytable;") ; use default functor as alias
+;;
+;; (sql3:error)            ; return error text
+;;
+;; (sql3:close)            ; close the database
+
+;; Function calls returning 'nil' signal that an error has occurred. The
+;; function 'sql3:error' can then be used to get details about the error
+;; as a text string.
+;;
+;; At the bottom of the source file 'sqlite3.lsp' a test routine called
+;; 'test-sqlite3' can be found to test for correct installation of SQLite.
+
+; make this module compatible with version less than 10.1.11
+(when (< (sys-info -2) 10111)
+	(constant (global 'term) name))
+
+(when (< (sys-info -2) 10110)
+	(constant (global '++) inc))
+
+(context 'sql3)
+
+; fetch-row and keep-type functions depend on this
+(set 'NEWLISP64 (not (zero? (& (sys-info -1) 256))))
+
+; set library to path-name of the library on your platform OS
+;
+(set 'files (list
+    "/usr/lib/libsqlite3.so" ; SuSE Linux
+    "/usr/local/lib/libsqlite3.so" ; Linux, BSD, Solaris
+    "/usr/pkg/lib/libsqlite3.so" ; NetBSD
+    "/usr/local/lib/libsqlite3.so.13.3" ; OpenBSD 4.6
+    "/usr/lib/libsqlite3.0.dylib" ; Mac OSX Darwin
+    "/usr/lib64/libsqlite3.so" ; for 64Bit Fedora CentOS 6 Linux
+    "/usr/lib/x86_64-linux-gnu/libsqlite3.so" ; for UBUNTU 64-bit
+    "/usr/lib/x86_64-linux-gnu/libsqlite3.so.0"
+    "/usr/lib/i386-linux-gnu/libsqlite3.so" ; for UBUNTU 32-bit
+    "/usr/lib/i386-linux-gnu/libsqlite3.so.0"
+    "sqlite3.dll" ; Windows DLL path and current directory
+    (string (env "PROGRAMFILES") "/sqlite3/sqlite3.dll") ; Windows SQLite3 std install
+))
+
+
+(set 'library (files (or
+		       (find true (map file? files)) 
+		       (throw-error "cannot find sqlite3 library"))))
+
+(import library "sqlite3_open" "cdecl")
+(import library "sqlite3_close" "cdecl")
+(import library "sqlite3_prepare" "cdecl")
+(import library "sqlite3_bind_blob" "cdecl")
+(import library "sqlite3_bind_double" "cdecl")
+(import library "sqlite3_bind_null" "cdecl")
+(import library "sqlite3_bind_parameter_count" "cdecl")
+(import library "sqlite3_bind_parameter_index" "cdecl")
+(import library "sqlite3_bind_parameter_name" "cdecl")
+(import library "sqlite3_bind_text" "cdecl")
+(import library "sqlite3_bind_text16" "cdecl")
+(import library "sqlite3_step" "cdecl")
+(import library "sqlite3_column_count" "cdecl")
+(import library "sqlite3_column_name" "cdecl")
+(import library "sqlite3_column_type" "cdecl")
+(import library "sqlite3_column_int64" "cdecl")
+(import library "sqlite3_column_double" "cdecl")
+(import library "sqlite3_column_text" "cdecl")
+(import library "sqlite3_column_blob" "cdecl")
+(import library "sqlite3_column_bytes" "cdecl")
+(import library "sqlite3_finalize" "cdecl")
+(import library "sqlite3_get_table" "cdecl")
+(import library "sqlite3_last_insert_rowid" "cdecl")
+(import library "sqlite3_changes" "cdecl")
+(import library "sqlite3_busy_timeout" "cdecl")
+(import library "sqlite3_errmsg" "cdecl")
+
+
+; gloablly used vars and constants
+
+(define db nil)                  ; database handle
+(define dbp "\000\000\000\000\000\000\000\000")  ; ptr to database handle
+(define error-message nil)        ; error message
+(define col-names '())           ; list of column headers
+(define col-types '())           ; list of column types
+(define pstm "\000\000\000\000\000\000\000\000") ; ptr to compiled sql
+
+(constant 'SQLITE_OK 0)
+(constant 'SQLITE_ROW 100)
+(constant 'SQLITE_DONE 101)
+
+(constant 'SQLITE_TYPES '(
+	0 
+	SQLITE_INTEGER 
+	SQLITE_FLOAT 
+	SQLITE_TEXT 
+	SQLITE_BLOB 
+	SQLITE_NULL))
+
+;; @syntax (sql3:open <str-db-name>)
+;; @param <str-db-name> The name of the database.
+;; @return A database handle (discard), or 'nil' on failure.
+;; Opens or creates a database. If the database does exist it gets opened, 
+;; else a new database with the name given is created.
+;; If trying to open a database that already has been opened 'nil' is returned
+;; and an error text can be retrieved using 'sql3:error'.
+
+(define (sql3:open db-name)
+  ; only open if not alrady done
+  (if (not db)
+    (begin
+      (set 'result (sqlite3_open db-name dbp))
+      (if (!= result SQLITE_OK)
+        (set 'db nil)
+        (if NEWLISP64
+            (set 'db (get-long dbp))
+            (set 'db (get-int dbp)))
+      ))
+    (begin
+      (set 'error-message "A database is already open")
+      nil))
+)
+
+;; @syntax (sql3:close)
+;; @return Returns 'true' on success;
+;; Closes the currently open database.
+
+(define (sql3:close) 		;;  overwrite the close in MAIN
+	(if db (begin
+		(sqlite3_close db)
+		(set 'db nil)
+		true)))
+
+
+;; @syntax (sql3:sql <str-sql> [<sql-args>])
+;; @param <str-sql> The SQL statement.
+;; @param <sql-args> Parameters for the SQL statement's host variables
+;;
+;; Executes the SQL statement in <str-sql>. For 'select' statements a table
+;; of the result set is returned or '()' for the empty set. For other statements
+;; 'true' is returned for a  successful outcome. On failure 'nil' is returened 
+;; and 'sql3:error' can be used to retrieve the error text.
+;;
+;; If the parameter <sql-args> is given, it has either to be a list of values (if
+;; the SQL statement use the '?' type of host variables) or an association list
+;; whose every association is formed like (<varname> <value>). The <varname> is
+;; the name of the host variable used in the SQL statement e.g. ':name' or '?123'.
+;;
+;; Strings are bound to host variables as BLOBs. That mean the data will be passed
+;; as is, without any further modification.
+;;
+;; Using host variables is much safer than passing those values via string
+;; composition as no SQL quoting problem can occur (SQL injection attack).
+;; For example:
+;;
+;; @example
+;; ; traditional usage 
+;; (sql3:sql "select * from persons where age > 18;") 
+;;
+;; ; safer usage using SQLite parameter binding
+;; (sql3:sql "select * from persons where age > ?;" '(18))
+;;
+;; ; bind parameters from association lists
+;; (sql3:sql "select * from persons where name like :name;" '((":name" "Do%")))
+;; (sql3:sql "select * from persons where age > :a and name like :n;" '((":n" "Do%") (":a" 18)))
+
+
+(define (sql sql-str sql-args)
+	(set 'result nil 'done nil 'error-message nil)
+	(set 'sqarray '());
+	(set 'col-names '());
+	(set 'col-types '());
+
+	; set up parameters for sqlite3_prepare() call
+	(set 'ppstm "\000\000\000\000\000\000\000\000") ; pointer to statement ptr
+	(set 'pptail "\000\000\000\000\000\000\000\000") ; pointer to statement tail
+
+	; compile the sql statment
+	(if db (set 'result (sqlite3_prepare db sql-str -1 ppstm pptail)))
+
+	; set up parameters for sqlite3_step() call
+	(if NEWLISP64
+		(set 'pstm (get-long ppstm))
+		(set 'pstm (get-int ppstm)))
+
+	; bind parameters to sql stament if necessary
+	(if (and (= result SQLITE_OK) sql-args)
+  		(let (argi 0)
+    			(dolist (entry sql-args (!= result SQLITE_OK))
+      				(if (list? entry) 
+        				(set 'result (bind-parameter pstm (first entry) (last entry)))
+        				(set 'result (bind-parameter pstm (++ argi) entry))
+				)))
+	)
+
+	; execute the compiled statement
+	(if (= result SQLITE_OK) 
+		(while (not done) 
+			;; execute statement until done/101 or 
+			(set 'result (sqlite3_step pstm))
+			(set 'num-cols (sqlite3_column_count pstm))
+			(if (empty? col-names) (set 'col-names (get-names pstm num-cols)))
+			(set 'col-types (get-types pstm num-cols))
+			(if (= result SQLITE_ROW)
+				(push (get-values pstm num-cols) sqarray -1)
+				(set 'done true) ;; received done/101 or error
+			))
+  	)
+  
+	; if done/101 finalize
+	(if (= result SQLITE_DONE) 
+		(begin
+			(set 'result (sqlite3_finalize pstm))
+			; for 'select' statements return the array else 'true'
+			(if (> num-cols 0) sqarray true))
+		(if (= result 0) true (set-error))))
+
+
+(define (bind-parameter pstm param value)
+	(let (idx param)
+		(unless (integer? param)
+			(set 'idx (sqlite3_bind_parameter_index pstm
+				(if (symbol? param) (term param) (string param)))))
+		(cond
+			((float? value) (sqlite3_bind_double pstm idx (float value)))
+			;((string? value) (sqlite3_bind_blob pstm idx value (length value) -1))
+			((string? value) (sqlite3_bind_text pstm idx value (length value) -1))
+			((nil? value) (sqlite3_bind_null pstm idx))
+			(true (sqlite3_bind_text pstm idx (string value) (length (string value)) -1)) )) )
+
+
+(define (get-values pstm cols) 
+	(set 'row '())
+	(dotimes (idx cols)
+		(set 'i (int idx)) ; all loop vars are float
+		(case (nth idx col-types idx)
+;			(SQLITE_INTEGER 
+;				(push (sqlite3_column_int pstm i) row -1))
+;			fixed for 64-bit, thanks Dmitry
+			(SQLITE_INTEGER 
+				(set 'pstr (sqlite3_column_text pstm i)) 
+				(if (= pstr 0) 
+					(push nil row -1) 
+					(push (int (get-string pstr)) row -1))) 
+			(SQLITE_FLOAT 
+				(set 'pstr (sqlite3_column_text pstm i))
+				(if (= pstr 0)
+					(push nil row -1)
+					(push (float (get-string pstr)) row -1)))
+			(SQLITE_TEXT 
+				(set 'pstr (sqlite3_column_text pstm i))
+				(if (= pstr 0)
+					(push "" row -1)
+					(push (get-string pstr) row -1)))
+			(SQLITE_BLOB 
+				(set 'pstr (sqlite3_column_blob pstm i))
+				(set 'len (sqlite3_column_bytes pstm i))
+				(set 'buff (dup "\000" len))
+				(if (= pstr 0)
+					(push "" row -1)
+					(begin
+						(cpymem pstr buff len)
+						(push buff row -1))))
+			(SQLITE_NULL 
+				(push nil row -1))))
+	row)
+
+(define (get-names pstm cols) 
+	(set 'row '())
+	(dotimes (idx cols)
+		(set 'i (int idx)) ; all loop vars are float
+		(set 'ps (sqlite3_column_name pstm i))
+		(if (= ps 0)	       ;; check for null pointer to result
+			(push "" row -1)
+			(push (get-string ps) row -1)))
+	row)
+
+(define (get-types pstm cols)
+	(set 'row '())
+	(dotimes (idx cols)
+		(set 'i (int idx)) ; all loop vars are float
+		(push (nth (sqlite3_column_type pstm i) SQLITE_TYPES) row -1))
+	row)
+
+(define sql3:sql3 sql)
+
+;; @syntax (sql3:colnames)
+;; @return A list of column header names.
+;; Returns a list of column header names for the last query. This is
+;; a function wrapper around the internal variable <tt>sql3:col-names</tt>.
+
+(define (colnames) col-names)
+
+
+;; @syntax (sql3:rowid)
+;; @return The last row id from last 'insert'.
+;; Gets the id of the last row inserted.
+
+(define (rowid)
+	(if db (sqlite3_last_insert_rowid db)))
+
+;; @syntax (sql3:tables)
+;; @return A list of tables in the database.
+
+(define (tables)
+	(if db (begin
+		(set 'lst (sql "select tbl_name from sqlite_master")) ))
+		(if lst (set 'lst (first (transpose lst)))))
+
+
+;; @syntax (sql3:columns <str-tabel-name>)
+;; @return A list of column names for a table.
+
+(define (columns aTable)
+        (if (list? (sql (append "select * from " aTable " where 0;")))
+                col-names))
+
+
+;; @syntax (sql3:changes)
+;; @return The Number of rows changed/affected by the last SQL statement.
+
+(define (changes)
+	(if db (sqlite3_changes db)))
+
+
+
+;; @syntax (sql3:timeout <num-milli-seconds>)
+;; @return 'true' on success or 'nil' on failure.
+;; Sets busy timeout in milliseconds.
+
+(define (timeout ms)
+	(if db (zero? (sqlite3_busy_timeout db (int ms)))))
+
+
+
+;; @syntax (sql3:error)
+;; @return The error text of the last error occured in 'sql3:sql'.
+
+(define (error) error-message)
+	
+(define (set-error)
+	(set 'result (sqlite3_errmsg db))
+	(if (= result 0) 
+		(set 'error-message nil)
+		(set 'error-message (get-string result))
+		nil
+	)
+)
+
+
+(context 'MAIN)
+
+; -------------------------------------------------------------------------
+;
+; test the database routines
+;
+; if there is an old "SQLITE3-TEST" db from an earlier sqlite 2.8 delete it first
+;
+(define (test-sqlite3)
+	(if (sql3:open "SQLITE3-TEST") 
+		(println "database opened/created,  ... Ok")
+		(println "problem opening/creating database"))
+
+	(if (sql3:sql "create table fruits (name CHAR(20), qty INT(3), price FLOAT(10), blobtext BLOB);")
+		(println "created table fruits,  ... Ok")
+		(println "problem creating table fruits"))
+
+	(if (sql3:sql "insert into fruits values ('apples', 11, 1.234, X'41424300010101');")
+		(println "inserted, last row id: " (sql3:rowid) ",  ... Ok")
+		(println "problem inserting row"))
+
+	(if (sql3:sql "insert into fruits values ('oranges', 22, 2.345, X'42434400020202');")
+		(println "inserted, last row id: " (sql3:rowid) ",  ... Ok")
+		(println "problem inserting row"))
+
+	(if (sql3:sql "insert into fruits values ('bananas', 33, 3.456, X'44454600030303');")
+		(println "inserted, last row id: " (sql3:rowid) ",  ... Ok")
+		(println "problem inserting row"))
+
+	; Definition of a small helper function for the tests to emulate the X'...' argument
+	; quoting of SQL
+
+	(define (hexstring hexstr)
+		(join (map (fn (s) (pack "c" (int s 0 16))) (find-all ".." hexstr))))
+
+	; Following statement was modified below to show, how to use host variables with
+	; the SQL INSERT statement.
+	;	(if (sql3:sql "insert into fruits values (:name, :qty, :price, X'47484900040404');" 
+	;        '((":name" "grapes") (":qty" 123456789012345678) (":price" 7,89)))
+	;		(println "inserted, last row id: " (sql3:rowid) ",  ... Ok")
+	;		(println "problem inserting row"))
+
+	(if (sql3:sql "insert into fruits values (?, ?, ?, ?);" 
+        		(list "grapes" 123456789012345678 (div 789 100) (hexstring "47484900040404")))
+		(println "inserted, last row id: " (sql3:rowid) ",  ... Ok")
+		(println "problem inserting row: " (sql3:error)))
+
+	(set 'sqarray (sql3:sql "select * from fruits;"))
+
+	(if sqarray
+		(begin
+			(println "selected rows: ") 
+			(map println sqarray)
+			(println "column names with sql3:col-names: ")
+			(map println (sql3:colnames))
+			(println "... Ok")
+		)
+		(println "problem with select"))
+
+  	(if (= (sql3:sql "select name from fruits where qty < ? order by name;" '(33))
+   		 	'(("apples") ("oranges")))
+    		(println "select via host parameter (type '?'), ... Ok")
+		(println "problem with selecting via host parameters (type '?')"))
+
+  	(if (= (sql3:sql "select name from fruits where qty < :qty order by name;" '((":qty" 33)))
+   		 	'(("apples") ("oranges")))
+    		(println "select via host parameter (type ':VVV'), ... Ok")
+		(println "problem with selecting via host parameters (type ':VVV')"))
+
+  	(if (= (sql3:sql "select name from fruits where qty < ?2 order by name;" '(("?2" 33)))
+   		 	'(("apples") ("oranges")))
+    		(println "select via host parameter (type '?NNN'), ... Ok")
+		(println "problem with selecting via host parameters (type '?NNN')"))
+
+  	(if (= (sql3:sql "select name from fruits where qty < @par order by name;" '(("@par" 33)))
+   		 	'(("apples") ("oranges")))
+    		(println "select via host parameter (type '@VVV'), ... Ok")
+		(println "problem with selecting via host parameters (type '@VVV')"))
+
+  	(if (= (sql3:sql "select name from fruits where qty < $par order by name;" '(("$par" 33)))
+   	 		'(("apples") ("oranges")))
+    		(println "select via host parameter (type '$VVV'), ... Ok")
+		(println "problem with selecting via host parameters (type '$VVV')"))
+
+
+  	; SQL injection has no chance:
+	
+  	(print "try to drop table fruits via SQL injection attack ... ") 
+
+  	(if (sql3:sql "select * from fruits where name = ?;" '("''; drop table fruits;"))
+		(println "OUCH! Table was dropped via SQL injection!!!")
+		(println "no luck, table was safe against SQL injection."))
+	
+	(if (sql3:sql "delete from fruits where 1;")
+		(println "deleted, rows affected: " (sql3:changes) ",  ... Ok")
+		(println "problem deleting rows"))
+
+	(if (list? (sql3:tables) )
+		(println "tables: " (sql3:tables) ", ... Ok")
+		(println "problem in sql3:tables"))
+
+	(if (list? (sql3:columns "fruits") )
+		(println "columns: " (sql3:columns "fruits") ", ... Ok")
+		(println "problem in sql3:columns"))
+
+	(if (sql3 "drop table fruits;")
+		(println "table fruits dropped,  ... Ok")
+		(println "problem dropping table fruits"))
+
+	(sql3:close)
+)
+
+; eof ;
diff --git a/modules/stat.lsp b/modules/stat.lsp
new file mode 100644
index 0000000..3721cc9
--- /dev/null
+++ b/modules/stat.lsp
@@ -0,0 +1,525 @@
+;; @module stat.lsp
+;; @description Basic statistics and plotting library
+;; @version 3.0 - Eliminated plot functions and f-prob which now is built-in as prob-f
+;; @version 3.1 - Documentation changes
+;; @version 3.2 - Documentation, mention built-in 'stats' function since 10.4.2
+;;
+;; @author Lutz Mueller, 2001-2014
+;; <h2>Functions for statistics</h2>
+;; To use this module it has to be loaded at the beginning of the
+;; program file:
+;; <pre>
+;; (load (append (env "NEWLISPDIR") "/modules/stat.lsp"))
+;; ; or shorter
+;; (module "stat.lsp")
+;; </pre>
+;; All functions work on integers and floats or a mix of both. <lists> are normal
+;; LISP lists. <matrices> are lists of lists, one list for each row in the
+;; two dimensional data matrix. See the function 'stat:matrix' on how to make matrices
+;; from lists.
+;;
+;; In version 3.0 of 'stat.lsp' the usage for Gnuplot the stat:plot and stat:plotXY 
+;; functions has been eliminated. Instead use the module 'plot.lsp' shipped with all binary and
+;; source distributions. The F-distribution function 'f-prob' has also been eliminated
+;; instead use one of new the built-in 'prob-f' or 'crit-f' functions.
+;;
+;; The documention contains only the call patterns. See the source for more
+;; documentation.
+;;
+;; <h2>Summary of functions</h2><br>
+;; <h3>General uni- and bi- variate statistics</h3>
+;; <pre>
+;; stat:sum      - sum of a vector of numbers (see also built-in stats since 10.4.2)
+;; stat:mean     - arithmetik mean of a vector of numbers (see also built-in stats since 10.4.2)
+;; stat:var      - estimated variance of numbers in a vector sample
+;; stat:sdev     - estimated standard deviation of numbers in a vector (see also built-in stats since 10.4.2)
+;; stat:sum-sq   - sum of squares of a data vector
+;; stat:sum-xy   - sum of products of a two data vectors
+;; stat:corr     - correlation coefficient between two vectors (built-in since 10.4.2)
+;; stat:cov      - covariance of two number vectors
+;; stat:sum-d2   - sum of squared differences of a vector from its mean
+;; stat:sum-d2xy - sum of squared diffferences of two vectors
+;; stat:regression - calculates the intecept and slope of a regression estimate
+;; stat:fit      - return the fitted line using regression coefficients
+;; stat:moments  - calulates 1st to 3rd moments from a vector of numbers
+;; </pre>
+;; <h3>Multi variate statistics</h3>
+;; <pre>
+;; stat:multiple-reg  - calculates a multiple regression
+;; stat:cov-matrix    - calculates a covariance matrix
+;; stat:corr-matrix   - calculates a correlation matrix
+;; </pre>
+;; <h3>Time series</h3>
+;; <pre>
+;; stat:smooth   - smoothes a vector of numbers
+;; stat:lag      - calcultes a difference list with specified lag
+;; stat:cumulate - cumulate a data vector
+;; stat:power    - calculate the power spectrum of a time series
+;; </pre>
+;; <h3>Matrix and list utilities</h3>
+;; <pre>
+;; stat:matrix       - make a matrix from column vectors
+;; stat:diagonal     - make a diagonal matrix
+;; stat:get-diagonal - return the diagonal of a matrix in a vector
+;; stat:mat-map      - map a binary function on to matrices
+;; </pre>
+
+
+(if (< (sys-info -2) 10111)
+	(constant (global 'term) name))
+
+;; @syntax (stat:corr <X> <Y>)
+;; @param <X> A list of numbers.
+;; @param <Y> A list of numbers.
+;; @return Correlation coefficient of lists <X> and <Y>.
+;; A 'corr' native function is built into newLISP since 10.4.2.
+
+;; @syntax (stat:cov <X> <Y>)
+;; @param <X> A list of numbers.
+;; @param <Y> A list of numbers.
+;; @return Covariance of data in lists <X> and <Y>
+
+;; @syntax (stat:cov-matrix <X>)
+;; @param <X> A matrix of numbers.
+;; @return Covariance matrix of <X> with <N> rows and <k> columns.
+
+;; @syntax (stat:corr-matrix <X>)
+;; @param <X> A matrix of numbers.
+;; @return Correlation matrix of <X> with <N> rows and <k> columns.
+
+;; @syntax (stat:cumulate <X>)
+;; @param <X> A list of numbers.
+;; @return The cumulated list of <X>.
+
+;; @syntax (stat:diagonal <item> <N>)
+;; @param <item> The diagonal element.
+;; @return A diagonal matrix of length <N> with <item> in the diagonal.
+
+;; @syntax (stat:fit <X> <Y>)
+;; @param <X> A list of numbers.
+;; @param <Y> A list of numbers.
+;; @return fitted line based on '(stat:regression X Y)'.
+
+;; @syntax (stat:f-prob <F> <df1> <df2>)
+;; @param <F> The variance ratio.
+;; @param <df1> Degrees of freedom.
+;; @param <df2> Degrees of freedom.
+;; @return Probablity of F variance ratio for <df1>, <df2> degress of freedom.
+
+;; @syntax (stat:get-diagonal <X>)
+;; @param <X> An matrix filled with numbers.
+;; @return A list from the diagonal elements of <X>.
+
+;; @syntax (stat:lag <X> <n>)
+;; @param <X> A list of numbers.
+;; @param <n> Lag n.
+;; @return A differenced list of <X> with a lag of <n>.
+;; If the length of list <X> is <l> then the length of the resulting
+;; differenced list is <l - n>.
+
+;; @syntax (stat:mat-map <op> <A> <B>)
+;; @return Matrix map, e.g. '(stat:mat-map + A B)'.
+;; Used for adding and subtracting matrices.
+
+;; @syntax (stat:matrix <C1> .... <CN>)
+;; @param <C1> The first column list of values.
+;; @param <CN> The Nth column list of values.
+;; @return A matrix off  <1> to <N> columns <C>.
+
+;; @syntax (stat:mean <X>) 
+;; @param <X> A list of numbers.
+;; @return The mean of data in list <X>.
+
+;; @syntax (stat:moments <X>)
+;; @param <X> A list of numbers.
+;; @return Calculates all moments of list <X>.
+
+;; @syntax (stat:multiple-reg <X> <offY>)
+;; @param <X> A matrix of numbers.
+;; @param <offY> Zero based offset into <Y>.
+;; @return Multiple regression of vars in <X> onto <Y> at <offsetY>.
+
+;; @syntax (stat:power <TS>)
+;; @param <TS> A time series of numbers.
+;; @return The power spectrum of a time series
+
+;; @syntax (stat:regression <X> <Y>)
+;; @param <X> A list of numbers.
+;; @param <Y> A list of numbers.
+;; returns <(b0 b1)> coefficients of regression <Y = b0 + b1*X>.
+
+;; @syntax (stat:sdev <X>)
+;; @param <X> A list of numbers.
+;; @return Standard deviation of data in list <X>.
+
+;; @syntax (stat:smooth <X> <alpha>)
+;; @param <X> A list of numbers.
+;; @param <alpha> Smoothing coefficient <0 &lt; alpha &lt; 1>.
+;; @return Exponentially smoothed sequence in <X>.
+
+;; @syntax (stat:sum <X>)
+;; @param <X> A list of numbers,
+;; @return Sum of data in list <X>.
+
+;; @syntax (stat:sum-d2 <X>)
+;; @param <X> A list of numbers.
+;; @return Sum of squared diffs <(x - mean(X))^2> in list <X>.
+
+;; @syntax (stat:sum-d2xy <X> <Y>)
+;; @return Sum of squared differences <(x - y)^2> of elements in lists <X> and <Y>.
+
+;; @syntax (stat:sum-sq <X>)              
+;; @param <X> A list of numbers.
+;; @return Sum of <x*x> data elements in list <X>.
+
+;; @syntax (stat:sum-xy <X> <Y>)
+;; @param <X> A list of numbers.
+;; @param <Y> A list of numbers.
+;; @return Sum of products <x*y> data elements in lists <X> and <Y>.
+
+;; @syntax (stat:var <X>)
+;; @param <X> A list of numbers.
+;; @return The variance of the data in list <X>.
+
+
+
+(context 'stat)
+
+;-------------------  General uni and bi-variate statistics --------------------
+
+; sum of a data vector X
+(define (sum X)
+	(apply add X))
+
+; mean of a data vector X
+(define (mean X)
+	(div (sum X) (length X)))
+
+; variance of a data vector X
+(define (var X)
+	(div (sum-d2 X) (sub (length X) 1)))
+
+; standard deviation of a data vector X
+(define (sdev X)
+	(sqrt (var X)))
+
+; sum of squares of a data vector X
+(define (sum-sq X)
+	(apply add (map mul X X)))
+
+; sum of the product of data vectors X*Y
+(define (sum-xy X Y)
+	(apply add (map mul X Y)))
+
+; covariance of data vectors X Y
+(define (cov X Y)
+	(sub (sum-xy X Y) (div (mul (sum X) (sum Y)) (length X))))
+
+; sum of sqared differenses of X to mean of X
+(define (sum-d2 X)
+	(sub (sum-sq X) (div (mul (sum X) (sum X)) (length X))))
+
+; Pearson r, product moment correlation of data vectors X and Y
+(define (stat:corr X Y)
+	(div (cov X Y) (sqrt (mul (sum-d2 X) (sum-d2 Y)))))
+
+; regression Yest = b0 + b1*X calculates intercept b0 and slope b1
+(define (regression X Y)
+	(set 'b1 (div (cov X Y) (sum-d2 X)))
+	(set 'b0 (sub (mean Y) (mul b1 (mean X))))
+	(list b0 b1))
+
+; fitted line using regression Y on X
+(define (fit X Y, coeffs b0 b1)
+	(set 'coeffs (regression X Y))
+	(set 'b0 (first coeffs))
+	(set 'b1 (last coeffs))
+	(map (lambda (x) (add b0 (mul x b1))) X))
+
+; sum of squared differences of X and Y
+(define (sum-d2xy X Y)
+  (apply add (map (lambda (x y) (mul (sub x y) (sub x y))) X Y)))
+
+
+; moments of a vector of numbers
+;
+(define (moments vector, n median mean avg-dev std-dev var skew kurtosis dev sum)
+  (set 'n (length vector))
+
+  (set 'sum (apply add vector))
+  (set 'mean (div sum n))
+
+  (set 'avg-dev 0 'std-dev 0 'var 0 'skew 0 'kurtosis 0)
+
+  (set 'dev (map sub vector (dup mean n)))
+  (set 'avg-dev (div (apply add (map abs dev)) n))
+  (set 'var (div (apply add (map mul dev dev)) (- n 1)))
+  (set 'skew (apply add (map mul dev dev dev)))
+  (set 'kurtosis (apply add (map  mul dev dev dev dev)))
+
+  (set 'std-dev (sqrt var))
+
+  (if (> var 0.0)
+    (begin
+	(set 'skew (div skew (mul n var std-dev)))
+	(set 'kurtosis (sub (div kurtosis (mul n var var)) 3.0))))
+
+  (sort vector)
+  (set 'mid (/ n 2))
+
+  (if (= 0 (% n 2))
+	(set 'median (div (add (nth mid vector) (nth (- mid 1) vector)) 2))
+	(set 'median (nth mid vector)))
+
+  (list n median mean avg-dev std-dev var skew kurtosis)
+
+;  (println (format "n:                  %d" n))
+;  (println (format "median:             %f" median))
+;  (println (format "mean:               %f" mean))
+;  (println (format "average_deviation:  %f" avg-dev))
+;  (println (format "standard_deviation: %f" std-dev))
+;  (println (format "variance:           %f" var))
+;  (println (format "skew:               %f" skew))
+;  (println (format "kurtosis:           %f" kurtosis))
+)
+
+;-------------------------------- Time Series ----------------------------------
+
+; expontial smoothing with 0 < alpha <= 1
+(define (smooth lst alpha , previous slist)
+  (set 'previous (first lst))
+  (set 'slist '())
+  (dolist (elmnt lst) 
+   (set 'previous (add (mul alpha elmnt) (mul (sub 1 alpha) previous))) 
+   (push previous slist))
+  (reverse slist)) ; could be written shorter starting v.9.9.5
+                   ; because push returns the modified list
+
+;
+; seasonal difference list with variable lag
+; the resulting list is lag shorterm than the original
+;
+(define (lag lst n , sLst)
+	(set 'sLst lst)
+	(dotimes (i n) (pop lst))
+	(set 'sLst (slice sLst 0 (length lst)))
+	(map sub lst sLst))
+
+
+;
+; cumulate of a list
+;
+(define (cumulate lst , sc cum)
+	(set 'sc 0.0)
+	(set 'cum '())
+	(dolist (x lst)
+		(push (inc sc x) cum))
+	(reverse cum)) ; could be written shorter after 9.9.5
+	               ; because push returns the list
+
+;
+; power spectrum
+;
+; takes a rows by 2 columns matrix with real part in the first and 
+; imagenary part the in the second column. If all numbers are real
+; then the second column is just 0's.
+;
+; returns a matrix with two rows. First row contains power numbers
+; and second row contains the respective frequencies
+;
+
+(define (power ts , lenOrg fts n n2 ps mid frqs)
+	; remember original length
+	(set 'lenOrg (length ts))
+	; do discrete fourier transform
+	(set 'fts (transpose (fft ts)))
+	; calc power spectrum 
+	(set 'n (length (transpose fts)))
+	(set 'n2 (mul n n))
+	(set 'ps (map (lambda (x y) (add (mul x x) (mul y y))) (nth 0 fts) (nth 1 fts)))
+	(set 'ps (map (lambda (x) (mul (div x n2) 2)) ps))
+	; the first and last are not multiplied by 2, divide them back
+	; use deprecated nth-set in versions older than 9.9.02
+	(setf (ps 0) (div (first ps) 2))
+	(set 'mid (sub (div n 2) 1))
+	(replace mid ps (div (nth mid ps) 2))
+	; calc a vector with frequencies, adjusted for the new power-2 length
+	; which came back from the FFT
+	(set 'frqs (sequence 0 (- n 1)))
+	(set 'frqs (map (lambda (x) (mul (div x n) lenOrg)) frqs))
+	(transpose (matrix ps frqs)))
+
+
+
+;------------------------- multivariate statistics -----------------------------
+
+;
+; multiple regression of variables in X onto one of variables in X, Y
+; indicated by column offset offY
+; 
+; X is N rows by k columns, the column at offset offY is Y
+;
+; returns a matrix with two rows:
+; first row is regression coefficients and multiple R: b0, b1, b2 ....., R
+; second row is sum of squares: regression-SQ, error-SQ, total-SQ
+; (the unused part of the second row is <tt>nil</tt> padded)
+;
+; the SQs can be used to calculate mean sqares for regression and error:
+;
+; regression-MSQ = regression-SQ / (k - 1)
+; error-MSQ = error-sq / (n - k - 1)
+;
+; F-ratio = regression-MSQ / error-MSQ  
+; with k and (n - k - 1) df degreees of freedom
+;
+;
+;
+;
+(define (multiple-reg X offY ,  Y Ycoffs b b0 R2 Yest sqErr sqTotal sqReg sq d)
+	(set 'covX (cov-matrix X))
+	(set 'Y (extract-col X offY))
+	; covX is the covariance matrix
+	(pop covX offY)
+	(set 'cvX (transpose covX))
+	; the covariance matrix is reduced to cvX and the
+	; extracted values put in Ycoffs
+	(set 'Ycoffs (matrix (pop cvX offY)))
+	; b contains the regression coefficients except for b0
+	(set 'b (multiply (invert cvX) Ycoffs))
+	; calculate multiple R2 as b'*b / sqTotal
+	(set 'sqTotal (sum-d2 Y))
+	(set 'R2 (div (first (first (multiply (transpose b) Ycoffs))) sqTotal))
+	; estimate Y without b0
+	(set 'Yest (multiply (reduce-col X offY) b))
+	; calculate b0, d is the difference between Y and the Y estimate
+	; b0 is the mean of differences between Y and Yest
+	(set 'd (mat-map sub (matrix Y) Yest))
+	(set 'b0 (mean (first (transpose d))))
+	; estimate Y including b0
+	(set 'Yest (mat-map add Yest (matrix (dup b0 (length Yest)))))
+	; error sum of squares
+	(set 'sqErr (sum-d2xy Y (first (transpose Yest))))
+	; regression sum of squares
+	(set 'sqReg (sub sqTotal sqErr))
+	; make list b out of b0, b1, b2 ... sqrt(R2)
+	(set 'b (append (list b0) (first (transpose b)) (list (sqrt R2))))
+	; make list sq out of sqReg, sqErr and sqTotal
+	(set 'sq (list sqReg sqErr sqTotal))
+	; return matrix with two rows:
+	(transpose (matrix b sq)))
+
+
+
+;
+; covariance matrix cov 
+; 
+; matrix x with N rows and k columns
+; 
+;
+(define (cov-matrix X , XtX N I sumX sumX2)
+	(set 'XtX (multiply (transpose X) X)) 
+	(set 'N (length X))
+	(set 'I (matrix (dup 1 N)))
+	(set 'sumX (multiply (transpose X) I)) 
+	(set 'sumX2 (multiply sumX (transpose sumX)))  
+	(set 'sumX2 (multiply sumX2 (diagonal (div 1 N) (length sumX2))))
+	(mat-map sub XtX sumX2))
+
+
+;
+; correlation matrix
+;
+; matrix X with N rows and k columns
+;
+;
+(define (corr-matrix X , covX N d dd)
+	(set 'covX (cov-matrix X))
+	(set 'd (matrix (get-diagonal covX)))
+	(set 'dd (multiply d (transpose d)))
+	(set 'dd (map (lambda (z) (map sqrt z)) dd))
+	(mat-map div covX dd))
+
+	
+;
+; probablity of F variance ratio with degrees of freedom df1 df2
+;
+; 
+(define (f-prob F df1 df2)
+  (let (prob (mul 2 (betai (div df2 (add df2 (mul df1 F))) 
+                           (mul 0.5 df2) 
+                           (mul 0.5 df1)))) 
+   (div (if (> prob 1) (sub 2 prob) prob) 2)))	
+
+;----------------------------- utility functions -------------------------------
+
+;
+; make a matrix from 1 up to 16 lists
+;
+(define (matrix)
+	(transpose (args)))
+
+
+;
+; make a diagonal matrix n by n and elmnt in the diagonal
+; 
+;
+(define (diagonal elmnt n, m lst)
+	(set 'm '())
+	(dotimes (i n)
+		(set 'lst (dup 0 n))
+		; use deprecated nth-set in versions older than 9.9.02
+		(if (< (sys-info -2) 9902)
+			(nth-set (lst i) elmnt)
+			(setf (lst i) elmnt))
+		(push lst m))
+	(reverse m)) ; make shorter starting v.9.9.5
+		
+;
+; get the diagonal from a square matrix
+;
+(define (get-diagonal X , d x)
+	(set 'd '())
+	(dotimes (idx (length X))
+		(push (nth idx (nth idx X)) d))
+	(reverse d))
+
+;
+; matrix map
+;
+; e.g.: (mat-map sub A B) ;; for matrix subtraction
+;
+(define (mat-map op A B)
+	(map (lambda (x y) (map op x y)) A B))
+
+;
+; reduce matrix by a column at offset
+;
+; returns the reduced matrix
+;
+(define (reduce-col matr off, X)
+	(set 'matr (transpose matr))
+	(pop matr off)
+	(transpose matr))
+
+;
+; extract a column from a matrix
+;
+; returns the extracted column
+;
+(define (extract-col matr off, X)
+	(pop (transpose matr) off))
+
+;
+; convert list to ascii lines terminated by CR-LF
+; for storage in files usable by Gnuplot, R, Excel etc.
+;
+; example: 
+;
+; (write-file "MyData.txt" (list2ascii mydata-list))
+;
+(define (list2ascii lst)
+	(append (join (map string lst) "\r\n") "\r\n"))
+
+; eof
+
+
diff --git a/modules/unix.lsp b/modules/unix.lsp
new file mode 100644
index 0000000..07de71e
--- /dev/null
+++ b/modules/unix.lsp
@@ -0,0 +1,239 @@
+;; @module unix.lsp
+;; @description Interface to various UNIX libc functions
+;; @version 0.1 alpha - mostly untested
+;; @version 0.2 alpha - eliminated getpid and getppid, included in 'sys-info'
+;; @version 0.3 alpha - added diferent libc.so library path for UBUNTU 9.04
+;; @version 0.4 alpha - take care of overwrite protection of imports in ffilib versions
+;; @version 0.5 alpha - precautions for multiple load of module because of overwritten symbols
+;; @version 0.6 alpha - libc library path for Linux UBUNTU
+;; @version 0.71 alpha - libc library path for several OS
+;; @author L.M. 2006-Sep-12, 2012, 2013 lutz@nuevatec.com
+;; 
+;;
+;; <h2>UNIX libc function support</h2>
+;; To use this module include the following line at the beginning of
+;; the program file:
+;; <pre>
+;; (load "/usr/share/newlisp/modules/unix.lsp")
+;; ; or shorter
+;; (module "unix.lsp")
+;; </pre>
+;; All functions are named like the UNIX functions they implelement but with
+;; the unix: namespace prefix. All functions work similar to the UNIX libc functions
+;; they implement but return 'nil' instead of '-1' for failure and 'true' instead
+;; of 0 for success. Note that in the implementaion most parameter types are casted
+;; even though redundant in most situation. The addional cast avoids segfaulting
+;; of the imported functions when supplied with wrong parameter types, i.e. for strings.
+;; Some times the 'int' cast is used to supply default values of an argument, in case
+;; the argument is not given.
+;;
+;; The arguments are given in, is the order used by the equivalent libc functions, not
+;; the order as used by shell  commandline utilities with the same name.
+;;
+;; Some of the wordings from functions descriptions are taken from BSD man pages.
+;;
+;; This module contains wrappers for the following libc functions:
+;; 'getuid', 'geteuid', 'getgid', 'getegid', 
+;; 'setuid', 'seteuid', 'setgid', 'setegid',
+;; 'kill', 'chmod', 'ioctl', 'mkfifo', 'mltemp', 'syslog'
+
+(context 'unix)
+
+(set 'files (list
+    "/usr/lib/libc.dylib" ; MacOS/Darwin
+    "/usr/lib/libc.so.51.0" ; OpenBSD 4.6
+    "/lib/x86_64-linux-gnu/libc.so.6" ; Ubuntu 12.04 LTS
+    "/lib/i386-linux-gnu/libc.so.6" ; UBUNTU Linux
+    "/lib/i686-linux-gnu/libc.so.6" ; UBUNTU Linux
+    "/lib64/libc.so.6" ; CentOS 6.x
+    "/lib/libc.so.6" ; UBUNTU Linux 9.04
+    "/usr/lib/libc.so" ; Linux, BSD, Solaris
+))
+
+(set 'library (files (or
+		       (find true (map file? files))
+		       (throw-error "cannot find standard C library (libc)"))))
+
+
+(unless module-is-loaded
+    (import library "getuid")
+    (import library "geteuid")
+    (import library "getgid")
+    (import library "getegid")
+    (set '_setuid (import library "setuid"))
+    (set '_seteuid (import library "seteuid"))
+    (set '_setegid (import library "setegid"))
+    (set '_setgid (import library "setgid"))
+    (set '_kill (import library "kill"))
+    (set '_chmod (import library "chmod"))
+    (set '_ioctl (import library "ioctl"))
+    (set '_mkfifo (import library "mkfifo"))
+    (set '_mktemp (import library "mktemp"))
+    (set '_syslog (import library "syslog"))
+    (set 'module-is-loaded true)
+)
+
+;; @syntax (unix:getuid)
+;; @return Returns the real and effective user ID
+
+;; @syntax (unix:geteuid)
+;; @return Returns the effective user ID
+
+;; @syntax (unix:getgid)
+;; @return Returns the real group ID.
+
+;; @syntax (unix:getegid)
+;; @return Returns the effective group ID
+
+;; @syntax (unix:setuid <num-id>)
+;; @param <num-id> The number of the real and effective user IDs to set.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Set the real and effective user IDs.
+;; If no argument or the argument given is not a number then sets
+;; current real and effective user IDs.
+
+(constant 'setuid  (lambda (id)
+	(zero? (_setuid (int id (getuid))))
+))
+
+;; @syntax (unix:seteuid <num-id>)
+;; @param <num-id> The number of the effective user ID to set.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Sets the effective user ID.
+;; If no argument or the argument given is not a number then sets
+;; current effective user ID.
+;;
+
+(constant 'seteuid (lambda (id)
+	(zero? (_seteuid (int id (geteuid))))
+))
+
+;; @syntax (unix:setgid <num-id>)
+;; @param <num-id> The number of the real and effective group ID to set.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Sets the real and effective group IDs.
+;; If no argument or the argument given is not a number then sets
+;; current real and effective group IDs.
+
+(constant 'setgid (lambda (id)
+	(zero? (_setgid (int id (getgid))))
+))
+
+;; @syntax (unix:setegid <num-id>)
+;; @param <num-id> the number of the effective group ID to set.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Sets the effective group ID.
+;; If no argument or the argument given is not a number then sets
+;; current effective group ID.
+
+(constant 'setegid (lambda (id)
+	(zero? (_setegid (int id (getegid))))
+))
+
+;; @syntax (unix:kill <num-pid> <num-sig>)
+;; @param <num-pid> The process ID of the process to send a signal to.
+;; @param <num-sig> The signal to send to the process in <num-pid>
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Send a signal to a process.
+;; If no argument is given for <num-sig> or <num-sig> is zero, then
+;; the validiy of the <num-pid> is checked and 'nil' is returned for
+;; an invalid <num-pid>.
+;; Note that kill works has parameters backwards compared to the
+;; kill used in on the shell command line. '(unix:kill ...)' works
+;; like the libc 'kill()' counterpart.
+
+(constant 'kill (lambda (pid sig)
+	(zero? (_kill (int pid 0) (int sig 0)))
+))
+
+;; @example
+;; (unix:kill 2652 9)
+
+;; Sends the 'SIGKILL' signal 9 to process ID '2652'
+
+;; @syntax (unix:chmod <str-path> <num-mode>)
+;; @param <str-path> The path name of the file or directory
+;; @param <num-option> The permission pattern as a number
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Sets the permission pattern for a UNIX filesystem node. The
+;; pattern is best given as an octal number, i.e.: '0755' for 
+;; a -rwxr-xr-x permission pattern, '0644' for '-rw-r--r--' etc.
+;; If no <int-option> is given unix:chmod assumes '0644'.
+
+(constant 'chmod (lambda (file-path option)
+	(zero? (_chmod (string file-path) (int option 0644)))
+))
+
+;; @example
+;; (unix:chmod "myfile.txt" 0644)
+
+;; Gives '-rw-r--r--' permission to the file 'myfile.txt'
+
+;; @syntax (unix:ioctl <num-id> <num-request> <str-argp>)
+;; @param <num-id> A number for file descriptor.
+;; @param <num-request> A number for a request.
+;; @param <str-argp> An argument string.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Manipulates the underlying device parameters of special
+;; files.
+;;
+
+(constant 'ioctl (lambda (id request argp)
+	(zero? (_ioctl (int id 0) (int request 0) (string argp)))
+))
+
+;; @syntax (unix:mkfifo <str-path> <num-mode>)
+;; @param <str-path> The path  of the new fifo filename.
+;; @param <num-mode> The persmissions mode number.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; Creates a new fifo file with name path.  The access permissions
+;; are specified by mode and restricted by the 'umask(2)' of the calling
+;; process.
+
+(constant 'mkfifo (lambda (file-path mode)
+	(zero? (_mkfifo (string file-path) (int mode)))
+))
+
+;; @example
+;; (unix:mkfifo "myfifo" 0755)
+
+;; This will create a fifo node with 'prwxr-xr-x' permissions
+
+;; @syntax (unix:mktemp <str-template>)
+;; @param <str-template> A file template with Xs appended, i.e. '/tmp/temp.XXXX'.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; The function takes the given file name template and overwrites a
+;; portion of it to create a file name.  This file name is guaranteed not to
+;; exist at the time of function invocation and is suitable for use by the
+;; application.  The template may be any file name with some number of 'X's
+;; appended to it, for example '/tmp/temp.XXXXXX'.  The trailing 'X's are
+;; replaced with a unique alphanumeric combination.
+
+(constant 'mktemp (lambda (template)
+	(zero? (_mktemp (string template)))
+))
+
+;; @syntax (unix:syslog <num-priority> <str-message> ...)
+;; @param <num-priority> The priority of the message.
+;; @param <str-message> The message string and template in printf format.
+;; @return Returns 'true' or 'nil' depending on success
+;;
+;; The function writes message to the system message logger.  The
+;; message is then written to the system console, log files, logged-in
+;; users, or forwarded to other machines as appropriate.
+
+(constant 'syslog (lambda (priority message)
+	(zero? (_syslog (int priority 0) (string message)))
+))
+
+; eof
+
diff --git a/modules/xmlrpc-client.lsp b/modules/xmlrpc-client.lsp
new file mode 100644
index 0000000..0e8f38e
--- /dev/null
+++ b/modules/xmlrpc-client.lsp
@@ -0,0 +1,236 @@
+;; @module xmlrpc-client.lsp 
+;; @description XMLRPC protocol client routines
+;; @version 0.3 - comments redone for automatic documentation
+;; @version 0.4 - multiple indices with <tt>nth</tt> redone to be compatible with future versions
+;; @version 0.5 - doc changes
+;; @version 0.6 - fixed bug in error handler
+;; @version 0.61 - fixed doc typo
+;; @version 0.7 - check for valid list type in (get-value expr) thanks Kosh
+;; @version 0.8 - changed references to /usr/ to /usr/local/
+;; @version 0.9 - make system.listMethods more flexible for no of args - thanks Ofoe
+;; @author Lutz Mueller 2005-2011, Kosh 2012, Oofoe 2016
+;;
+;; <h2>Functions for XML-RPC client</h2>
+;; To use this module include a 'load' statement at the beginning of the program:
+;; <pre>
+;; (load "/usr/local/share/newlisp/modules/xmlrpc-client.lsp")
+;; ; or shorter
+;; (module "xmlrpc-client.lsp")
+;; </pre>
+;; The script 'xmlrpc.cgi' implements a method 'newLISP.evalString'. This  module contains 
+;; a client side function for this method for testing purposes. The file 'xmlrpc.cgi'
+;; can be found in the 'example' directory of the newLISP source distribution.
+;; 
+;; For further information on XML-RPC consult 
+;; @link http://www.xmlrpc.com/ http://www.xmlrpc.com/ .
+;;
+;; Whenever a connection could be made, method functions will return a response
+;; formatted by the XML-RPC server in XML. If a connection failed the function will
+;; return 'nil' and a call to '(XMLRPC:error)' will return an error text.
+;;
+;; If the XML received cannot be parsed into SXML, the function returns 'nil'
+;; and '(XMLRPC:error)' will return an XML error. SXML is XML transformed into
+;; LISP S-expressions.
+
+;; If the XML received is syntactically correct but not correctly formatted,
+;; XML garbage is returned or 'nil' is returned and an error message in 
+;; '(XMLRPC:error)'.
+
+;; @syntax (XMLRPC:system.listMethods <str-url>)                    
+;; @param <str-url> The URL of the XML-RPC server
+;; @return A list of methods supported.
+;; The server at <url> returns a list of methods supported.
+
+;; @syntax (XMLRPC:system.methodHelp <str-url> <str-method-name>)        
+;; @param <str-url> The URL of the XML-RPC server.
+;; @param <method-name> The name of the method to get help for.
+;; @return Help for <str-method-name>
+;; The server at <str-url> returns help for the method in <str-method-name>
+
+;; @syntax (XMLRPC:system.methodSignatures <str-url> <str-method-name>) 
+;; @param <str-url> The URL of the XML-RPC server.
+;; @param <method-name> The name of the method to get the signature for.
+;; @return The signature for a server method.
+;; Gets the calling parameter conventions (signature) for a method
+;; <method-name> at <str-url>.
+
+;; @syntax (XMLRPC:execute <str-url> <str-xml-request>)
+;; @param <str-url> The URL of the XML-RPC server.
+;; @param <str-xml-request> A XML formatted request.
+;; @return XML formatted server response
+;; This is a generic method for making XML-RPC requests.
+;; The request must be XML formatted correctly by the sender (client).
+
+
+;; @syntax (XMLRPC:newLISP.evalString <str-url> <str-expression>)
+;; @param <str-url> The URL of the XML-RPC server.
+;; @param <str-expression> The expresssion to be evaluated in a string.
+;; @return The result of the expression evaluation.
+;; The expression in <str-expression> is encoded in base64 and then
+;; transmitted to the remote server.
+
+;; @syntax (XMLRPC:error)
+;; @return Error text of last error occured.
+
+(context 'XMLRPC)
+
+(set 'request
+[text]<?xml version="1.0"?>
+<methodCall>
+   <methodName>%s</methodName>
+   <params>
+      <param>
+         <value>%s</value>
+       </param>
+    </params>
+</methodCall>
+[/text])
+
+(set 'error-msg "")
+
+
+######### extract value(s) from XML-RPC response XML with <params> #############
+
+; get result data from result structure
+;
+(define (get-result-data xml)
+    (if (starts-with xml "ERR:") 
+        (begin
+            (set 'error-msg xml)
+            (throw nil)))
+    (xml-type-tags nil nil nil nil)
+    (set 'sxml (xml-parse xml (+ 1 2 4)))   
+    (if (not sxml) (throw (format "XML error: %s" (first (xml-error)))))
+
+    (if (match '(("methodResponse" ("fault" *))) sxml) 
+        (begin
+            (set 'error-msg 
+                (let (fault (sxml 0 1 1 1 1 2 1 1) 
+                      text (sxml 0 1 1 1 2 2 1 1))
+                     (append "Fault " fault ": " text)))
+                (throw nil)))
+
+    (get-value (sxml 0 1 1 1)))
+   
+
+; get contents from expr = (value ...)
+;
+(define (get-value expr)
+    (if 
+        (empty? expr) nil
+        
+        (list? (expr 1))
+        (case (expr 1 0)
+            ("i4" (int (expr 1 1)))
+            ("int" (int (expr 1 1)))
+            ("boolean" (if (= "0" (expr 1 1) ) nil true))
+            ("double" (float (expr 1 1)))
+            ("base64" (base64-dec (expr 1 1)))
+            ("dateTime.iso8601" (expr 1 1))
+            ("array" (if (= (expr 1) "array") 
+                         "array" ;; if untagged string "array"
+                         (get-array (rest (expr 1 1)))) )
+            ("struct" (get-struct (rest (expr 1))))
+            ("string" (expr 1 1))
+            (true (expr 1))
+        ) ; end case
+        
+        true (string (expr 1))
+    ) ; end if
+) 
+
+; get contents from expr = ((value ...) (value ...) ...)
+;
+(define (get-array expr)
+    (if (empty? expr) 
+        '()
+        (cons (get-value (first expr)) (get-array (rest expr)))))
+
+
+; get contents from expr = ((member ...) (member) ...)
+;
+(define (get-struct expr)
+    (if (empty? expr)
+        '()
+        (cons (get-member (first expr)) (get-struct (rest expr)))))
+
+
+; get contents from expr = (member ...)
+;
+(define (get-member expr)
+    (list (expr 1 1)  (get-value (last expr))))
+
+
+################################ standard system methods #######################
+
+# convert to SXML
+(xml-type-tags nil nil nil nil)
+
+# ( method /arg.../ -- XML) Compose XML request.
+(define (format-request method)
+  (let ((xml (format
+             "<?xml version=\"1.0\"?><methodCall><methodName>%s</methodName><params>"
+             method)))
+    (dolist (value (args))
+      (push (format "<param><value>%s</value></param>" value) xml -1))
+    (push "</params></methodCall>\n" xml -1)))
+
+# return method names in a list of strings
+#
+# (XMLRPC:system.listMethods <url>)  
+#
+(define (system.listMethods url)
+    (execute url (format-request "system.listMethods")))
+
+# get help for a methodName at url
+# return help in a string
+#
+# (XMLRPC:system.methodHelp <url> <method-name) 
+#
+(define (system.methodHelp url methodName)
+    (execute url (format request "system.methodHelp" methodName) ))
+
+
+# get method signatures of methodName at url
+# return ans array of strings
+#
+# (XMLRPC:system.methodSignatures <url> <method-name>) 
+#
+(define (system.methodSignature url methodName)
+    (execute url (format request "system.methodSignature" methodName) ))
+
+
+(define (error) error-msg)
+
+
+# Execute a method on url with XML formatted request
+#
+# This is a generic method, but with XML formatted by caller.
+#
+# (XMLRPC:execute <url> <xml-request>)
+#
+(define (execute url parameter-XML)
+    (if (not (catch (begin
+        (set 'error-msg "")
+        (set 'xml (post-url url parameter-XML "text/xml"))
+        (get-result-data xml)) 'result))
+
+        (begin (set 'error-msg "Wrong format in XML-RPC") nil)
+        result))
+
+######################### newLISP XML-RPC specific methods #####################
+
+# evaluate a newLISP expression in str at newLISP XML-RPC server at url
+# return evaluation result in a string 
+#
+
+(define (newLISP.evalString url str)
+    (execute url 
+        (format request 
+                "newLISP.evalString" (append "<base64>" (base64-enc str) "</base64>")))
+)
+
+(context MAIN)
+
+# eof
+
diff --git a/modules/zlib.lsp b/modules/zlib.lsp
new file mode 100644
index 0000000..5ab53d9
--- /dev/null
+++ b/modules/zlib.lsp
@@ -0,0 +1,92 @@
+;; @module zlib.lsp
+;; @description Functions for compression/decompression with zlib
+;; @version 1.1 - comments redone for automatic documentation
+;; @version 1.2 - new library detection routine
+;; @version 1.3 - added lib for opnBSD and tested for 64-bit newLISP
+;; @version 1.4 - doc changes
+;; @version 1.5 - replaced <tt>write-buffer</tt> with <tt>write</tt>
+;; @version 1.6 - removed broken <tt>squeeze</tt> and <tt>unsqueeze</tt> functions.
+;; @version 1.7 - added library for CentOS 6 Linux
+;; @version 1.71 - added library for Ubuntu Linux 12.04 and 13.04
+;; @version 1.72 - swap else-less 'if' for 'when'
+;; @version 1.73 changes references to /usr/ to /usr/local/
+;; @author L.M 2006-2013
+;; <h3>Functions for compression/decompression with zlib</h3> 
+;; For this module a platform sepcific library
+;; from @link http://www.zlib.net/ www.zib.net is needed.
+;;
+;; The module offers two compression/decompression support as
+;; GZ compatible file compression and decompression.
+;; 
+;; Before using the module it must be loaded:
+;; <pre>
+;; (load "/usr/local/share/newlisp/modules/zlib.lsp")
+;; ; or shorter
+;; (module "zlib.lsp")
+;; </pre>
+
+(when (< (sys-info -2) 10110)
+	(constant (global 'write) write-buffer))
+
+(context 'zlib)
+
+(set 'files '(
+    "/lib/i386-linux-gnu/libz.so.1" ; Ubuntu 13.04
+    "/usr/lib/x86_64-linux-gnu/libz.so" ; Ubuntu 12.04 LTS
+    "/usr/lib/libz.so" ; Linux, BSD, Solaris
+    "/usr/lib/libz.so.4.1" ; OpenBSD 4.6
+    "/usr/lib64/libz.so" ; for 64Bit CentOS 6 Linux
+    "/usr/lib/libz.dylib" ; Mac OSX / Darwin
+    "libz1.dll" ; MS Windows 
+))
+
+(set 'library (files (or
+    (find true (map file? files))
+    (throw-error "cannot find zlib compression library"))))
+
+(import library "compress")
+(import library "uncompress")
+(import library "gzopen")
+(import library "gzread")
+(import library "gzclose")
+(import library "gzwrite")
+
+;; @syntax (zlib:gz-read-file <str-file-name>)
+;; @return A string buffer with the original contents.
+;;
+;; Uncompresses the GZ compressed file in <str-file-name>.
+;; @example
+;; (set 'buff (zlib:gz-read-file "myfile.gz"))
+
+(define (gz-read-file file-name)
+    (let (  (fno (gzopen file-name "rb"))
+            (buff (dup "\000" 0x1000))
+            (result ""))
+        (when (!= fno 0)
+            (while (> (set 'bytes (gzread fno buff 0x1000)) 0)
+            (write result buff bytes))
+            (gzclose fno)
+            result)
+))
+
+;; @syntax (zlib:gz-write-file <str-file-name> <str-buffer>)
+;; @return The number of bytes in <str-buffer>.
+;;
+;; Does a GZ compatible comrpression of a buffer in <str-buffer> and
+;; writes it to the file in <str-file-name>.
+;; @example
+;; (zlib:gz-write-file "myfile.gz" buff) 
+
+(define (gz-write-file file-name buff)
+    (let (  (fno (gzopen file-name "wb"))
+            (result nil))
+        (when (!= fno 0)	
+            (set 'result (gzwrite fno buff (length buff)))
+            (gzclose fno)
+            result)
+))
+	
+(context MAIN) 
+
+; eof
+
diff --git a/newlisp-js/README.html b/newlisp-js/README.html
new file mode 100644
index 0000000..db6b55b
--- /dev/null
+++ b/newlisp-js/README.html
@@ -0,0 +1,370 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+   <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+   <meta name="author" content="Lutz Mueller"/>
+   <meta name="keywords" 
+         content="newLISP LISP SCHEME programming language manual reference Artificial Intelligence AI NUEVATEC"/>
+   <meta name="description" content="Info newLISP in a web browser"/>
+   <title>Info about newLISP in a web browser</title>
+
+<style type="text/css" media="screen">
+
+<!--
+
+.title {
+    font-family:Optima, Georgia, Times New Roman, Times, serif; 
+    font-size:300%;
+    font-weight: 500;
+	color: #404040;
+    }
+
+.footer {
+   text-align: center;
+   margin: 0 10%;
+   max-width: 752px;
+   font-family: Helvetica, Verdanan, Arial, sans-serif;
+   font-size: 10px;
+   line-height: 12px;
+ }
+
+body, h4, p {
+    font-family: Lucida Sans, Helvetica, sans-serif;
+    line-height: 120%;
+    max-width: 752px;
+	}
+
+h1, h2, h3 {
+	margin-top: 3%;
+    font-family: Helvetica, Lucida Sans sans-serif;
+    line-height: 120%;
+	color: #404040;
+    }
+
+table {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: solid;
+	border-width: 0px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+	font-size: 95%;
+    }
+    
+th {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #eeeeee;
+    font-size: 100%;
+    }
+    
+td {
+	border-style: solid;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 3px;
+	background: #f8ffff;
+    font-size: 100%;
+    }
+    
+pre {
+	margin: 0px;
+	margin-left: 10px;
+	margin-right: 10px;
+	border-style: dashed;
+	border-width: 1px;
+	border-color: #888888;
+	padding: 4px;
+    font-family: Andale Mono, Monaco, Courier;
+    font-size: 100%;
+	background: #f8ffff;
+    }
+
+tt {
+    font-family: Andale Mono, Monaco, Courier;
+    font-size: 100%;
+    }
+    
+-->
+</style>
+</head>
+<body style="margin: 0 auto;" text="#000000" bgcolor="#FFFFFF" link="#376590" vlink="#551A8B" alink="#ffAA28">
+
+<h2>What is 'newLISP in a web browser'&nbsp <font size=-1>last edited 2011-11-28</font></h2>
+
+<p>newLISP can be compiled to JavaScript and then run in a web browser like any other JavaScript program.
+<tt>newlisp-js-lib.js</tt> is newLISP compiled to a JavaScript library using the Emscripten SDK tool chain:</p>
+
+<blockquote>
+<p><a href="http://kripken.github.io/emscripten-site/">http://kripken.github.io/emscripten-site/</a></p>
+</blockquote>
+
+<p>This application implements an editor and development environment (IDE) for 
+newLISP, HTML and JavaScript code. Any other Application could be built this way.
+To run newLISP code from JavaSript a <tt>newlispEvalStr(<em>string</em>)</tt> 
+JavaScript function is available after loading the <tt>newlisp-js-lib.js</tt> 
+library and using a line of JavaScript to import this function.</p>
+
+<p>Likewise newLISP can call back into JavaScript code using the 
+<tt>(eval-string-js <em>string</em>)</tt> function. Both languages can be hosted 
+by an HTML page.</p>
+
+<p>The <a href="app.html">app.html</a> demo file shows how to do this. Everything 
+necessary to write your own application is contained in a 3k part of this file. 
+Only <tt>app.html</tt> and the <tt>newlisp-js-lib.js</tt> library are required 
+to run this newLISP application client-side in a web browser.</p>
+
+<!--
+<p>For a tutorial in to the basics of newLISP type <tt>(load "newlisp-js/tutorial.lsp")</tt>
+in to the editor then click the <tt>eval</tt> button. This tutorial is best 
+used in two-column layout and copies some material from the WikiBooks tutorial:
+<a href="http://en.wikibooks.org/wiki/Introduction_to_newLISP">Introduction to newLISP</a>.</p>
+-->
+<p>The editor control with syntax highlighting and themes is from the CodeMirror
+project at: <a href="http://codemirror.net/">codemirror.net/</a>.</p>
+
+<p>An alternative <a href="simple.html">simple editor</a> without synytax highlighting,
+but with parenthesis matching, has no external dependencies.</p>
+
+<h2>Installation</h2>
+
+<p>Download and unzip the <a href="http://www.newlisp.org/newlisp-js/newlisp-js-10.6.3.zip">
+newlisp-js-10.6.3.zip</a>  package in the document directory of a web server or do
+a serverless installation on an individual computer and load the <tt>index.html</tt>
+file directly into your web browser. This file contains the editor.</p>
+
+<p>When running on a webserver, the <tt>newlisp-js-lib.js</tt> library can be 
+compressed to a <tt>.gz</tt> file for faster delivery. Compress using the Unix 
+<tt>gzip</tt> or other zip compression utilities. Full HTTP 1.1 webserver 
+installations can serve these files and they are automatically decompressed by 
+most web browsers. The compressed <tt>newlisp-js-lib.js.gz</tt> is only about 200K
+in size. When using a compressed library, the library name in <tt>index.html</tt> 
+and <tt>app.html</tt> has to be changed to reflect the name change of 
+<tt>newlisp-js-lib.js</tt>. There is only one place at the end of the file where 
+<tt>.gz</tt> has to be appended to the library name.</p>
+
+<p>The CodeMirror editor library <tt>codemirror/lib/codemirror.js</tt> can
+also be compressed and is only referenced at the beginning of <tt>index.html</tt>.
+</p>
+
+<h2>How to use 'newLISP in a web browser'</h2>
+
+<p>Wait for "Downloading ..." to finish. newLISP expressions can now be entered in
+the editor input window and be evaluated pushing the red <tt>eval</tt> button.
+Output is shown in the log window.</p>
+
+<p>The editor can also be used to edit JavaScript content or HTML content. The
+red <tt>JS</tt> button will evaluate JavaScript content and the red <tt>HTML</tt>
+button will open a page in a new browser tab containing the rendered HTML.
+Code from all three languages can be mixed on the same oage and interact with each
+other.</p>
+
+<h4>Buttons on top and keyboard short-cuts:</h4>
+<ul>
+<li><tt>eval</tt> - evaluates newLISP source in edit box (Ctrl-enter)</li>
+<li><tt>silent</tt> - evaluates newLISP source in edit box silently (Shift-Ctrl-enter)</li>
+<li><tt>JS</tt> - evaluates JavaScript in  edit box</li>
+<li><tt>htlml</tt> - opens a new tab with HTML from the editor</li>
+<li><tt>x-edit</tt> - clears the editor box (Ctrl-L)</li>
+<li><tt>x-log</tt> - clears log box (Shift-Ctrl-L)</li>
+<li><tt>layout</tt> - switches between three layouts</li>
+<li><tt>#</tt> - toggle line numbers on / off - (Ctrl-1)</li>
+<li><tt>theme</tt> - switches between seven color themes</li>
+<li><tt>info</tt> - shows this page in a new browser tab</li>
+<li><tt>doc</tt> - shows and searches the reference manual</li>
+<li><tt><font size="+1">&#8635;</font></tt> - reload newLISP and local browser storage (Ctrl-R)</li>
+</ul>
+
+<p>The <tt>eval</tt> button will show all  top-level return values in the log
+window. The <tt>silent</tt> button only shows text output by <tt>print</tt> 
+or <tt>println</tt> or other functions writing to standard out.</p>
+
+<p><tt>htlml</tt> is the preferred button for web development, as HTML,
+JavaScript and newLISP source can be mixed on the same page (see 
+<a href="app.html">app.html</a> demo as an example.</p>
+
+<p>Different themes set by the <tt>theme</tt> button also change the
+way matching parentheses are shown.</p>
+
+<p>The input box to the right of the <tt>doc</tt> button can be either filled
+manually using the keyboard or a text selection can be made anywhere in the editor
+or log box. On computer devicers with a mouse, the text gets put into the 
+search box on mouse-up. On mobile touch devices the selecton must be copy/pasted
+manually.</p>
+
+<h4>Buttons at the bottom and keyboard short-cuts:</h4>
+<ul>
+<li><tt>save</tt> - save edit box content to browser local storage (Ctrl-S)</li>
+<li><tt>open</tt> - load edit content from a file on the local file system (Ctrl-O)</li>
+</ul>
+
+<p>The <tt>save</tt> button saves the current edit content to the 
+local storage system of the browser. On startup this content will be restored 
+automatically. This storage is owned by the inidividual browser (IE, Firefox, 
+Chrome, Safari, Opera). There are no browser cookies set and no internet 
+connection is necessary for this private storage. For saving files to the local
+file system <em>copy</em> and <em>paste</em> must be used to transfer files 
+out of the browser.</p>
+
+<p>The <tt>save</tt> button also saves the layout and color theme.</p>
+
+<p>The <tt>open file</tt> button is disabled on mobile devices.</p>
+
+<p>Note, that all browser local storage is tied to the domain from which the
+editor is loaded. Allthough storage is local to your device, the same content
+can only be accessed using the editor from the same internet domain location.
+If using Firefox, distinction is also made for different places on the local
+disk. Safari and Chrome don't forget local storage even if the browser gets
+shut down and the editor was loaded from a remote site. Firefox behavior is
+different in this respect depending on the platform it is running on.</p>
+
+<p>Red buttons delete or replace existing content. Blue buttons act on 
+content in the edit box. <tt>x-edit</tt>, <tt>x-log</tt> and <tt>open</tt>
+can be undone using <tt>Ctrl-Z</tt> or <tt>Command-Z</tt> on Mac OS X.
+<tt><font size="+1">&#8635;</font></tt> cannot be undone.</p>
+
+
+<h4>Keyboard commands without buttons</h4>
+
+<p>In the editor <tt>Alt-up/down</tt> or <tt>Option-up/down</tt> moves the current
+line or all lines in a selection. Select with a mouse or <tt>Shift-right/down</tt>.
+</p>
+
+<p>Fontsize can be adjusted on Mac OS X using the <tt>command+</tt> and <tt>command-</tt>
+keys. On Windows and Unix systems use <tt>Ctrl+</tt> and <tt>Ctrl-</tt>.</p>
+
+<p>Changes of the editor content can be undone using <tt>Command-Z</tt> on Mac OS X
+or using <tt>Ctrl-Z</tt> on Windows and Linux.</p>
+
+<p>On Mac OS X the <tt>Ctrl-B,F,P,N,H,D</tt> keys can be used for cursor movement in
+all for directions and deletion of characters before and after the caret.</p>
+
+<h2>Performance considerations</h2>
+
+<p>In this sandboxed JavaScript environment, most File and network I/O functions 
+will not work or work in different ways. Memory is also constrained for 
+applications in a web browser. Bigger newLISP applications for the web should
+run server-side in native compiled newLISP to use all of its File, network and 
+distributed and parallel processing functions.</p>
+
+<p>The following functions are not available in newlisp-js-lib.js:</p>
+
+<blockquote>
+<tt>debug, trace, trace-highlight<br/>
+semaphore, share, signal, timer<br/>
+abort, exec, fork, process, receive, send, spawn, sync<br/>
+net-packet, net-ping, net-service<br/>
+get-url, put-url, post-url, delete-url<br/>
+net-accept, net-close, net-connect, net-error, net-eval<br/>
+net-interface, net-ipv, net-listen, net-local, net-lookup<br/> 
+net-packet, net-peek, net-peer, net-ping, net-receive<br/> 
+net-receive-from, net-receive-udp, net-select, net-send<br/>
+net-send-to, net-send-udp, net-sessions</tt>
+</blockquote>
+
+<p>The following functions are available but will have limited functonality.
+<tt>file://</tt> and <tt>http://</tt> URLs cannot be used, as is possible
+on native compiled newLISP with the last line of functions below. All functions 
+work on a <em>session filesystem</em>.  All contents of this filesystem is 
+forgotten when closing or reloading the browser page. Still, for learning 
+purpose or testing code, it can be useful.</p>
+
+<blockquote>
+<tt>load, save</tt><br/>
+<tt>directory, make-dir, change-dir, remove-dir</tt><br/>
+<tt>open, close, read, write</tt><br/>
+<tt>read-char, write-char, read-line, write-line, read-utf8</tt><br/>
+<tt>read-file, write-file, append-file, delete-file, rename-file</tt>
+</blockquote>
+
+<p>Some functions can work on <tt>stdin</tt>. E.g.: <tt>(read-line)</tt> will
+pop up two JavaScript <tt>window.prompt()</tt> dialogs one after the other 
+to enter a string:</p>
+
+<pre>
+(add (int (read-line)) (int (read-line)))
+</pre>
+
+<p>To write to <tt>stdout</tt> open the device <tt>dev/stdout</tt>:</p>
+
+<pre>
+(set 'out (open "dev/stdout" "w"))
+(write out "hello\n")
+(close out)
+</pre>
+
+<p>This would add the two numbers entered in dialog windows and show the 
+result in the log window.</p>
+
+<h2>Re-defining existing built-in functions using JavaScript</h2>
+
+<p>The browser version of newLISP adds a function <tt>eval-string-js</tt> 
+to call JavaScript int the host browser. This way libraries like jQuery or 
+Bootstrap can be used to replace some of the web and network functions:</p>
+
+<pre>
+    (constant 'get-url (lambda (url) 
+        (eval-string-js (string "GetUrl('" url "')")) )
+    )
+</pre>
+
+<p><tt>GetUrl()</tt> would be a JavaScript function implementing the functionality
+of newLISP's <tt>get-url</tt>. The <tt>constant</tt> function allows
+to redefine protected symbols from built-in functions. Primitives redefined this way 
+will still be <tt>protected?</tt> and <tt>global?</tt>.</p>
+
+<h2>Replacing the editor page with a new page</h2>
+
+<p>Another new builtin function is <tt>display-html</tt>. The function
+can be used to replace the current page containing the editor with a
+new webpage. When evaluating the following snippet in the editor box,
+the new content will apear:</p>
+
+<pre>
+(display-html "&lt;html&gt;Hello World&lt;/html&gt;")
+</pre>
+
+<p>To get back to the newLISP environment, hit the back-key in the browser.</p>
+
+<h2>Displaying an HTML page in a new browser tab</h2>
+
+<pre>
+(display-html "&lt;html&gt;Hello World&lt;/html&gt;" true)
+</pre>
+
+<p>The <tt>true</tt> parameter causes a new tab to be opened. This is the
+same function as used by the <tt>html</tt> button.</p>
+
+<h2>Developing HTML in the browser</h2>
+
+<p>Without using <tt>display-html</tt>, HTML can be written in the editor
+box, intermixed with JavaScript, if required. The <tt>html</tt> button will then 
+open a page in a new tab of the web browser with HTML content of the editor
+box:</p>
+
+<pre>
+&lt;html&gt;Hello World&lt;/html&gt;
+</pre>
+
+<p>See also the <a href="app.html">app.html</a> page.</p>
+
+
+<h2>License</h2>
+<p>The JavaScript Emscripten library <tt>newlisp-js-lib.js</tt> is licensed under
+GNU General Public License Version 3, June 2007 - (GPL v.3).</p>
+<br/>
+<div class="footer" align="center">
+Copyright &copy; 2014, Lutz Mueller 
+<a href="http://www.newlisp.org">newlisp.org</a>. All rights reserved.
+</div>
+
+<br/><center>&sect;</center><br/>
+</body>
+</html>
+
diff --git a/newlisp-js/index.cgi b/newlisp-js/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/newlisp-js/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/newlisp-js/newlisp-js.html b/newlisp-js/newlisp-js.html
new file mode 100644
index 0000000..a0c3ea9
--- /dev/null
+++ b/newlisp-js/newlisp-js.html
@@ -0,0 +1,684 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8"/>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+    <title>newLISP in a browser</title>
+<!-- codemirror stuff -->
+    <link rel=stylesheet href="codemirror/lib/codemirror.css">
+    <link rel=stylesheet href="codemirror/addon/dialog/dialog.css"> 
+    <link rel="stylesheet" href="codemirror/theme/newlisp.css">
+    <link rel="stylesheet" href="codemirror/theme/lesser-dark.css">
+    <link rel="stylesheet" href="codemirror/theme/solarized.css">
+    <link rel="stylesheet" href="codemirror/theme/ambiance.css">
+    <link rel="stylesheet" href="codemirror/theme/xq-light.css">
+    <link rel="stylesheet" href="codemirror/theme/no-color.css">
+    <script src="codemirror/lib/codemirror.js"></script>
+<!-- does not work, don't know why, not caused by newlisp-keymap.js
+    <script src="codemirror/dialog/dialog.js"></script>
+    <script src="codemirror/search/searchcursor.js"></script>
+    <script src="codemirror/search/search.js"></script>
+-->
+    <script src="codemirror/keymap/newlisp-keymap.js"></script>
+    <script src="codemirror/mode/newlisp/newlisp.js"></script>
+    <script src="codemirror/addon/selection/active-line.js"></script>
+    <script src="codemirror/addon/edit/closebrackets.js"></script>
+    <script src="codemirror/addon/edit/matchbrackets.js"></script>
+    <style title="cm-main-style">
+    .CodeMirror { height: 540px; }
+    .CodeMirror { border: 1px solid #AAA; margin-bottom: 5px; border-radius: 5px;}
+    .CodeMirror pre { padding-left: 7px; line-height: 1.25; }
+    .CodeMirror-scroll { overflow: scroll; }
+    </style>
+<!-- end codemirror stuff -->
+    <style type="text/css" media="screen">
+    .emscripten {
+        padding-right: 0; margin-left: auto; margin-right: auto; display: block;
+        }
+    .button {
+        color: #000000;
+        background-color: #B0B0B0;
+        font-size: 1.0em;
+        border: 0px;
+        border-radius: 5px;
+        right: 0px;
+        padding-left: 6px;
+        padding-right: 6px;
+        margin-top: 3px;
+        margin-bottom: 4px;
+        }
+    .blue-button {
+        color: #0000AA;
+        background-color: #B0B0B0;
+        font-size: 1.0em;
+        border: 0px;
+        border-radius: 5px;
+        padding-left: 6px;
+        padding-right: 6px;
+        margin-top: 3px;
+        margin-bottom: 4px;
+        }
+    .red-button {
+        color: #AA0000;
+        background-color: #B0B0B0;
+        font-size: 1.0em;
+        border: 0px;
+        border-radius: 5px;
+        padding-left: 6px;
+        padding-right: 6px;
+        margin-top: 3px;
+        margin-bottom: 4px;
+        }
+    .filesbutton {
+        color: #000000;
+        font-size: 0.1em;
+        margin-bottom: 2px;
+        opacity: 0.0;
+        }
+    .keyword {
+        font-family: Helvetica, sans-serif;
+        font-size: 1.0em;
+        color: #000000;
+        background-color: #E0E0E0;
+        border: 2px solid #5080B0;
+        border-radius: 5px;
+        margin-right: 0px;
+        }
+    .menu {
+        margin-top: 6px;
+        margin-left: 1%;
+        margin-bottom: 2px;
+        }
+    body, p {
+        font-family: Helvetica, sans-serif;
+        color: #C0C0C0;
+        }
+    body {
+        overflow:hidden;
+        background-color: #7080B0;
+        margin: 0;
+        padding: 0;
+        }
+    a {
+        background-color: transparent;
+        color: #c0c0c0;
+        text-decoration: underline;
+        }
+
+    </style>
+    <style name="layout-style">
+    .left {
+        margin-left: 1%;
+        margin-bottom: 2px;
+        float: left;
+        }
+    .right {
+        margin-left: 1%;
+        margin-bottom: 2px;
+        float: left;
+        }
+    .upper {
+        position: relative;
+        margin-left: 1%;
+        margin-right: 1%;
+        margin-bottom: 2px;
+        }
+    .lower {
+        position: relative;
+        margin-left: 1%;
+        margin-right: 1%;
+        margin-bottom: 2px;
+        }
+     </style>
+    <script language="Javascript">
+<!--
+        var editor = false;
+        var cmlog = false;
+
+        // globalarray for width percentages editor and log in 3 layouts
+        var LayoutWidth = [["48.5%", "48.5%"],["65%", "32%"], ["97%", "97%"]];
+        var LayoutClass = [["left", "right"],["left","right"], ["upper", "lower"]];
+        var LayoutIdx = 0;
+
+        // these two functions must be in all 'newLISP in a browser' apps
+        function displayHTML(content) { 
+              document.write(content); document.close(); 
+              return content.length;
+              }
+        function displayHTMLnew(content) { 
+              var newWindow = window.open('');
+              newWindow.document.write(content); newWindow.document.close();
+              return content.length;
+              }
+
+        // the following functions are specific to the editor IDE application
+         var isMobile = {
+            Android: function() { return navigator.userAgent.match(/Android/i);},
+            iOS: function() { return navigator.userAgent.match(/iPhone|iPad|iPod/i);},
+            Windows: function() { return navigator.userAgent.match(/IEMobile/i);},
+            any: function() { return (isMobile.Android() || isMobile.iOS() || isMobile.Windows());}
+            };
+        
+         function detectIPadOrientation () {
+            resizeTextarea();
+            window.scrollTo(0, 0);
+            //if ( orientation == 0 ) { alert ('Portrait Mode, Home Button bottom');
+            }
+
+        function writeLog(content) {
+            cmlog.setValue(cmlog.getValue() + content + "\n");
+            cmlog.setCursor(99999, 0);
+            }
+
+        function evaluateInput() {
+            var result = newlispEvalStr(' ' + editor.getValue());
+            writeLog(result);
+            flashBackground(300);
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function evaluateInputSilent() {
+            var result = newlispEvalStr('(silent)' + editor.getValue());
+            writeLog(result);
+            flashBackground(300);
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function evaluateInputJS() {
+            var result = newlispEvalStr ('(eval-string-js {' + editor.getValue() + '})');
+            writeLog(result);
+            editor.setOption("mode", "text/html");
+            flashBackground(300);
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function reload() {
+            location.reload();
+            }
+
+        function clearEditor() {
+            editor.setValue('');
+            if(!isMobile.any()) editor.focus();
+            editor.setCursor(0, 0);
+            }
+
+        function clearLog() {
+            cmlog.setValue('');
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function clearAll() {
+            editor.setValue('');
+            cmlog.setValue('');
+            document.getElementById('keywordtext').value = '';
+            if(!isMobile.any()) editor.focus();
+            editor.setCursor(0, 0);
+            }
+
+        function switchLayout() {
+            LayoutIdx = (LayoutIdx += 1) % 3;
+            resizeTextarea();
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function openFile() {
+            document.getElementById('files').click();
+            }
+
+        function lineNumbers() {
+            editor.setOption('lineNumbers', editor.getOption('lineNumbers') == false);
+            if(!isMobile.any()) editor.focus();
+            }
+                
+
+        // for CodeMirror
+        function switchTheme() {
+            var newTheme;
+
+            switch(editor.getOption("theme"))
+                {
+                case "newlisp":
+                    newTheme = "lesser-dark"; break;
+                case "lesser-dark":
+                    newTheme = "solarized light"; break;
+                case "solarized light":
+                    newTheme = "xq-light"; break;
+                case "xq-light":
+                    newTheme = "solarized dark"; break;
+                case "solarized dark":
+                    newTheme = "ambiance"; break;
+                case "ambiance":
+                    newTheme = "no-color"; break;
+                case "no-color":
+                    newTheme = "newlisp"; break;
+                default:
+                    newTheme = "newlisp"; break;
+                }
+            writeLog("# set theme: " + newTheme);
+            editor.setOption("theme", newTheme);
+            cmlog.setOption("theme", newTheme);
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function flashBackground(duration) {
+            document.body.style.background = "#68b";
+            var myTimer = setInterval(function() {
+                clearInterval(myTimer);
+                document.body.style.background = "#7080B0";
+                }, duration);
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function restoreLayoutAndTheme() {
+            var theme = localStorage.theme;	
+
+	        if(!isMobile.any()) {
+                var allInputs = document.getElementsByTagName("input");
+                for(var i = 0; i < allInputs.length; i++) {
+                    allInputs[i].setAttribute('style', "font-size: 1.1em");
+                    }
+            	document.getElementById('keywordtext').setAttribute('size', '12');
+		        }
+
+            editor.setOption('lineNumbers', localStorage.lineNumbers == "true");
+
+            LayoutIdx = localStorage.layout;
+            if(LayoutIdx != 0 && LayoutIdx != 1 && LayoutIdx  != 2)
+                LayoutIdx = 0;
+            resizeTextarea();
+
+            if(!theme) { 
+                if(isMobile.any()) { theme = "newlisp"; } 
+                else { theme = "newlisp"; }
+                }
+            editor.setOption("theme", theme);
+            cmlog.setOption("theme", theme);
+
+            var elem = document.getElementById("files");
+            if(isMobile.any()) { elem.style.marginLeft = "-200px"; }
+            else { elem.style.marginLeft = "0px"; }
+            writeLog("# set theme: " + theme);
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function resizeTextarea() {
+            var styleSheet;
+            var offset = 0;
+
+            // set width
+            document.getElementById('editdiv').className = LayoutClass[LayoutIdx][0];
+            document.getElementById('logdiv').className = LayoutClass[LayoutIdx][1];
+            document.getElementById('editdiv').style.width = LayoutWidth[LayoutIdx][0];
+            document.getElementById('logdiv').style.width = LayoutWidth[LayoutIdx][1];
+
+            // set height
+            for(var i = 0; i < document.styleSheets.length; i++) {
+                var sheet = document.styleSheets[i];
+                if(sheet.title == 'cm-main-style') { styleSheet = sheet; }
+                }
+
+            styleSheet.deleteRule(0);
+    	    if(isMobile.any()) { offset = 10; }
+            if(LayoutIdx < 2) {
+                var vertical = window.innerHeight - 80 - offset;
+                } else {
+                var vertical = (window.innerHeight - 120) / 2;
+                } 
+
+            styleSheet.insertRule('.CodeMirror { height: ' + vertical + 'px; }', 0);
+            }
+
+        function handleFileSelect(evt) {
+            var files = evt.target.files; // FileList object
+            var textFile = files[0];
+
+            // textFile.name textFile.type textFile.size
+            // textFile.lastModifiedDate[.toLocaleDateString()]
+
+            //Only process text files.
+            if(textFile.type.match('image.*')) {
+                alert(textFile.type + 'is an invalid file type');
+                return;
+                }
+ 
+            var reader = new FileReader();
+ 
+            // read file asynchronous and fill editor box
+            reader.onload = (function(theFile) {
+                return function(e) {
+                    editor.setCursor(0, 0);
+                    editor.setValue('');
+                    editor.setValue(e.target.result);
+                    };
+                })(textFile);
+ 
+            // Read in the text file
+            reader.readAsText(textFile);
+            writeLog('# loaded ' + textFile.name + ' -', textFile.size + ' bytes');
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function GetSelectedText() {
+            var selText = "";
+            if (window.getSelection) {  // all browsers, except IE before version 9
+                if (document.activeElement &&
+                    document.activeElement.tagName.toLowerCase () == "textarea")
+                    {
+                    var text = document.activeElement.value;
+                    selText = text.substring (document.activeElement.selectionStart,
+                                              document.activeElement.selectionEnd);
+                    } else {
+                    var selRange = window.getSelection ();
+                    selText = selRange.toString ();
+                    }
+                } else {
+                    if (document.selection.createRange) {  // Internet Explorer
+                        var range = document.selection.createRange ();
+                        selText = range.text;
+                        }
+                    }
+                if (selText !== "") {
+                    document.getElementById('keywordtext').value = selText;
+                    //alert(selText);
+                    }
+            }   
+ 
+        function searchKeyPress(e) {
+            // look for window.event in case event isn't passed in
+            if(typeof e == 'undefined' && window.event) { e = window.event; }
+            if(e.keyCode == 13) { document.getElementById('doc').click(); }
+            }       
+
+        //function cmeditorKeyPress () { alert(' key pressed '); } 
+
+        function sleep(ms){
+            var startTime = new Date().getTime();
+            while (new Date().getTime() < startTime + ms) {}
+            }
+
+        function getCaretPosition (field) {
+            var caretPos = 0;
+            // IE 9 and after
+            if (document.selection) {
+                field.focus ();
+                var sel = document.selection.createRange ();
+                sel.moveStart ('character', - field.value.length);
+                caretPos = sel.text.length;
+                }
+            // Firefox, Safari, Chrome
+            else if (field.selectionStart || field.selectionStart == '0') {
+                caretPos = field.selectionStart; }
+            return (caretPos);
+            }
+
+        function OpenDoc () {
+            var selText = document.getElementById('keywordtext').value.trim();
+             
+            if(selText.charAt(selText.length - 1) == "?") {
+                 selText = selText.substring(0, selText.length - 1) + 'p';
+                }
+            if(selText !== '') {
+                //window.open('http://www.newlisp.org/downloads/newlisp_manual.html#'+selText,'MsgWindow');
+                window.open('newlisp_manual.html#'+selText,'MsgWindow');
+                }
+            else {
+                //window.open('http://www.newlisp.org/downloads/manual_frame.html','MsgWindow');
+                window.open('manual_frame.html','MsgWindow');
+                }
+            }
+
+        function saveEdit() {
+            localStorage.userEdits = editor.getValue();
+            localStorage.log = cmlog.getValue();
+            localStorage.theme = editor.getOption("theme");
+            localStorage.layout = LayoutIdx;
+            localStorage.lineNumbers = editor.getOption('lineNumbers');
+            writeLog("# saved to local browser storage");
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function restoreLocalStorage() {
+            var log = document.getElementById('output');
+            if(localStorage.log != null) {
+                cmlog.setValue(localStorage.log);
+                }
+            if(localStorage.userEdits != null) {
+                //content.value = localStorage.userEdits;
+                editor.setValue(localStorage.userEdits);
+                if(editor.getValue().length > 0)
+                     { writeLog("# local browser storage recovered"); }
+                else
+                     { writeLog("# local browser storage is empty"); }
+                }
+            else { 
+                clearLog();
+                writeLog("# no local browser storage found"); 
+                }
+            }
+
+        function insertEdit(text) {
+            editor.setValue(text);
+            }
+
+        function changeSaveOpenButton() {
+            document.getElementById('files').disabled = true;
+            document.getElementById('browse').disabled = false; // for mobile
+            // make prev button
+            document.getElementById('save').value= 'prev';
+            document.getElementById('save').setAttribute('style', 'color: green;');
+            var action = "Module.print(newlispEvalStr('(Tutorial:prev)'))";
+            document.getElementById('save').setAttribute('onclick', action);
+            // make next button
+            document.getElementById('browse').value= 'next';
+            document.getElementById('browse').setAttribute('style', 'color: green;');
+            action = "Module.print(newlispEvalStr('(Tutorial:next)'))";
+            document.getElementById('browse').setAttribute('onclick', action);
+            }
+
+        function enableButtons() {
+            var allInputs = document.getElementsByTagName('input');
+            for(var i = 0; i < allInputs.length; i++) {
+                allInputs[i].disabled = false;
+                }
+            // leave file selection button disabled on Android, IOS and mobile Windows
+            if(isMobile.any()) {
+                document.getElementById('files').disabled = true;
+                document.getElementById('browse').disabled = true;
+                }
+            }
+
+        function initCoderMirrorWidgets() {
+            editor = CodeMirror.fromTextArea(document.getElementById('input'), { 
+                mode: "newlisp",
+                theme: "lesser-dark",
+                lineNumbers: false,
+                styleActiveLine: false,
+                autoCloseBrackets: true,
+                matchBrackets: true,
+                lineWrapping: true,
+                autofocus: true
+                });
+
+            cmlog = CodeMirror.fromTextArea(document.getElementById('output'), { 
+                mode: "text/html",
+                theme: "lesser-dark",
+                readOnly: true,
+                lineWrapping: true
+                });    
+
+            //editor.on("keypress",  function() { cmeditorKeyPress(); });
+            }
+
+-->
+    </script>
+  </head>
+
+  <body onmouseup="GetSelectedText();">
+    <!-- this hidden text area contains code which is preloaded into newLISP. -->
+    <textarea id="code" style="display: none;">
+; insert newLISP code for preload here
+    (set (global 'display-html) (fn (x y)
+        (replace {\} x {\\}) 
+        (replace "\n" x "\\n") 
+        (replace {'} x {\'})
+        (replace {"} x {\"})
+        (eval-string-js (if (true? y)
+        (string {displayHTMLnew('} x {')})
+        (string {displayHTML('} x {')})))))
+; eof
+    </textarea>
+    <div class="emscripten" id="status">Downloading...</div>
+    <div class="emscripten">
+      <progress value="0" max="100" id="progress" hidden=1></progress> 
+    </div>
+    <div class="menu">
+    <input type="button" value="eval" id="evalinput" class="blue-button" title="eval newLISP - Ctl-enter"
+         onclick="evaluateInput();" disabled />
+    <input type="button" value="silent" id="evalsilent" class="blue-button"
+         title="eval silent - Shift-Ctrl-enter" onclick="evaluateInputSilent();" disabled />
+    <input type="button" value="JS" id="evalinputJS" class="blue-button" title="eval JavaScript"
+         onclick="evaluateInputJS();" disabled />
+    <input type="button" value="html" id="evalinputHTML" class="blue-button" title="display HTML"
+         onclick="displayHTMLnew(editor.getValue())" disabled />
+    <input type="button" value="x-edit" id="clearinput" class="red-button" title="clear editor - Ctrl-L" i
+      onclick="clearEditor();" disabled />
+    <input type="button" value="x-log" id="clearoutput" class="red-button" title="clear log - Shift-Ctrl-L"
+         onclick="clearLog();"  disable />
+    <input type="button" value="layout" id="switchlayout" class="button" title="change layout"
+         onclick="switchLayout();" disabled />
+    <input type="button" value='#' id="linenumbers" class="button" title="line numbers - Ctrl-1"
+         onclick="lineNumbers();" disabled />
+    <input type="button" value="theme" id="theme" class="button" title="change color scheme"
+         onclick="switchTheme();" disabled />
+    <input type="button" value='&#8635' id="reload" class="red-button" title="reload newLISP - Ctrl-R"
+         onclick="reload();" />
+    <input type="button" value="info" id="info" class="button" title="about this program"
+         onclick="window.open('README.html','MsgWindow');" disabled />
+    <input type="button" value="doc" id="doc" class="button" title="reference manual"
+         onclick="OpenDoc();"/>
+    <input type="text" class="keyword" id="keywordtext" size="10" 
+         title="search keyword" onkeypress="searchKeyPress(event);" />
+    </div>
+<!--  EDITOR -->
+    <div class="left" id="editdiv" style="width: 49%">
+    <form><textarea id="input" display="none" disabled >; Welcome to newLISP running in a browser.
+; based on newLISP v10.6.3 2015-05-14, Emscripten v1.29.0
+; best used with FireFox browser
+; Click [eval]
+
+(println "Hello World")
+
+(define (double x)
+   (+ x x))
+
+(println "=> " (double 123))
+
+; [eval] shows all the return values from
+; evaluated expressions plus the effect from
+; 'println'. Now click [silent]. It only shows
+; the effect from the 'println' expression.
+
+; To find out more about how to use this 
+; editor, click the [info] button.
+
+; The best introduction to newLISP can be found
+; here:
+; en.wikibooks.org/wiki/Introduction_to_newLISP
+;
+; More documentation can be found here:
+; www.newlisp.org/index.cgi?Documentation
+; or by clicking the [doc] button.
+</textarea></form>
+     <input  type="button" value="save" id="save" class="button" title="save to local storage - Ctrl-S"
+        onclick="saveEdit();" disabled />
+     <input  type="button" value="open" id="browse" class="red-button" title="open disk file - Ctrl-O"
+        onclick="openFile()" disabled />
+     <input type="file" class="filesbutton" id="files" name="load" disabled />
+    </div>
+<!-- LOG MONITOR -->
+    <div class="right" id="logdiv" style="width: 48%">
+    <textarea  id="output"  disabled ></textarea>
+    <center><font size="-1">Copyright &copy; 2014-2015, <a href="http://newlisp.org">newlisp.org</a>
+    </font></center>
+    </div>
+
+    <script type='text/javascript'>
+<!--
+        // EMSCRIPTEN loading newlisp-js-lib.js showing progress of downloading
+        // importing newlispEvalStr and output to the console
+        var Module = {
+          preRun: [],
+          postRun: [(function() {
+            newlispEvalStr = Module.cwrap('newlispEvalStr', 'string', ['string']); 
+            // preload newLISP functions from code textarea id='code'
+            newlispEvalStr(document.getElementById('code').value);
+          })],
+          print: (function() {
+            //var element = document.getElementById('output');
+            //element.value = ''; // clear browser cache
+            return function(text) {
+              text = Array.prototype.slice.call(arguments).join(' ');
+              writeLog(text);
+              //element.value += text + "\n";
+              //element.scrollTop = 99999; // focus on bottom
+            };
+          })(),
+          printErr: function(text) {
+            text = Array.prototype.slice.call(arguments).join(' ');
+            console.log(text);
+          },
+          canvas: document.getElementById('canvas'),
+          setStatus: function(text) {
+            if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' };
+            if (text === Module.setStatus.text) return;
+            var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
+            var now = Date.now();
+            if (m && now - Date.now() < 30) return; // if progress update, skip it if too soon
+            var statusElement = document.getElementById('status');
+            var progressElement = document.getElementById('progress');
+            if (m) {
+              text = m[1];
+              progressElement.value = parseInt(m[2])*100;
+              progressElement.max = parseInt(m[4])*100;
+              progressElement.hidden = false;
+            } else {
+              progressElement.value = null;
+              progressElement.max = null;
+              progressElement.hidden = true;
+
+              // start application, start CodeMirror, restore local storage and layout
+              if(editor == false) {
+                enableButtons();
+                initCoderMirrorWidgets();
+                restoreLocalStorage();
+                restoreLayoutAndTheme();
+                window.onresize = resizeTextarea;
+                //file browser
+                document.getElementById('files').addEventListener('change', handleFileSelect, false);
+                }
+
+              if(isMobile.any()) { 
+                // settings for mobile device orientation discovery
+                window.onorientationchange = detectIPadOrientation;
+                // on mobile scroll page into position when keyboard closes
+                document.addEventListener('focusout', function(e) {window.scrollTo(0, 0);});
+                }
+            }
+            statusElement.innerHTML = text;
+          },
+          totalDependencies: 0,
+          monitorRunDependencies: function(left) {
+            this.totalDependencies = Math.max(this.totalDependencies, left);
+            Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) +
+                          '/' + this.totalDependencies + ')' : 'All downloads complete.');
+          }
+        };
+        Module.setStatus('Downloading...');
+-->
+      </script>
+      <script async type="text/javascript" src="newlisp-js-lib.js"></script>
+  </body>
+</html>
+
+<!-- eof -->
+
diff --git a/newlisp-js/readme.txt b/newlisp-js/readme.txt
new file mode 100644
index 0000000..a958ee8
--- /dev/null
+++ b/newlisp-js/readme.txt
@@ -0,0 +1,3 @@
+New files and directories created here, will 
+disappear when closing or reloading the page. 
+
diff --git a/newlisp-js/simple.html b/newlisp-js/simple.html
new file mode 100644
index 0000000..a01e6ac
--- /dev/null
+++ b/newlisp-js/simple.html
@@ -0,0 +1,723 @@
+<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8"/>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+    <title>newLISP in a browser</title>
+    <style type="text/css" media="screen">
+    .emscripten {
+        padding-right: 0; margin-left: auto; margin-right: auto; display: block;
+        }
+    .button {
+        color: #000000;
+        background-color: #B0B0B0;
+        font-size: 1.0em;
+        border: 0px;
+        border-radius: 5px;
+        padding-left: 6px;
+        padding-right: 6px;
+        margin-top: 3px;
+        margin-bottom: 4px;
+        }
+    .blue-button {
+        color: #0000AA;
+        background-color: #B0B0B0;
+        font-size: 1.0em;
+        border: 0px;
+        border-radius: 5px;
+        padding-left: 6px;
+        padding-right: 6px;
+        margin-top: 3px;
+        margin-bottom: 4px;
+        }
+    .red-button {
+        color: #AA0000;
+        background-color: #B0B0B0;
+        font-size: 1.0em;
+        border: 0px;
+        border-radius: 5px;
+        padding-left: 6px;
+        padding-right: 6px;
+        margin-top: 3px;
+        margin-bottom: 4px;
+        }
+    .filesbutton {
+        color: #000000;
+        font-size: 0.1em;
+        margin-bottom: 2px;
+        opacity: 0.0;
+        }
+    .keyword {
+        font-family: Helvetica, sans-serif;
+        font-size: 1.0em;
+        color: #000000;
+        background-color: #E0E0E0;
+        border: 2px solid #5080B0;
+        border-radius: 5px;
+        margin-right: 0px;
+        }
+    .dark-theme {
+        color: #f0b060;
+        background-color: #222223;
+        cursor: cell;
+        }
+    .light-theme {
+        color: #303060;
+        background-color: #F8E8C8;
+        }
+    .white-theme {
+        color: #000000;
+        background-color: #FFFFFF;
+        }
+    .blue-theme {
+        color: #DDDDDD;
+        background-color: #102030;
+        cursor: cell;
+        }
+    body, p {
+        font-family: Helvetica, sans-serif;
+        color: #C0C0C0;
+        }
+    body {
+        overflow:hidden;
+        background-color: #5080B0;
+        margin: 0;
+        padding: 0;
+        }
+    a {
+        background-color: transparent;
+        color: #c0c0c0;
+        text-decoration: underline;
+        }
+    </style>
+    <style title="layout">
+    .left {
+        height: 500px;
+        }
+    .left {
+        margin-left: 1%;
+        margin-bottom: 2px;
+        float: left;
+        }
+    .right {
+        height: 500px;
+        }
+    .right {
+        margin-left: 1%;
+        margin-bottom: 2px;
+        float: left;
+        }
+    .upper {
+        height: 240px;
+        }
+    .upper {
+        margin-left: 1%;
+        margin-bottom: 4px;
+        }
+    .lower {
+        height: 240px;
+        }
+    .lower {
+        margin-left: 1%;
+        margin-bottom: 6px;
+        }
+    .menu {
+        margin-top: 6px;
+        margin-left: 1%;
+        margin-bottom: 2px;
+        }
+    .lower-menu {
+        margin-left: 1%;
+        }
+    textarea {
+        font-family: Andale Mono, Monaco, Courier;
+        font-size: 1.0em;
+        border: 2px solid #C0C0C0;
+        border-radius: 5px;
+        width: 99%;
+        height: 99%;
+        resize: none;
+        }
+    </style>
+    <script language="Javascript">
+<!--
+        // globalarray for width percentages editor and log in 3 layouts
+        var LayoutWidth = [["48.5%", "48.5%"],["65%", "32%"], ["97%", "97%"], ["97%", "97%"]];
+        var LayoutHeight = [[1.0, 1.0], [1.0, 1.0] ,[0.5, 0.5], [0.65, 0.35]];
+        var LayoutClass = [["left", "right"],["left","right"], ["upper", "lower"], ["upper", "lower"]];
+        var LayoutIdx = 0;
+
+        // these two functions must be in all newLISP in a browser app
+        function displayHTML(content) { 
+              document.write(content); document.close(); 
+              return content.length;
+              }
+        function displayHTMLnew(content) { 
+              var newWindow = window.open('');
+              newWindow.document.write(content); newWindow.document.close();
+              return content.length;
+              }
+
+        // the following funcitons are specific to the editor IDE application
+         var isMobile = {
+            Android: function() { return navigator.userAgent.match(/Android/i);},
+            iOS: function() { return navigator.userAgent.match(/iPhone|iPad|iPod/i);},
+            Windows: function() { return navigator.userAgent.match(/IEMobile/i);},
+            any: function() { return (isMobile.Android() || isMobile.iOS() || isMobile.Windows());}
+            };
+        
+         function detectIPadOrientation () {
+            resizeTextarea();
+            window.scrollTo(0, 0);
+            //if ( orientation == 0 ) { alert ('Portrait Mode, Home Button bottom');
+            }
+
+        function evaluateInput() {
+            var result = newlispEvalStr(document.getElementById('input').value.trim());
+            Module.print(result);
+            }
+
+        function evaluateInputSilent() {
+            var result = newlispEvalStr('(silent)' + document.getElementById('input').value.trim());
+            Module.print(result);
+            }
+
+        function evaluateInputJS() {
+            var result = newlispEvalStr (
+                '(eval-string-js {' + document.getElementById('input').value.trim() + '})' );
+            Module.print(result);
+            }
+
+        function clearEditor() {
+            document.getElementById('input').value = '';
+            }
+
+        function clearLog() {
+            document.getElementById('output').value = ''
+            }
+
+        function editorSetFocus() {
+            document.getElementById('input').focus();
+            }
+
+        function switchLayout() {
+            LayoutIdx = (LayoutIdx += 1) % 4;
+            resizeTextarea();
+            if(!isMobile.any()) editor.focus();
+            }
+
+        function switchTheme() {
+            var newTheme;
+
+            switch(document.getElementById('input').className)
+                {
+                case "dark-theme":
+                    newTheme = "light-theme"; break;
+                case "light-theme":
+                    newTheme = "white-theme"; break;
+                case "white-theme":
+                    newTheme = "blue-theme"; break;
+                case "blue-theme":
+                    newTheme = "dark-theme"; break;
+                default:
+                    newTheme = "white-theme";
+                } 
+
+            document.getElementById('input').className = newTheme;
+            document.getElementById('output').className = newTheme;
+            Module.print("# set theme: " + newTheme);
+            }
+ 
+        function flashBackground(duration) {
+            document.body.style.background = "#8888CC";
+            var myTimer = setInterval(function() {
+                clearInterval(myTimer);
+                document.body.style.background = "#5080B0";
+                }, duration);
+            }
+
+        function restoreLayoutAndTheme() {
+            var theme = localStorage.theme;
+
+	        if(!isMobile.any()) {
+                var allInputs = document.getElementsByTagName("input");
+                for(var i = 0; i < allInputs.length; i++) {
+                    allInputs[i].setAttribute('style', "font-size: 1.1em");
+                    }
+            	document.getElementById('keywordtext').setAttribute('size', '12');
+		        }
+
+            LayoutIdx = localStorage.layout;
+            if(LayoutIdx != 0 && LayoutIdx != 1 && LayoutIdx  != 2 && LayoutIdx != 3)
+                LayoutIdx = 0;
+            resizeTextarea();
+
+            if(!theme) { theme = "white-theme"; }
+            document.getElementById('input').className = theme; 
+            document.getElementById('output').className = theme;
+            Module.print("# set theme: " + theme);
+
+            var elem = document.getElementById("files");
+            if(isMobile.any()) { elem.style.marginLeft = "-200px"; }
+            else { elem.style.marginLeft = "0px"; }
+
+            if(!isMobile.any()) editorSetFocus();
+            }
+
+        function resizeTextarea() {
+            var styleSheet;
+            var offset = 0;
+            var vertical;
+
+            // set width
+            document.getElementById('editdiv').className = LayoutClass[LayoutIdx][0];
+            document.getElementById('logdiv').className = LayoutClass[LayoutIdx][1];
+            document.getElementById('editdiv').style.width = LayoutWidth[LayoutIdx][0];
+            document.getElementById('logdiv').style.width = LayoutWidth[LayoutIdx][1];
+
+            // set height
+            for(var i = 0; i < document.styleSheets.length; i++) {
+                var sheet = document.styleSheets[i];
+                if(sheet.title == 'layout') { styleSheet = sheet; }
+                }
+
+    	    if(isMobile.any()) { offset = 16; }
+            if(LayoutIdx < 2) { // left right layout
+                vertical = window.innerHeight - 76 - offset;
+                } else { // one column layout
+                vertical = window.innerHeight - 84 - offset;
+                } 
+
+            var editHeight = vertical * LayoutHeight[LayoutIdx][0];
+            var logHeight = vertical - editHeight;
+
+            styleSheet.deleteRule(0); // left
+            styleSheet.insertRule('.left { height: ' + editHeight + 'px;}' , 0);
+            styleSheet.deleteRule(2); // right
+            styleSheet.insertRule('.right { height: ' + editHeight + 'px;}' , 2);
+            styleSheet.deleteRule(4); // upper
+            styleSheet.insertRule('.upper { height: ' + editHeight + 'px;}' , 4);
+            styleSheet.deleteRule(6); // lower
+            styleSheet.insertRule('.lower { height: ' + logHeight + 'px;}' , 6);
+            }
+
+        function handleFileSelect(evt) {
+            var files = evt.target.files; // FileList object
+            var textFile = files[0];
+
+            // file info:
+            // textFile.name
+            // textFile.type
+            // textFile.size
+            // textFile.lastModifiedDate[.toLocaleDateString()]
+
+            //Only process text files.
+            if(textFile.type.match('image.*')) {
+                alert(textFile.type + 'is an invalid file type');
+                return;
+                }
+ 
+            var reader = new FileReader();
+ 
+            // read file asynchronous and fill editor box
+            reader.onload = (function(theFile) {
+                return function(e) {
+                    var editBox = document.getElementById('input');
+                    editBox.value = ''; // clear editbox
+                    editBox.value = e.target.result;
+                    };
+                })(textFile);
+ 
+            // Read in the text file
+            reader.readAsText(textFile);
+            Module.print('# loaded ' + textFile.name + ' -', textFile.size + ' bytes');
+            editorSetFocus();
+            }
+
+        function GetSelectedText() {
+            var selText = "";
+            if (window.getSelection) {  // all browsers, except IE before version 9
+                if (document.activeElement &&
+                    document.activeElement.tagName.toLowerCase () == "textarea")
+                    {
+                    var text = document.activeElement.value;
+                    selText = text.substring (document.activeElement.selectionStart,
+                                              document.activeElement.selectionEnd);
+                }
+                else {
+                    var selRange = window.getSelection ();
+                    selText = selRange.toString ();
+                    }
+                }
+                else {
+                    if (document.selection.createRange) {       // Internet Explorer
+                        var range = document.selection.createRange ();
+                        selText = range.text;
+                    }
+                }
+                if (selText !== "") {
+                    document.getElementById('keywordtext').value = selText;
+                    //alert(selText);
+                }
+        }
+ 
+        function searchKeyPress(e) {
+            // look for window.event in case event isn't passed in
+            if(typeof e == 'undefined' && window.event) { e = window.event; }
+            if(e.keyCode == 13) { document.getElementById('doc').click(); }
+            }       
+
+        function editorKeyDown(e) {
+            var editor = document.getElementById('input');
+            if(typeof e == 'undefined' && window.event) { e = window.event; }
+
+            if(e.keyCode == 9) { // TAB key emits 4 spaces
+                e.preventDefault();
+                var oldCaret = getCaretPosition(editor);
+                var newCaret = oldCaret + 4; 
+                editor.value = editor.value.substring(0, oldCaret) + "    " + 
+                               editor.value.substring(oldCaret, editor.value.length);
+                editor.selectionStart = newCaret;
+                editor.selectionEnd = newCaret;
+                }
+            }
+
+        function editorKeyUp(e) {
+            var editor = document.getElementById('input');
+            if(typeof e == 'undefined' && window.event) { e = window.event; }
+            //alert(e.shiftKey + ' ' + e.ctrlKey + ' ' + e.altKey + ' ' + e.keyCode + ' ' + e.charCode + ' ' + e.which);
+
+            if(e.ctrlKey === true) {
+                e.preventDefault();
+                if(e.shiftKey === false && e.keyCode === 76) { // Ctrl-L  [x edit] 
+                    document.getElementById('clearinput').click(); 
+                    document.getElementById('keywordtext').value = '';
+                    }
+                if(e.shiftKey ===  true && e.keyCode === 76) { // Shift-Ctrl-L  [x edit] 
+                    document.getElementById('clearoutput').click(); 
+                    }
+                if(e.altKey ===  true && e.keyCode === 76) { // Shift-Ctrl-L  [x edit] 
+                    document.getElementById('clearinput').click(); 
+                    document.getElementById('keywordtext').value = '';
+                    document.getElementById('clearoutput').click(); 
+                    }
+                if(e.keyCode === 79) { // Ctrl-O [open]
+                    document.getElementById('browse').click();
+                    }
+                if(e.keyCode === 83) { // Ctrl-S [save]
+                    document.getElementById('save').click();
+                    }
+                }
+            }
+
+        function editorKeyPress(e) {
+            var editor = document.getElementById('input');
+            var closingPar = '';
+            var openPar;
+            //alert(e.shiftKey + ' ' + e.ctrlKey + ' ' + e.altKey + ' ' + e.keyCode + ' ' + e.charCode + ' ' + e.which);
+
+            if(typeof e == 'undefined' && window.event) { e = window.event; }
+
+            if(e.charCode == 41) 
+                { closingPar = ')'; openPar = '('; }
+            if(e.charCode == 125) 
+                { closingPar = '}'; openPar = '{'; }
+
+            // blink opening parenthesis on closing par
+            if(closingPar == ')' || closingPar == '}') {
+                var text = editor.value;
+                var caret = getCaretPosition(editor);
+                var balance = 1;
+                for(var pos = caret - 1; pos >= 0; pos -= 1 ) {
+                    if(text.charAt(pos) == openPar) balance -= 1;
+                    if(text.charAt(pos) == closingPar) balance += 1;
+                    if(balance === 0) {
+                        editor.selectionStart = pos;
+                        editor.selectionEnd = pos;
+                        var myTimer = setTimeout(function() {
+                            clearInterval(myTimer);
+                            editor.value = text.substring(0, caret) + closingPar +
+                                text.substring(caret, text.length);
+                            editor.selectionStart = caret + 1;
+                            editor.selectionEnd = caret + 1;
+                            }, 300);
+                        e.preventDefault();
+                        break;
+                        }
+                    }
+                }
+            
+            if(e.ctrlKey === true) {
+                e.preventDefault();
+                if(e.shiftKey === false && e.keyCode === 13) { // Ctrl-enter [eval]
+                    document.getElementById('evalinput').click(); 
+                    } 
+                if(e.shiftKey === true && e.keyCode === 13) { // Shift-Ctrl-enter [silent]
+                    document.getElementById('evalsilent').click();
+                    }
+                }
+            }
+
+        function sleep(ms){
+            var startTime = new Date().getTime();
+            while (new Date().getTime() < startTime + ms) {}
+            }
+
+        function getCaretPosition (field) {
+            var caretPos = 0;
+            // IE 9 and after
+            if (document.selection) {
+                field.focus ();
+                var sel = document.selection.createRange ();
+                sel.moveStart ('character', - field.value.length);
+                caretPos = sel.text.length;
+                }
+            // Firefox, Safari, Chrome
+            else if (field.selectionStart || field.selectionStart == '0') {
+                caretPos = field.selectionStart; }
+            return (caretPos);
+            }
+
+        function setCaretPosition(elem, caretPos) {
+            if(elem !== null) {
+                // IE 6 and after
+                if(elem.createTextRange) {
+                    var range = elem.createTextRange();
+                    range.move('character', caretPos);
+                    range.select();
+                    }
+                // Firefox, Safari, Chrome
+                else {
+                    if(elem.selectionStart) {
+                        elem.focus();
+                        elem.setSelectionRange(caretPos, caretPos);
+                        }
+                    else
+                        elem.focus();
+                    }
+                }
+            }
+
+        function OpenDoc () {
+            var selText = document.getElementById('keywordtext').value.trim();
+             
+            if(selText.charAt(selText.length - 1) == "?") {
+                 selText = selText.substring(0, selText.length - 1) + 'p';
+                }
+            if(selText !== '') {
+                //window.open('http://www.newlisp.org/downloads/newlisp_manual.html#'+selText,'MsgWindow');
+                window.open('newlisp_manual.html#'+selText,'MsgWindow');
+                }
+            else {
+                //window.open('http://www.newlisp.org/downloads/manual_frame.html','MsgWindow');
+                window.open('manual_frame.html','MsgWindow');
+                }
+            }
+
+        function saveEdit() {
+            localStorage.userEdits = document.getElementById('input').value;
+            localStorage.log = document.getElementById('output').value;
+            localStorage.theme = document.getElementById('input').className;
+            localStorage.layout = LayoutIdx;
+            Module.print("# saved to local browser storage");
+            if(!isMobile()) { editorSetFocus() };
+            }
+
+        function restoreEdit() {
+            var log = document.getElementById('output');
+            if(localStorage.log != null) {
+                log.value = localStorage.log;
+                }
+            var content = document.getElementById('input');
+            if(localStorage.userEdits != null) {
+                content.value = localStorage.userEdits;
+                if(content.value.length > 0)
+                     { Module.print("# local browser storage recovered"); }
+                else
+                     { Module.print("# local browser storage is empty"); }
+                }
+            else { Module.print("# no local browser storage found"); }
+            }
+
+        function insertEdit(text) {
+            document.getElementById('input').value = text;
+            }
+-->
+    </script>
+  </head>
+
+  <body onmouseup="GetSelectedText();" onload="restoreEdit();">
+    <!-- this hidden text area contains code which is preloaded into newLISP.
+         The code is part of the tutorial application and is not required
+         for a functioning editor IDE.
+         Do not remove first and last out-commenting tags! -->
+    <textarea id="code" style="display: none;">
+; insert newLISP code for preload here
+    (set (global 'display-html) (fn (x y)
+        (replace {\} x {\\}) 
+        (replace "\n" x "\\n") 
+        (replace {'} x {\'})
+        (replace {"} x {\"})
+        (eval-string-js (if (true? y)
+        (string {displayHTMLnew('} x {')})
+        (string {displayHTML('} x {')})))))
+; eof
+    </textarea>
+
+    <div class="emscripten" id="status">Downloading...</div>
+    <div class="emscripten">
+      <progress value="0" max="100" id="progress" hidden=1></progress> 
+    </div>
+    <div class="menu">
+    <input type="button" value="eval" class="blue-button" id="evalinput" title="eval newLISP - Ctl-enter"
+      onclick="evaluateInput();" />
+    <input type="button" value="silent" class="blue-button" id="evalsilent" 
+      title="eval silent - Shift-Ctrl-enter" onclick="evaluateInputSilent();" />
+    <input type="button" value="JS" id="evalinputJS" class="blue-button" title="eval JavaScript"
+      onclick="evaluateInputJS();" />
+    <input type="button" value="html" id="evalinputHTML" class="blue-button" title="display HTML"
+      onclick="displayHTMLnew(document.getElementById('input').value)" />
+    <input type="button" value="x edit" id="clearinput" class="red-button" title="clear edit - Ctrl-L" 
+      onclick="clearEditor();" />
+    <input type="button" value="x log" class="red-button" id="clearoutput" title="clear log - Shift-Ctrl-L"
+      onclick="clearLog();" />
+    <input type="button" value="layout" id="switchlayout" class="button" title="change layout"
+      onclick="switchLayout();" />
+    <input type="button" value="theme" id="theme" class="button" title="change colors"
+     onclick="switchTheme();" />
+    <input type="button" value="info" id="info" class="button" title="about this program"
+      onclick="window.open('README.html','MsgWindow');" />
+    <input type="button" value="doc" id="doc" class="button" title="access documentation" 
+      onclick="OpenDoc();"/>
+    <input type="text" class="keyword" id="keywordtext" size="14" onkeypress="searchKeyPress(event);" />
+    </div>
+    <div class="two-column" id="editdiv">
+    <textarea id="input" class="light-theme" spellcheck="false" onkeydown="editorKeyDown(event);"
+        onkeypress="editorKeyPress(event);" onkeyup="editorKeyUp(event);"
+         >; Welcome to newLISP running in a browser.
+; based on newLISP v10.6.3 2015-05-14, Emscripten v1.29.0
+; best used with FireFox browser
+; Click [eval]
+
+(println "Hello World")
+
+(define (double x)
+   (+ x x))
+
+(println "=> " (double 123))
+
+; [eval] shows all the return values from
+; evaluated expressions plus the effect from
+; 'println'. Now click [silent]. It only shows
+; the effect from the 'println' expression.
+
+; To find out more about how to use this 
+; editor, click the [info] button.
+
+; The best introduction to newLISP can be found
+; here:
+; en.wikibooks.org/wiki/Introduction_to_newLISP
+;
+; More documentation can be found here:
+; www.newlisp.org/index.cgi?Documentation
+; or by clicking the [doc] button.
+</textarea>
+    </div>
+
+    <div class="two-column" id="logdiv">
+    <textarea  id="output" class="light-theme" style="cursor:default;" readonly ></textarea>
+    <center>
+    <font size="-1">Copyright &copy; 2014-2015, <a href="http://newlisp.org">newlisp.org</a></font>
+    </center>
+    </div>
+    <div class="lower-menu">
+     <input type="button" value="save" id="save" class="button" title="save to browser storage - Ctrl-S"
+      onclick="saveEdit();" />
+     <input type="button" value="open" id="browse" class="red-button" title="open a disk file - Ctrl-O"
+        onclick="document.getElementById('files').click();" />
+     <input type="file" class="filesbutton" id="files" name="load" />
+    </div>
+
+    <script type='text/javascript'>
+<!--
+        // EMSCRIPTEN loading newlisp-js-lib.js showing progress of downloading
+        // importing newlispEvalStr and output to the console
+        var Module = {
+          preRun: [],
+          postRun: [(function() {
+            newlispEvalStr = Module.cwrap('newlispEvalStr', 'string', ['string']); 
+            // preload newLISP functions from code textarea id='code'
+            newlispEvalStr(document.getElementById('code').value);
+          })],
+          print: (function() {
+            var element = document.getElementById('output');
+            element.value = ''; // clear browser cache
+            return function(text) {
+              text = Array.prototype.slice.call(arguments).join(' ');
+              element.value += text + "\n";
+              element.scrollTop = 99999; // focus on bottom
+            };
+          })(),
+          printErr: function(text) {
+            text = Array.prototype.slice.call(arguments).join(' ');
+            console.log(text);
+          },
+          setStatus: function(text) {
+            if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' };
+            if (text === Module.setStatus.text) return;
+            var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
+            var now = Date.now();
+            if (m && now - Date.now() < 30) return; // if progress update, skip it if too soon
+            var statusElement = document.getElementById('status');
+            var progressElement = document.getElementById('progress');
+            if (m) {
+              text = m[1];
+              progressElement.value = parseInt(m[2])*100;
+              progressElement.max = parseInt(m[4])*100;
+              progressElement.hidden = false;
+            } else {
+              progressElement.value = null;
+              progressElement.max = null;
+              progressElement.hidden = true;
+
+              // leave file selection button disabled on Android, IOS and mobile Windows
+              if(isMobile.any()) {
+                  document.getElementById('files').disabled = true;
+                  document.getElementById('browse').disabled = true;
+                  }
+
+              document.getElementById('files').addEventListener('change', handleFileSelect, false);
+              // restore editor layout settings
+              restoreLayoutAndTheme();
+              window.onresize = resizeTextarea;
+              editorSetFocus();
+
+              if(isMobile.any()) { 
+                // settings for mobile discover orientation
+                window.onorientationchange = detectIPadOrientation;
+                // on mobile scroll page into position when keyboard closes
+                document.addEventListener('focusout', function(e) {window.scrollTo(0, 0);});
+                }
+
+        // EMSCRIPTEN finish download status update code
+
+            }
+            statusElement.innerHTML = text;
+          },
+          totalDependencies: 0,
+          monitorRunDependencies: function(left) {
+            this.totalDependencies = Math.max(this.totalDependencies, left);
+            Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) +
+                          '/' + this.totalDependencies + ')' : 'All downloads complete.');
+          }
+        };
+        Module.setStatus('Downloading...');
+-->
+      </script>
+
+      <script async type="text/javascript" src="newlisp-js-lib.js"></script>
+  </body>
+</html>
+
+<!-- eof -->
+
diff --git a/newlisp.c b/newlisp.c
new file mode 100644
index 0000000..10dbeb5
--- /dev/null
+++ b/newlisp.c
@@ -0,0 +1,7443 @@
+/* newlisp.c --- enrty point and main functions for newLISP
+
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+#include "primes.h"
+
+#ifdef WINDOWS
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#endif
+
+#ifdef READLINE
+#include <readline/readline.h>
+/* take following line out on Slackware Linux */
+#include <readline/history.h>
+#endif /* end READLINE */
+
+#ifdef SUPPORT_UTF8
+#include <wctype.h>
+#endif
+
+#define freeMemory free
+
+#define INIT_FILE "init.lsp"
+
+#ifdef WINDOWS
+#define fprintf win_fprintf
+#define fgets win_fgets
+#define fclose win_fclose
+#endif
+
+#ifdef LIBRARY
+extern STREAM libStrStream;
+int newlispLibConsoleFlag = 0;
+#endif
+
+#ifdef LINUX
+#ifdef ANDROID
+int opsys = 11;
+#else
+int opsys = 1;
+#endif
+#endif
+
+#ifdef _BSD
+int opsys = 2;
+#endif
+
+#ifdef MAC_OSX
+#ifdef EMSCRIPTEN
+int opsys = 11;
+#else
+int opsys = 3;
+#endif
+#endif
+
+#ifdef SOLARIS
+int opsys = 4;
+#endif
+
+#ifdef WINDOWS
+int opsys = 6;
+#endif
+
+#ifdef OS2 
+int opsys = 7; 
+#endif
+
+#ifdef CYGWIN
+int opsys = 8;
+#endif
+
+#ifdef TRU64
+int opsys = 9; 
+#endif
+
+#ifdef AIX
+int opsys = 10;
+#endif
+
+
+/* opsys = 11 taken for ANDROID; see LINUX */
+
+int bigEndian = 1; /* gets set in main() */
+
+int version = 10700;
+
+char copyright[]=
+"\nnewLISP v.10.7.0 Copyright (c) 2016 Lutz Mueller. All rights reserved.\n\n%s\n\n";
+
+#ifndef NEWLISP64
+#ifdef SUPPORT_UTF8
+char banner[]=
+"newLISP v.10.7.0 32-bit on %s IPv4/6 UTF-8%s%s\n\n";
+#else
+char banner[]=
+"newLISP v.10.7.0 32-bit on %s IPv4/6%s%s\n\n";
+#endif
+#else /* NEWLISP64 */
+#ifdef SUPPORT_UTF8
+char banner[]=
+"newLISP v.10.7.0 64-bit on %s IPv4/6 UTF-8%s%s\n\n";
+#else
+char banner[]=
+"newLISP v.10.7.0 64-bit on %s IPv4/6%s%s\n\n";
+#endif 
+#endif /* NEWLISP64 */
+
+char banner2[]= ", options: newlisp -h";
+
+void linkSource(char *, char *, char *);
+char linkOffset[] = "&&&&@@@@";
+char preLoad[] = 
+#ifdef EMSCRIPTEN
+    "(set (global 'module) (fn ($x) (load (append {/newlisp-js/} $x))))"
+#else
+    "(set (global 'module) (fn ($x) (load (append (env {NEWLISPDIR}) {/modules/} $x))))"
+#endif
+    "(context 'Tree) (constant 'Tree:Tree) (context MAIN)"
+    "(define (Class:Class) (cons (context) (args)))";
+void printHelpText(void);
+#ifdef READLINE
+char ** newlisp_completion (char * text, int start, int end);
+#endif
+/* --------------------- globals -------------------------------------- */
+
+/* interactive command line */
+
+int isTTY = FALSE;
+int daemonMode = 0;
+
+int noPromptMode = 0;
+int forcePromptMode = 0;
+int httpMode = 0;
+int evalSilent = 0;
+
+
+#ifdef WINDOWS
+int IOchannelIsSocketStream = 0;
+#endif
+FILE * IOchannel;
+char * IOdomain = NULL;
+int IOport = 0;
+int connectionTimeout = 0;
+
+int logTraffic = 0;
+#define LOG_LESS 1
+#define LOG_MORE 2
+
+/* initialization */
+int MAX_CPU_STACK = 0x800;
+int MAX_ENV_STACK;
+int MAX_RESULT_STACK;
+#define MAX_OBJECT_STACK 64
+#ifndef NEWLISP64
+INT MAX_CELL_COUNT = 0x10000000;
+#else
+INT MAX_CELL_COUNT = 0x800000000000000LL;
+#endif
+INT blockCount = 0;
+
+CELL * firstFreeCell = NULL;
+
+CELL * nilCell;
+CELL * trueCell;
+CELL * lastCellCopied;
+CELL * countCell;
+SYMBOL * nilSymbol;
+SYMBOL * trueSymbol;
+SYMBOL * starSymbol;
+SYMBOL * plusSymbol;
+SYMBOL * questionSymbol;
+SYMBOL * atSymbol;
+SYMBOL * currentFunc;
+SYMBOL * argsSymbol;
+SYMBOL * mainArgsSymbol;
+SYMBOL * listIdxSymbol;
+SYMBOL * itSymbol;
+SYMBOL * sysxSymbol;
+SYMBOL * countSymbol;
+SYMBOL * beginSymbol;
+SYMBOL * expandSymbol;
+
+SYMBOL * sysSymbol[MAX_REGEX_EXP];
+
+SYMBOL * currentContext = NULL;
+SYMBOL * mainContext = NULL;
+SYMBOL * errorEvent;
+SYMBOL * timerEvent;
+SYMBOL * promptEvent;
+SYMBOL * commandEvent;
+SYMBOL * transferEvent;
+SYMBOL * readerEvent;
+
+SYMBOL * symHandler[32];
+int currentSignal = 0;
+
+SYMBOL * symbolCheck = NULL;
+CELL * stringCell = NULL;
+void * stringIndexPtr = NULL;
+
+jmp_buf errorJump;
+
+char lc_decimal_point;
+
+/* error and exception handling */
+
+#define EXCEPTION_THROW -1
+int errorReg = 0;
+CELL * throwResult;
+
+/* buffers for read-line and error reporting */
+STREAM readLineStream;
+STREAM errorStream;
+
+/* compiler */
+
+size_t cellCount = 0;
+size_t symbolCount = 0;
+
+int parStackCounter = 0;
+
+/* expression evaluation */
+
+static CELL * (*evalFunc)(CELL *) = NULL;
+
+UINT * envStack = NULL;
+UINT * envStackIdx;
+UINT * envStackTop;
+UINT * resultStack = NULL;
+UINT * resultStackIdx;
+UINT * resultStackTop;
+UINT * lambdaStack = NULL;
+UINT * lambdaStackIdx;
+
+/* internal dummy to carry FOOP object */
+SYMBOL objSymbol = {SYMBOL_GLOBAL | SYMBOL_BUILTIN, 
+    0, "container of (self)", 0, NULL, NULL, NULL, NULL};
+CELL * objCell;
+
+extern PRIMITIVE primitive[];
+
+/* debugger in nl-debug.c */
+extern char debugPreStr[];
+extern char debugPostStr[];
+extern CELL * debugPrintCell;
+
+int traceFlag = 0;
+int evalCatchFlag = 0;
+int recursionCount = 0;
+
+int prettyPrintPars = 0;
+int prettyPrintCurrent = 0;
+int prettyPrintFlags = 0;
+int prettyPrintLength = 0;
+char * prettyPrintTab = " ";
+char * prettyPrintFloat = "%1.16g";
+#define MAX_PRETTY_PRINT_LENGTH 80
+UINT prettyPrintMaxLength =  MAX_PRETTY_PRINT_LENGTH;
+int stringOutputRaw = TRUE;
+
+#define pushLambda(A) (*(lambdaStackIdx++) = (UINT)(A))
+
+int pushResultFlag = TRUE;
+
+char startupDir[PATH_MAX]; /* start up directory, if defined via -w */
+char * tempDir; /* /tmp on unix or geten("TMP") on Windows */
+char logFile[PATH_MAX]; /* logFile, is define with -l, -L */
+
+/* nl-filesys.c */
+int pagesize;
+
+/* ============================== MAIN ================================ */
+
+#ifndef EMSCRIPTEN
+/*
+void setupSignalHandler(int sig, void (* handler)(int))
+{
+static struct sigaction sig_act;
+sig_act.sa_handler = handler;
+sigemptyset(&sig_act.sa_mask);
+sig_act.sa_flags = SA_RESTART | SA_NOCLDSTOP;
+if(sigaction(sig, &sig_act, 0) != 0)
+    printf("Error setting signal:%d handler\n", sig);
+}
+*/
+void setupSignalHandler(int sig, void (* handler)(int))
+{
+if(signal(sig, handler) == SIG_ERR)
+    printf("Error setting signal:%d handler\n", sig);
+}
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+void sigpipe_handler(int sig)
+{
+setupSignalHandler(SIGPIPE, sigpipe_handler);
+}
+
+void sigchld_handler(int sig)
+{
+waitpid(-1, (int *)0, WNOHANG);
+}
+
+void ctrlC_handler(int sig) 
+{
+char chr; 
+
+setupSignalHandler(SIGINT, ctrlC_handler);
+
+traceFlag |= TRACE_SIGINT;
+
+printErrorMessage(ERR_SIGINT, NULL, 0);
+printf("%s", "(c)ontinue, e(x)it, (r)eset:");
+fflush(NULL);
+chr = getchar();
+if(chr == 'x') exit(1);
+if(chr == 'c') traceFlag &= ~TRACE_SIGINT;
+}
+
+
+void sigalrm_handler(int sig)
+{
+setupSignalHandler(sig, sigalrm_handler);
+/* check if not sitting idle */
+if(recursionCount)
+  traceFlag |= TRACE_TIMER;
+else /* if idle */
+  executeSymbol(timerEvent, NULL, NULL);
+}
+
+#endif /* SOLARIS, TRUE64, AIX */
+
+
+void setupAllSignals(void)
+{
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+setupSignalHandler(SIGINT, ctrlC_handler);
+#else
+setupSignalHandler(SIGINT, signal_handler);
+#endif
+
+#ifndef WINDOWS
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+setupSignalHandler(SIGALRM, sigalrm_handler);
+setupSignalHandler(SIGVTALRM, sigalrm_handler);
+setupSignalHandler(SIGPROF, sigalrm_handler);
+setupSignalHandler(SIGPIPE, sigpipe_handler);
+setupSignalHandler(SIGCHLD, sigchld_handler);
+#else
+setupSignalHandler(SIGALRM, signal_handler);
+setupSignalHandler(SIGVTALRM, signal_handler);
+setupSignalHandler(SIGPROF, signal_handler);
+setupSignalHandler(SIGPIPE, signal_handler);
+setupSignalHandler(SIGCHLD, signal_handler);
+#endif
+
+#endif
+}
+
+void signal_handler(int sig)
+{
+#ifndef WINDOWS
+char chr; 
+#endif
+
+if(sig > 32 || sig < 1) return;
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+switch(sig)
+  {
+  case SIGALRM:
+  case SIGVTALRM:
+  case SIGPROF:
+    setupSignalHandler(sig, sigalrm_handler);
+    break;
+  case SIGPIPE:
+    setupSignalHandler(SIGPIPE, sigpipe_handler);
+    break;
+  case SIGCHLD:
+    setupSignalHandler(SIGCHLD, sigchld_handler);
+    break;
+  }
+#else
+setupSignalHandler(sig, signal_handler);
+#endif
+
+if(symHandler[sig - 1] != nilSymbol)
+    {
+    if(recursionCount)
+        {
+        currentSignal = sig;
+        traceFlag |= TRACE_SIGNAL;
+        return;
+        }
+    else
+        {
+        executeSymbol(symHandler[sig-1], stuffInteger(sig), NULL);
+        return;
+        }
+    }
+
+switch(sig)
+    {
+    case SIGINT:
+        printErrorMessage(ERR_SIGINT, NULL, 0);
+
+#ifdef WINDOWS
+        traceFlag |= TRACE_SIGINT;
+#else
+        printf("%s", "\n(c)ontinue, (d)ebug, e(x)it, (r)eset:");
+        fflush(NULL);
+        chr = getchar();
+        if(chr == 'x') exit(1);
+        if(chr == 'd') 
+            {
+            traceFlag &= ~TRACE_SIGINT;
+            openTrace();
+            }
+        if(chr == 'r') traceFlag |= TRACE_SIGINT;
+        break;
+    case SIGPIPE:
+        break;
+    case SIGALRM:
+    case SIGVTALRM:
+    case SIGPROF:
+        /* check if not sitting idle */
+        if(recursionCount)
+            traceFlag |= TRACE_TIMER;
+        else /* if idle */
+            executeSymbol(timerEvent, NULL, NULL);
+        break;
+    case SIGCHLD:
+        waitpid(-1, (int *)0, WNOHANG);
+#endif
+        break;
+    default:
+        return;
+    }   
+}
+#endif /* no EMSCRIPTEN */
+ 
+char * which(char * name, char * buff)
+{
+char *path_list, *test, *tmp, *path_parsed;
+struct stat filestat;
+int count = 1;
+int i, len, nlen;
+int found = FALSE;
+
+path_list = getenv("PATH");
+if (!path_list) path_list = "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin";
+
+len = strlen(path_list);
+nlen = strlen(name);
+path_parsed = alloca(len + 1);
+strncpy(path_parsed, path_list, len + 1);
+
+test = path_parsed;
+while (TRUE) 
+    {
+#ifdef WINDOWS
+    tmp = strchr(test, ';');
+#else
+    tmp = strchr(test, ':');
+#endif
+    if (tmp == NULL) break;
+    *tmp = 0;
+    test = tmp + 1;
+    count++;
+    }   
+
+test = path_parsed;
+for (i = 0; i < count; i++) 
+    {
+    len = strlen(test);
+    if((len + nlen + 2) > PATH_MAX) 
+	    return(NULL);
+    strncpy(buff, test, len + 1);
+    buff[len] = '/';
+    memcpy(buff + len + 1, name, nlen);
+    buff[len + 1 + nlen] = 0;
+    if (stat (buff, &filestat) == 0 && filestat.st_mode & S_IXUSR)
+        {
+        found = TRUE;
+        break;
+        }
+    test += (len + 1);
+    }
+
+if(!found) return(NULL);
+errno = 0;
+return(buff);
+}
+
+#ifndef LIBRARY
+void loadStartup(char * name)
+{
+char initFile[PATH_MAX];
+char * envPtr;
+int len;
+
+/* normal newLISP start up */
+if(strncmp(linkOffset + 4, "@@@@", 4) == 0)
+    {
+    if(getenv("HOME"))
+        strncpy(initFile, getenv("HOME"), PATH_MAX - 16);
+    else if(getenv("USERPROFILE"))
+        strncpy(initFile, getenv("USERPROFILE"), PATH_MAX - 16);
+    else if(getenv("DOCUMENT_ROOT"))
+        strncpy(initFile, getenv("DOCUMENT_ROOT"), PATH_MAX - 16);
+
+    len = strlen(initFile);
+    memcpy(initFile + len, "/.", 2);
+    memcpy(initFile + len + 2, INIT_FILE, 8);
+    initFile[len + 2 + 8] = 0;
+    if(loadFile(initFile, 0, 0, mainContext) == NULL)
+        {
+        envPtr = getenv("NEWLISPDIR");
+        if(envPtr)
+            {
+            strncpy(initFile, envPtr, PATH_MAX - 16);
+            len = strlen(envPtr);
+            memcpy(initFile + len, "/", 1);
+            memcpy(initFile + len + 1, INIT_FILE, 8);
+            initFile[len + 1 + 8] = 0;
+            loadFile(initFile, 0, 0, mainContext);      
+            }
+        }
+    }
+/* load part at offset no init.lsp or .init.lsp is loaded */
+else
+    {
+#ifdef WINDOWS
+	name = win_getExePath(alloca(MAX_PATH));
+    loadFile(name, *(unsigned int *)linkOffset, 1, mainContext);
+#else /* if not Win32 get full pathname of file in name */
+    if(strchr(name, '/') == NULL) 
+        if((name = which(name, alloca(PATH_MAX))) == NULL)
+            {
+            printf("%s: %s\n", strerror(ENOENT), name);
+            exit(ENOENT);
+            }
+    loadFile(name, *(unsigned int *)linkOffset, 1, mainContext);
+#endif
+    }
+}
+#endif /* LIBRARY */
+
+#ifdef _BSD
+struct lconv    *localeconv(void);
+char            *setlocale(int, const char *);  
+#endif
+
+void initLocale(void)
+{
+#ifndef ANDROID
+struct lconv * lc;
+#endif
+char * locale;
+
+#ifndef SUPPORT_UTF8
+locale = setlocale(LC_ALL, "C");
+#else
+locale = setlocale(LC_ALL, "");
+#endif
+
+if (locale != NULL)
+  stringOutputRaw = (strcmp(locale, "C") == 0);
+
+#ifdef ANDROID
+lc_decimal_point = '.';
+#else
+lc = localeconv();
+lc_decimal_point = *lc->decimal_point;
+#endif
+}
+
+/* set NEWLISPDIR only if not set already */
+void initNewlispDir(void)
+{
+#ifdef WINDOWS
+char * varValue;
+char * newlispDir;
+int len;
+
+if(getenv("NEWLISPDIR") == NULL)
+    {
+    newlispDir = alloca(MAX_PATH);
+    varValue = getenv("PROGRAMFILES");
+    if(varValue != NULL)
+        {
+        len = strlen(varValue);
+        strncpy(newlispDir, varValue, MAX_PATH - 12);
+        memcpy(newlispDir + len, "/newlisp", 8);
+        newlispDir[len + 8] = 0; 
+        setenv("NEWLISPDIR", newlispDir, TRUE);
+        }
+    else setenv("NEWLISPDIR", "newlisp", TRUE);
+    }
+#else
+if(getenv("NEWLISPDIR") == NULL)
+    setenv("NEWLISPDIR", NEWLISPDIR, TRUE);
+#endif
+}
+
+void initTempDir()
+{
+#ifdef WINDOWS
+if((tempDir = getenv("TMP")) == NULL)
+    {
+    printf("Environment variable TMP not set, assuming /tmp .");
+    tempDir = "/tmp";
+    }
+#else
+#ifdef ANDROID
+tempDir = "/data/tmp";
+#else /* all UNIX */
+tempDir = "/tmp";
+#endif
+#endif
+return;
+}
+
+#ifndef  LIBRARY
+char * getArg(char * * arg, int argc, int * index)
+{
+if(strlen(arg[*index]) > 2)
+    return(arg[*index] + 2);
+
+if(*index >= (argc - 1))
+    {
+    printf("missing parameter for %s\n", arg[*index]);
+    exit(-1);
+    }
+
+*index = *index + 1;
+
+return(arg[*index]);
+}
+
+#ifndef WINDOWS
+char ** MainArgs;
+#endif 
+
+CELL * getMainArgs(char * mainArgs[])
+{
+CELL * argList;
+int idx = 0;
+
+#ifndef WINDOWS
+MainArgs = mainArgs;
+#endif
+
+argList = getCell(CELL_EXPRESSION);
+
+while(mainArgs[idx] != NULL)
+    addList(argList, stuffString(mainArgs[idx++]));
+
+return(argList);
+}
+
+char * getCommandLine(int batchMode, int * length);
+    
+int main(int argc, char * argv[])
+{
+char command[MAX_COMMAND_LINE];
+STREAM cmdStream = {NULL, NULL, 0, 0, 0};
+char * cmd;
+int idx;
+
+#ifdef WINDOWS
+WSADATA WSAData;
+if(WSAStartup(MAKEWORD(2,2), &WSAData) != 0)
+    {
+    printf("Winsocket initialization failed\n");
+    exit(-1);
+    }
+pagesize = 4096;
+
+/* replace '_CRT_fmode = _O_BINARY' in nl-filesys.c for 10.4.8, thanks to Kosh */
+_setmode(_fileno(stdin), _O_BINARY);
+_setmode(_fileno(stdout), _O_BINARY);
+_setmode(_fileno(stderr), _O_BINARY);
+#endif
+
+#ifdef SUPPORT_UTF8
+opsys += 128;
+#endif
+
+#ifdef NEWLISP64
+opsys += 256;
+#endif
+
+#ifdef FFI
+opsys += 1024;
+initFFI();
+#endif
+
+#ifndef WINDOWS
+#ifndef OS2
+pagesize = getpagesize();
+#endif
+tzset();
+#endif
+
+#ifdef OS2
+/* Reset the floating point coprocessor */
+_fpreset();
+#endif
+
+initLocale();
+initNewlispDir();
+initTempDir();
+
+IOchannel = stdin;
+bigEndian = (*((char *)&bigEndian) == 0);
+
+initStacks();
+initialize();
+initDefaultInAddr(); 
+
+#ifdef WINDOWS
+#ifdef SUPPORT_UTF8
+ {
+   /*
+     command line parameter is MBCS.
+     MBCS -> Unicode(UTF-16) -> UTF-8
+   */
+   char **argv_utf8 = allocMemory((argc + 1)* sizeof(char *)) ;
+   {
+   for(idx = 0 ; idx<argc ; idx++)
+      {
+      WCHAR *p_argvW = ansi_mbcs_to_utf16(argv[idx]) ;
+      char *p_argvU = utf16_to_utf8(p_argvW) ;
+      argv_utf8[idx] = p_argvU ;
+      }
+   argv_utf8[idx] = NULL ;
+   argv = argv_utf8 ;
+   }
+ }
+#endif
+#endif
+mainArgsSymbol->contents = (UINT)getMainArgs(argv);
+
+if((errorReg = setjmp(errorJump)) != 0) 
+    {
+    if((errorEvent != nilSymbol) || (errorReg == ERR_USER_RESET)) 
+        executeSymbol(errorEvent, NULL, NULL);
+    else exit(-1);
+    goto AFTER_ERROR_ENTRY;
+    }
+
+setupAllSignals();
+
+sysEvalString(preLoad, mainContext, nilCell, EVAL_STRING);
+
+/* loading of init.lsp can be suppressed with -n as first option
+   but is never done when program is link.lsp'd */
+
+if(argc < 2 || strncmp(argv[1], "-n", 2))
+    {
+    if(!(argc >= 2 && strcmp(argv[1], "-x") == 0)) 
+        loadStartup(argv[0]);
+    }
+   
+errno = 0;
+
+if(realpath(".", startupDir) == NULL)
+    fatalError(ERR_IO_ERROR, 0, 0);
+
+for(idx = 1; idx < argc; idx++)
+    {
+    if(strncmp(argv[idx], "-c", 2) == 0)
+        {
+        noPromptMode = TRUE;
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-C", 2) == 0)
+        {
+        forcePromptMode = TRUE;
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-http", 5) == 0)
+        {
+        noPromptMode = TRUE;
+        httpMode = TRUE;
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-s", 2) == 0)
+        {
+        MAX_CPU_STACK = atoi(getArg(argv, argc, &idx));
+
+        if(MAX_CPU_STACK < 1024) MAX_CPU_STACK = 1024;
+        initStacks();
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-p", 2) == 0 || strncmp(argv[idx], "-d", 2) == 0  )
+        {
+        if(strncmp(argv[idx], "-d", 2) == 0)
+            daemonMode = TRUE;
+
+        IOdomain = getArg(argv, argc, &idx);
+        IOport = atoi(IOdomain);
+
+        setupServer(0);
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-t", 2) == 0)
+        {
+        connectionTimeout = atoi(getArg(argv, argc, &idx));
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-l", 2) == 0 || strncmp(argv[idx], "-L", 2) == 0)
+        {
+        logTraffic = (strncmp(argv[idx], "-L", 2) == 0) ? LOG_MORE : LOG_LESS;
+        if(realpath(getArg(argv, argc, &idx), logFile) == NULL)
+            close(openFile(logFile, "w", 0));
+
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-m", 2) == 0)
+        {
+#ifndef NEWLISP64
+        MAX_CELL_COUNT =  abs(0x0010000 * atoi(getArg(argv, argc, &idx)));
+#else
+        MAX_CELL_COUNT =  abs(0x0008000 * atoi(getArg(argv, argc, &idx)));
+#endif
+        continue;
+        }
+
+    if(strncmp(argv[idx], "-w", 2) == 0)
+        {
+        if(realpath(getArg(argv, argc, &idx), startupDir) == NULL 
+                                        || chdir(startupDir) < 0)
+            fatalError(ERR_WORKING_DIR, 0, 0);
+        continue;
+        }   
+
+    if(strcmp(argv[idx], "-6") == 0)
+        {
+        ADDR_FAMILY = AF_INET6;
+        initDefaultInAddr(); 
+        continue;
+        }
+
+    if(strcmp(argv[idx], "-v") == 0)
+        {
+        varPrintf(OUT_CONSOLE, banner, OSTYPE, LIBFFI, ".");
+        exit(0);
+        }
+
+    if(strncmp(argv[idx], "-e", 2) == 0)
+        {
+        executeCommandLine(getArg(argv, argc, &idx), OUT_CONSOLE, &cmdStream);
+        exit(0);
+        }       
+
+    if(strncmp(argv[idx], "-x", 2) == 0)
+        {
+        if(argc == 4)
+            linkSource(argv[0], argv[idx + 1], argv[idx + 2]);
+        exit(0);
+        }
+
+    if(strcmp(argv[idx], "-h") == 0)
+        {
+        printHelpText();
+        exit(0);
+        }
+    
+    loadFile(argv[idx], 0, 0, mainContext);
+    }
+
+AFTER_ERROR_ENTRY:
+
+if(isatty(fileno(IOchannel)))
+    {
+    isTTY = TRUE;
+    if(!noPromptMode)   
+        varPrintf(OUT_CONSOLE, banner, OSTYPE, LIBFFI, banner2);
+    }
+else
+    {
+#ifdef WINDOWS
+    if(!IOchannelIsSocketStream) 
+#endif
+        setbuf(IOchannel,0);
+    if(forcePromptMode)
+        varPrintf(OUT_CONSOLE, banner, OSTYPE, LIBFFI, banner2);
+    }
+
+/* ======================= main entry on reset ====================== */
+
+
+errorReg = setjmp(errorJump);
+
+setupAllSignals();
+reset();
+initStacks();
+
+if(errorReg && !isNil((CELL*)errorEvent->contents) ) 
+    executeSymbol(errorEvent, NULL, NULL);
+
+
+#ifdef READLINE
+rl_readline_name = "newlisp";
+rl_attempted_completion_function = (char ** (*) (const char *, int, int))newlisp_completion;
+#if defined(LINUX) || defined(_BSD)
+/* in Bash .inputrc put 'set blink-matching-paren on' */
+rl_set_paren_blink_timeout(300000); /* 300 ms */
+#endif
+#endif
+
+while(TRUE)
+    {
+    cleanupResults(resultStack);
+    if(isTTY)  
+        {
+        cmd = getCommandLine(FALSE, NULL);
+        executeCommandLine(cmd, OUT_CONSOLE, &cmdStream);
+        free(cmd);
+        continue;
+        }
+
+    if(IOchannel != stdin || forcePromptMode) 
+        varPrintf(OUT_CONSOLE, "%s", prompt());
+
+    /* daemon mode timeout if nothing read after accepting connection */
+    if(connectionTimeout && IOchannel && daemonMode)
+        {
+#ifdef WINDOWS
+        if(IOchannelIsSocketStream)
+          if(wait_ready(getSocket(IOchannel), connectionTimeout, 0) == 0)
+#else
+        if(wait_ready(fileno(IOchannel), connectionTimeout, 0) == 0)
+#endif
+            {
+            fclose(IOchannel);
+            setupServer(1);
+            continue;
+            }
+        }
+
+    if(IOchannel == NULL || fgets(command, MAX_COMMAND_LINE - 1, IOchannel) == NULL)
+        {
+        if(!daemonMode)  exit(1);
+        if(IOchannel != NULL) fclose(IOchannel);
+        setupServer(1);
+        continue;
+        }
+
+    executeCommandLine(command, OUT_CONSOLE, &cmdStream);
+    }
+
+#ifndef WINDOWS
+return 0;
+#endif
+}
+#endif /* not LIBRARY */
+
+#ifdef READLINE
+char * command_generator(char * text, int state)
+{
+static int list_index, len, clen;
+char * name;
+     
+if (!state)
+    {
+    list_index = 0;
+    len = strlen (text);
+    }
+     
+while((name = primitive[list_index].name))
+    {
+    list_index++;
+     
+    if (strncmp (name, text, len) == 0)
+        {
+        clen = strlen(name) + 1;
+        return(strncpy(malloc(clen), name, clen));
+        }
+    }
+     
+return ((char *)NULL);
+}
+
+char ** completion_matches(const char * text,  char * (*commands)(const char *, int)); 
+
+char ** newlisp_completion (char * text, int start, int end)
+{
+return(completion_matches(text,  (char * (*) (const char *, int) )command_generator));
+}
+
+#endif /* READLINE */
+
+
+char * getCommandLine(int batchMode, int * length)
+{
+char * cmd;
+int len;
+
+#ifndef READLINE
+if(!batchMode) varPrintf(OUT_CONSOLE, "%s", prompt());
+cmd = calloc(MAX_COMMAND_LINE + 4, 1);
+if(fgets(cmd, MAX_COMMAND_LINE - 1, IOchannel) == NULL) 
+    {
+    puts("");
+    exit(0);
+    }
+len = strlen(cmd);
+/* cut off line terminators  left by fgets */
+*(cmd + len - LINE_FEED_LEN) = 0;
+len -= LINE_FEED_LEN; /* v.10.6.2 */
+#else /*  READLINE */
+int errnoSave = errno;
+if((cmd = readline(batchMode ? "" : prompt())) == NULL) 
+    {
+    puts("");
+    exit(0);
+    }
+errno = errnoSave; /* reset errno, set by readline() */
+len = strlen(cmd);
+if(len > 0) 
+    add_history(cmd);
+#endif  
+
+if(length != NULL) *length = len;
+return(cmd);
+}
+
+#ifndef LIBRARY
+
+void printHelpText(void)
+{
+varPrintf(OUT_CONSOLE, copyright, 
+    "usage: newlisp [file | url ...] [options ...] [file | url ...]\n\noptions:");
+varPrintf(OUT_CONSOLE, 
+    "%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n\n",
+    " -h this help",
+    " -n no init.lsp (must be first)",
+    " -x <source> <target> link",
+    " -v version",
+    " -s <stacksize>",
+    " -m <max-mem-MB> cell memory",
+    " -e <quoted lisp expression>",
+    " -l <path-file> log connections",
+    " -L <path-file> log all",
+    " -w <working dir>",
+    " -c no prompts, net-eval, HTTP",
+    " -C force prompts",
+    " -t <usec-server-timeout>",
+    " -p <port-no>",
+    " -d <port-no> daemon mode",
+    " -http only mode",
+    " -6 IPv6 mode",
+    "\nmore info at http://newlisp.org");
+}
+
+void setupServer(int reconnect)
+{
+if((IOchannel  = serverFD(IOport,  IOdomain, reconnect)) == NULL)
+    {
+    printf("newLISP server setup on %s failed.\n", IOdomain);
+    exit(1);
+    }
+
+#ifdef WINDOWS
+else    IOchannelIsSocketStream = TRUE; 
+
+if(!IOchannelIsSocketStream)
+#endif
+    setbuf(IOchannel,0);
+
+if(!reconnect && !noPromptMode)
+    varPrintf(OUT_CONSOLE, banner, OSTYPE, LIBFFI, ".");
+}
+
+#endif /* ifndef LIBRARY */
+
+char * prompt(void)
+{
+char * contextName = "";
+CELL * result;
+static char string[64];
+
+if(evalSilent || noPromptMode) 
+    {
+    evalSilent = 0;
+    return("");
+    }
+
+if(promptEvent != nilSymbol)
+    {
+    if(executeSymbol(promptEvent, stuffSymbol(currentContext), &result) == CELL_STRING)
+        {
+        strncpy(string, (char *)result->contents, 64);
+        string[63] = 0;
+        deleteList(result);
+        return(string);
+        }
+    deleteList(result);
+    }
+    
+if(currentContext != mainContext)
+    contextName = currentContext->name;
+
+if(traceFlag & TRACE_SIGINT) 
+    {
+    traceFlag &= ~TRACE_SIGINT;
+    longjmp(errorJump, errorReg);
+    }
+    
+if(traceFlag && !(traceFlag & TRACE_PRINT_EVAL))
+    snprintf(string, 63, "%d %s> ", recursionCount, contextName);
+else
+    snprintf(string, 63, "%s> ", contextName);
+
+return(string);
+}
+
+
+void reset()
+{
+recoverEnvironment(envStack);
+
+while(resultStackIdx > resultStack)
+    deleteList(popResult());
+
+envStackIdx = envStack;
+lambdaStackIdx = lambdaStack;
+
+freeCellBlocks();
+
+if(printDevice) close((int)printDevice);
+printDevice = recursionCount  = traceFlag = prettyPrintFlags = 0;
+evalFunc = NULL;
+#ifdef XML_SUPPORT
+xmlTags = NULL; /* force recreation */
+#endif
+pushResultFlag = TRUE;
+currentContext = mainContext;
+itSymbol->contents = (UINT)nilCell;
+}
+
+
+void recoverEnvironment(UINT * index)
+{
+SYMBOL * symbol;
+CELL * cell;
+
+while(envStackIdx > index)
+    {
+    symbol = (SYMBOL *)popEnvironment();
+    cell = (CELL*)popEnvironment();
+    if(cell != (CELL*)symbol->contents)
+        {
+        deleteList((CELL*)symbol->contents);
+        symbol->contents = (UINT)cell;
+        }
+    }
+}
+
+
+char * processCommandEvent(char * command);
+
+void executeCommandLine(char * command, UINT outDevice, STREAM * cmdStream)
+{
+STREAM stream;
+char buff[MAX_COMMAND_LINE];
+char * cmd;
+int batchMode = 0;
+int len;
+
+memset(buff + MAX_COMMAND_LINE -2, 0, 2);
+
+if(memcmp(command, "[cmd]", 5) == 0)
+    batchMode = 2;
+else if(isTTY && (*command == '\n' || *command == '\r' || *command == 0))
+    batchMode = 1;
+
+#ifndef LIBRARY
+if(!batchMode && commandEvent != nilSymbol)
+    command = processCommandEvent(command);
+#endif
+
+if(!isTTY && (*command == '\n' || *command == '\r' || *command == 0)) return;
+
+if(!batchMode) 
+    {
+    if(logTraffic == LOG_MORE) 
+        writeLog(command, TRUE);
+#ifndef LIBRARY
+    if(strncmp(command, "GET /", 5) == 0) 
+        executeHTTPrequest(command + 5, HTTP_GET);
+    else if(strncmp(command, "HEAD /", 6) == 0)
+        executeHTTPrequest(command + 6, HTTP_HEAD);
+    else if(strncmp(command, "PUT /", 5) == 0)
+        executeHTTPrequest(command + 5, HTTP_PUT);
+    else if(strncmp(command, "POST /", 6) == 0)
+        executeHTTPrequest(command + 6, HTTP_POST);
+    else if(strncmp(command, "DELETE /", 8) == 0)
+        executeHTTPrequest(command + 8, HTTP_DELETE);
+#endif
+    else if(!httpMode) goto EXEC_COMMANDLINE;
+    return;
+    }
+
+if(httpMode) goto RETURN_BATCHMODE;
+
+EXEC_COMMANDLINE:
+if(noPromptMode == FALSE && *command == '!' && *(command + 1) != ' ' && strlen(command) > 1)
+    {
+    if(system(command + 1)) return; /* avoid stupid compiler warning */
+    return;
+    }
+    
+if(cmdStream != NULL && batchMode)
+    {
+    openStrStream(cmdStream, 1024, TRUE);
+    for(;;)
+        {
+        if(isTTY) 
+            {
+            cmd = getCommandLine(TRUE, &len);
+            if(len > (MAX_COMMAND_LINE - 3))
+                len = MAX_COMMAND_LINE - 3;
+            memcpy(buff, cmd, len);
+            memcpy(buff + len, LINE_FEED, LINE_FEED_LEN);
+            buff[len + LINE_FEED_LEN] = 0; 
+            free(cmd);
+            }
+        else
+            if(fgets(buff, MAX_COMMAND_LINE - 1, IOchannel) == NULL) break;
+        if( (memcmp(buff, "[/cmd]", 6) == 0 && batchMode == 2) || 
+                (batchMode == 1 && (*buff == '\n' || *buff == '\r' || *buff == 0)))
+            {
+            if(logTraffic) 
+                writeLog(cmdStream->buffer, 0);
+            makeStreamFromString(&stream, cmdStream->buffer);
+            evaluateStream(&stream, outDevice, 0);
+            return;
+            }
+        writeStreamStr(cmdStream, buff, 0);
+        }
+    closeStrStream(cmdStream);
+RETURN_BATCHMODE:
+    if(!daemonMode)  exit(1);
+    if(IOchannel != NULL) fclose(IOchannel);
+#ifndef LIBRARY
+    setupServer(1);
+#endif
+    return;
+    }
+
+if(logTraffic == LOG_LESS) writeLog(command, TRUE);
+prettyPrintLength = 0;
+
+makeStreamFromString(&stream, command);
+evaluateStream(&stream, outDevice, 0);
+}
+
+char * processCommandEvent(char * command)
+{
+CELL * result;
+
+if(executeSymbol(commandEvent, stuffString(command), &result) == CELL_STRING)
+    {
+    pushResult(result);
+    command = (char *)result->contents;
+    }
+
+return(command);
+}
+
+/*
+void printResultStack()
+{
+printf("result stack:\n");
+while(resultStackIdx > resultStack)
+    {
+    --resultStackIdx;
+    printCell(*resultStackIdx, TRUE, OUT_CONSOLE);
+    printf("\n");
+    }
+printf("\n");
+}
+*/
+
+/* used for loadFile() and and executeCommandLine() */
+CELL * evaluateStream(STREAM * stream, UINT outDevice, int flag)
+{
+CELL * program;
+CELL * eval = nilCell;
+CELL * xlate;
+UINT * resultIdxSave = resultStackIdx;
+int result = TRUE;
+
+while(result)
+    {
+    pushResult(program = getCell(CELL_QUOTE));
+    result = compileExpression(stream, program);
+    if(readerEvent != nilSymbol && result)
+        {
+        --resultStackIdx; /* program cell consumed by executeSymbol() */
+        executeSymbol(readerEvent, program, &xlate);
+        pushResult(program = makeCell(CELL_QUOTE, (UINT)xlate));
+        }
+    if(result)
+        {
+        if(flag && eval != nilCell) deleteList(eval);
+        eval = evaluateExpression((CELL *)program->contents);
+        if(outDevice != 0 && !evalSilent) 
+            {
+            printCell(eval, TRUE, outDevice);
+            varPrintf(outDevice, "\n");
+            if(logTraffic == LOG_MORE)
+                {
+                writeLog("-> ", 0);
+                printCell(eval, TRUE, OUT_LOG);
+                writeLog("", TRUE);
+                }
+#ifdef EMSCRIPTEN
+            if(outDevice) fflush(NULL);
+#endif
+            }
+        if(flag) eval = copyCell(eval);
+        }
+    cleanupResults(resultIdxSave);
+    }
+
+if(flag) return(eval);
+return(NULL);
+}
+
+
+int executeSymbol(SYMBOL * symbol, CELL * params, CELL * * result)
+{
+CELL * program;
+CELL * cell;
+UINT * resultIdxSave = resultStackIdx;
+
+if(symbol == nilSymbol || symbol == trueSymbol || symbol == NULL)   return(0);
+pushResult(program = getCell(CELL_EXPRESSION));
+cell = makeCell(CELL_SYMBOL, (UINT)symbol);
+program->contents = (UINT)cell;
+if(params != NULL) cell->next = params;
+
+if(result == NULL)
+    {
+    evaluateExpression(program);
+    cleanupResults(resultIdxSave);
+    return(0);
+    }
+
+*result = copyCell(evaluateExpression(program));
+cleanupResults(resultIdxSave);
+
+return((*result)->type);
+}
+
+
+/* -------------------------- initialization -------------------- */
+
+void initialize()
+{
+SYMBOL * symbol;
+CELL * pCell;
+char  symName[8];
+int i;
+
+/* build true and false cells */
+nilCell = getCell(CELL_NIL);
+nilCell->aux = nilCell->contents = (UINT)nilCell;
+nilCell->next =  nilCell;
+
+trueCell = getCell(CELL_TRUE);
+trueCell->contents = (UINT)trueCell;
+
+/* make first symbol, which is context MAIN */
+currentContext = createRootContext("MAIN");
+
+/* build symbols for primitives */
+for(i = 0; primitive[i].name != NULL; i++)
+    {
+    pCell = getCell(CELL_PRIMITIVE);
+    symbol = translateCreateSymbol(
+        primitive[i].name, CELL_PRIMITIVE, mainContext, TRUE);
+    symbol->contents = (UINT)pCell;
+    symbol->flags = primitive[i].flags | SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+    pCell->contents = (UINT)primitive[i].function;
+    pCell->aux = (UINT)symbol->name;
+    }
+
+/* build nil, true, * and ? symbols and others  */
+nilSymbol = translateCreateSymbol("nil", CELL_NIL, mainContext, TRUE);
+nilSymbol->contents = (UINT)nilCell;
+trueSymbol = translateCreateSymbol("true", CELL_TRUE, mainContext, TRUE);
+trueSymbol->contents = (UINT)trueCell;
+starSymbol = translateCreateSymbol("*", CELL_PRIMITIVE, mainContext, TRUE);
+plusSymbol = translateCreateSymbol("+", CELL_PRIMITIVE, mainContext, TRUE);
+questionSymbol = translateCreateSymbol("?", CELL_NIL, mainContext, TRUE);
+atSymbol = translateCreateSymbol("@", CELL_NIL, mainContext, TRUE);
+argsSymbol = translateCreateSymbol("$args", CELL_NIL, mainContext, TRUE);
+mainArgsSymbol = translateCreateSymbol("$main-args", CELL_NIL, mainContext, TRUE);
+listIdxSymbol = translateCreateSymbol("$idx", CELL_NIL, mainContext, TRUE);
+itSymbol = translateCreateSymbol("$it", CELL_NIL, mainContext, TRUE);
+countSymbol = translateCreateSymbol("$count", CELL_NIL, mainContext, TRUE);
+sysxSymbol = translateCreateSymbol("$x", CELL_NIL, mainContext, TRUE);
+beginSymbol = translateCreateSymbol("begin", CELL_NIL, mainContext, TRUE);
+expandSymbol = translateCreateSymbol("expand", CELL_NIL, mainContext, TRUE);
+
+symbol = translateCreateSymbol("ostype", CELL_STRING, mainContext, TRUE);
+symbol->flags = SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+symbol->contents = (UINT)stuffString(OSTYPE);
+
+for(i = 0; i < MAX_REGEX_EXP; i++)
+    {
+    snprintf(symName, 8, "$%d", i);
+    sysSymbol[i] = translateCreateSymbol(symName, CELL_NIL, mainContext, TRUE);
+    sysSymbol[i]->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN;
+    }
+
+currentFunc = errorEvent = timerEvent = promptEvent = commandEvent = transferEvent = readerEvent = nilSymbol;
+
+trueSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+nilSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+questionSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+atSymbol->flags |=  SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+argsSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+mainArgsSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+listIdxSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+itSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+countSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN | SYMBOL_PROTECTED;
+sysxSymbol->flags |= SYMBOL_GLOBAL | SYMBOL_BUILTIN;
+
+countCell = stuffInteger(0);
+countSymbol->contents = (UINT)countCell ;
+argsSymbol->contents = (UINT)getCell(CELL_EXPRESSION);
+objSymbol.contents = (UINT)nilCell;
+objSymbol.context = mainContext;
+objCell = nilCell;
+
+/* init signal handlers */
+for(i = 0; i < 32; i++)
+  symHandler[i] = nilSymbol;
+
+/* init system wide string streams */
+openStrStream(&readLineStream, 16, 0);
+openStrStream(&errorStream, MAX_LINE, 0);
+}
+
+void initStacks()
+{
+MAX_ENV_STACK = (MAX_CPU_STACK * 8 * 2);
+MAX_RESULT_STACK = (MAX_CPU_STACK * 2);
+if(envStack != NULL) freeMemory(envStack);
+if(resultStack != NULL) freeMemory(resultStack);
+if(lambdaStack != NULL) freeMemory(lambdaStack);
+envStackIdx = envStack = (UINT *)allocMemory((MAX_ENV_STACK + 16) * sizeof(UINT));
+envStackTop = envStack + MAX_ENV_STACK;
+resultStackIdx = resultStack = (UINT *)allocMemory((MAX_RESULT_STACK + 16) * sizeof(UINT));
+resultStackTop = resultStack + MAX_RESULT_STACK;
+lambdaStackIdx = lambdaStack = (UINT *)allocMemory((MAX_RESULT_STACK + 16) * sizeof(UINT));
+}
+
+    
+/* ------------------------- evaluate s-expression --------------------- */
+
+
+CELL * evaluateExpression(CELL * cell)
+{
+#ifdef ISO_C90
+CELL * result;
+UINT * resultIdxSave = resultStackIdx;
+CELL * args = NULL;
+CELL * pCell = NULL;
+SYMBOL * newContext = NULL;
+SYMBOL * sPtr = NULL;
+#endif
+
+symbolCheck = NULL;
+stringCell = NULL;
+
+if(isSelfEval(cell->type))
+    return(cell);
+
+if(cell->type == CELL_SYMBOL || cell->type == CELL_CONTEXT)
+    {
+    symbolCheck = (SYMBOL *)cell->contents;
+    return((CELL *)symbolCheck->contents);
+    }
+
+#ifndef ISO_C90
+CELL * result;
+UINT * resultIdxSave = resultStackIdx;
+CELL * args = NULL;
+CELL * pCell = NULL;
+SYMBOL * newContext = NULL;
+SYMBOL * sPtr = NULL;
+#endif
+
+switch(cell->type)
+    {
+    case CELL_QUOTE:
+        return((CELL *)cell->contents);
+
+    case CELL_EXPRESSION:
+        args = (CELL *)cell->contents;
+        if(++recursionCount > (int)MAX_CPU_STACK)
+            fatalError(ERR_OUT_OF_CALL_STACK, args, 0);
+        
+        if(args->type == CELL_SYMBOL) /* precheck for speedup */
+            {
+            sPtr = (SYMBOL *)args->contents;
+            newContext = sPtr->context;
+            pCell =  (CELL*)sPtr->contents;
+            }
+        else if(args->type == CELL_DYN_SYMBOL)
+            {
+            sPtr = getDynamicSymbol(args);
+            newContext = sPtr->context;
+            pCell = (CELL *)sPtr->contents;
+            }
+        else
+            { 
+            pCell = evaluateExpression(args);
+            newContext = currentContext;
+            }
+
+        if(traceFlag) traceEntry(cell, pCell, args);
+
+            /* check for 'default' functor
+            * allow function call with context name, i.e: (ctx)
+            * assumes that a ctx:ctx contains a function
+            */
+        if(pCell->type == CELL_CONTEXT)
+            {
+            newContext = (SYMBOL *)pCell->contents;
+            sPtr= translateCreateSymbol(newContext->name, CELL_NIL, newContext, TRUE);
+            pCell = (CELL *)sPtr->contents;
+
+            /* if the default functor contains nil, it works like a hash function */
+            if(isNil(pCell))
+                {
+                result = evaluateNamespaceHash(args->next, newContext);
+                break;
+                }
+            }
+
+        /* pCell is evaluated op element */
+        if(pCell->type == CELL_PRIMITIVE)
+            {
+            evalFunc = (CELL *(*)(CELL*))pCell->contents;
+            result = evalFunc(args->next);
+            evalFunc = NULL;
+            break;
+            }
+        
+        if(pCell->type == CELL_LAMBDA)
+            { 
+            pushLambda(cell);
+            result = evaluateLambda((CELL *)pCell->contents, args->next, newContext); 
+            --lambdaStackIdx; 
+            break; 
+            }
+        
+        if(pCell->type == CELL_FEXPR)
+            { 
+            pushLambda(cell);
+            result = evaluateLambdaMacro((CELL *)pCell->contents, args->next, newContext);
+            --lambdaStackIdx; 
+            break;
+            }
+#ifndef EMSCRIPTEN
+        /* simple ffi with CDECL or DLL and extended libffi */
+        if(pCell->type & IMPORT_MASK) 
+            {
+            result = executeLibfunction(pCell, args->next);  
+            break;
+            }
+#endif
+        /* implicit indexing or resting for list, array or string 
+        */
+        if(args->next != nilCell)
+            {
+            /* implicit indexing array */
+            if(pCell->type == CELL_EXPRESSION)
+                {
+                if(!sPtr) sPtr = symbolCheck;
+                result = implicitIndexList(pCell, args->next);
+                symbolCheck = sPtr;
+                pushResultFlag = FALSE;
+                }
+
+            /* implicit indexing array */
+            else if(pCell->type == CELL_ARRAY)
+                {
+                if(!sPtr) sPtr = symbolCheck;
+                result = implicitIndexArray(pCell, args->next);
+                symbolCheck = sPtr;
+                pushResultFlag = FALSE;
+                }   
+
+            /* implicit indexing string */
+            else if(pCell->type == CELL_STRING)
+                {
+                if(sPtr || (sPtr = symbolCheck))
+                    {
+                    result = implicitIndexString(pCell, args->next);
+                    /* result is always a copy */
+                    pushResult(result);
+                    symbolCheck = sPtr;
+                    --recursionCount;
+                    return(result);
+                    }
+                else
+                    result = implicitIndexString(pCell, args->next); 
+                }
+
+            /* implicit resting for lists and strings */
+            else if(isNumber(pCell->type))
+                result = implicitNrestSlice(pCell, args->next);
+    
+            else 
+                result = errorProcExt(ERR_INVALID_FUNCTION, cell);                              
+            } /* implixit indexing, resting on lists and strings */
+        else 
+            result = errorProcExt(ERR_INVALID_FUNCTION, cell);
+        break;
+
+    case CELL_DYN_SYMBOL:
+        symbolCheck = getDynamicSymbol(cell);
+        return((CELL *)symbolCheck->contents);
+        
+    default:
+        result = nilCell;
+    }
+
+if(pushResultFlag) 
+    {
+    if(resultStackIdx > resultStackTop)
+        fatalError(ERR_OUT_OF_CALL_STACK, pCell, 0);
+
+    while(resultStackIdx > resultIdxSave)
+        deleteList(popResult());
+
+    pushResult(result);
+    }
+else 
+    pushResultFlag = TRUE;
+
+if(traceFlag) traceExit(result, cell, pCell, args);
+--recursionCount;
+return(result);
+}
+
+
+CELL *  evaluateExpressionSafe(CELL * cell, int * errNo)
+{
+jmp_buf errorJumpSave;
+CELL * result;
+
+memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+if((*errNo = setjmp(errorJump)) != 0)
+    {
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    return(NULL);
+    }
+
+result = evaluateExpression(cell);
+memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+return(result);
+}
+
+
+CELL * evaluateNamespaceHash(CELL * args, SYMBOL * newContext)
+{   
+SYMBOL * sPtr;
+CELL * pCell;
+
+pCell = evaluateExpression(args);
+if(pCell->type == CELL_STRING || isNumber(pCell->type))
+    {
+    /* set contents */
+    if(args->next != nilCell)
+        {
+        sPtr = makeSafeSymbol(pCell, newContext, TRUE);
+        
+        itSymbol->contents = sPtr->contents; 
+        /* itSymbol may occur in evaluateExpression() */
+        itSymbol->contents = (UINT)copyCell(evaluateExpression(args->next));
+        deleteList((CELL *)sPtr->contents);
+        sPtr->contents = itSymbol->contents;
+        itSymbol->contents = (UINT)nilCell;
+        
+        if(isNil((CELL *)sPtr->contents))
+            {
+            deleteAndFreeSymbol(sPtr, FALSE);
+            return(nilCell);
+            }
+
+        symbolCheck = sPtr;
+        pushResultFlag = FALSE;
+        return((CELL *)sPtr->contents);
+        }
+    /* get contents */
+    else 
+        {
+        sPtr = makeSafeSymbol(pCell, newContext, FALSE);
+        if(sPtr == NULL)
+            return(nilCell);
+        else
+            {
+            symbolCheck = sPtr;
+            pushResultFlag = FALSE;
+            return((CELL *)sPtr->contents);
+            }
+        }
+    }
+/* create Tree from association list */
+else if(pCell->type == CELL_EXPRESSION)
+    {
+    args = (CELL *)pCell->contents;
+    while(args->type == CELL_EXPRESSION)
+        {
+        pCell = (CELL *)args->contents;
+        if(pCell->type == CELL_STRING || isNumber(pCell->type))
+            {
+            sPtr = makeSafeSymbol(pCell, newContext, TRUE);
+            deleteList((CELL *)sPtr->contents);
+            sPtr->contents = (UINT)copyCell(pCell->next);
+            }
+        args = args->next;
+        }
+    return(stuffSymbol(newContext));
+    }
+/* return association list */
+else if(pCell->type == CELL_NIL)
+    return(associationsFromTree(newContext));
+
+return(errorProcExt(ERR_INVALID_PARAMETER, pCell));
+}
+
+
+/* a symbol belonging to a dynamic context
+   the parent context symbol points to the real context  
+   cell->contents -> name str of this symbol
+   cell->aux -> symbol var which holds context (dynamic) 
+   ((SYMBOL*)cell->aux)->contents -> context cell
+ */
+SYMBOL * getDynamicSymbol(CELL * cell)
+{
+CELL * contextCell;
+
+contextCell = (CELL *)((SYMBOL *)cell->aux)->contents;
+if(contextCell->type != CELL_CONTEXT)
+    fatalError(ERR_CONTEXT_EXPECTED, stuffSymbol((SYMBOL*)cell->aux), TRUE);
+
+return(translateCreateSymbol( 
+        (char*)cell->contents, /* name of dyn symbol */
+        CELL_NIL,
+        (SYMBOL*)contextCell->contents, /* contextPtr */
+        TRUE));
+}
+
+
+void cleanupResults(UINT * from)
+{
+while(resultStackIdx > from)
+    deleteList(popResult());
+}
+
+/* -------------------- evaluate lambda function ----------------------- */
+
+CELL * evaluateLambda(CELL * localLst, CELL * arg, SYMBOL * newContext)
+{
+CELL * local;
+CELL * result = nilCell;
+CELL * cell;
+SYMBOL * symbol;
+SYMBOL * contextSave;
+UINT * resultIdxSave;
+int localCount = 1; /* 1 for $args */
+
+if(envStackIdx > envStackTop)
+    return(errorProc(ERR_OUT_OF_ENV_STACK));
+
+if(localLst->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_INVALID_LAMBDA, localLst));
+
+/* evaluate arguments */
+if(arg != nilCell)
+    {
+    /* this symbol precheck does 10% speed improvement on lambdas  */
+    if(arg->type == CELL_SYMBOL)
+        cell = result = copyCell((CELL*)((SYMBOL *)arg->contents)->contents);
+    else
+        cell = result = copyCell(evaluateExpression(arg));
+       
+    while((arg = arg->next) != nilCell)
+        {
+        if(arg->type == CELL_SYMBOL)
+            cell = cell->next = copyCell((CELL*)((SYMBOL *)arg->contents)->contents);
+        else
+            cell = cell->next = copyCell(evaluateExpression(arg));
+        }
+    }
+
+/* change to new context */
+contextSave = currentContext;
+currentContext = newContext;
+
+/* save environment and get parameters */
+local = (CELL*)localLst->contents;
+for(;;)
+    {
+    if(local->type == CELL_SYMBOL)
+        symbol = (SYMBOL *)local->contents;
+    /* get default parameters */
+    else if(local->type == CELL_EXPRESSION)
+        {
+        cell = (CELL *)local->contents;
+        if(cell->type == CELL_SYMBOL)
+            {
+            symbol = (SYMBOL *)cell->contents;
+            if(result == nilCell)
+                result = copyCell(evaluateExpression(cell->next));
+            }
+        else break;
+        }
+    else break;
+
+    if(isProtected(symbol->flags))
+        return(errorProcExt(ERR_SYMBOL_PROTECTED, local));
+
+    /* save symbol environment */
+    pushEnvironment(symbol->contents);
+    pushEnvironment((UINT)symbol);
+
+    /* fill local symbols */
+    if(result == nilCell) result = copyCell(nilCell);
+    symbol->contents = (UINT)result;
+
+    cell = result;
+    result = result->next;
+
+    /* unlink list */
+    cell->next = nilCell;
+
+    local = local->next;
+    localCount++;
+    }
+
+/* put unassigned args in protected $args */
+pushEnvironment(argsSymbol->contents);
+pushEnvironment((UINT)argsSymbol);
+argsSymbol->contents = (UINT)makeCell(CELL_EXPRESSION, (UINT)result);
+
+/* get contents for (self), is nil if no ancestor caller is colon : */
+objSymbol.contents = (UINT)objCell;
+
+#ifdef FOOP_DEBUG
+printf("objCell in lambda:");
+printCell(objCell, TRUE, OUT_CONSOLE);
+printf(" context:%s\n", currentContext->name);
+#endif
+
+/* evaluate body expressions */
+resultIdxSave = resultStackIdx;
+result = nilCell;
+while( (localLst = localLst->next) != nilCell)
+    {
+    while(resultStackIdx > resultIdxSave)
+        deleteList(popResult());
+    result = evaluateExpression(localLst);
+    }
+result = copyCell(result);
+
+/* restore symbols used as locals */
+while(localCount--)
+    {
+    symbol = (SYMBOL *)popEnvironment();
+    deleteList((CELL *)symbol->contents);
+    symbol->contents = popEnvironment();
+    }
+
+currentContext = contextSave;
+symbolCheck = NULL;
+stringCell = NULL;
+return(result);
+}
+
+
+CELL * evaluateLambdaMacro(CELL * localLst, CELL * arg, SYMBOL * newContext)
+{
+CELL * local;
+CELL * result = nilCell;
+CELL * cell;
+SYMBOL * symbol;
+SYMBOL * contextSave;
+UINT * resultIdxSave;
+int localCount = 1; /* for $args */
+
+if(envStackIdx > envStackTop)
+    return(errorProc(ERR_OUT_OF_ENV_STACK));
+
+if(localLst->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_INVALID_MACRO, localLst));
+
+local = (CELL *)localLst->contents;
+
+contextSave = currentContext;
+currentContext = newContext;
+
+/* save environment and get parameters */
+while (TRUE)
+  {
+  if(local->type == CELL_SYMBOL)
+    symbol = (SYMBOL *)local->contents;
+  /* get default parameters */
+  else if(local->type == CELL_EXPRESSION)
+        {
+        if(((CELL*)local->contents)->type == CELL_SYMBOL)
+            {
+            cell = (CELL *)local->contents;
+            if(cell->type == CELL_SYMBOL)
+                {
+                symbol = (SYMBOL *)cell->contents;
+                if(arg == nilCell)
+                    arg = evaluateExpression(cell->next);
+                }
+            else break;
+            }
+        else break;
+        }
+  else break;
+
+  if(isProtected(symbol->flags))
+    return(errorProcExt(ERR_SYMBOL_PROTECTED, local));
+
+  pushEnvironment(symbol->contents);
+  pushEnvironment((UINT)symbol);
+  symbol->contents = (UINT)copyCell(arg);
+  local = local->next;
+  arg = arg->next;
+  localCount++;
+  }
+
+/* put unassigned args in $args */
+pushEnvironment(argsSymbol->contents);
+pushEnvironment((UINT)argsSymbol);
+argsSymbol->contents = (UINT)makeCell(CELL_EXPRESSION, (UINT)copyList(arg));
+
+/* evaluate body expressions */
+resultIdxSave = resultStackIdx;
+while((localLst = localLst->next) != nilCell)
+    {
+    while(resultStackIdx > resultIdxSave)
+        deleteList(popResult());
+    result = evaluateExpression(localLst);
+    }
+result = copyCell(result);
+
+/* restore symbols used as locals */
+while(localCount--)
+    {
+    symbol = (SYMBOL *)popEnvironment();
+    deleteList((CELL *)symbol->contents);
+    symbol->contents = popEnvironment();
+    }
+
+currentContext = contextSave;   
+symbolCheck = NULL;
+stringCell = NULL;
+return(result);
+}
+
+
+/* -------------- list/cell creation/deletion routines ---------------- */
+
+
+CELL * stuffInteger(UINT contents)
+{
+CELL * cell;
+
+if(firstFreeCell == NULL) allocBlock();
+cell = firstFreeCell;
+firstFreeCell = cell->next;
+++cellCount;
+
+cell->type = CELL_LONG;
+cell->next = nilCell;
+cell->aux = (UINT)nilCell;
+cell->contents = contents;
+
+return(cell);
+}
+
+#ifndef NEWLISP64
+CELL * stuffInteger64(INT64 contents)
+{
+CELL * cell;
+
+if(firstFreeCell == NULL) allocBlock();
+cell = firstFreeCell;
+firstFreeCell = cell->next;
+++cellCount;
+
+cell->type = CELL_INT64;
+cell->next = nilCell;
+
+*(INT64 *)&cell->aux = contents;
+return(cell);
+}
+#endif
+
+CELL * stuffIntegerList(int argc, ...)
+{
+CELL * cell;
+CELL * list;
+va_list ap;
+
+va_start(ap, argc);
+
+list = makeCell(CELL_EXPRESSION, (UINT)stuffInteger(va_arg(ap, UINT)));
+cell = (CELL *)list->contents;
+
+while(--argc)
+    cell = cell->next = stuffInteger(va_arg(ap, UINT));
+
+va_end(ap);
+
+return(list);
+}
+
+#ifdef BIGINT
+CELL * stuffBigint(char * token)
+{
+int len;
+CELL * cell;
+
+cell = getCell(CELL_BIGINT);
+cell->contents = (UINT)strToBigint(token, strlen(token), &len);
+cell->aux = len + 1;
+
+return(cell);
+}
+#endif
+
+/* only safe for text content */
+CELL * stuffString(char * string)
+{
+CELL * cell;
+
+cell = getCell(CELL_STRING);
+cell->aux = strlen(string) + 1;
+cell->contents = (UINT)allocMemory((UINT)cell->aux);
+
+memcpy((void *)cell->contents, string, (UINT)cell->aux);
+return(cell);
+}
+
+/* safe for binary content */
+CELL * stuffStringN(char * string, int len)
+{
+CELL * cell;
+
+cell = getCell(CELL_STRING);
+cell->aux = len + 1;
+cell->contents = (UINT)allocMemory((UINT)cell->aux);
+memcpy((void *)cell->contents, string, len);
+*(char*)(cell->contents + len) = 0;
+return(cell);
+}
+
+CELL * stuffFloat(double floatVal)
+{
+CELL * cell;
+
+cell = getCell(CELL_FLOAT);
+#ifndef NEWLISP64
+*(double *)&cell->aux = floatVal;
+#else
+*(double *)&cell->contents = floatVal;
+#endif
+return(cell);
+}
+
+CELL * stuffSymbol(SYMBOL * sPtr)
+{
+CELL * cell;
+
+cell = getCell(CELL_SYMBOL);
+cell->contents = (UINT)sPtr;
+return(cell);
+}
+
+/* appends to a list, the list must have be either optimized
+   with list->aux pointing to the last cell, or list->aux must
+   contain nilCell and be empty
+*/
+
+void addList(CELL * list, CELL * new)
+{
+if(list->aux == (UINT)nilCell)
+    list->contents = (UINT)new;
+else
+    ((CELL *)list->aux)->next = new;
+list->aux = (UINT)new;
+}
+
+ssize_t convertNegativeOffset(ssize_t offset, CELL * list)
+{
+int len = 0;
+
+while(list != nilCell)
+    {
+    ++len;
+    list = list->next;
+    }
+offset = len + offset;
+if(offset < 0) 
+    errorProc(ERR_LIST_INDEX_INVALID);
+
+return(offset);
+}
+
+/* ------------------------ creating and freeing cells ------------------- */
+
+CELL * getCell(int type)
+{
+CELL * cell;
+
+if(firstFreeCell == NULL) allocBlock();
+cell = firstFreeCell;
+firstFreeCell = cell->next;
+++cellCount;
+
+cell->type = type;
+cell->next = nilCell;
+cell->aux = (UINT)nilCell;
+cell->contents = (UINT)nilCell;
+
+return(cell);
+}
+
+
+CELL * makeCell(int type, UINT contents)
+{
+CELL * cell;
+
+if(firstFreeCell == NULL) allocBlock();
+cell = firstFreeCell;
+firstFreeCell = cell->next;
+++cellCount;
+
+cell->type = type;
+cell->next = nilCell;
+cell->aux = (UINT)nilCell;
+cell->contents = contents;
+
+return(cell);
+}
+
+
+CELL * makeStringCell(char * contents, size_t size)
+{
+CELL * cell;
+
+if(firstFreeCell == NULL) allocBlock();
+cell = firstFreeCell;
+firstFreeCell = cell->next;
+++cellCount;
+
+cell->type = CELL_STRING;
+cell->next = nilCell;
+cell->aux = (UINT)size + 1;
+cell->contents = (UINT)contents;
+
+return(cell);
+}
+
+CELL * copyCell(CELL * cell)
+{
+#ifdef ISO_C90
+CELL * newCell;
+CELL * list;
+UINT len;
+#endif
+
+/* avoids copy if cell on resultStack */
+if(cell == (CELL *)*(resultStackIdx))
+    {
+    if(cell != nilCell && cell != trueCell)
+        return(popResult());
+    }
+
+#ifndef ISO_C90
+CELL * newCell;
+CELL * list;
+UINT len;
+#endif
+
+if(firstFreeCell == NULL) allocBlock();
+newCell = firstFreeCell;
+firstFreeCell = newCell->next;
+++cellCount;
+
+newCell->type = cell->type;
+newCell->next = nilCell;
+newCell->aux = cell->aux;
+newCell->contents = cell->contents;
+
+if(isEnvelope(cell->type))
+    {
+    if(cell->type == CELL_ARRAY)
+        newCell->contents = (UINT)copyArray(cell);
+    else /* normal list expression */
+        {
+        if(cell->contents != (UINT)nilCell) 
+            {
+            newCell->contents = (UINT)copyCell((CELL *)cell->contents);
+            list = (CELL *)newCell->contents;
+            cell = (CELL *)cell->contents;
+            while((cell = cell->next) != nilCell)
+                list = list->next = copyCell(cell);
+            newCell->aux = (UINT)list;  /* last element optimization */
+            }
+        }
+    }
+else if(cell->type == CELL_STRING)
+    {
+    newCell->contents = (UINT)allocMemory((UINT)cell->aux);
+    memcpy((void *)newCell->contents, (void*)cell->contents, (UINT)cell->aux);
+    }
+else if(cell->type == CELL_DYN_SYMBOL)
+    {
+    len = strlen((char *)cell->contents);
+    newCell->contents = (UINT)allocMemory(len + 1);
+    memcpy((char *)newCell->contents, (char *)cell->contents, len + 1);
+    }
+#ifdef BIGINT
+else if(cell->type == CELL_BIGINT)
+    {
+    newCell->contents = (UINT)allocMemory((UINT)cell->aux * sizeof(int));
+    memcpy((void *)newCell->contents, (void*)cell->contents, (UINT)cell->aux * sizeof(int));
+    }
+#endif
+
+return(newCell);
+}
+
+
+/* this routine must be called with the list head
+   if copying with envelope call copyCell() instead */
+CELL * copyList(CELL * cell)
+{
+#ifdef ISO_C90
+CELL * firstCell;
+CELL * newCell;
+#endif
+
+if(cell == nilCell) 
+    {
+    lastCellCopied = nilCell;
+    return(cell);
+    }
+
+#ifndef ISO_C90
+CELL * firstCell;
+CELL * newCell;
+#endif
+
+firstCell = newCell = copyCell(cell);
+
+while((cell = cell->next) != nilCell)
+    newCell = newCell->next = copyCell(cell);
+    
+lastCellCopied = newCell;
+return(firstCell);
+}
+
+
+/* for deleting lists _and_ cells */
+void deleteList(CELL * cell)
+{
+CELL * next;
+
+while(cell != nilCell)
+    {
+    if(isEnvelope(cell->type))
+        {
+        if(cell->type == CELL_ARRAY)
+            deleteArray(cell);
+        else
+            deleteList((CELL *)cell->contents);
+        }
+
+    else if(cell->type == CELL_STRING || cell->type == CELL_DYN_SYMBOL 
+#ifdef BIGINT
+                || cell->type == CELL_BIGINT
+#endif
+            )
+        freeMemory( (void *)cell->contents);
+    
+    /* free cell changes in 10.6.3 */
+    if(cell == nilCell || cell == trueCell) 
+        cell = cell->next;
+    else    
+        {
+        next = cell->next;
+        cell->type = CELL_FREE;
+        cell->next = firstFreeCell;
+        firstFreeCell = cell;
+        --cellCount;
+        cell = next;
+        }
+
+    }
+}
+
+/* --------------- cell / memory allocation and deallocation -------------
+
+   allthough (MAC_BLOCK + 1) are allocated only MAX_BLOCK cells
+   are used. The last cell only serves as a pointer to the next block
+*/
+
+CELL * cellMemory = NULL;/* start of cell memory */
+CELL * cellBlock = NULL; /* the last block allocated */
+
+void allocBlock()
+{
+int i;
+
+if(cellCount > MAX_CELL_COUNT - MAX_BLOCK)  
+    {
+    printErrorMessage(ERR_NOT_ENOUGH_MEMORY, NULL, 0);
+    exit(ERR_NOT_ENOUGH_MEMORY);
+    }
+
+if(cellMemory == NULL)
+    {
+    cellMemory = (CELL *)allocMemory((MAX_BLOCK + 1) * sizeof(CELL));
+    cellBlock = cellMemory;
+    }
+else
+    {
+    (cellBlock + MAX_BLOCK)->next = 
+        (CELL *)allocMemory((MAX_BLOCK + 1) * sizeof(CELL));
+    cellBlock = (cellBlock + MAX_BLOCK)->next;
+    }
+
+for(i = 0; i < MAX_BLOCK; i++)
+    {
+    (cellBlock + i)->type = CELL_FREE;
+    (cellBlock + i)->next = (cellBlock + i + 1);
+    }
+(cellBlock + MAX_BLOCK - 1)->next = NULL;
+(cellBlock + MAX_BLOCK)->next = NULL;
+firstFreeCell = cellBlock;
+++ blockCount;
+}
+
+
+/* Return unused blocks to OS, this is normally only called under error 
+   conditions but can also be forced issuing a (reset nil)
+
+   Older versions also did a complete cell mark and sweep. Now all
+   error conditons clean out allocated cells and memory before doing
+   the longjmp().
+*/
+
+/* not used, not tested
+void freeAllCells()
+{
+CELL * blockPtr = cellMemory;
+int i, j;
+
+for(i = 0; i < blockCount; i++)
+    {
+    for(j = 0; j < MAX_BLOCK; j++)
+        {
+        if(*(UINT *)blockPtr != CELL_FREE)
+            {
+            deleteList(blockPtr);
+            }
+        blockPtr++;
+        }
+    blockPtr = blockPtr->next;
+    }        
+}
+*/
+
+void freeCellBlocks()
+{
+CELL * blockPtr;
+CELL * lastBlockPtr = NULL;
+CELL * lastFreeCell = NULL;
+CELL * prevLastFreeCell;
+CELL * prevCellBlock;
+int i, freeCount;
+
+cellBlock = blockPtr = cellMemory;
+firstFreeCell = NULL;
+while(blockPtr != NULL)
+    {
+    prevLastFreeCell = lastFreeCell;
+    prevCellBlock = cellBlock;
+    cellBlock = blockPtr;
+    for(i = freeCount = 0; i < MAX_BLOCK; i++)
+        {
+        if(*(UINT *)blockPtr == CELL_FREE)
+            {
+            if(firstFreeCell == NULL)
+                firstFreeCell = lastFreeCell = blockPtr;
+            else
+                {
+                lastFreeCell->next = blockPtr;
+                lastFreeCell = blockPtr;
+                }
+            freeCount++;
+            }
+        blockPtr++;
+        }
+    if(freeCount == MAX_BLOCK)
+        {
+        lastFreeCell = prevLastFreeCell;
+        cellBlock = prevCellBlock;
+        blockPtr = blockPtr->next;
+        freeMemory(lastBlockPtr->next);
+        --blockCount;
+        lastBlockPtr->next = blockPtr;
+        }
+    else 
+        {
+        lastBlockPtr = blockPtr;
+        blockPtr = blockPtr->next;
+        }
+    }
+lastFreeCell->next = NULL;
+}
+
+
+/* OS memory allocation */
+
+void * allocMemory(size_t nbytes)
+{
+void * ptr;
+
+if( (ptr = (void *)malloc(nbytes)) == NULL)
+    fatalError(ERR_NOT_ENOUGH_MEMORY, NULL, 0);
+
+return(ptr);
+}
+
+void * callocMemory(size_t nbytes)
+{
+void * ptr;
+
+if( (ptr = (void *)calloc(nbytes, 1)) == NULL)
+    fatalError(ERR_NOT_ENOUGH_MEMORY, NULL, 0);
+
+return(ptr);
+}
+
+void * reallocMemory(void * prevPtr, UINT size)
+{
+void * ptr;
+
+if( (ptr = realloc(prevPtr, size)) == NULL)
+    fatalError(ERR_NOT_ENOUGH_MEMORY, NULL, 0);
+
+return(ptr);
+}
+
+/* -------------------------- I/O routines ------------------------------ */
+
+UINT printDevice;
+void prettyPrint(UINT device);
+
+void varPrintf(UINT device, char * format, ...)
+{
+char * buffer;
+va_list argptr;
+ 
+va_start(argptr,format);
+
+/* defined in nl-filesys.c if not in libc */
+vasprintf(&buffer, format, argptr); 
+
+prettyPrintLength += strlen(buffer);
+switch(device)
+    {
+    case OUT_NULL:
+        return;
+
+    case OUT_DEVICE:
+        if(printDevice != 0)
+            {
+            if(write(printDevice, buffer, strlen(buffer)) < 0)
+                fatalError(ERR_IO_ERROR, 0, 0);
+            break;
+            }
+    case OUT_CONSOLE:
+#ifdef LIBRARY
+        if(!newlispLibConsoleFlag)
+            {
+            writeStreamStr(&libStrStream, buffer, 0);
+            freeMemory(buffer);
+            fflush(NULL);
+            return;
+            }
+        else
+#endif
+        if(IOchannel == stdin)
+            {
+            printf("%s", buffer);
+            if(!isTTY) fflush(NULL);
+            }
+        else if(IOchannel != NULL) 
+            fprintf(IOchannel, "%s", buffer);
+        break;
+    case OUT_LOG:
+        writeLog(buffer, 0);
+        break;
+    default:
+        writeStreamStr((STREAM *)device, buffer, 0);
+        break;
+    }
+
+freeMemory(buffer);
+
+va_end(argptr);
+}
+
+
+void printCell(CELL * cell, UINT printFlag, UINT device)
+{
+SYMBOL * sPtr;
+SYMBOL * sp;
+#ifdef BIGINT
+char * ptr;
+#endif
+
+if(cell == debugPrintCell)
+    varPrintf(device, "%s", debugPreStr);
+
+switch(cell->type)
+    {
+    case CELL_NIL:
+        varPrintf(device, "nil"); break;
+
+    case CELL_TRUE:
+        varPrintf(device, "true"); break;
+    
+    case CELL_LONG:
+        varPrintf(device,"%"PRIdPTR, cell->contents); break;
+#ifndef NEWLISP64
+    case CELL_INT64:
+        varPrintf(device,"%"PRId64, *(INT64 *)&cell->aux); break;
+#endif /* NEWLISP64 */
+#ifdef BIGINT
+    case CELL_BIGINT:
+        ptr = bigintToDigits((int *)cell->contents, cell->aux - 1, 48, NULL);        
+        varPrintf(device, "%sL", ptr);
+        free(ptr);
+        break;
+#endif
+    case CELL_FLOAT:
+#ifndef NEWLISP64
+        varPrintf(device, prettyPrintFloat ,*(double *)&cell->aux);
+#else
+        varPrintf(device, prettyPrintFloat ,*(double *)&cell->contents);
+#endif
+        break;
+
+    case CELL_STRING:
+        if(printFlag)
+            printString((char *)cell->contents, device, cell->aux - 1);
+        else
+            varPrintf(device,"%s",cell->contents);
+        break;
+    
+    case CELL_SYMBOL:
+    case CELL_CONTEXT:
+        sPtr = (SYMBOL *)cell->contents;
+        if(sPtr->context != currentContext  
+            /* if not global or global overwritten in current context */
+            && (!(sPtr->flags & SYMBOL_GLOBAL) || (lookupSymbol(sPtr->name, currentContext)))
+            && (symbolType(sPtr) != CELL_CONTEXT || 
+                (SYMBOL *)((CELL*)sPtr->contents)->contents != sPtr)) /* context var */
+            {
+            varPrintf(device,"%s:%s", (char*)((SYMBOL*)sPtr->context)->name, sPtr->name);
+            break;
+            }
+        /* overwriting global in MAIN */
+        if(sPtr->context == currentContext
+            && currentContext != mainContext
+            && ((sp = lookupSymbol(sPtr->name, mainContext)) != NULL)
+            && (sp->flags & SYMBOL_GLOBAL) )
+            {
+            varPrintf(device,"%s:%s", currentContext->name, sPtr->name);
+            break;
+            }
+
+        varPrintf(device,"%s",sPtr->name);
+        break;
+    
+    case CELL_PRIMITIVE:
+        varPrintf(device,"%s@%lX", (char *)cell->aux, cell->contents);
+        break;
+    case CELL_IMPORT_CDECL:
+    case CELL_IMPORT_FFI:
+#if defined(WINDOWS) || defined(CYGWIN)
+    case CELL_IMPORT_DLL:
+#endif
+
+#ifdef FFI
+        if(cell->type == CELL_IMPORT_FFI)
+            varPrintf(device,"%s@%lX", (char *)((FFIMPORT *)cell->aux)->name,
+                                                 cell->contents);
+        else
+            varPrintf(device,"%s@%lX", (char *)cell->aux, cell->contents);
+#else
+        varPrintf(device,"%s@%lX", (char *)cell->aux, cell->contents);
+#endif
+        break;
+    
+    case CELL_QUOTE:
+        varPrintf(device, "'");
+        prettyPrintFlags |= PRETTYPRINT_DOUBLE;
+        printCell((CELL *)cell->contents, printFlag, device);
+        break;
+    
+    case CELL_EXPRESSION:
+    case CELL_LAMBDA:
+    case CELL_FEXPR:
+        printExpression(cell, device);
+        break;
+
+    case CELL_DYN_SYMBOL:
+        varPrintf(device, "%s:%s", ((SYMBOL*)cell->aux)->name, (char*)cell->contents);
+        break;                                                                                                                                                                             
+    case CELL_ARRAY:
+        printArray(cell, device);
+        break;
+
+    default:
+        varPrintf(device,"?");
+    }
+
+if(cell == debugPrintCell)
+    varPrintf(device, "%s", debugPostStr);
+
+prettyPrintFlags &= ~PRETTYPRINT_DOUBLE;
+}
+
+
+void printString(char * str, UINT  device, int size)
+{
+char chr;
+
+if(size >= MAX_STRING)
+    {
+    varPrintf(device, "[text]");
+    while(size--) varPrintf(device, "%c", *str++);
+    varPrintf(device, "[/text]");
+    return;
+    }
+
+varPrintf(device,"\"");
+while(size--)
+    {
+    switch(chr = *str++)
+        {
+        case '\b': varPrintf(device,"\\b"); break;
+        case '\f': varPrintf(device,"\\f"); break;
+        case '\n': varPrintf(device,"\\n"); break;
+        case '\r': varPrintf(device,"\\r"); break;
+        case '\t': varPrintf(device,"\\t"); break;
+        case '\\': varPrintf(device,"\\\\"); break;
+        case '"': varPrintf(device,"\\%c",'"'); break;
+        default: 
+            if((unsigned char)chr < 32 || (stringOutputRaw && (unsigned char)chr > 126))
+                            varPrintf(device,"\\%03u", (unsigned char)chr);
+                        else
+                varPrintf(device,"%c",chr); break;
+        }
+    }
+varPrintf(device,"\"");
+}
+
+
+void printExpression(CELL * cell, UINT device)
+{
+CELL * item;
+int i, pFlags;
+
+item = (CELL *)cell->contents;
+
+
+if(prettyPrintPars <= prettyPrintCurrent || 
+    prettyPrintLength > prettyPrintMaxLength)
+    prettyPrint(device);
+
+if(cell->type == CELL_LAMBDA) 
+    {
+    varPrintf(device, "(lambda ");
+    ++prettyPrintPars;
+    }
+else if(cell->type == CELL_FEXPR) 
+    {
+    varPrintf(device, "(lambda-macro ");
+    ++prettyPrintPars;
+    }
+else 
+    {
+    if(isSymbol(item->type))
+        {
+        if(item->type == CELL_SYMBOL)
+             pFlags = ((SYMBOL *)item->contents)->flags;
+        else
+             pFlags = 0;
+
+        if((pFlags & PRINT_TYPE_MASK) != 0)
+            {
+            prettyPrint(device);
+            varPrintf(device, "(");
+            ++prettyPrintPars;
+            for(i = 0; i < (pFlags & PRINT_TYPE_MASK); i++)
+                {
+                if(item == nilCell) 
+                    {prettyPrintFlags |= PRETTYPRINT_DOUBLE; break;}
+                printCell(item, TRUE, device);
+                item = item->next;
+                if(item != nilCell) varPrintf(device," ");
+                else prettyPrintFlags |= PRETTYPRINT_DOUBLE;
+                }
+            prettyPrint(device);
+            }
+        else 
+            {
+            varPrintf(device, "(");
+            ++prettyPrintPars;
+            }
+        }
+    else 
+        {
+        varPrintf(device, "(");
+        ++prettyPrintPars;
+        }
+    }
+
+
+while(item != nilCell)
+    {
+    if(prettyPrintLength > prettyPrintMaxLength) prettyPrint(device);
+    printCell(item, TRUE, device);
+    item = item->next;
+    if(item != nilCell) varPrintf(device," ");
+    }
+
+varPrintf(device,")");
+--prettyPrintPars;
+}
+
+
+void prettyPrint(UINT device)
+{
+int i;
+
+if(prettyPrintFlags) return;
+
+if(prettyPrintPars > 0) 
+    varPrintf(device, LINE_FEED);
+
+for(i = 0; i < prettyPrintPars; i++) 
+    varPrintf(device, "%s", prettyPrintTab);
+
+prettyPrintLength = prettyPrintCurrent = prettyPrintPars;
+prettyPrintFlags |= PRETTYPRINT_DOUBLE;
+}
+
+
+void printSymbol(SYMBOL * sPtr, UINT device)
+{
+CELL * cell;
+CELL * list = NULL;
+char * setStr;
+size_t offset, len;
+
+prettyPrintCurrent = prettyPrintPars = 1;
+prettyPrintLength = 0;
+prettyPrintFlags &= ~PRETTYPRINT_DOUBLE;
+
+if(sPtr->flags & SYMBOL_PROTECTED)
+    setStr = "(constant ";
+else
+    setStr = "(set ";
+
+switch(symbolType(sPtr))
+    {
+    case CELL_PRIMITIVE:
+    case CELL_IMPORT_CDECL:
+    case CELL_IMPORT_FFI:
+#if defined(WINDOWS) || defined(CYGWIN) 
+    case CELL_IMPORT_DLL:
+#endif
+        break;
+    case CELL_SYMBOL:
+    case CELL_DYN_SYMBOL:
+        varPrintf(device, "%s", setStr);
+        printSymbolNameExt(device, sPtr);
+        varPrintf(device,"'");
+        printCell((CELL *)sPtr->contents, TRUE, device);
+        varPrintf(device, ")");
+        break;
+    case CELL_ARRAY:
+    case CELL_EXPRESSION:
+        varPrintf(device, "%s", setStr);
+        printSymbolNameExt(device, sPtr);
+        cell = (CELL *)sPtr->contents;
+
+        if(symbolType(sPtr) == CELL_ARRAY)
+            {
+            varPrintf(device, "(array ");
+            printArrayDimensions(cell, device);
+            varPrintf(device, "(flat ");
+            list = cell = arrayList(cell, TRUE);
+            }
+
+        cell = (CELL *)cell->contents;
+
+        varPrintf(device,"'(");
+        prettyPrintPars = 2;
+        if(cell->type == CELL_EXPRESSION) prettyPrint(device);
+        while(cell != nilCell)
+            {
+            if(prettyPrintLength > prettyPrintMaxLength) 
+                    prettyPrint(device);
+            printCell(cell, TRUE, device);
+            cell = cell->next;
+            if(cell != nilCell) varPrintf(device, " ");
+            }
+        varPrintf(device, "))");
+        if(symbolType(sPtr) == CELL_ARRAY)
+            {
+            deleteList(list);
+            varPrintf(device ,"))");
+            }
+        break;
+    case CELL_LAMBDA:
+    case CELL_FEXPR:
+        if(isProtected(sPtr->flags))
+            {
+            varPrintf(device, "%s%s%s", LINE_FEED, LINE_FEED, setStr);
+            printSymbolNameExt(device, sPtr);
+            printExpression((CELL *)sPtr->contents, device);
+            varPrintf(device, ")");
+            }
+        else if (isGlobal(sPtr->flags))
+            {
+            printLambda(sPtr, device);
+            varPrintf(device, "%s%s", LINE_FEED, LINE_FEED);
+            printSymbolNameExt(device, sPtr);
+            }
+        else printLambda(sPtr, device);
+        break;
+    default:
+        varPrintf(device, "%s", setStr);
+        printSymbolNameExt(device, sPtr);
+        cell = (CELL *)sPtr->contents;
+        if(cell->type == CELL_STRING && cell->aux > MAX_STRING) /* size > 2047 */
+            {
+            varPrintf(device, "%s ", "(append ");
+            offset = 0;
+            while(offset < cell->aux - 1)
+                {
+                varPrintf(device, "%s  ", LINE_FEED); 
+                len = (cell->aux - 1 - offset);
+                len = len > 72 ? 72 : len;
+                printString((char *)(cell->contents + offset), device, len); 
+                offset += len;
+                }
+            varPrintf(device, "))");
+            break; 
+            }
+        printCell(cell, TRUE, device);
+        varPrintf(device, ")");
+        break;
+    }
+
+varPrintf(device, "%s%s", LINE_FEED, LINE_FEED);
+
+prettyPrintLength = prettyPrintPars = 0;
+}
+
+
+void printLambda(SYMBOL * sPtr, UINT device)
+{
+CELL * lambda;
+CELL * cell;
+
+lambda = (CELL *)sPtr->contents;
+cell = (CELL *)lambda->contents;
+if(cell->type == CELL_EXPRESSION)
+    cell = (CELL *)cell->contents;
+
+if(!isLegalSymbol(sPtr->name))
+        {
+        varPrintf(device, "(set (sym ");
+        printString(sPtr->name, device, strlen(sPtr->name));
+        varPrintf(device, " %s) ", ((SYMBOL*)sPtr->context)->name);
+        printExpression((CELL *)sPtr->contents, device);
+        varPrintf(device, ")");
+        return;
+        }
+    
+if(symbolType(sPtr) == CELL_LAMBDA)
+    varPrintf(device, "(define (");
+else 
+    varPrintf(device, "(define-macro (");
+prettyPrintPars += 2;
+
+printSymbolName(device, sPtr);
+varPrintf(device, " ");
+
+while(cell != nilCell)
+    {
+    printCell(cell, TRUE, device);
+    cell = cell->next;
+    if(cell != nilCell) varPrintf(device, " ");
+    }
+varPrintf(device, ")");
+--prettyPrintPars;
+prettyPrint(device);
+
+cell = (CELL *)lambda->contents;
+while((cell = cell->next) != nilCell)
+    {
+    if(prettyPrintLength > prettyPrintMaxLength) prettyPrint(device);
+    printCell(cell, TRUE, device);
+    if(!(cell->type & ENVELOPE_TYPE_MASK) && cell->next != nilCell) varPrintf(device, " ");
+    }
+
+varPrintf(device, ")");
+--prettyPrintPars;
+}
+
+
+void printSymbolName(UINT device, SYMBOL * sPtr)
+{
+SYMBOL * sp;
+
+if(sPtr->context == currentContext)
+    {
+    if(*sPtr->name == *currentContext->name && strcmp(sPtr->name, currentContext->name) == 0)
+        varPrintf(device, "%s:%s", sPtr->name, sPtr->name);
+
+    else if(currentContext != mainContext 
+        && ((sp = lookupSymbol(sPtr->name, mainContext)) != NULL)
+        && (sp->flags &  SYMBOL_GLOBAL) )
+        varPrintf(device, "%s:%s", currentContext->name, sPtr->name);
+    else
+        varPrintf(device,"%s", sPtr->name);
+    }
+else
+    varPrintf(device,"%s:%s", 
+        (char *)((SYMBOL*)sPtr->context)->name, sPtr->name);
+}
+
+
+void printSymbolNameExt(UINT device, SYMBOL * sPtr)
+{
+if(isGlobal(sPtr->flags))
+    {
+    varPrintf(device, "(global '");
+    printSymbolName(device, sPtr);
+    if(symbolType(sPtr) == CELL_LAMBDA || symbolType(sPtr) == CELL_FEXPR)
+        varPrintf(device, ")");
+    else varPrintf(device, ") ");
+    }
+else 
+    {
+    if(!isLegalSymbol(sPtr->name))
+        {
+        varPrintf(device, " (sym ");
+        printString(sPtr->name, device, strlen(sPtr->name));
+        varPrintf(device, " MAIN:%s) ", ((SYMBOL*)sPtr->context)->name);
+        }
+    else
+        {
+        varPrintf(device, "'");
+        printSymbolName(device, sPtr);
+        }
+    varPrintf(device, " ");
+    }
+}
+
+
+CELL * p_prettyPrint(CELL * params)
+{
+CELL * result;
+char * str;
+size_t len;
+
+if(params != nilCell)
+    params = getInteger(params, &prettyPrintMaxLength);
+if(params != nilCell)
+    {
+    params = getStringSize(params, &str, &len, TRUE);
+    prettyPrintTab = allocMemory(len + 1);
+    memcpy(prettyPrintTab, str, len + 1);
+    }
+if(params != nilCell)
+    {
+    getStringSize(params, &str, &len, TRUE);
+    prettyPrintFloat = allocMemory(len + 1);
+    memcpy(prettyPrintFloat, str, len + 1);
+    }
+
+result = getCell(CELL_EXPRESSION);
+addList(result, stuffInteger(prettyPrintMaxLength));
+addList(result, stuffString(prettyPrintTab));
+addList(result, stuffString(prettyPrintFloat));
+
+return(result);
+}
+
+
+
+/* -------------------------- error handling --------------------------- */
+
+char * errorMessage[] =
+    {
+    "",                             /* 0 */
+    "not enough memory",            /* 1 */
+    "environment stack overflow",   /* 2 */
+    "call or result stack overflow",/* 3 */
+    "problem accessing file",       /* 4 */
+    "illegal token or expression",  /* 5 */
+    "missing parenthesis",          /* 6 */
+    "string token too long",        /* 7 */
+    "missing argument",             /* 8 */
+    "number or string expected",    /* 9 */
+    "value expected",               /* 10 */
+    "string expected",              /* 11 */
+    "symbol expected",              /* 12 */
+    "context expected",             /* 13 */
+    "symbol or context expected",   /* 14 */
+    "list expected",                /* 15 */
+    "list or array expected",       /* 15 */
+    "list or symbol expected",      /* 17 */
+    "list or string expected",      /* 18 */
+    "list or number expected",      /* 19 */
+    "array expected",               /* 20 */
+    "array, list or string expected", /* 21 */
+    "lambda expected",              /* 22 */
+    "lambda-macro expected",        /* 23 */
+    "invalid function",             /* 24 */
+    "invalid lambda expression",    /* 25 */
+    "invalid macro expression",     /* 26 */
+    "invalid let parameter list",   /* 27 */
+    "problem saving file",          /* 28 */
+    "division by zero",             /* 29 */
+    "matrix expected",              /* 30 */ 
+    "wrong dimensions",             /* 31 */
+    "matrix is singular",           /* 32 */
+    "invalid option",               /* 33 */
+    "throw without catch",          /* 34 */
+    "problem loading library",      /* 35 */
+    "import function not found",    /* 36 */
+    "symbol is protected",          /* 37 */
+    "number out of range",          /* 38 */
+    "regular expression",           /* 39 */
+    "end of text [/text] tag",      /* 40 */
+    "mismatch in number of arguments",  /* 41 */
+    "problem in format string",     /* 42 */
+    "data type and format don't match", /* 43 */
+    "invalid parameter",            /* 44 */
+    "invalid parameter: 0.0",       /* 45 */
+    "invalid parameter: NaN",       /* 46 */
+    "invalid UTF8 string",          /* 47 */
+    "illegal parameter type",       /* 48 */
+    "symbol not in MAIN context",   /* 49 */
+    "symbol not in current context", /* 50 */
+    "target cannot be MAIN",        /* 51 */
+    "invalid list index",           /* 52 */
+    "array index out of bounds",    /* 53 */
+    "invalid string index",         /* 54 */
+    "nesting level to deep",        /* 55 */
+    "list reference changed",       /* 56 */
+    "invalid syntax",               /* 57 */
+    "user error",                   /* 58 */
+    "user reset -",                 /* 59 */
+    "received SIGINT -",            /* 60 */
+    "function is not reentrant",    /* 61 */
+    "not allowed on local symbol",  /* 62 */
+    "no reference found",           /* 63 */
+    "list is empty",                /* 64 */
+    "I/O error",                    /* 65 */
+    "no working directory found",   /* 66 */
+    "invalid PID",                  /* 67 */
+    "cannot open socket pair",      /* 68 */
+    "cannot fork process",          /* 69 */
+    "no comm channel found",        /* 70 */
+    "ffi preparation failed",       /* 71 */
+    "invalid ffi type",             /* 72 */
+    "ffi struct expected",          /* 73 */
+    "bigint type not applicable",   /* 74 */
+    "not a number or infinite",     /* 75 */
+    "cannot convert NULL to string",/* 76 */
+    NULL
+    };
+
+
+void errorMissingPar(STREAM * stream)
+{
+char str[48]; 
+snprintf(str, 40, "...%.40s", ((char *)((stream->ptr - stream->buffer) > 40 ? stream->ptr - 40 : stream->buffer)));
+errorProcExt2(ERR_MISSING_PAR, stuffString(str));
+}
+
+CELL * errorProcAll(int errorNumber, CELL * expr, int deleteFlag)
+{
+if(!traceFlag) fatalError(errorNumber, expr, deleteFlag);
+printErrorMessage(errorNumber, expr, deleteFlag);
+return(nilCell);
+}
+
+CELL * errorProc(int errorNumber)
+{
+return(errorProcAll(errorNumber, NULL, 0));
+}
+
+/* extended error info in expr */
+CELL * errorProcExt(int errorNumber, CELL * expr)
+{
+return(errorProcAll(errorNumber, expr, 0));
+}
+
+/* extended error info in expr, which has to be discarded after printing */
+CELL * errorProcExt2(int errorNumber, CELL * expr)
+{
+return(errorProcAll(errorNumber, expr, 1));
+}
+
+CELL * errorProcArgs(int errorNumber, CELL * expr)
+{
+if(expr == nilCell) 
+    return(errorProcExt(ERR_MISSING_ARGUMENT, NULL));
+
+return(errorProcExt(errorNumber, expr));
+}
+
+void fatalError(int errorNumber, CELL * expr, int deleteFlag)
+{
+printErrorMessage(errorNumber, expr, deleteFlag);
+#ifndef LIBRARY
+closeTrace();
+#endif
+longjmp(errorJump, errorReg);
+}
+
+void printErrorMessage(UINT errorNumber, CELL * expr, int deleteFlag)
+{
+CELL * lambdaFunc;
+CELL * lambdaExpr;
+UINT * stackIdx = lambdaStackIdx;
+SYMBOL * context;
+int i;
+
+if(errorNumber == EXCEPTION_THROW)
+    errorNumber = ERR_THROW_WO_CATCH;
+
+errorReg = errorNumber;
+
+if(!errorNumber) return;
+
+openStrStream(&errorStream, MAX_STRING, 1);
+writeStreamStr(&errorStream, "ERR: ", 5);
+writeStreamStr(&errorStream, errorMessage[errorReg], 0);
+
+for(i = 0; primitive[i].name != NULL; i++)
+    {
+    if(evalFunc == primitive[i].function)
+        {
+        writeStreamStr(&errorStream, " in function ", 0);
+        writeStreamStr(&errorStream, primitive[i].name, 0);
+        break;
+        }
+    }
+
+if(expr != NULL)
+    {
+    writeStreamStr(&errorStream, " : ", 3);
+    printCell(expr, (errorNumber != ERR_USER_ERROR), (UINT)&errorStream);
+    if(deleteFlag) deleteList(expr);
+    }
+
+while(stackIdx > lambdaStack)
+    {
+    lambdaExpr = (CELL *)*(--stackIdx);
+    lambdaFunc = (CELL *)lambdaExpr->contents;
+    if(lambdaFunc->type == CELL_SYMBOL)
+        {
+        writeStreamStr(&errorStream, LINE_FEED, 0);
+        writeStreamStr(&errorStream, "called from user function ", 0);
+        context = ((SYMBOL *)lambdaFunc->contents)->context;
+        if(context != mainContext)
+          {
+          writeStreamStr(&errorStream, context->name, 0);
+          writeStreamStr(&errorStream, ":", 0);
+          }
+        /* writeStreamStr(&errorStream, ((SYMBOL *)lambdaFunc->contents)->name, 0); */
+        printCell(lambdaExpr, (errorNumber != ERR_USER_ERROR), (UINT)&errorStream); /* 10.6.3 */
+        }
+    }
+
+if(!(traceFlag & TRACE_SIGINT)) evalFunc = NULL; 
+parStackCounter = prettyPrintPars = 0;
+
+if(evalCatchFlag && !((traceFlag & TRACE_SIGINT) 
+        || (traceFlag & TRACE_IN_DEBUG))) return;
+
+if(errorEvent == nilSymbol)
+    {
+    if(errorNumber == ERR_SIGINT)
+        printf("%s", errorStream.buffer);
+    else
+        {
+        varPrintf(OUT_CONSOLE, "\n%.1024s\n", errorStream.buffer);
+        if(logTraffic == LOG_MORE) writeLog(errorStream.buffer, TRUE);
+        }
+    }
+
+if(traceFlag & TRACE_PRINT_EVAL) tracePrint(errorStream.buffer, NULL);
+}
+
+
+/* --------------------------- load source file ------------------------- */
+
+
+CELL * loadFile(char * fileName, UINT offset, int linkFlag, SYMBOL * context)
+{
+CELL * result;
+STREAM stream;
+int errNo, sourceLen;
+jmp_buf errorJumpSave;
+SYMBOL * contextSave;
+#ifdef LOAD_DEBUG
+int i;
+#endif
+
+contextSave = currentContext;
+currentContext = context;
+if(linkFlag)
+    sourceLen = *((int *) (linkOffset + 4));
+else sourceLen = MAX_FILE_BUFFER;
+
+#ifndef EMSCRIPTEN
+if(my_strnicmp(fileName, "http://", 7) == 0)
+    {
+    result = getPutPostDeleteUrl(fileName, nilCell, HTTP_GET, CONNECT_TIMEOUT);
+    pushResult(result);
+    if(memcmp((char *)result->contents, "ERR:", 4) == 0)
+        return(errorProcExt2(ERR_ACCESSING_FILE, stuffString((char *)result->contents)));
+    result = copyCell(sysEvalString((char *)result->contents, context, nilCell, EVAL_STRING));
+    currentContext = contextSave;
+    return(result);
+    }
+#endif
+
+if(makeStreamFromFile(&stream, fileName, sourceLen + 4 * MAX_STRING, offset) == 0) 
+    return(NULL);
+
+memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+if((errNo = setjmp(errorJump)) != 0)
+    {
+    closeStrStream(&stream);
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    currentContext = contextSave;
+    longjmp(errorJump, errNo);
+    }
+    
+#ifdef LOAD_DEBUG
+for(i = 0; i<recursionCount; i++) printf("  "); 
+printf("load: %s\n", fileName);
+#endif
+
+result = evaluateStream(&stream, 0, TRUE);
+currentContext = contextSave;
+
+#ifdef LOAD_DEBUG
+for(i = 0; i<recursionCount; i++) printf("  "); 
+printf("finish load: %s\n", fileName);
+#endif
+
+memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+closeStrStream(&stream);
+return(result);
+}
+
+
+void linkSource(char * pathname, char * source, char * target)
+{
+int sourceLen;
+char * buffer;
+int size, offset = 0;
+char * ptr;
+
+#ifdef WINDOWS
+/* gets full path of currently executing newlisp.exe */
+pathname = win_getExePath(alloca(PATH_MAX));
+#else /* Unix */
+if(strchr(pathname, '/') == NULL) 
+    pathname = which(pathname, alloca(PATH_MAX));
+#endif
+
+size = readFile(pathname, &buffer);
+sourceLen = (size_t)fileSize(source);
+
+if(errno) 
+    {
+    printf("%s\n", strerror(errno));
+    exit(errno);
+    }
+
+ptr = buffer;
+
+if(strncmp(linkOffset + 4, "@@@@", 4) != 0) return; /* already linked */
+do  {
+    offset = searchBuffer(ptr, size - (ptr - buffer) , "@@@@", 4, 1);
+    ptr = ptr + offset + 4;
+    } while (strncmp(ptr - 8, "&&&&", 4) != 0); /* the linkOffset */
+
+offset = (ptr - buffer - 8);
+*(int *)(buffer + offset) = (int)size;
+*(int *)(buffer + offset + 4) = (int)sourceLen;
+writeFile(target, buffer, size, "w");
+readFile(source, &buffer);
+writeFile(target, buffer, sourceLen, "a");
+
+free(buffer);
+}
+
+/* -------------------------- parse / compile -----------------------------
+
+   Takes source in a string stream and and envelope cell and compiles
+   newLISP source into an internal LISP cell structure tree. The tree
+   can be decompiled to source at any time and is processed by the
+   evaluateExpression() function.
+
+*/
+int references(SYMBOL *, int);
+int compileExpression(STREAM * stream, CELL * cell)
+{
+char token[MAX_STRING + 4];
+double floatNumber;
+CELL * newCell;
+CELL * contextCell;
+CELL * preCell;
+SYMBOL * contextPtr;
+SYMBOL * sPtr;
+int listFlag, tklen;
+char * lastPtr;
+int errnoSave;
+INT64 number;
+
+listFlag = TRUE; /* cell is either quote or list envelope */
+
+GETNEXT:
+lastPtr = stream->ptr;
+switch(getToken(stream, token, &tklen))
+    {
+    case TKN_ERROR:
+        errorProcExt2(ERR_EXPRESSION, stuffStringN(lastPtr, 
+            (strlen(lastPtr) < 60) ? strlen(lastPtr) : 60));
+        return(FALSE);
+
+    case TKN_EMPTY:
+        if(parStackCounter != 0) errorMissingPar(stream);
+        return(FALSE);
+
+    case TKN_CHARACTER:
+        newCell = stuffInteger((UINT)token[0]);
+        break;
+
+    case TKN_HEX:
+        newCell = stuffInteger64((INT64)strtoull(token,NULL,0));
+        break;
+
+    case TKN_BINARY:
+        newCell = stuffInteger64((INT64)strtoull(&token[2],NULL,2));
+        break;
+    
+    case TKN_OCTAL:
+        newCell = stuffInteger64(strtoll(token,NULL,0));
+        break;
+
+    case TKN_DECIMAL:
+        errnoSave = errno;
+        errno = 0;
+#ifdef BIGINT
+        if(*(token + tklen - 1) == 'L')
+            {
+            newCell = stuffBigint(token);
+            break;
+            }
+#endif
+
+#ifndef NEWLISP64
+        number = (INT64)strtoll(token, NULL, 0);
+#else
+        number = strtoll(token, NULL, 0);
+#endif
+        
+#ifdef BIGINT
+        if(errno == ERANGE)
+            {
+            newCell = stuffBigint(token);
+            errno = errnoSave;
+            break;
+            }
+#endif
+
+        newCell = stuffInteger64(number);
+        errno = errnoSave;
+        break;
+
+    case TKN_FLOAT:
+        floatNumber = (double)atof(token);
+        newCell = stuffFloat(floatNumber);
+        break;
+
+    case TKN_STRING:
+        newCell = stuffStringN(token, tklen);
+        break;
+
+    case TKN_SYMBOL:
+        if(strcmp(token, "lambda") == 0 || strcmp(token, "fn") == 0)
+            {
+            if(cell->type != CELL_EXPRESSION)
+                {
+                errorProcExt2(ERR_INVALID_LAMBDA, stuffString(lastPtr));
+                return(FALSE);
+                }
+            cell->type =  CELL_LAMBDA;
+            cell->aux = (UINT)nilCell;
+            goto GETNEXT;
+            }
+        else if(strcmp(token, "lambda-macro") == 0 || strcmp(token, "fn-macro") == 0)
+            {
+            if(cell->type != CELL_EXPRESSION)
+                {
+                errorProcExt2(ERR_INVALID_LAMBDA, stuffString(lastPtr));
+                return(FALSE);
+                }
+            cell->type =  CELL_FEXPR;
+            cell->aux = (UINT)nilCell;
+            goto GETNEXT;
+            }
+        else if(strncmp(token, "[text]", 6) == 0) 
+            {
+            newCell = makeCell(CELL_STRING, (UINT)readStreamText(stream, &tklen));
+            if(newCell->contents == 0)
+                {
+                deleteList(newCell); 
+                errorProc(ERR_TEXT_END_TAG);
+                }
+            newCell->aux = tklen + 1;
+            break;
+            }
+        newCell = getCell(CELL_SYMBOL);
+        if(*token == '$')
+            {
+            newCell->contents = (UINT)translateCreateSymbol(
+                token, CELL_NIL, mainContext, TRUE);
+            ((SYMBOL *)newCell->contents)->flags |= SYMBOL_GLOBAL;
+            }
+        else
+            newCell->contents = (UINT)translateCreateSymbol(
+                token, CELL_NIL, currentContext, 0);
+        break;
+
+    case TKN_CONTEXT:
+        contextPtr = NULL;
+        if(currentContext != mainContext)
+            {
+            if(strcmp(currentContext->name, token) == 0)
+                contextPtr = currentContext;
+            else
+                contextPtr = lookupSymbol(token, currentContext);
+            }
+
+        if(contextPtr == NULL)
+            {
+            contextPtr = translateCreateSymbol(
+                token, CELL_CONTEXT, mainContext, TRUE);
+            }
+
+        contextCell = (CELL *)contextPtr->contents;
+        if(getToken(stream, token, &tklen) != TKN_SYMBOL)
+            errorProcExt2(ERR_SYMBOL_EXPECTED, stuffString(lastPtr));
+
+        /* context does not exist */
+        if(contextCell->type != CELL_CONTEXT 
+           || contextPtr != (SYMBOL*)contextCell->contents)
+            {
+            newCell = getCell(CELL_DYN_SYMBOL);
+            newCell->aux = (UINT)contextPtr;
+            newCell->contents = (UINT)allocMemory(tklen + 1);
+            strncpy((char *)newCell->contents, token, tklen + 1);
+            break;
+            }
+
+        /* context exists make a symbol for it */
+        newCell = getCell(CELL_SYMBOL);
+        newCell->contents = (UINT)translateCreateSymbol(
+                token, CELL_NIL, contextPtr, TRUE);
+        break;
+
+    case TKN_QUOTE:
+        newCell = getCell(CELL_QUOTE);
+        compileExpression(stream, newCell);
+        break;
+
+    case TKN_LEFT_PAR:
+        ++parStackCounter;
+        newCell = getCell(CELL_EXPRESSION);
+        compileExpression(stream, newCell);
+        if(((CELL *)newCell->contents)->type == CELL_SYMBOL)
+            {
+            sPtr = (SYMBOL *)((CELL *)newCell->contents)->contents;
+            /* macro expansion */
+            if(sPtr->flags & SYMBOL_MACRO)     
+                {
+                preCell = copyCell(evaluateExpression(newCell));
+                deleteList(newCell);
+                newCell = preCell;
+                }
+            }
+        break;
+
+    case TKN_RIGHT_PAR:
+        if(parStackCounter == 0) errorMissingPar(stream);
+        --parStackCounter;
+        cell->next = nilCell;
+        return(TRUE);
+
+    default:
+        errorProcExt2(ERR_EXPRESSION, stuffString(lastPtr));
+        return(FALSE);
+
+    }
+
+linkCell(cell, newCell, listFlag);
+
+if(cell->type == CELL_QUOTE && listFlag == TRUE)
+    return(TRUE);
+
+listFlag = FALSE;
+cell = newCell;
+
+if(parStackCounter != 0)
+    {
+    if(*(stream->ptr) != 0) goto GETNEXT;
+    else errorMissingPar(stream);
+    }
+
+return(FALSE);
+}
+
+
+void linkCell(CELL * left, CELL * right, int linkFlag)
+{
+if(linkFlag == 0) left->next = right;
+else left->contents = (UINT)right;
+}
+
+int getToken(STREAM * stream, char * token, int * ptr_len)
+{
+char *tkn;
+char chr;
+int tknLen;
+#ifdef SUPPORT_UTF8
+int len;
+#endif
+int floatFlag;
+int bracketBalance;
+char buff[8];
+
+tkn = token;
+tknLen = floatFlag = 0;
+*tkn = 0;
+
+STRIP:
+if(stream->ptr > (stream->buffer + stream->size - 4 * MAX_STRING))
+    {
+    if(stream->handle == 0)
+        {
+        /* coming from commmand line or p_evalString */
+        stream->buffer = stream->ptr;
+        }
+    else
+        {
+        stream->position += (stream->ptr - stream->buffer);
+                lseek((int)stream->handle, stream->position, SEEK_SET);
+        memset(stream->buffer, 0, stream->size + 1);
+
+        if(read(stream->handle, stream->buffer, stream->size) > 0)
+            stream->ptr = stream->buffer;
+        else
+            {
+            *stream->ptr = 0;
+            return(TKN_EMPTY);
+            }
+        }
+    }
+
+while((unsigned char)*stream->ptr <= ' ' && (unsigned char)*stream->ptr != 0)
+    ++stream->ptr;
+
+if(*stream->ptr == 0) return(TKN_EMPTY);
+
+/* check for comments */
+if(*stream->ptr == ';' || *stream->ptr == '#')
+    {
+    stream->ptr++;
+    for(;;)
+        {
+        if(*stream->ptr == 0) return(TKN_EMPTY);
+        if(*stream->ptr == '\n' || *stream->ptr == '\r')
+            break;
+        stream->ptr++;
+        }
+    stream->ptr++;
+    goto STRIP;
+    }
+
+
+if( *stream->ptr == '-' || *stream->ptr == '+')
+    {
+    if(isDigit((unsigned char)*(stream->ptr + 1)) 
+        || *(stream->ptr + 1) == lc_decimal_point ) /* added 10.4.8 to allow -.9 */
+        *(tkn++) = *(stream->ptr++), tknLen++;
+    }
+
+    
+if(isDigit((unsigned char)*stream->ptr) || 
+                (*stream->ptr == lc_decimal_point && 
+                isDigit((unsigned char)*(stream->ptr + 1))))
+    {
+    if(*stream->ptr == '0' && isDigit((unsigned char)*(stream->ptr + 1)))
+        {
+        *(tkn++) = *(stream->ptr++), tknLen++;
+        while(*stream->ptr < '8' && *stream->ptr >= '0' && *stream->ptr != 0)
+            *(tkn++) = *(stream->ptr++), tknLen++;
+        *tkn = 0;
+        return(TKN_OCTAL);
+        }
+        
+    while(isDigit((unsigned char)*stream->ptr) && tknLen < MAX_DIGITS)
+        *(tkn++) = *(stream->ptr++), tknLen++;
+    
+    if(toupper(*stream->ptr) == 'X' && token[0] == '0')
+        {
+        *(tkn++) = *(stream->ptr++), tknLen++;
+        while(isxdigit((unsigned char)*stream->ptr) && tknLen < MAX_HEX_NO)
+            *(tkn++) = *(stream->ptr++), tknLen++;
+        *tkn = 0;
+        return(TKN_HEX);
+        }
+
+    if(toupper(*stream->ptr) == 'B' && token[0] == '0')
+        {
+        *(tkn++) = *(stream->ptr++), tknLen++;
+        while((*stream->ptr == '0' || *stream->ptr == '1') && tknLen < MAX_BIN_NO)
+            *(tkn++) = *(stream->ptr++), tknLen++;
+        *tkn = 0;
+        return(TKN_BINARY);
+        }
+
+    if(*stream->ptr == lc_decimal_point)
+        {
+        *(tkn++) = *(stream->ptr++), tknLen++;
+        while(isDigit((unsigned char)*stream->ptr) && tknLen < MAX_DECIMALS)
+            *(tkn++) = *(stream->ptr++), tknLen++;
+        floatFlag = TRUE;
+        }
+    else if(toupper(*stream->ptr) != 'E')
+        {
+        if(*stream->ptr == 'L') *(tkn++) = *(stream->ptr++), tknLen++;
+        *tkn = 0;
+        *ptr_len = tknLen;
+        return(TKN_DECIMAL);
+        }
+    
+    if(toupper(*stream->ptr) == 'E') 
+        {
+        if(isDigit((unsigned char)*(stream->ptr+2))
+        && ( *(stream->ptr+1) == '-' || *(stream->ptr+1) == '+') )
+            *(tkn++) = *(stream->ptr++), tknLen++;
+        if(isDigit((unsigned char)*(stream->ptr+1)))
+            {
+            *(tkn++) = *(stream->ptr++), tknLen++;
+            while(isDigit((unsigned char)*stream->ptr) && tknLen < MAX_SYMBOL)
+                *(tkn++) = *(stream->ptr++), tknLen++;
+            }
+        else 
+            {
+            *tkn = 0;
+            if(floatFlag == TRUE) return(TKN_FLOAT);
+            else 
+                {
+                *ptr_len = tknLen;
+                return(TKN_DECIMAL);
+                }
+            }
+        }
+    *tkn = 0;
+    return(TKN_FLOAT);
+    }
+else
+    {
+    chr = *stream->ptr;
+    *(tkn++) = *(stream->ptr++), tknLen++;
+    switch(chr)
+     {
+     case '"':
+        --tkn; --tknLen;
+        while(*stream->ptr != '"' && *stream->ptr != 0 
+                      && tknLen < MAX_STRING) 
+            {
+            if(*stream->ptr == '\\')
+                {
+                stream->ptr++;
+                if(isDigit((unsigned char)*stream->ptr) && 
+                          isDigit((unsigned char)*(stream->ptr+1)) && 
+                          isDigit((unsigned char)*(stream->ptr+2)))
+                    {
+                    memcpy(buff, stream->ptr, 3);
+                    buff[3] = 0;
+                    *(tkn++) = atoi(buff);
+                    tknLen++;
+                    stream->ptr += 3;
+                    continue;
+                    }
+
+                switch(*stream->ptr)
+                    {
+                    case 0:
+                        goto SRING_TO_LONG_ERROR;
+                        break;
+                    case 'n':
+                        *(tkn++) = '\n'; break;
+                    case '\\':
+                        *(tkn++) = '\\'; break;
+                    case 'b':
+                        *(tkn++) = '\b'; break;
+                    case 'f':
+                        *(tkn++) = '\f'; break;
+                    case 'r':
+                        *(tkn++) = '\r'; break;
+                    case 't':
+                        *(tkn++) = '\t'; break;
+                    case '"':
+                        *(tkn++) = '"';  break;
+                    case 'x':
+                        if(isxdigit((unsigned char)*(stream->ptr + 1)) &&
+                           isxdigit((unsigned char)*(stream->ptr + 2)))
+                            {
+                            buff[0] = '0';
+                            buff[1] = (unsigned char)*(stream->ptr + 1);
+                            buff[2] = (unsigned char)*(stream->ptr + 2);
+                            buff[3] = 0;
+                            *(tkn++) = strtol(buff, NULL, 16);
+                            stream->ptr += 2;
+                            break;
+                            }
+                    case 'u':
+                        if(isxdigit((unsigned char)*(stream->ptr + 1)) &&
+                           isxdigit((unsigned char)*(stream->ptr + 2)) &&
+                           isxdigit((unsigned char)*(stream->ptr + 3)) &&
+                           isxdigit((unsigned char)*(stream->ptr + 4)))
+                            {
+#ifdef SUPPORT_UTF8
+                            buff[0] = '0';
+                            buff[1] = 'x';
+                            memcpy(buff + 2, stream->ptr + 1, 4);
+                            buff[6] = 0;
+                            len = wchar_utf8(strtol(buff, NULL, 16), tkn);
+                            stream->ptr += 4;
+                            tkn += len;
+                            tknLen += len -1;
+#else
+                            *(tkn++) = '\\';
+                            memcpy(tkn, stream->ptr, 5);
+                            tknLen = 5;   
+                            tkn += 5;
+                            stream->ptr += 4;
+#endif
+                            break;
+                            }
+                    default:
+                        *(tkn++) = *stream->ptr;
+                    }
+                stream->ptr++;
+                tknLen++;
+                }
+            else *(tkn++) = *(stream->ptr++), tknLen++;
+            }
+        if(*stream->ptr == '\"')
+            {
+            *tkn = 0;
+            stream->ptr++;
+            *ptr_len = tknLen;
+            return(TKN_STRING);
+            }
+        else
+            {
+            goto SRING_TO_LONG_ERROR;
+            }
+        break;
+
+     case '\'':
+     case '(':
+     case ')':
+        *tkn = 0;
+        return(chr);
+     case '{':
+        --tkn; --tknLen;
+        bracketBalance = 1;
+        while(*stream->ptr != 0  && tknLen < MAX_STRING) 
+            {
+            if(*stream->ptr == '{') ++bracketBalance;
+            if(*stream->ptr == '}') --bracketBalance;
+            if(bracketBalance == 0) break;
+            *(tkn++) = *(stream->ptr++), tknLen++;
+            }
+        if(*stream->ptr == '}')
+            {
+            *tkn = 0;
+            stream->ptr++;
+                        *ptr_len = tknLen;
+            return(TKN_STRING);
+            }
+        else
+            {
+            goto SRING_TO_LONG_ERROR;
+            }
+        break;
+
+        
+     case ',':
+     case ':':
+        *tkn = 0;
+        *ptr_len = tknLen;
+        return(TKN_SYMBOL);
+
+    case '[':
+        while( tknLen < MAX_SYMBOL && *stream->ptr != 0 && *stream->ptr != ']')
+            *(tkn++) = *(stream->ptr++), tknLen++;
+        if(*stream->ptr == 0) return(TKN_ERROR);
+        *tkn++ = ']';
+        *tkn = 0;
+        *ptr_len = ++tknLen;
+        stream->ptr++;
+
+        return(TKN_SYMBOL);
+
+     default:
+        while(  tknLen < MAX_SYMBOL
+            && (unsigned char)*stream->ptr > ' ' 
+            && *stream->ptr != '"' && *stream->ptr != '\''
+            && *stream->ptr != '(' && *stream->ptr != ')'
+            && *stream->ptr != ':' && *stream->ptr != ','
+                        && *stream->ptr != 0)
+                *(tkn++) = *(stream->ptr++), tknLen++;
+        *tkn = 0;
+        *ptr_len = tknLen;
+        if(*stream->ptr == ':') 
+            {
+            stream->ptr++;
+            return(TKN_CONTEXT);
+            }
+        return(TKN_SYMBOL);
+     }
+    }
+*tkn=0;
+return(TKN_ERROR);
+
+SRING_TO_LONG_ERROR:
+*tkn = 0;
+errorProcExt2(ERR_STRING_TOO_LONG, 
+    stuffStringN(token, strlen(token) < 40 ? strlen(token) : 40));
+return(TKN_ERROR);
+}
+
+/* -------------------------- utilities ------------------------------------ */
+
+size_t listlen(CELL * listHead)
+{
+size_t len = 0;
+
+while(listHead != nilCell)
+  {
+  len++;
+  listHead = listHead->next;
+  }
+  
+return(len);
+}
+
+/* -------------------------- functions to get parameters ------------------ */
+
+int getFlag(CELL * params)
+{
+params = evaluateExpression(params);
+return(!isNil(params));
+}
+
+CELL * getInteger(CELL * params, UINT * number)
+{
+CELL * cell;
+#ifdef BIGINT
+INT64 longNum;
+#endif
+    
+cell = evaluateExpression(params);
+
+#ifndef NEWLISP64
+if(cell->type == CELL_INT64)
+    {
+    if(*(INT64 *)&cell->aux >  0xFFFFFFFF) *number = 0xFFFFFFFF;
+    else if(*(INT64 *)&cell->aux < INT32_MIN_AS_INT64) *number = 0x80000000;
+    else *number = *(INT64 *)&cell->aux;
+    }
+else if(cell->type == CELL_LONG)
+    *number = cell->contents;
+else if(cell->type == CELL_FLOAT)
+    {
+#ifdef WINDOWS
+    if(isnan(*(double *)&cell->aux) || !_finite(*(double *)&cell->aux)) *number = 0;
+#else
+    if(isnan(*(double *)&cell->aux)) *number = 0; 
+#endif
+    else if(*(double *)&cell->aux >  4294967295.0) *number = 0xFFFFFFFF;
+    else if(*(double *)&cell->aux < -2147483648.0) *number = 0x80000000;
+    else *number = *(double *)&cell->aux;
+    }
+#else /* NEWLISP64 */
+if(cell->type == CELL_LONG)
+    *number = cell->contents;
+else if(cell->type == CELL_FLOAT)
+    {
+    if(isnan(*(double *)&cell->contents)) *number = 0;
+    else if(*(double *)&cell->contents >  9223372036854775807.0) *number = 0x7FFFFFFFFFFFFFFFLL;
+    else if(*(double *)&cell->contents < -9223372036854775808.0) *number = 0x8000000000000000LL;
+    else *number = *(double *)&cell->contents;
+    }
+#endif
+else
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        {
+        longNum = bigintToInt64(cell);
+        *number = longNum;
+#ifndef NEWLISP64
+        if(longNum > 2147483647LL || longNum < -2147483648LL)
+            return(errorProcExt(ERR_NUMBER_OUT_OF_RANGE, cell));
+#endif
+        }
+    else
+#endif
+        {
+        *number = 0;
+        return(errorProcArgs(ERR_NUMBER_EXPECTED, params));
+        }
+    }
+
+return(params->next);
+}
+
+#ifndef NEWLISP64
+CELL * getInteger64Ext(CELL * params, INT64 * number, int evalFlag)
+{
+CELL * cell;
+   
+if(evalFlag) 
+    cell = evaluateExpression(params);
+else
+    cell = params;
+
+if(cell->type == CELL_INT64)
+    *number = *(INT64 *)&cell->aux;
+else if(cell->type == CELL_LONG)
+    *number = (int)cell->contents;
+else if(cell->type == CELL_FLOAT)
+    {
+    if(isnan(*(double *)&cell->aux)) *number = 0; 
+    else if(*(double *)&cell->aux >  9223372036854775807.0) *number = 0x7FFFFFFFFFFFFFFFLL;
+    else if(*(double *)&cell->aux < -9223372036854775808.0) *number = 0x8000000000000000LL;
+    else *number = *(double *)&cell->aux;
+    }
+else /* check for bigint if size * != NULL, then return bigint address in number */
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        *number = bigintToInt64(cell);
+    else
+#endif
+        {
+        *number = 0; 
+        return(errorProcExt(ERR_NUMBER_EXPECTED, params));
+        }
+    }
+
+return(params->next);
+}
+
+#else /* NEWLISP64 */
+CELL * getInteger64Ext(CELL * params, INT64 * number, int evalFlag)
+{
+CELL * cell;
+
+if(evalFlag)
+    cell = evaluateExpression(params);
+else
+    cell = params;
+
+if(cell->type == CELL_LONG)
+    *number = cell->contents;
+else if(cell->type == CELL_FLOAT)
+    {
+    if(isnan(*(double *)&cell->contents)) *number = 0;
+    else if(*(double *)&cell->contents >  9223372036854775807.0) *number = 0x7FFFFFFFFFFFFFFFLL;
+    else if(*(double *)&cell->contents < -9223372036854775808.0) *number = 0x8000000000000000LL;
+    else *number = *(double *)&cell->contents;
+    }
+else
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        *number = bigintToInt64(cell);
+    else
+#endif
+        {
+        *number = 0;
+        return(errorProcArgs(ERR_NUMBER_EXPECTED, params));
+        }
+    }
+
+return(params->next);
+}
+#endif
+
+CELL * getIntegerExt(CELL * params, UINT * number, int evalFlag)
+{
+CELL * cell;
+#ifdef BIGINT
+INT64 longNum;
+#endif
+
+if(evalFlag)
+    cell = evaluateExpression(params);
+else cell = params;
+
+#ifndef NEWLISP64
+if(cell->type == CELL_INT64)
+    {
+    if(*(INT64 *)&cell->aux >  0xFFFFFFFF) *number = 0xFFFFFFFF;
+    else if(*(INT64 *)&cell->aux < INT32_MIN_AS_INT64) *number = 0x80000000;
+    else *number = *(INT64 *)&cell->aux;
+    }
+else if(cell->type == CELL_LONG)
+    *number = cell->contents;
+else if(cell->type == CELL_FLOAT)
+    {
+#ifdef WINDOWS
+    if(isnan(*(double *)&cell->aux) || !_finite(*(double *)&cell->aux)) *number = 0;
+#else
+    if(isnan(*(double *)&cell->aux)) *number = 0; 
+#endif
+    else if(*(double *)&cell->aux >  4294967295.0) *number = 0xFFFFFFFF;
+    else if(*(double *)&cell->aux < -2147483648.0) *number = 0x80000000;
+    else *number = *(double *)&cell->aux;
+    }
+#else /* NEWLISP64 */
+if(cell->type == CELL_LONG)
+    *number = cell->contents;
+else if(cell->type == CELL_FLOAT)
+    {
+    if(isnan(*(double *)&cell->contents)) *number = 0;
+    else if(*(double *)&cell->contents >  9223372036854775807.0) *number = 0x7FFFFFFFFFFFFFFFLL;
+    else if(*(double *)&cell->contents < -9223372036854775808.0) *number = 0x8000000000000000LL;
+    else *number = *(double *)&cell->contents;
+    }
+#endif
+else /* if BIGNUM type throw ERR_NUMBER_OUT_OF_RANGE */
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        {
+        longNum = bigintToInt64(cell);
+        *number = longNum;
+#ifndef NEWLISP64
+        if(longNum > 2147483647LL || longNum < -2147483648LL)
+            return(errorProcExt(ERR_NUMBER_OUT_OF_RANGE, cell));
+#endif
+        }
+    else
+     
+#endif /* BIGINT */
+        {
+        *number = 0;
+        return(errorProcArgs(ERR_NUMBER_EXPECTED, params));
+        }
+    }
+
+return(params->next);
+}
+
+
+CELL * getFloat(CELL * params, double * floatNumber)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+
+#ifndef NEWLISP64
+if(cell->type == CELL_FLOAT)
+    *floatNumber = *(double *)&cell->aux;
+else if(cell->type == CELL_INT64)
+    *floatNumber = *(INT64 *)&cell->aux;
+#else
+if(cell->type == CELL_FLOAT)
+    *floatNumber = *(double *)&cell->contents;
+#endif
+else if(cell->type == CELL_LONG)
+    *floatNumber = (INT)cell->contents;
+else
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        *floatNumber = bigintCellToFloat(cell);
+    else
+#endif
+        { 
+        *floatNumber = 0.0;
+        return(errorProcArgs(ERR_NUMBER_EXPECTED, params));
+        }
+    }
+
+return(params->next);
+}
+
+
+CELL * getString(CELL * params, char * * stringPtr)
+{
+CELL * cell;
+SYMBOL * sPtr;
+
+cell = evaluateExpression(params);
+
+if(cell->type == CELL_CONTEXT)
+    {
+    sPtr = translateCreateSymbol( ((SYMBOL*)cell->contents)->name, CELL_NIL,
+        (SYMBOL*)cell->contents, TRUE);
+    cell = (CELL *)sPtr->contents;
+    }
+
+if(cell->type != CELL_STRING)
+    {
+    *stringPtr = "";
+    return(errorProcArgs(ERR_STRING_EXPECTED, params));
+    }
+
+*stringPtr = (char *)cell->contents;
+return(params->next);
+}
+
+
+CELL * getStringSize(CELL * params, char * * stringPtr, size_t * size, int evalFlag)
+{
+CELL * cell;
+SYMBOL * sPtr;
+
+if(evalFlag)
+    cell = evaluateExpression(params);
+else 
+    cell = params;
+
+if(cell->type == CELL_CONTEXT)
+    {
+    sPtr = translateCreateSymbol( ((SYMBOL*)cell->contents)->name, CELL_NIL,
+        (SYMBOL*)cell->contents, TRUE);
+    symbolCheck = sPtr;
+    cell = (CELL *)sPtr->contents;
+    }
+
+if(cell->type != CELL_STRING)
+    {
+    *stringPtr = "";
+    return(errorProcArgs(ERR_STRING_EXPECTED, params));
+    }
+
+*stringPtr = (char *)cell->contents;
+
+if(size) *size = cell->aux - 1;
+return(params->next);
+}
+
+
+CELL * getSymbol(CELL * params, SYMBOL * * symbol)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+
+if(cell->type != CELL_SYMBOL)
+    {
+    if(cell->type == CELL_DYN_SYMBOL)
+        {
+        *symbol = getDynamicSymbol(cell);
+        return(params->next);
+        }
+    *symbol = nilSymbol;
+    return(errorProcArgs(ERR_SYMBOL_EXPECTED, params));
+    }
+
+*symbol = (SYMBOL *)cell->contents;
+return(params->next);
+}
+
+/* only used for internal syms: $timer, $error-event, $prompt-event, $command-event
+   $transfer-event, and $signal-1-> $signal-32 
+   If a quoted symbols hasn't been passed take the evaluated params as contents
+   of the system event symbols starting with $ */
+CELL * getCreateSymbol(CELL * params, SYMBOL * * symbol, char * name)
+{
+CELL * cell;
+CELL * cellForDelete;
+
+cell = evaluateExpression(params);
+
+if(cell->type != CELL_SYMBOL)
+    {
+    if(cell->type == CELL_DYN_SYMBOL)
+        {
+        *symbol = getDynamicSymbol(cell);
+        return(params->next);
+        }
+    *symbol = translateCreateSymbol(name, CELL_NIL, mainContext, TRUE);
+    (*symbol)->flags |= SYMBOL_PROTECTED | SYMBOL_GLOBAL;
+    cellForDelete = (CELL *)(*symbol)->contents;
+    if(isNil(cell)) 
+        *symbol = nilSymbol;
+    else if(cell->type != CELL_LAMBDA && cell->type != CELL_FEXPR && cell->type != CELL_PRIMITIVE)
+        {
+        *symbol = nilSymbol;
+        deleteList(cellForDelete);
+        return(errorProcExt(ERR_INVALID_PARAMETER, params));
+        }
+    else if(compareCells(cellForDelete, cell) != 0)
+        {
+        (*symbol)->contents = (UINT)copyCell(cell);
+        deleteList(cellForDelete);
+        }
+    }
+else
+    *symbol = (SYMBOL *)cell->contents;
+
+return(params->next);
+}
+
+
+CELL * getContext(CELL * params, SYMBOL * * context)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+
+if(cell->type == CELL_CONTEXT || cell->type == CELL_SYMBOL)
+    *context = (SYMBOL *)cell->contents;
+else    
+    {
+    *context = NULL;
+    return(errorProcArgs(ERR_CONTEXT_EXPECTED, params));
+    }
+
+if(symbolType(*context) != CELL_CONTEXT)
+    return(errorProcExt(ERR_CONTEXT_EXPECTED, params));
+
+return(params->next);
+}
+
+
+CELL * getEvalDefault(CELL * params, CELL * * result)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+
+if(cell->type == CELL_CONTEXT)
+    {
+    symbolCheck = translateCreateSymbol( ((SYMBOL*)cell->contents)->name, CELL_NIL,
+        (SYMBOL*)cell->contents, TRUE);
+    cell = (CELL *)symbolCheck->contents;
+    }
+
+*result = cell;
+
+return(params->next);
+}
+
+/* gets the first element, without list envelope in head
+   and return the list with envelope
+*/
+CELL * getListHead(CELL * params, CELL * * head)
+{
+CELL * cell;
+SYMBOL * sPtr;
+
+cell = evaluateExpression(params);
+
+if(cell->type == CELL_CONTEXT)
+    {
+    sPtr = translateCreateSymbol( ((SYMBOL*)cell->contents)->name, CELL_NIL,
+        (SYMBOL*)cell->contents, TRUE);
+    cell = (CELL *)sPtr->contents;
+    }
+
+if(!isList(cell->type))
+    {
+    *head = nilCell;
+    return(errorProcExt(ERR_LIST_EXPECTED, params));
+    }
+
+*head = (CELL *)cell->contents;
+
+return(params->next);
+}
+
+/* ------------------------------- core predicates ------------------------ */
+
+CELL * p_setLocale(CELL * params)
+{
+#ifndef ANDROID
+struct lconv * lc;
+#endif
+char * locale;
+UINT category;
+CELL * cell;
+
+if(params != nilCell)
+    params = getString(params, &locale);
+else locale = NULL;
+
+getEvalDefault(params, &cell);
+if(isNumber(cell->type)) /* second parameter */
+    getIntegerExt(cell, &category, FALSE);
+else category = LC_ALL;
+
+locale = setlocale(category, locale);
+
+if(locale == NULL)
+    return(nilCell);
+
+stringOutputRaw = (strcmp(locale, "C") == 0);
+
+#ifndef ANDROID
+lc = localeconv();  
+lc_decimal_point = *lc->decimal_point;
+#endif
+cell = getCell(CELL_EXPRESSION);
+addList(cell, stuffString(locale));
+#ifdef ANDROID
+addList(cell, stuffStringN(".", 1));
+#else
+addList(cell, stuffStringN(lc->decimal_point, 1));
+#endif
+return(cell);
+}
+
+CELL * p_quote(CELL * params)
+{
+return(copyCell(params));
+}
+
+
+CELL * p_eval(CELL * params)
+{
+CELL * result;
+
+params = evaluateExpression(params);
+result = evaluateExpression(params);
+pushResultFlag = FALSE;
+return(result);
+}
+
+
+CELL * p_catch(CELL * params)
+{
+jmp_buf errorJumpSave;
+UINT * envStackIdxSave;
+UINT * lambdaStackIdxSave;
+int recursionCountSave;
+int value;
+CELL * expr;
+CELL * result;
+SYMBOL * symbol = NULL;
+SYMBOL * contextSave;
+CELL * objSave;
+CELL * objCellSave;
+
+expr = params;
+if(params->next != nilCell)
+    {
+    getSymbol(params->next, &symbol);
+    if(isProtected(symbol->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+    }
+
+memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+/* save general environment */
+envStackIdxSave = envStackIdx;
+recursionCountSave = recursionCount;
+lambdaStackIdxSave = lambdaStackIdx;
+contextSave = currentContext;
+/* save FOOP environment */
+objSave = (CELL *)objSymbol.contents;
+objCellSave = objCell;
+itSymbol->contents = (UINT)nilCell;
+
+if((value = setjmp(errorJump)) != 0)
+    {
+    memcpy(errorJump, errorJumpSave, (sizeof(jmp_buf)));
+    /* restore general environment */
+    recoverEnvironment(envStackIdxSave);
+    recursionCount = recursionCountSave;
+    lambdaStackIdx = lambdaStackIdxSave;
+    currentContext = contextSave;
+    /* restore FOOP environment */
+    objSymbol.contents = (UINT)objSave;
+    objCell = objCellSave;
+
+    evalCatchFlag--;
+    if(value == EXCEPTION_THROW)
+        {
+        if(symbol == NULL) return(throwResult);
+        deleteList((CELL*)symbol->contents);
+        symbol->contents = (UINT)throwResult;
+        return(trueCell);
+        }
+        
+    if(errorStream.buffer != NULL)
+        {
+        if(symbol == NULL) 
+            {
+            if(errorEvent == nilSymbol && evalCatchFlag == 0)
+                varPrintf(OUT_CONSOLE, "\n%.1024s\n", errorStream.buffer);
+            longjmp(errorJump, value);
+            }
+        deleteList((CELL*)symbol->contents);
+        symbol->contents = (UINT)stuffString(errorStream.buffer);
+        }
+
+    return(nilCell);
+    }
+
+evalCatchFlag++;
+result = copyCell(evaluateExpression(expr));
+evalCatchFlag--;
+memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+
+if(symbol == NULL) return(result);
+
+deleteList((CELL*)symbol->contents);
+symbol->contents = (UINT)result;
+
+return(trueCell);
+}
+
+
+CELL * p_throw(CELL * params)
+{
+if(evalCatchFlag == 0) 
+    return(errorProc(ERR_THROW_WO_CATCH));
+
+throwResult = copyCell(evaluateExpression(params));
+longjmp(errorJump, EXCEPTION_THROW);
+
+return(trueCell);
+}
+
+CELL * p_throwError(CELL * params)
+{
+evalFunc = NULL;
+errorProcExt(ERR_USER_ERROR, evaluateExpression(params));
+return(nilCell);
+}
+
+CELL * evalString(CELL * params, int mode);
+
+CELL * p_evalString(CELL * params) { return(evalString(params, EVAL_STRING)); }
+CELL * p_readExpr(CELL * params) { return(evalString(params, READ_EXPR)); }
+
+CELL * evalString(CELL * params, int mode)
+{
+SYMBOL * context = currentContext;
+char * evalStr;
+
+params = getString(params, &evalStr);
+
+if(params != nilCell)
+    {
+    if((context = getCreateContext(params, TRUE)) == NULL)
+        return(errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, params));
+    }
+
+if(mode == EVAL_STRING)
+    return(copyCell(sysEvalString(evalStr, context, params->next, mode)));
+
+/* returns a new object not yet marked for deletion */
+return(sysEvalString(evalStr, context, params->next, mode));
+}
+
+/* modes:
+EVAL_STRING  
+  the classic eval-string: read the string, compile to s-expression , evaluate
+READ_EXPR_SYNC
+  used by p_sync() in nl-filesys.c 
+READ_EXPR
+  used by p_readExpr 
+READ_EXPR_NET
+  used by p_netEval introduces in 10.6.3, before READ_EXPR_SYNC was used
+*/
+
+
+CELL * sysEvalString(char * evalString, SYMBOL * context, CELL * proc, int mode)
+{
+CELL * program;
+STREAM stream;
+CELL * resultCell = nilCell;
+SYMBOL * contextSave = NULL;
+UINT * resultIdxSave;
+jmp_buf errorJumpSave;
+int recursionCountSave;
+UINT * envStackIdxSave;
+UINT offset;
+CELL * xlate;
+
+makeStreamFromString(&stream, evalString);
+if(proc->next != nilCell)
+    {
+    getInteger(proc->next, &offset);
+    stream.ptr += offset;
+    }
+
+resultIdxSave = resultStackIdx;
+contextSave = currentContext;
+currentContext = context;
+
+if(proc != nilCell)
+    {
+    recursionCountSave = recursionCount;
+    envStackIdxSave = envStackIdx;
+    evalCatchFlag++;
+    memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+
+    if(setjmp(errorJump) != 0)
+        {
+        memcpy(errorJump, errorJumpSave, (sizeof(jmp_buf)));
+        recoverEnvironment(envStackIdxSave);
+        evalCatchFlag--;
+        recursionCount = recursionCountSave;
+        currentContext = contextSave;
+        if(mode == READ_EXPR)
+            return(copyCell(evaluateExpression(proc)));
+        return(evaluateExpression(proc));
+        }
+    }
+
+while(TRUE)
+    {
+    pushResult(program = getCell(CELL_QUOTE));
+    if(compileExpression(&stream, program) == 0) 
+        break;
+    if(readerEvent != nilSymbol)
+        {
+        --resultStackIdx;
+        executeSymbol(readerEvent, program, &xlate);
+        pushResult(program = makeCell(CELL_QUOTE, (UINT)xlate));
+        }
+    if(mode == EVAL_STRING)
+        resultCell = evaluateExpression((CELL *)program->contents);
+    else /* READ_EXPR, READ_EXPR_SYNC, READ_EXPR_NET */
+        {
+        if(resultCell != nilCell) pushResult(resultCell); /* 10.6.3 */
+        countCell->contents = (UINT)(stream.ptr - stream.buffer);
+        resultCell = (CELL *)program->contents;
+        program->contents = (UINT)nilCell; /* de-couple */
+        if(mode == READ_EXPR_SYNC || mode == READ_EXPR) /* 10.6.3 */
+            break; /* only do first expression */
+        }
+
+    if(resultStackIdx > resultStackTop - 256)
+        {
+        program = popResult(); /* leave last result */
+        cleanupResults(resultIdxSave);
+        pushResult(program);
+        }
+    }
+
+currentContext = contextSave;
+
+if(proc != nilCell)
+    {
+    memcpy(errorJump, errorJumpSave, (sizeof(jmp_buf)));
+    evalCatchFlag--;
+    }
+
+return(resultCell);
+}
+
+#ifdef EMSCRIPTEN
+extern char *emscripten_run_script_string(const char *script);
+char * evalJSbuff = NULL;
+
+char * evalStringJS(char * cmd, size_t len)
+{
+if(evalJSbuff != NULL) free(evalJSbuff);
+
+evalJSbuff = callocMemory(len + 1);
+memcpy(evalJSbuff, cmd, len);
+
+return(emscripten_run_script_string(evalJSbuff));
+}
+
+
+CELL * p_evalStringJS(CELL * params)
+{
+char * cmd;
+size_t len;
+char * result;
+
+getStringSize(params, &cmd, &len, TRUE);
+result = evalStringJS(cmd, len);
+
+return(stuffString(result));
+}
+#endif
+
+
+CELL * p_curry(CELL * params)
+{
+CELL * lambda;
+CELL * cell;
+
+cell = makeCell(CELL_EXPRESSION, (UINT)stuffSymbol(sysxSymbol));
+lambda = makeCell(CELL_LAMBDA, (UINT)cell);
+cell->next = getCell(CELL_EXPRESSION);
+cell = cell->next;
+cell->contents = (UINT)copyCell(params);
+cell = (CELL *)cell->contents;
+/* take left parameter */
+cell->next = copyCell(params->next);
+cell = cell->next;
+cell->next = stuffSymbol(sysxSymbol);
+/* take right parameter
+cell->next = stuffSymbol(sysxSymbol);
+cell = cell->next;
+cell->next = copyCell(params->next);
+*/
+return(lambda);
+}
+
+
+CELL * p_apply(CELL * params)
+{
+CELL * expr;
+CELL * args;
+CELL * cell;
+CELL * result;
+CELL * func;
+ssize_t count = 0, cnt;
+UINT * resultIdxSave;
+
+func = evaluateExpression(params);
+params = getEvalDefault(params->next, &args);
+cell = copyCell(func);
+expr = makeCell(CELL_EXPRESSION, (UINT)cell);
+
+if(args->type == CELL_ARRAY)
+    {
+    args = arrayList(args, FALSE);
+    pushResult(args);
+    }
+
+if(args->type != CELL_EXPRESSION)
+    {
+    pushResult(expr);
+    if(isNil(args))
+        return(copyCell(evaluateExpression(expr)));
+    else
+        return(errorProcExt(ERR_LIST_EXPECTED, args));
+    }
+
+args = (CELL *)args->contents;        
+
+if(params != nilCell)
+    getInteger(params, (UINT *)&count);
+if(count < 2) count = MAX_LONG;
+cnt = count;
+
+resultIdxSave = resultStackIdx + 2;
+for(;;)
+    {
+    while(args != nilCell && cnt--)
+        {
+        if(isSelfEval(args->type))
+            cell->next = copyCell(args);
+        else
+            cell->next = makeCell(CELL_QUOTE, (UINT)copyCell(args));
+        cell = cell->next;
+        args = args->next;
+        }
+    pushResult(expr);
+    if(args == nilCell)
+        {
+        result = evaluateExpression(expr);
+        if(symbolCheck) 
+            {
+            pushResultFlag = FALSE;
+            return(result);
+            }
+        else return(copyCell(result));
+        }       
+    result = copyCell(evaluateExpression(expr));
+    cell = copyCell(func);
+    expr = makeCell(CELL_EXPRESSION, (UINT)cell);
+    cell->next = makeCell(CELL_QUOTE, (UINT)result);
+    cell = cell->next;
+    cnt = count - 1;
+    cleanupResults(resultIdxSave);
+    }
+}
+
+CELL * p_args(CELL * params)
+{
+if(params != nilCell) 
+    return(copyCell(implicitIndexList((CELL*)argsSymbol->contents, params)));
+return(copyCell((CELL*)argsSymbol->contents));
+}
+
+/* in-place expansion, if symbol==NULL all uppercase, non-nil vars are expanded */
+CELL * expand(CELL * expr, SYMBOL * symbol)
+{
+CELL * cell = nilCell;
+SYMBOL * sPtr;
+int enable = 1;
+CELL * cont;
+int wchar;
+
+if(isList(expr->type) || expr->type == CELL_QUOTE)
+    cell = (CELL*)expr->contents;
+else if(expr->type == CELL_SYMBOL && expr->contents == (UINT)symbol)
+    expandExprSymbol(expr, symbol);
+
+while(cell != nilCell)
+    {   
+    if(cell->type == CELL_SYMBOL && (cell->contents == (UINT)symbol || symbol == NULL) )
+        {
+        sPtr = (SYMBOL *)cell->contents;
+        if(symbol == NULL)
+            {
+#ifndef SUPPORT_UTF8
+            wchar = *sPtr->name;
+#else
+            utf8_wchar(sPtr->name, &wchar);
+#endif
+            enable = (wchar > 64 && wchar < 91);
+            cont = (CELL*)sPtr->contents;
+            enable = (enable && cont->contents != (UINT)nilCell 
+                            && cont->contents != (UINT)nilSymbol);
+            }
+
+        if(symbol || enable)
+            expandExprSymbol(cell, sPtr);
+        }
+
+    else if(isEnvelope(cell->type)) expand(cell, symbol);
+    cell = cell->next;
+    }
+
+return(expr);
+}
+
+
+void expandExprSymbol(CELL * cell, SYMBOL * sPtr)
+{
+CELL * rep;
+
+rep = copyCell((CELL*)sPtr->contents);
+/* check for and undo copyCell optimization */
+while((UINT)rep == sPtr->contents)
+    rep = copyCell((CELL*)sPtr->contents);
+
+cell->type = rep->type;
+cell->aux = rep->aux;
+cell->contents = rep->contents;
+rep->type = CELL_LONG;
+deleteList(rep);
+}
+
+
+/* expands one or a chain of expressions */
+
+CELL * blockExpand(CELL * block, SYMBOL * symbol)
+{
+CELL * expanded = nilCell;
+CELL * next = nilCell;
+
+while(block != nilCell)
+    {
+    if(expanded == nilCell)
+        {
+        next = expand(copyCell(block), symbol);
+        expanded = next;
+        }
+    else
+        {
+        next->next = expand(copyCell(block), symbol);
+        next = next->next;
+        }
+    block = block->next;
+    }
+
+return(expanded);
+}
+
+
+CELL * p_expand(CELL * params)
+{
+SYMBOL * symbol;
+CELL * expr;
+CELL * next;
+CELL * list;
+CELL * cell;
+int evalFlag;
+
+params = getEvalDefault(params, &expr);
+
+if((next = params) == nilCell)
+    return(expand(copyCell(expr), NULL));
+
+while((params = next) != nilCell)
+    {
+    next = params->next;
+    params = evaluateExpression(params);
+    if(params->type == CELL_SYMBOL)
+        symbol = (SYMBOL*)params->contents;
+    else if(params->type == CELL_DYN_SYMBOL)
+        symbol = getDynamicSymbol(params);
+    else if(params->type == CELL_EXPRESSION)
+        {
+        evalFlag = getFlag(next);
+        list = (CELL*)params->contents; /* expansion assoc list */
+        while(list != nilCell)
+            {
+            if(list->type != CELL_EXPRESSION)
+                return(errorProcExt(ERR_LIST_EXPECTED, list));
+            cell = (CELL *)list->contents;
+            if(cell->type != CELL_SYMBOL)
+                return(errorProcExt(ERR_SYMBOL_EXPECTED, cell));
+            symbol = (SYMBOL*)cell->contents;
+            pushEnvironment(symbol->contents);
+            pushEnvironment(symbol);
+            if(evalFlag)
+                symbol->contents = (UINT)copyCell(evaluateExpression(cell->next));
+            else
+                symbol->contents = (UINT)cell->next;
+            expr = expand(copyCell(expr), symbol);
+            if(evalFlag) deleteList((CELL *)symbol->contents); 
+            symbol = (SYMBOL*)popEnvironment();
+            symbol->contents = popEnvironment();
+            pushResult(expr);
+            list = list->next;
+            continue;
+            }
+        break;
+        }
+    else 
+        return(errorProcExt(ERR_LIST_OR_SYMBOL_EXPECTED, params));
+    expr = expand(copyCell(expr), symbol);
+    pushResult(expr);
+    }
+
+return(copyCell(expr));
+}
+
+
+CELL * defineOrMacro(CELL * params, UINT cellType, int flag)
+{
+SYMBOL * symbol;
+CELL * argsPtr;
+CELL * lambda;
+CELL * args;
+CELL * body;
+CELL * cell;
+
+if(params->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_LIST_OR_SYMBOL_EXPECTED, params));
+
+/* symbol to be defined */
+argsPtr = (CELL *)params->contents;
+if(argsPtr->type != CELL_SYMBOL)
+    {
+    if(argsPtr->type == CELL_DYN_SYMBOL)
+        symbol = getDynamicSymbol(argsPtr);
+    else
+        return(errorProcExt(ERR_SYMBOL_EXPECTED, params));
+    }
+else symbol = (SYMBOL *)argsPtr->contents;
+
+if(isProtected(symbol->flags))
+    return(errorProc(ERR_SYMBOL_PROTECTED));
+
+/* local symbols */
+argsPtr = copyList(argsPtr->next);
+
+args = getCell(CELL_EXPRESSION);
+args->contents = (UINT)argsPtr;
+/* body expressions */
+body = copyList(params->next);
+
+/* if expansion macro insert expand symbol for body expansion
+   (expand 'body) */
+if(flag)
+    {
+    if(body->next != nilCell)
+        {
+        /* body has multiple expressions (expand '(begin ...)) */
+        cell = stuffSymbol(beginSymbol);
+        cell->next = body;
+        body = makeCell(CELL_EXPRESSION, (UINT)cell);
+        }
+    cell = stuffSymbol(expandSymbol);
+    cell->next = makeCell(CELL_QUOTE, (UINT)body);
+    body = makeCell(CELL_EXPRESSION, (UINT)cell);
+    symbol->flags |= SYMBOL_MACRO;
+    }
+
+args->next = body;
+lambda = makeCell(cellType, (UINT)args);
+
+deleteList((CELL *)symbol->contents);
+symbol->contents = (UINT)lambda;
+
+pushResultFlag = FALSE;
+return(lambda);
+}
+
+
+CELL * p_define(CELL * params)
+{
+if(params->type != CELL_SYMBOL)
+    {
+    if(params->type != CELL_DYN_SYMBOL)
+        return(defineOrMacro(params, CELL_LAMBDA, FALSE));
+    return(setDefine(getDynamicSymbol(params), params->next, SET_SET));
+    }
+
+return(setDefine((SYMBOL *)params->contents, params->next, SET_SET));
+}
+
+CELL * p_defineMacro(CELL * params)
+{
+return(defineOrMacro(params, CELL_FEXPR, FALSE));
+}
+
+CELL * p_macro(CELL * params)
+{
+return(defineOrMacro(params, CELL_FEXPR, TRUE));
+}
+
+/* also called from setq */
+CELL * p_setf(CELL *params)
+{
+SYMBOL * symbolRef = NULL;
+CELL * cell;
+CELL * new;
+CELL * stringRef;
+char * indexRefPtr;
+
+SETF_BEGIN:
+if(params->next == nilCell)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+        
+cell = evaluateExpression(params);
+
+if(cell == nilCell || cell == trueCell)
+    errorProcExt(ERR_IS_NOT_REFERENCED, cell);
+            
+symbolRef = symbolCheck;
+stringRef = stringCell;
+indexRefPtr = stringIndexPtr;
+
+if(symbolRef && isProtected(symbolRef->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolRef)));
+
+itSymbol->contents = (UINT)cell;
+new = copyCell(evaluateExpression(params->next));
+itSymbol->contents = (UINT)nilCell;
+    
+params = params->next; 
+params = params->next; 
+
+
+if(stringRef && indexRefPtr)
+    {
+    cell = setNthStr((CELL *)stringRef, new, indexRefPtr);
+    if(params != nilCell) goto SETF_BEGIN;
+    return(cell);
+    }
+
+/* delete contents of original cell */
+if(isEnvelope(cell->type))
+    {
+    if(cell->type == CELL_ARRAY)
+        deleteArray(cell);
+    else
+        deleteList((CELL *)cell->contents);
+    }
+else if(cell->type == CELL_STRING || cell->type == CELL_DYN_SYMBOL 
+#ifdef BIGINT
+        || cell->type == CELL_BIGINT
+#endif
+        )
+    freeMemory( (void *)cell->contents);
+    
+    
+/* get new contents */  
+cell->type = new->type;
+cell->aux = new->aux;
+cell->contents = new->contents;
+
+/* free cell */
+new->type = CELL_FREE;
+new->aux = 0;
+new->contents = 0;
+new->next = firstFreeCell;
+firstFreeCell = new;
+--cellCount;
+
+if(params != nilCell) goto SETF_BEGIN;
+
+/* return modified cell */
+symbolCheck = symbolRef;
+pushResultFlag = FALSE;
+return(cell);
+}
+
+
+CELL * p_set(CELL *params)
+{
+SYMBOL * symbol;
+CELL * next;
+
+for(;;)
+    {
+    params = getSymbol(params, &symbol);
+    next = params->next;
+    if(params == nilCell)
+        return(errorProc(ERR_MISSING_ARGUMENT));
+    if(next == nilCell) return(setDefine(symbol, params, SET_SET));
+    setDefine(symbol, params, SET_SET);
+    params = next;
+    }
+}
+
+
+CELL * p_constant(CELL *params)
+{
+SYMBOL * symbol;
+CELL * next;
+UINT * idx = envStackIdx;
+
+for(;;)
+    {
+    params = getSymbol(params, &symbol);
+    /* make sure symbol is not used as local in call hierachy */
+    while(idx > envStack)
+        {
+        if(symbol == (SYMBOL *)*(--idx))
+            errorProcExt2(ERR_CANNOT_PROTECT_LOCAL, stuffSymbol(symbol));
+        --idx;
+        }
+
+    /* protect contexts from being set, but not vars holding contexts */
+    if((symbolType(symbol) == CELL_CONTEXT && (SYMBOL *)((CELL *)symbol->contents)->contents == symbol)
+            || symbol == countSymbol)
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+    next = params->next;
+    if(symbol->context != currentContext)
+        return(errorProcExt2(ERR_NOT_CURRENT_CONTEXT, stuffSymbol(symbol)));
+    symbol->flags |= SYMBOL_PROTECTED;
+    if(params == nilCell)
+        return(copyCell((CELL*)symbol->contents));
+    if(next == nilCell) 
+        {
+        next = setDefine(symbol, params, SET_CONSTANT);
+        pushResultFlag = TRUE;
+        return(copyCell(next));
+        }
+    setDefine(symbol, params, SET_CONSTANT);
+    pushResultFlag = TRUE;
+    params = next;
+    }
+}
+
+
+CELL * setDefine(SYMBOL * symbol, CELL * params, int type)
+{
+CELL * cell;
+
+if(isProtected(symbol->flags))
+    {
+    if(type == SET_CONSTANT)
+        {
+        if(symbol == nilSymbol || symbol == trueSymbol)
+            return(errorProcExt2(ERR_SYMBOL_EXPECTED, stuffSymbol(symbol)));
+        }
+    else
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+    }
+
+cell = copyCell(evaluateExpression(params));
+
+deleteList((CELL *)symbol->contents);
+symbol->contents = (UINT)(cell);
+
+symbolCheck = symbol;
+pushResultFlag = FALSE; 
+
+return(cell);
+}
+
+
+CELL * p_global(CELL * params)
+{
+SYMBOL * sPtr;
+
+do
+    {
+    params = getSymbol(params, &sPtr);
+    if(sPtr->context != mainContext || currentContext != mainContext)
+        return(errorProcExt2(ERR_NOT_IN_MAIN, stuffSymbol(sPtr)));
+    else 
+        sPtr->flags |= SYMBOL_GLOBAL;
+    } while (params != nilCell);
+
+return(stuffSymbol(sPtr));
+}
+
+#define LET_STD 0
+#define LET_NEST 1
+#define LET_EXPAND 2
+#define LET_LOCAL 3
+
+CELL * let(CELL * params, int type);
+
+CELL * p_let(CELL * params) { return(let(params, LET_STD)); }
+CELL * p_letn(CELL * params) { return(let(params, LET_NEST)); }
+CELL * p_letExpand(CELL * params) { return(let(params, LET_EXPAND)); }
+CELL * p_local(CELL * params) { return(let(params, LET_LOCAL)); }
+
+CELL * let(CELL * params, int type)
+{
+CELL * inits;
+CELL * cell;
+CELL * result = nilCell;
+CELL * args = NULL, * list = NULL;
+CELL * body;
+SYMBOL * symbol;
+int localCount = 0;
+
+if(params->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_INVALID_LET, params));
+
+/* evaluate symbol assignments in parameter list 
+   handle double syntax classic: (let ((s1 e1) (s2 e2) ...) ...) 
+                            and: (let (s1 e1 s2 e2 ...) ...)
+*/
+inits = (CELL*)params->contents;
+body = params->next;
+
+if(type == LET_LOCAL)
+    {
+    while(inits != nilCell)
+        {
+        if(inits->type != CELL_SYMBOL)
+            return(errorProcExt(ERR_SYMBOL_EXPECTED, inits));
+        symbol = (SYMBOL *)inits->contents;
+        if(isProtected(symbol->flags))
+                return(errorProcExt(ERR_SYMBOL_PROTECTED, inits));
+        pushEnvironment(symbol->contents);
+        pushEnvironment(symbol);
+        symbol->contents = (UINT)copyCell(nilCell);
+        localCount++;
+        inits = inits->next;
+        }
+    goto EVAL_LET_BODY; 
+    }
+
+while(inits != nilCell)
+    {
+    if(inits->type != CELL_EXPRESSION)
+        {
+        if(inits->type != CELL_SYMBOL)
+            return(errorProcExt(ERR_INVALID_LET, inits));
+        cell = inits;
+        inits = ((CELL*)cell->next)->next;
+        }
+    else 
+        {
+        cell = (CELL *)inits->contents;
+        if(cell->type != CELL_SYMBOL)
+            return(errorProcExt(ERR_SYMBOL_EXPECTED, inits));
+        inits = inits->next;
+        }
+
+    if(type == LET_STD || type == LET_EXPAND)
+        {
+        if(localCount == 0) 
+            list = args = copyCell(evaluateExpression(cell->next));
+        else 
+            {
+            args->next = copyCell(evaluateExpression(cell->next));
+            args = args->next;
+            }
+        }
+    else /* LET_NEST */
+        {
+        symbol = (SYMBOL *)cell->contents;
+        if(isProtected(symbol->flags))
+                return(errorProcExt(ERR_SYMBOL_PROTECTED, cell));
+        args = copyCell(evaluateExpression(cell->next));
+        pushEnvironment((CELL *)symbol->contents);
+        pushEnvironment((UINT)symbol);
+        symbol->contents = (UINT)args;
+        }
+
+    localCount++;
+    }
+
+/* save symbols and get new bindings */
+if(type == LET_STD || type == LET_EXPAND) 
+    {
+    inits = (CELL*)params->contents;
+    while(inits != nilCell)
+        {
+        if(inits->type == CELL_EXPRESSION)
+            {
+            cell = (CELL *)inits->contents;
+            inits = inits->next;
+            }
+        else
+            {
+            cell = inits;
+            inits = ((CELL*)cell->next)->next;
+            }   
+
+        symbol = (SYMBOL *)cell->contents;
+
+        if(isProtected(symbol->flags))
+            return(errorProcExt(ERR_SYMBOL_PROTECTED, cell));
+
+        pushEnvironment((CELL *)symbol->contents);
+        pushEnvironment((UINT)symbol);
+        symbol->contents = (UINT)list;
+
+        args = list;
+        list = list->next;
+        args->next = nilCell; /* decouple */
+
+        /* hook in LET_EXPAND mode here */
+        if(type == LET_EXPAND)
+            {
+            body = blockExpand(body, symbol);
+            pushResult(body);
+            }
+
+        }
+    }
+
+EVAL_LET_BODY:
+/* evaluate body expressions */
+while(body != nilCell)
+    {
+    if(result != nilCell) deleteList(result);
+    result = copyCell(evaluateExpression(body));
+    body = body->next;
+    }
+
+/* restore environment */
+while(localCount--)
+    {
+    symbol = (SYMBOL *)popEnvironment();
+    deleteList((CELL *)symbol->contents);
+    symbol->contents = popEnvironment();
+    }
+
+return(result);
+}
+
+CELL * p_first(CELL * params)
+{
+char str[2];
+CELL * cell;
+CELL * result;
+#ifdef SUPPORT_UTF8
+size_t len;
+#endif
+
+getEvalDefault(params, &cell);
+
+if(cell->type == CELL_STRING)
+    {
+    stringCell = cell;
+    if((str[0] = *(char *)cell->contents) == 0)
+        return(stuffString(""));
+    
+#ifndef SUPPORT_UTF8
+    str[1] = 0;
+    result = stuffString(str);
+#else
+    len =  utf8_1st_len((char*)cell->contents);
+    if(len > cell->aux -1)
+        return(errorProc(ERR_INVALID_UTF8));
+    result = stuffStringN((char*)cell->contents, len);
+#endif
+
+    stringIndexPtr = (char *)cell->contents;
+    if(symbolCheck)
+        {
+        pushResult(result);
+        pushResultFlag = FALSE;
+        }
+    return(result);
+    }
+
+else if(isList(cell->type))
+    {
+    if(cell->contents == (UINT)nilCell)
+        return(errorProcExt(ERR_LIST_EMPTY, params));
+
+    pushResultFlag = FALSE;
+    return((CELL *)cell->contents);
+    }
+
+else if(cell->type == CELL_ARRAY)
+    {
+    pushResultFlag = FALSE;
+    return(*(CELL * *)cell->contents);
+    }
+
+return(errorProcExt(ERR_ARRAY_LIST_OR_STRING_EXPECTED, params));
+}
+
+
+CELL * p_rest(CELL * params)
+{
+CELL * cell;
+CELL * tail;
+#ifdef SUPPORT_UTF8
+size_t size;
+#endif
+
+/* cell = evaluateExpression(params); */
+getEvalDefault(params, &cell);
+
+if(isList(cell->type))
+    {
+    tail = makeCell(CELL_EXPRESSION, (UINT)copyList(((CELL*)cell->contents)->next));
+    return(tail);
+    }
+else if(cell->type == CELL_ARRAY)
+    return(subarray(cell, 1, MAX_LONG));
+
+else if(cell->type == CELL_STRING)
+    {
+    if(*(char *)cell->contents == 0)
+        return(stuffString(""));
+#ifndef SUPPORT_UTF8
+    return(stuffString((char *)(cell->contents + 1)));
+#else
+    size = utf8_1st_len((char *)cell->contents);
+    if(size > cell->aux - 1)
+        return(errorProc(ERR_INVALID_UTF8));
+    return(stuffString((char *)(cell->contents + size)));
+#endif
+    }
+
+return(errorProcExt(ERR_ARRAY_LIST_OR_STRING_EXPECTED, params));
+}
+
+CELL * implicitNrestSlice(CELL * num, CELL * params)
+{
+CELL * list;
+ssize_t  n, len;
+
+getIntegerExt(num, (UINT *)&n, FALSE);
+list = evaluateExpression(params);
+
+if(list->type == CELL_CONTEXT)
+    list = (CELL *)(translateCreateSymbol(
+        ((SYMBOL*)list->contents)->name,
+        CELL_NIL,
+        (SYMBOL*)list->contents,
+        TRUE))->contents;
+
+/* slice  */
+if(isNumber(list->type))
+    {
+    getIntegerExt(list, (UINT*)&len, FALSE);
+    list = evaluateExpression(params->next);
+
+    if(list->type == CELL_CONTEXT)
+    list = (CELL *)(translateCreateSymbol(
+        ((SYMBOL*)list->contents)->name,
+        CELL_NIL,
+        (SYMBOL*)list->contents,
+        TRUE))->contents;
+
+    if(isList(list->type))    
+        return(sublist((CELL *)list->contents, n, len));
+    else if(list->type == CELL_STRING)
+        return(substring((char *)list->contents, list->aux-1, n, len));
+    else if(list->type == CELL_ARRAY)
+        return(subarray(list, n, len));
+    }
+    
+/* nrest lists */
+else if(isList(list->type))
+    {
+    list = (CELL *)list->contents;
+
+    if(n < 0) n = convertNegativeOffset(n, list);
+    
+    while(n-- && list != nilCell)
+        list = list->next;
+  
+    return(makeCell(CELL_EXPRESSION, (UINT)copyList(list)));
+    }
+
+/* nrest strings 
+   this was UTF-8 sensitive before 9.1.11, but only the
+   explicit first/last/rest should be UTF8-sensitive
+*/
+else if(list->type == CELL_STRING) 
+    return(substring((char *)list->contents, list->aux - 1, n, MAX_LONG));
+
+else if(list->type == CELL_ARRAY)
+    return(subarray(list, n, MAX_LONG));
+
+return(errorProcExt(ERR_ILLEGAL_TYPE, params));
+}
+
+
+CELL * p_cons(CELL * params)
+{
+CELL * cons;
+CELL * head;
+CELL * tail;
+
+if(params == nilCell)
+    return(getCell(CELL_EXPRESSION));
+
+head = copyCell(evaluateExpression(params));
+cons = makeCell(CELL_EXPRESSION, (UINT)head);
+params = params->next;
+
+if(params != nilCell)
+    {
+    tail = evaluateExpression(params);
+    
+    if(isList(tail->type))
+        {
+        head->next = copyList((CELL *)tail->contents);
+        cons->type = tail->type;    
+        }
+    else
+        head->next = copyCell(tail);
+    }
+
+return(cons);
+}
+
+
+CELL * p_list(CELL * params)
+{
+CELL * list;
+CELL * lastCopy = NULL;
+CELL * copy;
+CELL * cell;
+UINT * resultIdxSave;
+
+list = getCell(CELL_EXPRESSION);
+
+resultIdxSave = resultStackIdx;
+while(params != nilCell)
+    {
+    cell = evaluateExpression(params);
+    if(cell->type == CELL_ARRAY)
+        copy = arrayList(cell, TRUE);
+    else
+        copy = copyCell(cell);
+    if(lastCopy == NULL)
+        list->contents = (UINT)copy;
+    else lastCopy->next = copy;
+    lastCopy = copy;
+    cleanupResults(resultIdxSave);
+    params = params->next;
+    }
+
+return(list);
+}
+
+
+CELL * p_last(CELL * params)
+{
+CELL * cell;
+CELL * listPtr;
+CELL * result;
+char * str;
+
+getEvalDefault(params, &cell);
+
+if(cell->type == CELL_STRING)
+    {
+    stringCell = cell;
+    str = (char *)cell->contents;
+    if(*str == 0) return(copyCell(cell));
+#ifndef SUPPORT_UTF8
+    str += (cell->aux - 2);
+    result = stuffString(str);
+#else
+    str = utf8_index(str, utf8_wlen(str, str + cell->aux) -1);
+    result = stuffString(str);
+#endif
+    stringIndexPtr = (char *)str;
+    if(symbolCheck)
+        {
+        pushResult(result);
+        pushResultFlag = FALSE;
+        }
+    return(result);
+    }
+
+else if(isList(cell->type))
+    {
+    if(cell->contents == (UINT)nilCell)
+        return(errorProcExt(ERR_LIST_EMPTY, params));
+
+    if(cell->aux != (UINT)nilCell) 
+        {
+        pushResultFlag = FALSE;
+        return((CELL *)cell->aux);
+        }
+        
+    listPtr = (CELL *)cell->contents;
+    while(listPtr->next != nilCell) listPtr = listPtr->next;
+    cell->aux = (UINT)listPtr;
+    pushResultFlag = FALSE;
+    return(listPtr);
+    }
+
+else if(cell->type == CELL_ARRAY)
+    {
+    pushResultFlag = FALSE;
+    return(*((CELL * *)cell->contents + (cell->aux - 1) / sizeof(UINT) - 1));
+    }
+
+return(errorProcExt(ERR_ARRAY_LIST_OR_STRING_EXPECTED, params));
+}
+
+
+/* -------------------------- program flow  and logical ------------------ */
+
+CELL * evaluateBlock(CELL * cell)
+{
+CELL * result;
+
+result = nilCell;
+
+while(cell != nilCell)
+    {
+    result = evaluateExpression(cell);
+    cell = cell->next;
+    }
+return(result);
+}
+
+
+CELL * p_if(CELL * params)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+itSymbol->contents = (UINT)cell;
+while(isNil(cell) || isEmpty(cell))
+    {
+    params = params->next;
+    if(params->next == nilCell) 
+        goto IF_RETURN;
+    params = params->next;
+    cell = evaluateExpression(params);
+    }
+
+if(params->next != nilCell) 
+    cell = evaluateExpression(params->next);
+   
+IF_RETURN: 
+itSymbol->contents = (UINT)nilCell;
+pushResultFlag = FALSE;
+return(cell);
+}
+
+
+CELL * p_ifNot(CELL * params)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+if(!isNil(cell) && !isEmpty(cell))
+    params = params->next;
+
+cell = evaluateExpression(params->next);
+
+pushResultFlag = FALSE;
+return(cell);
+}
+
+
+CELL * p_when(CELL * params)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+if(isNil(cell) || isEmpty(cell)) goto WHEN_END;
+
+while((params = params->next) != nilCell)
+    cell = evaluateExpression(params);
+
+WHEN_END:
+pushResultFlag = FALSE;
+return(cell);
+}
+
+CELL * p_unless(CELL * params)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+if(!isNil(cell) && !isEmpty(cell)) goto UNLESS_END;
+
+while((params = params->next) != nilCell)
+    cell = evaluateExpression(params);
+
+UNLESS_END:
+pushResultFlag = FALSE;
+return(cell);
+}
+
+
+CELL * p_condition(CELL * params)
+{
+CELL * condition;
+CELL * eval = nilCell;
+
+while(params != nilCell)
+    {
+    if(params->type == CELL_EXPRESSION)
+        {
+        condition = (CELL *)params->contents;
+        eval = evaluateExpression(condition);
+        if(!isNil(eval) && !isEmpty(eval))
+            {
+            if(condition->next != nilCell)
+                eval = evaluateBlock(condition->next);
+            break;
+            }
+        params = params->next;
+        }
+    else return(errorProc(ERR_LIST_EXPECTED));
+    }
+
+pushResultFlag = FALSE;
+return(eval);
+}
+
+
+CELL * p_case(CELL * params)
+{
+CELL * cases;
+CELL * cond;
+CELL * eval;
+
+cases = params->next;
+params = evaluateExpression(params);
+while(cases != nilCell)
+  {
+  if(cases->type == CELL_EXPRESSION)
+    {
+    cond = (CELL *)cases->contents;
+    if(compareCells(params, cond) == 0
+      || (cond->type == CELL_SYMBOL && symbolType((SYMBOL *)cond->contents) == CELL_TRUE)
+          || cond->type == CELL_TRUE)
+        {
+        eval = evaluateBlock(cond->next);
+        pushResultFlag = FALSE;
+        return(eval);
+        }
+    }
+    cases = cases->next;
+  }
+
+return(nilCell);
+}
+
+#define REPEAT_WHILE 0
+#define REPEAT_DOWHILE 1
+#define REPEAT_UNTIL 2
+#define REPEAT_DOUNTIL 3
+
+CELL * p_while(CELL * params) { return(repeat(params, REPEAT_WHILE)); }
+CELL * p_doWhile(CELL * params) { return(repeat(params, REPEAT_DOWHILE)); }
+CELL * p_until(CELL * params) { return(repeat(params, REPEAT_UNTIL)); }
+CELL * p_doUntil(CELL * params) { return(repeat(params, REPEAT_DOUNTIL)); }
+
+
+CELL * repeat(CELL * params, int type)
+{
+CELL * result;
+CELL * cell;
+CELL * cellIdx;
+UINT * resultIdxSave;
+SYMBOL * symbolRef = NULL;
+
+cellIdx = initIteratorIndex();
+
+resultIdxSave = resultStackIdx;
+result = nilCell;
+while(TRUE)
+    {
+    switch(type)
+        {
+        case REPEAT_WHILE:
+            cell = evaluateExpression(params);
+            if(isNil(cell) || isEmpty(cell)) goto END_REPEAT;
+            cleanupResults(resultIdxSave);
+            result = evaluateBlock(params->next);
+            symbolRef = symbolCheck;
+            break;
+        case REPEAT_DOWHILE:
+            result = evaluateBlock(params->next);
+            symbolRef = symbolCheck;
+            cell = evaluateExpression(params);
+            if(isNil(cell) || isEmpty(cell)) goto END_REPEAT;
+            cleanupResults(resultIdxSave);
+            break;
+        case REPEAT_UNTIL:
+            cell = evaluateExpression(params);
+            if(!isNil(cell) && !isEmpty(cell)) 
+                {
+                if(params->next == nilCell)
+                    result = cell;
+                goto END_REPEAT;
+                }
+            cleanupResults(resultIdxSave);
+            result = evaluateBlock(params->next);
+            symbolRef = symbolCheck;
+            break;
+        case REPEAT_DOUNTIL:
+            result = evaluateBlock(params->next);
+            symbolRef = symbolCheck;
+            cell = evaluateExpression(params);
+            if(!isNil(cell) && !isEmpty(cell))
+                {
+                if(params->next == nilCell)
+                    result = cell;
+                goto END_REPEAT;
+                }
+            cleanupResults(resultIdxSave);
+            break;
+        default:
+            break;
+        }
+
+    if(cellIdx->type == CELL_LONG) cellIdx->contents += 1;
+    }
+
+END_REPEAT:
+recoverIteratorIndex(cellIdx);
+
+symbolCheck = symbolRef;
+pushResultFlag = FALSE;
+return(result);
+}
+
+
+CELL * getPushSymbolParam(CELL * params, SYMBOL * * sym)
+{
+SYMBOL * symbol;
+CELL * cell;
+
+if(params->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_LIST_EXPECTED, params));
+
+cell = (CELL *)params->contents;
+if(cell->type != CELL_SYMBOL)
+    return(errorProcExt(ERR_SYMBOL_EXPECTED, cell));
+
+*sym = symbol = (SYMBOL *)cell->contents;
+if(isProtected(symbol->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+
+pushEnvironment((CELL *)symbol->contents);
+pushEnvironment((UINT)symbol);
+symbol->contents = (UINT)nilCell;
+
+return(cell->next);
+}
+
+
+CELL * initIteratorIndex(void)
+{
+CELL * cell = stuffInteger(0);
+
+pushEnvironment(listIdxSymbol->contents);
+pushEnvironment(listIdxSymbol);
+listIdxSymbol->contents = (UINT)cell;
+
+return(cell);
+}
+
+void recoverIteratorIndex(CELL * cellIdx)
+{
+deleteList(cellIdx);
+listIdxSymbol = (SYMBOL*)popEnvironment();
+listIdxSymbol->contents = (UINT)popEnvironment();
+}
+
+CELL * loop(CELL * params, int forFlag)
+{
+CELL * cell;
+CELL * cond = nilCell;
+CELL * block;
+SYMBOL * symbol = NULL;
+double fromFlt, toFlt, interval, step, cntFlt;
+INT64 stepCnt, i;
+INT64 fromInt64 = 0, toInt64 = 0;
+int intFlag;
+UINT * resultIdxSave;
+
+cell = getPushSymbolParam(params, &symbol);
+
+/* integer loops for dotimes and (for (i from to) ...) */
+if((intFlag = ((CELL *)cell->next)->next == nilCell))
+    {
+    if(forFlag)
+        {
+        cell = getInteger64Ext(cell, &fromInt64, TRUE);
+        getInteger64Ext(cell, &toInt64, TRUE);
+        stepCnt = (toInt64 > fromInt64) ? toInt64 - fromInt64 : fromInt64 - toInt64;
+        }
+    else /* dotimes */
+        {
+        fromInt64 = toInt64 = 0;
+        cond = getInteger64Ext(cell, &stepCnt, TRUE);
+        }
+    }
+else /* float (for (i from to step) ...) */
+    {
+    cell = getFloat(cell, &fromFlt);
+    cell = getFloat(cell, &toFlt);
+    cond = getFloat(cell, &step);
+    if(isnan(fromFlt) || isnan(toFlt) || isnan(step))
+        return(errorProc(ERR_INVALID_PARAMETER_NAN));
+    if(step < 0) step = -step;
+    if(fromFlt > toFlt) step = -step;
+    cntFlt = (fromFlt < toFlt) ? (toFlt - fromFlt)/step : (fromFlt - toFlt)/step;
+    stepCnt = (cntFlt > 0.0) ? floor(cntFlt + 0.0000000001) : floor(-cntFlt + 0.0000000001);
+    }
+    
+block = params->next;
+resultIdxSave = resultStackIdx;
+cell = nilCell;
+for(i = 0; i <= stepCnt; i++)
+    {
+    if(!forFlag && i == stepCnt) break;
+    deleteList((CELL *)symbol->contents);
+    if(intFlag) 
+        {
+        symbol->contents = 
+            (UINT)stuffInteger64((fromInt64 > toInt64) ? fromInt64 - i: 
+                                                         fromInt64 + i);
+        }
+    else
+        {
+        interval = fromFlt + i * step;
+        symbol->contents = (UINT)stuffFloat(interval);
+        }
+    /* cleanupResults(resultIdxSave);*/
+    while(resultStackIdx > resultIdxSave) deleteList(popResult());
+    if(cond != nilCell)  
+            {
+            cell = evaluateExpression(cond);
+            if(!isNil(cell)) break;
+            }
+    cell = evaluateBlock(block);
+    }
+
+
+if(symbolCheck && cell != (CELL *)symbol->contents && symbol != symbolCheck)
+    pushResultFlag = FALSE;
+else
+    cell = copyCell(cell);
+
+deleteList((CELL *)symbol->contents);
+symbol = (SYMBOL*)popEnvironment();
+symbol->flags &= ~SYMBOL_PROTECTED;
+symbol->contents = (UINT)popEnvironment();
+
+return(cell);
+}
+
+
+CELL * p_dotimes(CELL * params)
+{
+return(loop(params, 0));
+}
+
+CELL * p_for(CELL * params)
+{
+return(loop(params, 1));
+}
+
+
+#define DOLIST 0
+#define DOTREE 1
+#define DOARGS 2
+#define DOSTRING 3
+
+CELL * p_dolist(CELL * params)
+{
+return(dolist(params, DOLIST));
+}
+
+CELL * p_dotree(CELL * params)
+{
+return(dolist(params, DOTREE));
+}
+
+CELL * p_doargs(CELL * params)
+{
+return(dolist(params, DOARGS));
+}
+
+CELL * p_dostring(CELL * params)
+{
+return(dolist(params, DOSTRING));
+}
+
+CELL * dolist(CELL * params, int doType)
+{
+CELL * cell;
+CELL * list = nilCell;
+char * str;
+#ifdef SUPPORT_UTF8
+int chr;
+#endif
+CELL * cond = nilCell;
+SYMBOL * symbol = NULL;
+SYMBOL * sPtr;
+CELL * cellIdx;
+UINT * resultIdxSave;
+
+cell = getPushSymbolParam(params, &symbol);
+cellIdx = initIteratorIndex();
+
+switch(doType)
+    {
+    case DOLIST:
+        /* list = copyCell(evaluateExpression(cell)); */
+        getEvalDefault(cell, &list);
+        if(isList(list->type)) list = copyCell(list);
+        else if(list->type == CELL_ARRAY) list = arrayList(list, FALSE);
+        else return(errorProcExt(ERR_LIST_EXPECTED, cell));
+        cond = cell->next;
+        break;
+    case DOTREE:
+        getContext(cell, &sPtr);
+        list = getCell(CELL_EXPRESSION);
+        collectSymbols((SYMBOL *)((CELL *)sPtr->contents)->aux, list);
+        cond = (getFlag(cell->next) == 1) ? trueCell : nilCell;
+        break;  
+    case DOARGS:
+        list = copyCell((CELL *)argsSymbol->contents);
+        cond = cell;
+        break;
+    case DOSTRING:
+        getString(cell, &str);
+        resultIdxSave = resultStackIdx;
+        cond = cell->next;
+        while(*str)
+            {
+            cleanupResults(resultIdxSave);
+            deleteList((CELL *)symbol->contents);
+#ifdef SUPPORT_UTF8
+            str = utf8_wchar(str, &chr);
+            symbol->contents = (UINT)stuffInteger(chr);
+#else
+            symbol->contents = (UINT)stuffInteger((int)*str++);
+#endif
+            if(cond != nilCell)
+                {
+                cell = evaluateExpression(cond);
+                if(!isNil(cell)) break;
+                }
+            cell = evaluateBlock(params->next);
+            if(cellIdx->type == CELL_LONG) cellIdx->contents += 1;
+            }
+        goto FINISH_DO;
+        break;
+    }
+
+/* make sure worklist gets destroyed */
+pushResult(list); 
+list = (CELL *)list->contents;
+
+resultIdxSave = resultStackIdx;
+cell = nilCell;
+while(list!= nilCell)
+    {
+    cleanupResults(resultIdxSave);
+    deleteList((CELL *)symbol->contents);
+    symbol->contents = (UINT)copyCell(list);
+    if(cond != nilCell)
+        {
+        if(doType == DOTREE)
+            {
+            sPtr = (SYMBOL *)list->contents;
+            if(*sPtr->name != '_') 
+                {
+                cell = nilCell;
+                goto DO_CONTINUE;
+                }
+            }
+        else
+            {
+            cell = evaluateExpression(cond);
+            if(!isNil(cell)) break;
+            }
+        }
+    cell = evaluateBlock(params->next);
+    if(cellIdx->type == CELL_LONG) cellIdx->contents += 1;
+    DO_CONTINUE:    
+    list = list->next;
+    }
+
+FINISH_DO:
+if(symbolCheck && cell != (CELL *)symbol->contents && symbol != symbolCheck)
+    pushResultFlag = FALSE;
+else
+    cell = copyCell(cell);
+
+recoverIteratorIndex(cellIdx);
+
+deleteList((CELL *)symbol->contents);
+symbol = (SYMBOL*)popEnvironment();
+symbol->contents = (UINT)popEnvironment();
+
+return(cell);
+}
+
+
+CELL * p_evalBlock(CELL * params)
+{
+CELL * result = nilCell;
+
+while(params != nilCell)
+    {
+    result = evaluateExpression(params);
+    params = params->next;
+    }
+
+pushResultFlag = FALSE;
+return(result);
+}
+
+extern UINT getAddress(CELL * params);
+
+CELL * p_copy(CELL * params)
+{
+CELL * copy;
+
+/* experimental: copy a cell from address, from:
+   http://www.newlispfanclub.alh.net/forum/viewtopic.php?f=5&t=4548
+   June 14, 2014 "get-cell function patch"
+*/
+if(params->next != nilCell && getFlag(params->next))
+    return(copyCell((CELL *)getAddress(params)));
+
+copy = copyCell(evaluateExpression(params));
+symbolCheck = NULL;
+return(copy);
+}
+
+CELL * p_silent(CELL * params)
+{
+CELL * cell;
+evalSilent  = TRUE;
+
+cell = evaluateBlock(params);
+if(symbolCheck)
+    {
+    pushResultFlag = FALSE;
+    return(cell);
+    }
+    
+return(copyCell(cell));
+}
+
+
+CELL * p_and(CELL * params)
+{
+CELL * result = trueCell;
+
+while(params != nilCell)
+    {
+    result = evaluateExpression(params);
+    if(isNil(result) || isEmpty(result)) return(copyCell(result));
+    params = params->next;
+    }
+
+if(symbolCheck)
+    {
+    pushResultFlag = FALSE;
+    return(result);
+    }
+    
+return(copyCell(result));     
+}
+
+
+CELL * p_or(CELL * params)
+{
+CELL * result = nilCell;
+
+while(params != nilCell)
+    {
+    result = evaluateExpression(params);
+    if(!isNil(result) && !isEmpty(result)) 
+        {
+        if(symbolCheck)
+            {
+            pushResultFlag = FALSE;
+            return(result);
+            }
+        return(copyCell(result));
+        }
+    params = params->next;
+    }
+
+return(copyCell(result));
+}
+
+
+CELL * p_not(CELL * params)
+{
+CELL * eval;
+
+eval = evaluateExpression(params);
+if(isNil(eval) || isEmpty(eval)) 
+    return(trueCell);
+return(nilCell);
+}
+
+
+
+/* ------------------------------ I / O --------------------------------- */
+
+CELL * p_print(CELL * params)
+{
+return println(params, FALSE);
+}
+
+
+CELL * p_println(CELL * params)
+{
+return println(params, TRUE);
+}
+
+
+CELL * println(CELL * params, int lineFeed)
+{
+CELL * result;
+
+result = nilCell;
+while(params != nilCell)
+    {
+    result = evaluateExpression(params);
+    printCell(result, 0, OUT_DEVICE);
+    params = params->next;
+    }
+
+if(lineFeed) varPrintf(OUT_DEVICE, LINE_FEED);
+
+return(copyCell(result));
+}
+
+
+CELL * p_device(CELL * params)
+{
+if(params != nilCell)
+    getInteger(params, &printDevice);
+return(stuffInteger(printDevice));
+}
+
+
+CELL * p_load(CELL * params)
+{
+char * fileName;
+CELL * result = nilCell;
+CELL * next;
+SYMBOL * context;
+int count = 0;
+
+/* get last parameter */
+if((next = params) == nilCell)
+    errorProc(ERR_MISSING_ARGUMENT);
+while(next->next != nilCell)
+    {
+    count++;
+    next = next->next;
+    }
+
+next = evaluateExpression(next);
+if(next->type == CELL_STRING)
+    {
+    count++;
+    context = mainContext;
+    }
+else
+    {
+    if(count == 0)
+        errorProcExt(ERR_STRING_EXPECTED, next);
+    if((context = getCreateContext(next, FALSE)) == NULL)
+        errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, next);
+    next = NULL;
+    }
+
+while(count--)
+    {
+    /* if last arg was a string, avoid double evaluation */
+    if(count == 0 && next != NULL)
+        getStringSize(next, &fileName, NULL, FALSE);
+    else 
+        params = getString(params, &fileName);
+
+    result = loadFile(fileName, 0, 0, context);
+
+    if(result == NULL)
+        return(errorProcExt2(ERR_ACCESSING_FILE, stuffString(fileName)));
+    }
+
+return(result);
+}
+
+
+void saveContext(SYMBOL * sPtr, UINT device)
+{
+SYMBOL * contextSave;
+
+contextSave = currentContext;
+
+currentContext = sPtr;
+
+if(currentContext != mainContext)
+    {
+    varPrintf(device, "%s(context '%s)%s%s", 
+        LINE_FEED, sPtr->name, LINE_FEED, LINE_FEED);
+    /* make sure 'set' is not overwritten */
+    if((sPtr = lookupSymbol("set", currentContext)) != NULL)
+        {
+        deleteList((CELL *)sPtr->contents);
+        sPtr->contents = (UINT)copyCell(nilCell);
+        }
+    }
+            
+
+saveSymbols((SYMBOL *)((CELL*)currentContext->contents)->aux, device);
+
+if(currentContext != mainContext)
+    varPrintf(device, "%s(context MAIN)%s%s", 
+        LINE_FEED, LINE_FEED, LINE_FEED);
+
+currentContext = contextSave;
+}
+
+
+void saveSymbols(SYMBOL * sPtr, UINT device)
+{
+int type;
+
+if(sPtr != NIL_SYM && sPtr != NULL)
+    {
+    saveSymbols(sPtr->left, device);
+    type = symbolType(sPtr);
+    if(type == CELL_CONTEXT)
+        {
+        if(sPtr == (SYMBOL *)((CELL *)sPtr->contents)->contents)
+            {
+            if(sPtr != currentContext && *sPtr->name != '$') saveContext(sPtr, device);
+            }
+        else printSymbol(sPtr, device); 
+        }
+    /* don't save primitives, symbols containing nil and the trueSymbol */
+    else if(type != CELL_PRIMITIVE && type != CELL_NIL
+        && sPtr != trueSymbol && type != CELL_IMPORT_CDECL && type != CELL_IMPORT_FFI
+#if defined(WINDOWS) || defined(CYGWIN)
+        && type != CELL_IMPORT_DLL
+#endif
+        )
+        if(*sPtr->name != '$') printSymbol(sPtr, device);
+    saveSymbols(sPtr->right, device);
+    }
+}
+
+
+CELL * p_save(CELL * params)
+{
+char * fileName;
+STREAM strStream = {NULL, NULL, 0, 0, 0};
+SYMBOL * contextSave;
+#ifndef EMSCRIPTEN
+CELL * result;
+CELL * dataCell;
+#endif
+int errorFlag = 0;
+
+contextSave = currentContext;
+currentContext = mainContext;
+
+params = getString(params, &fileName);
+
+openStrStream(&strStream, MAX_STRING, 0);
+serializeSymbols(params, (UINT)&strStream);
+
+#ifndef EMSCRIPTEN
+/* check for URL format */
+if(my_strnicmp(fileName, "http://", 7) == 0)
+    {
+    dataCell = stuffString(strStream.buffer);
+    result = getPutPostDeleteUrl(fileName, dataCell, HTTP_PUT, CONNECT_TIMEOUT);
+    pushResult(result);
+    deleteList(dataCell);
+    errorFlag = (strncmp((char *)result->contents, "ERR:", 4) == 0);
+    }
+else
+#endif
+    errorFlag = writeFile(fileName, strStream.buffer, strStream.position, "w");
+
+closeStrStream(&strStream);
+
+currentContext = contextSave;
+
+if(errorFlag)
+    return(errorProcExt2(ERR_SAVING_FILE, stuffString(fileName)));
+
+return(trueCell);
+}
+
+void serializeSymbols(CELL * params, UINT device)
+{
+SYMBOL * sPtr;
+
+if(params->type == CELL_NIL)
+    saveSymbols((SYMBOL *)((CELL*)currentContext->contents)->aux, device);
+else
+    while(params != nilCell)
+    {
+    params = getSymbol(params, &sPtr);
+    if(symbolType(sPtr) == CELL_CONTEXT)
+        saveContext((SYMBOL*)((CELL *)sPtr->contents)->contents, device);
+    else        
+        printSymbol(sPtr, device);
+    }
+}
+
+/* ----------------------- copy a context with 'new' -------------- */
+static SYMBOL * fromContext;
+static SYMBOL * toContext;
+static int overWriteFlag;
+
+CELL * copyContextList(CELL * cell);
+UINT * copyContextArray(CELL * array);
+
+
+CELL * copyContextCell(CELL * cell)
+{
+CELL * newCell;
+SYMBOL * sPtr;
+SYMBOL * newSptr;
+
+if(firstFreeCell == NULL) allocBlock();
+newCell = firstFreeCell;
+firstFreeCell = newCell->next;
+++cellCount;
+
+newCell->type = cell->type;
+newCell->next = nilCell;
+newCell->aux = cell->aux;
+newCell->contents = cell->contents;
+
+if(cell->type == CELL_DYN_SYMBOL)
+    {
+    sPtr = (SYMBOL*)cell->aux;
+    if(sPtr->context == fromContext)
+        newCell->aux =
+            (UINT)translateCreateSymbol(sPtr->name, 0, toContext, TRUE);
+    newCell->contents = (UINT)allocMemory(strlen((char *)cell->contents) + 1);
+    memcpy((void *)newCell->contents,
+        (void*)cell->contents, strlen((char *)cell->contents) + 1);
+    }
+
+if(cell->type == CELL_SYMBOL)
+    {
+    /* if the cell copied, itself contains a symbol copy it recursevely,
+       if new, if not done here it might not been seen as new later and left
+       without contents */
+    sPtr = (SYMBOL *)cell->contents;
+    /* don't copy symbols of builtins and libffi */
+    if(sPtr->context == fromContext && !(sPtr->flags & (SYMBOL_BUILTIN | SYMBOL_FFI)))
+        {
+        if((newSptr = lookupSymbol(sPtr->name, toContext)) == NULL)
+            {
+            newSptr = translateCreateSymbol(sPtr->name, symbolType(sPtr), toContext, TRUE);
+            deleteList((CELL *)newSptr->contents);
+            newSptr->contents = (UINT)copyContextCell((CELL*)sPtr->contents);
+            }
+        newCell->contents = (UINT)newSptr;
+        newSptr->flags = sPtr->flags;
+        }
+    }
+
+if(isEnvelope(cell->type))
+    {
+    if(cell->type == CELL_ARRAY)
+        newCell->contents = (UINT)copyContextArray(cell);
+    else
+        {
+        /* undo push last optimization */
+        newCell->aux = (UINT)nilCell;
+        newCell->contents = (UINT)copyContextList((CELL *)cell->contents);
+        }
+    }
+else if(cell->type == CELL_STRING)
+    {
+    newCell->contents = (UINT)allocMemory((UINT)cell->aux);
+    memcpy((void *)newCell->contents, (void*)cell->contents, (UINT)cell->aux);
+    }
+
+return(newCell);
+}
+
+
+CELL * copyContextList(CELL * cell)
+{
+CELL * firstCell;
+CELL * newCell;
+
+if(cell == nilCell || cell == trueCell) return(cell);
+
+firstCell = newCell = copyContextCell(cell);
+
+while((cell = cell->next) != nilCell)
+    {
+    newCell->next = copyContextCell(cell);
+    newCell = newCell->next;
+    }
+    
+return(firstCell);
+}
+
+
+UINT * copyContextArray(CELL * array)
+{
+CELL * * newAddr;
+CELL * * orgAddr;
+CELL * * addr;
+size_t size;
+
+addr = newAddr = (CELL * *)callocMemory(array->aux);
+
+size = (array->aux - 1) / sizeof(UINT);
+orgAddr = (CELL * *)array->contents;
+
+while(size--)
+    *(newAddr++) = copyContextCell(*(orgAddr++));
+    
+return((UINT*)addr);
+}
+
+
+void iterateCopyCreateSymbols(SYMBOL * sPtr)
+{
+int type, newFlag = FALSE;
+SYMBOL * newPtr = NULL;
+
+if(sPtr != NIL_SYM && sPtr != NULL && !(sPtr->flags & SYMBOL_BUILTIN))
+    {
+    iterateCopyCreateSymbols(sPtr->left);
+    type = symbolType(sPtr);
+
+    /* optimized check for default symbol, translate default symbol to default symbol */
+    if(*sPtr->name == *fromContext->name && strcmp(sPtr->name, fromContext->name) == 0)
+        {
+        if((newPtr = lookupSymbol(toContext->name, toContext)) == NULL)
+            {
+            newPtr = translateCreateSymbol(toContext->name, type, toContext, TRUE);
+            newFlag = TRUE;
+            }
+        }
+    else
+        {
+        if((newPtr = lookupSymbol(sPtr->name, toContext)) == NULL)
+            {
+            newPtr = translateCreateSymbol(sPtr->name, type, toContext, TRUE);
+            newFlag = TRUE;
+            }
+        }
+
+    if(overWriteFlag == TRUE || newFlag == TRUE)
+        {
+        deleteList((CELL *)newPtr->contents);
+        newPtr->contents = (UINT)copyContextCell((CELL*)sPtr->contents);
+        }
+
+    newPtr->flags |= sPtr->flags & SYMBOL_PROTECTED;
+    iterateCopyCreateSymbols(sPtr->right);
+    }
+}
+
+
+
+CELL * p_new(CELL * params)
+{
+CELL * next;
+
+overWriteFlag = FALSE;
+
+params = getContext(params, &fromContext);
+if(!fromContext) return(nilCell); /* for debug mode */
+
+next = params->next;
+
+if(params == nilCell)
+    toContext = currentContext;
+else 
+    {
+    params = evaluateExpression(params);
+    if(params->type == CELL_CONTEXT || params->type == CELL_SYMBOL)
+        toContext = (SYMBOL *)params->contents;
+    else
+        return(errorProcExt(ERR_CONTEXT_EXPECTED, params));
+
+        overWriteFlag = (evaluateExpression(next)->type != CELL_NIL);
+
+    /* allow symbols to be converted to contexts */
+    if(symbolType(toContext) != CELL_CONTEXT)
+        {
+        if(isProtected(toContext->flags))
+            return(errorProcExt(ERR_SYMBOL_PROTECTED, params));
+
+        if(toContext->context != mainContext)
+            return(errorProcExt2(ERR_NOT_IN_MAIN, stuffSymbol(toContext)));
+
+        deleteList((CELL *)toContext->contents);
+        makeContextFromSymbol(toContext, NULL);
+        }
+    }
+
+if(toContext == mainContext)
+    return(errorProc(ERR_TARGET_NO_MAIN));
+
+iterateCopyCreateSymbols((SYMBOL *)((CELL*)fromContext->contents)->aux);
+
+return(copyCell((CELL*)toContext->contents));
+}
+
+
+CELL * p_defineNew(CELL * params)
+{
+SYMBOL * sourcePtr;
+SYMBOL * targetPtr;
+char * name;
+
+params = getSymbol(params, &sourcePtr);
+if(params != nilCell)
+    {
+    getSymbol(params, &targetPtr);
+    name = targetPtr->name;
+    toContext = targetPtr->context;
+    }
+else
+    {
+    name = sourcePtr->name;
+    toContext = currentContext;
+    }
+
+if(toContext == mainContext)
+    return(errorProc(ERR_TARGET_NO_MAIN));
+
+fromContext = sourcePtr->context;
+targetPtr = translateCreateSymbol(name, symbolType(sourcePtr), toContext, TRUE);
+
+deleteList((CELL *)targetPtr->contents);
+targetPtr->contents = (UINT)copyContextCell((CELL*)sourcePtr->contents);
+
+targetPtr->flags = sourcePtr->flags;
+
+return(stuffSymbol(targetPtr));
+}
+    
+
+
+/* ------------------------------ system ------------------------------ */
+
+CELL * isType(CELL *, int);
+
+CELL * p_isNil(CELL * params)
+{
+params = evaluateExpression(params);
+
+if(isNil(params))
+        return(trueCell);
+
+return(nilCell);
+}
+
+CELL * p_isEmpty(CELL * params)
+{
+CELL * cell;
+
+getEvalDefault(params, &cell);
+return(isEmptyFunc(cell));
+}
+
+CELL * isEmptyFunc(CELL * cell)
+{
+if(cell->type == CELL_STRING)
+    {
+    if(*(char*)cell->contents == 0)
+        return(trueCell);
+    else return(nilCell);
+    }
+
+if(!isList(cell->type))
+        return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, cell));
+if(cell->contents == (UINT)nilCell)
+    return(trueCell);
+return(nilCell);
+}
+
+CELL * isZero(CELL * cell)
+{
+#ifdef BIGINT
+int * numPtr;
+#endif
+
+switch(cell->type)
+    {
+#ifndef NEWLISP64
+    case CELL_INT64:
+        if(*(INT64 *)&cell->aux == 0)
+            return(trueCell);
+        break;
+#endif
+    case CELL_FLOAT:
+#ifndef NEWLISP64
+        if(*(double *)&cell->aux == 0.0)
+#else
+        if(*(double *)&cell->contents == 0.0)
+#endif
+            return(trueCell);
+        break;
+    case CELL_LONG:
+        if(cell->contents == 0)
+            return(trueCell);
+        break;
+#ifdef BIGINT
+    case CELL_BIGINT:
+        numPtr = (int *)(UINT)cell->contents;
+        if(cell->aux == 2 && numPtr[1] == 0)
+            return(trueCell);
+        break;
+#endif
+    default:
+        break;
+    }
+
+return(nilCell);
+}
+
+
+CELL * p_isNull(CELL * params)
+{
+CELL * cell;
+
+cell = evaluateExpression(params);
+if(isNil(cell))
+    return(trueCell);
+
+if( (cell->type == CELL_STRING || isList(cell->type)))
+    return(isEmptyFunc(cell));
+
+#ifndef NEWLISP64
+if(cell->type == CELL_FLOAT && (isnan(*(double *)&cell->aux)) )
+#else
+if(cell->type == CELL_FLOAT && (isnan(*(double *)&cell->contents)))
+#endif
+    return(trueCell);
+
+return(isZero(cell));
+}
+
+CELL * p_isZero(CELL * params)
+{
+return(isZero(evaluateExpression(params)));
+}
+
+
+CELL * p_isTrue(CELL * params)
+{
+params = evaluateExpression(params);
+if(!isNil(params) && !isEmpty(params))
+        return(trueCell);
+
+return(nilCell);
+}
+
+CELL * p_isInteger(CELL * params)
+{
+params = evaluateExpression(params);
+if((params->type & COMPARE_TYPE_MASK) == CELL_INT)
+    return(trueCell);
+return(nilCell);
+}
+
+#ifdef BIGINT
+CELL * p_isBigInteger(CELL * params)
+    { return(isType(params, CELL_BIGINT)); }
+#endif
+
+CELL * p_isFloat(CELL * params)
+    { return(isType(params, CELL_FLOAT)); }
+    
+CELL * p_isNumber(CELL * params)
+{
+params = evaluateExpression(params);
+if(isNumber(params->type)) return(trueCell);
+return(nilCell);
+}
+
+CELL * p_isString(CELL * params)
+    { return(isType(params, CELL_STRING)); }
+
+CELL * p_isSymbol(CELL * params)
+        { return(isType(params, CELL_SYMBOL)); }
+
+CELL * p_isContext(CELL * params)
+{
+char * symStr;
+SYMBOL * ctx;
+
+/* check type */
+if(params->next == nilCell) 
+    return(isType(params, CELL_CONTEXT)); 
+
+/* check for existense of symbol */
+params = getContext(params, &ctx);
+if(!ctx) return(nilCell); /* for debug mode */
+getString(params, &symStr);
+
+return (lookupSymbol(symStr, ctx) ? trueCell : nilCell);    
+}
+
+CELL * p_isPrimitive(CELL * params)
+    { return(isType(params, CELL_PRIMITIVE)); }
+
+
+CELL * p_isGlobal(CELL * params)
+{
+params = evaluateExpression(params);
+if(isSymbol(params->type) && isGlobal(((SYMBOL *)params->contents)->flags))
+    return(trueCell);
+return(nilCell);
+}
+
+CELL * p_isProtected(CELL * params)
+{
+params = evaluateExpression(params);
+if(isSymbol(params->type) && isProtected(((SYMBOL *)params->contents)->flags))
+    return(trueCell);
+return(nilCell);
+}
+    
+CELL * p_isAtom(CELL * params)
+{
+if(params == nilCell)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+params = evaluateExpression(params);
+if(params->type & ENVELOPE_TYPE_MASK) return(nilCell);
+return(trueCell);
+}
+
+CELL * p_isQuote(CELL *params)
+    { return(isType(params, CELL_QUOTE)); }
+
+CELL * p_isList(CELL * params)
+    { return(isType(params, CELL_EXPRESSION)); }
+
+CELL * p_isLambda(CELL * params)
+    { return(isType(params, CELL_LAMBDA)); }
+
+CELL * p_isMacro(CELL * params)
+{ 
+SYMBOL * sPtr;
+
+if(params == nilCell)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+params = evaluateExpression(params);
+if(params->type == CELL_FEXPR) /* lambda-macro */
+    return(trueCell);
+if(params->type == CELL_SYMBOL)
+    {
+    sPtr = (SYMBOL *)params->contents;
+    if(sPtr->flags & SYMBOL_MACRO)
+        return(trueCell);
+    }
+return(nilCell);
+}
+
+CELL * p_isArray(CELL * params)
+    { return(isType(params, CELL_ARRAY)); }
+
+CELL * isType(CELL * params, int operand)
+{
+CELL * contextCell;
+
+if(params == nilCell)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+params = evaluateExpression(params);
+if((UINT)operand == params->type) return(trueCell);
+switch(operand)
+    {
+    case CELL_PRIMITIVE:
+        if(params->type == CELL_IMPORT_CDECL
+        || params->type == CELL_IMPORT_FFI
+#if defined(WINDOWS) || defined(CYGWIN)
+        || params->type == CELL_IMPORT_DLL 
+#endif
+        )
+            return(trueCell);
+        break;
+    case CELL_EXPRESSION:
+        if(isList(params->type)) return(trueCell);
+                break;
+    case CELL_SYMBOL:
+        if(params->type == CELL_DYN_SYMBOL) /* check if already created */
+            {
+            contextCell = (CELL *)((SYMBOL *)params->aux)->contents;
+            if(contextCell->type != CELL_CONTEXT)
+                fatalError(ERR_CONTEXT_EXPECTED, 
+                    stuffSymbol((SYMBOL*)params->aux), TRUE);
+            if(lookupSymbol((char *)params->contents, (SYMBOL*)contextCell->contents))
+                return(trueCell);
+            }
+            
+        break;
+    default:
+        break;
+    }
+
+return(nilCell);
+}
+
+
+CELL * p_isLegal(CELL * params)
+{
+char * symStr;
+
+getString(params, &symStr);
+
+if(isLegalSymbol(symStr)) return(trueCell);
+
+return(nilCell);
+}
+
+
+int isLegalSymbol(char * source)
+{
+STREAM stream;
+char token[MAX_SYMBOL + 1];
+int tklen;
+
+if(*source == (char)'"' || *source == (char)'{' 
+   || (unsigned char)*source <= (unsigned char)' ' || *source == (char)';' || *source == (char)'#')
+        return(0);
+
+makeStreamFromString(&stream, source);
+
+return(getToken(&stream, token, &tklen) == TKN_SYMBOL && tklen == stream.size - 4 * MAX_STRING);
+}
+
+CELL * p_exit(CELL * params)
+{
+UINT result;
+
+#ifndef EMSCRIPTEN
+if(daemonMode) 
+    {
+    fclose(IOchannel);
+#ifndef WINDOWS
+    IOchannel = NULL;
+#endif
+    longjmp(errorJump, ERR_USER_RESET);
+    }
+#else
+return(nilCell);
+#endif
+
+if(params != nilCell) getInteger(params, &result);
+else result = 0;
+
+#ifdef HAVE_FORK
+/* release spawn resources */
+purgeSpawnList(TRUE);
+#endif
+
+exit(result);
+return(trueCell);
+}
+
+
+#ifdef EMSCRIPTEN
+void emscriptenReload(void)
+{
+char * cmd = "location.reload();";
+printf("# newLISP is reloading ...\n");
+evalStringJS(cmd, strlen(cmd));
+}
+#endif
+
+
+CELL * p_reset(CELL * params)
+{
+int blockCountBefore = blockCount;
+
+if(params != nilCell)
+    {
+    params = evaluateExpression(params);
+    if(isNumber(params->type))
+        {
+        getIntegerExt(params, (UINT*)&MAX_CELL_COUNT, FALSE);
+        if(MAX_CELL_COUNT < MAX_BLOCK) MAX_CELL_COUNT = MAX_BLOCK;
+        return(stuffInteger(MAX_CELL_COUNT));
+        }
+    else if(isNil(params)) 
+        {
+        freeCellBlocks(); 
+        return(stuffIntegerList(2, blockCountBefore, blockCount)); /* 10.3.3 */
+        }
+#ifndef LIBRARY
+#ifndef WINDOWS
+    else
+        execv(MainArgs[0], MainArgs);
+#endif
+#endif
+#ifdef EMSCRIPTEN
+        emscriptenReload();
+#endif
+    }
+else
+#ifndef EMSCRIPTEN
+    longjmp(errorJump, ERR_USER_RESET);
+#else
+    return(nilCell);
+#endif
+
+return(trueCell);
+}
+
+CELL * setEvent(CELL * params, SYMBOL * * eventSymPtr, char * sysSymName)
+{
+if(params != nilCell) getCreateSymbol(params, eventSymPtr, sysSymName);
+return(makeCell(CELL_SYMBOL, (UINT)*eventSymPtr));
+}
+
+CELL * p_errorEvent(CELL * params)
+{
+return(setEvent(params, &errorEvent, "$error-event"));
+}
+
+CELL * p_promptEvent(CELL * params)
+{
+return(setEvent(params, &promptEvent, "$prompt-event"));
+}
+
+CELL * p_commandEvent(CELL * params)
+{
+return(setEvent(params, &commandEvent, "$command-event"));
+}
+
+CELL * p_transferEvent(CELL * params)
+{
+return(setEvent(params, &transferEvent, "$transfer-event"));
+}
+
+CELL * p_readerEvent(CELL * params)
+{
+return(setEvent(params, &readerEvent, "$reader-event"));
+}
+
+
+#ifndef WINDOWS
+
+CELL * p_timerEvent(CELL * params)
+{
+double seconds;
+UINT timerOption = 0;
+struct itimerval timerVal;
+struct itimerval outVal;
+static double duration;
+
+if(params != nilCell) 
+  {
+  params = getCreateSymbol(params, &timerEvent, "$timer");
+
+  if(params != nilCell)
+    {
+    params = getFloat(params, &seconds);
+    duration = seconds;
+    if(params != nilCell)
+        getInteger(params, &timerOption);
+    memset(&timerVal, 0, sizeof(timerVal));
+    timerVal.it_value.tv_sec = seconds;
+    timerVal.it_value.tv_usec = (seconds - timerVal.it_value.tv_sec) * 1000000;
+    if(setitimer((int)timerOption, &timerVal, &outVal) == -1)
+      return(nilCell);
+    return(stuffInteger(0));
+    }
+  else
+    getitimer(timerOption, &outVal);
+
+  seconds = duration - (outVal.it_value.tv_sec + outVal.it_value.tv_usec / 1000000.0);
+  return(stuffFloat(seconds));
+  }
+  
+return(makeCell(CELL_SYMBOL, (UINT)timerEvent));
+}
+#endif
+
+#ifndef EMSCRIPTEN
+#define IGNORE_S 0
+#define DEFAULT_S 1
+#define RESET_S 2
+CELL * p_signal(CELL * params)
+{
+SYMBOL * signalEvent;
+UINT sig;
+char sigStr[12];
+char mode;
+
+params = getInteger(params, &sig);
+if(sig > 32 || sig < 1) return(nilCell);
+
+if(params->type == CELL_STRING)
+    {
+    mode = toupper(*(char *)params->contents);
+    symHandler[sig - 1] = nilSymbol;
+    if(mode == 'I') /* "ignore" */
+        return(signal(sig, SIG_IGN) == SIG_ERR ? nilCell: trueCell);
+    else if(mode == 'D') /* "default" */
+        return(signal(sig, SIG_DFL) == SIG_ERR ? nilCell: trueCell);
+    else if(mode == 'R') /* "reset" */
+        return(signal(sig, signal_handler) == SIG_ERR ? nilCell: trueCell);
+    }
+else if(params != nilCell)
+    {
+    snprintf(sigStr, 11, "$signal-%d", (int)sig);
+    getCreateSymbol(params, &signalEvent, sigStr);
+    symHandler[sig - 1] = signalEvent;
+    if(signal(sig, signal_handler) == SIG_ERR) return(nilCell);
+    }
+  
+return(makeCell(CELL_SYMBOL, (UINT)symHandler[sig - 1]));
+}
+#endif
+
+CELL * p_lastError(CELL * params)
+{
+CELL * result;
+char * sPtr;
+UINT errNum = errorReg;
+
+if(params != nilCell)
+    getInteger(params, &errNum);
+
+if(!errNum) return(nilCell);
+
+result = makeCell(CELL_EXPRESSION, (UINT)stuffInteger(errNum));
+if(params != nilCell)
+    sPtr = (errNum > MAX_ERROR_NUMBER) ? UNKNOWN_ERROR : errorMessage[errNum];
+else
+    sPtr = errorStream.buffer;
+
+((CELL *)result->contents)->next = stuffString(sPtr);
+
+return(result);
+}
+
+
+CELL * p_dump(CELL * params)
+{
+CELL * blockPtr;
+CELL * cell;
+UINT count = 0;
+int i;
+
+if(params != nilCell)
+    {
+    cell = evaluateExpression(params);
+    return(stuffIntegerList
+           (5, cell, cell->type, cell->next, cell->aux, cell->contents));
+    }
+
+blockPtr = cellMemory;
+while(blockPtr != NULL)
+    {
+    for(i = 0; i <  MAX_BLOCK; i++)
+        {
+        if(*(UINT *)blockPtr != CELL_FREE)
+            {
+            varPrintf(OUT_DEVICE, "address=%lX type=%d contents=", blockPtr, blockPtr->type);
+            printCell(blockPtr, TRUE, OUT_DEVICE);
+            varPrintf(OUT_DEVICE, LINE_FEED);
+            ++count;
+            }
+        ++blockPtr;
+        }
+    blockPtr = blockPtr->next;
+    }
+
+return(stuffInteger(count));
+}
+
+
+CELL * p_mainArgs(CELL * params)
+{
+CELL * cell;
+ssize_t idx;
+
+cell = (CELL*)mainArgsSymbol->contents;
+if(params != nilCell && cell->type == CELL_EXPRESSION)
+    {
+    getInteger(params, (UINT *)&idx);
+    cell = (CELL *)cell->contents;
+    if(idx < 0) idx = convertNegativeOffset(idx, (CELL *)cell);
+    while(idx--) cell = cell->next;
+    }
+
+return(copyCell(cell));
+}
+
+
+CELL * p_context(CELL * params)
+{
+CELL * cell;
+SYMBOL * sPtr;
+SYMBOL * cPtr;
+char * newSymStr;
+
+if(params->type == CELL_NIL)
+    return(copyCell((CELL *)currentContext->contents));
+
+if((cPtr = getCreateContext(params, TRUE)) == NULL)
+    return(errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, params));
+    
+if(params->next == nilCell)
+    {
+    currentContext = cPtr;
+    return(copyCell( (CELL *)currentContext->contents));
+    }
+    
+params = params->next;
+cell = evaluateExpression(params);
+if(cell->type == CELL_STRING)
+    newSymStr = (char *)cell->contents;
+else if(cell->type == CELL_SYMBOL)  
+    newSymStr = ((SYMBOL *)cell->contents)->name;
+else if(cell->type == CELL_DYN_SYMBOL)
+    {
+    sPtr = getDynamicSymbol(cell);
+    newSymStr = sPtr->name;
+    }
+else
+    return(errorProcExt(ERR_ILLEGAL_TYPE, cell));
+
+
+if(params->next == nilCell)
+    {
+    pushResultFlag = FALSE;
+    sPtr = lookupSymbol(newSymStr, cPtr);
+    if(sPtr == NULL)
+        return(nilCell);
+    else
+        return((CELL *)sPtr->contents);
+    }
+
+
+sPtr = translateCreateSymbol(newSymStr, CELL_NIL, cPtr, TRUE);
+
+return(setDefine(sPtr, params->next, SET_SET));
+}
+
+
+SYMBOL * getCreateContext(CELL * cell, int evaluate)
+{
+SYMBOL * contextSymbol;
+
+if(evaluate)
+    cell = evaluateExpression(cell);
+if(cell->type == CELL_SYMBOL || cell->type == CELL_CONTEXT)
+    contextSymbol = (SYMBOL *)cell->contents;
+else
+    return(NULL);
+
+
+if(symbolType(contextSymbol) != CELL_CONTEXT)
+    {
+    if(contextSymbol->context != mainContext)
+        {
+        contextSymbol= translateCreateSymbol(
+            contextSymbol->name, CELL_CONTEXT, mainContext, 1);
+        }
+
+    if(symbolType(contextSymbol) != CELL_CONTEXT)
+        {
+        if(isProtected(contextSymbol->flags))
+            errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(contextSymbol));
+
+        deleteList((CELL *)contextSymbol->contents);
+        makeContextFromSymbol(contextSymbol, NULL);
+        }
+    }
+
+/* if this is a context var retrieve the real context symbol */
+return((SYMBOL *)((CELL *)contextSymbol->contents)->contents);
+}
+
+
+CELL * p_default(CELL * params)
+{
+SYMBOL * contextSymbol;
+
+getContext(params, &contextSymbol);
+
+symbolCheck = translateCreateSymbol(contextSymbol->name, CELL_NIL, contextSymbol, TRUE);
+pushResultFlag = FALSE;
+return((CELL *)symbolCheck->contents);
+}
+
+
+/* FOOP fuctions */
+
+/* filled in colon, only used internally and by obj function */
+/* need stack for objSymbol.contents */
+/* what happens to stack when using catch/throw */
+
+CELL * p_colon(CELL * params)
+{
+SYMBOL * contextSymbol = NULL;
+SYMBOL * methodSymbol;
+SYMBOL * sPtr;
+CELL * proc;
+CELL * cell;
+CELL * obj;
+CELL * objSave;
+CELL * objCellSave;
+SYMBOL * objSymbolContextSave;
+int objSymbolFlagsSave;
+
+if(params->type != CELL_SYMBOL)
+    return(errorProcExt(ERR_SYMBOL_EXPECTED, params));
+
+methodSymbol = (SYMBOL *)params->contents;
+params = getEvalDefault(params->next, &obj);
+
+objSymbolFlagsSave = objSymbol.flags;
+objSymbolContextSave = objSymbol.context;
+if(symbolCheck) 
+    {
+    objSymbol.flags = symbolCheck->flags;
+    objSymbol.context = symbolCheck->context;
+    }   
+
+objSave = (CELL *)objSymbol.contents;
+objCellSave = objCell;
+objCell = obj;
+
+#ifdef FOOP_DEBUG
+printf("entering colon, saving in objSave:");
+printCell(objSave, TRUE, OUT_CONSOLE);
+puts("");
+#endif
+
+cell = (CELL *)obj->contents;
+if(obj->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_LIST_EXPECTED, obj));
+
+if(cell->type == CELL_SYMBOL || cell->type == CELL_CONTEXT)
+    contextSymbol = (SYMBOL *)cell->contents;
+if(contextSymbol == NULL || symbolType(contextSymbol) != CELL_CONTEXT)
+    return(errorProcExt(ERR_CONTEXT_EXPECTED, cell));
+
+sPtr = methodSymbol;
+if((methodSymbol = lookupSymbol(sPtr->name, contextSymbol)) == NULL)
+    return(errorProcExt2(ERR_INVALID_FUNCTION, stuffSymbol(sPtr)));
+
+cell = stuffSymbol(methodSymbol);
+proc = makeCell(CELL_EXPRESSION, (UINT)cell);
+
+while(params != nilCell)
+    {
+    cell->next = copyCell(params);
+    cell = cell->next;
+    params = params->next;
+    }
+
+pushResult(proc);
+
+#ifdef FOOP_DEBUG
+printf("colon calling %s in %s with objCell:", methodSymbol->name, contextSymbol->name);
+printCell(objCell, TRUE, OUT_CONSOLE);
+puts("");
+#endif
+
+cell = copyCell(evaluateExpression(proc));
+
+objSymbol.flags = objSymbolFlagsSave;
+objSymbol.context = objSymbolContextSave;
+
+objSymbol.contents = (UINT)objSave;
+objCell = objCellSave;
+
+#ifdef FOOP_DEBUG
+printf("leavin colon, objCell restored to:");
+printCell(obj, TRUE, OUT_CONSOLE);
+puts("");
+#endif
+
+
+return(cell);
+}
+
+CELL * p_self(CELL * params)
+{
+CELL * result;
+
+if(objSymbol.contents == (UINT)nilCell)
+    return(nilCell);
+
+if(params == nilCell)
+    {
+    symbolCheck = &objSymbol;
+    pushResultFlag = FALSE;
+    return((CELL *)objSymbol.contents);
+    }
+
+result = implicitIndexList((CELL*)objSymbol.contents, params);
+
+symbolCheck = &objSymbol;
+pushResultFlag = FALSE;
+
+return(result);
+}
+
+
+CELL * p_systemSymbol(CELL * params)
+{
+UINT idx;
+
+getInteger(params, &idx);
+
+if(idx > 15) return(nilCell);
+
+return(copyCell((CELL*)sysSymbol[idx]->contents));
+}
+
+
+/* end of file */
diff --git a/newlisp.h b/newlisp.h
new file mode 100644
index 0000000..fa307d0
--- /dev/null
+++ b/newlisp.h
@@ -0,0 +1,741 @@
+/* newlisp.h - header file for newLISP
+
+    Copyright (C) 2015 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef NEWLISP_H
+#define NEWLISP_H
+
+/* Take out bigger, less used code portions.  By default these capabilities 
+   are enabled on all shipped binaries. Out-comment definitions to suppress.
+   Other capabilities like READLINE, SUPPORT_UTF8 can be en/disabled in
+   makefiles.
+   Undefining DEBUGGER does not affected simple tracing with (trace <device-no>)
+*/
+
+#define XML_SUPPORT
+#define BIGINT
+#define KMEANS 
+#define DEBUGGER
+
+
+/* config.h is only needed when doing auto configuration with ./configure-alt */
+#ifdef NEWCONFIG
+#include "config.h"
+#else
+#define NEWLISPDIR "/usr/local/share/newlisp"
+#endif
+
+/* force ISO_C90 restrictions */
+#if defined(CYGWIN) || defined(OS2) || defined(SOLARIS) || defined(AIX) || defined(SUNOS)
+/* not sure how this plays with introducing C99 based inttypes.h header file in 10.6.3 */
+#define ISO_C90
+#endif
+
+#ifdef LINUX
+#define OSTYPE "Linux"
+#endif
+
+#ifdef ANDROID
+#define NO_SEMAPHORE 
+#endif
+
+#ifdef _BSD
+#define OSTYPE "BSD"
+#endif
+
+#ifdef MAC_OSX
+#ifdef EMSCRIPTEN
+#define OSTYPE "JS"
+#else
+#define OSTYPE "OSX"
+#endif
+#endif
+
+#ifdef SOLARIS
+#define OSTYPE "Solaris"
+#endif
+
+#ifdef SUNOS
+#define SOLARIS
+#define SPARC
+#define OSTYPE "SunOS"
+#endif
+
+#ifdef TRU64
+#define OSTYPE "Tru64Unix"
+#endif
+
+#ifdef AIX 
+#define OSTYPE "AIX" 
+#endif 
+
+
+#ifdef WINDOWS
+#define OSTYPE "Windows"
+#ifdef NEWLISP64
+#define WIN_64 
+#else
+#define WIN_32
+#endif
+#endif
+
+#ifdef CYGWIN
+#define OSTYPE "Cygwin"
+#endif
+
+#ifdef OS2 
+#define OSTYPE "OS/2" 
+#endif 
+
+/* include -DFFI in your makefile on the compile line 
+   and -lffi on the link line */
+#ifdef FFI
+
+#if defined(MAC_OSX)
+#include <ffi/ffi.h>
+#endif
+
+#if defined(WINDOWS)  
+#include "win-ffi.h" 
+#endif
+
+#if defined(LINUX) || defined(_BSD) || defined(CYGWIN) 
+#include <ffi.h>
+#endif
+
+#define LIBFFI " libffi"
+#else /* not FFI */
+#define LIBFFI ""
+
+#endif /* FFI */
+
+#ifdef TRU64
+#define strtoll strtol
+#define strtoull strtoul
+#endif
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+#define MY_RAND_MAX 2147483647
+#else
+#define MY_RAND_MAX RAND_MAX
+#endif
+
+#ifdef LIBRARY
+#define NO_FORK
+#define NO_SPAWN
+#define NO_DEBUG
+#define NO_TIMER
+#endif
+
+#ifdef EMSCRIPTEN
+#define NO_DEBUG
+#define NO_NET_FUNCTIONS
+#define NO_WEB_FUNCTIONS
+#endif
+
+
+/* 
+This is for 64bit large file support (LFS),
+*/
+#define LFS
+#ifdef LFS
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+#define _LARGEFILE64_SOURCE 1
+#endif
+#define _FILE_OFFSET_BITS 64
+#endif
+
+#ifdef WINDOWS
+/* NOTE:
+ * Windows XP [0x0501] end of support on 2014/04/08
+ * WIndows Vista [0x0600] support ends on 2017/04/11
+ */
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0600
+#endif
+#endif
+
+#include <signal.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <locale.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <dirent.h>
+#include <limits.h>
+
+/* some Linux do UTF-8 but do not have wcsftime() 
+   buggy in some GCC, i.e. MinGW and Solaris
+*/
+
+#ifdef SUPPORT_UTF8
+#ifdef LINUX
+#include <wchar.h>
+#define WCSFTIME
+#endif
+#ifdef WINDOWS
+#include <wchar.h>
+#endif
+#ifdef CYGWIN
+#include <wchar.h>
+#define WCSFTIME
+#endif
+#endif
+
+#ifdef WINDOWS
+#include <windef.h>
+#include <winbase.h>
+#else
+#include <termios.h>
+#include <sys/wait.h>
+#endif
+
+#include <unistd.h>
+#include <sys/time.h>
+#include <math.h>
+#include <float.h>
+#include <string.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#if defined(LINUX) || defined(WINDOWS) || defined(OS2)
+#include <malloc.h>
+#endif
+
+#if defined(MAC_OSX) || defined(SOLARIS) || defined(TRU64) || defined(AIX)
+#include <alloca.h>
+#endif
+
+#ifdef OS2
+#define vasprintf my_vasprintf 
+#define MY_VASPRINTF 
+#define NO_SPAWN
+#define NO_FORK
+#define NO_SHARE
+#define NO_PACKET
+#endif
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+#define vasprintf my_vasprintf
+#define MY_VASPRINTF
+#endif
+
+#if defined(SOLARIS) && defined(SPARC)
+#define setenv my_setenv 
+#define MY_SETENV 
+#endif
+
+#ifdef WINDOWS
+
+/* not needed on later MinGW, linker will complain if necessary  */
+#define MY_VASPRINTF
+#define vasprintf my_vasprintf
+
+#define MY_SETENV
+#define NO_SPAWN
+#define NO_FORK
+#define NO_NET_PACKET
+#define NO_NET_PING
+
+#define LITTLE_ENDIAN
+#define LINE_FEED "\r\n"
+#define LINE_FEED_LEN 2
+#define getSocket(A) ((A)->_file)
+#define setenv my_setenv
+#define random rand
+#define srandom srand
+#define ioctl ioctlsocket
+#define off_t off64_t
+#define lseek lseek64
+#define ftell ftello64
+#define getpid GetCurrentProcessId
+
+#ifndef SUPPORT_UTF8 
+#define mkdir  _mkdir
+#define rmdir  _rmdir
+#define lstat stat
+#endif
+
+#define realpath win_realpath
+
+/* WINDOWS UTF16 support for file paths */
+#ifdef SUPPORT_UTF8 
+#define USE_WIN_UTF16PATH
+#define rename rename_utf16
+#define open open_utf16
+#define mkdir mkdir_utf16
+#define rmdir rmdir_utf16
+#define unlink unlink_utf16
+#define chdir chdir_utf16
+#define opendir opendir_utf16
+#define DIR _WDIR
+#define lstat _wstat
+#define dirent _wdirent
+#define readdir _wreaddir
+#define closedir _wclosedir
+#endif /* SUPPORT_UTF8 */
+
+#endif /* WINDOWS */
+
+#ifndef WINDOWS
+#define LINE_FEED "\n"
+#define LINE_FEED_LEN 1
+#define NANOSLEEP
+#endif
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+#define UTF8_MAX_BYTES 6
+
+#include <stdint.h>
+#include <inttypes.h>
+
+#define UINT   uintptr_t  /* either 32-bit on ILP32 or 64-bit on LP64,LLP64 */
+#define INT    intptr_t   /* replaces 'long' which stayed 32-bit on Windows LLP64 */   
+
+#define INT16  int16_t
+#define INT64  int64_t
+#define UINT64 int64_t
+
+#define MAX_LONG INTPTR_MAX
+
+#define CONNECT_TIMEOUT 10000 
+
+#define pushEnvironment(A) (*(envStackIdx++) = (UINT)(A))
+#define popEnvironment() (*(--envStackIdx))
+
+/* reading top of stack in copyCell() does not require
+   subtracting 1 from index (changed in 10.3.2 */
+#define pushResult(A) (*(++resultStackIdx) = (UINT)(A))
+#define popResult() ((CELL *)*(resultStackIdx--))
+
+#define freeMemory free
+
+#define INT32_MIN_AS_INT64 (((long long int)0xFFFFFFFF << 32) | 0x80000000)
+#define MY_INT64_MAX (((long long int)0x7FFFFFFF << 32) | 0xFFFFFFFF)
+#define TRUE 1
+#define FALSE 0
+  
+#define MAX_STRING 2048 /* buffer length */
+#define MAX_LINE 256 /* buffer length */
+/* following limits are only for parsing */
+#define MAX_COMMAND_LINE 1024 /* buffer length */
+#define MAX_SYMBOL 255 /* strlen() */
+#define MAX_DIGITS 1001 /* 1000 + sign, limitation only for parsing source */
+#define MAX_HEX_NO MAX_DIGITS /* 16 + 0x */
+#define MAX_BIN_NO MAX_DIGITS /* 64 + 0B */
+#define MAX_DECIMALS MAX_DIGITS /* 32, numbers with decimal point */
+
+#define MAX_FILE_BUFFER 0x2000
+#define MAX_BLOCK 4095
+#define MAX_URL_LEN 255 /* strlen() */
+
+#define MAX_REGEX_EXP 16 
+
+/* token types */
+#define TKN_ERROR -1
+#define TKN_EMPTY 0
+#define TKN_CHARACTER 1
+#define TKN_HEX 2
+#define TKN_OCTAL 3
+#define TKN_BINARY 4
+#define TKN_DECIMAL 5
+#define TKN_FLOAT 6
+#define TKN_STRING 7
+#define TKN_SYMBOL 8
+#define TKN_CONTEXT 9
+#define TKN_LEFT_PAR '('
+#define TKN_RIGHT_PAR ')'
+#define TKN_QUOTE '\''
+
+/* symbol flags types and masks */
+#define PRINT_TYPE_MASK 0x0F
+#define SYMBOL_PROTECTED 0x10
+#define SYMBOL_GLOBAL 0x20
+#define SYMBOL_BUILTIN 0x40
+#define SYMBOL_FFI 0x100
+#define SYMBOL_MACRO 0x200
+#define SYMBOL_DESTRUCTIVE 0x400
+
+/* cell masks */
+
+#define RAW_TYPE_MASK 0x0FFF
+#define COMPARE_TYPE_MASK 0x000F
+#define ENVELOPE_TYPE_MASK 0x0010
+#define LIST_TYPE_MASK 0x0020
+#define SYMBOL_TYPE_MASK 0x0040
+#define NUMBER_TYPE_MASK 0x0080
+#define EVAL_SELF_TYPE_MASK 0x0100
+#define INT64_MASK 0x0200
+#define BIGINT_MASK 0x0400
+#define CALL_CDECL_MASK 0x1000
+#define CALL_DLL_MASK 0x2000
+#define CALL_FFI_MASK 0x4000
+#define IMPORT_MASK (CALL_CDECL_MASK | CALL_DLL_MASK | CALL_FFI_MASK)
+/* only used for type ids used in shared memory
+   to indicate translation from string */
+#define SHARED_MEM_EVAL_MASK 0x8000
+
+/* cell types, do not change these without changing newlisp.c/cellCopy() */
+#define CELL_NIL (0 | EVAL_SELF_TYPE_MASK)
+#define CELL_TRUE (1 | EVAL_SELF_TYPE_MASK)
+#define CELL_INT 2 /* any INT */
+#define CELL_LONG (2 | EVAL_SELF_TYPE_MASK | NUMBER_TYPE_MASK)
+#ifndef NEWLISP64
+#define CELL_INT64 (2 | EVAL_SELF_TYPE_MASK | NUMBER_TYPE_MASK | INT64_MASK)
+#endif
+
+#ifdef BIGINT
+#define CELL_BIGINT (2 | EVAL_SELF_TYPE_MASK | NUMBER_TYPE_MASK | BIGINT_MASK)
+#endif
+
+#define CELL_FLOAT (3 | EVAL_SELF_TYPE_MASK | NUMBER_TYPE_MASK)
+#define CELL_STRING (4 | EVAL_SELF_TYPE_MASK)
+#define CELL_SYMBOL (5 | SYMBOL_TYPE_MASK)
+#define CELL_CONTEXT 6
+#define CELL_PRIMITIVE (7 | EVAL_SELF_TYPE_MASK)
+#define CELL_IMPORT_CDECL (8 | EVAL_SELF_TYPE_MASK | CALL_CDECL_MASK)
+#define CELL_IMPORT_DLL (8 | EVAL_SELF_TYPE_MASK | CALL_DLL_MASK)
+#define CELL_IMPORT_FFI (9 | EVAL_SELF_TYPE_MASK | CALL_FFI_MASK)
+#define CELL_QUOTE (10 | ENVELOPE_TYPE_MASK)
+#define CELL_EXPRESSION (11 | ENVELOPE_TYPE_MASK | LIST_TYPE_MASK)
+#define CELL_LAMBDA (12 | ENVELOPE_TYPE_MASK | LIST_TYPE_MASK | EVAL_SELF_TYPE_MASK)
+#define CELL_FEXPR (13 | ENVELOPE_TYPE_MASK | LIST_TYPE_MASK | EVAL_SELF_TYPE_MASK)
+#define CELL_ARRAY (14 | ENVELOPE_TYPE_MASK | EVAL_SELF_TYPE_MASK)
+#define CELL_DYN_SYMBOL (15 | SYMBOL_TYPE_MASK)
+#define CELL_FREE 0xFF
+
+/* cell type classes */
+#define isEnvelope(A) ((A) & ENVELOPE_TYPE_MASK)
+#define isList(A) ((A) & LIST_TYPE_MASK)
+#define isNumber(A) ((A) & NUMBER_TYPE_MASK)
+#define isSymbol(A) ((A) & SYMBOL_TYPE_MASK)
+#define isSelfEval(A) ((A) & EVAL_SELF_TYPE_MASK)
+
+/* symbol classes */
+#define isProtected(A) ((A) & (SYMBOL_PROTECTED | SYMBOL_MACRO))
+#define isBuiltin(A) ((A) & SYMBOL_BUILTIN)
+#define isGlobal(A) ((A) & SYMBOL_GLOBAL)
+#define isFFIsymbol(A) ((A) & SYMBOL_FFI)
+
+#define isDigit(A) isdigit((int)(A))
+#define isHexDigit(A) isxdigit((int)(A))
+
+#define isNil(A) ((A)->type == CELL_NIL || ((A)->type == CELL_SYMBOL && (A)->contents == (UINT)nilSymbol))
+#define isTrue(A) ((A)->type == CELL_TRUE || ((A)->type == CELL_SYMBOL && (A)->contents == (UINT)trueSymbol))
+#define isEmpty(A) ((A)->type == CELL_EXPRESSION && (A)->contents == (UINT)nilCell)
+
+#define symbolType(A) ((CELL*)(A)->contents)->type
+
+/* redefine some functions */
+#ifdef NEWLISP64
+#define stuffInteger64 stuffInteger
+#endif
+
+/* RED BLACK binary balanced tree: nl-symbol.c */
+#define BLACK 0
+#define RED 1
+#define NIL_SYM &sentinel
+#define LOOKUP_ONLY 0		/* symbol lookup only, if not found return NULL */
+#define FORCE_CREATION 1	/* if symbol does not exist, create it */
+
+/* traceFlag */
+#define TRACE_TRUE 0x0001
+#define TRACE_IN_ENTRY 0x0002
+#define TRACE_IN_EXIT 0x0004
+#define TRACE_IN_DEBUG 0x0008
+#define TRACE_DEBUG_PENDING 0x0010
+#define TRACE_DEBUG_EVAL 0x0020
+#define TRACE_DEBUG_STEP 0x0040
+#define TRACE_DEBUG_NEXT 0x0080
+#define TRACE_PRINT_EVAL 0x0100
+#define TRACE_SIGINT 0x1000
+#define TRACE_TIMER  0x2000
+#define TRACE_SIGNAL 0x4000
+#define TRACE_CILK 0x8000
+
+/* error handling */
+
+#define ERR_NOT_ENOUGH_MEMORY 1
+#define ERR_OUT_OF_ENV_STACK 2
+#define ERR_OUT_OF_CALL_STACK 3
+#define ERR_ACCESSING_FILE 4
+#define ERR_EXPRESSION 5
+#define ERR_MISSING_PAR 6
+#define ERR_STRING_TOO_LONG 7
+#define ERR_MISSING_ARGUMENT 8
+#define ERR_NUMBER_OR_STRING_EXPECTED 9
+#define ERR_NUMBER_EXPECTED 10
+#define ERR_STRING_EXPECTED 11
+#define ERR_SYMBOL_EXPECTED 12
+#define ERR_CONTEXT_EXPECTED 13
+#define ERR_SYMBOL_OR_CONTEXT_EXPECTED 14
+#define ERR_LIST_EXPECTED 15
+#define ERR_LIST_OR_ARRAY_EXPECTED 16
+#define ERR_LIST_OR_SYMBOL_EXPECTED 17
+#define ERR_LIST_OR_STRING_EXPECTED 18
+#define ERR_LIST_OR_NUMBER_EXPECTED 19
+#define ERR_ARRAY_EXPECTED 20
+#define ERR_ARRAY_LIST_OR_STRING_EXPECTED 21
+#define ERR_LAMBDA_EXPECTED 22
+#define ERR_MACRO_EXPECTED 23
+#define ERR_INVALID_FUNCTION 24
+#define ERR_INVALID_LAMBDA 25
+#define ERR_INVALID_MACRO 26
+#define ERR_INVALID_LET 27
+#define ERR_SAVING_FILE 28
+#define ERR_MATH 29
+#define ERR_NOT_MATRIX 30
+#define ERR_WRONG_DIMENSIONS 31
+#define ERR_SINGULAR 32
+#define ERR_INVALID_OPTION 33
+#define ERR_THROW_WO_CATCH 34
+#define ERR_IMPORT_LIB_NOT_FOUND 35
+#define ERR_IMPORT_FUNC_NOT_FOUND 36
+#define ERR_SYMBOL_PROTECTED 37
+#define ERR_NUMBER_OUT_OF_RANGE 38
+#define ERR_REGEX 39
+#define ERR_TEXT_END_TAG 40
+#define ERR_NUM_ARGS 41
+#define ERR_FORMAT_STRING 42
+#define ERR_FORMAT_DATA_TYPE 43
+#define ERR_INVALID_PARAMETER 44
+#define ERR_INVALID_PARAMETER_0 45
+#define ERR_INVALID_PARAMETER_NAN 46
+#define ERR_INVALID_UTF8 47
+#define ERR_ILLEGAL_TYPE 48
+#define ERR_NOT_IN_MAIN 49
+#define ERR_NOT_CURRENT_CONTEXT 50
+#define ERR_TARGET_NO_MAIN 51
+#define ERR_LIST_INDEX_INVALID 52
+#define ERR_ARRAY_INDEX_OUTOF_BOUNDS 53
+#define ERR_STRING_INDEX_INVALID 54
+#define ERR_NESTING_TOO_DEEP 55
+#define ERR_LIST_REFERENCE_CHANGED 56
+#define ERR_SYNTAX_WRONG 57
+#define ERR_USER_ERROR 58
+#define ERR_USER_RESET 59
+#define ERR_SIGINT 60
+#define ERR_NOT_REENTRANT 61
+#define ERR_CANNOT_PROTECT_LOCAL 62
+#define ERR_IS_NOT_REFERENCED 63
+#define ERR_LIST_EMPTY 64
+#define ERR_IO_ERROR 65
+#define ERR_WORKING_DIR 66
+#define ERR_INVALID_PID 67
+#define ERR_CANNOT_OPEN_SOCKETPAIR 68
+#define ERR_CANNOT_FORK_PROCESS 69
+#define ERR_NO_SOCKET 70
+#define ERR_FFI_PREP_FAILED 71
+#define ERR_FFI_INVALID_TYPE 72
+#define ERR_FFI_STRUCT_EXPECTED 73
+#define ERR_BIGINT_NOT_ALLOWED 74
+#define ERR_CANNOT_CONVERT 75
+#define ERR_CANNOT_CONVERT_NULL 76
+#define MAX_ERROR_NUMBER 76
+#define UNKNOWN_ERROR "Unknown error"
+
+/* network error handling */
+#define ERR_INET_OPEN_SOCKET 1
+#define ERR_INET_HOST_UNKNOWN 2
+#define ERR_INET_INVALID_SERVICE 3
+#define ERR_INET_CONNECT_FAILED 4
+#define ERR_INET_ACCEPT 5
+#define ERR_INET_CONNECTION_DROPPED 6
+#define ERR_INET_CONNECTION_BROKEN 7
+#define ERR_INET_READ 8
+#define ERR_INET_WRITE 9
+#define ERR_INET_CANNOT_BIND 10
+#define ERR_INET_TOO_MUCH_SOCKETS 11
+#define ERR_INET_LISTEN_FAILED 12
+#define ERR_INET_BAD_FORMED_IP 13
+#define ERR_INET_SELECT_FAILED 14
+#define ERR_INET_PEEK_FAILED 15
+#define ERR_INET_NOT_VALID_SOCKET 16
+#define ERR_INET_CANNOT_CHANGE_SOCK_BLOCK 17
+#define ERR_INET_TIMEOUT 18
+/* used in nl-web.c */
+#define ERROR_BAD_URL 19
+#define ERROR_FILE_OP 20
+#define ERROR_TRANSFER 21
+#define ERROR_INVALID_RESPONSE 22
+#define ERROR_NO_RESPONSE 23
+#define ERROR_NO_CONTENT 24
+#define ERROR_HEADER 25
+#define ERROR_CHUNKED_FORMAT 26
+
+#define MAX_NET_ERROR 26
+
+
+/* I/O routines */
+#define OUT_NULL 0
+#define OUT_DEVICE 1
+#define OUT_CONSOLE 2
+#define OUT_LOG 3
+
+/* HTTP in nl-web.c */
+#define HTTP_GET 0
+#define HTTP_HEAD 1
+#define HTTP_PUT 2
+#define HTTP_PUT_APPEND 3
+#define HTTP_POST 4
+#define HTTP_DELETE 5
+
+/* sysEvalString() in newlisp.c */
+#define EVAL_STRING 0 /* the classic eval-string: read, xlate, evaluate */
+#define READ_EXPR 1 /* read one toplevel expression: read */
+#define READ_EXPR_SYNC 2 /* called from sync */
+#define READ_EXPR_NET 3 /* called from net-eval */
+
+/* used inf setDefine() define in newlisp.c */
+#define SET_SET 1
+#define SET_CONSTANT 2
+#define SET_DEFINE 3
+
+extern int vasprintf (char **, const char *, va_list); 
+
+/* ---------------------------- standard types ------------------------- */
+
+typedef struct
+	{
+	char *ptr;
+	char *buffer;
+	size_t position;
+	size_t size;
+	int handle;
+	} STREAM;
+
+typedef struct tagSYMBOL
+	{
+	int flags;
+	int color;
+	char * name;
+	UINT contents; 
+	struct tagSYMBOL * context;
+	struct tagSYMBOL * parent;
+	struct tagSYMBOL * left;
+	struct tagSYMBOL * right;   
+	} SYMBOL;
+
+typedef struct 
+	{
+	UINT type;
+	void * next;
+	UINT aux;
+	UINT contents;
+	} CELL;
+
+typedef struct
+	{
+	char * name;
+	CELL * (*function)(CELL *);
+	short int flags;
+	} PRIMITIVE;
+
+typedef struct
+    {
+    int handle;
+    int family;
+    FILE * stream;
+    void * next;
+    } IO_SESSION;
+
+#ifdef FFI
+
+#define FFI_FUNCTION (1)
+#define FFI_CLOSURE  (2)
+#define FFI_STRUCT   (3)
+
+typedef struct {
+  SYMBOL *symbol;
+  void *code;
+} ffi_closure_data;
+
+typedef struct
+    {
+    char *name;
+    void (*func)(void);
+    ffi_cif cif;
+    void *code;
+    ffi_closure *clos;
+    ffi_closure_data *data;
+    ffi_type *cstruct;
+    short int type;
+    } FFIMPORT;
+#endif
+
+/* --------------------------- globals -------------------------------- */
+
+extern char startupDir[];
+extern char * tempDir;
+extern FILE * IOchannel;
+extern int ADDR_FAMILY;
+#ifdef WINDOWS
+extern int IOchannelIsSocket;
+#endif
+extern int MAX_CPU_STACK;
+extern INT MAX_CELL_COUNT;
+extern int version;
+extern int opsys;
+extern char ostype[];
+extern size_t cellCount;
+extern size_t symbolCount;
+extern int recursionCount;
+extern UINT printDevice;
+extern UINT * resultStack;
+extern UINT * resultStackIdx;
+extern UINT * envStack;
+extern UINT * envStackIdx;
+extern CELL * trueCell;
+extern CELL * nilCell;
+extern STREAM strStream;
+extern SYMBOL * nilSymbol;
+extern SYMBOL * trueSymbol;
+extern SYMBOL * startSymbol;
+extern SYMBOL * questionSymbol;
+extern SYMBOL * atSymbol;
+extern SYMBOL * mainContext;
+extern SYMBOL * currentContext;
+extern SYMBOL * errorEvent;
+extern SYMBOL * symbolCheck;
+extern SYMBOL * itSymbol;
+extern SYMBOL sentinel;
+extern void * stringIndexPtr;
+extern CELL * stringCell;
+extern int traceFlag;
+extern int errorReg;
+extern char * errorMessage[];
+extern jmp_buf errorJump;
+extern int pushResultFlag;
+extern int prettyPrintFlags;
+#define PRETTYPRINT_DOUBLE 1
+#define PRETTYPRINT_STRING 2
+extern char lc_decimal_point;
+extern CELL * xmlTags;
+extern CELL * xmlCallback;
+/* end of file */
+
+#endif /* NEWLISP_H */
+
diff --git a/nl-debug.c b/nl-debug.c
new file mode 100644
index 0000000..7912f7c
--- /dev/null
+++ b/nl-debug.c
@@ -0,0 +1,404 @@
+/* nl-debug.c --- debugging functions, and functions to trap signals and timers 
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+
+#include "newlisp.h"
+#include "protos.h"
+
+#ifdef WINDOWS
+#define fgets win_fgets
+#endif
+
+extern FILE * IOchannel;
+extern int evalSilent;
+
+int matchString(char * buffer,  char * string, int * length);
+int stringComp(char * buffer, char * string);
+int debugPrintFunction(CELL * cell);
+void getDebuggerInput(char * msg);
+
+extern SYMBOL * currentFunc;
+extern SYMBOL * timerEvent;
+extern SYMBOL * cilkEvent;
+extern SYMBOL * symHandler[];
+extern int currentSignal;
+
+int currentLevel = 0;
+int debugStackIdx = 0;
+UINT * debugStack;
+UINT tracePrintDevice;
+
+char debugPreStr[8] = "#";
+char debugPostStr[8] = "#";
+CELL * debugPrintCell = NULL;
+
+char headerStr[16] = "\n-----\n\n";
+char footerStr[32] = " s|tep n|ext c|ont q|uit > ";
+
+#define pushDebugStack(A) (*(debugStack + debugStackIdx++) = (UINT)(A))
+#define popDebugStack() (*(debugStack + --debugStackIdx))
+
+#define DEBUG_ENTRY "->"
+#define DEBUG_EXIT "<-"
+
+void openTrace(void)    
+    {
+    if(traceFlag) return;
+    traceFlag = TRACE_TRUE;
+    currentFunc = nilSymbol;
+    debugStackIdx = 0;
+    debugStack = (UINT *)allocMemory(MAX_CPU_STACK * 2 * sizeof(UINT));
+    }
+
+void closeTrace(void)
+    {
+    if(traceFlag & TRACE_PRINT_EVAL) 
+        close(tracePrintDevice);
+    traceFlag = 0;
+    if(debugStack) free(debugStack);
+    debugStack = NULL;
+    }
+
+#ifdef DEBUGGER
+CELL * p_debug(CELL * params)
+{
+CELL * result;
+
+openTrace();
+traceFlag |= TRACE_IN_DEBUG;
+result = copyCell(evaluateExpression(params));
+closeTrace();
+
+return(result);
+}
+#endif
+
+
+CELL * p_trace(CELL * params)
+{
+if(params != nilCell)
+    {
+    params = evaluateExpression(params);
+    if(isNumber(params->type))
+        {
+        traceFlag |= TRACE_PRINT_EVAL;
+        getIntegerExt(params, &tracePrintDevice, FALSE);
+        return(stuffInteger(tracePrintDevice));
+        }
+    if(!isNil(params))
+        {
+        openTrace();
+        traceFlag |= TRACE_IN_DEBUG;
+        }
+    else
+        closeTrace();
+    }
+
+if(traceFlag & TRACE_IN_DEBUG) return(trueCell);
+if(traceFlag & TRACE_PRINT_EVAL) return(stuffInteger(tracePrintDevice));
+return(nilCell);
+}
+
+#ifdef DEBUGGER
+CELL * p_traceHighlight(CELL * params)
+{
+char * pre, * post, * header, * footer;
+
+params = getString(params, &pre);
+params = getString(params, &post);
+
+strncpy(debugPreStr, pre, 8);
+strncpy(debugPostStr, post, 8);
+*(debugPreStr + 7) = 0;
+*(debugPostStr + 7) = 0;
+
+if(params != nilCell)
+    {
+    params = getString(params, &header);
+    strncpy(headerStr, header, 16);
+    }
+
+if(params != nilCell)
+    {
+    getString(params, &footer);
+    strncpy(footerStr, footer, 32);
+    }
+
+*(headerStr + 15) = 0;
+*(footerStr + 31) = 0;
+
+return(trueCell);
+}
+#endif /* DEBUGGER */
+
+void tracePrint(char * label, CELL * expr)
+{
+UINT printDeviceSave = printDevice;
+
+printDevice = tracePrintDevice;
+varPrintf(OUT_DEVICE, "%d %s: ", recursionCount, label);
+if(expr) printCell(expr, TRUE, OUT_DEVICE);
+varPrintf(OUT_DEVICE, "%s", "\n");
+printDevice = printDeviceSave;
+}
+
+void traceEntry(CELL * cell, CELL * pCell, CELL * args)
+{
+if(traceFlag & (TRACE_IN_ENTRY | TRACE_IN_EXIT | TRACE_DEBUG_NEXT)) return;
+traceFlag |= TRACE_IN_ENTRY;
+
+#ifdef DEBUGGER
+int defaultFuncFlag = FALSE;
+#endif
+
+if(traceFlag & TRACE_SIGNAL)
+    {
+    traceFlag &= ~TRACE_SIGNAL;
+    executeSymbol(symHandler[currentSignal - 1], stuffInteger(currentSignal), NULL);
+    traceFlag &= ~TRACE_IN_ENTRY;
+    return;
+    }
+
+if(traceFlag & TRACE_SIGINT)
+    {
+    traceFlag &= ~TRACE_SIGINT;
+    longjmp(errorJump, ERR_USER_RESET);
+    }
+    
+if(traceFlag & TRACE_TIMER)
+    {
+    traceFlag &= ~TRACE_TIMER;
+    executeSymbol(timerEvent, NULL, NULL);
+    traceFlag &= ~TRACE_IN_ENTRY;
+    return;
+    }
+
+if(traceFlag & TRACE_PRINT_EVAL)
+    {
+    if(cell->type == CELL_EXPRESSION) tracePrint("entry", cell);
+    traceFlag &= ~TRACE_IN_ENTRY;
+    return;
+    }
+
+#ifdef DEBUGGER
+if(debugStackIdx > 1)
+    {
+    if(debugPrintFunction(cell))
+        getDebuggerInput(DEBUG_ENTRY);
+    if(!traceFlag) return;
+    }
+
+if(traceFlag & TRACE_DEBUG_NEXT)
+    {
+    traceFlag &= ~TRACE_IN_ENTRY;
+    return;
+    }
+
+if(pCell->type == CELL_CONTEXT)
+    {
+    defaultFuncFlag = TRUE;
+    currentFunc = translateCreateSymbol(
+            ((SYMBOL*)pCell->contents)->name,
+            CELL_NIL,
+            (SYMBOL*)pCell->contents,
+            TRUE);
+
+    pCell = (CELL *)currentFunc->contents;
+    }
+
+if((pCell->type == CELL_LAMBDA || pCell->type == CELL_FEXPR)
+    && args->type == CELL_SYMBOL)
+    {
+    if(debugStackIdx == 0) /* startup */
+        traceFlag &= ~TRACE_DEBUG_NEXT;
+    
+    if(!defaultFuncFlag)
+        currentFunc = (SYMBOL *)args->contents; 
+    pushDebugStack(recursionCount);
+    pushDebugStack(currentFunc);
+    }
+#endif /* no_DEBUG */
+
+traceFlag &= ~TRACE_IN_ENTRY;
+}
+
+
+void traceExit(CELL * result, CELL * cell, CELL * pCell, CELL * args)
+{
+if(traceFlag & (TRACE_IN_ENTRY | TRACE_IN_EXIT | TRACE_SIGNAL | TRACE_SIGINT | TRACE_TIMER)) return;
+
+if(traceFlag == TRACE_PRINT_EVAL)
+    {
+    tracePrint("exit", result);
+    return;
+    }
+
+traceFlag |= TRACE_IN_EXIT;
+
+#ifdef DEBUGGER
+if(traceFlag & TRACE_DEBUG_NEXT)
+    {
+    if(currentLevel >= recursionCount)
+        traceFlag &= ~TRACE_DEBUG_NEXT;
+    else 
+        {
+        traceFlag &= ~TRACE_IN_EXIT;
+        return;
+        }
+    }
+
+if( (pCell->type == CELL_LAMBDA || pCell->type == CELL_FEXPR)
+        && args->type == CELL_SYMBOL)
+    {
+    if((UINT)recursionCount == *(debugStack + debugStackIdx - 2) )
+        {
+        debugStackIdx -= 2;
+        if(debugStackIdx > 0)
+            currentFunc = (SYMBOL *)*(debugStack + debugStackIdx - 1);
+        if(debugStackIdx == 0)
+            traceFlag &= ~TRACE_DEBUG_NEXT;
+        }
+    }
+
+if(debugPrintFunction(cell))
+    {
+    varPrintf(OUT_CONSOLE, "\nRESULT: ");
+    printCell(result, TRUE, OUT_CONSOLE);
+    varPrintf(OUT_CONSOLE, "\n");
+
+    if(debugStackIdx > 0)
+        {
+        getDebuggerInput(DEBUG_EXIT);
+        if(!traceFlag) return;
+        }
+    }
+
+if(traceFlag & TRACE_DEBUG_NEXT)
+    currentLevel = recursionCount;
+#endif /* DEBUGGER */
+
+traceFlag &= ~TRACE_IN_EXIT;
+}
+
+#ifdef DEBUGGER
+void getDebuggerInput(char * msg)
+{
+char command[MAX_LINE];
+char * context;
+jmp_buf errorJumpSave;
+UINT * resultStackIdxSave;
+SYMBOL * contextSave;
+
+while(TRUE)
+    {
+
+    if(currentContext != mainContext)
+        context = currentContext->name;
+    else context = "";
+
+
+    if(!evalSilent)
+        varPrintf(OUT_CONSOLE, "\n[%s %d %s]%s", msg, recursionCount, context, footerStr);
+    else evalSilent = FALSE;
+
+    if(fgets(command, MAX_LINE - 1, IOchannel) == NULL)
+        fatalError(ERR_IO_ERROR, 0, 0);
+
+    /* client and server could have different line-termination */
+    if(*(command + 1) == '\n' || *(command + 1) == '\r')
+        {
+        if(*command == 'n')
+            {
+            traceFlag |= TRACE_DEBUG_NEXT;
+            currentLevel = recursionCount;
+            break;
+            }
+        if(*command == 's')
+            {
+            traceFlag &= ~TRACE_DEBUG_NEXT;
+            break;
+            }
+        if(*command == 'q')
+            {
+            closeTrace();
+            longjmp(errorJump, ERR_USER_RESET);
+            }
+        if(*command == 'c')
+            {
+            closeTrace();
+            break;
+            }
+        }
+
+    resultStackIdxSave = resultStackIdx;
+    memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+    contextSave = currentContext;
+    currentContext = currentFunc->context;
+    if(setjmp(errorJump))
+        {
+        cleanupResults(resultStackIdxSave);
+        goto DEBUG_EVAL_END;
+        }
+
+    executeCommandLine(command, OUT_CONSOLE, NULL); 
+
+    DEBUG_EVAL_END:
+    currentContext = contextSave;
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    }
+}
+
+
+int debugPrintFunction(CELL * cell)
+{
+int preLen, pos = 0;
+char * strPos;
+
+STREAM strStream = {NULL, NULL, 0, 0, 0};
+
+if(currentFunc == nilSymbol) return FALSE;
+
+debugPrintCell = cell;
+openStrStream(&strStream, MAX_STRING, 0);
+printSymbol(currentFunc, (UINT)&strStream);
+debugPrintCell = NULL;
+
+strPos = strstr(strStream.buffer, debugPreStr);
+if(strPos != NULL)
+    {
+    preLen = strlen(debugPreStr);
+    while(*(strPos + preLen + pos) <= ' ' && *(strPos + preLen + pos) != 0) ++pos;
+    if(pos) /* if there is white space */
+        {
+        /* swap whitespace and debugPreStr */
+        strncpy(strPos, strPos + preLen, pos);
+        strncpy(strPos + pos, debugPreStr, preLen);
+        }
+    varPrintf(OUT_CONSOLE, "%s", headerStr);
+    varPrintf(OUT_CONSOLE, "%s", strStream.buffer);
+    }
+
+closeStrStream(&strStream);
+return (strPos != NULL);
+}
+
+#endif /* DEBUGGER */
+/* eof */
+
+
diff --git a/nl-filesys.c b/nl-filesys.c
new file mode 100644
index 0000000..4e5e664
--- /dev/null
+++ b/nl-filesys.c
@@ -0,0 +1,3202 @@
+/*
+
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include <errno.h>
+#include "protos.h"
+
+#define AF_UNSPEC 0 /* from socket.h or winsock2.h */
+
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX) 
+#include <stropts.h>
+#endif
+
+#ifdef SOLARIS
+#define FIONREAD I_NREAD
+#endif
+
+#ifndef WINDOWS
+#include <sys/types.h>
+#ifndef ANDROID
+#ifndef EMSCRIPTEN
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#endif
+#endif
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#endif
+
+int init_argv(char * ptr, char *argv[]);
+char * getUUID(char * str, char * node);
+
+#ifdef OS2
+#include <conio.h>
+int semctl(int semid, int semnum, int cmd, ...);
+#endif
+
+#ifndef TRU64
+extern char ** environ;
+#endif
+
+#ifdef WINDOWS
+#define fgetc win_fgetc
+#define realpath win_realpath
+#include <conio.h>  
+#include <io.h>
+#include <direct.h>
+#define popen  _popen
+#define pclose _pclose
+#define pipe _pipe
+
+/* 
+Set binary as default file mode for Windows.
+See also http://www.mingw.org/MinGWiki/index.php/binary
+*/
+unsigned int _CRT_fmode = _O_BINARY;
+
+int setenv (const char *name, const char *value, int replace);
+#endif /* Win32 */
+
+#ifndef WINDOWS
+#include <sys/socket.h>
+#define SOCKET_ERROR -1
+#define INVALID_SOCKET -1
+#endif
+
+#if defined(LINUX) || defined(CYGWIN)
+char * strptime(const char * str, const char * fmt, struct tm * ttm);
+#endif
+
+time_t calcDateValue(int year, int month, int day, int hour, int min, int sec);
+ssize_t currentDateValue(void);
+extern STREAM readLineStream;
+extern FILE * IOchannel;
+extern int pagesize;
+
+extern char * errorMessage[];
+extern STREAM errorStream;
+extern UINT netErrorIdx;
+extern int newlispLibConsoleFlag;
+
+/* semaphore() function type */
+#ifndef NO_SEMAPHORE
+#define SEM_CREATE 0
+#define SEM_STATUS 1
+#define SEM_SIGNAL 2
+#endif
+
+/* used in fork and spawn */
+int parentPid = 0;
+/* share, message */
+CELL * readWriteShared(UINT * address, CELL * params, int flag);
+CELL * readWriteSocket(int socket, CELL * params);
+CELL * readWriteSharedExpression(UINT * adress, CELL * params);
+
+void checkDeleteShareFile(UINT * address);
+
+CELL * p_isFile(CELL * params) /* includes dev,socket,dir,file etc. */
+{
+char * fileName;
+int flag;
+
+params = getString(params, &fileName);
+flag = getFlag(params);
+
+return(isFile(fileName, flag) ? nilCell : flag ? stuffString(fileName) : trueCell);
+}
+
+int isFile(char * fileName, int flag)
+{
+struct stat fileInfo;
+int result;
+
+#ifdef WINDOWS
+char slash;
+size_t len;
+
+len = strlen(fileName);
+slash = *(fileName + len - 1);
+if((slash == '\\' || slash == '/') && (!(len >= 2 && *(fileName + len - 2) == ':')))
+    *(fileName + len - 1) = 0;
+
+#ifdef USE_WIN_UTF16PATH
+result = stat_utf16(fileName, &fileInfo);
+#else
+result = stat(fileName, &fileInfo);
+#endif
+if(slash == '\\' || slash == '/')
+    *(fileName + len - 1) = slash;
+#else /* not WINDOWS */
+result = stat(fileName, &fileInfo);
+#endif
+if(result == 0)
+    {
+    if(flag)
+        result = ! S_ISREG(fileInfo.st_mode);
+    }
+
+return(result);
+}
+
+CELL * p_isDirectory(CELL * params)
+{
+char * fileName;
+
+getString(params, &fileName);
+return(isDir(fileName) ? trueCell : nilCell);
+}
+
+int isDir(char * fileName)
+{
+struct stat fileInfo;
+
+#ifdef WINDOWS
+char slash;
+size_t len;
+
+len = strlen(fileName);
+slash = *(fileName + len - 1);
+if((slash == '\\' || slash == '/') && (!(len >= 2 && *(fileName + len - 2) == ':')))
+    *(fileName + len - 1) = 0;
+#endif
+
+#ifdef USE_WIN_UTF16PATH
+if(stat_utf16(fileName, &fileInfo) != 0)
+#else
+if(stat(fileName, &fileInfo) != 0)
+#endif
+    {
+#ifdef WINDOWS
+    *(fileName + len - 1) = slash;
+#endif
+    return(0);
+    }
+
+#ifdef WINDOWS
+*(fileName + len - 1) = slash;
+#endif
+
+if(S_ISDIR(fileInfo.st_mode))
+    return(1);
+return(0);
+}
+
+
+CELL * p_open(CELL * params)
+{
+char * fileName;
+char * accessMode;
+char * option = NULL;
+int handle;
+IO_SESSION * session;
+
+params = getString(params, &fileName);
+params = getString(params, &accessMode);
+
+if(params != nilCell)
+    getString(params, &option);
+    
+if( (handle = openFile(fileName, accessMode, option)) == (int)-1)
+    return(nilCell);
+
+session = createIOsession(handle, AF_UNSPEC);
+if(*accessMode == 'r')
+    session->stream = fdopen(handle, "r");
+else if(*accessMode == 'w')
+    session->stream = fdopen(handle, "w");
+else if(*accessMode == 'u')
+    session->stream = fdopen(handle, "r+");
+else if(*accessMode == 'a')
+    session->stream = fdopen(handle, "a+");
+
+return(stuffInteger((UINT)handle));
+}
+
+CELL * p_close(CELL * params)
+{
+UINT handle;
+
+getInteger(params, &handle);
+if(handle == 0) return(nilCell);
+if(handle == printDevice) printDevice = 0;
+if(deleteIOsession(handle)) return(trueCell);
+return(nilCell);
+}
+
+
+CELL * p_readChar(CELL * params)
+{
+UINT handle;
+unsigned char chr;
+
+if(params != nilCell)
+    getInteger(params, &handle);
+else 
+    handle = printDevice;
+
+#ifdef WINDOWS
+/* make it work as on Unix */
+if(printDevice == 1 || printDevice == 2) handle = 0;
+#endif
+
+if(read((int)handle, &chr, 1) <= 0) return(nilCell);
+
+return(stuffInteger((UINT)chr));
+}
+
+
+CELL * p_readBuffer(CELL * params)
+{
+UINT handle;
+size_t size, length;
+ssize_t bytesRead = 0;
+char * waitFor;
+STREAM stream = {NULL, NULL, 0, 0, 0};
+CELL * strCell;
+SYMBOL * readSptr;
+int found = 0;
+char chr;
+
+params = getInteger(params, &handle);
+params = getEvalDefault(params, &strCell);
+if(!symbolCheck || symbolCheck->contents != (UINT)strCell)
+    return(errorProc(ERR_IS_NOT_REFERENCED));
+if(isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+readSptr = symbolCheck;
+params = getInteger(params, (UINT *)&size);
+
+if(params == nilCell)
+    {
+    openStrStream(&stream, size, 0);
+    found = 1;
+    if((bytesRead = read(handle, stream.buffer, size)) == -1)
+        {
+        closeStrStream(&stream); 
+        return(nilCell);
+        }
+    }
+else
+    {
+    getString(params, &waitFor);
+    openStrStream(&stream, MAX_LINE, 0);
+    length = strlen(waitFor);
+    while(bytesRead < size)
+        {
+        if(read(handle, &chr, 1) <= 0)
+            break;
+
+        writeStreamChar(&stream, chr); 
+        if(++bytesRead < length) continue;
+        if(strcmp(waitFor,  stream.ptr - length) == 0)
+            {
+            found = 1;
+            break;
+            }       
+        }           
+    }
+
+deleteList(strCell);
+
+if(bytesRead == 0) 
+    { 
+    readSptr->contents = (UINT)copyCell(nilCell);
+    closeStrStream(&stream); 
+    return(nilCell);
+    } 
+
+if(stream.size > bytesRead)
+    stream.buffer = reallocMemory(stream.buffer, bytesRead + 1);
+readSptr->contents = (UINT)makeStringCell(stream.buffer, bytesRead);
+
+if(found) return(stuffInteger(bytesRead));
+return(nilCell);
+}
+
+
+CELL * p_readFile(CELL * params)
+{
+char * fileName;
+char * buffer = NULL;
+ssize_t size;
+#ifndef EMSCRIPTEN
+CELL * result;
+#endif
+
+params = getString(params, &fileName);
+#ifndef EMSCRIPTEN
+if(my_strnicmp(fileName, "http://", 7) == 0)
+    {
+    result = getPutPostDeleteUrl(fileName, params, HTTP_GET, CONNECT_TIMEOUT);
+    return((my_strnicmp((char *)result->contents, (char *)"ERR:", 4) == 0) && netErrorIdx ? nilCell : result);
+    }
+#endif
+if((size = readFile(fileName, &buffer)) == -1)
+    return(nilCell);
+
+return(makeStringCell(buffer, size));
+}
+
+/* allocates a buffer and reads a file into it */
+ssize_t readFile(char * fileName, char * * buffer)
+{
+int handle; 
+off_t size;
+struct stat fileInfo;
+
+fileName = getLocalPath(fileName);
+
+#ifdef USE_WIN_UTF16PATH
+if(stat_utf16(fileName, &fileInfo) != 0)
+#else
+if(stat(fileName, &fileInfo) != 0)
+#endif
+    return(-1);
+
+size = fileInfo.st_size;
+
+if( (handle = openFile(fileName, "r", NULL)) == (int)-1)
+    return(-1);
+
+*buffer = callocMemory(size+1);
+
+if(read(handle, *buffer, size) == -1)
+    {
+    freeMemory(*buffer);
+        close(handle);
+    *buffer = NULL;
+    return(-1);
+    }
+
+close(handle);
+
+return(size);
+}
+
+
+
+CELL * p_writeChar(CELL * params)
+{
+UINT handle;
+UINT data;
+size_t count;
+unsigned char chr;
+
+params = getInteger(params, &handle);
+count = 0;
+
+while(params != nilCell)
+    {
+    params = getInteger(params, &data);
+    chr = (unsigned char)data;
+    if(write((int)handle, (void *)&chr, 1) == -1)
+        return(nilCell);
+    ++count;
+    }
+    
+return(stuffInteger(count));
+}
+
+
+size_t appendCellString(CELL * cell, char * buffer, size_t size)
+{
+cell->contents = (UINT)reallocMemory((char *)cell->contents, cell->aux + size);
+memcpy((char *)cell->contents + cell->aux - 1, buffer, size);
+cell->aux += size;
+
+*((char *)cell->contents + cell->aux - 1) = 0; 
+
+return(size);
+}
+
+
+CELL * p_appendFile(CELL * params)
+{
+return(appendWriteFile(params, "a"));
+}
+
+CELL * p_writeFile(CELL * params)
+{
+return(appendWriteFile(params, "w"));
+}
+
+int writeFile(char * fileName, char * buffer, size_t size, char * type)
+{
+int handle;
+
+if( (handle = openFile(fileName, type, NULL)) == (int)-1)
+    return(-1);
+
+if(write(handle, buffer, size) == (int)-1)
+    return(-1);
+
+close(handle);
+return(0);
+}
+
+CELL * appendWriteFile(CELL * params, char * type)
+{
+char * fileName;
+char * buffer;
+size_t size;
+#ifndef EMSCRIPTEN
+CELL * result;
+#endif
+
+params = getString(params, &fileName);
+
+#ifndef EMSCRIPTEN
+if(my_strnicmp(fileName, "http://", 7) == 0)
+    {
+    result = getPutPostDeleteUrl(fileName, params, 
+                (*type == 'w') ? HTTP_PUT : HTTP_PUT_APPEND, CONNECT_TIMEOUT);
+    return((my_strnicmp((char *)result->contents, (char *)"ERR:", 4) == 0) && netErrorIdx ? nilCell : result);
+    }
+#endif
+
+getStringSize(params, &buffer, &size, TRUE);
+
+if(writeFile(fileName, buffer, size, type) == (int)-1)
+    return(nilCell);
+
+return(stuffInteger(size));
+}
+
+CELL * writeBuffer(CELL * params, int lineFeed);
+
+CELL * p_writeBuffer(CELL * params)
+{
+return(writeBuffer(params, FALSE));
+}
+
+CELL * p_writeLine(CELL * params)
+{
+return(writeBuffer(params, TRUE));
+}
+
+
+CELL * writeBuffer(CELL * params, int lineFeed)
+{
+CELL * device;
+UINT handle;
+SYMBOL * symbolRef;
+char * buffer;
+size_t size, userSize;
+
+if(params == nilCell)
+    {
+    varPrintf(OUT_DEVICE, "%s", readLineStream.buffer);
+    if(lineFeed) varPrintf(OUT_DEVICE, LINE_FEED);
+    size = readLineStream.ptr - readLineStream.buffer;
+    goto RETURN_WRITE_BUFFER;
+    }
+
+params = getEvalDefault(params, &device);
+symbolRef = symbolCheck;
+
+if(params == nilCell)
+    {
+    buffer = readLineStream.buffer;
+    size = readLineStream.ptr - readLineStream.buffer;
+    }
+else
+    params = getStringSize(params, &buffer, &size, TRUE);
+
+if(!lineFeed)
+    {
+    if(params != nilCell)
+        {
+        getInteger(params, (UINT *)&userSize);
+        size = (userSize > size) ? size : userSize;
+        }
+    }
+
+if(isNumber(device->type))
+    {
+    getIntegerExt(device, &handle, FALSE);
+    if(write((int)handle, buffer, size) == -1) return(nilCell);
+    if(lineFeed)
+        if(write((int)handle, LINE_FEED, LINE_FEED_LEN) == -1) return(nilCell);
+    }
+
+else if(device->type == CELL_STRING)
+    {
+    if(symbolRef && isProtected(symbolRef->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolRef)));
+
+    appendCellString(device, buffer, size);
+    if(lineFeed)
+        appendCellString(device, LINE_FEED, LINE_FEED_LEN);
+    }
+else
+    return(errorProcExt(ERR_INVALID_PARAMETER, device));
+
+
+RETURN_WRITE_BUFFER:
+return(stuffInteger(size + (lineFeed ? LINE_FEED_LEN : 0)));
+}
+
+
+CELL * p_seek(CELL * params)
+{
+UINT handle;
+FILE * fstream;
+#ifdef LFS
+INT64 paramPosition;
+off_t newPosition;
+#else
+off_t paramPosition;
+off_t newPosition;
+#endif
+
+params = getInteger(params, &handle);
+
+if(params == nilCell)
+    {
+    if(handle == 0)
+        newPosition = ftell(stdout);
+    else if((fstream = getIOstream(handle)) != NULL)
+        newPosition = ftell(fstream);
+    else if( (newPosition = lseek(handle, 0, SEEK_CUR)) == -1)
+        return(nilCell);
+    }
+else
+    {
+#ifdef LFS
+    getInteger64Ext(params, &paramPosition, TRUE);
+#else
+    getInteger(params, (UINT *)&paramPosition);
+#endif
+
+    newPosition = paramPosition;
+    if(newPosition == -1)
+        {
+        if( (newPosition = lseek((int)handle, 0, SEEK_END)) == -1)
+            return(nilCell);
+        }
+    else
+        {
+        if( lseek((int)handle, newPosition, SEEK_SET) == -1)
+            return(nilCell);
+        }
+    }
+
+paramPosition = newPosition;
+#ifdef LFS
+return(stuffInteger64(paramPosition));
+#else
+return(stuffInteger(paramPosition));
+#endif
+}
+
+char * readStreamLine(STREAM * stream, FILE * inStream)
+{
+#ifdef OLD_READ_STREAM /* pre 10.5.8 */
+int chr;
+#else
+char buff[MAX_STRING];
+size_t l;
+#endif
+
+openStrStream(stream, MAX_STRING, 1);
+
+#ifdef TRU64
+do {
+errno = 0;
+#endif
+#ifdef TRUE64 /* pre 10.5.8 also all other OS */
+while((chr = fgetc(inStream)) != EOF)
+    {
+    if(chr == '\n') break;
+    if(chr == '\r')
+        {
+        chr = fgetc(inStream);
+        if(chr == '\n' || chr == EOF) break;
+        }
+    writeStreamChar(stream, chr);
+    }
+#else
+while(fgets(buff, MAX_STRING, inStream) != NULL)
+    {
+    l=strlen(buff);
+    if(buff[l-1] == 0x0A)
+        {
+        buff[--l] = 0;
+        if(buff[l-1] == 0x0D)
+            buff[--l] = 0;
+        writeStreamStr(stream, buff, l);
+        break;
+        }
+    writeStreamStr(stream, buff, l);
+    }
+#endif /* pre 10.5.8 also all other OS */
+#ifdef TRU64
+} while (errno == EINTR);
+#endif
+
+#ifdef TRU64 /* and pre 10.5.8 on all other OS */
+if(chr == EOF && stream->position == 0) return(NULL);
+#else
+if(feof(inStream)) 
+    {
+    clearerr(inStream);
+    if(stream->position == 0) return(NULL);
+    }
+#endif
+return(stream->buffer);
+}
+
+CELL * p_readLine(CELL * params)
+{
+UINT handle;
+unsigned char chr;
+char * line;
+int bytesRead;
+FILE * fstream;
+
+
+if(params != nilCell)
+    getInteger(params, &handle);
+else 
+    handle = printDevice;
+
+#ifdef WINDOWSXXX
+/* make it work as on Unix */
+if(printDevice == 1 || printDevice == 2) handle = 0;
+#endif
+
+/* check if stream input can be done */
+fstream = (handle == 0) ? IOchannel : getIOstream(handle);
+#ifdef LIBRARY
+if(!newlispLibConsoleFlag && fstream == stdin)
+    return(nilCell);
+#endif
+if(fstream != NULL)
+    {
+    if((line = readStreamLine(&readLineStream, fstream)) == NULL)
+        return(nilCell);
+    return(stuffString(line));
+    }
+
+/* do raw handle input, only happens when using read-line on 
+   sockets on UNIX and pipes on Windows  */
+openStrStream(&readLineStream, MAX_STRING, 1);
+while(TRUE)
+    {
+    if((bytesRead = read((int)handle, &chr, 1)) <= 0) break;
+    if(chr == '\n') break;
+    if(chr == '\r')
+        {
+        if(read((int)handle, &chr, 1) < 0) break;
+        if(chr == '\n') break;
+        }
+    writeStreamChar(&readLineStream, chr);
+    }
+
+if(bytesRead <= 0 && readLineStream.position == 0)
+    return(nilCell);
+
+return(stuffStringN(readLineStream.buffer, readLineStream.position));;
+}
+
+
+CELL * p_currentLine(CELL * params)
+{
+return(stuffString(readLineStream.buffer));
+}
+
+
+char * getLocalPath(char * fileName)
+{
+if(my_strnicmp(fileName, "file://", 7) == 0)
+    fileName = fileName + 7;
+
+#ifdef WINDOWS
+if(*fileName == '/' && *(fileName + 2) == ':')
+    fileName = fileName + 1;
+#endif
+
+return(fileName);
+}
+
+
+int openFile(char * fileName, char * accessMode, char * option)
+{
+int blocking = 0;
+#ifndef WINDOWS
+int handle;
+#endif
+
+fileName = getLocalPath(fileName);
+
+#ifndef WINDOWS
+if(option != NULL && *option == 'n')
+    blocking = O_NONBLOCK;
+#endif
+
+if(*accessMode == 'r')
+    return(open(fileName, O_RDONLY | O_BINARY | blocking, 0));
+
+else if(*accessMode == 'w')
+#ifdef WINDOWS
+    return(open( fileName, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE) );
+#else
+    return(open(fileName,O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | blocking, 
+        S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH)); /* rw-rw-rw */
+#endif
+
+else if(*accessMode == 'u')
+    return(open(fileName, O_RDWR | O_BINARY, 0));
+
+else if(*accessMode == 'a')
+       {
+#ifdef WINDOWS
+       return(open(fileName, O_RDWR | O_APPEND | O_BINARY | O_CREAT, S_IREAD | S_IWRITE));
+#else
+       handle = open(fileName, O_RDWR | O_APPEND | O_BINARY | O_CREAT,
+          S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH); /* rw-rw-rw */
+#ifdef EMSCRIPTEN
+       /* oppen append is broken on Emscripten, open for update but filepointer
+          stays at the beginning and old contents is overwritten */
+       if(lseek(handle, 0, SEEK_END) != -1)
+                return(handle);
+#else
+       return(handle);
+#endif
+
+#endif
+       }
+
+return(-1);
+}
+
+/* ------------------------- directory management ------------------------- */
+
+CELL * p_copyFile(CELL * params)
+{
+char * fromName;
+char * toName;
+int fromHandle, toHandle;
+unsigned char * copyBuffer;
+UINT bytesRead;
+
+params = getString(params, &fromName);
+getString(params, &toName);
+
+if((fromHandle = openFile(fromName, "read", NULL)) < 0)
+    return(nilCell);
+
+if((toHandle = openFile(toName,"write", NULL)) < 0)
+    return(nilCell);
+
+copyBuffer = allocMemory(MAX_FILE_BUFFER);
+do
+    {
+    bytesRead = read(fromHandle, copyBuffer, MAX_FILE_BUFFER);
+    if(write(toHandle, copyBuffer, (int)bytesRead) < 0) 
+        fatalError(ERR_IO_ERROR, 0, 0);
+    } while (bytesRead == MAX_FILE_BUFFER);
+
+free(copyBuffer);
+
+close(fromHandle);
+close(toHandle);
+
+return(trueCell);
+}
+
+
+CELL * p_renameFile(CELL * params)
+{
+char *oldName;
+char *newName;
+
+params = getString(params, &oldName);
+getString(params, &newName);
+return(rename(oldName, newName) == 0 ? trueCell : nilCell);
+}
+
+
+CELL * p_deleteFile(CELL * params)
+{
+char * fileName;
+#ifndef EMSCRIPTEN
+CELL * result;
+#endif
+
+params = getString(params, &fileName);
+#ifndef EMSCRIPTEN
+if(my_strnicmp(fileName, "http://", 7) == 0)
+    {
+    result = getPutPostDeleteUrl(fileName, params, HTTP_DELETE, CONNECT_TIMEOUT);
+    return((my_strnicmp((char *)result->contents, (char *)"ERR:", 4) == 0) && netErrorIdx ? nilCell : result);
+    }
+#endif
+
+fileName = getLocalPath(fileName);
+return(unlink(fileName) == 0 ? trueCell : nilCell);
+}
+
+
+CELL * p_makeDir(CELL * params)
+{
+char * dirString;
+UINT mode = 0777; /* drwxrwxrwx  gets user masked to drwxr-xr-x on most UNIX */
+
+/* consume param regardless of OS */
+params = getString(params, &dirString);
+
+if(params != nilCell)
+    {
+    getInteger(params, &mode);
+    mode = mode > 0xfff ? 0xfff : mode;
+    }
+
+#ifdef WINDOWS
+return(mkdir(dirString) == 0 ? trueCell : nilCell);
+#else
+return(mkdir(dirString, (mode_t)mode) == 0 ? trueCell : nilCell);
+#endif
+}
+
+
+CELL * p_removeDir(CELL * params)
+{
+char * dirString;
+
+getString(params, &dirString);
+return(rmdir(dirString) == 0 ? trueCell : nilCell);
+}
+
+
+CELL * p_changeDir(CELL * params)
+{
+char * newDir;
+
+getString(params, &newDir);
+return(chdir(newDir) == 0 ? trueCell : nilCell);
+}
+
+CELL * p_directory(CELL * params)
+{
+CELL * dirList;
+char * dirPath;
+char * fileName;
+char * pattern = NULL;
+INT options = 0;
+DIR * dir;
+struct dirent * dEnt;
+
+if(params != nilCell)
+    {
+    params = getString(params, &dirPath);
+    if(params != nilCell)
+        {
+        params = getString(params, &pattern);
+        if(params != nilCell)
+            /* 10.6.1 also accept string for options */
+            parseRegexOptions(params, (UINT *)&options, TRUE);
+        }
+    }
+else dirPath = ".";
+
+dirList = getCell(CELL_EXPRESSION);
+
+dir = opendir(dirPath);
+if(dir == NULL) return(nilCell);
+
+while((dEnt = readdir(dir)) != NULL)
+    {
+#ifdef USE_WIN_UTF16PATH
+    fileName = utf16_to_utf8(dEnt->d_name);
+#else
+    fileName = dEnt->d_name;
+#endif
+    if(!pattern || searchBufferRegex(fileName, 0, pattern, strlen(fileName), options, NULL) != -1)
+        addList(dirList, stuffString(fileName));
+#ifdef USE_WIN_UTF16PATH
+    free(fileName);
+#endif
+    }
+
+closedir(dir);
+return(dirList);
+}
+
+
+#define DOT_PATH ".\000"
+
+
+CELL * p_realpath(CELL * params)
+{
+char  path[PATH_MAX];
+char * name;
+
+if(params != nilCell)
+    {
+    params = getString(params, &name);
+    if(getFlag(params))
+        {
+        if((name = which(name, alloca(PATH_MAX))) == NULL)
+            return(nilCell);
+        return(stuffString(name));
+        }
+    }
+else name = DOT_PATH;
+
+if(realpath(name, path) == NULL)
+    return(nilCell);
+
+#ifdef _BSD /* behaves like Windows */
+if(isFile(path, 0)) return(nilCell);
+#endif
+
+return(stuffString(path));
+}
+
+CELL * p_fileInfo(CELL * params)
+{
+char * pathName;
+struct stat fileInfo;
+CELL * list;
+int result = 0;
+
+params = getString(params, &pathName);
+
+#ifdef WINDOWS /* has no link-flag */
+#ifdef USE_WIN_UTF16PATH
+result = stat_utf16(pathName, &fileInfo);
+#else
+result = stat(pathName, &fileInfo);
+#endif
+
+#else /* Unix */
+if(getFlag(params->next))
+    result = stat(pathName, &fileInfo);
+else
+    result = lstat(pathName, &fileInfo);
+#endif
+
+if(result != 0)
+    return(nilCell);
+
+list = stuffIntegerList(
+    8,
+    (UINT)fileInfo.st_size,
+    (UINT)fileInfo.st_mode,
+    (UINT)fileInfo.st_rdev,
+    (UINT)fileInfo.st_uid,
+    (UINT)fileInfo.st_gid,
+    (UINT)fileInfo.st_atime,
+    (UINT)fileInfo.st_mtime,
+    (UINT)fileInfo.st_ctime
+    );
+
+#ifndef NEWLISP64
+#ifdef LFS
+((CELL *)list->contents)->type = CELL_INT64;
+*(INT64 *)&((CELL *)list->contents)->aux = (INT64)fileInfo.st_size;
+#endif /* LFS */
+#endif /* NEWLISP64 */
+
+if(params != nilCell)
+    {
+    pushResult(list);
+    return(copyCell(implicitIndexList(list, params)));
+    }
+    
+return(list);
+}
+
+
+#ifdef LFS
+INT64 fileSize(char * pathName)
+#else
+size_t fileSize(char * pathName)
+#endif
+{
+struct stat fileInfo;
+int result;
+
+#ifdef WINDOWS /* has no link-flag */
+#ifdef USE_WIN_UTF16PATH
+result = stat_utf16(pathName, &fileInfo);
+#else
+result = stat(pathName, &fileInfo);
+#endif
+#else /* Unix */
+result = stat(pathName, &fileInfo);
+#endif
+
+if(result != 0) return 0;
+
+return(fileInfo.st_size);
+}
+
+
+/* ------------------------- processes and pipes ------------------------- */
+
+#ifndef WINDOWS
+CELL * p_system(CELL *params)
+{
+char * command;
+getString(params, &command);
+return(stuffInteger((UINT)system(command)));
+}
+#else
+CELL * p_system(CELL *params)
+{
+UINT creation_flags = 0;
+char * command;
+STARTUPINFO si;
+PROCESS_INFORMATION pi;
+UINT result;
+
+memset(&si, 0, sizeof(STARTUPINFO));
+memset(&pi, 0, sizeof(PROCESS_INFORMATION));
+
+si.cb = sizeof(STARTUPINFO);
+
+params = getString(params, &command);
+if(params != nilCell)
+    getInteger(params, &creation_flags);
+else
+    return(stuffInteger((UINT)system(command)));
+
+result = CreateProcessA(NULL, command, NULL, NULL, 0, (DWORD)creation_flags, NULL, NULL, 
+        (LPSTARTUPINFO)&si, (LPPROCESS_INFORMATION)&pi); 
+
+
+if(!result) return(nilCell);
+
+WaitForSingleObject(pi.hProcess, -1);
+CloseHandle(pi.hProcess);
+CloseHandle(pi.hThread); 
+
+return(stuffInteger(result));
+}
+#endif
+
+
+CELL * p_exec(CELL * params)
+{
+CELL * lineList;
+char * line;
+char * command, * data;
+FILE * handle;
+size_t size;
+
+params = getString(params, &command);
+if(params == nilCell)
+    {
+    if((handle = popen(command , "r")) == NULL)
+        return(nilCell);
+
+    lineList = getCell(CELL_EXPRESSION);
+    while((line = readStreamLine(&readLineStream, handle)) != NULL)
+        addList(lineList, stuffString(line));
+
+    pclose(handle);
+    return(lineList);
+    }
+    
+getStringSize(params, &data, &size, TRUE);
+
+if((handle = popen(command, "w")) == NULL)
+    return(nilCell);
+
+if(fwrite(data, 1, (size_t)size, handle) < size)
+    return(nilCell);
+
+pclose(handle);
+return(trueCell);
+}
+
+
+/* parses/splits a string intor substrings separated
+   by spaces, strings containing spaces can be enclosed
+   in either a pair of single or double quotes
+*/
+int init_argv(char * ptr, char *argv[])
+{
+int argc = 0;
+char brkChr;
+
+while(*ptr != 0)
+    {
+    while(*ptr == ' ') ++ptr;
+    if(*ptr == 0) break;
+    if(*ptr == '\'' || *ptr == '"')
+        {
+        brkChr = *ptr;
+        argv[argc++] = ++ptr;
+        while(*ptr != brkChr && *ptr != 0) ++ptr;
+        if(*ptr == 0) break;
+        *ptr++ = 0; 
+        continue;
+        }
+    else
+        {
+        argv[argc++] = ptr++;
+        while(*ptr != ' ' && *ptr != 0) ptr++;
+        if(*ptr == 0) break;
+        *ptr++ = 0;
+        }
+    }
+
+argv[argc] = 0;
+return(argc);
+}
+
+
+#ifndef EMSCRIPTEN
+#ifdef WINDOWS
+int kill(pid_t pid, int sig);
+int winPipe(UINT * inpipe, UINT * outpipe);
+UINT winPipedProcess(char * command, int inpipe, int outpipe, int option);
+UINT plainProcess(char * command, size_t size);
+
+CELL * p_pipe(CELL * params)
+{
+UINT hin, hout;
+IO_SESSION * session;
+
+if(!winPipe(&hin, &hout))    /* see file win-util.c */
+    return(nilCell);
+
+session = createIOsession(hin, AF_UNSPEC);
+session->stream = fdopen(hin, "r");
+session = createIOsession(hout, AF_UNSPEC);
+session->stream = fdopen(hout, "w");
+
+return(stuffIntegerList(2, hin, hout));
+}
+
+
+CELL * p_process(CELL * params)
+{
+char * command;
+int result;
+size_t size;
+
+UINT inpipe = 0, outpipe = 0, option = 1;
+
+params = getStringSize(params, &command, &size, TRUE);
+if(params != nilCell)
+    {
+    params = getInteger(params, (UINT *)&inpipe);
+    params = getInteger(params, (UINT *)&outpipe);
+    if(params != nilCell)
+        getInteger(params, (UINT *)&option);
+	result = winPipedProcess(command, (int)inpipe, (int)outpipe, (int)option);
+    }
+else result = plainProcess(command, size);
+
+if(!result) return(nilCell);
+
+return(stuffInteger(result));
+}
+
+
+#else /* not WINDOWS */
+
+CELL * p_pipe(CELL * params)
+{
+int handles[2];
+#ifndef SUNOS
+IO_SESSION * session;
+#endif
+
+if(pipe(handles) != 0)
+    return(nilCell);
+
+#ifndef SUNOS
+session = createIOsession(handles[0], AF_UNSPEC);
+session->stream = fdopen(handles[0], "r");
+session = createIOsession(handles[1], AF_UNSPEC);
+session->stream = fdopen(handles[0], "w");
+#endif
+
+return(stuffIntegerList(2, (UINT)handles[0], (UINT)handles[1]));
+}
+
+
+CELL * p_process(CELL * params)
+{
+char * command;
+char * cmd;
+int forkResult;
+UINT inpipe = 0, outpipe = 0, errpipe = 0;
+char * argv[16];
+size_t  size;
+
+params = getStringSize(params, &command, &size, TRUE);
+cmd = callocMemory(size + 1);
+memcpy(cmd, command, size + 1);
+
+#ifdef DEBUG_INIT_ARGV
+    int i;
+    init_argv(cmd, argv);
+    for(i = 0; i < 15; i++)
+        {
+        if(argv[i] == NULL) break;
+        printf("->%s<-\n", argv[i]);
+        }
+    return(trueCell);
+#endif
+
+if(params != nilCell)
+    {
+    params = getInteger(params, (UINT *)&inpipe);
+    params = getInteger(params, (UINT *)&outpipe);
+    if(params != nilCell)
+        getInteger(params, (UINT *)&errpipe);
+    }
+
+if((forkResult = fork()) == -1)
+    return(nilCell);
+if(forkResult == 0)
+    {
+    /* redirect stdin and stdout, stderr to pipe handles */
+    if(inpipe)
+        {
+        close(STDIN_FILENO); 
+        if(dup2((int)inpipe, STDIN_FILENO) == -1) exit(0);
+        close((int)inpipe);
+        }
+    if(outpipe)
+        {
+        close(STDOUT_FILENO); 
+        if(dup2((int)outpipe, STDOUT_FILENO) == -1) exit(0);
+        if(!errpipe)
+            if(dup2((int)outpipe, STDERR_FILENO) == -1) exit(0);
+        close((int)outpipe);
+        }
+    if(errpipe)
+        {
+        close(STDERR_FILENO);
+        if(dup2((int)errpipe, STDERR_FILENO) == -1) exit(0);
+        close((int)errpipe);
+        }
+    
+    init_argv(cmd, argv);
+
+    execve(argv[0], argv, environ);
+    exit(0);
+    }
+
+freeMemory(cmd);
+
+return(stuffInteger(forkResult));
+}
+
+#ifndef NO_FORK
+CELL * p_fork(CELL * params)
+{
+int forkResult;
+int ppid = getpid();
+
+if((forkResult = fork()) == -1)
+    return(nilCell);
+if(forkResult == 0)
+    {
+    parentPid = ppid;
+    evaluateExpression(params);
+    exit(0);
+    }
+
+return(stuffInteger(forkResult));
+}
+#endif
+
+/* ------------------------------------------------------------------------- */
+
+
+/* Cilk like interface for spawning and syncronizing child processes
+   spawn - start child
+   sync  - syncronize results
+   abort - abort child
+
+   message - share data with chold and parent
+*/
+
+/* run with or without semaphores */
+
+void * parentPad = NULL;    /* written by parent for this process */
+void * thisPad = NULL;      /* written by this process for the parent */
+int thisSocket = 0;
+fd_set myFdSet;             /* set of all child sockets */
+
+
+#ifndef NO_SPAWN
+
+typedef struct 
+    {
+    void * result_addr; /* written by child */
+    SYMBOL * symbolPtr; /* smbol for result */
+    int pid;            /* childs pid */
+    int socket; 
+    void * next;    
+    } SPAWN_LIST;
+
+SPAWN_LIST * mySpawnList = NULL;
+
+void addSpawnedChild(void * addr, SYMBOL * sPtr, int pid, int socket)
+{
+SPAWN_LIST * spawnList;
+
+spawnList = (SPAWN_LIST  *)allocMemory(sizeof(SPAWN_LIST));
+
+spawnList->result_addr = addr;
+spawnList->symbolPtr = sPtr;
+spawnList->pid = pid;
+spawnList->socket = socket;
+spawnList->next = NULL;
+
+if(mySpawnList == NULL)
+    mySpawnList = spawnList;
+else/* insert in front */
+    {
+    spawnList->next = mySpawnList;
+    mySpawnList = spawnList;
+    }
+}
+
+
+SPAWN_LIST * getSpawnedChild(int pid)
+{
+SPAWN_LIST * spawnList = mySpawnList;
+
+while(spawnList != NULL)
+    {
+    if(spawnList->pid == pid) break;
+    spawnList = spawnList->next;
+    }
+
+return(spawnList);
+}
+
+void purgeSpawnList(int sockFlag)
+{
+SPAWN_LIST * spawnList;
+
+/* pop and delete entries */
+
+while(mySpawnList != NULL)
+    {
+    if(sockFlag)
+        close(mySpawnList->socket);
+    spawnList = mySpawnList->next;
+    free(mySpawnList);
+    mySpawnList = spawnList;
+    }
+}
+
+/* lookup pid get result from shared memory and delete entry */
+
+#define PROCESS_SPAWN_RESULT 0
+#define PROCESS_SPAWN_ABORT 1
+#define PROCESS_SPAWN_ABNORMAL_END 2
+#define ABEND "ERR: abnormal process end"
+
+void processSpawnList(int pid, int mode, int result)
+{
+SPAWN_LIST * pidSpawn;
+SPAWN_LIST * previousSpawn;
+CELL * cell;
+SYMBOL * sPtr;
+char str[32];
+
+pidSpawn = previousSpawn = mySpawnList;
+
+while(pidSpawn)
+    {
+    if(pidSpawn->pid == pid)
+        {
+        if(pidSpawn == mySpawnList)
+            mySpawnList = pidSpawn->next;
+        else
+            previousSpawn->next = pidSpawn->next;
+
+        if(mode == PROCESS_SPAWN_RESULT)
+            {
+            cell = readWriteShared(pidSpawn->result_addr, nilCell, 0);
+            sPtr = pidSpawn->symbolPtr;
+            deleteList((CELL *)sPtr->contents);
+            sPtr->contents = (UINT)cell;
+            }
+        else if(mode == PROCESS_SPAWN_ABORT)
+            {
+            FD_CLR(pidSpawn->socket, &myFdSet);
+            kill(pidSpawn->pid, 9);
+            waitpid(pidSpawn->pid, (int *)0, 0);
+            }
+        else /* PROCESS_SPAWN_ABNORMAL_END */
+            {
+            sPtr = pidSpawn->symbolPtr;
+            deleteList((CELL *)sPtr->contents);
+            snprintf(str, 32, "%s %d", ABEND, result);
+            sPtr->contents = (UINT)stuffString(str);
+            }
+           
+	/* close parent socket */
+        if(pidSpawn->socket) close(pidSpawn->socket); 
+        checkDeleteShareFile(pidSpawn->result_addr);
+        /* unmap shared result memory */
+        munmap(pidSpawn->result_addr, pagesize);
+        free((char *)pidSpawn);
+        break;
+        }
+    previousSpawn = pidSpawn;
+    pidSpawn = pidSpawn->next;
+    }
+}
+
+/* spawn (fork) a process and assign result to the symbol given
+     (spawn <quoted-symbol> <epxression>) => pid
+   creates a memory share and passes it to the spawned process
+   when the spawned child finishes, it copies the result
+   to the memory share. If the result does not fit in the pagesize
+   store the result in a file with a unique filename which is
+   stored in the memory share. The first int32 word is -1 for
+   memshare store or 0 for file store.
+   For house keeping purpose SPAWN_LIST is maintained to find
+   the memshare adddress from the child pid.
+*/
+CELL * p_spawn(CELL * params)
+{
+int forkPid;
+int pid;
+void * address; /* share memory area for result */
+SYMBOL * symPtr;
+int sockets[2] = {0, 0};
+
+if((address = mmap( 0, pagesize, 
+    PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0)) == (void*)-1)
+        return(nilCell);
+
+memset(address, 0, sizeof(INT));
+
+params = getSymbol(params, &symPtr);
+if(isProtected(symPtr->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symPtr)));
+deleteList((CELL *)symPtr->contents);
+symPtr->contents = (UINT)nilCell;
+
+pid = getpid();
+
+/* socketpair for send/receive API is optional */
+if(getFlag(params->next))
+    {
+    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == -1) 
+        {
+        munmap(address, pagesize);
+        return(errorProc(ERR_CANNOT_OPEN_SOCKETPAIR)); 
+        }
+
+    /* add the parent socket to myFdSet */ 
+    if(mySpawnList == NULL)
+        FD_ZERO(&myFdSet);
+    FD_SET(sockets[0], &myFdSet);
+    }
+
+/* make signals processable by waitpid() in p_sync() */
+signal(SIGCHLD, SIG_DFL);
+
+if((forkPid = fork()) == -1)
+    {
+    if(sockets[0]) close(sockets[0]);
+    if(sockets[1]) close(sockets[1]);
+    munmap(address, pagesize);
+    return(nilCell);
+    }
+
+if(forkPid == 0) /* the child process */
+    {
+    /* seed random generator for message fail delay */
+    srandom(getpid()); 
+    /* get parent pid */
+    parentPid = pid;
+    if(sockets[0]) close(sockets[0]);
+    thisSocket = sockets[1];
+    /* purge inherited spawnlist */
+    purgeSpawnList(FALSE);
+    /* evaluate and write result to shared memory */
+    readWriteShared(address, params, TRUE);
+    /* close child socket */
+    if(thisSocket) close(thisSocket);
+    exit(0);
+    }
+
+if(sockets[1]) close(sockets[1]);
+addSpawnedChild(address, symPtr, forkPid, sockets[0]);
+
+return(stuffInteger(forkPid));
+}
+
+/* wait for spawned processes to finish for the timeout specified:
+     (sync <timeout-milli-seconds>) => true
+   if no timeout is not specified only return a list of pending
+   child pids:
+     (sync) => list of pids
+   For each finished child get the result and assign it to the 
+   symbol looked up in SPAWN_LIST.
+*/
+CELL * p_sync(CELL * params)
+{
+int result;
+int pid;
+UINT timeout = 0;
+struct timeval tv, tp;
+SPAWN_LIST * spawnList;
+CELL * resultList = getCell(CELL_EXPRESSION);
+int inletFlag = 0;
+UINT * resultIdxSave;
+CELL * cell;
+
+if(mySpawnList == NULL)
+    return(resultList); /* nothing pending */
+
+if(params == nilCell)
+    {
+    spawnList = mySpawnList;
+    while(spawnList != NULL)
+        {
+        addList(resultList, stuffInteger(spawnList->pid));
+        spawnList = spawnList->next;
+        }
+    return(resultList);
+    }
+
+deleteList(resultList);
+
+params = getInteger(params, &timeout);
+if(params == nilCell || isNil((CELL *)((SYMBOL *)params->contents)->contents))
+    signal(SIGCHLD, SIG_DFL);
+else
+    inletFlag = TRUE;
+    
+gettimeofday(&tv, NULL);
+
+while(mySpawnList != NULL)
+    {
+    gettimeofday(&tp, NULL);
+    if(timediff_ms(tp, tv) > timeout) return(nilCell);
+    /* wait for any child process to finish */
+    pid = waitpid(-1, &result, WNOHANG); 
+    if(pid) 
+        {
+        if(!WIFEXITED(result))
+            processSpawnList(pid, PROCESS_SPAWN_ABNORMAL_END, result);
+        else
+            processSpawnList(pid, PROCESS_SPAWN_RESULT, 0);
+        if(inletFlag)
+            {
+            resultIdxSave = resultStackIdx;
+            pushResult(cell = makeCell(CELL_EXPRESSION, (UINT)copyCell(params)));
+            ((CELL *)cell->contents)->next = stuffInteger((UINT)pid);
+            evaluateExpression(cell);
+            cleanupResults(resultIdxSave);
+            }
+        }
+    }
+
+/* put initial behaviour back */
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX) 
+setupSignalHandler(SIGCHLD, sigchld_handler);
+#else
+setupSignalHandler(SIGCHLD, signal_handler);
+#endif
+
+return(trueCell);
+}
+
+/* if abort a specific pid if specified:
+     (abort <pid>)
+   or abort all:
+     (abort)
+*/
+
+CELL * p_abort(CELL * params)
+{
+UINT pid;
+ 
+if(params != nilCell)
+    {
+    getInteger(params, &pid);
+    processSpawnList(pid, PROCESS_SPAWN_ABORT, 0);
+    }
+else /* abort all */
+    {
+    while(mySpawnList != NULL) 
+        processSpawnList(mySpawnList->pid, PROCESS_SPAWN_ABORT, 0);
+    /* put initial behaviour back */
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX) 
+   setupSignalHandler(SIGCHLD, sigchld_handler);
+#else
+    setupSignalHandler(SIGCHLD, signal_handler);
+#endif
+}
+
+return(trueCell);
+}
+
+#define SELECT_READ_READY 0
+#define SELECT_WRITE_READY 1
+
+CELL * getSelectReadyList(int mode)
+{
+CELL * pidList = getCell(CELL_EXPRESSION);
+SPAWN_LIST * child;
+int ready = 0;
+struct timeval tv;
+fd_set thisFdSet;
+
+tv.tv_sec = 0;
+tv.tv_usec = 892 + random() / 10000000;
+
+#if defined(SUNOS) || defined(LINUX) || defined(CYGWIN) || defined(AIX) 
+memcpy(&thisFdSet, &myFdSet, sizeof(fd_set));
+#else
+FD_COPY(&myFdSet, &thisFdSet);
+#endif
+
+if(mode == SELECT_READ_READY)
+    ready = select(FD_SETSIZE, &thisFdSet, NULL, NULL, &tv);
+else /* SELECT_WRITE_READY */
+    ready = select(FD_SETSIZE, NULL, &thisFdSet, NULL, &tv);
+
+if(ready == 0) return(pidList);
+
+if(ready < 0) 
+    return(pidList);
+
+child = mySpawnList;
+while (child != NULL)
+    {
+    if(FD_ISSET(child->socket, &thisFdSet))
+         addList(pidList, stuffInteger(child->pid)); 
+    child = child->next;
+    }
+
+return(pidList);
+}
+     
+
+CELL * p_send(CELL * params)
+{
+UINT pid;
+CELL * result = nilCell;
+SPAWN_LIST * child = NULL;
+int socket;
+
+/* return list of writable child pids */
+if(params == nilCell) 
+    return(getSelectReadyList(SELECT_WRITE_READY));
+
+params = getInteger(params, &pid);
+
+if(pid == parentPid) /* write to parent */
+    {
+    socket = thisSocket;
+    }
+else  /* write to child */
+    {
+    if((child = getSpawnedChild(pid)) == NULL)
+        errorProcExt2(ERR_INVALID_PID, stuffInteger(pid));
+    socket = child->socket;
+    }
+
+if(!socket)
+    errorProc(ERR_NO_SOCKET);
+
+if(params == nilCell)
+    errorProc(ERR_MISSING_ARGUMENT);
+
+result = readWriteSocket(socket, params);
+
+return(result);
+}
+
+
+CELL * p_receive(CELL * params)
+{
+UINT pid;
+CELL * cell;
+SPAWN_LIST * child = NULL;
+SYMBOL * sPtr = NULL;
+int socket;
+
+/* return list of readable child pids */
+if(params == nilCell) 
+    return(getSelectReadyList(SELECT_READ_READY));
+
+params = getInteger(params, &pid);
+
+if(params != nilCell)
+    {
+    getEvalDefault(params, &cell);
+    if(!symbolCheck)
+        return(errorProc(ERR_IS_NOT_REFERENCED));
+    if(isProtected(symbolCheck->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+    if(symbolCheck->contents != (UINT)cell)
+        return(errorProc(ERR_IS_NOT_REFERENCED));
+    sPtr = symbolCheck;
+    }
+
+/* read from parent */
+if(pid == parentPid)
+    {
+    socket = thisSocket;
+    }
+else  /* read from child */
+    {
+    if((child = getSpawnedChild(pid)) == NULL)
+        errorProcExt2(ERR_INVALID_PID, stuffInteger(pid));
+        socket = child->socket;
+    }
+
+if(!socket)
+    errorProc(ERR_NO_SOCKET);
+
+cell = readWriteSocket(socket, nilCell);
+if(cell == nilCell)
+    return(nilCell);
+
+/* if no msg variable is given make message the return value */
+if(sPtr == NULL)
+    return(cell);
+
+deleteList((CELL *)sPtr->contents);
+sPtr->contents = (UINT)cell;
+pushResultFlag = FALSE;
+
+return(trueCell);
+}
+
+
+/* evaluate expression in params and write to socket,
+   part of a socket pair. Similar to readWriteShare()
+   but uses sockets instead od shared memory */
+   
+CELL * readWriteSocket(int socket, CELL * params)
+{
+char * buffer;
+CELL * cell;
+STREAM strStream = {NULL, NULL, 0, 0, 0};
+UINT length;
+ssize_t size, bytesReceived;
+struct timeval tv;
+fd_set fdset;
+int ready;
+
+tv.tv_sec = 0;
+tv.tv_usec = 892 + random()/10000000;
+
+FD_ZERO(&fdset);
+FD_SET(socket, &fdset);
+
+if(params != nilCell) /* send message, write */
+    {
+    /* ready = select(socket, NULL, &fdset, NULL, &tv); */
+    ready = select(FD_SETSIZE, NULL, &fdset, NULL, &tv); 
+    /* ready = FD_ISSET(socket, &fdset) */
+    if(ready == 1)
+        {
+        cell = evaluateExpression(params);
+        if(cell->type == CELL_EXPRESSION)
+            size = 128;
+        else
+            size = 32;
+        openStrStream(&strStream, size, 0);
+        prettyPrintFlags |= PRETTYPRINT_STRING;
+        printCell(cell , TRUE, (UINT)&strStream);
+        prettyPrintFlags &= ~PRETTYPRINT_STRING;
+        length = strStream.position;
+        if(send(socket, &length, sizeof(UINT), 0) ==  sizeof(UINT))
+            {
+            size = send(socket, strStream.buffer, strStream.position, 0);
+            if(size == strStream.position)
+                {
+                closeStrStream(&strStream);
+                return(trueCell);
+                }
+            /* caller should check errno using (sys-error) */
+            closeStrStream(&strStream);
+            return(nilCell);
+            }
+        }
+    else
+        {
+        /* timeout, socket not ready */
+        return(nilCell);
+        }
+    }
+/* receive message, read */
+/* ready = select(socket, &fdset, NULL, NULL, &tv); */
+ready = select(FD_SETSIZE, &fdset, NULL, NULL, &tv);
+/* ready = FD_ISSET(socket, &fdset) */
+if(ready == 1)
+    {
+    if((size = recv(socket, &length, sizeof(UINT), 0)) == sizeof(UINT))
+        {
+        buffer = callocMemory(length + 1);
+        bytesReceived = 0;
+        while(bytesReceived < length)
+            {
+            size = recv(socket, buffer + bytesReceived, length - bytesReceived, 0);
+            if(size == -1)
+                {
+                free(buffer);
+                return(nilCell);
+                }
+            bytesReceived += size; 
+            }
+        cell = sysEvalString(buffer, currentContext, nilCell, READ_EXPR_SYNC);
+        free(buffer);
+        return(cell);
+        }
+    }
+
+return(nilCell);
+}
+
+#endif /* NO_SPAWN */
+
+/* --------------------------- end Cilk ------------------------------------- */
+
+
+extern SYMBOL * symHandler[];
+
+CELL * p_waitpid(CELL * params)
+{
+UINT pid, options;
+int result, retval;
+
+symHandler[SIGCHLD - 1] = nilSymbol;
+signal(SIGCHLD, SIG_DFL);
+
+params = getInteger(params, (UINT *)&pid);
+if(params != nilCell)
+    {
+    params = evaluateExpression(params);
+    if(isNil(params))
+        options = WNOHANG;
+    else
+        getIntegerExt(params, (UINT *)&options, FALSE);
+    }
+else
+    options = 0;
+
+retval = waitpid((int)pid, &result , (int)options);
+
+return(stuffIntegerList(2, (UINT)retval, (UINT)result));
+}
+
+#endif
+
+CELL * p_destroyProcess(CELL * params)
+{
+UINT pid;
+UINT sig;
+
+params = getInteger(params, &pid);
+if(params != nilCell)   
+    getInteger(params, &sig);
+else
+    sig = 9;
+
+if(kill(pid, sig) != 0)
+    return(nilCell);
+
+return(trueCell);
+}
+
+/* ------------------------------ semaphores --------------------------------- */
+#ifndef NO_SEMAPHORE
+#ifdef WINDOWS
+
+UINT winCreateSemaphore(void);
+UINT winWaitSemaphore(UINT hSemaphore);
+UINT winSignalSemaphore(UINT hSemaphore, int count);
+UINT winDeleteSemaphore(UINT hSemaphore);
+int getSemaphoreCount(UINT hSemaphore);
+
+CELL * p_semaphore(CELL * params)
+{
+UINT sem_id;
+INT value;
+
+if(params != nilCell)
+    {
+    params = getInteger(params, &sem_id);
+    if(params != nilCell)
+        {
+        getInteger(params,(UINT *)&value);
+        if(value == 0)
+            {
+            if(!winDeleteSemaphore(sem_id)) 
+                return(nilCell);
+            return(trueCell);
+            }
+
+        /* wait or signal */
+        if(value < 0)
+            {
+            if(winWaitSemaphore(sem_id)) return(trueCell);
+            return(nilCell);
+            }
+        if(value > 0)
+            {
+            if(winSignalSemaphore(sem_id, value)) return(trueCell);
+            return(nilCell);    
+            }
+        }
+
+    else
+        {
+        /* return semaphore value, not on Win32 ? */
+        return(nilCell);
+        }
+    }
+
+/* create semaphore */
+if((sem_id = winCreateSemaphore()) == 0) return(nilCell);
+return(stuffInteger(sem_id));
+}
+#else /* Mac OS X, Linux/UNIX */
+
+CELL * p_semaphore(CELL * params)
+{
+INT sem, value, result;
+
+if(params == nilCell)
+    {
+    result = semaphore(0, 0, SEM_CREATE);
+    goto SEMAPHORE_END;
+    }
+
+params = getInteger(params, (UINT *)&sem);
+if(params == nilCell)
+    {
+    result = semaphore(sem, 0, SEM_STATUS);
+    goto SEMAPHORE_END;
+    }
+
+getInteger(params, (UINT *)&value);
+    {
+    result = semaphore(sem, value, SEM_SIGNAL);
+    if(result != -1) return(trueCell);
+    }
+
+SEMAPHORE_END:
+if(result == -1) return(nilCell);
+return(stuffInteger((UINT)result));
+}
+
+
+int semaphore(UINT sem_id, int value, int type)
+{
+struct sembuf sem_b;
+#ifdef SPARC
+#ifndef NEWLISP64
+int semun_val = 0;
+#endif
+#endif
+
+#ifdef MAC_OSX
+union semun semu;
+
+semu.val = 0;
+#endif
+
+if(type != SEM_CREATE)
+    {
+    if(type == SEM_SIGNAL)
+        {
+        if(value == 0)
+            {
+            /* remove semaphore */
+#ifdef SPARC
+    #ifndef NEWLISP64
+            if(semctl(sem_id, 0, IPC_RMID, &semun_val) == -1) /* SPARC 32 */
+    #else 
+            if(semctl(sem_id, 0, IPC_RMID, 0) == -1) /* SPARC 64 */
+    #endif
+
+#else /* not SPARC */
+    #ifdef MAC_OSX
+            if(semctl(sem_id, 0, IPC_RMID, semu) == -1) /* MAC_OSX */
+    #else
+            if(semctl(sem_id, 0, IPC_RMID, 0) == -1) /* LINUX, BSD, TRU64 */
+    #endif /* not MAC_OSX */
+#endif /* not SPARC */
+                return(-1);
+            return(0);
+            }
+
+        /* wait or signal */
+        sem_b.sem_num = 0;
+        sem_b.sem_op = value;
+        sem_b.sem_flg = 0; 
+        if(semop(sem_id, &sem_b, 1) == -1)
+            return(-1);
+        return(0);
+        }
+
+    else
+        /* return semaphore value */
+#ifdef MAC_OSX
+        return(semctl(sem_id, 0, GETVAL, semu));
+#else
+        return(semctl(sem_id, 0, GETVAL, 0));
+#endif
+    }
+
+/* create semaphore */
+sem_id = semget(IPC_PRIVATE, 1, 0666 );
+
+#ifdef SPARC
+  #ifndef NEWLISP64
+if(semctl(sem_id, 0, SETVAL, &semun_val) == -1) /* SPARC 32 */
+  #else
+if(semctl(sem_id, 0, SETVAL, 0) == -1) /* SPARC 64 */
+  #endif
+#else /* not SPARC */
+ #ifdef MAC_OSX
+if(semctl(sem_id, 0, SETVAL, semu) == -1) /* MAC_OSX */
+ #else
+if(semctl(sem_id, 0, SETVAL, 0) == -1) /* LINUX, BSD, TRU64 */
+ #endif /* not MAC_OSX */
+#endif /* not SPARC */
+    return(-1);
+
+return(sem_id);
+}
+
+#endif /* MAC OSX, Unix, Linux */
+#endif /* NO_SEMAPHORE */
+
+
+#ifndef NO_SHARE
+
+#ifdef WINDOWS
+UINT winSharedMemory(int size);
+UINT * winMapView(UINT handle, int size);
+#endif
+
+/* since 10.1.0 also can share object > pagesize
+   objects are stored in the tmp directory of OS
+   as a file starting with nls-
+*/
+
+CELL * p_share(CELL * params)
+{
+void * address;
+CELL * cell;
+#ifdef WINDOWS
+UINT handle;
+#endif
+
+/* read write  or release (UNIX) shared memory */
+if(params != nilCell) 
+    {
+    cell = evaluateExpression(params);
+#ifndef WINDOWS
+    if(isNil(cell)) /* release shared address */
+        {
+        getInteger(params->next, (UINT *)&address);
+        checkDeleteShareFile(address);
+        if(munmap(address, pagesize) == -1)
+            return(nilCell);
+        else
+            return(trueCell);
+        }
+#endif
+    getIntegerExt(cell, (UINT *)&address, FALSE);
+    params = params->next;
+#ifdef WINDOWS
+    if((address = winMapView((UINT)address, pagesize)) == NULL)
+        return(nilCell);
+#endif
+    return(readWriteShared(address, params, 0));
+    }
+
+/* get shared memory UNIX */
+#ifndef WINDOWS
+if((address = (UINT*)mmap(
+    0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0)) == (void*)-1)
+        return(nilCell);
+
+memset((char *)address, 0, pagesize);
+return(stuffInteger((UINT)address));
+
+/* get shared memory WINDOWS */
+#else 
+
+if((handle = winSharedMemory(pagesize)) == 0)
+    return(nilCell);
+
+if((address = winMapView(handle, pagesize)) == NULL)
+    return(nilCell);
+
+memset((char *)address, 0, pagesize);
+return(stuffInteger(handle));
+#endif
+}
+#endif /* NO_SHARE  */
+
+/* evaluate the expression in params and the write the result
+   to shared memory. If size > pagesize use files tmp files
+   for transfer. For atomic datatypes are xlation into message
+   optimized for speed (but doesn't bring much in overall
+   performance, should perhaps be taken out and only use
+   readWriteSharedExpression() */
+CELL * readWriteShared(UINT * address, CELL * params, int flag)
+{
+CELL * cell;
+size_t size;
+char * str;
+int errNo;
+
+/* write to shared memory */
+if(params != nilCell) 
+    {
+    if(flag) /* in spawned process */
+        {
+        if((cell = evaluateExpressionSafe(params, &errNo)) == NULL)
+            cell = stuffString(errorStream.buffer);
+        }
+    else 
+        cell = evaluateExpression(params);
+
+    /* if a previous share mem file is still present, delete it
+       when *address == 0 when called from Cilk then file is
+       deleted p_message(). Here only used from p_share() */
+    if(*address == (CELL_STRING | SHARED_MEM_EVAL_MASK))
+        checkDeleteShareFile(address);
+
+    /* write anything not bool, number or string */
+    if((cell->type & COMPARE_TYPE_MASK) > (CELL_STRING & COMPARE_TYPE_MASK))
+        return(copyCell(readWriteSharedExpression(address, cell)));
+
+    switch(cell->type)
+        {
+        case CELL_NIL:
+            *address = cell->type;
+#ifdef WINDOWS
+            UnmapViewOfFile(address);
+#endif
+            return(nilCell);
+        case CELL_TRUE:
+            *address = cell->type;
+#ifdef WINDOWS
+            UnmapViewOfFile(address);
+#endif
+            return(trueCell);
+        case CELL_LONG:
+            *(address + 1) = sizeof(INT);
+            *(address + 2) = cell->contents;
+            break;
+#ifndef NEWLISP64
+        case CELL_INT64:
+            *(address + 1) = sizeof(INT64);
+            memcpy(address + 2, (void *)&cell->aux, sizeof(INT64));
+            break;
+        case CELL_FLOAT:
+            *(address + 1) = sizeof(double);
+            *(address + 2) = cell->aux;
+            *(address + 3) = cell->contents;
+            break;
+#else /* NEWLISP64 */
+        case CELL_FLOAT:
+            *(address + 1) = sizeof(double);
+            *(address + 2) = cell->contents;
+            break;
+#endif /* NEWLISP64 */
+        case CELL_STRING:
+            getStringSize(cell, &str, &size, FALSE);
+            if(size > (pagesize - 3 * sizeof(INT)))
+                return(copyCell(readWriteSharedExpression(address, cell)));
+
+            *(address + 1) = size;
+            memcpy((char *)(address + 2), str, size);
+            *((char *)address + 2 * sizeof(INT) + size) = 0;
+            break;
+        default:
+            return(errorProcExt(ERR_ILLEGAL_TYPE, cell));
+        }
+
+    *address = cell->type;
+#ifdef WINDOWS
+    UnmapViewOfFile(address);
+#endif
+    return(copyCell(cell));
+    }
+
+/* read shared memory */
+switch(*address & RAW_TYPE_MASK)
+    {
+    case CELL_NIL:
+#ifdef WINDOWS 
+        UnmapViewOfFile(address);
+#endif
+        return(nilCell);
+    case CELL_TRUE:
+#ifdef WINDOWS 
+        UnmapViewOfFile(address);
+#endif
+        return(trueCell);   
+    case CELL_LONG:
+        cell = stuffInteger(*(address + 2));
+        break;
+#ifndef NEWLISP64
+    case CELL_INT64:
+        cell = stuffInteger64(*(INT64 *)(address + 2));
+        break;
+#endif
+    case CELL_FLOAT:
+#ifndef NEWLISP64
+        cell = getCell(CELL_FLOAT);
+        cell->aux = *(address + 2);
+        cell->contents = *(address + 3);
+#else
+        cell = getCell(CELL_FLOAT);
+        cell->contents = *(address + 2);
+#endif
+        break;
+    case CELL_STRING:
+        if(*address & SHARED_MEM_EVAL_MASK)
+            return(readWriteSharedExpression(address, nilCell));
+        size = *(address + 1);
+        cell = makeStringCell(allocMemory(size + 1), size);
+        memcpy((char *)cell->contents, (char*)(address + 2), cell->aux);
+        break;
+    default:
+        return(nilCell);
+    }
+
+#ifdef WINDOWS
+        UnmapViewOfFile(address);
+#endif
+return(cell);
+}
+
+
+/* Takes anything and passes as string or file which has to
+   be compiled back into expression when reading.
+   Returns a new cell object on read, old on write
+*/
+
+CELL * readWriteSharedExpression(UINT * address, CELL * params)
+{
+ssize_t size;
+STREAM strStream = {NULL, NULL, 0, 0, 0};
+CELL * cell;
+char * buffer = NULL;
+/* int errNo; */
+
+/* read */
+if(params == nilCell)
+    {
+    size = *(address + 1);
+    if(size < (pagesize - 3 * sizeof(INT) ))
+        {   
+        cell = sysEvalString((char *)(address + 2), 
+                currentContext, nilCell, READ_EXPR_SYNC);
+        }
+    else 
+        {
+        if((size = readFile((char *)(address + 2), &buffer)) != -1)
+            cell = sysEvalString(buffer, currentContext, nilCell, READ_EXPR_SYNC);
+        else cell = nilCell;
+        }
+
+    if(buffer != NULL) free(buffer); 
+    return(cell);
+    }
+
+/* write */
+cell = params;
+openStrStream(&strStream, MAX_STRING, 0);
+prettyPrintFlags |= PRETTYPRINT_STRING;
+printCell(cell , TRUE, (UINT)&strStream);
+prettyPrintFlags &= ~PRETTYPRINT_STRING;
+
+*(address + 1) = strStream.position;
+
+if(strStream.position < pagesize - 3 * sizeof(INT))
+    {
+    memcpy((char *)(address + 2), strStream.buffer, strStream.position);
+    *((char *)address + 2 * sizeof(INT) + strStream.position) = 0;
+    }
+else
+    {
+    checkDeleteShareFile(address);
+    memset((char *)(address + 2), 0, pagesize - 2 * sizeof(INT));
+    strncpy((char *)(address + 2), tempDir, PATH_MAX - 2 * sizeof(INT));
+    strncat((char *)(address + 2), "/nls-", 6);
+    size = strlen((char *)(address + 2));
+    getUUID((char *)(address + 2) + size, 0);
+    writeFile((char *)(address + 2), strStream.buffer, strStream.position, "w");
+    }
+closeStrStream(&strStream);
+
+*address = (CELL_STRING | SHARED_MEM_EVAL_MASK);
+return(cell);
+}
+
+void checkDeleteShareFile(UINT * address)
+{
+if(     (*address == (CELL_STRING | SHARED_MEM_EVAL_MASK)) &&
+#ifndef WINDOWS
+#ifdef ANDROID
+        (strncmp((char *)(address + 2), "/data/tmp/nls-", 9) == 0) &&
+#else
+        (strncmp((char *)(address + 2), "/tmp/nls-", 9) == 0) &&
+#endif
+        (strlen((char *)(address + 2)) == 45) )
+#else
+        (strncmp((char *)(address + 2), "/temp/nls-", 10) == 0) &&
+        (strlen((char *)(address + 2)) == 46) )
+#endif
+    unlink((char *)(address + 2)); 
+}
+#endif /* ifndef EMSCRIPTEN */
+
+extern int ADDR_FAMILY;
+CELL * p_systemInfo(CELL * params)
+{
+CELL * cell;
+
+cell = stuffIntegerList(
+    10,
+    cellCount,
+    MAX_CELL_COUNT,
+    symbolCount,
+    (UINT)recursionCount,
+    (UINT)(envStackIdx - envStack)/sizeof(UINT),
+    (UINT)MAX_CPU_STACK,
+    (UINT)parentPid,
+    (UINT)getpid(),
+    (UINT)version,
+    (UINT)opsys
+    );
+
+if(params != nilCell)   
+    {
+    pushResult(cell);
+    return(copyCell(implicitIndexList(cell, params)));
+    }
+
+return(cell);
+}
+
+
+CELL * p_systemError(CELL * params)
+{
+CELL * cell;
+UINT errnum = errno;
+
+if(params != nilCell)
+    {
+    getInteger(params, &errnum);
+    if(errnum == 0) errno = 0;
+    }
+else 
+    if(!errnum) return(nilCell);
+
+cell = makeCell(CELL_EXPRESSION, (UINT)stuffInteger(errnum));
+((CELL *)cell->contents)->next = stuffString(strerror(errnum));
+
+/* on some platforms strerror(0) causes errno set to 22 */
+if(errnum == 0) errno = 0;
+
+return(cell);
+}
+
+/* ------------------------------ time and date functions -------------------- */
+CELL * p_date(CELL * params)
+{
+time_t t;
+struct tm * ltm;
+char * ct;
+char * fmt;
+ssize_t offset;
+/* time_t tme; 10.6.1. */
+UINT tme;
+size_t size;
+
+#ifdef SUPPORT_UTF8
+#ifdef WCSFTIME
+int * ufmt;
+int * timeString;
+#endif
+char * utf8str;
+#else
+char * timeString;
+#endif
+
+if(params == nilCell)
+    t = (time_t)currentDateValue();
+else
+    {
+    /* 10.6.1 */
+    params = getInteger(params, &tme);
+    t = (time_t)tme;
+    
+    if(params != nilCell)
+        {
+        params = getInteger(params, (UINT *)&offset);
+            t += (int)offset * 60;
+        }
+        
+    if(params != nilCell)
+        {
+        params = getStringSize(params, &fmt, &size, TRUE);
+        ltm = localtime(&t);
+#ifdef SUPPORT_UTF8
+    /* some Linux do UTF-8 but don't have wcsftime() or it is buggy */
+#ifdef WCSFTIME
+        size = utf8_wlen(fmt, fmt + size + 1);
+        ufmt = alloca(UTF8_MAX_BYTES * (size + 1));
+        utf8_wstr(ufmt, fmt, size);
+
+        timeString = alloca(UTF8_MAX_BYTES * 128);
+        size = wcsftime((wchar_t *)timeString, 127, (wchar_t *)ufmt, ltm);
+        utf8str = alloca(size * UTF8_MAX_BYTES + 1);
+        size =  wstr_utf8(utf8str, timeString, size * UTF8_MAX_BYTES);
+        return(stuffString(utf8str));
+#else
+        utf8str = alloca(128);
+        strftime(utf8str, 127, fmt, ltm);
+        return(stuffString(utf8str));
+#endif /* WCSFTIME */
+
+#else
+        timeString = alloca(128);
+        strftime(timeString, 127, fmt, ltm);
+        return(stuffString(timeString));
+#endif
+        }
+    }
+
+ct = ctime(&t);
+if(ct == NULL) return(nilCell);
+
+ct[strlen(ct) - 1] = 0;  /* supress linefeed */
+return(stuffString(ct));
+}
+
+INT64 microSecTime(void)
+{
+struct timeval tv;
+struct tm * ttm;
+time_t sec;
+
+gettimeofday(&tv, NULL);
+sec = tv.tv_sec;
+ttm = localtime(&sec);
+
+return (ttm->tm_hour * 3600000000LL + 
+       ttm->tm_min * 60000000LL + ttm->tm_sec * 1000000 + 
+       tv.tv_usec);
+}
+
+
+int milliSecTime(void)
+{
+return(microSecTime()/1000);
+}
+
+
+/* returns a differerence of 2 timeval structs in milliseconds
+*/
+int timediff_ms(struct timeval out, struct timeval in )
+{
+    if( (out.tv_usec -= in.tv_usec) < 0 )   {
+        out.tv_sec--;
+        out.tv_usec += 1000000;
+    }
+    out.tv_sec -= in.tv_sec;
+
+return(out.tv_sec*1000 + (out.tv_usec/1000));
+}
+
+
+/* returns a differerence of 2 timeval structs in microseconds
+*/
+UINT64 timediff64_us(struct timeval out, struct timeval in )
+{
+UINT64 usec;
+
+    if( (out.tv_usec -= in.tv_usec) < 0 )   {
+        out.tv_sec--;
+        out.tv_usec += 1000000;
+    }
+    out.tv_sec -= in.tv_sec;
+
+usec = (UINT64)1000000 * out.tv_sec + out.tv_usec;
+return(usec);
+}
+
+#ifndef WINDOWS
+CELL * p_dateParse(CELL * params)
+{
+struct tm ttm;
+char * dateStr;
+char * formatStr;
+time_t dateValue;
+
+params = getString(params, &dateStr);
+getString(params, &formatStr);
+
+memset (&ttm, 0, sizeof (ttm));
+ttm.tm_mday = 1;
+
+if(strptime(dateStr, formatStr, &ttm) == NULL)
+    return(nilCell);
+
+dateValue = calcDateValue(
+        ttm.tm_year + 1900,
+        ttm.tm_mon + 1,
+        ttm.tm_mday,
+        ttm.tm_hour,
+        ttm.tm_min,
+        ttm.tm_sec);
+
+return(stuffInteger(dateValue));
+}
+#endif
+
+CELL * p_time(CELL * params)
+{
+struct timeval start, end;
+INT64 N = 1;
+UINT * resultIdxSave;
+double diff;
+
+gettimeofday(&start, NULL);
+if(params->next != nilCell)
+    getInteger64Ext(params->next, &N, TRUE);
+
+resultIdxSave = resultStackIdx;
+while(N--)  
+    {
+    evaluateExpression(params);
+    cleanupResults(resultIdxSave);
+    }
+
+gettimeofday(&end, NULL);
+
+diff = (1.0 * timediff64_us(end, start)) / 1000;
+return(stuffFloat(diff));
+}
+
+
+CELL * p_timeOfDay(CELL * params)
+{
+double microSecs = microSecTime()/1000.0;
+return(stuffFloat(microSecs));
+}
+
+
+CELL * p_now(CELL * params)
+{
+struct timeval tv;
+struct tm *ttm;
+#ifndef WINDOWS
+struct tm *ltm;
+#ifndef SUNOS
+#ifndef OS2
+#ifndef AIX
+INT gmtoff;
+UINT isdst;
+#endif
+#endif
+#endif
+#else /* WINDOWS */
+TIME_ZONE_INFORMATION timeZone;
+#endif
+ssize_t offset = 0;
+time_t sec;
+CELL * cell;
+
+gettimeofday(&tv, NULL);
+
+if(params != nilCell)
+    {
+    params = getInteger(params, (UINT*)&offset);
+    offset *= 60;
+        tv.tv_sec += offset;
+    }
+
+#ifndef WINDOWS
+ltm = localtime((time_t *)&tv.tv_sec);
+#ifndef SUNOS
+#ifndef OS2
+#ifndef AIX
+isdst = ltm->tm_isdst;
+
+#ifdef CYGWIN
+gmtoff = _timezone/60;
+#else
+gmtoff = ltm->tm_gmtoff/60;
+#endif
+
+#endif
+#endif
+#endif
+#else /* WINDOWS */
+GetTimeZoneInformation(&timeZone);
+#endif
+
+sec = tv.tv_sec;
+ttm = gmtime(&sec);
+
+cell = stuffIntegerList(
+    11,
+    (UINT)ttm->tm_year + 1900,
+    (UINT)ttm->tm_mon + 1,
+    (UINT)ttm->tm_mday,
+    (UINT)ttm->tm_hour,
+    (UINT)ttm->tm_min,
+    (UINT)ttm->tm_sec,
+    (UINT)tv.tv_usec,
+    (UINT)ttm->tm_yday + 1,
+    ((UINT)ttm->tm_wday == 0 ? 7 : (UINT)ttm->tm_wday),
+
+#if defined(MAC_OSX) || defined(LINUX) || defined(_BSD) || defined(CYGWIN)
+    gmtoff, isdst
+#endif
+
+#if defined(SUNOS)
+    timezone/60, daylight
+#endif
+
+#if defined(OS2) || defined(TRU64) || defined(AIX)
+#ifdef NEWLISP64
+    (UINT)0L, (UINT)0L
+#else
+    (UINT)0, (UINT)0
+#endif
+#endif
+
+#if defined(WINDOWS)
+     (UINT)-timeZone.Bias - (UINT)timeZone.DaylightBias,
+     (UINT)timeZone.DaylightBias  
+#endif
+    );
+
+if(params != nilCell)   
+    {
+    pushResult(cell);
+    return(copyCell(implicitIndexList(cell, params)));
+    }
+
+return(cell);
+}
+
+CELL * p_dateList(CELL * params)
+{
+struct tm *ttm;
+ssize_t timeValue;
+time_t timer;
+CELL * cell;
+
+if(params == nilCell)
+    timeValue = currentDateValue();
+else
+    params = getInteger(params, (UINT*)&timeValue);
+
+timer = (time_t)timeValue;
+if((ttm = gmtime(&timer)) == NULL)
+    return(errorProcExt2(ERR_INVALID_PARAMETER, stuffInteger((UINT)timeValue)));
+
+cell = stuffIntegerList(
+    8,
+    (UINT)ttm->tm_year + 1900,
+    (UINT)ttm->tm_mon + 1,
+    (UINT)ttm->tm_mday,
+    (UINT)ttm->tm_hour,
+    (UINT)ttm->tm_min,
+    (UINT)ttm->tm_sec,
+    (UINT)ttm->tm_yday + 1,
+    ((UINT)ttm->tm_wday == 0 ? 7 : (UINT)ttm->tm_wday)
+);
+
+if(params != nilCell)   
+    {
+    pushResult(cell);
+    return(copyCell(implicitIndexList(cell, params)));
+    }
+
+return(cell);
+}
+
+ssize_t currentDateValue(void)
+{
+struct timeval tv;
+
+gettimeofday(&tv, NULL);
+return(tv.tv_sec);
+}
+
+CELL * p_dateValue(CELL * params)
+{
+ssize_t year, month, day, hour, min, sec;
+time_t dateValue;
+int evalFlag = TRUE;
+CELL * next;
+
+if(params->type == CELL_NIL)
+    return(stuffInteger(currentDateValue()));
+
+next = params->next;
+params = evaluateExpression(params);
+if(params->type == CELL_EXPRESSION)
+    {
+    params = (CELL *)params->contents;
+    next = params->next;
+    evalFlag = FALSE;
+    }
+
+params = getIntegerExt(params, (UINT *)&year, FALSE);
+params = getIntegerExt(next, (UINT *)&month, evalFlag);
+params = getIntegerExt(params, (UINT *)&day, evalFlag);
+
+hour = min = sec = 0;
+if(params != nilCell)
+        {
+        params = getIntegerExt(params, (UINT *)&hour, evalFlag);
+        params = getIntegerExt(params, (UINT *)&min, evalFlag);
+        getIntegerExt(params, (UINT *)&sec, evalFlag);
+        }
+
+dateValue = calcDateValue(year, month, day, hour, min, sec);
+
+#ifndef NEWLISP64
+return(stuffInteger64((INT64)dateValue));
+#else
+return(stuffInteger((UINT)dateValue));
+#endif
+}
+
+
+
+/* changed for 10.6.1 where time_t can be 64-bit on 32-bit Windows */
+time_t calcDateValue(int year, int month, int day, int hour, int min, int sec)
+{
+time_t dateValue;
+INT64 value;
+
+value = 367 * year - (7 * (year + ((month + 9) / 12)))/4 
+            + (275 * month)/9 + day + 1721013;
+
+value = value * 24 * 3600 + hour * 3600 + min * 60 + sec 
+            - 413319296; /* correction for 1970-1-1 */
+
+if(sizeof(time_t) == 8)
+    {
+    if(value & 0x80000000)
+        dateValue = value | 0xFFFFFFFF00000000LL;
+    else
+        dateValue = value & 0x00000000FFFFFFFF; 
+    }
+else
+    dateValue = value;
+
+return(dateValue);
+}
+
+
+#ifdef MAC_OSX
+extern int nanosleep();
+#endif
+
+void mySleep(int ms)
+{
+#ifdef NANOSLEEP
+struct timespec tm;
+
+tm.tv_sec = ms / 1000;
+tm.tv_nsec = (ms - tm.tv_sec * 1000) * 1000000;
+nanosleep(&tm, 0);
+
+#else
+
+#ifdef WINDOWS
+Sleep(ms);
+#else
+sleep((ms + 500)/1000);
+#endif
+
+#endif
+}
+
+#ifdef NANOSLEEP
+void myNanoSleep(int nanosec)
+{
+struct timespec tm;
+
+tm.tv_sec =  nanosec / 1000000000;
+tm.tv_nsec = (nanosec - tm.tv_sec * 1000000000);
+nanosleep(&tm, 0);
+}
+#endif
+
+
+CELL * p_sleep(CELL * params)
+{
+double milliSecsFloat;
+#ifdef NANOSLEEP
+int nanoSecsInt;
+#endif
+
+getFloat(params, &milliSecsFloat);
+
+mySleep((UINT)milliSecsFloat);
+#ifdef NANOSLEEP
+nanoSecsInt = (milliSecsFloat - (int)milliSecsFloat) * 1000000;
+if(nanoSecsInt) myNanoSleep(nanoSecsInt);
+#endif
+
+return(stuffFloat(milliSecsFloat));
+}
+
+/* -------------------------------- environment functions ------------------- */
+
+
+CELL * p_env(CELL * params)
+{
+char * varName;
+char * varValue;
+
+/* no parameters returns whole environment */
+if(params == nilCell) 
+    return(environment());
+
+/* one parameter get environment for one variable */
+params = getString(params, &varName);
+if(params == nilCell) 
+    {
+    if( (varValue = getenv(varName)) == NULL)
+        return(nilCell);
+    return(stuffString(varValue));
+    }
+
+/* two parameters sets environment for one variable */
+getString(params, &varValue);
+#ifndef MY_SETENV
+if(*varValue == 0)
+    unsetenv(varName);
+else
+#endif
+    if(setenv(varName, varValue, 1) != 0)
+        return(nilCell);
+
+return(trueCell);
+}
+
+
+#ifdef MY_SETENV
+int my_setenv(const char * varName, const char * varValue, int flag)
+{
+char * envstr;
+envstr = alloca(strlen(varName) + strlen(varValue) + 2);
+strcpy(envstr, varName);
+strcat(envstr, "=");
+strcat(envstr, varValue);
+return(putenv(envstr));
+}
+#endif
+
+
+CELL * environment(void)
+{
+char ** env;
+CELL * envList;
+CELL * lastEntry;
+CELL * pair;
+char * ptr;
+
+lastEntry = NULL;
+envList = getCell(CELL_EXPRESSION);
+
+env = environ;
+
+while(*env)
+    {
+    if((ptr = strstr(*env, "=")) != NULL)
+        {
+        pair = getCell(CELL_EXPRESSION);
+        addList(pair, stuffStringN(*env, ptr - *env));
+        addList(pair, stuffString(ptr + 1));
+        }
+    else 
+        {
+        env++;
+        continue;
+        }
+    
+    if(lastEntry == NULL)
+        {
+        lastEntry = pair;
+        envList->contents = (UINT)lastEntry;
+        }
+    else
+        {
+        lastEntry->next = pair;
+        lastEntry = lastEntry->next;
+        }
+    env++;
+    }
+
+return(envList);
+}
+
+/* --------------------- read the keyboard -----------------------------------*/
+
+/* thanks to Peter van Eerten for contributing this function */
+CELL * p_readKey(CELL * params)
+{
+#if defined(WINDOWS) || defined(OS2)
+return(stuffInteger(getch()));
+#else
+
+struct termios term, oterm;
+char c = 0;
+
+tcgetattr(0, &oterm);
+
+memcpy(&term, &oterm, sizeof(term));
+
+/* put the terminal in non-canonical mode, any
+reads timeout after 0.1 seconds or when a
+single character is read */
+term.c_lflag &= ~(ICANON | ECHO);
+term.c_cc[VMIN] = 0;
+term.c_cc[VTIME] = 1;
+tcsetattr(0, TCSANOW, &term);
+
+#if defined(_BSD) || defined(MAC_OSX)
+while(read(0, &c, 1) == 0);
+#else
+while((c = (char)getchar()) == (char)-1);
+#endif
+
+/* reset the terminal to original state */
+tcsetattr(0, TCSANOW, &oterm);
+
+return(stuffInteger(c));
+#endif
+} 
+
+/* --------------------- peek a file descriptor ------------------------------*/
+
+#ifndef WINDOWS
+CELL * p_peek(CELL * params)
+{
+UINT handle;
+int result;
+
+getInteger(params, &handle);
+
+if(ioctl((int)handle, FIONREAD, &result) < 0)
+    return(nilCell);
+
+return(stuffInteger((UINT)result));
+} 
+#endif
+
+/* --------------------- library functions not found on some OSs -------------*/
+
+#ifdef MY_VASPRINTF
+int my_vasprintf(char * * buffer, const char * format, va_list argptr)
+{
+int size;
+
+/* get size */
+size = vsnprintf(NULL, 0, format, argptr);
+if (size < 0) return -1;
+
+*buffer = calloc(size + 1, 1);
+if (!*buffer) return(-1);
+
+vsnprintf(*buffer, size + 1, format, argptr);
+(*buffer)[size] = '\0';
+
+return(size);
+}
+#endif
+
+
+/* ---------------------- Universal Unique ID version 1 and 3 ----------- */
+
+#define UINT16 unsigned short
+#define UINT32 unsigned int
+
+typedef struct 
+    {
+    UINT32          time_low;
+    UINT16          time_mid;
+    UINT16          time_hi_and_version;
+    unsigned char   clock_seq_hi_and_reserved;
+    unsigned char   clock_seq_low;
+    unsigned char   node[6];
+    } UUID;
+
+UINT16 clock_seq = 0;
+INT64 last_time = 0;
+char last_node[6];
+
+#define OCT151582 0x01B21DD213814000LL
+
+char * getUUID(char * str, char * node) 
+{
+UUID uuid;
+struct timeval tp;
+INT64 timestamp;
+UINT16 nodeID[3];
+int uuid_version;
+
+gettimeofday(&tp, (struct timezone *)0);
+
+/* add UUID UTC offset Oct 15, 1582 */
+timestamp = tp.tv_sec * (INT64)10000000 + tp.tv_usec * 10 + OCT151582; 
+
+#ifdef WINDOWS
+if(timestamp <= last_time) timestamp = last_time + 1;
+#else
+if(timestamp < last_time) clock_seq++;
+if(timestamp == last_time) timestamp++;
+#endif
+
+if(last_time == 0)
+    srandom((timestamp & 0xFFFFFFFF) + getpid());
+
+last_time = timestamp;
+
+
+if(clock_seq == 0) clock_seq = random();
+if(node != NULL && (memcmp(last_node, node, 6) != 0))
+    {
+    clock_seq = random();
+    memcpy(last_node, node, 6);
+    }
+
+if(node == NULL)
+    {
+    nodeID[0] = random(); 
+    nodeID[1] = random();
+    nodeID[2] = random();
+    uuid_version = 4;
+    memcpy(uuid.node, (void *)nodeID, 6);
+    }
+else
+    {
+    uuid_version = 1;
+    /* least sign bit of first byte must be 0 on MACs
+       and 1 on artifical generated node IDs */
+    memcpy(uuid.node, node, 6);
+    }
+
+if(uuid_version == 4) 
+    {
+    clock_seq = random();
+    uuid.time_low = random();
+#ifdef WINDOWS
+    uuid.time_low |= (random() << 16);
+#endif
+    uuid.time_mid = random();
+    uuid.time_hi_and_version = random();
+    }
+else
+    {
+    uuid.time_low = (unsigned int)(timestamp & 0xFFFFFFFF);
+    uuid.time_mid = (unsigned short)((timestamp >> 32) & 0xFFFF);
+    uuid.time_hi_and_version = (unsigned short)(timestamp >> 48) ;
+    }
+
+uuid.time_hi_and_version &= 0x0FFF;
+uuid.time_hi_and_version |= (uuid_version << 12);
+uuid.clock_seq_low = clock_seq & 0xFF;
+uuid.clock_seq_hi_and_reserved = (clock_seq & 0x3F00) >> 8;
+uuid.clock_seq_hi_and_reserved |= 0x80;
+
+snprintf(str, 37, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", 
+    uuid.time_low, uuid.time_mid, uuid.time_hi_and_version,
+    uuid.clock_seq_hi_and_reserved, uuid.clock_seq_low,
+    uuid.node[0], uuid.node[1], uuid.node[2], 
+    uuid.node[3], uuid.node[4], uuid.node[5]);
+
+return(str);
+}
+
+CELL * p_uuid(CELL * params)
+{
+char * nodeMAC = NULL;
+size_t size;
+char str[38];
+
+if(params != nilCell)
+    {
+    getStringSize(params, &nodeMAC, &size, TRUE);
+    if(size < 6) nodeMAC = NULL;
+    }
+    
+return(stuffString(getUUID(str, nodeMAC)));
+}
+
+
+SYMBOL * getSymbolCheckProtected(CELL * params)
+{
+SYMBOL * sPtr = NULL;
+CELL * cell;
+
+if(params->type == CELL_SYMBOL)
+    {
+    sPtr = (SYMBOL *)params->contents;
+    cell = (CELL *)sPtr->contents;
+    if(cell->type == CELL_CONTEXT)
+        sPtr = translateCreateSymbol( ((SYMBOL*)cell->contents)->name, CELL_NIL,
+            (SYMBOL*)cell->contents, TRUE);
+    }
+else if(params->type == CELL_DYN_SYMBOL)
+    sPtr = getDynamicSymbol(params);
+else errorProcExt(ERR_SYMBOL_EXPECTED, params);
+
+if(isProtected(sPtr->flags))
+    errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(sPtr));
+
+symbolCheck = sPtr;
+
+return sPtr;
+}
+
+
+/* eof */
+
+
+
diff --git a/nl-import.c b/nl-import.c
new file mode 100644
index 0000000..422a08d
--- /dev/null
+++ b/nl-import.c
@@ -0,0 +1,1184 @@
+/* nl-import.c --- shared library interface for newLISP
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+
+#include "newlisp.h"
+#include "protos.h"
+
+#ifndef WINDOWS
+#include <dlfcn.h>
+#endif
+
+#ifdef MAC_OSX
+#include <sys/mman.h>
+#endif
+
+UINT cdeclFunction(UINT fAddress, UINT * args, int count);
+extern int evalCatchFlag;
+
+#ifdef FFI
+CELL * ffiPreparation(CELL * pCell, CELL * params, int type);
+CELL * ffiTypeToCell(ffi_type *type, void * src);
+CELL * unpackFFI(ffi_type * ffi, char * data);
+void ffi_trampoline(ffi_cif *cif, void *ret, void **args, void *symbol);
+#endif
+
+
+#if defined(WINDOWS) || defined(CYGWIN)
+UINT stdcallFunction(UINT fAddress, UINT * args, int count);
+#endif
+
+#ifdef WINDOWS
+
+CELL * p_importLib(CELL * params)
+{
+char * libName;
+char * funcName;
+char * options = NULL;
+HINSTANCE hLibrary;
+CELL * pCell;
+SYMBOL * symbol;
+FARPROC initProc;
+int type = CELL_IMPORT_DLL;
+
+params = getString(params, &libName);
+params = getString(params, &funcName);
+if(params != nilCell)
+    {
+    if(params->next == nilCell)
+        params = getString(params, &options);
+#ifdef FFI
+    else
+        type = CELL_IMPORT_FFI;
+#endif
+    }
+
+if( (UINT)(hLibrary = LoadLibrary(libName)) < 32)
+    return(errorProcExt2(ERR_IMPORT_LIB_NOT_FOUND, stuffString(libName)));
+
+if(options != NULL && strcmp(options, "cdecl") ==  0)
+	type = CELL_IMPORT_CDECL;
+
+symbol = translateCreateSymbol(funcName, type, currentContext, TRUE);
+if(isFFIsymbol(symbol->flags)) /* don't redefine return current def */
+        return (copyCell((CELL *)symbol->contents));
+
+if(isProtected(symbol->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+
+pCell = getCell(type);
+
+deleteList((CELL *)symbol->contents);
+symbol->contents = (UINT)pCell;
+if((pCell->contents = (UINT)GetProcAddress(hLibrary, (LPCSTR)funcName)) == 0)
+    return(errorProcExt2(ERR_IMPORT_FUNC_NOT_FOUND, stuffString(funcName)));
+
+/* put name of imported DLL into DLLs space for loadStartup() */
+initProc = GetProcAddress(hLibrary, (LPCSTR)"dllName");
+if(initProc != 0) (*initProc)(libName);
+
+#ifdef FFI
+symbol->flags |= SYMBOL_FFI | SYMBOL_PROTECTED;
+if(pCell->type == CELL_IMPORT_FFI)
+    {
+    pCell->aux = (UINT)calloc(sizeof(FFIMPORT), 1);
+    ((FFIMPORT *)pCell->aux)->name = symbol->name;
+    return(copyCell(ffiPreparation(pCell, params, FFI_FUNCTION)));
+    }
+#endif
+
+pCell->aux = (UINT)symbol->name;
+
+return(copyCell(pCell));
+}
+
+#else  /* UNIX and compatible operating systems */
+
+CELL * p_importLib(CELL * params)
+{
+char * libName;
+char * funcName;
+void * hLibrary;
+CELL * pCell;
+SYMBOL * symbol;
+char * error;
+#ifdef CYGWIN
+char * options = NULL;
+int type = CELL_IMPORT_DLL;
+#else
+int type = CELL_IMPORT_CDECL;
+#endif
+
+
+params = getString(params, &libName);
+if(params != nilCell)
+    params = getString(params, &funcName);
+else funcName = NULL;
+
+#ifdef CYGWIN
+if(params != nilCell)
+    { 
+    if(params->next == nilCell)   
+        {
+        params = getString(params, &options);
+        if(strcmp(options, "cdecl") ==  0)
+            type = CELL_IMPORT_CDECL;
+        }
+#ifdef FFI
+    else type = CELL_IMPORT_FFI;
+#endif
+    }
+#else
+if(params->next != nilCell)
+    type = CELL_IMPORT_FFI;
+#endif
+
+hLibrary = 0;                
+
+#ifdef TRU64
+if((hLibrary = dlopen(libName, RTLD_LAZY)) == 0)
+#else
+if((hLibrary = dlopen(libName, RTLD_GLOBAL|RTLD_LAZY)) == 0)
+#endif
+    return(errorProcExt2(ERR_IMPORT_LIB_NOT_FOUND, stuffString((char *)dlerror())));
+
+if(funcName == NULL)
+    return(trueCell);
+
+symbol = translateCreateSymbol(funcName, type, currentContext, TRUE);
+if(isFFIsymbol(symbol->flags)) /* don't redefine */
+        return (copyCell((CELL *)symbol->contents));
+
+if(isProtected(symbol->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+    
+pCell = getCell(type);
+deleteList((CELL *)symbol->contents);
+symbol->contents = (UINT)pCell;
+
+dlerror(); /* clear potential error */
+pCell->contents = (UINT)dlsym(hLibrary, funcName);
+
+if((error = (char *)dlerror()) != NULL)
+    return(errorProcExt2(ERR_IMPORT_FUNC_NOT_FOUND, stuffString(error)));
+
+#ifdef FFI
+symbol->flags |= SYMBOL_FFI | SYMBOL_PROTECTED;
+if(pCell->type == CELL_IMPORT_FFI)
+    {
+    pCell->aux = (UINT)calloc(sizeof(FFIMPORT), 1);
+    ((FFIMPORT *)pCell->aux)->name = symbol->name;
+    return(copyCell(ffiPreparation(pCell, params, FFI_FUNCTION)));
+    }
+#endif
+
+pCell->aux = (UINT)symbol->name;
+return(copyCell(pCell));
+}
+#endif
+
+
+CELL * executeLibfunction(CELL * pCell, CELL * params)
+{
+CELL * arg;
+UINT args[14];
+int count;
+
+#ifdef FFI
+if(pCell->type == CELL_IMPORT_FFI)
+    if(((FFIMPORT *)pCell->aux)->type != 0)
+    return executeLibFFI(pCell, params);
+#endif
+
+count = 0;
+while(params->type != CELL_NIL && count < 14)
+    {
+    arg = evaluateExpression(params);
+    switch(arg->type)
+        {
+        case CELL_LONG:
+        case CELL_STRING:
+        case CELL_PRIMITIVE:
+            args[count++] = arg->contents;
+            break;
+#ifndef NEWLISP64
+        /* change 64-bit to 32-bit */
+        case CELL_INT64: 
+            args[count++] = *(INT64 *)&arg->aux;
+            break;
+#endif
+        case CELL_FLOAT:
+#ifndef NEWLISP64
+            args[count++] = arg->aux;
+#endif
+            args[count++] = arg->contents;
+            break;
+        default:
+            args[count++] = (UINT)arg;
+            break;
+        }
+    params = (CELL *)params->next;
+    }
+
+#if defined(WINDOWS) || defined(CYGWIN)
+if(pCell->type == CELL_IMPORT_DLL)
+    return(stuffInteger(stdcallFunction(pCell->contents, args, count)));
+else
+#endif
+return(stuffInteger(cdeclFunction(pCell->contents, args, count)));
+}
+
+
+UINT cdeclFunction(UINT fAddress, UINT * args, int count)
+{
+UINT (*function)();
+
+function = (UINT (*)())fAddress;
+
+switch(count)
+    {
+    case 0:
+            return (*function)();
+
+    case 1:
+            return  (*function)(args[0]);
+
+    case 2:
+            return  (*function)(args[0], args[1]);
+
+    case 3:
+            /* printf("args[0] %llx, args[1] %llx, args[2] %llx, args[1]-args[2] %llx\n ",
+                    args[0], args[1], args[2], args[1] - args[2]); */
+
+            return  (*function)(args[0], args[1], args[2]);
+    case 4:
+
+            return  (*function)(args[0], args[1], args[2], args[3]);
+
+    case 5:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4]);
+    case 6:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5]);
+    case 7:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6]);
+    case 8:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6], args[7]);
+
+    case 9:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6], args[7], args[8]);
+
+    case 10:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6], args[7], args[8], args[9]);
+    case 11:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10]);
+    case 12:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10], args[11]);
+
+    case 13:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10], args[11],
+                args[12]);
+    case 14:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10], args[11],
+                args[12], args[13]);
+    default:
+        break;
+    }
+
+return(0);
+}
+
+
+#if defined(WINDOWS) || defined(CYGWIN)
+UINT stdcallFunction(UINT fAddress, UINT * args, int count)
+{
+UINT _stdcall (*function)();
+
+function = (UINT _stdcall (*)())fAddress;
+
+switch(count)
+    {
+    case 0:
+            return (*function)();
+
+    case 1:
+            return  (*function)(args[0]);
+
+    case 2:
+            return  (*function)(args[0], args[1]);
+
+    case 3:
+            return  (*function)(args[0], args[1], args[2]);
+
+    case 4:
+            return  (*function)(args[0], args[1], args[2], args[3]);
+
+    case 5:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4]);
+    case 6:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5]);
+    case 7:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6]);
+    case 8:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6], args[7]);
+
+    case 9:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6], args[7], args[8]);
+
+    case 10:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                     args[4], args[5], args[6], args[7], args[8], args[9]);
+    case 11:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10]);
+    case 12:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10], args[11]);
+
+    case 13:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10], args[11],
+                args[12]);
+    case 14:
+            return  (*function)(args[0], args[1], args[2], args[3],
+                args[4], args[5], args[6], args[7],
+                args[8], args[9], args[10], args[11],
+                args[12], args[13]);
+    default:
+        break;
+    }
+
+return(0);
+}
+#endif
+
+
+/* 16 callback functions for up to 8 parameters */
+
+INT template(INT n, INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8);
+
+INT callback0(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(0, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback1(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(1, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback2(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(2, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback3(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(3, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback4(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(4, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback5(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(5, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback6(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(6, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback7(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(7, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback8(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(8, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback9(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(9, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback10(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(10, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback11(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(11, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback12(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(12, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback13(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(13, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback14(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(14, p1, p2, p3, p4, p5, p6, p7, p8);}
+INT callback15(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+    {return template(15, p1, p2, p3, p4, p5, p6, p7, p8);}
+
+typedef INT (*lib_callback_t)(INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8);
+
+typedef struct {
+    SYMBOL * sym;
+    lib_callback_t func;
+    } LIBCALLBACK;
+
+LIBCALLBACK callback[] = {
+    { NULL, callback0 },
+    { NULL, callback1 },
+    { NULL, callback2 },
+    { NULL, callback3 },
+    { NULL, callback4 },
+    { NULL, callback5 },
+    { NULL, callback6 },
+    { NULL, callback7 },
+    { NULL, callback8 },
+    { NULL, callback9 },
+    { NULL, callback10 },
+    { NULL, callback11 },
+    { NULL, callback12 },
+    { NULL, callback13 },
+    { NULL, callback14 },
+    { NULL, callback15 },
+};
+
+
+INT template(INT n, INT p1, INT p2, INT p3, INT p4, INT p5, INT p6, INT p7, INT p8) 
+{
+CELL * args;
+CELL * cell;
+INT result;
+jmp_buf errorJumpSave;
+
+memcpy(errorJumpSave, errorJump, sizeof(errorJump));
+if(setjmp(errorJump))
+    {
+    reset();
+    initStacks();
+    result = -1;
+    goto FINISH_CALLBACK;
+    }
+
+args = stuffIntegerList(8, p1, p2, p3, p4, p5, p6, p7, p8);
+executeSymbol(callback[n].sym, (CELL *)args->contents, &cell);
+
+#ifndef NEWLISP64
+if(cell->type == CELL_INT64)
+    result = *(INT64 *)&cell->aux;
+else 
+#endif
+    result = (INT)cell->contents;
+
+args->contents = (UINT)nilCell;
+
+deleteList(args);
+/* before 10.4.4 this was pushResult(cell) but caused resultStack overflow
+   in 10.4.4 changed to deleteList(cell), but now return value on
+   simple callback not available anymore, use callback with libffi instead
+   available on -DFFI compiled versions. See also:
+       qa-specific-tests/qa-simplecallback
+*/
+deleteList(cell); 
+
+FINISH_CALLBACK:
+memcpy(errorJump, errorJumpSave, sizeof(errorJump));
+return(result);
+}
+
+
+CELL * p_callback(CELL * params)
+{
+CELL * cell;
+SYMBOL * sPtr;
+UINT n;
+
+
+#ifdef FFI
+SYMBOL * symbol;
+CELL * ffiCell;
+FFIMPORT *ffi;
+char * cb_name;
+int result, len;
+
+#ifdef MAC_OSX
+ffi_closure *closure;
+#endif
+
+#endif /* FFI */
+
+cell = evaluateExpression(params);
+if(cell->type == CELL_SYMBOL)
+	sPtr = (SYMBOL *)cell->contents;
+else
+	goto CALLBACK_SIMPLE;
+
+#ifdef FFI
+len = strlen(sPtr->name);
+cb_name = calloc(sizeof(char) * (len + 6), 1);
+/*
+strncpy(cb_name, "$ffi-", 6);
+strncat(cb_name, sPtr->name, len);
+*/
+memcpy(cb_name, "$ffi-", 5);
+memcpy(cb_name + 5, sPtr->name, len + 1);
+
+symbol = translateCreateSymbol(cb_name, CELL_NIL, mainContext, TRUE);
+if(isFFIsymbol(symbol->flags)) /* already defined */
+    {
+    ffiCell = (CELL *)symbol->contents;
+    ffi = (FFIMPORT *) ffiCell->aux;
+    return(stuffInteger((UINT) ffi->code));
+    }
+
+if(isProtected(symbol->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+
+symbol->flags |= SYMBOL_FFI | SYMBOL_PROTECTED;
+
+if(params->next == nilCell)
+    return(errorProcExt(ERR_FFI_PREP_FAILED,nilCell));
+
+ffiCell = getCell(CELL_IMPORT_FFI);
+ffiCell->aux = (UINT)calloc(sizeof(FFIMPORT), 1);
+((FFIMPORT *)ffiCell->aux)->name = cb_name;
+ffiCell = ffiPreparation(ffiCell,params->next,FFI_CLOSURE);
+
+if(ffiCell != nilCell)
+    {
+    ffi = (FFIMPORT *) ffiCell->aux;
+    ffi->data = calloc(sizeof(ffi_closure_data), 1);
+#ifndef MAC_OSX
+    ffi->clos = ffi_closure_alloc(sizeof(ffi_closure),&ffi->code);
+    if(!ffi->clos)
+        {
+        free(ffi->data);
+        return(errorProcExt(ERR_FFI_PREP_FAILED,nilCell));
+        }
+    result = ffi_prep_closure_loc(ffi->clos, &ffi->cif, ffi_trampoline, ffi->data, ffi->code);
+    if(result != FFI_OK)
+        {
+        free(ffi->data);
+        return(errorProcExt(ERR_FFI_PREP_FAILED, stuffSymbol(sPtr)));
+        }
+#else /* MAC_OSX */
+    if((closure = mmap(NULL, sizeof(ffi_closure), PROT_READ | PROT_WRITE,
+             MAP_ANON | MAP_PRIVATE, -1, 0)) == (void*)-1)
+        {
+        free(ffi->data);
+        return(errorProcExt(ERR_FFI_PREP_FAILED, stuffSymbol(sPtr)));
+        }
+    ffi->clos = closure;
+    if((result = ffi_prep_closure(closure, &ffi->cif, ffi_trampoline, ffi->data)) != FFI_OK)
+        {
+        free(ffi->data);
+        munmap(closure, sizeof(closure));
+        return(errorProcExt(ERR_FFI_PREP_FAILED, stuffSymbol(sPtr)));
+        }
+    if(mprotect(closure, sizeof(closure), PROT_READ | PROT_EXEC) == -1)
+        {
+        free(ffi->data);
+        munmap(closure, sizeof(closure));
+        return(errorProcExt(ERR_FFI_PREP_FAILED, stuffSymbol(sPtr)));
+        }
+    /* ffi->code = ffi_trampoline; */
+    ffi->code = closure;
+#endif
+    ffi->data->symbol = sPtr;
+    ffi->data->code = ffi->code;
+
+    deleteList((CELL *)symbol->contents);
+    symbol->contents = (UINT)ffiCell;
+
+    return(stuffInteger((UINT) ffi->code));
+    }
+else
+    return(errorProcExt(ERR_FFI_PREP_FAILED, stuffString(sPtr->name)));
+#endif /* FFI */
+
+CALLBACK_SIMPLE:
+getIntegerExt(cell, &n, FALSE);
+
+if(n > 15) return(errorProc(ERR_NUMBER_OUT_OF_RANGE));
+
+getSymbol(params->next, &sPtr);
+callback[n].sym = sPtr;
+
+return(stuffInteger((UINT)callback[n].func));
+}
+
+/* ========================= FFFI using ffilib ========================== */
+
+/* because of the non-standard cell in FFI symbol->contents, it cannot be
+   memory managed in an efficient way. This is why FFI functions and structs
+   can only be defined once. A repeated definitions will return nil and leave
+   the symbol's original definition untouched. 
+
+   Thanks to Stefan Sonnenberg for doing most of the coding in this section.
+*/
+
+
+#ifdef FFI
+
+typedef struct 
+    {
+    char * name;
+    ffi_type * type;
+    int size;
+    } FFITYPE;
+
+/* of the native C-types only types, which are the same 
+   on LP64, LLP64 and ILP32, are supported
+*/
+
+/* custom ffi_type_charpointer see initFFI() */
+ffi_type ffi_type_charpointer = {0, 0, 0, NULL};
+
+FFITYPE ffi_types[] =
+    {
+    {"void",        &ffi_type_void},
+    {"char",        &ffi_type_sint8},
+    {"byte",        &ffi_type_uint8},
+    {"unsigned short int",  &ffi_type_uint16},
+    {"short int",   &ffi_type_sint16},
+    {"unsigned int",&ffi_type_uint32},
+    {"int",         &ffi_type_sint32},
+#ifdef NEWLISP64
+    {"long",        &ffi_type_sint64},
+#else
+    {"long",        &ffi_type_sint32},
+#endif
+    {"long long",   &ffi_type_sint64},
+    {"float",       &ffi_type_float},
+    {"double",      &ffi_type_double},
+    {"char*",       &ffi_type_charpointer}, /* zero terminated string buffers with textual info */
+    {"void*",       &ffi_type_pointer}, /* string or address with binary info, address return */
+    {NULL,          NULL}
+    };
+
+void initFFI(void)
+{
+memcpy(&ffi_type_charpointer, &ffi_type_pointer, sizeof(ffi_type));
+}
+
+/* creates ffi usable struct information */
+CELL * p_struct(CELL * params)
+{
+CELL * ffiCell;
+SYMBOL * symbol;
+FFIMPORT * ffi;
+int i;
+
+    params = getSymbol(params, &symbol);
+    if(isFFIsymbol(symbol->flags)) /* don't redefine */
+        return(stuffSymbol(symbol));
+
+    if(isProtected(symbol->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol)));
+
+    if(params == nilCell)
+        return(errorProc(ERR_MISSING_ARGUMENT));
+
+    symbol->flags |= SYMBOL_FFI | SYMBOL_PROTECTED;
+
+    ffiCell = getCell(CELL_IMPORT_FFI);
+    ffiCell->aux = (UINT)calloc(sizeof(FFIMPORT), 1);
+    ffi = (FFIMPORT *) ffiCell->aux;
+    ffi->name = symbol->name;
+    ffiCell = ffiPreparation(ffiCell, params, FFI_STRUCT);
+    ffi->cstruct = calloc(sizeof(ffi_type),1);
+    
+    ffi->cstruct->elements = calloc(sizeof(ffi_type *) * (ffi->cif.nargs + 1), 1);
+
+    for(i = 0; i < ffi->cif.nargs; i++)
+        ffi->cstruct->elements[i] = ffi->cif.arg_types[i];
+	/* last elements[nargs] must be left 0, NULL */
+	/* size and alignment are already 0, to let ffi know, it has to calculate */
+
+    ffi->cstruct->type = FFI_TYPE_STRUCT; 
+
+    if(ffi_prep_cif(&ffi->cif, FFI_DEFAULT_ABI, 0, ffi->cstruct, 0) != FFI_OK)
+        return(errorProc(ERR_FFI_PREP_FAILED));
+
+    deleteList((CELL *)symbol->contents);
+    symbol->contents = (UINT)ffiCell;
+
+    return(stuffSymbol(symbol));
+
+}
+
+CELL * packFFIstruct(CELL * cell, CELL * params)
+{
+char chrV;
+unsigned char byteV;
+short int shortV;
+unsigned short int uint16V;  /* 16 bit */
+unsigned int uint32V;         /* 32 bit */
+int int32V;                 /* 32 bit */
+unsigned long long  uint64V; /* 64 bit */
+float floatV;
+double doubleV;
+ffi_type ** elements;
+ffi_type *elem;
+size_t offset = 0;
+unsigned short pad;
+char * data;
+int listFlag = 0;
+FFIMPORT * ffi;
+
+ffi = (FFIMPORT *) cell->aux;
+if(ffi->cstruct && ffi->cstruct->type != FFI_TYPE_STRUCT)
+    return(errorProc(ERR_FFI_STRUCT_EXPECTED));
+
+elements = (ffi_type **) ffi->cstruct->elements;
+
+data = allocMemory(ffi->cstruct->size + 1);
+memset(data, 0, ffi->cstruct->size + 1);
+
+/* check if data come in as a list like in traditional pack */
+    
+/* computing offsets and copy data */
+elements = (ffi_type **) ffi->cstruct->elements;
+while( (elem = *elements++) != NULL)
+    {
+    if(params->type == CELL_NIL) break;
+    if(listFlag)
+        cell = params;
+    else
+        cell = evaluateExpression(params);
+    /* accept data in a list */
+    if(isList(cell->type))
+        {
+        params = cell = (CELL *)cell->contents;
+        listFlag = 1;
+        }
+
+    /* aligned ? */
+    pad = offset % elem->alignment;
+    /* no, add size of alignment boundary - padding bytes */
+    if (pad != 0) offset += elem->alignment - pad;
+
+#ifndef NEWLISP64
+    if(cell->type == CELL_FLOAT || cell->type == CELL_INT64)
+        uint64V = *(INT64 *)&cell->aux;
+    else /* CELL_LONG and CELL_STRING */
+        uint64V = cell->contents;
+#else
+    uint64V = cell->contents;
+#endif
+
+    if( elem == &ffi_type_sint8 )
+        {
+        chrV = (char)uint64V;
+        memcpy(data + offset, &chrV, sizeof(char));
+        }
+    else if( elem == &ffi_type_uint8)
+        {
+        byteV = (char)uint64V;
+        memcpy(data + offset, &byteV, sizeof(unsigned char));
+        }
+    else if( elem == &ffi_type_uint16)
+        {
+        uint16V = (unsigned short int)uint64V;
+        memcpy(data + offset, &uint16V, sizeof(unsigned short int));
+        }
+    else if( elem == &ffi_type_sint16)
+        {
+        shortV = (short int)uint64V;
+        memcpy(data + offset, &shortV, sizeof(short int));
+        }
+    else if( elem == &ffi_type_uint32)
+        {
+        uint32V = (unsigned int)uint64V;
+        memcpy(data + offset, &uint32V, sizeof(unsigned int));
+        }
+    else if(elem == &ffi_type_sint32)
+        {
+        int32V = (int)uint64V;
+        memcpy(data + offset, &int32V, sizeof(int));
+        }
+    else if(elem == &ffi_type_sint64)
+        memcpy(data + offset, &uint64V, sizeof(long long));
+    else if(elem == &ffi_type_float)
+        {
+        floatV = (float) *(double *)&cell->aux;
+        memcpy(data + offset, &floatV, sizeof(float));
+        }
+    else if(elem == &ffi_type_double)
+        {
+        doubleV = getDirectFloat(cell);
+        memcpy(data+offset, &doubleV, sizeof(double));
+        }
+    else if(elem == &ffi_type_pointer || elem == &ffi_type_charpointer)
+        memcpy(data + offset, (void *)&cell->contents, sizeof(void *));
+    else /* just copy what's there, must be struct */
+        memcpy(data + offset, (void *)cell->contents, elem->size);
+
+    /* grow offset by size of last element */
+    offset += elem->size;
+    /* go to next param and repeat */
+    params = params->next;
+    }
+
+cell = makeStringCell(data, ffi->cstruct->size);
+
+return(cell);
+}
+
+CELL * unpackFFIstruct(CELL * cell, char * data)
+{
+FFIMPORT * ffi;
+
+ffi = (FFIMPORT *) cell->aux;
+if(ffi->cstruct && ffi->cstruct->type != FFI_TYPE_STRUCT)
+    return(errorProc(ERR_FFI_STRUCT_EXPECTED));
+
+/* This is redundant? works with or without it on OSX, Windows, Linux. 
+if(ffi->cstruct->size != 0)
+    if(ffi_prep_cif(&ffi->cif, FFI_DEFAULT_ABI, 0, ffi->cstruct,0) != FFI_OK)
+        return(errorProc(ERR_FFI_PREP_FAILED));
+*/
+return(unpackFFI(ffi->cstruct, data));
+}
+
+
+CELL * unpackFFI(ffi_type * ffiPtr, char * data)
+{
+ffi_type * elem;
+ffi_type ** elements;
+CELL * cell;
+size_t offset = 0;
+unsigned short pad;
+
+cell = getCell(CELL_EXPRESSION);
+elements = ffiPtr->elements;
+while( (elem = *elements++) != NULL )
+    {
+    pad = offset % elem->alignment;
+    if (pad != 0) offset += elem->alignment - pad;
+    addList(cell, (CELL *) ffiTypeToCell(elem, data + offset));
+    offset += elem->size;
+    }
+
+return(cell);
+}
+ 
+
+ffi_type * getFFIType(char * type)
+{
+int i = 0;
+char * name;
+SYMBOL * sPtr;
+CELL * sType;
+FFIMPORT * tmp;
+
+while((name = ffi_types[i].name))
+    {
+    if(strcmp(name, type) == 0)
+        return(ffi_types[i].type);
+    ++i;
+    }
+
+/* ok - no primitive type found: try to lookup struct definition */
+sPtr = lookupSymbol(type,currentContext);
+if(sPtr)
+    {
+    sType = (CELL *)sPtr->contents;
+    tmp = (FFIMPORT *)sType->aux;
+    return( (ffi_type *)tmp->cstruct );
+    }
+
+errorProcExt2(ERR_FFI_INVALID_TYPE, stuffString(type) );
+
+return(NULL);
+}
+    
+#define MAX_TYPE_ARGS 32
+
+CELL * ffiPreparation(CELL * pCell, CELL * params, int type)
+    {
+    CELL * arg;
+    FFIMPORT * ffi;
+    ffi_type **atypes;
+    unsigned int nargs;
+    ffi_type *rtype;
+
+    if(pCell->type != CELL_IMPORT_FFI)
+        errorProcExt(ERR_INVALID_PARAMETER, pCell);
+
+    ffi = (FFIMPORT *)pCell->aux;
+    ffi->func = FFI_FN(pCell->contents);
+    ffi->type = type;
+
+    atypes = calloc(sizeof(ffi_type) * MAX_TYPE_ARGS, 1);
+
+    rtype = &ffi_type_void;
+
+    /* get return type if not a structure */
+    if(type != FFI_STRUCT)
+        {
+        arg = evaluateExpression(params);
+        if(arg->type == CELL_STRING)
+            rtype = getFFIType((char *) arg->contents);
+        else
+            errorProcExt(ERR_STRING_EXPECTED, arg);
+        params = params->next;
+        }
+
+    nargs=0;
+    while((arg = evaluateExpression(params)) != nilCell)
+        {
+        if(arg->type == CELL_STRING)
+            {
+            /* skip void arguments */
+            if(strcmp((char *)arg->contents,"void") != 0)
+                {
+                atypes[nargs] = getFFIType((char *) arg->contents);
+                nargs++;
+                }
+            }
+        else
+            errorProcExt(ERR_INVALID_PARAMETER,pCell);
+        params = params->next;
+
+        if(nargs == MAX_TYPE_ARGS)
+            break; 
+        } 
+
+    ffi->cif.nargs = nargs;
+    ffi->cif.arg_types = atypes;
+    if(ffi_prep_cif(&ffi->cif, FFI_DEFAULT_ABI, nargs, rtype, atypes) != FFI_OK)
+        errorProcExt(ERR_FFI_PREP_FAILED, pCell);
+
+    return(pCell);
+}
+
+
+
+CELL * executeLibFFI(CELL * pCell, CELL * params)
+{
+    FFIMPORT * ffi;
+    int c = 0;
+    ffi_type * ffiType;
+    INT64 value64;
+    UINT value;
+    void **avalues;
+    CELL * cell;
+    void * result;
+    double valueDouble;
+
+    ffi = (FFIMPORT *)pCell->aux;
+    if(ffi->type == FFI_STRUCT)
+        return(pCell);
+
+    avalues = alloca(sizeof(void *) * 16);
+
+    while(params != nilCell)
+        {
+        if(c >= ffi->cif.nargs) /* too much args */
+            errorProc(ERR_NUM_ARGS);
+
+        ffiType = ffi->cif.arg_types[c];
+        if(ffiType !=  &ffi_type_void)
+            avalues[c] = alloca(ffiType->size);
+        /* printf("c: %d size:%ld\n", c, ffiType->size); */
+
+        if(ffiType->type == FFI_TYPE_STRUCT)
+            {
+            cell = evaluateExpression(params);
+            if(cell->type == CELL_STRING)
+                memcpy(avalues[c],(void*) cell->contents,ffiType->size);
+            else
+                {
+                getIntegerExt(cell, (UINT *) &value, FALSE);
+                memcpy(avalues[c], (void **) value, ffiType->size);
+                }
+            params = params->next;
+            }
+        else if(ffiType ==  &ffi_type_pointer) /*  "void*" */
+            {
+            cell = evaluateExpression(params);
+            if(cell->type == CELL_STRING)
+                *(UINT *)avalues[c] = cell->contents;
+            else
+                getIntegerExt(cell, avalues[c], FALSE);
+            params = params->next;
+            }
+        else if(ffiType ==  &ffi_type_charpointer) /*  "char*" */
+            {
+            params = getString(params, avalues[c]);
+            }
+        else if(ffiType == &ffi_type_float)  /* float 64-bit */
+            {
+            params = getFloat(params, &valueDouble);
+            *(float *)avalues[c] = valueDouble;
+            }
+        else if(ffiType == &ffi_type_double)  /* double 64-bit */
+            params = getFloat(params, avalues[c]);
+        else if(ffiType == &ffi_type_sint64 
+               || ffiType == &ffi_type_uint64) /* int 64-bit unsiged 64-bit in newLISP */
+            {
+            params = getInteger64Ext(params, &value64, TRUE);
+            avalues[c] = alloca(sizeof(INT64));
+            *(INT64 *)avalues[c] = value64;
+            }
+        else
+            { 
+            params = getInteger(params, &value);
+            if(ffiType == &ffi_type_sint8) /* char 8-bit */
+                *(char *)avalues[c] = value;
+            else if(ffiType == &ffi_type_uint8) /* unsigned char 8-bit */
+                *(unsigned char *)avalues[c] = value;
+            else if(ffiType == &ffi_type_sint16) /* short int 16-bit */
+                *(short int *)avalues[c] = value;
+            else if(ffiType == &ffi_type_uint16) /* unsigned short int 16-bit */
+                *(unsigned short int *)avalues[c] = value;
+            else if(ffiType == &ffi_type_sint32) /* int 32-bit */
+                *(int *)avalues[c] = value;
+            else if(ffiType == &ffi_type_uint32) /* unsigned int 32-bit */
+                *(unsigned int *)avalues[c] = value;
+            }
+        c++;
+        } 
+    if(c < ffi->cif.nargs) /* not enough args */
+        errorProc(ERR_NUM_ARGS); 
+
+    result = (ffi_type *) alloca(sizeof(ffi->cif.rtype->size));
+
+    ffi_call(&ffi->cif, FFI_FN(pCell->contents), result, avalues);
+
+    return ffiTypeToCell(ffi->cif.rtype, result);
+}
+
+
+CELL * ffiTypeToCell(ffi_type *type, void * result)
+    {
+    double valueDouble;
+    char * cPtr;
+
+    /* returning a structure */
+    if(type->type == FFI_TYPE_STRUCT) 
+        return(unpackFFI(type, result));
+/*
+        return stuffStringN(result, type->size);
+*/
+
+    /* for C displayable strings use return type "char*"
+       for destructuring pointers to binary info
+       use "void*" as return type */
+    else if(type == &ffi_type_charpointer)
+        {
+        cPtr = *(char **)result; 
+        if(cPtr == NULL)
+                errorProc(ERR_CANNOT_CONVERT_NULL);
+        return stuffString(cPtr);
+        }
+    else if(type == &ffi_type_pointer)
+        return stuffInteger(*((UINT  *)result));
+    else if(type == &ffi_type_double)
+        return stuffFloat(*(double *)result);
+    else if(type == &ffi_type_float)
+        {
+        valueDouble = *(float *)result;
+        return stuffFloat(valueDouble);
+        }
+    else if(type == &ffi_type_sint8)
+        return stuffInteger(*((char *)result));
+    else if(type == &ffi_type_uint8)
+        return stuffInteger(*((unsigned char *)result));
+    else if(type == &ffi_type_sint16)
+        return stuffInteger(*((short int *)result));
+    else if(type == &ffi_type_uint16)
+        return stuffInteger(*((unsigned short int *)result));
+    else if(type == &ffi_type_sint32)
+        return stuffInteger(*((int *)result));
+    else if(type == &ffi_type_uint32)
+        return stuffInteger64(*((unsigned int *)result));
+    else if(type == &ffi_type_sint64 || type == &ffi_type_uint64)
+        return stuffInteger64(*((INT64 *)result));
+
+    return nilCell;
+    }
+
+/* This function gets called by external C functions/libraries */
+
+void ffi_trampoline(ffi_cif *cif, void *ret, void **args, void *data)
+{
+
+    SYMBOL *symbol;    
+    CELL *arg = NULL;
+    CELL *next;
+    CELL *result;
+    int c;
+    INT64 value64;
+    UINT value;
+
+    if(!cif)
+        return;
+
+    if(ret)
+        memset(ret, 0, cif->rtype->size);
+
+    symbol = (SYMBOL *) ((ffi_closure_data*) data)->symbol;    
+    if(!symbol)
+        return;
+    
+    if(cif->nargs)
+		{
+        arg = next = ffiTypeToCell(cif->arg_types[0], args[0]);
+		for(c = 1;c < cif->nargs; c++)
+			next = next->next =  ffiTypeToCell(cif->arg_types[c], args[c]);
+		}
+
+    executeSymbol(symbol,(CELL *) arg, &result);
+    
+    if((cif->rtype ==  &ffi_type_pointer) || (cif->rtype->type == FFI_TYPE_STRUCT) ) /* string or void pointer, or struct */
+        *(UINT *) ret = (UINT) result->contents;
+    else if(cif->rtype == &ffi_type_float)  /* float 64-bit */
+        *(float *)ret = (float) getDirectFloat(result);
+    else if(cif->rtype == &ffi_type_double)  /* double 64-bit */
+        *(double *)ret = getDirectFloat(result);
+    /* int 64-bit in newLISP */
+    else if(cif->rtype == &ffi_type_sint64 || cif->rtype == &ffi_type_uint64) 
+        {
+        getInteger64Ext(result, &value64, TRUE);
+        *(INT64 *)ret = value64;
+        }
+    else if(cif->rtype == &ffi_type_void)
+        goto TRAMPOLINE_FINISH;
+    else 
+        {
+        getIntegerExt(result, &value, FALSE);
+        if(cif->rtype == &ffi_type_sint8) /* char 8-bit */
+            *(char *)ret = (char) value;
+        else if(cif->rtype == &ffi_type_uint8) /* unsigned char 8-bit */
+            *(unsigned char *)ret = (unsigned char) value;
+        else if(cif->rtype == &ffi_type_sint16) /* short int 16-bit */
+            *(short int *)ret = (short int) value;
+        else if(cif->rtype == &ffi_type_uint16) /* unsigned short int 16-bit */
+            *(unsigned short int *)ret = (unsigned short int) value;
+        else if(cif->rtype == &ffi_type_sint32) /* int 32-bit */
+            *(int *)ret = (int) value;
+        else if(cif->rtype == &ffi_type_uint32) /* unsigned int 32-bit */
+            *(unsigned int *)ret = (unsigned int) value;
+        else
+            *(double *)ret = sqrt(-1.0); /* return NaN; never happens */
+        }
+
+    TRAMPOLINE_FINISH:
+    deleteList(result); 
+    return;
+    }
+#endif /* FFI */
+
+/* end of file */
diff --git a/nl-list.c b/nl-list.c
new file mode 100644
index 0000000..39abdeb
--- /dev/null
+++ b/nl-list.c
@@ -0,0 +1,2105 @@
+/* n-list.c
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+
+#include "newlisp.h"
+#include "protos.h"
+
+extern SYMBOL * starSymbol;
+extern SYMBOL * plusSymbol;
+extern CELL * countCell;
+
+extern CELL * firstFreeCell;
+
+/* following used in count, difference, intersect, unique and sort 8.6.2 */
+CELL * * listToSortedVector(CELL * list, ssize_t * length, CELL * func, int indexFlag);
+CELL * resortVectorToList(CELL * * vector, ssize_t length);
+void binsort(CELL * * x, ssize_t n, CELL * pCell);
+
+
+CELL * p_map(CELL * params)
+{
+CELL * argsPtr;
+CELL * arg;
+CELL * argCell;
+CELL * funcPtr;
+CELL * cell;
+CELL * expr;
+CELL * results;
+CELL * res;
+CELL * cellIdx;
+UINT * resultIdxSave;
+
+funcPtr = evaluateExpression(params);
+
+/* get first of argument lists */
+params = getEvalDefault(params->next, &cell);
+
+argsPtr = cell = (cell->type == CELL_ARRAY) ?  
+    arrayList(cell, FALSE) : copyCell(cell);
+
+if(!isList(cell->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, cell));
+
+/* get rest of argument lists */
+while (params != nilCell)
+    {
+    params = getEvalDefault(params, &results);
+    cell->next = (results->type == CELL_ARRAY) ? 
+        arrayList(results, FALSE) : copyCell(results);
+
+    cell = cell->next;
+    if(!isList(cell->type))
+        return(errorProcExt(ERR_LIST_EXPECTED, results));
+    }
+
+results = getCell(CELL_EXPRESSION);
+res = NULL;
+
+cellIdx = initIteratorIndex();
+
+expr = getCell(CELL_EXPRESSION);
+cell = copyCell(funcPtr);
+expr->contents = (UINT)cell;
+
+/* prepeare for deletion now, in case of error 
+   in mapped function execution */
+
+pushResult(argsPtr);
+pushResult(expr);
+pushResult(results);
+
+resultIdxSave = resultStackIdx;
+
+while(argsPtr->contents != (UINT)nilCell) /* for all instances of a arg */
+    {
+    arg = argsPtr;
+    while(arg != nilCell)              /* for all args */
+        {
+        argCell = (CELL *)arg->contents; /* pop out first */
+        if(argCell == nilCell) break;
+        arg->contents = (UINT)argCell->next;
+        argCell->next = nilCell; /* unlink */
+        if(isSelfEval(argCell->type))
+            cell = cell->next = argCell;
+        else
+            cell = cell->next = makeCell(CELL_QUOTE, (UINT)argCell);
+        arg = arg->next;
+        }
+
+    cell = evaluateExpression(expr);
+    cell = copyCell(cell);
+    while(resultStackIdx > resultIdxSave)
+            deleteList(popResult());
+
+    if(res == NULL)
+        results->contents = (UINT)cell;
+    else
+        res->next = cell;
+    res = cell;
+    if(cellIdx->type == CELL_LONG) cellIdx->contents += 1; 
+    cell = (CELL *)expr->contents;
+    deleteList(cell->next);
+    }
+
+cell->next = nilCell; /* decouple */
+recoverIteratorIndex(cellIdx);
+
+symbolCheck = NULL;
+pushResultFlag = FALSE; /* results are already pushed */
+return(results);
+}
+
+
+CELL * explodeList(CELL * list, CELL * params)
+{
+ssize_t len = 1;
+ssize_t count = 1;
+CELL * cell = NULL;
+CELL * last = NULL;
+CELL * result = NULL;
+CELL * * lastChunk = NULL;
+int flag = FALSE;
+
+if(params != nilCell)
+    {
+    params = getInteger(params, (UINT*)&len);
+    flag = getFlag(params);
+    }
+
+result = getCell(CELL_EXPRESSION);
+
+if(len <= 0) return(result);
+
+while(list != nilCell)
+    {
+    if(result->contents == (UINT)nilCell)
+        {
+        cell = getCell(CELL_EXPRESSION);
+        lastChunk = (CELL * *)&result->contents;
+        result->contents = (UINT)cell;
+        cell->contents = (UINT)copyCell(list);
+        last = (CELL*)cell->contents;
+        }
+    else
+        {
+        if(count < len)
+            {
+            last->next = copyCell(list);
+            last = last->next;
+            count++;
+            }
+        else
+            {
+            cell->next = getCell(CELL_EXPRESSION);
+            lastChunk = (CELL * *)&cell->next;
+            cell = cell->next;
+            cell->contents = (UINT)copyCell(list);
+            last = (CELL*)cell->contents;
+            count = 1;
+            }
+        
+        }
+    list = list->next;
+    }
+    
+if(flag && count < len)
+    {
+    if(lastChunk)
+        {
+        deleteList(*lastChunk);
+        *lastChunk = nilCell;
+        }
+    }
+    
+return(result);
+}
+
+
+/* ---------------------- set primitives --------------------------------- */
+
+CELL * setInterDiff(CELL * params, int mode);
+
+
+#define SET_INTER 0
+#define SET_DIFF 1
+#define SET_UNIQUE 2
+
+CELL * p_intersect(CELL * params)
+{
+if(params->next == nilCell)
+    return(setInterDiff(params, SET_UNIQUE));
+else
+    return(setInterDiff(params, SET_INTER));
+}
+
+CELL * p_difference(CELL * params)
+{
+return(setInterDiff(params, SET_DIFF));
+}
+
+
+CELL * p_union(CELL * params)
+{
+CELL * result;
+CELL * appnd;
+
+appnd = makeCell(CELL_QUOTE, (UINT)p_append(params));
+result = setInterDiff(appnd, SET_UNIQUE);
+deleteList(appnd);
+
+return(result);
+}
+
+
+CELL * p_unique(CELL * params)
+{
+return(setInterDiff(params, SET_UNIQUE));
+}
+
+
+CELL * setInterDiff(CELL * params, int mode)
+{
+CELL * listA;
+CELL * listB = NULL;
+CELL * * vectorA;
+CELL * * vectorB = NULL;
+CELL * * vectorResult;
+ssize_t lengthA, lengthB = 0;
+ssize_t i = 0, j = 0, k = 0, top = 0;
+CELL * cell = NULL;
+CELL * result;
+int listMode = FALSE;
+int cmp, flag = FALSE;
+
+params = getListHead(params, &listA);
+if(listA == nilCell)
+    return(getCell(CELL_EXPRESSION));
+
+if(mode != SET_UNIQUE)
+    {
+    params = getListHead(params, &listB);
+    listMode = getFlag(params);
+
+    if(listA == listB)
+        {
+        flag = TRUE;
+        listA = copyList(listB);
+        }
+
+    if(listB == nilCell) 
+        {
+        if(mode == SET_INTER)
+            return(getCell(CELL_EXPRESSION));
+        listB = NULL;
+        }
+    }
+
+vectorA = listToSortedVector(listA, &lengthA, NULL, TRUE);
+
+vectorResult = callocMemory(lengthA * sizeof(CELL *));
+
+if(listB)
+    vectorB = listToSortedVector(listB, &lengthB, NULL, 0);
+
+result = getCell(CELL_EXPRESSION);
+
+while(i < lengthA)
+    {
+    if(listB) switch(mode)
+        {
+        case SET_INTER:
+            cmp = compareCells(vectorA[i], vectorB[j]);
+            if(cmp == 0) break;
+            if(cmp < 0)
+                {
+                ++i;
+                continue;
+                }      
+            if(j < (lengthB - 1)) ++j;
+            else ++i;
+            continue;
+
+        case SET_DIFF:
+            cmp = compareCells(vectorA[i], vectorB[j]);
+            if(cmp == 0)
+                {
+                ++i;
+                continue;
+                }
+            if(cmp < 0) break;
+            if(j < (lengthB - 1)) ++j;
+            else break;
+
+            continue;
+                            
+        case SET_UNIQUE:
+        default:
+            break;
+        }
+
+    /* if not in result or if list mode is specified */
+    if( (k == 0) || (compareCells(vectorA[i], vectorResult[top]) != 0) || (listMode == TRUE) )
+        {
+        top = k;
+        vectorResult[k++] = vectorA[i];
+        }
+
+    ++i;
+    }
+
+
+if(k > 0)
+    {
+    binsort(vectorResult, k, (CELL*)0xFFFFFFFF);
+    cell = copyCell(vectorResult[0]);
+    result->contents = (UINT)cell;
+
+    /* relinking */
+    for(i = 1; i < k; i++)
+        {
+        cell->next = copyCell(vectorResult[i]);
+        cell = cell->next;
+        }
+    cell->next = nilCell;
+    }
+
+free(vectorResult);
+
+cell = resortVectorToList(vectorA, lengthA);
+
+if(vectorB) free(vectorB);
+
+if(flag) deleteList(listA);
+
+return(result);
+}    
+
+/* ----------------------------------------------------------------------- */
+
+CELL * p_match(CELL * params)
+{
+CELL * cell;
+CELL * next;
+CELL * result;
+
+params = getEvalDefault(params, &cell);
+if(!isList(cell->type)) return(nilCell);
+params = getEvalDefault(params, &next);
+if(!isList(next->type)) return(nilCell);
+
+result = patternMatchL((CELL *)cell->contents, (CELL *)next->contents, getFlag(params));
+
+return(result ? result : getCell(CELL_EXPRESSION));
+}
+
+CELL * linkMatches(CELL * * matchList, CELL * matchPtr, CELL * elmnt)
+{
+if(*matchList == NULL)
+    {
+    *matchList = makeCell(CELL_EXPRESSION, (UINT)elmnt);
+    matchPtr = (CELL *)(*matchList)->contents;
+    }
+else
+    {
+    matchPtr->next = elmnt;
+    }
+
+while(matchPtr->next != nilCell)
+    matchPtr = matchPtr->next;
+
+return(matchPtr);
+}
+
+
+CELL * patternMatchL(CELL * pattern, CELL * list, int flag)
+{
+CELL * match;
+CELL * matchList = NULL;
+CELL * matches = NULL;
+CELL * starList = NULL;
+CELL * stars = NULL;
+
+MATCH_LIST:
+switch(pattern->type)
+    {
+    case CELL_NIL:
+    /* end of pattern and list */
+    if(list->type == CELL_NIL) 
+        {
+        if(starList) deleteList(starList);
+        return(matchList);
+        }
+        
+    goto NO_MATCH_RETURN;
+
+    case CELL_QUOTE:
+    case CELL_EXPRESSION:
+    case CELL_FEXPR:
+    case CELL_LAMBDA:
+        /* compare subexpressions */
+        if(list->type == pattern->type)
+            {
+            if((match = patternMatchL((CELL*)pattern->contents, (CELL*)list->contents, flag)) != nilCell)
+                {
+                if(match != NULL)
+                    {
+                    if(flag)
+                        matches = linkMatches(&matchList, matches, match);
+                    else
+                        {
+                        matches = linkMatches(&matchList, matches, (CELL*)match->contents);
+                        match->contents = (UINT)nilCell;
+                        deleteList(match);
+                        }
+                    }
+                pattern = pattern->next;
+                list = list->next;
+                goto MATCH_LIST;
+                }
+            }
+
+        goto NO_MATCH_RETURN;
+
+    case CELL_SYMBOL:
+        if(pattern->contents == (UINT)questionSymbol)   /* '?' */
+            {
+            if(list == nilCell) goto NO_MATCH_RETURN;
+            if(!flag) matches = linkMatches(&matchList, matches, copyCell(list));
+            break;
+            }
+
+        if(pattern->contents == (UINT)starSymbol ||
+           pattern->contents == (UINT)plusSymbol)   /* '*'  and '+' */
+            {
+            if(starList == NULL) 
+                {
+                starList = getCell(CELL_EXPRESSION);
+                }
+
+            if(stars == NULL && pattern->contents == (UINT)plusSymbol)
+                goto WILD_CARD_GREP;
+            
+            if(pattern->next == nilCell)
+                {
+                if(stars == NULL)
+                    starList->contents = (UINT)copyList(list);
+                else 
+                    stars->next = copyList(list);
+
+                linkMatches(&matchList, matches, starList);
+                return(matchList);
+                }
+
+            if((match = patternMatchL(pattern->next, list, flag)) != nilCell)
+                {
+                matches = linkMatches(&matchList, matches, starList);
+                if(match != NULL)
+                    {
+                    matches->next = (CELL*)match->contents;
+                    match->contents = (UINT)nilCell;
+                    deleteList(match);
+                    }
+                return(matchList);
+                }
+
+            if(list->next == nilCell)
+            goto NO_MATCH_RETURN;
+
+WILD_CARD_GREP:
+            if(pattern->contents == (UINT)plusSymbol)
+                if(list == nilCell) goto NO_MATCH_RETURN;
+
+            if(stars == NULL)
+                {
+                starList->contents = (UINT)copyCell(list);
+                stars = (CELL*)starList->contents;
+                }
+            else 
+                {
+                stars->next = copyCell(list);
+                stars = stars->next;
+                }
+
+            list = list->next;
+            goto MATCH_LIST;
+            }
+    default:
+        if(compareCells(pattern, list) != 0)
+        goto NO_MATCH_RETURN;
+
+        break;  
+    }
+
+if(flag) matches = linkMatches(&matchList, matches, copyCell(list));
+
+
+pattern = pattern->next;
+list = list->next;
+goto MATCH_LIST;
+
+NO_MATCH_RETURN:
+if(starList != NULL) deleteList(starList);
+if(matchList != NULL) deleteList(matchList);
+return(nilCell);
+}
+
+
+CELL * p_assoc(CELL * params)
+{
+CELL * key;
+CELL * list;
+int listMode;
+
+key = evaluateExpression(params);
+if((listMode = isList(key->type)))
+    key = (CELL *)key->contents;
+
+if(key == nilCell) key = copyCell(nilCell);
+
+getEvalDefault(params->next, &list);
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, list));
+
+list = (CELL *)list->contents;
+
+while(key != nilCell)
+    {
+    while(list != nilCell)
+        {
+        if(isList(list->type))
+            {
+            if(compareCells(key, (CELL *)list->contents) == 0)
+                break;
+            }
+        list = list->next;
+        }
+
+    if(!listMode || (key = key->next) == nilCell) break;
+    list = ((CELL *)list->contents)->next;
+    }
+
+if(list == nilCell) return(nilCell);
+
+pushResultFlag = FALSE;
+return(list);
+}
+
+
+CELL * p_lookup(CELL * params)
+{
+CELL * key;
+CELL * list;
+int listMode;
+ssize_t index;
+CELL * deflt = nilCell;
+SYMBOL * symbolRef;
+
+key = evaluateExpression(params);
+if((listMode = isList(key->type)))
+    key = (CELL *)key->contents;
+
+if(key == nilCell) key = copyCell(nilCell);
+
+params = getEvalDefault(params->next, &list);
+symbolRef = symbolCheck;
+
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, list));
+
+list = (CELL *)list->contents;
+
+if(params != nilCell)
+    deflt = getInteger(params, (UINT *)&index);
+else index = -1;
+
+while(key != nilCell)
+    {
+    while(list != nilCell)
+        {
+        if(isList(list->type))
+            if(compareCells(key, (CELL *)list->contents) == 0) break;
+        list = list->next;
+        }
+
+    if(!listMode || (key = key->next) == nilCell) break;
+    list = ((CELL *)list->contents)->next;
+    }
+
+if(list == nilCell)
+    return(copyCell(evaluateExpression(deflt)));    
+
+list = (CELL*)list->contents;
+
+if(index < 0) index = convertNegativeOffset(index, list);
+
+while(index--) 
+        {
+        if(list->next == nilCell) break;
+        list = list->next;
+        }
+
+symbolCheck = symbolRef;
+pushResultFlag = FALSE;
+return(list);
+}
+
+
+/* bind an association list, works like:
+   (define (bind L) (dolist (i L) (apply set i))) 
+   L => ((x 1) (y 2) (z 3))
+*/
+
+CELL * p_bind(CELL * params)
+{
+CELL * list;
+
+params = getListHead(params, &list);
+
+return(copyCell(bindList(list, getFlag(params))));
+}
+
+
+CELL * bindList(CELL * params, int evalFlag)
+{
+SYMBOL * lref = NULL;
+CELL * cell;
+CELL * old;
+
+while(params != nilCell)
+    {
+    if(params->type != CELL_EXPRESSION)
+        return(errorProcExt(ERR_LIST_EXPECTED, params));
+
+    cell = (CELL *)params->contents;
+    lref = getSymbolCheckProtected(cell);
+    old = (CELL *)lref->contents;
+    if(evalFlag)
+        lref->contents = (UINT)copyCell(evaluateExpression(cell->next));
+    else
+        lref->contents = (UINT)copyCell(cell->next);
+    deleteList(old);
+    params = params->next;
+    }
+
+if(lref == NULL)
+    return(nilCell);
+
+return((CELL *)lref->contents);
+}
+
+
+CELL * p_count(CELL * params)
+{
+CELL * items;
+CELL * list;
+CELL * result;
+CELL * * vectorItems;
+CELL * * vectorList;
+ssize_t lengthItems, lengthList;
+ssize_t i = 0, j = 0, idx; 
+int cmp;
+int flag = FALSE;
+CELL * cell;
+ssize_t * counts;
+
+params = getListHead(params, &items);
+getListHead(params, &list);
+
+result = getCell(CELL_EXPRESSION);
+
+if(items == nilCell)
+    return(result);
+    
+if(items == list)
+    {
+    flag = TRUE;
+    items = copyList(list);
+    }
+    
+vectorItems = listToSortedVector(items, &lengthItems, NULL, TRUE);
+vectorList = listToSortedVector(list, &lengthList, NULL, TRUE);
+
+counts = (ssize_t *)callocMemory(lengthItems * sizeof(ssize_t));
+
+if(vectorList)
+while(i < lengthList)
+    {
+    cmp = compareCells(vectorList[i], vectorItems[j]);
+    if(cmp == 0)
+        {
+        idx = (ssize_t)vectorItems[j]->next;
+        counts[idx] += 1;
+        ++i;
+        continue;
+        }
+    if(cmp < 0)
+        {
+        ++i;
+        continue;
+        }
+    if(j < (lengthItems - 1)) j++;
+    else i++;
+    }
+
+
+cell = stuffInteger(counts[0]);
+result->contents = (UINT)cell;
+for(i = 1; i < lengthItems; i++)
+    {
+    cell->next = stuffInteger(counts[i]);
+    cell = cell->next;
+    }
+freeMemory(counts);
+
+cell = resortVectorToList(vectorItems, lengthItems);
+if(vectorList) cell = resortVectorToList(vectorList, lengthList);
+
+if(flag) deleteList(items);
+
+return(result);
+}
+
+
+CELL * p_popAssoc(CELL * params)
+{
+CELL * key;
+CELL * list;
+CELL * original = NULL;
+CELL * previous = NULL;
+int listMode;
+
+key = evaluateExpression(params);
+if((listMode = isList(key->type)))
+    key = (CELL *)key->contents;
+
+if(key == nilCell) key = copyCell(nilCell);
+
+getEvalDefault(params->next, &list);
+
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, list));
+if(symbolCheck && isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+list->aux = (UINT)nilCell; /* undo last element optimization */
+original = list;
+list = (CELL *)list->contents;
+
+while(key != nilCell)
+    {
+    while(list != nilCell)
+        {
+        if(isList(list->type))
+            {
+            list->aux = (UINT)nilCell; /* undo last element optimization */
+            if(compareCells(key, (CELL *)list->contents) == 0) break;
+            }
+        previous = list;
+        list = list->next;
+        }
+
+    if(!listMode || (key = key->next) == nilCell) break;
+    previous = (CELL *)list->contents;
+    list = ((CELL *)list->contents)->next;
+    }
+
+if(list == nilCell) return(nilCell); /* key not found */
+
+if(previous == NULL)
+    original->contents = (UINT)list->next;
+else
+    previous->next = list->next;
+
+/* unlink */
+list->next = nilCell;
+return(list);   
+}
+
+void binsort(CELL * * x, ssize_t n, CELL * pCell)
+{
+ssize_t i,j,k,l,m,kf,lf;
+CELL * expr;
+CELL * cell;
+UINT * resultIndexSave;
+jmp_buf errorJumpSave;
+int errNo;
+CELL * * y;
+
+y = allocMemory(n * sizeof(CELL *));
+
+m = 1;
+while(m < n)
+    {
+    for(i = 0; i < n; i += 2*m)
+        {
+        k = i; l = i + m;
+        if(l >= n)
+            {
+            kf = lf = n;
+            l = lf + 1;
+            }
+        else 
+            {
+            kf = k + m - 1;
+            lf = l + m - 1;
+            }
+
+        if(lf >= n) lf = n - 1;
+
+        for(j = i; j <= lf; j++)
+            {
+            if(k > kf)
+                {
+                y[j] = x[l++]; 
+                continue;
+                }
+            if(l > lf)
+                {
+                y[j] = x[k++]; 
+                continue;
+                }
+                
+            if(pCell == NULL)
+                {
+                if(compareCells((CELL*)x[k], (CELL*)x[l]) <= 0)
+                    y[j] = x[k++];
+                else
+                    y[j] = x[l++];
+                continue;
+                }
+            if(pCell == (CELL*)0xFFFFFFFF)
+                {
+                if(((CELL*)x[k])->next <= ((CELL*)x[l])->next)
+                    y[j] = x[k++];
+                else
+                    y[j] = x[l++];
+                continue;
+                }
+
+            resultIndexSave = resultStackIdx;
+            expr = makeCell(CELL_EXPRESSION, (UINT)copyCell(pCell));
+
+            cell = (CELL *)expr->contents;
+            cell->next = makeCell(CELL_QUOTE, (UINT)copyCell((CELL*)x[k]));
+            cell = cell->next;
+
+            cell->next = makeCell(CELL_QUOTE, (UINT)copyCell((CELL*)x[l]));
+            
+            /* do result stack cleanup, and free memory under
+               error conditions */
+            memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+            if((errNo = setjmp(errorJump)) != 0)
+                {
+                memcpy(errorJump, errorJumpSave, (sizeof(jmp_buf)));
+                deleteList(expr);
+                cleanupResults(resultIndexSave);
+                free(x); /* allocates by parent routine */
+                free(y);
+                longjmp(errorJump, errNo);
+                }                                       
+
+            cell = evaluateExpression(expr);
+
+            memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+            if(!isNil(cell) && !isEmpty(cell))
+                y[j] = x[k++];
+            else
+                y[j] = x[l++];
+
+            deleteList(expr);
+            cleanupResults(resultIndexSave);
+            }
+        }
+
+    for(i = 0; i < n; i++) x[i] = y[i]; 
+    m = m * 2;
+    }
+    
+free(y);
+}
+
+CELL * * listToSortedVector(CELL * list, ssize_t * length, CELL * func, int indexFlag);
+
+CELL * p_sort(CELL * params)
+{
+CELL * list;
+CELL * cell;
+CELL * * vector;
+ssize_t length, i;
+SYMBOL * refSymbol;
+
+list = params;
+
+getEvalDefault(params, &cell);
+refSymbol = symbolCheck;
+
+if(symbolCheck && isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+if(isList(cell->type))
+    {
+    if(cell->contents == (UINT)nilCell)
+        return(getCell(CELL_EXPRESSION));
+    
+    cell->aux = (UINT)nilCell; /* undo last element optimization */
+
+    vector = listToSortedVector((CELL *)cell->contents, &length, list->next, 0);
+
+    /* relink cells */
+    list = vector[0];
+    --length;
+    i = 1;
+    while(length--)
+        {
+        list->next = vector[i];
+        list = list->next;
+        i++;
+        }
+    list->next = nilCell;
+
+    cell->contents = (UINT)vector[0];
+    freeMemory(vector);
+    }
+else if(cell->type == CELL_ARRAY)
+    {
+    vector = (CELL **)cell->contents;
+    length = (cell->aux - 1) / sizeof(UINT);
+    if(list->next == nilCell)
+        binsort(vector, length, NULL);
+    else
+        binsort(vector, length, list->next);
+    }
+else
+    return(errorProcExt(ERR_LIST_OR_ARRAY_EXPECTED, list));
+
+symbolCheck = refSymbol;
+pushResultFlag = FALSE;
+return(cell);
+}
+
+
+CELL * * listToSortedVector(CELL * list, ssize_t * length, CELL * func, int indexFlag)
+{
+CELL * * vector;
+CELL * prev;
+ssize_t i;
+
+if((*length = listlen(list)) == 0) return(NULL);
+
+/* build vector */
+vector = allocMemory(*length * sizeof(CELL *));
+for(i = 0; i < *length; i++)
+    {
+    vector[i] = prev = list;
+    list = list->next;
+    if(indexFlag) prev->next = (void *)i;
+    }
+if(func != nilCell && func != NULL)
+    {
+    func = evaluateExpression(func);
+    if(func->type == CELL_SYMBOL) 
+        func = (CELL*)((SYMBOL *)func->contents)->contents;
+    func = copyCell(func);
+    binsort(vector, *length, func);
+    deleteList(func);
+    } 
+else
+    binsort(vector, *length, NULL);
+
+return(vector);
+}
+
+
+CELL * resortVectorToList(CELL * * vector, ssize_t length)
+{
+CELL * list;
+ssize_t i;
+
+binsort(vector, length, (CELL*)0xFFFFFFFF);
+list  = vector[0];
+for(i = 1; i < length; i++)
+    {
+    list->next = vector[i];
+    list = list->next;
+    }
+list->next = nilCell;
+list = vector[0];
+free(vector);
+
+return(list);
+}
+
+/* called with params containing the indices 
+   or list of indices */
+
+CELL * implicitIndexList (CELL * list, CELL * params)
+{
+CELL * cell;
+ssize_t index;
+int evalFlag;
+
+cell = evaluateExpression(params);
+
+if(isNumber(cell->type))
+    {
+    getIntegerExt(cell, (UINT *)&index, FALSE);
+    params = params->next;
+    evalFlag = TRUE;
+    }
+else if(isList(cell->type))
+    {
+    params = (CELL*)cell->contents;
+    if(params == nilCell) return(list);
+    params = getIntegerExt(params, (UINT *)&index, FALSE);
+    evalFlag = FALSE;
+    }
+else return(errorProcExt(ERR_LIST_INDEX_INVALID, params));
+
+while(isList(list->type))
+    {
+    /* 10.3.1 catch changes in the list to be indexed 
+       caused by circular reference in index expression 
+       e.g (lst (set 'lst foo)) , when foo is a vector 
+    */
+    if(list->type == 255)
+        return(errorProc(ERR_LIST_REFERENCE_CHANGED));
+
+    /* last element optimization */
+    if(index == -1 && list->aux != (UINT)nilCell) 
+        list = (CELL *)list->aux;
+    else
+        {
+        list = (CELL *)list->contents;
+        if(index < 0) 
+            index = convertNegativeOffset(index, list);
+
+        while(index--)  list = list->next;
+
+        if(list == nilCell) 
+            errorProc(ERR_LIST_INDEX_INVALID);
+        }
+
+    if(params == nilCell || !isList(list->type))  break;
+    params = getIntegerExt(params, (UINT *)&index, evalFlag);
+    }
+
+return(list);
+}
+
+
+CELL * p_sequence(CELL * params)
+{
+double fromFlt, toFlt, interval, step, cntFlt;
+INT64 fromInt64 = 0, toInt64 = 0, stepCnt, i;
+CELL * sequence;
+CELL * cell;
+int intFlag;
+
+if((intFlag = (((CELL*)params->next)->next == nilCell)))
+    {
+    params = getInteger64Ext(params, &fromInt64, TRUE);
+    getInteger64Ext(params, &toInt64, TRUE);
+    stepCnt = (fromInt64 > toInt64) ? fromInt64 - toInt64 : toInt64 - fromInt64;
+    cell = stuffInteger64(fromInt64);
+    }
+else
+    {   
+    params = getFloat(params, &fromFlt);
+    params = getFloat(params, &toFlt);
+    getFloat(params, &step);
+
+    if(isnan(fromFlt) || isnan(toFlt) || isnan(step))
+        return(errorProc(ERR_INVALID_PARAMETER_NAN));
+
+    step = (step < 0) ? -step : step;
+    step = (fromFlt > toFlt) ? -step : step;
+    cntFlt = (fromFlt < toFlt) ? (toFlt - fromFlt)/step : (fromFlt - toFlt)/step;
+    stepCnt = (cntFlt > 0.0) ? floor(cntFlt + 0.0000000001) : floor(-cntFlt + 0.0000000001);
+    cell = stuffFloat(fromFlt);
+    }
+sequence = makeCell(CELL_EXPRESSION, (UINT)cell);
+
+for(i = 1; i <= stepCnt; i++)
+    {
+    if(intFlag)
+        {
+        if(fromInt64 > toInt64)
+            cell->next = stuffInteger(fromInt64 - i);
+        else
+            cell->next = stuffInteger(fromInt64 + i);
+        }
+    else
+        {
+        interval = fromFlt + i * step;
+        cell->next = stuffFloat(interval);
+        }
+    cell = cell->next;
+    }
+
+sequence->aux = (UINT)cell; /* last element optimization */
+return(sequence);
+}
+
+
+#define FILTER_FILTER 0
+#define FILTER_INDEX 1
+#define FILTER_CLEAN 2
+#define FILTER_FOR_ALL 3
+#define FILTER_EXISTS 4
+
+/* on EMSCRIPTEN, when compiling with -O1 or -O2, this is necessary
+   optimization messes up setjmp/longjmp
+*/
+
+#ifdef EMSCRIPTEN
+CELL * filterIndex(CELL * pCell, CELL * args, int mode);
+#else
+CELL * filterIndex(CELL * params, int mode);
+#endif
+
+
+CELL * p_filter(CELL * params)
+{
+#ifdef EMSCRIPTEN
+CELL * pCell;
+CELL * args;
+pCell = evaluateExpression(params);
+getEvalDefault(params->next, &args);
+if(!isList(args->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params->next));
+return filterIndex(pCell, args, FILTER_FILTER);
+#else
+return filterIndex(params, FILTER_FILTER);
+#endif
+}
+
+CELL * p_index(CELL * params)
+{
+#ifdef EMSCRIPTEN
+CELL * pCell;
+CELL * args;
+pCell = evaluateExpression(params);
+getEvalDefault(params->next, &args);
+if(!isList(args->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params->next));
+return filterIndex(pCell, args, FILTER_INDEX);
+#else
+return filterIndex(params, FILTER_INDEX);
+#endif
+}
+
+CELL * p_clean(CELL * params)
+{
+#ifdef EMSCRIPTEN
+CELL * pCell;
+CELL * args;
+pCell = evaluateExpression(params);
+getEvalDefault(params->next, &args);
+if(!isList(args->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params->next));
+return filterIndex(pCell, args, FILTER_CLEAN);
+#else
+return filterIndex(params, FILTER_CLEAN);
+#endif
+}
+
+CELL * p_exists(CELL * params)
+{
+#ifdef EMSCRIPTEN
+CELL * pCell;
+CELL * args;
+pCell = evaluateExpression(params);
+getEvalDefault(params->next, &args);
+if(!isList(args->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params->next));
+return filterIndex(pCell, args, FILTER_EXISTS);
+#else
+return filterIndex(params, FILTER_EXISTS);
+#endif
+}
+
+CELL * p_forAll(CELL * params)
+{
+#ifdef EMSCRIPTEN
+CELL * pCell;
+CELL * args;
+pCell = evaluateExpression(params);
+getEvalDefault(params->next, &args);
+if(!isList(args->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params->next));
+return filterIndex(pCell, args, FILTER_FOR_ALL);
+#else
+return filterIndex(params, FILTER_FOR_ALL);
+#endif
+}
+
+#ifdef EMSCRIPTEN
+CELL * filterIndex(CELL * pCell, CELL * args, int mode)
+#else
+CELL * filterIndex(CELL * params, int mode)
+#endif
+{
+CELL * expr;
+#ifndef EMSCRIPTEN
+CELL * pCell;
+CELL * args;
+#endif
+CELL * resultList = NULL;
+CELL * result;
+CELL * cell;
+UINT * resultIndexSave;
+jmp_buf errorJumpSave;
+ssize_t count;
+int errNo, trueFlag;
+
+#ifndef EMSCRIPTEN
+pCell = evaluateExpression(params);
+getEvalDefault(params->next, &args);
+
+if(!isList(args->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params->next));
+#endif
+
+args = (CELL *)args->contents;
+
+result = NULL;
+count = 0;
+resultIndexSave = resultStackIdx;
+
+memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+if((errNo = setjmp(errorJump)) != 0)
+    {
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    if(resultList) deleteList(resultList);
+    longjmp(errorJump, errNo);
+    }
+
+while(args != nilCell)
+    {
+    expr = makeCell(CELL_EXPRESSION, (UINT)copyCell(pCell));
+    cell = (CELL *)expr->contents;
+    cell->next = makeCell(CELL_QUOTE, (UINT)copyCell(args));
+
+    pushResult(expr);
+
+    cell = evaluateExpression(expr);
+
+    trueFlag = !isNil(cell) && !isEmpty(cell);
+
+    cleanupResults(resultIndexSave);
+
+    if(mode == FILTER_EXISTS && trueFlag)    
+        {
+        memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+        return(copyCell(args));
+        }
+
+    else if (mode == FILTER_FOR_ALL)
+        {
+        if(trueFlag) goto CONTINUE_FOR_ALL;
+        memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+        return(nilCell);
+        }
+
+    if((trueFlag && mode != FILTER_CLEAN) || (!trueFlag && mode == FILTER_CLEAN))
+        {
+        if(result == NULL)
+            {
+            resultList = makeCell(CELL_EXPRESSION, (mode == FILTER_INDEX) ? 
+                        (UINT)stuffInteger((UINT)count): (UINT)copyCell(args));
+            result = (CELL*)resultList->contents;
+            }
+        else
+            {
+            result->next = (mode == FILTER_INDEX) ?
+                        stuffInteger(count): copyCell(args);
+            result = result->next;
+            }
+        }
+
+    CONTINUE_FOR_ALL:
+    args = args->next;
+    count++;
+    }
+
+memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+
+if(mode == FILTER_EXISTS)
+    return(nilCell);
+
+if(mode == FILTER_FOR_ALL)
+    return(trueCell);
+
+if(resultList == NULL)
+    return(getCell(CELL_EXPRESSION));
+
+return(resultList);
+}
+
+
+#define MAX_REF_STACK 256
+typedef struct {
+    size_t * base;
+    size_t idx;
+    } REFSTACK;
+
+#define pushRef(A) (refStack->base[refStack->idx++] = (UINT)(A))
+#define popRef() (--refStack->idx)
+
+CELL * makeIndexVector(REFSTACK * refStack)
+{
+CELL * vector;
+CELL * next;
+int i;
+
+next = stuffInteger(refStack->base[0]);
+
+vector = makeCell(CELL_EXPRESSION, (UINT)next);
+
+for(i = 1; i < refStack->idx; i++)
+    {
+    next->next = stuffInteger(refStack->base[i]);
+    next = next->next;
+    }   
+    
+return(vector);
+}
+
+#define REF_SINGLE 0
+#define REF_ALL 1
+
+#define REF_INDEX 0
+#define REF_CONTENTS 1
+
+void ref(CELL * keyCell, CELL * list, CELL * funcCell, CELL * * head, 
+                        CELL * * next, REFSTACK * refStack, int mode)
+{
+size_t idx = 0;
+UINT * resultIdxSave = resultStackIdx;
+CELL * item;
+
+while(list != nilCell)
+    {
+    if(compareFunc(keyCell, list, funcCell) == 0)
+        {
+        if(refStack->base)
+            {
+            if(refStack->idx < MAX_REF_STACK) pushRef(idx);
+            else errorProc(ERR_NESTING_TOO_DEEP);
+            item = makeIndexVector(refStack);
+            popRef();
+            }       
+        else
+            {
+            if(mode == REF_SINGLE)
+                item = list;
+            else
+                item = copyCell(list);
+            }
+
+        if(*next == NULL)
+            *next = *head = item;
+        else
+            {
+            (*next)->next = item;
+            *next = (*next)->next;
+            }   
+
+        if(mode == REF_SINGLE) return;
+        countCell->contents++;
+        }
+
+    if(isList(list->type))
+        {
+        if(refStack->base)
+            {
+            if(refStack->idx < MAX_REF_STACK) pushRef(idx);
+            else errorProc(ERR_NESTING_TOO_DEEP);
+            }
+        ref(keyCell, (CELL*)list->contents, funcCell, head, next, refStack, mode);
+        if(refStack->base) popRef();
+        if(mode == REF_SINGLE && *head != NULL) 
+            return;
+        }
+
+    idx++;
+    cleanupResults(resultIdxSave);
+    list = list->next;
+    }
+}
+
+
+CELL * reference(CELL * params, int mode)
+{
+CELL * head = NULL;
+CELL * keyCell;
+CELL * list;
+CELL * funcCell = NULL;
+CELL * next = NULL;
+REFSTACK refStack = {NULL, 0};
+int flag = 0;
+SYMBOL * symbolRef;
+
+keyCell = evaluateExpression(params);
+params = getEvalDefault(params->next, &list);
+symbolRef = symbolCheck;
+
+if(params != nilCell)
+    {
+    funcCell = evaluateExpression(params);
+    flag = getFlag(params->next);
+    }
+
+if(!flag)
+    refStack.base = alloca((MAX_REF_STACK + 2) * sizeof(size_t));
+
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, list));
+
+ref(keyCell, (CELL *)list->contents, funcCell, &head, &next, &refStack, mode);
+
+if(mode == REF_SINGLE) 
+    {
+    if(head == NULL) return(nilCell);
+    if(flag) 
+        {
+        symbolCheck = symbolRef;
+        pushResultFlag = FALSE;
+        }
+    return(head);
+    }
+
+list = getCell(CELL_EXPRESSION);
+    
+list->contents = (UINT)((head == NULL) ? nilCell : head);
+
+return(list);
+}
+
+CELL * p_ref(CELL * params)
+{
+return(reference(params, REF_SINGLE));
+}
+
+CELL * p_refAll(CELL * params)
+{
+countCell->contents = 0;
+return(reference(params, REF_ALL));
+}
+
+
+#define SETREF_SINGLE 1
+#define SETREF_ALL 2
+
+CELL * modRef(CELL * key, CELL * list, CELL * func, CELL * new, int mode, int * count)
+{
+CELL * result;
+UINT * resultIdxSave = resultStackIdx;
+
+while(list != nilCell)
+    {
+    if(compareFunc(key, list, func) == 0)
+        {
+        *count += 1;
+        updateCell(list, new);
+        if(mode == SETREF_SINGLE) return(list);
+        countCell->contents++;
+        }
+    else if(isList(list->type))
+        {
+        result = modRef(key, (CELL *)list->contents, func, new, mode, count);
+        if(result != nilCell) return(result);
+        }
+
+    cleanupResults(resultIdxSave);
+    list = list->next;
+    }
+
+return(nilCell);
+}
+
+
+CELL * setRef(CELL * params, int mode)
+{
+CELL * key;
+CELL * list;
+CELL * new = NULL;
+CELL * funcCell = NULL;
+SYMBOL * refSymbol;
+int count = 0;
+
+key = evaluateExpression(params);
+new = getEvalDefault(params->next, &list);
+refSymbol = symbolCheck;
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, list));
+
+if(symbolCheck && isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+    
+if(new->next != nilCell)
+    funcCell = evaluateExpression(new->next);
+
+modRef(key, (CELL *)list->contents, funcCell, new, mode, &count);
+
+if(count == 0)
+    return(nilCell);
+
+symbolCheck = refSymbol;
+pushResultFlag = FALSE;
+return(list);
+}
+
+
+CELL * p_setRef(CELL * params)
+{
+return(setRef(params, SETREF_SINGLE));
+}
+
+CELL * p_setRefAll(CELL * params)
+{
+countCell->contents = 0;
+return(setRef(params, SETREF_ALL));
+}
+
+
+/* update a cell in-place and put a copy of previous content
+   in $it to be used in replacement expressions. 
+   Now only used in modeRef(), could be inlined.
+*/
+void updateCell(CELL * cell, CELL * val)
+{
+CELL * new;
+
+itSymbol->contents = (UINT)cell;
+
+if(val != nilCell)
+    {
+    new = copyCell(evaluateExpression(val)); 
+
+    /* delete contents of original cell */
+    if(isEnvelope(cell->type))
+        {
+        if(cell->type == CELL_ARRAY)
+            deleteArray(cell);
+        else
+            deleteList((CELL *)cell->contents);
+        }
+    else if(cell->type == CELL_STRING || cell->type == CELL_DYN_SYMBOL 
+#ifdef BIGINT
+            || cell->type == CELL_BIGINT
+#endif
+            ) 
+        freeMemory( (void *)cell->contents);
+
+    cell->type = new->type;
+    cell->aux = new->aux;
+    cell->contents = new->contents;
+
+    /* free the cell  */
+    new->type = CELL_FREE;
+    new->aux = 0;
+    new->contents = 0;
+    new->next = firstFreeCell;
+    firstFreeCell = new;
+    --cellCount;
+    }
+
+itSymbol->contents = (UINT)nilCell;
+}
+
+void flat(CELL * list, CELL * result, CELL * * next, UINT recursion)
+{
+while(list != nilCell)
+    {
+    if(isList(list->type) && recursion != 0)
+        flat((CELL*)list->contents, result, next, recursion - 1);
+    else
+        {
+        if(*next == NULL)
+            {
+            *next = copyCell(list);
+            result->contents = (UINT)*next;
+            }
+        else
+            {
+            (*next)->next = copyCell(list);
+            *next = (*next)->next;
+            }   
+        }
+
+    list = list->next;
+    }
+}
+
+
+CELL * p_flat(CELL * params)
+{
+CELL * list;
+CELL * result;
+CELL * next = NULL;
+UINT recursion = -1;
+
+params = getListHead(params, &list);
+if(params != nilCell)
+    getInteger(params, &recursion);
+
+result = getCell(CELL_EXPRESSION);
+
+flat(list, result, &next, recursion);
+
+return(result);
+}
+
+/* 
+    (collect <expr> [int-max-count]) 
+    collect results of evaluating <expr> while not nil
+    and optional max count is not reached
+*/
+CELL * p_collect(CELL * params)
+{
+CELL * result;
+CELL * cell;
+UINT * resultIdxSave = resultStackIdx;
+UINT count = MAX_LONG;
+
+result = getCell(CELL_EXPRESSION);
+if(params->next != nilCell)
+    getInteger(params->next, &count);
+
+while(count > 0)
+    {
+    cell = evaluateExpression(params);
+    if(isNil(cell)) break;
+    addList(result, copyCell(cell));
+    --count;
+    cleanupResults(resultIdxSave);
+    }
+
+return(result);
+}
+
+
+/* --------------------------------- array routines ------------------------- */
+
+
+CELL * initArray(CELL * array, CELL * list, CELL * * next);
+
+CELL * p_array(CELL * params)
+{
+ssize_t index[17];
+int p = 0;
+CELL * array = NULL;
+CELL * list = nilCell;
+CELL * next = NULL;
+SYMBOL * sPtr;
+
+while(params != nilCell && p < 17)
+    {
+    list = evaluateExpression(params);
+    if(isNumber(list->type))
+        {
+        getIntegerExt(list, (UINT*)&index[p], FALSE);
+        if(index[p] < 1) 
+            return(errorProcExt(ERR_WRONG_DIMENSIONS, list));
+        else p++;
+        }
+    else if(list->type == CELL_CONTEXT)
+        {
+        sPtr = translateCreateSymbol( ((SYMBOL*)list->contents)->name, CELL_NIL,
+            (SYMBOL*)list->contents, TRUE);
+        list = (CELL *)sPtr->contents;
+        }
+    else if(isList(list->type)) break;
+    else return(errorProcExt(ERR_NUMBER_EXPECTED, list));
+    params = params->next;
+    }
+
+if(p == 0)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+
+index[p] = 0;
+if(!isList(list->type)) list = nilCell;
+
+array = makeArray(index, 0);
+
+if(list != nilCell) 
+    array = initArray(array, list, &next);
+
+return(array);  
+}
+
+
+CELL * makeArray(ssize_t * index, int p)
+{
+CELL * array;
+CELL * list;
+CELL * * addr;
+ssize_t size;
+
+array = getCell(CELL_ARRAY);
+size = index[p];
+array->contents = (UINT)callocMemory(size * sizeof(UINT) + 1);
+array->aux = size * sizeof(UINT) + 1;
+addr = (CELL * *)array->contents;
+
+p++;
+if(index[p] > 0)
+    {
+    list = makeArray(index, p);
+    while(size--) *(addr++) = copyCell(list);
+    deleteList(list); 
+    return(array);
+    }
+else
+    while(size--) *(addr++) = copyCell(nilCell);
+
+return(array);
+}
+
+
+CELL * initArray(CELL * array, CELL * list, CELL * * next)
+{
+CELL * * addr;
+int size;
+
+size = (array->aux - 1) / sizeof(UINT);
+addr = (CELL * *)array->contents;
+
+while(size--)
+    {
+    if((*addr)->type == CELL_ARRAY)
+        {
+        *(addr) = initArray(*addr, list, next);
+        addr++;
+        continue;
+        }
+
+    if(*next == NULL || *next == nilCell)
+        {
+        deleteList(*addr);
+        *(addr++) = copyCell((CELL *)list->contents);
+        *next = (CELL*)list->contents;
+        *next = (*next)->next;
+        }
+    else    
+        {
+        deleteList(*addr);
+        *(addr++) = copyCell(*next);
+        *next = (*next)->next;
+        }
+    }
+
+return(array);
+}
+
+CELL * p_arrayList(CELL * params)
+{
+CELL * array;
+
+getEvalDefault(params, &array);
+
+if(array->type != CELL_ARRAY)
+    return(errorProcExt(ERR_ARRAY_EXPECTED, params));
+
+return(arrayList(array, TRUE));
+}
+
+CELL * arrayList(CELL * array, int flag)
+{
+CELL * list = NULL;
+CELL * * addr;
+CELL * new;
+CELL * cell;
+ssize_t size;
+
+addr = (CELL * *)array->contents;
+size = (array->aux - 1) / sizeof(UINT);
+
+while(size--)
+    {
+    cell = *(addr++);
+    if((cell->type == CELL_ARRAY) && flag)
+        new = arrayList(cell, flag);
+    else
+        new = copyCell(cell);
+    if(list == NULL)
+        {
+        array = list = makeCell(CELL_EXPRESSION, (UINT)new);
+        list = new;
+        }
+    else
+        {
+        list->next = new;
+        list = new;
+        }
+    }
+        
+return(array);
+}
+
+CELL * arrayTranspose(CELL * array)
+{
+ssize_t n, m, i, j;
+CELL * cell;
+CELL * * addr;
+CELL * * newAddr;
+CELL * * row;
+CELL * * newRow;
+CELL * newArray;
+
+addr = (CELL * *)array->contents;
+n = (array->aux - 1) / sizeof(CELL *);
+
+cell = *addr;
+if(cell->type != CELL_ARRAY)
+    return(errorProcExt(ERR_WRONG_DIMENSIONS, array));
+m = (cell->aux - 1) / sizeof(CELL *);
+
+newArray = getCell(CELL_ARRAY);
+newArray->aux = m  * sizeof(CELL *) + 1;
+newAddr = (CELL * *)callocMemory(newArray->aux);
+newArray->contents = (UINT)newAddr;
+
+for(j = 0; j < m; j++)
+    {
+    /* create new row vector */
+    cell = getCell(CELL_ARRAY);
+    cell->aux = n * sizeof(CELL *) + 1;
+    newRow = (CELL * *)callocMemory(cell->aux);
+    cell->contents = (UINT)newRow;
+    *(newAddr + j) = cell;
+    for( i = 0; i < n; i++)
+        {
+        cell = *(addr + i);
+        if(cell->type != CELL_ARRAY)
+            *(newRow + i) = copyCell(cell); 
+        else
+            {
+            row = (CELL * *)cell->contents;
+            if( (cell->aux - 1) / sizeof(CELL *) < (j + 1))
+                *(newRow + i) = nilCell;
+            else
+                *(newRow + i) = copyCell(*(row + j));
+            }
+        }
+    }   
+        
+return(newArray);
+}
+
+
+CELL * subarray(CELL * array, ssize_t offset, ssize_t length)
+{
+CELL * newArray;
+ssize_t size, i;
+CELL * * newAddr;
+CELL * * addr;
+
+size = (array->aux - 1) / sizeof(CELL *);
+if(offset < 0) offset = offset + size;
+if(offset >= size || offset < 0) 
+        return(errorProcExt2(ERR_ARRAY_INDEX_OUTOF_BOUNDS, stuffInteger(offset)));
+
+if(length < 0)
+    {
+    length = size - offset + length;
+    if(length < 0) length = 0;
+    }
+
+if(length == MAX_LONG && length > (size - offset))
+    length = size - offset;
+
+if(length == 0 || length > (size - offset))
+    return(errorProcExt2(ERR_ARRAY_INDEX_OUTOF_BOUNDS, stuffInteger(length)));
+
+addr = (CELL * *)array->contents;
+newArray = getCell(CELL_ARRAY);
+newArray->aux = length * sizeof(CELL *) + 1;
+newAddr = (CELL * *)callocMemory(newArray->aux);
+newArray->contents = (UINT)newAddr;
+
+for(i = 0; i < length; i++) 
+    *(newAddr + i) = copyCell(*(addr + offset + i));
+
+return(newArray);
+}
+
+
+/* copies an array */
+UINT * copyArray(CELL * array)
+{
+CELL * * newAddr;
+CELL * * orgAddr;
+CELL * * addr;
+ssize_t size;
+
+addr = newAddr = (CELL * *)callocMemory(array->aux);
+
+size = (array->aux - 1) / sizeof(UINT);
+orgAddr = (CELL * *)array->contents;
+
+while(size--)
+    *(newAddr++) = copyCell(*(orgAddr++));
+    
+return((UINT*)addr);
+}
+
+
+CELL * appendArray(CELL * array, CELL * params)
+{
+CELL * cell;
+CELL * * addr;
+ssize_t size, sizeCell;
+ssize_t i;
+CELL * * newAddr;
+int  deleteFlag = 0; 
+
+if(params == nilCell)
+    return(copyCell(array));
+
+START_APPEND_ARRAYS:
+size = (array->aux - 1) / sizeof(CELL *);
+addr = (CELL * *)array->contents;
+cell = evaluateExpression(params);
+if(cell->type != CELL_ARRAY)
+    return(errorProcExt(ERR_ARRAY_EXPECTED, params));
+sizeCell = (cell->aux - 1) / sizeof(CELL *);
+
+newAddr = allocMemory(array->aux + cell->aux -1);
+
+for(i = 0; i < size; i++)
+    *(newAddr + i) = copyCell(*(addr + i));
+
+addr = (CELL * *)cell->contents;
+
+for(i = 0; i < sizeCell; i++)
+    *(newAddr + size + i) = copyCell(*(addr + i));
+
+cell = getCell(CELL_ARRAY);
+cell->aux = (size + sizeCell) * sizeof(CELL *) + 1;
+cell->contents = (UINT)newAddr;
+
+if( (params = params->next) != nilCell)
+    {
+    if(deleteFlag)
+        deleteList(array);
+    deleteFlag = 1;
+    array = cell;
+    goto START_APPEND_ARRAYS;
+    }
+
+if(deleteFlag)
+    deleteList(array);
+
+symbolCheck = NULL;
+
+return(cell);
+}
+
+
+void deleteArray(CELL * array)
+{
+CELL * * addr;
+CELL * * mem;
+ssize_t size;
+
+mem = addr = (CELL * *)array->contents;
+size = (array->aux - 1) / sizeof(UINT);
+while(size--)
+    deleteList(*(addr++));
+
+freeMemory((char *)mem);
+}
+
+void printArray(CELL * array, UINT device)
+{
+CELL * list;
+
+list = arrayList(array, TRUE);
+
+printExpression(list, device);
+
+deleteList(list);
+}
+
+void printArrayDimensions(CELL * array, UINT device)
+{
+CELL * * addr;
+
+while(array->type == CELL_ARRAY)
+    {
+    varPrintf(device, "%d ", (array->aux - 1)/sizeof(CELL *));
+    addr = (CELL **)array->contents;
+    array = *addr;
+    }
+}
+
+
+CELL * implicitIndexArray(CELL * cell, CELL * params)
+{
+CELL * * addr;
+CELL * list;
+ssize_t size, index;
+int evalFlag;
+
+list = evaluateExpression(params);
+
+if(isNumber(list->type))
+    {
+    getIntegerExt(list, (UINT *)&index, FALSE);
+    params = params->next;
+    evalFlag = TRUE;
+    }
+else if(isList(list->type))
+    {
+    params = (CELL*)list->contents;
+    if(params == nilCell) return(cell);
+    params = getIntegerExt(params, (UINT *)&index, FALSE);
+    evalFlag = FALSE;
+    }
+else return(errorProcExt(ERR_ARRAY_INDEX_OUTOF_BOUNDS, params));
+
+while(cell->type == CELL_ARRAY)
+    {
+    addr = (CELL * *)cell->contents;
+    size = (cell->aux - 1) / sizeof(UINT);
+    if(index < 0) index = index + size;
+    if(index >= size || index < 0) 
+        return(errorProcExt2(ERR_ARRAY_INDEX_OUTOF_BOUNDS, stuffInteger(index)));
+    cell = *(addr + index);
+    if(params == nilCell || cell->type != CELL_ARRAY) break;
+    params = getIntegerExt(params, (UINT *)&index, evalFlag);
+    }
+
+return(cell);
+}
+
+
+int compareArrays(CELL * left, CELL * right)
+{
+CELL * * leftAddr;
+CELL * * rightAddr;
+ssize_t leftS, rightS;
+ssize_t result;
+
+leftAddr = (CELL * *)left->contents;
+rightAddr = (CELL * *)right->contents;
+leftS = (left->aux - 1) / sizeof(UINT);
+rightS = (right->aux - 1) / sizeof(UINT);
+
+if(leftS < rightS) return(-1);
+if(leftS > rightS) return(1);
+
+result = 0;
+while(leftS && result == 0)
+    {
+    result = compareCells(*(leftAddr++), *(rightAddr++));
+    leftS--; 
+    }
+
+return(result);
+}
+
+
+int compareFunc(CELL * left, CELL * right, CELL * func)
+{
+CELL * cell;
+CELL * expr;
+
+if(func == NULL) 
+    return(compareCells(left, right));
+
+expr = makeCell(CELL_EXPRESSION, (UINT)copyCell(func));
+
+pushResult(expr);
+
+cell = (CELL *)expr->contents;
+cell->next = makeCell(CELL_QUOTE, (UINT)copyCell((CELL*)left));
+cell = cell->next;
+cell->next = makeCell(CELL_QUOTE, (UINT)copyCell((CELL*)right));
+
+cell = evaluateExpression(expr);
+
+return(isNil(cell));
+}
+
+/* eof */
+
diff --git a/nl-liststr.c b/nl-liststr.c
new file mode 100644
index 0000000..2b1636f
--- /dev/null
+++ b/nl-liststr.c
@@ -0,0 +1,1705 @@
+/* nl-liststr.c --- newLISP primitives handling lists and strings
+
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+
+extern CELL * lastCellCopied;
+extern CELL * countCell;
+extern SYMBOL * sysSymbol[];
+extern SYMBOL * countSymbol;
+extern void printResultStack();
+
+/* used only on string indices */
+size_t adjustNegativeIndex(ssize_t index, size_t length)
+{
+if(index < 0) index = length + index;
+else if((index+1) > length) errorProc(ERR_STRING_INDEX_INVALID);
+
+if(index < 0) errorProc(ERR_STRING_INDEX_INVALID);
+
+return(index);
+}
+
+size_t adjustCount(ssize_t count, ssize_t length)
+{
+if(length <= 1 || count == 0 || length == count)
+    return(0);
+
+if(count > 0)
+    count = count % length;
+else
+    {
+    count = -count % length;
+    count = length - count;
+    }
+return(count);
+}
+
+#ifdef LINUX
+extern char * strcasestr(const char * haystack, const char * needle);
+#endif
+CELL * p_member(CELL * params)
+{
+CELL * key;
+CELL * list;
+INT options  = -1;
+char * ptr;
+ssize_t pos;
+
+key = evaluateExpression(params);
+
+params = getEvalDefault(params->next, &list);
+
+if(params != nilCell)
+    getInteger(params, (UINT *)&options);
+
+if(isList(list->type))
+    list = (CELL *)list->contents;
+else if (list->type == CELL_STRING)
+    {
+    if(key->type != CELL_STRING)
+        return(errorProcExt(ERR_STRING_EXPECTED, key));
+    if(options == -1)
+        {
+        ptr = strstr((char *)list->contents, (char *) key->contents);
+        if(ptr) return(stuffString(ptr));
+        }   
+    else
+        {
+        pos = searchBufferRegex((char*)list->contents, 0, (char *)key->contents, list->aux - 1, options, 0);
+        if(pos != -1) return(stuffString((char *)list->contents + pos));
+        }
+    return(nilCell);
+    }
+else 
+    return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, params->next));
+
+while(list != nilCell)
+    {
+    if(compareCells(key, list) == 0) break;
+    list = list->next;
+    }
+
+if(list == nilCell) return(nilCell);
+return(makeCell(CELL_EXPRESSION, (UINT)copyList(list)));
+}
+
+CELL * p_length(CELL * params)
+{
+size_t length;
+SYMBOL * symbol;
+#ifdef BIGINT
+int * bigintPtr;
+int * result;
+int len;
+#else
+INT64 number;
+double fnum;
+#endif
+
+params = evaluateExpression(params);
+length = 0;
+switch(params->type)
+    {
+#ifdef BIGINT
+    case CELL_LONG:
+#ifndef NEWLISP64
+    case CELL_INT64:
+#endif
+    case CELL_FLOAT:
+    case CELL_BIGINT:   
+        result = getBigintSizeDirect(params, &bigintPtr, &len);
+        length = lengthBigint(bigintPtr, len);
+        if(result) free(result);
+        break; 
+#else /* not BIGINT */
+    case CELL_LONG:
+#ifndef NEWLISP64
+    case CELL_INT64:
+#endif
+        getInteger64Ext(params, &number, FALSE);
+        if(number == 0)
+            length = 1;
+        else
+            {
+            if(number < 0) number = - number;
+            length = log(number) / log(10) + 1.5;
+            }
+        break;
+    case CELL_FLOAT:
+        getFloat(params, &fnum);
+        if(fnum == 0.0)
+            length = 1;
+        else
+            {
+            if(fnum < 0.0) fnum = - fnum;
+            length = log(fnum) / log(10) + 1.5;
+            }
+        break;
+#endif /* not BIGINT */
+    case CELL_STRING:
+        length = params->aux - 1; break;
+    case CELL_CONTEXT:
+        symbol = translateCreateSymbol( ((SYMBOL*)params->contents)->name, CELL_NIL,
+            (SYMBOL*)params->contents, TRUE);
+        params = (CELL *)symbol->contents;
+        if(params->type == CELL_STRING)
+            length = params->aux - 1;
+        else if(isList(params->type))
+            length = listlen((CELL *)params->contents);
+        else if(params->type == CELL_ARRAY)
+            length = (params->aux -1) / sizeof(UINT);
+        break;
+    case CELL_SYMBOL:
+        symbol = (SYMBOL *)params->contents;
+        length = strlen(symbol->name);
+        break;
+    case CELL_DYN_SYMBOL:
+        length = strlen((char *)params->contents);
+        break;
+    case CELL_EXPRESSION:
+    case CELL_LAMBDA:
+    case CELL_FEXPR:
+            length = listlen((CELL *)params->contents);
+        break;
+    case CELL_ARRAY:
+        length = (params->aux - 1) / sizeof(UINT);
+    default:
+        break;
+    }
+
+return(stuffInteger(length));
+}
+
+
+CELL * p_append(CELL * params)
+{
+CELL * list = NULL;
+CELL * firstCell = NULL;
+CELL * copy = NULL;
+CELL * cell;
+
+while(params != nilCell)
+    {
+    params = getEvalDefault(params, &cell);
+    if(!isList(cell->type))
+        {
+        if(copy == NULL)
+            {
+            if(cell->type == CELL_STRING)
+                return(appendString(cell, params, NULL, 0, FALSE, TRUE));
+            else if(cell->type == CELL_ARRAY)
+                return(appendArray(cell, params));
+            return(errorProcExt(ERR_ARRAY_LIST_OR_STRING_EXPECTED, cell));
+            }
+        
+        return(errorProcExt(ERR_LIST_EXPECTED, cell));
+        }
+
+    if(list == NULL)
+        list = getCell(cell->type);
+
+    copy = copyList((CELL *)cell->contents);
+
+    if(copy == nilCell) continue;
+
+    if(firstCell == NULL) list->contents = (UINT)copy;
+    else firstCell->next = copy;
+
+    firstCell = lastCellCopied;
+    }
+
+if(list == NULL)
+    return(getCell(CELL_EXPRESSION));
+
+symbolCheck = NULL;
+list->aux = (UINT)lastCellCopied; /* last element optimization */
+return(list);
+}
+
+
+CELL * appendString(CELL * cell, CELL * list, char * joint, size_t jointLen, int trailJoint, int evalFlag)
+{ 
+CELL * result;
+STREAM stream = {NULL, NULL, 0, 0, 0};
+char * sPtr;
+size_t len;
+
+openStrStream(&stream, MAX_LINE, 0);
+writeStreamStr(&stream, (char *)cell->contents, cell->aux - 1);
+while(list != nilCell)
+    {
+    if(joint == NULL)
+        {
+        list = getStringSize(list, &sPtr, &len, evalFlag);      
+        writeStreamStr(&stream, sPtr, len);
+        }
+    else
+        {
+        list = getStringSize(list, &sPtr, &len, FALSE);
+        if(jointLen) writeStreamStr(&stream, joint, jointLen);
+        writeStreamStr(&stream, sPtr, len);
+        }
+    }
+
+if(trailJoint)
+    writeStreamStr(&stream, joint, jointLen);
+
+result = stuffStringN(stream.buffer, stream.position);
+
+closeStrStream(&stream);
+
+symbolCheck = NULL;
+return(result);
+}
+
+
+CELL * p_extend(CELL * params)
+{
+CELL * target;
+CELL * head;
+CELL * tail;
+SYMBOL * symbolRef;
+char * pStr;
+size_t size;
+
+params = getEvalDefault(params, &target);
+if((symbolRef = symbolCheck))
+    {
+    if(isProtected(symbolRef->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolRef)));
+    if(isNil((CELL *)symbolRef->contents))
+        {
+        head = evaluateExpression(params); /* extension */
+        if(isList(head->type) || head->type == CELL_STRING)
+            {
+            target = copyCell(head);
+            deleteList((CELL*)symbolRef->contents);
+            symbolRef->contents = (UINT)target;
+            }
+        params = params->next;
+        }
+    }
+
+if(isList(target->type))
+    {
+    tail = (CELL *)target->aux;
+    target->aux = (UINT)nilCell;
+    if(tail == nilCell)
+        {
+        tail = (CELL *)target->contents;
+        while(tail->next != nilCell)
+            tail = tail->next;
+        }
+
+    while(params != nilCell)
+        {   
+        params = getListHead(params, &head);
+        if(head == nilCell) continue;
+        if(target->contents == (UINT)nilCell)
+            {
+            target->contents = (UINT)copyList(head);
+            tail = lastCellCopied;
+            }
+        else
+            {
+            tail->next = copyList(head);
+            target->aux = (UINT)lastCellCopied;
+            tail = (CELL *)target->aux;
+            }
+        }
+        
+    }   
+else if(target->type == CELL_STRING)
+    {
+    while(params != nilCell)
+        {
+        params = getStringSize(params, &pStr, &size, TRUE);
+        appendCellString(target, pStr, size);
+        }
+    }
+else return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, target));
+
+symbolCheck = symbolRef;
+pushResultFlag = FALSE;
+return(target);
+}
+
+
+
+CELL * p_chop(CELL * params)
+{
+size_t number = 1;
+size_t length = 0;
+CELL * next;
+#ifdef SUPPORT_UTF8
+char * ptr;
+#endif
+
+next = getEvalDefault(params, &params);
+
+if(next != nilCell)
+    getInteger(next, (UINT *)&number);
+
+if(params->type == CELL_STRING)
+    {
+#ifndef SUPPORT_UTF8
+    length = params->aux - 1;
+    if(number > length) number = length;
+    length = length - number;
+    return stuffStringN((char *)params->contents, length);
+#else
+    length = utf8_wlen((char *)params->contents, (char *)params->contents + params->aux);
+    if(number > length) number = length;
+    length = length - number;
+    ptr = (char *)params->contents;
+    ptr = utf8_index(ptr, length);
+    return stuffStringN((char *)params->contents, ptr - (char *)params->contents);
+#endif
+    }
+
+if(!isList(params->type))
+    return(errorProc(ERR_LIST_OR_STRING_EXPECTED)); 
+
+length = listlen((CELL *)params->contents);
+if(number > length) number = length;
+
+return(sublist((CELL *)params->contents, 0, length - number));
+}
+
+
+CELL * p_nth(CELL * params)
+{
+CELL * list; 
+CELL * cell;
+CELL * (*implicitIndexFunc)(CELL *, CELL *);
+SYMBOL * symbolRef;
+
+cell = getEvalDefault(params->next, &list); /* list or string to be indexed */
+symbolRef = symbolCheck;
+
+params = copyCell(params); /* indices */
+pushResult(params);
+
+if(isList(list->type)) 
+    implicitIndexFunc = implicitIndexList;
+else if(list->type == CELL_ARRAY) 
+    implicitIndexFunc = implicitIndexArray;
+else if(list->type == CELL_STRING)
+    {
+    list = implicitIndexString(list, params);
+    symbolCheck = symbolRef;
+    pushResult(list);
+    pushResultFlag = FALSE;
+    return(list);
+    }
+        
+else return(errorProcExt(ERR_LIST_EXPECTED, list));
+
+cell = (*implicitIndexFunc)(list, params);
+symbolCheck = symbolRef;
+pushResultFlag = FALSE;
+return(cell);
+}
+
+
+#define INSERT_BEFORE 0
+#define INSERT_AFTER 1
+#define INSERT_END 2
+CELL * p_push(CELL * params)
+{
+CELL * newCell;
+CELL * list;
+CELL * cell = NULL;
+CELL * listOrg;
+SYMBOL * symbolRef;
+int insert = 0, evalFlag = 0;
+ssize_t index;
+
+newCell = evaluateExpression(params);
+params = getEvalDefault(params->next, &list);
+listOrg = list;
+
+if((symbolRef = symbolCheck))
+    {
+    if(isProtected(symbolCheck->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+    if(isNil((CELL *)symbolCheck->contents))
+        {
+        deleteList((CELL*)symbolCheck->contents);
+        listOrg = makeCell(CELL_EXPRESSION, (UINT)copyCell(newCell));
+        symbolCheck->contents = (UINT)listOrg;
+        goto PUSH_RETURN;
+        }
+    }                                   
+
+if(!isList(list->type))
+    {
+    if(list->type == CELL_STRING)
+        {
+        pushOnString(newCell, list, params);
+        goto PUSH_RETURN;
+        }   
+    else
+        return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, list));
+    }
+
+if(params == nilCell) 
+    index = 0;
+else 
+    {
+    cell = (CELL*)params->next;
+    params = evaluateExpression(params);
+    if(isList(params->type))
+        {
+        evalFlag = FALSE;
+        params = getIntegerExt((CELL*)params->contents, (UINT*)&index, FALSE);
+        }
+    else 
+        {
+        evalFlag = TRUE;
+        getIntegerExt(params, (UINT*)&index, FALSE);
+        params = cell;
+        }
+    }
+
+if(index == -1) 
+    {
+    if(params == nilCell)
+        {
+        newCell = copyCell(newCell);
+        cell = (CELL*)list->aux;    
+        list->aux = (UINT)newCell;
+        if(cell != nilCell && cell != trueCell)
+            cell->next = newCell;
+        else if(list->contents == (UINT)nilCell)
+            list->contents = (UINT)newCell;
+        else
+            {
+            cell = (CELL *)list->contents;
+            while(cell->next != nilCell)
+                cell = cell->next;
+            cell->next = newCell;
+            }
+        goto PUSH_RETURN;
+        }
+    }
+    
+
+while(isList(list->type))
+    {
+    list->aux = (UINT)nilCell; /* undo last element optimization */
+    cell = list;
+    list = (CELL *)list->contents;
+
+    if(index < 0) 
+        {
+        index = listlen(list) + index;
+        if(index == -1) 
+            {
+            index = 0;
+            insert = INSERT_BEFORE;
+            }
+        else if(index >= 0) insert = INSERT_AFTER;
+        else errorProc(ERR_LIST_INDEX_INVALID);
+        }
+    else insert = INSERT_BEFORE;
+
+    while(index--) 
+        {
+        if(list == nilCell)
+            {
+            if(index >= 0) errorProc(ERR_LIST_INDEX_INVALID);
+            insert = INSERT_END;
+            break;
+            }
+        cell = list;
+        list = list->next;
+        }
+
+    if(params == nilCell || !isList(list->type))  break;
+    params = getIntegerExt(params, (UINT*)&index, evalFlag);
+    }
+
+newCell = copyCell(newCell);
+if(insert == INSERT_BEFORE || list == nilCell)
+    {
+    if(list == (CELL*)cell->contents)
+        {
+        cell->contents = (UINT)newCell;
+        newCell->next = list;
+        }
+    else
+        {
+        cell->next = newCell;
+        newCell->next = list;
+        }
+    }
+
+else if(insert == INSERT_AFTER || insert == INSERT_END)
+    {
+    cell = list->next;
+    list->next = newCell;
+    newCell->next = cell;
+    }
+
+PUSH_RETURN:
+symbolCheck = symbolRef;
+pushResultFlag = FALSE;
+return(listOrg);
+}
+
+
+CELL * p_pop(CELL * params)
+{
+CELL * list;
+CELL * envelope = NULL; /* suppress bogus warning on some compilers */
+CELL * cell;
+ssize_t index;
+int evalFlag = FALSE;
+
+params = getEvalDefault(params, &list);
+if(symbolCheck && isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+if(!isList(list->type))
+    {
+    if(list->type == CELL_STRING)
+        return(popString(list, params));
+    else
+        return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, list));
+    }
+
+/* no index, popping first */
+if(params == nilCell)
+    {
+    cell = (CELL *)list->contents;
+    list->contents = (UINT)cell->next;
+    if(cell->next == nilCell) /* check if only one element in list */
+        list->aux = (UINT)nilCell; /* undo last element optimization */
+    cell->next = nilCell;
+    return(cell);
+    }
+else
+    {
+    cell = (CELL*)params->next;
+    params = evaluateExpression(params);
+    if(isList(params->type))
+        {
+        evalFlag = FALSE;
+        params = getIntegerExt((CELL*)params->contents, (UINT*)&index, FALSE);
+        }
+    else 
+        {
+        evalFlag = TRUE;
+        getIntegerExt(params, (UINT*)&index, FALSE);
+        params = cell;
+        }
+    }
+
+/* pop with index */
+while(isList(list->type))
+    {
+    cell = envelope = list;
+    list = (CELL *)list->contents;
+
+    if(index < 0) index = convertNegativeOffset(index, list);
+
+    while(index--) 
+        {
+        cell = list;
+        list = list->next;
+        }
+    if(list == nilCell) 
+        errorProc(ERR_LIST_INDEX_INVALID);
+
+    if(params == nilCell || !isList(list->type)) break;
+    params = getIntegerExt(params, (UINT*)&index, evalFlag);
+    }
+
+if(list->next == nilCell) /* last cell is popped */
+    {
+    if(list == (CELL*)cell->contents) /* last is also first cell */
+        envelope->aux = (UINT)nilCell;        
+    else 
+        envelope->aux = (UINT)cell; /* cell is previous to last popped */
+    }
+
+if(list == (CELL*)cell->contents)
+    cell->contents = (UINT)list->next;
+else
+    cell->next = list->next;
+
+list->next = nilCell;
+return(list);
+}
+
+
+CELL * popString(CELL * str, CELL * params)
+{
+char * ptr;
+char * newPtr;
+ssize_t index = 0;
+ssize_t len = 1;
+ssize_t size;
+CELL * result;
+
+ptr = (char *)str->contents;
+
+#ifdef SUPPORT_UTF8
+size = utf8_wlen(ptr, (char *)str->contents + str->aux);
+#else
+size = str->aux - 1;
+#endif
+
+if(str->aux < 2)
+    return(stuffString(""));
+
+if(params != nilCell)
+    {
+    params = getInteger(params, (UINT*)&index);
+    if(params != nilCell) 
+        {
+        getInteger(params, (UINT*)&len);
+        if(len < 1) len = 0;
+        }
+    }
+
+index = adjustNegativeIndex(index, size);
+if((index + len) > size)
+    len = size - index;
+    
+#ifdef SUPPORT_UTF8
+newPtr = utf8_index(ptr, index);
+index = newPtr - ptr;
+
+newPtr = utf8_index(newPtr, len);
+len = newPtr - ptr;
+
+if(len > str->aux - 1)
+    return(errorProc(ERR_INVALID_UTF8));
+len -= index;
+#endif
+
+newPtr = callocMemory(str->aux - len);
+
+memcpy(newPtr, ptr, index);
+memcpy(newPtr + index, ptr + index + len, str->aux - len - index);
+str->aux = str->aux - len;
+str->contents = (UINT)newPtr;
+result = stuffStringN(ptr + index, len);
+free(ptr);
+return(result);
+}
+
+
+CELL * pushOnString(CELL * newStr, CELL * str, CELL * idx)
+{
+ssize_t index = 0;
+char * ptr;
+char * newPtr;
+int len;
+#ifdef SUPPORT_UTF8
+char * sptr;
+#endif
+
+if(idx != nilCell) getInteger(idx, (UINT*)&index);
+ptr = (char *)str->contents;
+
+if(newStr->type != CELL_STRING)
+    return(errorProcExt(ERR_STRING_EXPECTED, newStr));
+
+if(index == -1)
+    {
+    appendCellString(str, (char *)newStr->contents, newStr->aux - 1);
+    return(newStr);
+    }
+
+#ifndef SUPPORT_UTF8
+len = str->aux - 1;
+#else
+len = utf8_wlen(ptr, ptr + str->aux);
+#endif
+
+/* convert index into characters to skip before the new one is inserted */
+if(index < 0) index = len + index + 1;
+else if(index > len) index = len;
+if(index < 0) index = 0;
+
+newPtr = callocMemory(str->aux + newStr->aux - 1);
+#ifndef SUPPORT_UTF8
+memcpy(newPtr, ptr, index);
+memcpy(newPtr + index, (char*)newStr->contents, newStr->aux - 1);
+memcpy(newPtr + index + newStr->aux - 1, ptr + index, str->aux - index);
+#else
+sptr = utf8_index(ptr, index);
+memcpy(newPtr, ptr, sptr - ptr);
+memcpy(newPtr + (sptr - ptr), (char*)newStr->contents, newStr->aux - 1);
+memcpy(newPtr + (sptr - ptr) + newStr->aux - 1, sptr, str->aux - (sptr - ptr)  );
+#endif
+
+str->contents = (UINT)newPtr;
+str->aux = str->aux + newStr->aux - 1;
+*(newPtr + str->aux - 1) = 0;
+free(ptr);
+
+return(newStr);
+}
+
+
+CELL * p_select(CELL * params)
+{
+size_t n = 0, idx  = 0; 
+ssize_t index;
+CELL * list, * cell;
+CELL * result = NULL;
+CELL * head;
+int evalFlag = TRUE;
+char * str, * newStr;
+#ifdef SUPPORT_UTF8
+int * wstr;
+int * wnewStr;
+size_t len;
+#endif
+
+params = getEvalDefault(params, &head);
+cell = evaluateExpression(params);
+if(isList(cell->type))
+    {
+    evalFlag = FALSE;
+    cell = params = (CELL *)cell->contents;
+    }
+
+if(head->type == CELL_STRING)
+    {
+    if((n = listlen(params)) == 0) return(stuffString(""));
+    
+    str = (char *)head->contents;
+#ifndef SUPPORT_UTF8
+    newStr = (char *)allocMemory(n + 1);
+    idx = 0;
+    while(params->type != CELL_NIL)
+        {
+        if(idx == 0)
+            {
+            getIntegerExt(cell, (UINT *)&index, FALSE);
+            params = params->next;
+            }
+        else
+            params = getIntegerExt(params, (UINT *)&index, evalFlag);
+        index = adjustNegativeIndex(index, head->aux -1);
+        *(newStr + idx++) = *(str + index);
+        }
+    *(newStr + n) = 0;
+#else
+    wstr = allocMemory(head->aux * sizeof(int));
+    len = utf8_wstr(wstr, str, head->aux - 1);
+    wnewStr = allocMemory((n + 1) * sizeof(int));
+    idx = 0;
+    while(params->type != CELL_NIL)
+        {
+        if(idx == 0)
+            {
+            getIntegerExt(cell, (UINT *)&index, FALSE);
+            params = params->next;
+            }
+        else
+            params = getIntegerExt(params, (UINT *)&index, evalFlag);
+        index = adjustNegativeIndex(index, len);
+        *(wnewStr + idx++) = *(wstr + index);
+        }
+    *(wnewStr + n) = 0;
+    newStr = allocMemory(UTF8_MAX_BYTES * n + 1);
+    n = wstr_utf8(newStr, wnewStr, UTF8_MAX_BYTES * n);
+    newStr = reallocMemory(newStr, n + 1);
+    free(wstr); free(wnewStr);
+#endif
+    result = getCell(CELL_STRING);
+    result->aux = n + 1;
+    result->contents = (UINT)newStr;    
+    return(result);
+    }
+
+if(!isList(head->type))
+    return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, head));
+head = (CELL *)head->contents;
+list = head;
+n = 0;
+while(params->type != CELL_NIL)
+    {
+    if(n++ == 0)
+        {
+        getIntegerExt(cell, (UINT *)&index, FALSE);
+        params = params->next;
+        }
+    else
+        params = getIntegerExt(params, (UINT *)&index, evalFlag);
+    if(index < 0) index = convertNegativeOffset(index, head);
+    if(index < idx) list = head, idx = 0;
+    while(idx < index  && list != nilCell) list = list->next, idx++; 
+    if(list == nilCell) 
+        errorProc(ERR_LIST_INDEX_INVALID);
+    if(result == NULL)
+        {
+        result = getCell(CELL_EXPRESSION);
+        cell = copyCell(list);
+        result->contents = (UINT)cell;
+        }
+    else
+        {
+        cell->next = copyCell(list);
+        cell = cell->next;
+        }
+    }
+
+return((result == NULL) ? getCell(CELL_EXPRESSION) : result);
+}   
+
+
+CELL * p_slice(CELL * params)
+{
+CELL * cell;
+ssize_t offset;
+ssize_t length;
+
+params = getEvalDefault(params, &cell);
+params = getInteger(params, (UINT *)&offset);
+if(params != nilCell)
+    getInteger(params, (UINT *)&length);
+else
+    length = MAX_LONG;
+
+if(isList(cell->type))
+    return(sublist((CELL *)cell->contents, offset, length));
+else if(cell->type == CELL_STRING)
+    return(substring((char *)cell->contents, cell->aux - 1, offset, length));
+else if(cell->type == CELL_ARRAY)
+    return(subarray(cell, offset, length));
+
+return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, params));
+}
+
+
+CELL * sublist(CELL * list, ssize_t offset, ssize_t length)
+{
+CELL * subList;
+CELL * cell;
+
+if(offset < 0) 
+    offset = convertNegativeOffset(offset, list);
+
+if(length < 0)
+    {
+    length = listlen(list) - offset + length;
+    if(length < 0) length = 0;
+    }
+
+subList = getCell(CELL_EXPRESSION);
+if(length == 0) return(subList);
+
+while(offset-- && list != nilCell)
+    list = list->next;
+
+if(list == nilCell) return(subList);
+
+cell = copyCell(list);
+subList->contents = (UINT)cell;
+--length;
+while(length--) 
+    {
+    list = list->next;
+    if(list == nilCell) break;
+    cell->next = copyCell(list);
+    cell = cell->next;
+    }
+
+return(subList);
+}
+
+
+CELL * p_reverse(CELL * params)
+{
+CELL * cell;
+CELL * list;
+CELL * previous;
+CELL * next;
+char * str;
+char * left;
+char * right;
+CELL * * addr;
+CELL * * leftA;
+CELL * * rightA;
+size_t len, tmp;
+
+cell = params;
+getEvalDefault(params, &list);
+if(symbolCheck && isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+if(isList(list->type))
+    {
+    list->aux = (UINT)nilCell; /* undo last element optimization */
+
+    previous = cell = (CELL*)list->contents;
+    next = cell->next;
+    cell->next = nilCell;
+    while(cell!= nilCell)
+        {
+        previous = cell;
+        cell = next;
+        next = cell->next;
+        if(cell != nilCell) cell->next = previous;
+        }
+    list->contents = (UINT)previous;
+    }
+
+else if(list->type == CELL_STRING)
+    {
+    str = (char *)list->contents;
+    len = list->aux - 1;
+    left = str;
+    right = left + len - 1;
+    while(left < right)
+        {
+        tmp = *left;
+        *left = *right;
+        *right = tmp;
+        left++;
+        right--;
+        }
+    }
+
+else if(list->type == CELL_ARRAY)
+    {
+    addr = (CELL * *)list->contents;
+    len = (list->aux - 1) / sizeof(UINT);
+    leftA = addr;
+    rightA = leftA + len - 1;
+    while(leftA < rightA)
+        {
+        cell = *leftA;
+        *leftA = *rightA;
+        *rightA = cell;
+        leftA++;
+        rightA--;
+        }
+    }
+    
+else return(errorProcExt(ERR_ARRAY_LIST_OR_STRING_EXPECTED, cell));
+
+pushResultFlag = FALSE;
+return(list);
+}
+
+
+CELL * p_join(CELL * params)
+{
+char * joint = NULL;
+CELL * list;
+size_t jointLen = 0;
+int trailJoint = 0;
+
+params = getListHead(params, &list);
+if(list == nilCell)
+    return(stuffString(""));
+
+if(list->type != CELL_STRING)
+    return(errorProcExt(ERR_STRING_EXPECTED, list));
+
+if(params != nilCell)
+    {
+    params = getStringSize(params, &joint, &jointLen, TRUE);
+    trailJoint = getFlag(params);
+    }
+
+return(appendString(list, list->next, joint, jointLen, trailJoint, FALSE));
+}
+
+
+CELL * p_find(CELL * params) 
+{
+char * key;
+char * str;
+ssize_t found;
+CELL * next;
+CELL * keyCell;
+CELL * funcCell;
+size_t size;
+INT options = -1;
+size_t offset = 0;
+UINT * resultIdxSave;
+
+keyCell = evaluateExpression(params);
+params = getEvalDefault(params->next, &next);
+
+if(keyCell->type == CELL_STRING && next->type == CELL_STRING)
+    {
+    key = (char *)keyCell->contents;
+    str = (char *)next->contents;
+    size = next->aux - 1;
+
+    if(params != nilCell)
+        {
+        if(params->next != nilCell)
+            getInteger(params->next, (UINT*)&offset);
+        if(offset > size) offset = size;
+        params = evaluateExpression(params);
+        if(!isNil(params))
+            /* 10.6.1 also accept string for options */
+            parseRegexOptions(params, (UINT *)&options, FALSE);
+        }
+
+    if(options == -1)
+        found = searchBuffer(str + offset, size - offset, key, keyCell->aux - 1, TRUE);
+    else
+        found = searchBufferRegex(str, offset, key, size, options, NULL) - offset;
+    if(found < 0) return(nilCell);
+    }
+else
+    {
+    /* list mode with optional functor */
+    if(!isList(next->type)) 
+        return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, next));
+    next = (CELL *)next->contents;
+    found = 0;
+
+    if(params != nilCell)
+        funcCell = evaluateExpression(params);
+    else funcCell = NULL;
+
+    /* do regex when first arg is string and option# is present */
+    if(funcCell && 
+        (isNumber(funcCell->type) || funcCell->type == CELL_STRING) &&
+        keyCell->type == CELL_STRING)
+        {
+        /* 10.6.1 also accept string for options */
+        parseRegexOptions(funcCell, (UINT *)&options, FALSE);
+        key = (char *)keyCell->contents;
+        while(next != nilCell)
+            {
+            if(next->type == CELL_STRING)
+                {
+                if(searchBufferRegex((char *)next->contents, 0, 
+                        key, next->aux - 1 , options, NULL) != -1) break;
+                }
+            found++;
+            next = next->next;
+            }
+        if(next == nilCell) return(nilCell);
+        else return(stuffInteger(found));
+        }
+
+    resultIdxSave = resultStackIdx;
+    while(next != nilCell)
+        {
+        if(compareFunc(keyCell, next, funcCell) == 0)
+            {
+            if(funcCell)
+                {
+                deleteList((CELL*)sysSymbol[0]->contents);
+                sysSymbol[0]->contents = (UINT)copyCell(next);
+                }
+            break;
+            }
+        found++;
+        next = next->next;
+        cleanupResults(resultIdxSave);
+        }
+    if(next == nilCell) return(nilCell);
+    }
+
+return(stuffInteger(found + offset));
+}
+
+/* ------- find-all ---- finds all strings matching a pattern in a list ----- */
+
+CELL * findAllString(char * pattern, char * str, size_t size, CELL * params)
+{
+INT options = 0;
+ssize_t findPos = -1;
+ssize_t lastPos = -1;
+CELL * result = nilCell;
+CELL * exprCell;
+CELL * exprRes;
+CELL * cell = NULL;
+UINT * resultIdxSave;
+jmp_buf errorJumpSave;
+int errNo; 
+size_t len;
+size_t offset = 0;
+
+exprCell = params;
+if((params = params->next) != nilCell)
+    /* 10.6.1 also accept string for options */
+    parseRegexOptions(params, (UINT *)&options, TRUE);
+
+resultIdxSave = resultStackIdx;
+countCell->contents = 0;
+    
+if(exprCell != nilCell)
+    {
+    memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+    if((errNo = setjmp(errorJump)) != 0)
+        {
+        memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+        if(result != nilCell) deleteList(result);
+        longjmp(errorJump, errNo);
+        }   
+    }
+
+while( (findPos = searchBufferRegex(str, offset, pattern, size, options, &len)) 
+       != -1)
+    {
+    countCell->contents++;
+    if(exprCell != nilCell)
+        {
+        itSymbol->contents = sysSymbol[0]->contents;
+        exprRes = evaluateExpression(exprCell);
+        exprRes = copyCell(exprRes);
+        }
+    else
+        exprRes = stuffStringN(str + findPos, len);
+
+    if(lastPos == findPos)
+        {
+        ++findPos;
+        pushResult(exprRes);
+        goto FINDALL_CONTINUE;
+        }   
+
+    lastPos = findPos;
+
+    if(result == nilCell)
+        {
+        cell = exprRes;
+        result = makeCell(CELL_EXPRESSION, (UINT)cell);
+        }
+    else
+        {
+        cell->next = exprRes;
+        cell = cell->next;
+        }
+
+    FINDALL_CONTINUE:
+    offset = (findPos + len);
+    if(findPos > size) break;
+    cleanupResults(resultIdxSave);
+    }
+
+itSymbol->contents = (UINT)nilCell;
+
+if(exprCell != nilCell)
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+
+return(result == nilCell ? getCell(CELL_EXPRESSION) : result);
+}
+
+
+CELL * findAllList(CELL * pattern, CELL * list, CELL * exprCell)
+{
+CELL * result;
+CELL * exprRes;
+CELL * match;
+CELL * funcCell;
+UINT * resultIdxSave;
+jmp_buf errorJumpSave;
+int errNo;
+
+funcCell = evaluateExpression(exprCell->next);
+resultIdxSave = resultStackIdx;
+countCell->contents = 0;
+
+result = getCell(CELL_EXPRESSION);
+
+memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+if((errNo = setjmp(errorJump)) != 0)
+    {
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    deleteList(result);
+    longjmp(errorJump, errNo);
+    }
+
+while(list != nilCell)
+    {
+    if(funcCell == nilCell)
+        {
+        /* added in 10.4.7, this makes exp in func in 3rd syntax optional */
+        if(!isList(pattern->type))
+            {
+            if(compareFunc(pattern, list, NULL) != 0)
+                goto CONTINUE_NEXT;
+            }
+        else 
+            {
+            /* match only takes lists*/
+            if(!isList(list->type))
+                goto CONTINUE_NEXT;
+
+            match = patternMatchL((CELL *)pattern->contents, (CELL *)list->contents, TRUE);
+
+            if(match == NULL || match == nilCell)
+                goto CONTINUE_NEXT;
+
+            deleteList(match);
+            }
+        }
+    else
+        {
+        cleanupResults(resultIdxSave);
+        if(compareFunc(pattern, list, funcCell) != 0)
+            goto CONTINUE_NEXT;
+        }
+
+    countCell->contents++;
+    itSymbol->contents = (UINT)list;
+
+    if(exprCell != nilCell)
+        exprRes = evaluateExpression(exprCell);
+    else 
+        exprRes = list;
+
+    addList(result, copyCell(exprRes));
+    /* increment $count here */
+
+    CONTINUE_NEXT:  
+    list = list->next;
+    }
+
+memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+
+itSymbol->contents = (UINT)nilCell;
+return(result);
+}
+
+
+CELL * p_findAll(CELL * params)
+{
+CELL * key;
+CELL * space;
+
+key = evaluateExpression(params);
+params = getEvalDefault(params->next, &space);
+
+if(key->type == CELL_STRING && space->type == CELL_STRING)
+    return(findAllString((char *)key->contents, 
+            (char *)space->contents,  (size_t) space->aux - 1, params));
+
+if(!isList(space->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, space));
+
+return(findAllList(key, (CELL *)space->contents, params));
+}
+
+
+void swap(UINT * left, UINT * right)
+{
+UINT tmp;
+
+tmp = *left;
+*left = *right;
+*right = tmp;
+}
+
+
+CELL * getRefCheckProtected(CELL * params)
+{
+CELL * ref;
+
+ref = evaluateExpression(params);
+
+if(ref == nilCell || ref == trueCell)
+    errorProcExt(ERR_IS_NOT_REFERENCED, ref);
+
+if(symbolCheck != NULL)
+    {
+    if(isProtected(symbolCheck->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+    }
+
+return(ref);
+}
+
+
+CELL * p_swap(CELL * params)
+{
+CELL * firstCell;
+CELL * secondCell;
+
+firstCell = getRefCheckProtected(params);
+secondCell = getRefCheckProtected(params->next);
+swap(&firstCell->type, &secondCell->type);
+swap(&firstCell->contents, &secondCell->contents);
+swap(&firstCell->aux, &secondCell->aux);
+pushResultFlag = FALSE;
+return(secondCell);
+}
+
+
+CELL * p_dup(CELL * params)
+{
+CELL * list;
+CELL * expr;
+char * str;
+ssize_t n, len;
+
+expr = evaluateExpression(params);
+if((params = params->next) != nilCell)
+    getInteger(params, (UINT *)&n);
+else 
+    {
+    n = 2;
+    symbolCheck = NULL;
+    }
+
+if(n < 0) n = 0;
+
+if(expr->type == CELL_STRING && !getFlag(params->next) )
+    {
+    len = expr->aux - 1;
+    list = getCell(CELL_STRING);
+    str = allocMemory(len * n + 1);
+    list->contents = (UINT)str;
+    list->aux = (len * n + 1);
+    *(str + len * n) = 0;
+    while(n--) 
+        {
+        memcpy(str, (char *)expr->contents, len);
+        str += len;
+        }
+    return(list);
+    }
+
+list = getCell(CELL_EXPRESSION);
+if(n-- > 0) 
+    {
+    list->contents = (UINT)copyCell(expr);
+
+    params = (CELL *)list->contents;
+    while(n--)
+        {
+        params->next = copyCell(expr);
+        params = params->next;
+        }
+    }
+
+return(list);
+}
+
+
+#define STARTS_WITH 0
+#define ENDS_WITH 1
+
+CELL * startsEndsWith(CELL * params, int type)
+{
+char * string;
+char * key;
+char * keydollar;
+INT options = -1;
+size_t slen, pos;
+size_t klen;
+CELL * cell, * list;
+
+cell = params->next;
+getEvalDefault(params, &list);
+if(list->type == CELL_STRING)
+    {
+    string = (char *)list->contents;
+    getString(cell, &key);
+    }
+else
+    {
+    if(!isList(list->type))
+        errorProcExt(ERR_LIST_OR_STRING_EXPECTED, params);
+
+    cell = evaluateExpression(cell);
+
+    list = (CELL *)list->contents;
+   
+    if(type == ENDS_WITH)
+        while(list->next != nilCell) list = list->next;
+
+    if(compareCells(list, cell) == 0) return(trueCell);
+    else return(nilCell);
+    }
+
+if(cell->next != nilCell)
+    {
+    cell = evaluateExpression(cell->next);
+    /* 10.6.1 also accept string for options */
+    parseRegexOptions(cell, (UINT *)&options, FALSE);
+    }
+
+klen = strlen(key);
+slen = strlen(string);
+
+if(type == STARTS_WITH)
+    {
+    if(options == -1) 
+        {
+        if(strncmp(string, key, (size_t)klen) == 0)
+            return(trueCell);
+        }
+    else  
+        {
+        if(searchBufferRegex(string, 0, key, slen, options, 0) == 0)
+            return(trueCell);
+        }
+    return(nilCell);
+    }
+
+
+if((options == -1) && (klen > slen)) return(nilCell);
+
+if(options == -1) 
+    {
+    if(strncmp(string + slen - klen, key, klen) == 0)
+        return(trueCell);
+    }
+else
+    {
+    /* append $ to the pattern for anchoring at the end */
+    keydollar = malloc(klen + 4);
+    *keydollar = '(';
+    memcpy(keydollar + 1, key, klen);
+    memcpy(keydollar + 1 + klen, ")$", 2);
+    *(keydollar + klen + 3) = 0;
+    klen = klen + 3;
+    if((pos = searchBufferRegex(string, 0, keydollar, slen, options, &klen)) != -1) 
+        {
+        if(pos + klen == slen)
+            {
+            free(keydollar);
+            return(trueCell);
+            }
+        }
+    free(keydollar);
+    }
+
+return(nilCell);
+}
+
+CELL * p_startsWith(CELL * params) { return startsEndsWith(params, STARTS_WITH); }
+CELL * p_endsWith(CELL * params) { return startsEndsWith(params, ENDS_WITH); }
+
+CELL * p_replace(CELL * params)
+{
+CELL * keyCell;
+CELL * repCell;
+CELL * funcCell = NULL;
+CELL * list;
+CELL * cell;
+CELL * newList;
+char * keyStr;
+char * buff;
+char * newBuff;
+size_t newLen;
+INT options;
+UINT * resultIdxSave;
+SYMBOL * refSymbol;
+
+keyCell = copyCell(evaluateExpression(params));
+pushResult(keyCell);
+params = getEvalDefault(params->next, &cell);
+newList = cell;
+refSymbol = symbolCheck;
+if(symbolCheck && (isProtected(symbolCheck->flags) || isBuiltin(symbolCheck->flags)))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+countCell->contents = 0;
+resultIdxSave = resultStackIdx;
+if(isList(cell->type))
+    {
+    cell->aux = (UINT)nilCell; /* undo last element optimization */
+
+    list = (CELL *)cell->contents;
+
+    if(params != nilCell)
+        {
+        repCell = params;
+        if(params->next != nilCell)
+            funcCell = evaluateExpression(params->next);
+        }
+    else
+        repCell = NULL;
+
+COMPARE_START:
+    if(compareFunc(keyCell, list, funcCell) == 0)
+        {
+        countCell->contents++;
+        if(repCell != NULL)
+            {
+            itSymbol->contents = (UINT)list;
+            cell->contents = (UINT)copyCell(evaluateExpression(repCell));
+            cell = (CELL*)cell->contents;
+            cell->next = list->next;
+            }
+        else /* remove mode */
+            cell->contents = (UINT)list->next;
+
+        list->next = nilCell; /* decouple  and delete old */
+        deleteList(list);
+
+        if(repCell != NULL)
+            list = cell;
+        else /* remove mode */
+            {
+            list = (CELL*)cell->contents;
+            if(list != nilCell)
+                goto COMPARE_START;
+            }       
+        }
+    
+    while(list->next != nilCell)
+        {
+        if(compareFunc(keyCell, list->next, funcCell) == 0)
+            {
+            countCell->contents++;
+            cell = list->next;  /* cell = old elmnt */
+            if(repCell != NULL)
+                {
+                itSymbol->contents = (UINT)cell;
+                list->next = copyCell(evaluateExpression(repCell));
+                list = list->next;
+                }
+            list->next = cell->next;
+            cell->next = nilCell;
+            deleteList(cell);
+            }       
+        else    
+            list = list->next;
+
+        cleanupResults(resultIdxSave);
+        }
+
+    itSymbol->contents = (UINT)nilCell;
+    symbolCheck = refSymbol;
+    pushResultFlag = FALSE;
+    return(newList);
+    }
+
+if(cell->type == CELL_STRING)
+    {
+    if(keyCell->type != CELL_STRING)
+        return(errorProc(ERR_STRING_EXPECTED));
+    keyStr = (char *)keyCell->contents;
+    buff = (char *)cell->contents;
+    repCell = params;
+
+    if(repCell == nilCell)
+        return(errorProc(ERR_MISSING_ARGUMENT));
+            
+    options = -1;
+    if(repCell->next != nilCell)
+            /* 10.6.1 also accept string for options */
+            parseRegexOptions(repCell->next, (UINT *)&options, TRUE);
+
+    newBuff = replaceString(keyStr, keyCell->aux - 1, 
+                           buff, (size_t)cell->aux -1, repCell, &countCell->contents, options, &newLen);
+    if(newBuff != NULL)
+        {
+        freeMemory(buff);
+        cell->contents = (UINT)newBuff;
+        cell->aux = newLen + 1;
+        }
+
+    symbolCheck = refSymbol;
+    pushResultFlag = FALSE;
+    return(cell);
+    }
+
+return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, cell));
+}
+
+
+
+CELL * p_rotate(CELL * params)
+{
+CELL * cell;
+CELL * list;
+CELL * previous;
+CELL * last = NULL;
+char * str;
+size_t length, index;
+size_t count;
+
+cell = params;
+
+if(cell->next != nilCell) getInteger(cell->next, (UINT *)&count);
+else count = 1;
+
+getEvalDefault(params, &list);
+if(symbolCheck && isProtected(symbolCheck->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+
+if(list->type == CELL_STRING)
+    {   
+    length = list->aux - 1;
+    if((count = adjustCount(count, length)) != 0) 
+        {
+    	str = allocMemory(list->aux);  
+    	memcpy(str, (char *)(list->contents + length - count), count);
+    	memcpy(str + count, (char *)list->contents, length - count);
+    	memcpy((char*)list->contents, str, length);
+    	free(str);
+        }
+    pushResultFlag = FALSE;
+    return(list);
+    }   
+
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, cell));
+
+list->aux = (UINT)nilCell; /* undo last element optimization */
+
+cell = (CELL *)list->contents;
+length = 0;
+while(cell != nilCell)
+    {
+    ++length;
+    last = cell;
+    cell = cell->next;
+    }
+
+if((count = adjustCount(count, length))== 0) 
+    {
+    pushResultFlag = FALSE;
+    return(list);
+    }
+    
+index = length - count;
+
+previous = cell = (CELL *)list->contents;
+while(index--) 
+    {
+    previous = cell;
+    cell = cell->next;
+    }
+
+previous->next = nilCell;
+last->next = (CELL *)list->contents;
+list->contents = (UINT)cell;
+
+pushResultFlag = FALSE;
+list->aux = (UINT)previous; /* last element optimization */
+return(list);
+}
+
+/* eof */
diff --git a/nl-math.c b/nl-math.c
new file mode 100644
index 0000000..e79dc21
--- /dev/null
+++ b/nl-math.c
@@ -0,0 +1,4527 @@
+/* nl-math.c
+
+
+    Copyright (C) 2016 Lutz Mueller
+
+    This program is free software: you cann redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+
+    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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+
+/* turn on for extra debugging output */
+/* #define BAYES_DEBUG */
+/* #define DEBUG */
+
+#define OP_ADD 1
+#define OP_SUBTRACT 2
+#define OP_MULTIPLY 3
+#define OP_DIVIDE 4
+#define OP_BIT_OR 5
+#define OP_BIT_AND 6
+#define OP_BIT_XOR 7
+#define OP_SHIFTL 8
+#define OP_SHIFTR 9
+#define OP_POW 10
+#define OP_MODULO 11
+#define OP_SIN 12
+#define OP_COS 13
+#define OP_TAN 14
+#define OP_ASIN 15
+#define OP_ACOS 16
+#define OP_ATAN 17
+#define OP_SINH 18
+#define OP_COSH 19
+#define OP_TANH 20
+#define OP_ASINH 21
+#define OP_ACOSH 22
+#define OP_ATANH 23
+#define OP_SQRT 24
+#define OP_LOG 25
+#define OP_EXP 26
+#define OP_MIN 27
+#define OP_MAX 28
+#define OP_CEIL 30
+#define OP_FLOOR 31
+#define OP_NAN 32
+#define OP_ERRORFUNC 33
+#define OP_SIGNUM 34
+#define OP_ISNAN 35
+#define OP_ISINF 36
+
+#ifdef BIGINT
+#define BIGINT_BASE 1000000000 /* 9 zeros */
+#define BIGINT_BASE2 1000000000000000000LL /* 18 zeros */
+#endif
+
+extern uint32_t my_random();
+void my_srandom(uint32_t seed);
+uint32_t max_rand = MY_RAND_MAX;
+
+#ifdef DEBUG
+void debug(int * x, int n, char * txt)
+{
+int i;
+
+printf("%s ", txt);
+for(i = 0; i <= n; i++)
+    printf("%d_", x[i]);
+printf("\n");
+}
+#endif
+
+CELL * p_abs(CELL * params) 
+{  
+CELL * cell;
+INT64 intValue;
+double floatValue;
+#ifdef BIGINT
+int * numPtr;
+#endif
+    
+cell = evaluateExpression(params);
+#ifdef BIGINT
+if(cell->type == CELL_BIGINT)
+    {
+    cell = copyCell(cell);
+    numPtr = (int *)cell->contents;
+    if(*numPtr == -1) *numPtr = 1;
+    return(cell);
+    }
+else
+#endif 
+if(cell->type == CELL_FLOAT)
+    {
+    floatValue = getDirectFloat(cell);
+    if(floatValue < 0.0) floatValue = floatValue * -1.0;
+    return(stuffFloat(floatValue));
+    }
+
+getInteger64Ext(cell, &intValue, FALSE);
+if(intValue < 0) intValue = intValue * -1;
+
+return(stuffInteger64(intValue));
+}
+
+CELL * incDecI(CELL * params, int type)
+{
+CELL * cell;
+INT64 adjust = 1;
+INT64 lValue = 0;
+#ifdef BIGINT
+int * lvaluePtr;
+int * adjustPtr;
+int * resultPtr;
+int * freePtr = NULL;
+int lvlen, adjlen, reslen;
+#endif
+
+cell = evaluateExpression(params);
+
+if(symbolCheck != NULL) 
+    {
+    if(isProtected(symbolCheck->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck)));
+    }
+else
+    {
+    if(cell == nilCell)
+        errorProc(ERR_INVALID_PARAMETER);
+    }
+
+
+if(!isNil(cell)) 
+#ifdef BIGINT
+    {
+    if(cell->type == CELL_BIGINT)
+        {
+        lvaluePtr = (int *)cell->contents;
+        lvlen = cell->aux - 1;
+
+        if(params->next != nilCell)
+            freePtr = getBigintSizeDirect(evaluateExpression(params->next) , &adjustPtr, &adjlen);
+        else
+            freePtr = adjustPtr = intToBigint(1, &adjlen);
+
+        reslen = (lvlen > adjlen) ? lvlen + 2 : adjlen + 2;
+        resultPtr = calloc(reslen, sizeof(int));
+        if(type < 0)
+            subBigint(lvaluePtr, lvlen, adjustPtr, adjlen, resultPtr, &reslen);
+        else
+            addBigint(lvaluePtr, lvlen, adjustPtr, adjlen, resultPtr, &reslen);
+        if(freePtr) freeMemory(freePtr);
+        /* update old cell */
+        freeMemory((void *)cell->contents);
+        cell->contents = (UINT)resultPtr;
+        cell->aux = reslen + 1;
+        return(copyCell(cell));
+        }
+    getInteger64Ext(cell, &lValue, FALSE);
+    }
+#else
+    getInteger64Ext(cell, &lValue, FALSE);
+#endif
+    
+
+if(params->next != nilCell)
+    getInteger64Ext(params->next, &adjust, TRUE);
+
+#ifndef NEWLISP64
+cell->type = CELL_INT64;
+*(INT64 *)&cell->aux = lValue + adjust * type;
+#else
+cell->type = CELL_LONG;
+cell->contents = lValue + adjust * type;
+#endif
+
+return(copyCell(cell));
+}
+
+
+CELL * incDecF(CELL * params, int type)
+{
+CELL * cell;
+double adjust = 1.0;
+double lValue = 0.0;
+
+cell = evaluateExpression(params);
+
+if(symbolCheck != NULL)
+    {
+    if(isProtected(symbolCheck->flags))
+        return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbolCheck))); 
+    }
+else
+    {
+    if(cell == nilCell)
+        errorProc(ERR_INVALID_PARAMETER);
+    }
+
+if(!isNil(cell)) getFloat(cell, &lValue);
+
+if(params->next != nilCell)
+    getFloat(params->next, &adjust);
+
+cell->type = CELL_FLOAT;
+#ifndef NEWLISP64
+*(double *)&cell->aux = lValue + adjust * type;
+#else
+*(double *)&cell->contents = lValue + adjust * type;
+#endif
+
+return(copyCell(cell));
+}
+
+
+CELL * p_incrementI(CELL * params) { return(incDecI(params, 1)); }
+CELL * p_decrementI(CELL * params) { return(incDecI(params, -1)); }
+CELL * p_incrementF(CELL * params) { return(incDecF(params, 1)); }
+CELL * p_decrementF(CELL * params) { return(incDecF(params, -1)); }
+
+CELL * arithmetikOp(CELL * params, int op)
+{
+INT64 number;
+INT64 result;
+#ifdef BIGINT
+int sizex = 0;
+int sizey = 0;
+int n;
+int * num = NULL;
+int * numx;
+int * numy;
+int * freePtr = NULL;
+CELL * next;
+#endif
+CELL * cell;
+
+if(params == nilCell)
+    {
+    if(op == OP_ADD)
+        return(stuffInteger64(0));
+    if(op == OP_MULTIPLY)
+        return(stuffInteger64(1));
+    }
+
+cell = evaluateExpression(params);
+params = params->next;
+#ifdef BIGINT
+if(cell->type == CELL_BIGINT)
+    {
+    if(params == nilCell)
+        {
+        cell = copyCell(cell);
+        switch(op)
+            {
+            case OP_SUBTRACT:
+                *(int *)cell->contents *= -1; break;
+            case OP_ADD:
+            case OP_MULTIPLY:
+            case OP_DIVIDE:
+            case OP_MODULO:
+                break;
+            default:
+                return(errorProc(ERR_BIGINT_NOT_ALLOWED));
+            }
+        return(cell);
+        }
+
+    NEXT_FIRST_BIGINT:
+    /* first OP is CELL_BIGINT */
+    numx = (int*)cell->contents;
+    sizex = cell->aux - 1;
+
+    /* if 2nd OP is not CELL_BIGINT memory is allocated */
+    next = evaluateExpression(params);
+    if(next->type == CELL_BIGINT) /* speedup */
+        {
+        numy = (int*)next->contents;
+        sizey = next->aux - 1;
+        }
+    else
+        freePtr = getBigintSizeDirect(next, &numy, &sizey); 
+
+    if(op == OP_MULTIPLY)
+        n = sizex + sizey + 2; 
+    else
+        n = sizex > sizey ? sizex  + 2: sizey + 2;
+
+    switch(op)
+        {
+        case OP_ADD:
+            num = addBigint(numx, sizex, numy, sizey, malloc(n * sizeof(int)), &n); 
+            break;
+        case OP_SUBTRACT:
+            num = subBigint(numx, sizex, numy, sizey, malloc(n * sizeof(int)), &n); 
+            break;
+        case OP_MULTIPLY:
+            num = mulBigint(numx, sizex, numy, sizey, malloc(n * sizeof(int)), &n); 
+            break;
+        case OP_DIVIDE:         
+            num = divModBigint(numx, sizex, numy, sizey, FALSE, &n); 
+            break;
+        case OP_MODULO:
+            num = divModBigint(numx, sizex, numy, sizey, TRUE, &n);
+            break;
+        default:
+            return(errorProc(ERR_BIGINT_NOT_ALLOWED));
+        }    
+
+    if(freePtr) 
+        {
+        freeMemory(freePtr);
+        freePtr = NULL;
+        } 
+    cell = getCell(CELL_BIGINT);
+    cell->contents = (UINT)num;
+    cell->aux = n + 1; 
+    if(params->next != nilCell)
+        {
+        pushResult(cell);
+        params = params->next;
+        goto NEXT_FIRST_BIGINT;
+        }
+    return(cell);
+    }
+#endif
+
+getInteger64Ext(cell, &result, FALSE);
+if(params == nilCell)
+    {
+    switch(op)
+        {
+        case OP_SUBTRACT:
+            result = - result;
+            break;
+        case OP_SHIFTL:
+            result <<= 1;
+            break;
+        case OP_SHIFTR:
+            result >>= 1;
+        default:
+            break;
+        }
+    }
+
+else while(params != nilCell)
+    {
+    params = getInteger64Ext(params, &number, TRUE);
+    switch(op)
+        {
+        case OP_ADD:            result += number; break;
+        case OP_SUBTRACT:       result -= number; break;
+        case OP_MULTIPLY:       result *= number; break;
+        case OP_DIVIDE:         
+            if(number == 0) return(errorProc(ERR_MATH));
+                                result /= number; break;
+        case OP_BIT_OR:         result |= number; break;
+        case OP_BIT_AND:        result &= number; break;
+        case OP_BIT_XOR:        result ^= number; break;
+        case OP_SHIFTL:         result <<= number; break;
+        case OP_SHIFTR:         result >>= number; break;
+        case OP_MODULO:
+            if(number == 0) return(errorProc(ERR_MATH));
+            result %= number; break;
+        default:
+            break;
+        }
+    }
+
+return(stuffInteger64(result));
+}
+
+
+CELL * p_add(CELL * params) { return(arithmetikOp(params, OP_ADD)); }
+CELL * p_subtract(CELL * params) { return(arithmetikOp(params, OP_SUBTRACT)); }
+CELL * p_multiply(CELL * params) { return(arithmetikOp(params, OP_MULTIPLY)); }
+CELL * p_divide(CELL * params) { return(arithmetikOp(params, OP_DIVIDE)); }
+
+CELL * p_bitOr(CELL * params) { return(arithmetikOp(params, OP_BIT_OR)); }
+CELL * p_bitAnd(CELL * params) { return(arithmetikOp(params, OP_BIT_AND)); }
+CELL * p_bitXor(CELL * params) { return(arithmetikOp(params, OP_BIT_XOR)); }
+CELL * p_shiftLeft(CELL * params) { return(arithmetikOp(params, OP_SHIFTL)); }
+CELL * p_shiftRight(CELL * params) { return(arithmetikOp(params, OP_SHIFTR)); }
+CELL * p_modulo(CELL * params) { return(arithmetikOp(params, OP_MODULO)); }
+
+
+CELL * p_bitNot(CELL * params)
+{
+INT64 number;
+getInteger64Ext(params, &number, TRUE);
+return(stuffInteger64(~number));
+}
+
+
+/* ----------------------- float arithmetik ----------------------------- */
+
+CELL * getFloat(CELL * params, double *);
+CELL * floatOp(CELL * params, int op);
+int compareFloats(CELL * left, CELL * right);
+int compareInts(CELL * left, CELL * right);
+
+CELL * p_addFloat(CELL * params) { return(floatOp(params, OP_ADD)); }
+CELL * p_subFloat(CELL * params) { return(floatOp(params, OP_SUBTRACT)); }
+CELL * p_mulFloat(CELL * params) { return(floatOp(params, OP_MULTIPLY)); }
+CELL * p_divFloat(CELL * params) { return(floatOp(params, OP_DIVIDE)); }
+CELL * p_minFloat(CELL * params) { return(floatOp(params, OP_MIN)); }
+CELL * p_maxFloat(CELL * params) { return(floatOp(params, OP_MAX)); }
+CELL * p_powFloat(CELL * params) { return(floatOp(params, OP_POW)); }
+CELL * p_modFloat(CELL * params) { return(floatOp(params, OP_MODULO)); }
+
+CELL * floatOp(CELL * params, int op)
+{
+double number;
+double result;
+
+if(params == nilCell)
+    {
+    if(op == OP_ADD)
+        {
+        result = 0.0;
+        goto END_FLOAT_ARITHMETIK;
+        }
+    if(op == OP_MULTIPLY)
+        {
+        result = 1.0;
+        goto END_FLOAT_ARITHMETIK;
+        }
+    }
+
+params = getFloat(params, &result);
+
+if(params == nilCell)
+    {
+    switch(op)
+        {
+        case OP_SUBTRACT:
+            result = - result; break;
+        case OP_DIVIDE:
+            result = 1.0 / result; break;
+        case OP_POW:
+            result = result * result; break;
+        case OP_MODULO:
+            result = result - (int)result; break;
+        default: break;
+        }
+    goto END_FLOAT_ARITHMETIK;
+    }
+
+else while(params != nilCell)
+    {
+    params = getFloat(params, &number);
+    switch(op)
+        {
+        case OP_ADD:            result += number; break;
+        case OP_SUBTRACT:       result -= number; break;
+        case OP_MULTIPLY:       result *= number; break;
+        case OP_DIVIDE:         result /= number; break;
+        case OP_MIN: if(number < result) result = number; break;
+        case OP_MAX: if(number > result) result = number; break;
+        case OP_POW: result = pow(result, number); break;
+        case OP_MODULO: 
+            result = fmod(result, number);
+        default: break;
+        }
+    }
+
+END_FLOAT_ARITHMETIK:
+params = getCell(CELL_FLOAT);
+#ifndef NEWLISP64
+memcpy((void *)&params->aux, (void *)&result, sizeof(double));
+#else
+*(double *)&params->contents = result;
+#endif
+return(params);
+}
+
+
+int compareFloats(CELL * left, CELL * right)
+{
+double leftFloat, rightFloat;
+
+leftFloat = getDirectFloat(left);
+rightFloat = getDirectFloat(right);
+
+/* if(isnan(leftFloat) && isnan(rightFloat)) return(0); */
+if(isnan(leftFloat) || isnan(rightFloat)) return(9);
+
+if(leftFloat < rightFloat) return(-1);
+if(leftFloat > rightFloat) return(1);
+
+return(0);
+}
+
+/* should only be called when left and right type are different 
+   and only called from compareCells()
+*/
+int compareInts(CELL * left, CELL * right)
+{
+INT64 leftnum;
+INT64 rightnum;
+
+#ifdef BIGINT
+int * leftnumPtr;
+int leftlen;
+int * rightnumPtr;
+int rightlen;
+int cmp;
+
+if(left->type == CELL_BIGINT)
+    {
+    leftnumPtr = (int *)left->contents;
+    leftlen = left->aux - 1;
+    /* would never get here when right->type == CELL_BIGINT */
+    getBigintSizeDirect(right , &rightnumPtr, &rightlen);
+    cmp = cmpBigint(leftnumPtr, leftlen, rightnumPtr, rightlen);
+    freeMemory(rightnumPtr); 
+    return(cmp);
+    }
+#endif
+
+#ifndef NEWLISP64
+if(left->type == CELL_LONG)
+    leftnum = (int)left->contents;
+else
+    leftnum = *(INT64 *)&left->aux;
+
+if(right->type == CELL_LONG)
+    rightnum = (int)right->contents;
+#ifdef CELL_BIGINT
+else if(right->type == CELL_BIGINT)
+    getInteger64Ext(right, &rightnum, FALSE);
+#endif
+else
+    rightnum = *(INT64 *)&right->aux;
+#else /* NEWLISP64 */
+leftnum = (UINT)left->contents;
+#ifdef CELL_BIGINT 
+if(right->type == CELL_BIGINT)
+   getInteger64Ext(right, &rightnum, FALSE);
+else
+#endif 
+rightnum = (UINT)right->contents;
+#endif /* NEWLISP64 */
+
+if(leftnum < rightnum) return(-1);
+if(leftnum > rightnum) return(1);
+
+return(0);
+}
+
+
+double getDirectFloat(CELL * param)
+{
+double floatNum = 0.0;
+
+#ifndef NEWLISP64
+if(param->type == CELL_FLOAT)
+    return(*(double *)&param->aux);
+else if(param->type == CELL_LONG)
+    floatNum = (INT)param->contents;
+else if(param->type == CELL_INT64)
+    floatNum = *(INT64 *)&param->aux;
+#ifdef BIGINT
+else if(param->type == CELL_BIGINT)
+    floatNum = bigintCellToFloat(param);
+#endif
+
+#else /* NEWLISP64 */
+if(param->type == CELL_FLOAT)
+    return(*(double *)&param->contents);
+else if(param->type == CELL_LONG)
+    floatNum = (INT)param->contents;
+
+#ifdef BIGINT
+else if(param->type == CELL_BIGINT)
+    floatNum = bigintCellToFloat(param);
+#endif
+
+#endif
+
+return(floatNum);
+}
+
+/* ----------------------------- float functions ----------------------- */
+
+
+CELL * functionFloat(CELL *, int);
+
+CELL * p_sin(CELL * params) { return(functionFloat(params, OP_SIN)); }
+CELL * p_cos(CELL * params) { return(functionFloat(params, OP_COS)); }
+CELL * p_tan(CELL * params) { return(functionFloat(params, OP_TAN)); }
+CELL * p_asin(CELL * params) { return(functionFloat(params, OP_ASIN)); }
+CELL * p_acos(CELL * params) { return(functionFloat(params, OP_ACOS)); }
+CELL * p_atan(CELL * params) { return(functionFloat(params, OP_ATAN)); }
+CELL * p_sinh(CELL * params) { return(functionFloat(params, OP_SINH)); }
+CELL * p_cosh(CELL * params) { return(functionFloat(params, OP_COSH)); }
+CELL * p_tanh(CELL * params) { return(functionFloat(params, OP_TANH)); }
+CELL * p_asinh(CELL * params) { return(functionFloat(params, OP_ASINH)); }
+CELL * p_acosh(CELL * params) { return(functionFloat(params, OP_ACOSH)); }
+CELL * p_atanh(CELL * params) { return(functionFloat(params, OP_ATANH)); }
+CELL * p_sqrt(CELL * params) { return(functionFloat(params, OP_SQRT)); }
+CELL * p_log(CELL * params) { return(functionFloat(params, OP_LOG)); }
+CELL * p_exp(CELL * params) { return(functionFloat(params, OP_EXP)); }
+CELL * p_ceil(CELL * params) { return(functionFloat(params, OP_CEIL)); }
+CELL * p_floor(CELL * params) { return(functionFloat(params, OP_FLOOR)); }
+CELL * p_erf(CELL * params) { return(functionFloat(params, OP_ERRORFUNC)); }
+CELL * p_sgn(CELL * params) { return(functionFloat(params, OP_SIGNUM)); }
+CELL * p_isnan(CELL * params) { return(functionFloat(params, OP_ISNAN)); }
+CELL * p_isinf(CELL * params) { return(functionFloat(params, OP_ISINF)); }
+
+CELL * functionFloat(CELL * params, int op)
+{
+double floatN;
+double base;
+CELL * cell;
+
+getFloat(params, &floatN);
+
+switch(op)
+  {
+  case OP_SIN: floatN = sin(floatN); break;
+  case OP_COS: floatN = cos(floatN); break;
+  case OP_TAN: floatN = tan(floatN); break;
+
+  case OP_ASIN: floatN = asin(floatN); break;
+  case OP_ACOS: floatN = acos(floatN); break;
+  case OP_ATAN: floatN = atan(floatN); break;
+
+  case OP_SINH: floatN = sinh(floatN); break;
+  case OP_COSH: floatN = cosh(floatN); break;
+  case OP_TANH: floatN = tanh(floatN); break;
+
+  case OP_ASINH: floatN = asinh(floatN); break;
+  case OP_ACOSH: floatN = acosh(floatN); break;
+  case OP_ATANH: floatN = atanh(floatN); break;
+
+  case OP_SQRT: floatN = sqrt(floatN); break;
+  case OP_LOG:
+    if(params->next != nilCell)
+      {
+      getFloat(params->next, &base);
+      floatN = log(floatN) / log(base);
+      } 
+    else 
+      floatN = log(floatN); 
+    break;
+  case OP_EXP: floatN = exp(floatN); break;
+  case OP_CEIL: floatN = ceil(floatN); break;
+  case OP_FLOOR: floatN = floor(floatN); break;
+  case OP_ERRORFUNC: floatN = erf(floatN); break;
+  case OP_SIGNUM:
+    if(params->next == nilCell)
+        { 
+        if(floatN > 0.0) floatN = 1.0;
+        else if(floatN < 0.0) floatN = -1.0; 
+        else floatN = 0.0;
+        break;
+        }
+    else
+        {
+        if(floatN < 0.0) cell = params->next;
+        else
+            {
+            params = params->next;
+            if(floatN == 0.0) cell = params->next;
+            else {
+                 params = params->next;
+                 cell = params->next;
+                 }
+            }
+        }
+            
+        return(copyCell(evaluateExpression(cell)));
+    case OP_ISNAN:
+        return (isnan(floatN) ? trueCell : nilCell);
+    case OP_ISINF:
+#ifdef SOLARIS
+        return((isnan(floatN - floatN)) ? trueCell : nilCell);
+#else
+        return(isinf(floatN) ? trueCell : nilCell);
+#endif
+    default: break;
+    }
+
+cell = getCell(CELL_FLOAT);
+#ifndef NEWLISP64
+*(double *)&cell->aux = floatN;
+#else
+*(double *)&cell->contents = floatN;
+#endif
+return(cell);
+}
+
+CELL * p_ssq(CELL * params)
+{
+CELL * cell;
+double floatNum = 0.0;
+double sqSum = 0.0;
+CELL * * addr;
+UINT idx, n;
+
+getEvalDefault(params, &cell);
+if(cell->type == CELL_EXPRESSION)
+    {
+    cell = (CELL *)cell->contents;
+    while(cell != nilCell)
+        {
+        floatNum = getDirectFloat(cell);
+        sqSum += floatNum * floatNum;
+        cell = cell->next;
+        }    
+    }
+else if(cell->type == CELL_ARRAY)
+    {
+    addr = (CELL * *)cell->contents;
+    n = (cell->aux - 1) / sizeof(CELL *);
+    for (idx = 0; idx < n; idx++)
+        {
+        cell = *(addr + idx);
+        floatNum = getDirectFloat(cell);
+        sqSum += floatNum * floatNum;
+        }
+    }
+else return(errorProcExt(ERR_LIST_OR_ARRAY_EXPECTED, params));
+
+return(stuffFloat(sqSum));
+}
+
+CELL * p_atan2(CELL * params)
+{
+double floatX, floatY;
+CELL * cell;
+
+params = getFloat(params, &floatX);
+getFloat(params, &floatY);
+
+cell = getCell(CELL_FLOAT);
+#ifndef NEWLISP64
+*(double *)&cell->aux = atan2(floatX, floatY);
+#else
+*(double *)&cell->contents = atan2(floatX, floatY);
+#endif
+return(cell);
+}
+
+CELL * p_round(CELL * params)
+{
+double fNum;
+double precision = 1.0;
+INT digits = 0;
+char * fmt;
+char * result;
+
+
+params = getFloat(params, &fNum);
+if(params != nilCell)
+    getInteger(params, (UINT*)&digits);
+
+if(digits >= 0)
+    {
+    precision = pow(10.0, (double)(digits > 20 ? 20 : digits));
+    fNum = precision * floor(fNum/precision + 0.5);
+    }
+else
+    {
+    fmt = alloca(16);
+    result = alloca(32);
+    snprintf(fmt, 15, "%%.%df", (int)((digits < -16) ? 16 : -digits));
+    snprintf(result, 31, fmt, fNum);
+    fNum = atof(result);
+    }
+
+return(stuffFloat(fNum)); 
+}
+
+
+CELL * p_rand(CELL * params)
+{
+INT range;  
+INT n;
+CELL * dist, * cell;
+INT rnum;
+double scale;
+
+params = getInteger(params, (UINT *)&range);
+scale = range;
+if(range == 0)
+    {
+    srandom((unsigned)time(NULL));
+    return(trueCell);
+    }
+
+while((rnum = my_random()) == max_rand);
+rnum = (scale * rnum)/max_rand;
+
+if(params->type == CELL_NIL)
+    return(stuffInteger((UINT)rnum));
+    
+getInteger(params, (UINT *)&n);
+
+
+cell = stuffInteger((UINT)rnum);
+dist = makeCell(CELL_EXPRESSION, (UINT)cell);
+
+--n;
+while(n-- > 0)
+    {
+    while((rnum = my_random()) == max_rand);
+    rnum = (scale * rnum)/max_rand;
+    cell->next = stuffInteger((UINT)rnum);
+    cell = cell->next;
+    }
+
+return(dist);
+}
+
+
+CELL * p_amb(CELL * params)
+{
+INT len;
+CELL * cell;
+
+if((len = listlen(params)) == 0) return(nilCell);
+
+len = my_random() % len;
+
+while(len--) params = params->next;
+
+cell = evaluateExpression(params);
+if(symbolCheck)
+    {
+    pushResultFlag = FALSE;
+    return(cell);
+    }
+
+return(copyCell(cell));
+}
+
+
+/* from my_srandom() */
+extern int my_random_flag;
+extern UINT nshuff;
+extern uint32_t randseed;
+
+CELL *  p_seed(CELL * params)
+{
+static INT64 seedNum = 0;
+
+if(params == nilCell)
+    return(stuffInteger(my_random_flag ? randseed : seedNum));
+
+params = getInteger64Ext(params, &seedNum, TRUE);
+
+my_random_flag = getFlag(params);
+max_rand = my_random_flag ? 0x7FFFFFFF : MY_RAND_MAX;
+
+if(my_random_flag && params->next != nilCell)
+        getInteger(params->next, &nshuff);
+        
+my_srandom((UINT)(seedNum & 0xFFFFFFFF));
+
+return(stuffInteger(seedNum));
+}
+
+
+/* -----------------------  compare ops --------------------------- */
+
+#define OP_LESS 1
+#define OP_GREATER 2
+#define OP_LESS_EQUAL 3
+#define OP_GREATER_EQUAL 4
+#define OP_EQUAL 5
+#define OP_NOTEQUAL 6
+
+CELL * p_less(CELL * params) { return(compareOp(params, OP_LESS)); }
+CELL * p_greater(CELL * params) { return(compareOp(params, OP_GREATER)); }
+CELL * p_lessEqual(CELL * params) { return(compareOp(params, OP_LESS_EQUAL)); }
+CELL * p_greaterEqual(CELL * params) { return(compareOp(params, OP_GREATER_EQUAL)); }
+CELL * p_equal(CELL * params) { return(compareOp(params, OP_EQUAL)); }
+CELL * p_notEqual(CELL * params) { return(compareOp(params, OP_NOTEQUAL)); }
+
+CELL * compareOp(CELL * params, int op)
+{
+CELL * left;
+CELL * right;
+INT cnt = 0;
+int comp;
+
+left = evaluateExpression(params);
+
+while(TRUE)
+    {
+    if((params = params->next) == nilCell && cnt == 0)
+        {
+        if(isNumber(left->type))
+            right = stuffInteger64(0);
+        else if(left->type == CELL_STRING)
+            right = stuffString("");
+        else if(isList(left->type))
+            right = getCell(CELL_EXPRESSION);
+        else break;     
+        pushResult(right);
+        }
+    else
+        right = evaluateExpression(params);
+    ++cnt;
+    if((comp = compareCells(left, right)) == 9) 
+        return( (op == OP_NOTEQUAL) ? trueCell : nilCell);
+
+    switch(op)
+        {
+        case OP_LESS:
+            if(comp >= 0) return(nilCell);
+            break;
+        case OP_GREATER:
+            if(comp <= 0) return(nilCell);
+            break;
+        case OP_LESS_EQUAL:
+            if(comp > 0) return(nilCell);
+            break;
+        case OP_GREATER_EQUAL:
+            if(comp < 0) return(nilCell);
+            break;
+        case OP_EQUAL:
+            if(comp != 0) return(nilCell);
+            break;
+        case OP_NOTEQUAL:
+            if(comp == 0) return(nilCell);
+        default:
+            break;
+        }
+
+    if(params->next == nilCell) break;
+    left = right;
+    }
+
+return(trueCell);
+}
+
+int compareSymbols(CELL * left, CELL * right)
+{
+SYMBOL * leftS;
+SYMBOL * rightS;
+char * lcName;
+char * rcName;
+char * lsName;
+char * rsName;
+int comp;
+
+if(left->contents == (UINT)nilSymbol)
+    {
+    if(right->contents == left->contents)return(0);
+    else return(-1);
+    }
+
+if(left->contents == (UINT)trueSymbol)
+    {
+    if(left->contents == right->contents) return(0);
+    if(right->contents == (UINT)nilSymbol) return(1);
+    return(-1);
+    }
+
+if(right->contents == (UINT)nilSymbol || right->contents == (UINT)trueSymbol)
+    return(1);
+
+if(left->contents == right->contents) return(0);
+
+/* else compare context- and symbol- names */
+
+if(left->type == CELL_SYMBOL)
+    {
+    leftS = (SYMBOL *)left->contents;
+    lcName = ((SYMBOL *)leftS->context)->name;
+    lsName = leftS->name;
+    }
+else
+    {
+    lcName = ((SYMBOL *)left->aux)->name;
+    lsName = (char *)left->contents;
+    }
+
+if(right->type == CELL_SYMBOL)
+    {
+    rightS = (SYMBOL *)right->contents;
+    rcName = ((SYMBOL *)rightS->context)->name;
+    rsName = rightS->name;
+    }
+else
+    {
+    rcName = ((SYMBOL *)right->aux)->name;
+    rsName = (char *)right->contents;
+    }
+
+if((comp = strcmp(lcName, rcName)) == 0)
+    {
+    if((comp = strcmp(lsName, rsName)) == 0) return(0); 
+    }
+
+return (comp > 0 ? 1 : -1);
+}
+
+
+/* returns equal: 0 less: -1 greater: 1 or 9 if NaN or Inf equal comparison */
+int compareCells(CELL * left, CELL * right)
+{
+int comp;
+if(left->type != right->type)
+    {
+    if(left->type == CELL_FLOAT && ((right->type & COMPARE_TYPE_MASK) == CELL_INT))
+        return(compareFloats(left, right));
+    if(((left->type & COMPARE_TYPE_MASK) == CELL_INT) && right->type == CELL_FLOAT)
+        return(compareFloats(left, right));
+
+    if((left->type & COMPARE_TYPE_MASK) == CELL_INT && (right->type & COMPARE_TYPE_MASK) == CELL_INT)
+        return(compareInts(left, right));
+
+    if(isNil(left))
+        {
+        if(isNil(right)) return(0);
+        else return(-1);
+        }
+
+    if(isTrue(left))
+        {
+        if(isTrue(right)) return(0);
+        if(isNil(right)) return(1);
+        return(-1);
+        }
+
+    if(isNil(right) || isTrue(right))
+        return(1);
+
+    if(isSymbol(left->type) && isSymbol(right->type))
+        return(compareSymbols(left, right));
+        
+    if( (left->type == CELL_SYMBOL && right->type == CELL_CONTEXT) ||
+        (left->type == CELL_CONTEXT && right->type == CELL_SYMBOL) )
+        {
+        if((comp = strcmp( ((SYMBOL *)left->contents)->name, 
+                           ((SYMBOL *)right->contents)->name)) == 0) return(0);
+        return (comp > 0 ? 1 : -1);
+        }
+
+    comp = (left->type & COMPARE_TYPE_MASK) - (right->type & COMPARE_TYPE_MASK);
+    if(comp == 0) return(0);
+
+    return( comp > 0 ? 1 : -1);
+    }
+
+/* left type and right type are the same */
+switch(left->type)
+    {
+    case CELL_STRING:
+        comp = left->aux - right->aux;
+        if(comp == 0)
+            {
+            if((comp = memcmp((char *)left->contents, 
+                    (char *)right->contents,
+                    left->aux)) == 0) return(0);
+            }
+        else if(comp > 0)
+            {
+            if((comp = memcmp((char *)left->contents,
+                      (char *)right->contents,
+                      right->aux - 1)) == 0) 
+                return(1);
+            }
+        else if(comp < 0)
+            {
+            if((comp = memcmp((char *)left->contents,
+                      (char *)right->contents,
+                      left->aux - 1)) == 0) 
+                return(-1);
+            }
+            
+        return (comp > 0 ? 1 : -1);
+
+    case CELL_SYMBOL:
+    case CELL_DYN_SYMBOL:
+        return(compareSymbols(left, right));
+
+    case CELL_QUOTE:
+    case CELL_EXPRESSION:
+    case CELL_LAMBDA:
+    case CELL_FEXPR:
+        return(compareLists((CELL*)left->contents, (CELL*)right->contents));
+    case CELL_ARRAY:
+        return(compareArrays((CELL*)left, (CELL*)right));
+    case CELL_FLOAT:
+        return(compareFloats(left, right));
+#ifndef NEWLISP64
+    case CELL_INT64:
+        if(*(INT64 *)&left->aux > *(INT64 *)&right->aux) return(1);
+        if(*(INT64 *)&left->aux < *(INT64 *)&right->aux) return(-1);
+        break;
+#endif
+#ifdef BIGINT
+    case CELL_BIGINT:
+        comp = cmpBigint((int *)(UINT)left->contents, 
+                        left->aux - 1, (int *)(UINT)right->contents, right->aux - 1);
+        return(comp);
+#endif 
+    case CELL_LONG:
+    default:
+        if((INT)left->contents > (INT)right->contents) return(1);
+        if((INT)left->contents < (INT)right->contents) return(-1);
+        break;  
+    }
+
+return(0);
+}
+
+int compareLists(CELL * left, CELL * right)
+{
+int result;
+
+while(left != nilCell)
+    {
+    if( (result = compareCells(left, right)) != 0)
+        return(result);
+    left = left->next;
+    right = right->next;
+    }
+if(right == nilCell) return(0);
+return(-1);
+}
+
+/* ---------------------------- encryption -----------------------------
+
+  XOR one-pad enryption
+
+*/
+
+
+void encryptPad(char *encrypted, char *data, char * key, size_t dataLen, size_t keyLen)
+{
+size_t i;
+for(i = 0; i < dataLen; i++)
+    *(encrypted + i) = *(data + i) ^ *(key + i % keyLen);
+}
+
+
+CELL * p_encrypt(CELL * params)
+{
+char * data;
+char * key;
+char * dataEncrypted;
+CELL * encrypted;
+size_t dataLen, keyLen;
+
+getStringSize(params, &data, &dataLen, TRUE);
+getStringSize(params->next, &key, &keyLen, TRUE);
+
+if(!keyLen) return(errorProcExt(ERR_STRING_EXPECTED, params->next));
+
+dataEncrypted = (char *)allocMemory(dataLen + 1);
+*(dataEncrypted + dataLen) = 0;
+
+encryptPad(dataEncrypted, data, key, dataLen, keyLen);
+
+encrypted = getCell(CELL_STRING);
+encrypted->contents = (UINT)dataEncrypted;
+encrypted->aux = dataLen + 1;
+
+return(encrypted);
+}
+
+
+
+/* =============================  Fast Fourier Transform ======================== */
+
+CELL * fft(CELL * params, int isign);
+CELL * makeListFromFloats(double num1, double num2);
+void fastFourierTransform(double data[], unsigned int  nn, int isign);
+
+CELL * p_fft(CELL * params)
+{
+return fft(params, 1);
+}
+
+
+CELL * p_ifft(CELL * params)
+{
+return fft(params, -1);
+}
+
+CELL * fft(CELL * params, int isign)
+{
+CELL * listData;
+CELL * list;
+CELL * cell;
+double * data;
+unsigned int i, n, N;
+
+getListHead(params, &listData);
+
+n = listlen(listData);
+
+N = 1;
+while(N < n) N <<= 1;
+
+data = (double *)allocMemory(N * 2 * sizeof(double));
+list = listData;
+for(i = 0; i < n*2; i+=2)
+    {
+    if(isNumber(list->type))
+        {
+        data[i] = getDirectFloat(list);
+        data[i+1] = (double)0.0;
+        list = list->next;
+        continue;
+        }
+
+    if(list->type != CELL_EXPRESSION)
+        {
+        freeMemory(data);
+        return(errorProcExt(ERR_LIST_OR_NUMBER_EXPECTED, list));
+        }
+
+    cell = (CELL *)list->contents;
+    data[i] = getDirectFloat(cell);
+    data[i+1] = getDirectFloat(cell->next);
+    list= list->next;
+    }
+    
+
+for(i = n * 2; i < N * 2; i++)
+    data[i] = 0.0;
+
+fastFourierTransform(data, N, isign);
+
+list = listData = getCell(CELL_EXPRESSION);
+if(isign == -1) 
+    for(i = 0; i < n * 2; i++) data[i] = data[i]/N;
+
+list->contents = (UINT)makeListFromFloats(data[0], data[1]);
+list = (CELL*)list->contents;
+for(i = 2; i < N * 2; i += 2)
+    {
+    list->next = makeListFromFloats(data[i], data[i+1]);
+    list = list->next;
+    }
+
+freeMemory(data);
+
+return(listData);
+}
+
+
+CELL * makeListFromFloats(double num1, double num2)
+    {
+    CELL * cell;
+    CELL * list;
+
+    list = getCell(CELL_EXPRESSION);
+    list->contents = (UINT)stuffFloat(num1);
+    cell = (CELL *)list->contents;
+    cell->next = stuffFloat(num2);
+    return(list);
+    }
+
+
+/* Fast Fourier Transform 
+// algorithm modified for zero-offset data[] and double precision from
+// 
+// Numerical Recipes in 'C', 2nd Edition
+// W.H. Press, S.A. Teukolsky
+// W.T. Vettering, B.P. Flannery
+// Cambridge University Press, 1992
+*/
+
+#define SWAP(a,b) tempr=(a);(a)=(b);(b)=tempr
+
+void fastFourierTransform(double data[], unsigned int nn, int isign)
+{
+unsigned int n, mmax, m, j, istep, i;
+double wtemp, wr, wpr, wpi, wi, theta;
+double tempr, tempi;
+
+n = nn << 1;
+j = 1;
+
+for(i = 1; i < n; i += 2)
+    {
+    if(j > i)
+        {
+        SWAP(data[j-1], data[i-1]);
+        SWAP(data[j], data[i]);
+        }
+    m = n >> 1;
+    while(m >= 2 && j > m)
+        {
+        j -= m;
+        m >>= 1;
+        }
+    j += m;
+    }
+
+
+mmax = 2;
+while(n > mmax)
+    {
+    istep = mmax << 1;
+    theta = isign * (6.28318530717959/mmax);
+    wtemp = sin(0.5 * theta);
+    wpr = -2.0 * wtemp * wtemp;
+    wpi = sin(theta);
+    wr = 1.0;
+    wi = 0.0;
+    for(m = 1; m < mmax; m += 2)
+        {
+        for(i = m; i <= n; i += istep)
+            {   
+            j = i + mmax;
+            tempr = wr * data[j-1] - wi * data[j];
+            tempi = wr * data[j] + wi * data[j-1];
+            data[j-1] = data[i-1] - tempr;
+            data[j] = data[i] - tempi;
+            data[i-1] += tempr;
+            data[i] += tempi;
+            }
+        wtemp = wr;
+        wr = wtemp * wpr - wi * wpi + wr;
+        wi = wi * wpr + wtemp * wpi + wi;
+        }
+    mmax = istep;
+    }
+}
+
+
+/* --------------------------- probability distributions ----------------- */
+
+#define DIST_RANDOM 0
+#define DIST_NORMAL 1
+
+double getRandom(double offset, double scale, int type)
+{
+int i;
+double randnum;
+
+if(type == DIST_RANDOM)
+    {
+    randnum = my_random();
+    return(scale * randnum/max_rand + offset);
+    }
+
+if(type == DIST_NORMAL)
+    {
+    randnum = 0.0;
+    for(i = 0; i < 12; i++)
+        randnum += my_random() % 1024;
+    return(scale * (randnum - 6144 + 6)/1024 + offset);
+    }
+
+return(0.0);
+}
+
+CELL * randomDist(CELL * params, int type)
+{
+double randnum;
+size_t i;
+size_t n = 0;
+double scale = 1.0;
+double offset = 0.0;
+CELL * dist;
+CELL * cell;
+
+if(params->type != CELL_NIL)
+    {
+    params = getFloat(params, &offset);
+    params = getFloat(params, &scale);
+    if(params->type != CELL_NIL)
+        getInteger(params, (UINT*)&n);
+    }
+
+if( n == 0)
+    {
+    randnum = getRandom(offset, scale, type);
+    return(stuffFloat(randnum));
+    }
+
+dist = getCell(CELL_EXPRESSION);
+randnum = getRandom(offset, scale, type);
+dist->contents = (UINT)stuffFloat(randnum);
+cell = (CELL*)dist->contents;
+for(i = 1; i < n; i++)
+    {
+    randnum = getRandom(offset, scale, type);
+    cell->next = stuffFloat(randnum);
+    cell = cell->next;
+    }
+
+return(dist);
+}
+
+
+CELL * p_normal(CELL * params)
+{
+return(randomDist(params, DIST_NORMAL));
+}
+
+CELL * p_random(CELL * params)
+{
+return(randomDist(params, DIST_RANDOM));
+}
+
+CELL * p_randomize(CELL * params)
+{
+CELL * list;
+CELL * cell;
+CELL * * vector;
+size_t length, i, j;
+INT rnum;
+double scale;
+
+getListHead(params, &list);
+
+if((length = listlen(list)) <= 1) 
+  return(makeCell(CELL_EXPRESSION, (UINT)copyList(list)));
+ 
+/* build index vector */
+cell = list; 
+vector = allocMemory(length * sizeof(UINT));
+for(i = 0; i < length; i++)
+    {
+    vector[i] = copyCell(cell);
+    vector[i]->next = (void *)i;
+    cell = cell->next;
+    }
+
+/* reorganize randomly */
+RANDOMIZE:
+for(i = 0; i < (length - 1); i++)
+    {
+    scale = length - i;
+    while((rnum = my_random()) == max_rand);
+    rnum = (scale * rnum)/max_rand;
+    j = i + rnum;
+    cell = vector[i];
+    vector[i] = vector[j];
+    vector[j] = cell;
+    }
+
+/* check that new sequence is different 
+   for default no flag or nil flag */
+if(!getFlag(params->next))
+    {
+    for(i = 0; i < length; i++)
+        if(vector[i]->next != (void *)i) break;
+  
+    if(i == length)  goto RANDOMIZE;
+    }
+
+/* relink the list */
+cell = list = getCell(CELL_EXPRESSION);
+cell->contents  = (UINT)vector[0];
+cell = (CELL *)cell->contents;
+for(i = 1; i < length; i++)
+    {
+    cell->next = vector[i];
+    cell = cell->next;
+    }
+cell->next = nilCell;
+freeMemory(vector);
+
+return(list);
+}
+
+CELL * probability_x(CELL * params, int type);
+double probChi2(double chi2, UINT df);
+double probT(double t, UINT df);
+double probF(double t, UINT df1, UINT df2);
+double critical_value(double p, UINT df1, UINT df2, double max_val, int type);
+double gammaln(double xx);
+double betai(double a, double b, double x);
+double gammap(double a, double x);
+double betacf(double a, double b, double x);
+static double gser(double a, double x, double gln);
+double gcf(double a, double x, double gln);
+
+#define SQRT2 1.414213562373095
+
+CELL * p_probabilityZ(CELL * params)
+{
+double z;
+double p;
+
+getFloat(params, &z);
+
+p = 0.5 + erf(z/SQRT2) / 2.0;
+
+return(stuffFloat(p));
+}
+
+
+CELL * p_criticalZ(CELL * params)
+{
+double p;
+double sign = 1.0;
+#define Z_EPSILON 0.000001   /* Accuracy of Z approximation */
+double minZ = 0.0;
+double maxZ = 6.0;
+double Zval;
+double Z;
+        
+getFloat(params, &p);
+
+if (p < 0.5)
+    {
+    p = 1.0 - p;
+    sign = -1.0;
+    }
+        
+Zval = 2.0;    /* fair first value */
+while ((maxZ - minZ) > Z_EPSILON)
+    {
+    if ( (0.5 + erf(Zval/SQRT2) / 2.0) < p) minZ = Zval;
+    else maxZ = Zval;
+    Zval = (maxZ + minZ) * 0.5;
+    }
+
+Z = (Zval > 5.999999) ? sign * 6.0 : Zval * sign;
+
+return(stuffFloat(Z));
+}
+
+
+double probChi2(double chi2, UINT df)
+{
+return(gammap(df/2.0, chi2/2.0));
+}
+
+
+double probT(double t, UINT df)
+{
+double bta;
+
+bta = betai(df/2.0, 0.5, 1.0/(1.0 + t*t/df));
+if(t > 0.0) return(1.0 - 0.5 * bta);
+else if(t < 0.0) return(0.5 * bta);
+return(0.5);
+}
+
+double probF(double f, UINT df1, UINT df2)
+{
+double prob;
+
+prob = 2.0 * betai(0.5 * df2, 0.5 * df1, df2 / (df2 + df1 * f));
+
+if(prob > 1) prob = 2.0 - prob; 
+return(prob / 2.0);
+}
+
+#define STAT_CHI2 1
+#define STAT_T 2
+#define STAT_F 3
+
+CELL * p_probabilityChi2(CELL * params)
+{
+return(probability_x(params, STAT_CHI2));
+}
+
+CELL * p_probabilityT(CELL * params)
+{
+return(probability_x(params, STAT_T));
+}
+
+CELL * p_probabilityF(CELL * params)
+{
+return(probability_x(params, STAT_F));
+}
+
+
+CELL * probability_x(CELL * params, int type)
+{
+double x;
+UINT df1;
+UINT df2;
+double prob = 0.0;
+
+params = getFloat(params, &x);
+params = getInteger(params, &df1);
+if(type == STAT_F)
+    getInteger(params, &df2); 
+
+switch(type)
+    {
+    case STAT_CHI2:
+        prob = 1.0 - probChi2(x, df1);
+        break;
+    case STAT_T:
+        prob = 1.0 - probT(x, df1);
+        break;
+    case STAT_F:
+        prob = probF(x, df1, df2);
+        break;
+    default:
+        break;
+    }
+
+return(stuffFloat(prob));
+}
+
+
+double critical_value(double p, UINT df1, UINT df2, double max_val, int type)
+{
+#define NEWTON_EPSILON 0.000001   /* Accuracy of Newton approximation */
+double minval = 0.0;
+double maxval = max_val;
+double critval;
+double prob = 0.0;
+
+if (p <= 0.0) return 0.0;
+else if (p >= 1.0) return maxval;
+    
+critval = (df1 + df2) / sqrt(p);    /* fair first value */
+while ((maxval - minval) > NEWTON_EPSILON)
+    {
+    switch(type)
+        {
+        case STAT_CHI2:
+            prob = probChi2(critval, df1);
+            break;
+        case STAT_T: 
+            prob = probT(critval, df1);
+            break;
+        case STAT_F:
+            prob = 1.0 - probF(critval, df1, df2);
+            break;
+        default:
+            break;
+        }
+    if (prob < p) minval = critval;
+    else maxval = critval;
+    critval = (maxval + minval) * 0.5;
+    }
+
+return critval;
+}
+
+
+CELL * criticalX(CELL * params, int type)
+{
+double p;
+UINT df1;
+UINT df2 = 0;
+double x;
+
+params = getFloat(params, &p);
+params = getInteger(params, &df1);
+if(type == STAT_F) getInteger(params, &df2);
+
+x = critical_value((1.0 - p), df1, df2, 99999.0, type);
+
+if(x < NEWTON_EPSILON) x = 0.0;
+
+return(stuffFloat(x));
+}
+
+
+CELL * p_criticalChi2(CELL  * params)
+{
+return(criticalX(params, STAT_CHI2));
+}
+
+CELL * p_criticalT(CELL * params)
+{
+return(criticalX(params, STAT_T));
+}
+
+
+CELL * p_criticalF(CELL  * params)
+{
+return(criticalX(params, STAT_F));
+}
+
+/* Built-in versions for random() and srandom() are used only 
+   when 'seed' was called with extra 'true' value. Guarantees 
+   platform and compiler/libc indepedence when needed for some
+   applications. '(seed)' then can be used to retrieve state,
+   '(seed num true N)' can be used to set 'nshuff', which should
+   be 0 to when starting with a previously saved state seed. 
+
+   Adapted from FreeBSD: 
+   http://fxr.watson.org/fxr/source/libkern/random.c 
+   result is uniform on [0, 2^31 - 1]. 
+*/
+
+
+UINT nshuff = 50;  /* to drop some "seed -> 1st value" linearity */
+uint32_t randseed = 937186357; /* after srandom(1), NSHUFF=50 counted */
+int my_random_flag = 0; /* if not set, call libc version */
+
+void my_srandom(uint32_t seed)
+{
+int i;
+
+if(my_random_flag == 0) srandom(seed);
+else 
+    {
+    randseed = seed;
+    for (i = 0; i < nshuff; i++)
+        my_random();
+    }
+}
+
+uint32_t my_random()
+{
+int32_t x, hi, lo, t;
+
+if(my_random_flag == 0) return(random());
+
+/*
+* Compute x[n + 1] = (7^5 * x[n]) mod (2^31 - 1).
+* From "Random number generators: good ones are hard to find",
+* Park and Miller, Communications of the ACM, vol. 31, no. 10,
+* October 1988, p. 1195. (from FreeBSD code base)
+*/
+
+if ((x = randseed) == 0) x = 123459876;
+hi = x / 127773;
+lo = x % 127773;
+t = 16807 * lo - 2836 * hi;
+if (t < 0) t += 0x7fffffff;
+randseed = t;
+return (t);
+}
+
+#ifdef ALTERNATIVE_MY_RANDOM /* used for EMSCRIPTEN before v1.29 */
+int  m_w = 0x12345678;    /* must not be zero, nor 0x464fffff */
+int  m_z = 0x23456789;    /* must not be zero, nor 0x9068ffff */
+ 
+long int random(void)
+{
+m_z = 36969 * (m_z & 65535) + (m_z >> 16);
+m_w = 18000 * (m_w & 65535) + (m_w >> 16);
+return (((m_z << 16) + m_w)  & 0x7fffffff);  /* 31-bit result */
+}
+
+void srandom(unsigned int init)
+{
+m_z = init;
+m_w = 3 * init;
+}
+#endif
+
+/* ----------------------- betai and gammaln fucntions ----------------------*/
+
+
+static int paramError;
+
+CELL * p_beta(CELL * params)
+{
+double a, b, beta;
+
+params = getFloat(params, &a);
+getFloat(params, &b);
+
+beta = exp(gammaln(a) + gammaln(b) - gammaln(a+b));
+
+return(stuffFloat(beta));
+}
+
+CELL * p_betai(CELL * params)
+{
+double a, b, x, result;
+
+params = getFloat(params, &x);
+params = getFloat(params, &a);
+getFloat(params, &b);
+
+paramError = 0;
+
+result = betai(a,b,x);
+
+if(paramError)
+    return(nilCell);
+    
+return(stuffFloat(result));
+}
+
+
+CELL * p_gammaln(CELL * params)
+{
+double x, result;
+
+getFloat(params, &x);
+
+paramError = 0;
+
+result = gammaln(x);
+
+if(paramError)
+    return(nilCell);
+    
+return(stuffFloat(result));
+}
+
+
+CELL * p_gammai(CELL * params)
+{
+double a, x, result;
+
+params = getFloat(params, &a);
+getFloat(params, &x);
+
+result = gammap(a, x);
+
+/*
+printf("in p_gammai() result = %f\n", result);
+*/
+
+return(stuffFloat(result));
+}
+
+
+/* these functions are adapted from:
+   Numerical Recipes in C
+   W.H.Press, S.A. Teukolsky, W.T. Vettering, B.P. Flannery
+   Cambridge University Press (c) 1992
+*/
+
+#define ITMAX 100
+#define EPS7 3.0e-7
+
+double betai(double a, double b, double x)
+{
+double bt;
+
+if (x < 0.0 || x > 1.0) 
+    {
+    paramError = 1;
+    return(0.0);
+    }
+
+if (x == 0.0 || x == 1.0) 
+    bt = 0.0;
+else
+    bt = exp(gammaln(a+b)-gammaln(a)-gammaln(b)+a*log(x)+b*log(1.0-x));
+    
+if (x < (a+1.0)/(a+b+2.0))
+    return (bt * betacf(a,b,x) / a);
+else
+    return (1.0 - bt * betacf(b,a,1.0-x) / b);
+}
+
+
+double betacf(double a, double b, double x)
+{
+double qap,qam,qab,em,tem,d;
+double bz,bm,bp,bpp;
+double az,am,ap,app,aold;
+int m;
+
+bm = az = am = 1.0;
+qab=a+b;
+qap=a+1.0;
+qam=a-1.0;
+bz=1.0-qab*x/qap;
+for (m=1;m<=ITMAX;m++) 
+    {
+    em=(double) m;
+    tem=em+em;
+    d=em*(b-em)*x/((qam+tem)*(a+tem));
+    ap=az+d*am;
+    bp=bz+d*bm;
+    d = -(a+em)*(qab+em)*x/((qap+tem)*(a+tem));
+    app=ap+d*az;
+    bpp=bp+d*bz;
+    aold=az;
+    am=ap/bpp;
+    bm=bp/bpp;
+    az=app/bpp;
+    bz=1.0;
+    if (fabs(az-aold) < (EPS7 * fabs(az))) return az;
+    }
+
+return(paramError = 1);
+}
+
+
+double gammaln(double xx)
+{
+double x,y,tmp,ser;
+static double cof[6] = {
+ 76.18009172947146,
+-86.50532032941677,
+ 24.01409824083091,
+ -1.231739572450155,
+  0.1208650973866179e-2,
+ -0.5395239384953e-5};
+
+int j;
+
+if(xx == 0.0)
+    fatalError(ERR_INVALID_PARAMETER_0, NULL, 0);
+
+y=x=xx;
+tmp=x+5.5;
+tmp -= (x+0.5)*log(tmp);
+ser=1.000000000190015;
+
+for (j=0;j<=5;j++) ser += cof[j]/++y;
+    
+return -tmp+log(2.5066282746310005*ser/x);
+}
+
+
+#define EPS9 3.0e-9
+#define FPMIN 1.0e-307
+
+/* incomplete Gamma function
+//
+// gammap = P(a,x) 
+// gammaq = Q(a,x) = 1.0 - P(a,x)
+//
+// prob-chi2 = gammap(df/2, chi2/2) 
+// of beeing as good as observed (>=)
+*/
+double gammap(double a, double x)
+{
+double gln;
+gln = gammaln(a);
+#ifdef DEBUG
+/* horrible error on LLVM 32-bit Apple update Oct 7, 2010, fine on LLVM 64-bit
+   result is fine in printf() but gets passed up as NaN to gammai() by return() */
+printf("in gammap() result %f\n", (x < (a + 1.0)) ? gser(a, x, gln) : (1.0 - gcf(a ,x , gln)));
+#endif
+return( (x < (a + 1.0)) ? gser(a, x, gln) : (1.0 - gcf(a ,x , gln)) );
+}
+
+
+static double gser(double a, double x, double gln)
+{
+double ap, del, sum;
+int n;
+
+ap = a;
+del = 1.0/a;
+sum = del;
+
+for (n = 1 ; n <= ITMAX ; n++)
+    {
+    ++ap;
+    del *= x / ap;
+    sum += del;
+    if (fabs(del) < fabs(sum) * EPS9)
+    return sum * exp(-x + a * log(x) - gln);
+    }
+
+return sum * exp(-x + a * log(x) - gln);
+}
+
+
+double gcf(double a, double x, double gln)
+{
+double b, c, d, h, an, del;
+int i;
+
+b = x + 1 - a;
+c = 1.0/FPMIN;
+d = 1.0/b;
+h = d;
+
+for (i = 1 ; i <= ITMAX ; i++)
+    {
+    an = -i * (i - a);
+    b += 2;
+    
+    d = an * d + b;
+    if (fabs(d) < FPMIN) d = FPMIN;
+
+    c = b + an/c;
+    if (fabs(c) < FPMIN) c = FPMIN;
+
+    d = 1.0/d;
+    del = d * c;
+    h *= del;
+    if (fabs(del-1.0) < EPS9) break;
+    }
+
+return exp(-x + a * log(x) - gln) * h;
+}
+
+
+/* ------------------------------------- Binomial distribution -------------------- */
+
+CELL * p_binomial(CELL * params)
+{
+INT n, k;
+double bico, p, binomial;
+
+params = getInteger(params, (UINT *)&n);
+params = getInteger(params, (UINT *)&k);
+getFloat(params, &p);
+
+bico = exp(gammaln(n + 1.0) - gammaln(k + 1.0) - gammaln(n - k + 1.0));
+
+binomial = bico * pow(p, (double)k) * pow(1.0 - p, (double)(n - k));
+
+return(stuffFloat(binomial));
+}
+
+/* -------------------------------------------------------------------------------- */
+
+CELL * p_series(CELL * params)
+{
+double fromFlt, factFlt;
+ssize_t count, i;
+CELL * series;
+CELL * cell;
+CELL * pCell;
+CELL * expr;
+CELL * cellIdx;
+UINT * resultIdxSave;
+jmp_buf errorJumpSave;
+int errNo;
+
+cell = evaluateExpression(params);
+pCell = evaluateExpression(params->next);
+params = params->next;
+getInteger(params->next, (UINT *)&count);
+
+series = getCell(CELL_EXPRESSION);
+if(count <= 0) return(series);
+
+if(isNumber(pCell->type))
+    {
+    if(!isNumber(cell->type))
+        return(errorProcExt(ERR_NUMBER_EXPECTED, cell));
+    fromFlt = getDirectFloat(cell);
+    factFlt = getDirectFloat(pCell);
+    cell = copyCell(cell);
+    series->contents = (UINT)cell;
+    for(i = 1; i < count; i++)
+        {
+        fromFlt *= factFlt;
+        cell->next = stuffFloat(fromFlt);
+        cell = cell->next;
+        }
+    }
+else /* assumes lambda or primitive */
+    {
+    cellIdx = initIteratorIndex();
+    addList(series, copyCell(cell));
+    resultIdxSave = resultStackIdx;
+    memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+    if((errNo = setjmp(errorJump)) != 0)
+        {
+        memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+        deleteList(series);
+        longjmp(errorJump, errNo);
+        }
+
+    for(i = 1; i < count; i++)
+        {
+        cell = copyCell(cell);
+        cleanupResults(resultIdxSave);  
+        expr = makeCell(CELL_EXPRESSION, (UINT)copyCell(pCell));
+        ((CELL *)expr->contents)->next = cell;
+        pushResult(expr);
+        cell = evaluateExpression(expr);
+        addList(series, copyCell(cell));
+        if(cellIdx->type == CELL_LONG) cellIdx->contents += 1;
+        }
+    recoverIteratorIndex(cellIdx);
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    }
+
+series->aux = (UINT)cell; /* last element optimization */
+return(series);
+}
+
+/* ------------------------------- prime numbers ---------------------------- */
+
+/*
+* adapted for newLISP from the following code:
+*
+* factor.c -- print prime factorization of a number
+* Ray Gardner -- 1985 -- public domain
+* Modified Feb. 1989 by Thad Smith > public domain
+*
+*/
+
+CELL * p_factor (CELL * params)
+{
+INT64 d, n;
+INT k;
+CELL * factList;
+int i;
+
+getInteger64Ext(params, &n, TRUE);
+
+if (n < 2) return(nilCell);
+      
+factList = getCell(CELL_EXPRESSION);
+
+d = 2;
+for (k = 0; (n % d) == 0; k++)
+    n /= d;
+for(i = 0; i < k; i++) addList(factList, stuffInteger64(d));
+      
+for (d = 3; d * d <= n; d += 2)
+    {
+    for (k = 0; (n % d) == 0; k++)
+        n /= d;
+    for(i = 0; i < k; i++) addList(factList, stuffInteger64(d));
+    }
+
+if (n > 1)
+    addList(factList, stuffInteger64(n));
+      
+return(factList);
+}
+
+/* see http://en.wikipedia.org/wiki/Euclidean_algorithm */
+
+CELL * gcdBig(CELL * a, CELL * b);
+CELL * isZero(CELL * cell);
+
+CELL * p_gcd(CELL * params)
+{ 
+INT64 m, n, r; 
+CELL * cell;
+#ifdef BIGINT
+CELL * x;
+CELL * y;
+UINT * resultIdxSave = resultStackIdx;
+#endif
+
+cell = evaluateExpression(params);
+params = params->next;
+
+#ifdef BIGINT
+if(cell->type == CELL_BIGINT)
+    {
+    x = copyCell(cell);
+    NEXT_BIG_GCD:
+    y = p_bigInt(params);
+    cell = gcdBig(x, y);
+    cleanupResults(resultIdxSave);  
+    deleteList(x);
+    deleteList(y);
+    if(params->next != nilCell)
+        {
+        params = params->next;
+        x = cell;
+        goto NEXT_BIG_GCD;
+        }
+    *(int*)cell->contents = 1; /* abs */
+    return(cell);
+    }
+#endif
+
+cell = getInteger64Ext(cell, &m, FALSE);
+while(params != nilCell)
+    {
+    params = getInteger64Ext(params, &n, TRUE);
+    while (n != 0)
+        {
+        r = n;
+        n = m % n;
+        m = r;
+        } 
+    }
+
+if(m < 0) m = -m;
+return(stuffInteger64(m));
+} 
+
+
+/* for bigint use 
+(define (gcd-big a b)
+	(if (= b 0) a (gcd-big b (% a b))))
+*/
+
+#define NEW_BIG_GCD
+#ifdef NEW_BIG_GCD 
+CELL * gcdBig(CELL * a, CELL * b)
+{
+CELL * cell;
+
+while (isZero(b) == nilCell)
+    {
+    a->next = b;
+    cell = arithmetikOp(a, OP_MODULO);
+    a->next = nilCell;
+    pushResult(cell);
+    a = b;
+    b = cell; 
+    }
+
+return(copyCell(a));
+}
+
+#else
+
+CELL * gcdBig(CELL * a, CELL * b)
+{
+CELL * cell;
+if(isZero(b) == trueCell) return(copyCell(a));
+
+a->next = b;
+b->next = nilCell;
+
+cell = arithmetikOp(a, OP_MODULO);
+a->next = nilCell;
+pushResult(cell);
+
+return(gcdBig(b, cell));
+}
+#endif
+
+/* ------------------------------- financial functions ---------------------- */
+
+
+CELL * p_pmt(CELL * params)
+{
+INT nper;
+double rate, pv;
+double fv = 0.0;
+double pmt = 0.0;
+double inc;
+INT type = 0;
+
+params = getFloat(params, &rate);
+params = getInteger(params, (UINT *)&nper);
+params = getFloat(params, &pv);
+if(params != nilCell)
+    {
+    params = getFloat(params, &fv);
+    if(params != nilCell) getInteger(params, (UINT *)&type);
+    }
+
+if(rate == 0)
+    pmt = (-pv - fv) / nper;
+else
+    {
+    inc = pow(1 + rate, (double)nper);
+    pmt = - (pv * inc + fv) / ((1 + rate * type) * ((inc - 1) / rate));
+    }
+  
+return stuffFloat(pmt);
+}
+
+
+CELL * p_pv(CELL * params)
+{
+INT nper;
+double rate, pmt, pv;
+double fv = 0.0;
+double inc;
+INT type = 0;
+
+params = getFloat(params, &rate);
+params = getInteger(params, (UINT *)&nper);
+params = getFloat(params, &pmt);
+
+if(params != nilCell)
+    {
+    params = getFloat(params, &fv);
+    if(params != nilCell)
+        getInteger(params, (UINT *)&type);
+    }
+
+if(rate == 0)
+    pv = - pmt * nper - fv;
+else
+    {
+    inc = pow(1 + rate, (double)nper);
+    pv = (-pmt * (1 + rate * type) * ((inc - 1) / rate) - fv) / inc;
+    }
+  
+return stuffFloat(pv);
+}
+
+
+CELL * p_fv(CELL * params)
+{
+double rate, pmt, pv;
+INT nper, type;
+double inc, fv;
+
+params = getFloat(params, &rate);
+params = getInteger(params, (UINT *)&nper);
+params = getFloat(params, &pmt);
+params = getFloat(params, &pv);
+if(params != nilCell)
+    getInteger(params, (UINT *)&type);
+else type = 0;
+
+
+if(rate == 0)
+    fv = - pmt * nper - pv;
+else
+    {
+    inc = pow(1 + rate, (double)nper);
+    fv = -pmt * (1 + rate * type) * ((inc - 1) / rate) - pv * inc;
+    }
+  
+return stuffFloat(fv);
+}
+
+
+CELL * p_nper(CELL * params)
+{
+double rate, pmt, pv;
+double fv = 0.0;
+double R, c, nper;
+INT type = 0;
+
+params = getFloat(params, &rate);
+params = getFloat(params, &pmt);
+params = getFloat(params, &pv);
+
+if(params != nilCell)
+    {
+    params = getFloat(params, &fv);
+    if(params != nilCell) getInteger(params, (UINT *)&type);
+    }
+ 
+if(rate == 0)
+    nper = (-pv - fv) / pmt;
+else if(rate > -1.0)
+    {
+    R = 1.0 + rate;
+    c = pmt * (type ? R : 1.0) / rate;
+    nper = log((c - fv) / (c + pv)) / log(R);
+    }
+else nper = sqrt(-1.0);   /* NaN */
+
+
+return stuffFloat(nper);
+}
+
+
+CELL * p_npv(CELL * params)
+{
+CELL * list;
+double rate, cashFlow, fNum;
+int count;
+
+params = getFloat(params, &rate);
+list = evaluateExpression(params);
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, params));
+list = (CELL *)list->contents;
+
+cashFlow = 0.0;
+count = 0;
+while(list !=  nilCell)
+    {
+    fNum = getDirectFloat(list);
+    cashFlow += fNum / pow((1.0 + rate), (double)++count);
+    list = list->next;
+    }
+
+return stuffFloat(cashFlow);
+}
+
+
+/* Internal Rate of Return - irr
+
+   adapted from a C++ program by:
+  
+   Bernt Arne Odegaard, 1999 http://finance.bi.no/~bernt
+
+   Note, that some data have multiple solutions, this search
+   algorithm returns only one
+
+*/
+
+
+double cfPv(int N, int times[], double amounts[], double rate)
+{
+double PV = 0.0;
+int t;
+
+for(t = 0; t < N; t++)
+    PV += amounts[t] / pow((1.0 + rate), (double)times[t]);
+
+return(PV);
+}
+
+
+#define PRECISION 1.0e-5
+#define MAX_ITERATIONS 50
+#define IRR_ERROR -1.0
+
+double irr(int N, int times[], double amounts[], double x2)
+{
+double est1, est2;
+double x1 = 0.0;
+double f, rtb, dx;
+double x_mid, f_mid;
+int i;
+    
+est1 = cfPv(N, times, amounts,  x1);
+est2 = cfPv(N, times, amounts,  x2);
+
+for(i=0; i<MAX_ITERATIONS; i++)
+    {
+    if(est1 * est2 < 0.0) break;
+
+    if(fabs(est1) < fabs(est2)) 
+        est1 = cfPv(N, times, amounts,  x1 += 1.6 * (x1 - x2));
+    else 
+        est2 = cfPv(N, times, amounts,  x2 += 1.6 * (x2 - x1));
+    }
+    
+if (est2 * est1 > 0.0) return (IRR_ERROR);
+
+f = cfPv(N, times, amounts, x1);
+dx=0;
+
+if(f < 0.0) 
+    {
+    rtb = x1;
+    dx=x2-x1;
+    }
+else 
+    {
+    rtb = x2;
+    dx = x1-x2;     
+    };
+
+for(i = 0; i< MAX_ITERATIONS; i++)
+    {
+    dx *= 0.5;
+    x_mid = rtb + dx;
+    f_mid = cfPv(N, times, amounts, x_mid);
+
+    if(f_mid <= 0.0)
+        rtb = x_mid;
+
+    if((fabs(f_mid) < PRECISION) || (fabs(dx) < PRECISION)) 
+        return x_mid;
+    }; 
+   
+return(IRR_ERROR);
+}
+
+CELL * p_irr(CELL * params)
+{
+CELL * amounts;
+CELL * times;
+CELL * list;
+double result;
+double guess = 0.5;
+double * amountsVec;
+int * timesVec;
+int i, N = 0;
+INT number;
+
+params = getListHead(params, &amounts);
+list = amounts;
+if(params != nilCell)
+    {
+    params = getListHead(params, &times);
+    if(params != nilCell)
+        getFloat(params, &guess);
+    }   
+
+else
+    times = NULL;
+
+while(list != nilCell)
+    {
+    ++N;
+    list = list->next;
+    }
+
+amountsVec = (double *)allocMemory(N * sizeof(double));
+timesVec = (int *)allocMemory(N * sizeof(int));
+
+for(i = 0; i < N; i++)
+    {
+    if(isNumber(amounts->type))
+        {
+        amountsVec[i] = getDirectFloat(amounts);
+        amounts = amounts->next;
+        }
+    else 
+        {
+        freeMemory(amountsVec);
+        freeMemory(timesVec);
+        return(errorProcExt(ERR_NUMBER_EXPECTED, amounts));
+        }
+
+    if(times == NULL) 
+        timesVec[i] = i + 1;
+    else
+        {
+        times = getIntegerExt(times, (UINT *)&number, FALSE);
+        timesVec[i] = number;
+        }
+    }
+
+result = irr(N, timesVec, amountsVec, guess);
+if(result < 0.00001) 
+    result = 0.0;
+else
+    {
+    result = floor((10000 * result + 0.5))/10000;
+    }
+
+freeMemory(amountsVec);
+freeMemory(timesVec);
+
+if(result == IRR_ERROR)
+    return(nilCell);
+
+return(stuffFloat(result));
+}
+
+/* ----------------------------------- CRC32 ----------------------- */
+
+/* see also https://github.com/mattsta/crcspeed/blob/master/crc64speed.c
+   for fast 64-bt crc and here: https://matt.sh/redis-crcspeed
+*/
+
+#ifdef CRC16
+unsigned short crc16(unsigned char * buff, int len)
+{
+int i;
+unsigned short acc = 0xFFFF;
+
+for(i = 0; i < len; i++)
+    {
+    acc ^= buff[i];
+    acc  = (acc >> 8) | (acc << 8);
+    acc ^= (acc & 0xff00) << 4;
+    acc ^= (acc >> 8) >> 4;
+    acc ^= (acc & 0xff00) >> 5;
+    }
+
+return(acc);
+}
+#endif
+
+/* Algorithm from: http://www.w3.org/TR/PNG-CRCAppendix.html */
+
+CELL * p_crc32(CELL * params)
+{
+char * data;
+size_t len;
+unsigned int crc;
+
+getStringSize(params, &data, &len, TRUE);
+crc = update_crc(0xffffffffL, (unsigned char *)data, (int)len) ^ 0xffffffffL;
+return(stuffInteger64(crc));
+}
+
+/* Update a running CRC with the bytes buf[0..len-1]--the CRC
+   should be initialized to all 1's, and the transmitted value
+   is the 1's complement of the final running CRC (see the
+   crc() routine below)). 
+*/
+   
+unsigned int update_crc(unsigned int crc, unsigned char *buf, int len)
+{
+/* unsigned int crc_table[256]; */
+static unsigned int * crc_table = NULL; 
+unsigned int c;
+int n, k;
+
+if(crc_table == NULL)
+    { 
+    /* make crc table */  
+    crc_table = (unsigned int *)malloc(sizeof(unsigned int) * 256);
+    for (n = 0; n < 256; n++) 
+        {
+        c = (unsigned int) n;
+        for (k = 0; k < 8; k++) 
+            {
+            if (c & 1)
+                c = 0xedb88320L ^ (c >> 1);
+            else
+            c = c >> 1;
+            }
+        crc_table[n] = c;
+        }
+    }
+
+c = crc;   
+
+/* update crc */
+for (n = 0; n < len; n++) 
+    c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
+
+return c;
+}
+
+
+/* ----------------------------------- Bayesian statistics -------------------------- */
+
+/* 
+
+   (bayes-train M1 M2 [M3 ... Mn] D)
+
+   takes two or more lists M1, M2 ... with tokens from a joint set of tokens T.
+   Token can be symbols or strings other datatypes are ignored.
+   Tokerns are placed in a common dictionary in context D and the frquency 
+   is counted  how often they occur in each category Mi.
+   
+   The M categories represent data models for which a sequence of tokens can be
+   classified see (bayes-query ...)
+   
+   Each token in D is a content addressable symbol in D containing a
+   list of ferquencies of that token how often it occurs in each category.
+   String tokens are prepended with an undersocre _ before convering them
+   to a symbol in D.
+   
+   The function returns a list of token numbers in the different category models: 
+   (N-of-tokens-in-M1 N-of-tokens-in-M2)
+   
+   (bayes-train M1 M2 [M3 ... Mn] D)
+
+*/ 
+
+CELL * p_bayesTrain(CELL * params)
+{
+CELL * * category;
+CELL * list;
+CELL * count;
+int * total;
+int i, idx, maxIdx = 0;
+SYMBOL * ctx;
+SYMBOL * sPtr;
+SYMBOL * totalPtr;
+char * token;
+
+list = params;
+while(list != nilCell) list = list->next, maxIdx++;
+--maxIdx; /* last is a context not a category */
+if(maxIdx < 1) errorProc(ERR_MISSING_ARGUMENT);
+
+category = alloca(maxIdx * sizeof(CELL *));
+total = alloca(maxIdx * sizeof(int));
+token = alloca(MAX_SYMBOL + 1);
+
+for(idx = 0; idx < maxIdx; idx++)
+  {
+  params = getListHead(params, &list);
+  category[idx] = list;
+  }
+  
+if((ctx = getCreateContext(params, TRUE)) == NULL)
+  return(errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, params));
+            
+for(idx = 0; idx < maxIdx; idx++)
+  {
+  list = category[idx];
+  total[idx] = 0;
+  while(list != nilCell)    
+    {
+
+    switch(list->type)
+      {
+      case CELL_STRING:
+        if(list->aux > MAX_SYMBOL + 1) continue;
+        *token = '_';
+        memcpy(token + 1, (char *)list->contents, list->aux);
+        break;
+      case CELL_SYMBOL:
+        strncpy(token, ((SYMBOL *)list->contents)->name, MAX_SYMBOL + 1);
+        break;
+      }
+    
+    sPtr = translateCreateSymbol(token, CELL_EXPRESSION, ctx, TRUE);
+    if(((CELL*)sPtr->contents)->type == CELL_NIL)
+      {
+      /* create list with maxIdx 0s */
+      count = getCell(CELL_EXPRESSION);
+      sPtr->contents = (UINT)count;
+      count->contents = (UINT)stuffInteger(0);
+      count = (CELL *)count->contents;
+      for(i = 1; i < maxIdx; i++)
+        {
+        count->next = stuffInteger(0);
+        count = count->next;
+        }
+      }
+
+    /* increment value at idx */
+    count = (CELL *)sPtr->contents;
+    if(count->type != CELL_EXPRESSION)
+      return(errorProcExt(ERR_LIST_EXPECTED, count));
+    count = (CELL *)count->contents;
+    for(i = 0; i < idx; i++) 
+      count = count->next;
+    if(count->type == CELL_LONG)    
+      count->contents++;  
+#ifndef NEWLISP64
+    else if(count->type == CELL_INT64)
+      *(INT64 *)&count->aux += 1;
+#endif
+    else
+      return(errorProcExt(ERR_NUMBER_EXPECTED, count));
+    total[idx]++;
+    list = list->next;
+    } /* done category idx */
+  }
+
+totalPtr = translateCreateSymbol("total", CELL_EXPRESSION, ctx, TRUE);
+if(((CELL *)totalPtr->contents)->type == CELL_NIL)
+  {
+  count = getCell(CELL_EXPRESSION);
+  totalPtr->contents = (UINT)count;
+  count->contents = (UINT)stuffInteger(0);
+  count = (CELL *)count->contents;
+  for(i = 1; i < maxIdx; i++)
+    {
+    count->next = stuffInteger(0);
+    count = count->next;
+    }
+  }
+
+count = (CELL *)totalPtr->contents;
+if(count->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_LIST_EXPECTED, count));
+count = (CELL *)count->contents;
+for(i = 0; i < maxIdx; i++)
+  {
+  if(count->type == CELL_LONG)
+    count->contents += total[i];
+#ifndef NEWLISP64
+  else if(count->type == CELL_INT64)
+    *(INT64 *)&count->aux += total[i];
+#endif
+  count = count->next;
+  }    
+
+return(copyCell((CELL *)totalPtr->contents));
+}
+
+/* 
+   (bayes-query L D [trueChainedBayes])
+   (bayes-query L D [trueChainedBayes] [trueFloatProbs)
+   
+   Takes a list of tokens L and a trained dictionary D and returns a list of the 
+   combined probabilities of the tokens to be in one category A versus the other 
+   categories B. All token in L should occur in D, for tokens which are not in D
+   equal probability is asssumed over categories.
+   
+   Token can be strings or symbols. If token are strings, they are prepended with 
+   an underscore when looked up in D. When frequencies in D were learned using 
+   bayes-train, the underscore was automatically prepended during learning.
+
+   for 2 categories:
+   
+                     p(tkn|A) * p(A)
+   p(A|tkn) = ---------------------------------
+              p(tkn|A) * p(A) + p(tkn|B) * p(B)
+              
+   p(A|tkn) is the posterior for A which gets prior p(A) for the next token the 
+   priors: p(A) and p(B) = 1 are substituted after every token. p(A) = p(not B).
+
+   for N categories:
+   
+                    p(tkn|Mc) * p(Mc)
+   p(Mc|tkn) = -------------------------------    ; Mc is one of N categories
+                sum-i-N( p(tkn|Mi) * p(Mi) ) 
+              
+   
+   When in chain Bayes mode p(Mc|tkn) is the posterior for Mc and replaces the 
+   prior p(Mc) for the next token. In chain Bayes mode tokens with 0 frequency 
+   in one category will effectiviely put the probability of this category to 0. 
+   This causes queries resulting in 0 probabilities for all categories to yield 
+   NaN values. 
+   
+   The pure chain Bayes mode is the more sensitive one for changes, when a token 
+   count of 0 occurs the resulting probability goes to a complete 0 in this 
+   category, while other categories gain higher probabilities. In the Fisher's  
+   Chi2 mode the the zero-category is still assigned a probability resulting from 
+   other tokens with non-zero counts.
+*/
+
+CELL * p_bayesQuery(CELL * params)
+{
+CELL * tokens;
+CELL * tkn;
+char * token;
+SYMBOL * ctx;
+SYMBOL * sPtr;
+SYMBOL * totPtr;
+CELL * count;
+CELL * total;
+int i, idx; 
+int nTkn = 0;   /* number of token in query */
+int maxIdx = 0; /* number of catagories */
+int N = 0;      /* total of tokens in all categories */
+int chainBayes, probFlag;
+double * priorP;
+double * postP;
+double * p_tkn_and_cat;
+double p_tkn_and_all_cat;
+double * Pchi2 = NULL;
+double * Qchi2 = NULL;
+INT countNum, totalNum;
+
+CELL * result = NULL;
+CELL * cell = NULL;
+
+params = getListHead(params, &tokens);
+params = getContext(params, &ctx);
+
+chainBayes = getFlag(params);
+probFlag = getFlag(params->next);
+
+totPtr = translateCreateSymbol("total", CELL_EXPRESSION, ctx, FALSE);
+if(totPtr == NULL)  return(nilCell);
+
+total = (CELL *)totPtr->contents;
+if(total->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_LIST_EXPECTED, (CELL *)totPtr->contents));
+
+/* 
+   Get number of categories maxIdx and total N in all categories.
+   If no probabilities are specified get frequencies/counts  
+*/
+total = (CELL *)total->contents;
+while(total != nilCell)
+    {
+    if(probFlag == FALSE)
+        {
+        if(total->type == CELL_LONG)
+            N += total->contents;
+#ifndef NEWLISP64
+        else if(total->type == CELL_INT64)
+            N += *(INT64 *)&total->aux;
+#endif
+        }
+    total = total->next;
+    maxIdx++;
+    }
+
+/* allocate memory for priors and posts for each category */ 
+priorP = alloca(maxIdx * sizeof(double));
+postP = alloca(maxIdx * sizeof(double));
+p_tkn_and_cat = alloca(maxIdx * sizeof(double));
+
+/* allocate memory fo Chi-2 probs for each category */
+if(!chainBayes)
+    {
+    Pchi2 = alloca(maxIdx * sizeof(double));
+    Qchi2 = alloca(maxIdx * sizeof(double));
+    }
+
+/* calculate the prior prob for each category */
+total = (CELL *)((CELL *)totPtr->contents)->contents;
+for(idx = 0; idx < maxIdx; idx++) 
+    {
+    if(probFlag == TRUE)
+#ifndef NEWLISP64
+        priorP[idx] = *(double *)&total->aux; 
+#else
+        priorP[idx] = (double)total->contents;
+#endif
+    else
+        {
+        if(total->type == CELL_LONG)
+            priorP[idx] = (double)total->contents / N;
+#ifndef NEWLISP64
+        else /* INT64 */
+            priorP[idx] = (double)*(INT64 *)&total->aux / N;
+#endif
+        }
+
+#ifdef BAYES_DEBUG
+    printf("priorP[%d]=%f probability of category %d\n", idx, priorP[idx], idx);  
+#endif                                    
+
+    total = total->next;
+    /* initialize Fisher's Chi-2 probs and priors */
+    if(!chainBayes) 
+        {
+        Pchi2[idx] = Qchi2[idx] = 0.0;
+        priorP[idx] = 1.0 / maxIdx;
+        }
+    }
+
+token = alloca(MAX_SYMBOL + 1);
+tkn = tokens;
+while(tkn != nilCell) tkn = tkn->next, nTkn++;
+
+/* for each token  calculate p(tkn|M) in each category M */
+tkn = tokens;
+for(i = 0; i < nTkn; i++)
+    {
+    switch(tkn->type)
+      {
+      case CELL_STRING:
+        if(tkn->aux > MAX_SYMBOL + 1) continue;
+        *token = '_';
+        memcpy(token + 1, (char *)tkn->contents, tkn->aux);
+        break;
+      case CELL_SYMBOL:
+        strncpy(token, ((SYMBOL *)tkn->contents)->name, MAX_SYMBOL + 1);
+        break;
+      }
+
+    if((sPtr = lookupSymbol((char *)token, ctx)) == NULL) 
+        {
+        /* skip the token if it doesn't occur in data */
+        tkn = tkn->next;
+        continue;
+        }
+
+    count = (CELL *)sPtr->contents;
+    if(count->type != CELL_EXPRESSION) continue;
+  
+    count = (CELL *)(CELL *)count->contents;
+    total = (CELL *)((CELL *)totPtr->contents)->contents;
+     
+    /* in each category M[idx] */ 
+    p_tkn_and_all_cat = 0.0;
+    for(idx = 0; idx < maxIdx; idx++)
+        {
+        if(probFlag)
+#ifndef NEWLISP64
+            p_tkn_and_cat[idx] = *(double *)&count->aux * priorP[idx];
+#else
+            p_tkn_and_cat[idx] = *(double *)&count->contents * priorP[idx];
+#endif  
+        else /*   p(M) * p(tkn|M) */         
+            {
+            /* count of token in category idx */
+            getInteger(count, (UINT *)&countNum); 
+            /* total of all tokens in category idx */
+            getInteger(total, (UINT *)&totalNum); 
+            p_tkn_and_cat[idx] = priorP[idx] * countNum / totalNum;
+            }
+        
+        /* accumulate probability of token in all cataegories */
+        p_tkn_and_all_cat += p_tkn_and_cat[idx];
+
+#ifdef BAYES_DEBUG
+        printf("token[%d] p(M[%d]) * p(tkn|M[%d])=%lf * %ld / %ld = %lf\n", i, idx, idx, 
+            priorP[idx], countNum, totalNum, (double)p_tkn_and_cat[idx]);
+#endif
+        count = count->next;
+        total = total->next;
+        }  
+        
+    for(idx = 0; idx < maxIdx; idx++)
+        {
+        if(!chainBayes)
+            {
+            postP[idx] = p_tkn_and_cat[idx] / p_tkn_and_all_cat;
+            
+            /* handle probability limits of 0 and using very small value */
+            if(postP[idx] == 0.0)
+                Qchi2[idx] += log(3e-308) * -2.0;
+            else
+                Qchi2[idx] += log(postP[idx]) * -2.0;
+                       
+            if(postP[idx] == 1.0) 
+                Pchi2[idx] += log(3e-308) * -2.0; 
+            else 
+                Pchi2[idx] += log(1.0 - postP[idx]) * -2.0;
+            } 
+        else 
+            {
+            postP[idx] = p_tkn_and_cat[idx] / p_tkn_and_all_cat; 
+            priorP[idx] = postP[idx]; 
+            }
+#ifdef BAYES_DEBUG
+        printf("postP[%d] = p_tkn_and_cat[%d] / p_tkn_and_all_cat = %lf / %lf = %lf\n", 
+          idx, idx, p_tkn_and_cat[idx], p_tkn_and_all_cat, postP[idx]);
+#endif
+        }
+        
+    tkn = tkn->next;
+    }
+    
+if(!chainBayes)
+    {
+    for(idx = 0; idx < maxIdx; idx++)
+      {
+#ifdef BAYES_DEBUG
+        printf("Qchi2[%d] = %f, Pchi2[%d] = %f, nTkn = %d\n", idx, Qchi2[idx], idx, Pchi2[idx], nTkn);
+#endif
+      /* corrected swapped Pchi2[idx] and Qchi2[idx] in 10.5.5 */
+      postP[idx] = (probChi2(Pchi2[idx],  2 * nTkn) - probChi2(Qchi2[idx],  2 * nTkn)  + 1.0) / 2.0;
+      }
+    }
+                                                
+    
+for(idx = 0; idx < maxIdx; idx++)
+    {
+    if(idx == 0)
+        {
+        result = getCell(CELL_EXPRESSION);
+        result->contents = (UINT)stuffFloat(*(postP + idx));
+        cell = (CELL *)result->contents;
+        }
+    else
+        {
+        cell->next = stuffFloat(*(postP + idx));
+        cell = cell->next;
+        }
+    }
+
+return(result);
+}
+
+/*
+//
+// Copyright (C) 1992-2016 Lutz Mueller <lutz@nuevatec.com>
+// 
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2, 1991,
+// as published by the Free Software Foundation.
+//
+// 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.
+//
+*/
+
+/*
+ 'unify' for Prolog like unification of s-expressions:
+  (unify '(f (g A) A) '(f B xyz)) => binds A to xyz and B to (g xyz)
+
+  variable symbols must start with an upper-case letter, variables
+  containing nil are considered unbound
+
+  after linear left to right unification each variable symbol is expanded
+  by all other variable symbols
+*/
+
+#ifdef SUPPORT_UTF8
+#include <wctype.h>
+#endif
+
+typedef struct
+    {
+    CELL * left;
+    CELL * right;
+    void * next;
+    } TERMSET;
+
+void pushSet(TERMSET * * root, CELL * left, CELL * right);
+CELL * unify(CELL * left, CELL * right);
+int unifyGetType(CELL * cell);
+void substitute(CELL * expr, CELL * sym, TERMSET * tset);
+CELL * subsym(CELL * expr, CELL * sym, CELL * cell);
+CELL * finishUnify(CELL * result);
+int occurCheck(CELL * symCell, CELL * expr);
+void printStack(TERMSET * tset);
+void freeTermSet(TERMSET * * tset);
+
+TERMSET * mgu = NULL; /* most general unifier */
+TERMSET * ws = NULL;
+
+int bindFlag;
+
+#ifdef DEBUG
+int debugFlag;
+#endif
+
+CELL * p_unify(CELL * params)
+{
+CELL * left, * right;
+CELL * envHead;
+left = evaluateExpression(params);
+params = params->next;
+right = evaluateExpression(params);
+
+if((params = params->next) != nilCell)
+    {
+    params = getListHead(params, &envHead);
+    while(envHead != nilCell)
+        {
+        if(envHead->type != CELL_EXPRESSION)
+            return(errorProcExt(ERR_LIST_EXPECTED, envHead));
+        pushSet(&ws, copyCell((CELL*)envHead->contents),
+                    copyCell(((CELL*)envHead->contents)->next));
+        envHead = envHead->next;
+        }
+    }
+
+bindFlag =  getFlag(params);
+
+#ifdef DEBUG
+debugFlag =  getFlag(params->next);
+if(debugFlag) printStack(ws);
+#endif
+
+return(unify(left, right));
+}
+
+#define UNIFY_ATOM 0
+#define UNIFY_LIST 1
+#define UNIFY_VAR 2
+#define UNIFY_ANY 3
+
+void pushSet(TERMSET * * root, CELL * left, CELL * right)
+{
+TERMSET * set;
+
+set = (TERMSET *)callocMemory(sizeof(TERMSET));
+
+set->left = left;
+set->right = right;
+set->next = *root;
+*root = set;
+}
+
+void  popSet(TERMSET * * root, CELL * * left, CELL * * right)
+{
+TERMSET * set;
+
+set = *root;
+*root = set->next;
+
+*left = set->left;
+*right = set->right;
+
+freeMemory(set);
+}
+
+
+CELL * unify(CELL * left, CELL * right)
+{
+int leftType, rightType;
+CELL * lCell, * rCell;
+
+pushSet(&ws, copyCell(left), copyCell(right));
+
+while(ws != NULL)
+    {
+    popSet(&ws, &left, &right);
+
+#ifdef DEBUG
+    if(debugFlag)
+        {
+        printf("unify:");
+        printCell(left, FALSE, OUT_CONSOLE);
+        printf(" ");
+        printCell(right, FALSE, OUT_CONSOLE);
+        printf("\n");
+        }
+#endif
+
+    leftType = unifyGetType(left);
+    rightType = unifyGetType(right);
+
+    if(leftType == UNIFY_ANY || rightType == UNIFY_ANY)
+        {
+        deleteList(left);
+        deleteList(right);
+        continue;
+        }
+
+    if( (leftType == UNIFY_ATOM && rightType == UNIFY_ATOM) ||
+        (left->contents == right->contents))
+        {
+        if(compareCells(left, right) == 0)
+            {
+            deleteList(left);
+            deleteList(right);
+            continue;
+            }
+        else
+            {
+            deleteList(left);
+            deleteList(right);
+            return(finishUnify(nilCell));
+            }
+        }
+
+    if(leftType == UNIFY_VAR && !occurCheck(left, right))
+        {
+        substitute(right, left, mgu); /* expand(right-expr, left-sym) in mgu set */
+        substitute(right, left, ws);  /* expand(right-expr, left-sym) in ws set */
+
+#ifdef DEBUG
+        if(debugFlag)
+            {
+            printf("ws stack\n");
+            printStack(ws);
+            }
+#endif
+        pushSet(&mgu, left, right);
+#ifdef DEBUG
+        if(debugFlag)
+            {
+            printf("mgu stack\n");
+            printStack(mgu);
+            }
+#endif
+        continue;
+        }
+
+    if(rightType == UNIFY_VAR && !occurCheck(right, left))
+        {
+        substitute(left, right, mgu); /* expand(left-expr, right-sym) in mgu set */
+        substitute(left, right, ws); /* expand(left-expr, right-sym) in ws set */
+#ifdef DEBUG
+        if(debugFlag)
+            {
+            printf("ws stack\n");
+            printStack(ws);
+            }
+#endif
+        pushSet(&mgu, right, left);
+#ifdef DEBUG
+        if(debugFlag)
+            {
+            printf("mgu stack\n");
+            printStack(mgu);
+            }
+#endif
+        continue;
+        }
+
+    if(leftType == UNIFY_LIST && rightType == UNIFY_LIST)
+        {
+#ifdef DEBUG
+        if(debugFlag)
+            {
+            printf("lists:");
+            printCell(left, FALSE, OUT_CONSOLE);
+            printf(" ");
+            printCell(right, FALSE, OUT_CONSOLE);
+            printf("\n");
+            }
+#endif
+        if(listlen((CELL*)left->contents) != listlen((CELL*)right->contents))
+            {
+            deleteList(left);
+            deleteList(right);
+            return(finishUnify(nilCell));
+            }
+        
+        lCell = (CELL*)left->contents;
+        rCell = (CELL*)right->contents;
+        while(lCell != nilCell)
+            {
+            pushSet(&ws, copyCell(lCell), copyCell(rCell));
+            lCell = lCell->next;
+            rCell = rCell->next;
+            }
+        deleteList(left);
+        deleteList(right);
+        continue;
+        }
+
+    deleteList(left);
+    deleteList(right);
+    return(finishUnify(nilCell));
+    }
+
+return(finishUnify(trueCell));
+}
+
+int unifyGetType(CELL * cell)
+{
+SYMBOL * sPtr;
+int wchar;
+
+if(isSymbol(cell->type))
+    {
+    if(cell->type == CELL_SYMBOL)
+        sPtr = (SYMBOL *)cell->contents;
+    else
+        sPtr = getDynamicSymbol(cell);
+
+    if(*sPtr->name == '_' && *(sPtr->name + 1) == 0)
+        return(UNIFY_ANY);
+    
+#ifndef SUPPORT_UTF8
+    wchar = *sPtr->name;
+#else
+    utf8_wchar(sPtr->name, &wchar);
+#endif
+    return((wchar > 64 && wchar < 91) ? UNIFY_VAR : UNIFY_ATOM);
+    }
+else if(isList(cell->type))
+    return(UNIFY_LIST);
+
+return(UNIFY_ATOM);
+}
+
+
+int occurCheck(CELL * symCell, CELL * expr)
+{
+CELL * cell;
+
+if(!isEnvelope(expr->type))
+    return(symCell->contents == expr->contents);
+
+cell = (CELL*)expr->contents;
+
+while(cell != nilCell)
+    {
+    if(symCell->contents == cell->contents) return(1);
+    if(isEnvelope(cell->type) && occurCheck(symCell, cell)) return(1);
+    cell = cell->next;
+    }
+
+return(0);
+}
+
+void substitute(CELL * expr, CELL * sym, TERMSET * tset)
+{
+if(tset == NULL) 
+    {
+#ifdef DEBUG
+    if(debugFlag)
+        {
+        printf("empty set in substitute %s for ", ((SYMBOL*)sym->contents)->name);
+        printCell(expr, FALSE, OUT_CONSOLE);
+        printf("\n");
+        }
+#endif
+    return;
+    }
+
+while(tset != NULL)
+    {
+#ifdef DEBUG
+    if(debugFlag)
+        {
+        printf("substitute %s for ", ((SYMBOL*)sym->contents)->name);
+        printCell(expr, FALSE, OUT_CONSOLE);
+        printf("\n");
+        printf("left:");
+        printCell(tset->left, FALSE, OUT_CONSOLE);
+        }
+#endif
+    tset->left = subsym(expr, sym, tset->left);
+#ifdef DEBUG
+    if(debugFlag)
+        {
+        printf("->");
+        printCell(tset->left, FALSE, OUT_CONSOLE);
+        printf(" right:");
+        printCell(tset->right, FALSE, OUT_CONSOLE);
+        }
+#endif
+    tset->right = subsym(expr, sym, tset->right);
+#ifdef DEBUG
+    if(debugFlag)
+        {
+        printf("->");
+        printCell(tset->right, FALSE, OUT_CONSOLE);
+        printf("\n");
+        }
+#endif
+    tset = tset->next;
+    }
+}
+
+
+CELL * subsym(CELL * expr, CELL * sym, CELL * cell)
+{
+SYMBOL * sPtr;
+CELL * sCell;
+
+sPtr = (SYMBOL *)sym->contents;
+sCell = (CELL *)sPtr->contents;
+sPtr->contents = (UINT)expr;
+
+if(isList(cell->type) || cell->type == CELL_QUOTE)
+    {
+    expr =  expand(copyCell(cell), sPtr);
+    deleteList(cell);
+    }
+else
+    {
+    if(cell->contents == (UINT)sPtr)
+        {
+        expr = copyCell(expr); 
+        deleteList(cell);
+        }
+    else
+        expr = cell;
+    }
+
+sPtr->contents = (UINT)sCell;
+return(expr);
+}
+
+CELL * finishUnify(CELL * result)
+{
+CELL * left, * right;
+CELL * list = NULL;
+CELL * assoc,  * cell = NULL;
+SYMBOL * sPtr;
+
+if(result == nilCell)
+    {
+    freeTermSet(&mgu);
+    freeTermSet(&ws);
+    return(nilCell);
+    }
+
+/* make an association list of all bound variables */
+while(mgu != NULL)
+    {
+    popSet(&mgu, &left, &right);
+
+    if(!bindFlag)
+        {
+        assoc = getCell(CELL_EXPRESSION);
+        assoc->contents = (UINT)left;
+        left->next = right;
+        if(list == NULL)
+            {
+            list = getCell(CELL_EXPRESSION);
+            list->contents = (UINT)assoc;
+            }
+        else
+            cell->next = assoc;
+        cell = assoc;
+        }
+    else
+        {
+        sPtr = (SYMBOL*)left->contents;
+        if(isProtected(sPtr->flags))
+            return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(sPtr)));
+        sPtr->contents = (UINT)right;
+        }
+
+    }
+
+freeTermSet(&ws);
+
+if(!list || bindFlag) return(getCell(CELL_EXPRESSION));
+return(list);
+}       
+
+
+void freeTermSet(TERMSET * * tset)
+{
+TERMSET * set;
+
+while(*tset != NULL)
+    {
+    set = *tset;
+    deleteList(set->left);
+    deleteList(set->right);
+    *tset = set->next;
+    freeMemory(set);
+    }
+}
+
+#ifdef DEBUG
+void printStack(TERMSET * tset)
+{
+while(tset != NULL)
+    {
+    printCell(tset->left, FALSE, OUT_CONSOLE);
+    printf("<->");
+    printCell(tset->right, FALSE, OUT_CONSOLE);
+    printf("\n");
+    tset = tset->next;
+    }
+}
+#endif
+
+/* ---------------------------------- end unify ----------------------------- */
+
+CELL * p_bits(CELL * params) 
+{ 
+int count = 0;
+int i; 
+char temp[65];
+char result[65];
+INT64 num;
+CELL * resultList;
+
+params = getInteger64Ext(params, &num, TRUE);
+
+do  {
+    temp[count++] = (num % 2) != 0;
+    num = num >> 1; 
+    } while (num != 0 && count < 64);
+
+if(getFlag(params))
+    {
+    resultList = getCell(CELL_EXPRESSION);
+    for(i = 0; i < count; i++) 
+        addList(resultList, (copyCell (temp[i] ? trueCell : nilCell)));
+    return(resultList);
+    }
+
+for(i = 0; i < count; i++) 
+    result[i] = temp[count - 1 - i] + 48;
+ 
+return(stuffStringN(result, count));
+}
+
+
+#define BOOL_EVEN 0
+#define BOOL_ODD 1
+
+CELL * isOddEven(CELL * params, int type)
+{
+INT64 num;
+
+params = evaluateExpression(params);
+
+#ifdef BIGINT
+if(params->type == CELL_BIGINT)
+    num = *((int *)params->contents + params->aux - 1);
+else
+#endif
+    getInteger64Ext(params, &num, FALSE);
+
+if(type == BOOL_EVEN)
+    return((0 == (num & 1)) ? trueCell : nilCell);
+else /* BOOL_ODD */
+    return((0 == (num & 1)) ? nilCell : trueCell);
+}
+
+CELL * p_isOdd(CELL * params)
+{ return(isOddEven(params, BOOL_ODD)); }
+
+CELL * p_isEven(CELL * params)
+{ return(isOddEven(params, BOOL_EVEN)); }
+
+/* used when passing 32bit floats to library routines */
+CELL * p_flt(CELL * params)
+{
+double dfloatV;
+float floatV;
+unsigned int number;
+
+getFloat(params, &dfloatV);
+
+floatV = dfloatV;
+memcpy(&number, &floatV, 4);
+
+return(stuffInteger64(number));
+}
+
+
+/* ------------------------------ basic statistics ------------------------- */
+
+double * getVector(CELL * data, UINT * N, double * Sum, double * Mean, double * Sd2)
+{
+CELL * cell;
+UINT idx, n;
+double * vector = NULL;
+double value, sum, ssq, sd2;
+CELL * * addr;
+
+n = sum = ssq = 0;
+if(data->type == CELL_EXPRESSION)
+    {
+    if((data = cell = (CELL *)data->contents) == nilCell)
+        return(NULL);
+    n = 1;
+    while(cell->next != nilCell) 
+        { cell = cell->next; n++; }
+    cell = data;
+    vector = callocMemory(sizeof(double) * n);
+    for (idx = 0; idx < n; idx++)
+        {
+        value = getDirectFloat(cell);
+        *(vector + idx) = value;
+        sum += value;
+        ssq += value * value;
+        cell = cell->next;
+        }
+    }
+
+else if(data->type == CELL_ARRAY)
+    {
+    addr = (CELL * *)data->contents;
+    n = (data->aux - 1) / sizeof(CELL *);
+    vector = callocMemory(sizeof(double) * n);
+    for (idx = 0; idx < n; idx++)
+        {
+        cell = *(addr + idx);
+        value = getDirectFloat(cell);
+        *(vector + idx) = value;
+        sum += value;
+        ssq += value * value;
+        }
+    }
+else return(NULL);
+	
+sd2 = ssq - sum * sum / n;
+
+*N = n;
+*Sum = sum;
+*Mean = sum / n;
+*Sd2 = sd2;
+
+return(vector);
+}
+
+
+CELL * p_stats(CELL * params)
+{
+CELL * cell;
+UINT N = 0;
+double sum, mean, sd2, avdev, sdev, var, skew, curt, s;
+double * vector;
+int idx;
+
+if((vector = getVector(evaluateExpression(params), &N, &sum, &mean, &sd2)) == NULL)
+    return(errorProc(ERR_LIST_OR_ARRAY_EXPECTED));
+
+var = sd2 / (N - 1);    /* pop variance */
+sdev = sqrt(var);       /* standard deviation */
+
+skew = curt = avdev = 0.0;
+for(idx = 0; idx < N; idx++)
+    {
+    s = vector[idx] - mean;
+    avdev += fabs(s);
+    skew += s * s * s;
+    curt += s * s * s * s;
+    }
+avdev /= N;
+
+freeMemory(vector);
+
+if(var != 0.0)
+    {
+    skew = skew / (N * var * sdev);
+    curt = curt / (N * var * var) - 3.0; 
+    }
+else skew = curt = 0.0;
+
+cell = getCell(CELL_EXPRESSION);
+addList(cell, stuffInteger(N));
+addList(cell, stuffFloat(mean));
+addList(cell, stuffFloat(avdev));
+addList(cell, stuffFloat(sdev));
+addList(cell, stuffFloat(var));
+addList(cell, stuffFloat(skew));
+addList(cell, stuffFloat(curt));
+
+return(cell);
+}
+
+CELL * p_ttest(CELL * params)
+{
+UINT Nx, Ny, df;
+double sumx, sumy, sumxy;
+double meanx, meany;
+double sd2x, sd2y;
+double varx, vary;
+double sdevx, sdevy;
+double * X;
+double * Y;
+double svar, cov, t, tprob;
+CELL * cell;
+int dependent = FALSE, idx;
+double pF = 0.0;
+
+if((X = getVector(evaluateExpression(params), &Nx, &sumx, &meanx, &sd2x)) == NULL)
+    return(errorProc(ERR_LIST_OR_ARRAY_EXPECTED));
+params = params->next;
+
+cell = evaluateExpression(params);
+if(isNumber(cell->type)) /* One sample t-test */
+    {
+    meany = getDirectFloat(cell);
+    sdevx = sqrt(sd2x / (Nx - 1));
+    sdevy = sdevx / sqrt(Nx); /* standard error of difference */
+    t = (meanx - meany) / ( sdevx / sqrt(Nx) );
+    df = Nx - 1;
+    goto TTEST_RESULT;
+    }
+
+if((Y = getVector(evaluateExpression(params), &Ny, &sumy, &meany, &sd2y)) == NULL)
+    return(errorProc(ERR_LIST_OR_ARRAY_EXPECTED));
+
+sumxy = 0.0;
+for(idx = 0; idx < Nx; idx++)
+    sumxy += X[idx] * Y[idx];
+
+freeMemory(X);
+freeMemory(Y);
+
+cell = evaluateExpression(params->next);
+if(cell == trueCell)
+    {
+    dependent = TRUE;
+    if(Nx != Ny)
+        return(errorProc(ERR_WRONG_DIMENSIONS));
+    }
+else if(isNumber(cell->type))
+    pF = getDirectFloat(cell);
+
+varx = sd2x / (Nx - 1);
+vary = sd2y / (Ny - 1);
+sdevx = sqrt(varx);
+sdevy = sqrt(vary);
+cov = sumxy - sumx * sumy / Nx;
+
+/* t for related samples  Nx = Ny */
+if(dependent)
+    {
+    df = Nx - 1;
+    cov /= df;
+    t = (meanx - meany) / sqrt((varx + vary - 2.0 * cov) / Nx);
+    }
+/* t for different means in non-related samples */
+else
+    {
+    /* if varx and vary are not equal calc Welch Student's t */
+    if(pF != 0.0 && probF(varx/vary, Nx - 1, Ny - 1) < pF) 
+        {
+        t = (meanx - meany) / sqrt(varx/Nx + vary/Ny);
+        df = ((varx/Nx + vary/Ny) * (varx/Nx + vary/Ny)) / 
+             (((varx/Nx) * (varx/Nx)) / (Nx - 1) + ((vary/Ny) * (vary/Ny))/(Ny - 1));
+        }
+    /* assume varx and vary are equal */
+    else
+        {
+        df = Nx + Ny - 2;
+        svar = (sd2x + sd2y) / df;
+        t = (meanx - meany) / sqrt(svar * (1.0/Nx + 1.0/Ny));
+        }
+    }
+
+TTEST_RESULT:
+tprob = 2.0 * (1.0 - probT(fabs(t), df)); /* two tailed */
+cell = getCell(CELL_EXPRESSION);
+addList(cell, stuffFloat(meanx));
+addList(cell, stuffFloat(meany));
+addList(cell, stuffFloat(sdevx));
+addList(cell, stuffFloat(sdevy));
+addList(cell, stuffFloat(t));
+addList(cell, stuffInteger(df));
+addList(cell, stuffFloat(tprob));
+
+return(cell);
+}
+
+
+CELL * p_corr(CELL * params)
+{
+UINT idx, Nx, Ny, df;
+double * X;
+double * Y;
+double sumxy, sumx, sumy, meanx, meany, sd2x, sd2y;
+double cov, corr, b0, b1, t, tprob;
+CELL * cell;
+
+
+if((X = getVector(evaluateExpression(params), &Nx, &sumx, &meanx, &sd2x)) == NULL)
+    return(errorProc(ERR_LIST_OR_ARRAY_EXPECTED));
+if((Y = getVector(evaluateExpression(params->next), &Ny, &sumy, &meany, &sd2y)) == NULL)
+    return(errorProc(ERR_LIST_OR_ARRAY_EXPECTED));
+
+if(Nx != Ny)
+    return(errorProc(ERR_WRONG_DIMENSIONS));
+
+sumxy = 0.0;
+for(idx = 0; idx < Nx; idx++)
+    sumxy += X[idx] * Y[idx];
+
+freeMemory(X);
+freeMemory(Y);
+
+cov = sumxy - sumx * sumy / Nx;
+corr = cov / sqrt(sd2x * sd2y);
+b1 = cov / sd2x;
+b0 = meany - b1 * meanx;
+t = corr * sqrt((Nx - 2) / (1.0 - corr * corr));
+
+/* standard error of corr */
+/* rse = sqrt( (1.0 - corr * corr) / (Nx - 2) ); */
+/* see http://irthoughts.wordpress.com/2010/06/10/on-spearmans-correlation-coefficients-with-excel/ */
+/* rse = corr / t; */
+
+df = Nx - 2;
+tprob = 2 * (1.0 - probT(fabs(t), df)); /* two tailed */
+
+cell = getCell(CELL_EXPRESSION);
+addList(cell, stuffFloat(corr));
+addList(cell, stuffFloat(b0)); /* y = b0 + b1*x */
+addList(cell, stuffFloat(b1));
+addList(cell, stuffFloat(t));
+addList(cell, stuffInteger(df));
+addList(cell, stuffFloat(tprob));
+
+return(cell);
+}
+
+/* ============================= Big Integer support ============================= */
+
+/* other big int libs:
+    GNU GMP https://gmplib.org/
+    MPIR http://www.mpir.org/ 
+    BSDNT https://github.com/wbhart/bsdnt 
+*/
+
+#ifdef BIGINT
+
+/* translate either INT64 or double float to big int */
+
+CELL * p_bigInt(CELL * params)
+{
+int * numPtr;
+int len, size = 0;
+CELL * cell;
+char * ptr;
+
+cell = evaluateExpression(params);
+if(cell->type == CELL_BIGINT)
+    return(copyCell(cell));
+
+if(cell->type == CELL_STRING)
+    {
+    ptr = (char *)cell->contents;
+    if(*ptr == '-' || *ptr == '+') ++size, ptr++;
+    while(isdigit(*ptr++)) ++size;
+    if(size == 0) return(nilCell);
+    numPtr = strToBigint((char *)cell->contents, size, &len);
+    }
+else getBigintSizeDirect(cell, &numPtr, &len);
+
+cell = getCell(CELL_BIGINT);
+cell->aux = len + 1;
+cell->contents = (UINT)numPtr;
+
+return(cell);
+}
+
+/* does not do evaluate expression on cell
+   returns NULL when called with cell->type CELL_BIGINT
+   else returns numPtr which mast be freed or use by caller
+*/
+int * getBigintSizeDirect(CELL * cell, int * * numPtr, int * len)
+{
+int size = 0;
+int * num = NULL;
+
+#ifndef NEWLISP64
+if(cell->type == CELL_INT64)
+    num = intToBigint(*(INT64 *)&cell->aux, &size);
+else if(cell->type == CELL_LONG)
+    num = intToBigint((INT64)cell->contents, &size);
+else if(cell->type == CELL_FLOAT)
+    {
+#ifdef WINDOWS
+    if(isnan(*(double *)&cell->aux) || !_finite(*(double *)&cell->aux)) 
+        num = intToBigint(0, &size);
+    num = floatToBigint(*(double *)&cell->aux, &size);
+#else
+    if(isnan(*(double *)&cell->aux)) 
+        num = intToBigint(0, &size);
+    num = floatToBigint(*(double *)&cell->aux, &size);
+#endif
+    }
+#else /* NEWLISP64 */
+if(cell->type == CELL_LONG)
+    num = intToBigint((INT64)cell->contents, &size);
+else if(cell->type == CELL_FLOAT)
+    {
+    if(isnan(*(double *)&cell->contents))  
+        num = intToBigint(0, &size);
+    num = floatToBigint( *(double *)&cell->contents, &size);
+    }
+#endif
+else if(cell->type == CELL_BIGINT)
+    {
+    *numPtr = (int *)cell->contents;
+    *len = cell->aux - 1;
+    return(NULL);
+    }
+else 
+    errorProcArgs(ERR_NUMBER_EXPECTED, cell);
+
+*numPtr = num;
+*len = size;
+
+return(num);
+}
+
+
+/*  memory for num int array is allocated inside
+    return is ptr to the int array and length in *intlen
+*/
+int * strToBigint(char * str, int len, int * intlen)
+{
+int n, i, j, cut;
+int sign = 1;
+char * ptr = str;
+int * num;
+
+/* don't look at trailing L */
+if(*(str + len - 1) == 'L')
+    len--;
+
+/* skip leading sign */
+if(*ptr == '-' || *ptr == '+')
+    {
+    sign = (*ptr == '-') ? -1 : 1;
+    ptr++;
+    len--;
+    }
+
+/* remove leading zeros */
+while(len > 1 && *ptr == '0')
+    {
+    ptr++;
+    len--;
+    }
+
+n = len / 9 + 1;
+cut = len % 9;
+if(cut) n++;
+else cut = 9;
+
+num = calloc(sizeof(int), n);
+num[0] = sign;
+
+for(i = 1; i < n; i++)
+    {
+    for(j = 0; j < cut; j++)
+	num[i] = 10 * num[i] + ptr[j] - 48;
+    ptr += cut;
+    cut = 9;
+    }
+
+*intlen = n - 1;
+return(num);
+}
+
+
+/* when offset is specified (48) '+' is suppressed only '-' is put
+   when offset = 0, first digit is either -1 or 1  
+   call with offset either 0 or 48
+   do  ot call with 0 for num
+*/
+char * bigintToDigits(int * num, int n, int offset, int * slen)
+{
+int i, j, k = 0, cnt = 0, len = 0;
+int q, basediv;
+char * digits;
+int bigdigit;
+
+if(n == 1 && num[1] == 0)
+    {
+    digits = calloc(3, 1);
+    if(offset == 0)
+        {
+        digits[0] = '1';
+        digits[1] = 0;
+        }
+    else
+        digits[0] = '0';
+    return(digits); 
+    }
+
+/* cnt of digits in first big digit */
+bigdigit = num[1];
+basediv = BIGINT_BASE / 10;
+while(bigdigit / basediv == 0)
+    {
+    basediv /= 10;
+    cnt++;
+    }
+
+cnt = 9 - cnt;
+len = 9 * (n - 1) + cnt;
+
+digits = calloc(len + 2, 1);
+if(offset != 0)
+    {
+    if(num[0] == -1) digits[k++] = '-';
+    }
+else
+    digits[k++] = num[0];
+
+for(i = 1; i <=n; i++)
+    {
+    bigdigit = num[i];
+    for(j = 0; j < cnt; j++)
+        {
+        q = bigdigit / basediv;
+        digits[k++] = q + offset;
+        bigdigit -= q * basediv;
+        basediv /= 10; 
+        }
+    basediv = BIGINT_BASE / 10;
+    cnt = 9;
+    }
+
+if(slen) *slen = len;
+return(digits);
+} 
+
+/* digits come in high to low with leading sign digit (1 or -1)
+   nx and ny are the length without sign digit
+*/
+
+int * addBigint(int * x, int nx, int * y, int ny, int * sm, int * nsm)
+{
+int i, carry = 0, digit, n, d, sign;
+int * ptr;
+
+if(nx < ny)
+    {
+    n = nx; nx = ny; ny = n;
+    ptr = x; x = y; y = ptr;
+    }
+d = nx - ny;
+
+if(*x != *y) /* signs are different */
+    {
+    sign = x[0]; 
+    y[0] = sign;
+    sm = subBigint(x, nx, y, ny, sm, nsm);
+    x[0] = sign; y[0] = sign * -1;
+    return(sm);
+    }
+    
+ptr = sm + 1;
+
+/* memset(sm, 0, (nx + 2) * sizeof(int)); */
+
+for(i = ny; i > 0; i--) /* ny is the smaller */
+    {
+    digit = x[i + d] + y[i] + carry;
+    carry = digit / BIGINT_BASE;
+    ptr[i + d] = digit % BIGINT_BASE;
+    }
+
+for(i = nx - ny; i > 0; i--) /* nx is the bigger */
+    {
+    digit = x[i] + carry;
+    carry = digit / BIGINT_BASE;
+    ptr[i] = digit % BIGINT_BASE;
+    }
+ptr[0] = carry;
+
+if(*ptr == 0)
+    {
+    for(i = 0; i < nx; i++)
+        ptr[i] = ptr[i + 1];
+    *nsm = nx;
+    }
+else
+    *nsm = nx + 1;
+
+sm[0] = x[0];
+
+return(sm);
+}
+
+    
+int * subBigint(int * x, int nx, int * y, int ny, int * sm, int * nsm)
+{
+INT64 digit;
+int * ptr;
+int sign, i, j, n, carry = 0;
+
+if(*x != *y)
+    {
+    sign = x[0];
+    y[0] = sign;
+    addBigint(x, nx, y, ny, sm, nsm);
+    x[0] = sign; y[0] = sign * -1;
+    return(sm); 
+    }
+
+/* compare and subtract the abs(smaller) from the abs(greater) */
+if(cmpAbsBigint(x, nx, y, ny) >= 1)
+    sm[0] = x[0];
+else
+    {
+    sm[0] = x[0] * -1;
+    n = nx; nx = ny; ny = n;
+    ptr = x; x = y; y = ptr; 
+    }
+
+for(i = nx, j = ny; i > 0; i--, j--)
+    {
+    if(j > 0)
+        digit = (INT64)x[i] - y[j] - carry;
+    else
+        digit = (INT64)x[i] - carry;
+    if(digit < 0)
+        {
+        digit = digit + BIGINT_BASE;
+        carry = 1;
+        }
+    else
+        carry = 0;
+
+    sm[i] = digit % BIGINT_BASE;
+    }
+
+i = 1; n = 0;
+
+/* remove leading zero's */
+while (sm[i] == 0 && i <= nx) n++, i++;
+if(n == nx)
+    {
+    *nsm = 1;
+    return(sm);
+    }
+
+memmove((char *)sm + 1 * sizeof(int), (char *)sm + (n + 1) * sizeof(int), (nx - n) * sizeof(int));
+*nsm = (nx - n);
+
+return(sm);
+}
+
+
+int * mulBigint(int * x, int nx, int * y,  int ny, int * p, int * n)
+{
+int i, j, k, carry;
+INT64 digit;
+
+memset(p, 0, (nx + ny + 1) * sizeof(int));
+for(i = ny; i > 0 ; i--) /* for each digit in multiplier */
+    {
+    carry = 0;
+    for(j = nx; j > 0; j--)
+        {
+        digit = (INT64)p[j + i] + (INT64)y[i] * x[j] + carry;
+        carry = digit / BIGINT_BASE;
+        p[j + i] = digit % BIGINT_BASE;
+        }
+    digit = (INT64)p[i] + carry;
+    p[i] = digit % BIGINT_BASE;
+    }
+
+/* remove leading zero's */
+k = nx + ny;
+while(p[1] == 0 && k > 1)
+    {
+    for(i = 1; i < k; i++)
+        p[i] = p[i + 1];
+    k--;
+    }
+
+/* set sign  and n */
+*p = *x * *y;
+*n = k;
+return(p);
+}
+
+
+/* q = x/y - caller must _not_ allocate space for q
+*/
+int * divModBigint(int * x, int nx, int * y, int ny, int rmndr, int * nq)
+{
+int * r;
+int * q;
+int * p;
+int * ptr;
+INT64 digit;
+int i, j, k, carry;
+int nr, sq, n, pn;
+/* turn of certain optimizations using 'volatile' necessary 
+   on Linux but will no affect performance on other platforms
+*/
+volatile double rFloat, yFloat;
+
+if(y[1] == 0 && ny == 1)
+    errorProc(ERR_MATH);
+
+if(cmpAbsBigint(x, nx, y, ny) < 0)
+    {
+    if(rmndr)
+        {
+        q = malloc((nx + 1) * sizeof(int));
+        memcpy((void *)q, (void *)x, (nx + 1) * sizeof(int));
+        *nq = nx;
+        }
+    else
+        {
+        q = malloc(sizeof(int) * 2);
+        q[0] = 1; q[1] = 0;
+        *nq = 1;
+        }
+    return(q);
+    }
+
+r = alloca((nx + 1) * sizeof(int));
+q = alloca((nx - ny + 1) * sizeof(int));
+p = alloca((nx + 1) * sizeof(int));
+
+nr = 0; sq = 0;
+r[0] = q[0] = p[0] = 1; 
+yFloat = bigintToAbsFloat(y, (ny > 2) ? 2 : ny);
+#ifdef DEBUG
+printf("yFloat %f\n", yFloat); 
+#endif
+for(i = 1; i <= nx; i++)    
+    {
+#ifdef DEBUG
+    printf("i = %d\n", i);
+#endif
+    r[++nr] = x[i];
+#ifdef DEBUG
+    debug(r, nr, "r after <- x[i]");
+#endif
+    if(sq == 0 && cmpAbsBigint(r, nr, y, ny) < 0)
+        continue;
+
+    n = (ny > 2) ? (nr + 2 - ny) : nr; 
+    rFloat = bigintToAbsFloat(r, n);
+#ifdef DEBUG
+    printf("rFloat %f\n", rFloat); 
+#endif
+
+    if(yFloat > rFloat)
+        {
+#ifdef DEBUG
+        printf("yFloat > rFloat\n");
+#endif
+        q[++sq] = 0;
+        goto TRIM_ZEROS;
+        }
+
+    if(yFloat == rFloat)
+        {
+#ifdef DEBUG
+        printf("yFloat == rFloat\n");
+#endif
+        q[++sq] = 1;
+        }
+    else 
+        q[++sq] = rFloat / yFloat + 1.0; /* like ceil() */
+#ifdef DEBUG
+    debug(q, sq, "q after float div");
+#endif
+
+    PRODUCT: 
+    carry = 0;
+    for(j = ny, pn = ny; j > 0; j--)
+        {
+        digit = (INT64)y[j] * q[sq] + carry;
+        if(digit >= BIGINT_BASE)
+            {
+            p[j] = digit % BIGINT_BASE;
+            carry = digit/BIGINT_BASE;
+            }
+        else
+            p[j] = digit, carry = 0;
+        }
+    if(carry) /* shift right */
+        {
+        for(j = ny; j > 0; j--) p[j+1] = p[j];
+        p[1] = carry, ++pn;
+        }
+#ifdef DEBUG
+    debug(p, pn, "p product");
+#endif
+    if(cmpAbsBigint(r, nr, p, pn) < 0) 
+        {
+        q[sq] = q[sq] - 1; /* q[sq] too big */
+#ifdef DEBUG
+        printf("decrementing q[sq]\n");
+#endif
+        goto PRODUCT;
+        }
+
+    /* ----- inlined from subBigint ----- */
+    for(k = nr, j = pn, carry = 0; k > 0; k--, j--)
+        {
+        if(j > 0)
+            digit = (INT64)r[k] - p[j] - carry;
+        else
+            digit = (INT64)r[k] - carry;
+        if(digit < 0)
+            {
+            digit += BIGINT_BASE;
+            carry = 1;
+            }
+        else
+            carry = 0;
+
+        r[k] = digit % BIGINT_BASE;
+        }
+    /* trim leading zero's */
+TRIM_ZEROS:
+    if(r[1] == 0) {
+        k = 1; n = 0;
+        while (r[k] == 0 && k <= nr) n++, k++;
+        if(n == nr) nr = 1;
+        else
+            {
+            nr = (nr - n);
+            memmove((char *)r + 1 * sizeof(int), 
+                (char *)r + (n + 1) * sizeof(int), nr * sizeof(int));
+            }
+        }
+#ifdef DEBUG
+    debug(r, nr, "r after subtraction and trimming");
+#endif
+    /* ---------------------------------- */
+    if(r[1] == 0 && i < nx) nr = 0;
+    }
+
+if(rmndr)
+    {
+    q = malloc((nr + 1) * sizeof(int));
+    memcpy((void *)q, (void *) r, (nr + 1) * sizeof(int));
+    q[0] = x[0]; /* set sign */
+    *nq = nr;
+    }
+else
+    {
+    ptr = malloc((sq + 1) * sizeof(int));
+    memcpy((void *)ptr, (void *)q, (sq + 1) * sizeof(int));
+    q = ptr;
+    q[0] = *x * *y;
+    *nq = sq;
+    }     
+return(q);
+}
+
+
+int cmpAbsBigint(int * x, int nx, int * y, int ny)
+{
+int cmp, i;
+
+cmp = nx - ny;
+if(cmp == 0)
+    {
+    for(i = 1; i <= nx; i++)
+        {
+        if(x[i] > y[i]) return(1);
+        if(x[i] < y[i]) return(-1);
+        }
+    return(0);
+    }
+
+return (cmp > 0) ? 1 : -1;
+}
+
+int cmpBigint(int * x, int nx, int * y, int ny)
+{
+int cmp;
+
+/* make sure 0 == -0 */
+if(nx == 1 && ny == 1 && x[1] == 0 && y[1] == 0)
+    return(0);
+
+if(*x > *y) return(1);
+if(*x < *y) return(-1);
+
+/* signs are both 1,1 or -1, -1 */
+cmp = cmpAbsBigint(x, nx, y, ny);
+
+return(cmp * *x);
+}
+
+/* biggest  int64  9 223372036 854775807
+   smallest int64 -9 223372036 854775808
+*/
+
+INT64 bigintToInt64(CELL * cell)
+{
+INT64 num;
+int * numPtr;
+int  i;
+
+int maxInt[4] = {1, 9, 223372036, 854775807};
+int minInt[4] = {-1, 9, 223372036, 854775808};
+
+numPtr = (int *)(UINT)cell->contents;
+if(cmpBigint((int *)(UINT)cell->contents, cell->aux -1, maxInt, 3) == 1 ||
+            cmpBigint((int *)(UINT)cell->contents, cell->aux - 1, minInt, 3) == -1)
+    errorProc(ERR_NUMBER_OUT_OF_RANGE);
+
+num = numPtr[1];
+for(i = 2; i < cell->aux; i++)
+    num = num * BIGINT_BASE + numPtr[i];
+
+num = num * numPtr[0];
+
+return(num);
+}
+
+int * intToBigint(INT64 num, int * len)
+{
+int idx = 1;
+int * digit;
+
+digit = malloc(4 * sizeof(int));
+
+if(num < 0)
+    {
+    digit[0] = -1;
+    num = -num;
+    }
+else
+    digit[0] = 1;
+
+if(num > BIGINT_BASE2)
+    {
+    digit[idx] = (int)(num / BIGINT_BASE2);
+    num = num - digit[idx] * BIGINT_BASE2;
+    idx++;
+    }
+
+if(num > BIGINT_BASE)
+    {
+    digit[idx] =(int)(num / BIGINT_BASE);
+    num = num - digit[idx] * BIGINT_BASE;
+    idx++;
+    }
+
+digit[idx] = num;
+
+*len = idx;
+
+return(digit);
+}
+
+
+/* only used internally by divModBigint() 
+   does not check for overflow */
+double bigintToAbsFloat(int * numPtr, int n)
+{
+double value;
+int i;
+
+value = numPtr[1];
+for(i = 2; i <= n; i++)
+    value = value * BIGINT_BASE + numPtr[i];
+
+return(value);
+}
+
+
+double bigintCellToFloat(CELL * cell)
+{
+double value;
+int * numPtr;
+int i;
+
+numPtr = (int *)(UINT)cell->contents;
+value = numPtr[1];
+for(i = 2; i < cell->aux; i++)
+    {
+    value = value * BIGINT_BASE + numPtr[i];
+    if( value > 1.797693134862301e308)
+        return(1/0.0);
+    }
+
+value *= numPtr[0];
+
+return(value);
+}
+
+int * floatToBigint(double fnum, int * len)
+{
+int decDigits, bigDigits;
+int inum, i, sign;
+int * numPtr;
+
+#ifdef SOLARIS
+        if(isnan(fnum - fnum))
+#else
+        if(isinf(fnum))
+#endif
+    errorProcExt2(ERR_CANNOT_CONVERT, stuffFloat(fnum));
+        
+sign = fnum < 0 ? -1 : 1;
+fnum = fnum * sign;
+
+/* account for rounding errors */
+if(fnum > 1.797693134862301e308)
+    fnum = 1.797693134862301e308;
+    
+decDigits = log(fnum) / log(10) + 1;
+if(decDigits <= 0) 
+    {
+    numPtr = calloc(2, sizeof(int));
+    numPtr[0] = 1;
+    *len = 1;
+    return(numPtr);
+    }
+
+bigDigits = ((decDigits - 1) / 9) + 1;
+*len = bigDigits;
+numPtr = calloc(bigDigits + 3, sizeof(int)); 
+numPtr[0] = sign;
+for(i = 1; i <= 3; i++)
+    {
+    inum = fnum / pow(1000000000, (bigDigits - i));
+    numPtr[i] = inum;
+    fnum = fnum - (INT64)inum * pow(1000000000, (bigDigits - i));
+    }
+
+return(numPtr);
+}
+
+int lengthBigint(int * num, int len)
+{
+int cnt = 0;
+int bigdigit, basediv;
+
+if((bigdigit = num[1]) == 0) return(1);
+
+basediv = BIGINT_BASE / 10;
+while(bigdigit / basediv == 0)
+    basediv /= 10, cnt++;
+
+return(9 * (len - 1) + 9 - cnt);
+}
+#endif
+/* eof */
diff --git a/nl-matrix.c b/nl-matrix.c
new file mode 100644
index 0000000..fb7f0cc
--- /dev/null
+++ b/nl-matrix.c
@@ -0,0 +1,1069 @@
+/* nl-matrix.c --- matrix functions for newLISP
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/* Since version 8.9.9 all matrix operations work on lists and 
+   arrays. Previously only lists where supported.
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+#include "float.h"
+
+double * * multiply(double ** A, double ** B, int m, int n, int k, int l);
+double * * invert(double * * A, int n, int * err, double tiny);
+int ludcmp(double * * a, int n, int * indx, double * d, double tiny);
+void lubksb(double * * a, int n, int * indx, double * b);
+double * * getMatrix(CELL * params, int * type, int * n, int * m, int * err);
+double * * makeMatrix(CELL * number, int n, int m);
+int getDimensions(CELL * mat, int * n, int * m);
+double * * data2matrix(CELL * list, int n, int m);
+CELL * matrix2data(double * * matrix, int type, int n, int m);
+double * * allocateMatrix(int rows, int cols);
+void freeMatrix(double * * m, int rows);
+
+/* since version 7.4.8 'transpose' tramspose any matrix not only
+   matrices containing numbers.
+
+   some of the algorithms used come from C LAPACK and index
+   starting 1 not 0 as usual in C
+*/ 
+CELL * p_matTranspose(CELL * params)
+{
+CELL * A;
+CELL * B;
+CELL * rowA = NULL;
+CELL * cell = NULL;
+CELL * conCell;
+CELL * new;
+int n, m, i, j;
+CELL * * Brows;
+
+A = evaluateExpression(params);
+
+if(A->type == CELL_ARRAY)
+    return(arrayTranspose(A));
+
+if(A->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_NOT_MATRIX, params));
+
+if(getDimensions(A, &n, &m) == FALSE)
+    return(errorProcExt(ERR_NOT_MATRIX, params));
+    
+if(n == 0 || m == 0)
+    return(errorProcExt(ERR_WRONG_DIMENSIONS, params));
+
+Brows = allocMemory(sizeof(CELL *) * m);
+for(j = 0; j < m; j++)
+    {
+    Brows[j] = getCell(CELL_EXPRESSION);
+    if(j > 0) Brows[j-1]->next = Brows[j];
+    }
+
+B = makeCell(CELL_EXPRESSION, (UINT)Brows[0]);
+
+for(i = 0; i < n; i++)
+    {
+    if(i == 0)
+        rowA = (CELL*)A->contents;
+    else
+        rowA = rowA->next;
+
+    if(rowA->type != CELL_EXPRESSION)
+        conCell = rowA;
+    else
+        conCell = NULL;
+
+    for(j = 0; j < m; j++)
+        {
+        if(conCell == NULL)
+            {
+            if(j == 0)
+                cell = (CELL*)rowA->contents;
+            else
+                cell = cell->next;
+            new = copyCell(cell);
+            }
+        else
+            new = copyCell(conCell);
+
+        if( i == 0)
+            Brows[j]->contents = (UINT)new;
+        else
+            Brows[j]->next = new;
+
+        Brows[j] = new;
+        }
+    }
+
+free(Brows);
+
+return(B);
+}
+
+
+CELL * p_matMultiply(CELL * params)
+{
+CELL * C;
+double * * X = NULL;
+double * * Y = NULL;
+int typeX, typeY, typeM;
+double * * M = NULL;
+int n, m, k, l;
+int err = 0;
+
+if((X = getMatrix(params, &typeX, &n, &m, &err)) == NULL)
+    return(errorProcExt(err, params));
+
+if((Y = getMatrix(params->next, &typeY, &k, &l, &err)) == NULL)
+    {
+    freeMatrix(X, n);
+    return(errorProcExt(err, params->next));
+    }
+
+typeM = (typeX == CELL_ARRAY || typeY == CELL_ARRAY) ? CELL_ARRAY : CELL_EXPRESSION;
+
+if(m != k)
+    err = ERR_WRONG_DIMENSIONS;
+else if((M = multiply(X, Y, n, m, k, l)) == NULL)
+    err = ERR_NOT_ENOUGH_MEMORY;
+
+freeMatrix(X, n);
+freeMatrix(Y, k);
+
+if(err) return(errorProc(err));
+
+C = matrix2data(M, typeM, n, l);
+freeMatrix(M, n);
+
+return(C);
+}
+
+CELL * p_matInvert(CELL * params)
+{
+CELL * dataY;
+int n, m, err = 0;
+int typeA;
+double * * A;
+double * * Y;
+#ifdef FP_NAN
+double tiny = FP_NAN;
+#else
+double tiny = sqrt(-1);
+#endif
+
+if((A = getMatrix(params, &typeA, &n, &m, &err)) == NULL)
+    return(errorProcExt(err, params));
+
+if(params->next != nilCell)
+    getFloat(params->next, &tiny);
+
+if(n != m) 
+    {
+    freeMatrix(A, n);
+    return(errorProcExt(ERR_WRONG_DIMENSIONS, params));
+    }
+
+if( (Y = invert(A, n, &err, tiny)) == NULL)
+    {
+    freeMatrix(A, n);
+    if(err) return(errorProc(err));
+    return(nilCell);
+    }
+
+dataY = matrix2data(Y, typeA, n, n);
+
+freeMatrix(A, n);
+freeMatrix(Y, n);
+
+return(dataY);
+}
+
+
+CELL * p_determinant(CELL * params)
+{
+double * * M;
+double d;
+int typeM, n, m, i, err;
+int * indx;
+#ifdef FP_NAN
+double tiny = FP_NAN;
+#else
+double tiny = sqrt(-1);
+#endif
+
+if( (M = getMatrix(params, &typeM, &n, &m, &err)) == NULL)
+    return(errorProcExt(err, params));
+
+if(params->next != nilCell)
+    getFloat(params->next, &tiny);
+
+if(n != m) 
+    {
+    freeMatrix(M, n);
+    return(errorProcExt(ERR_WRONG_DIMENSIONS, params));
+    }
+
+indx = (int *)calloc((n + 1), sizeof(int));
+
+if(ludcmp(M, n, indx, &d, tiny) == FALSE)
+    {
+    free(indx);
+    freeMatrix(M, n);
+    return(nilCell);
+    }
+    
+for(i = 1; i <= n; i++)
+    d *= M[i][i];
+
+free(indx);
+freeMatrix(M, n);
+
+return(stuffFloat(d));
+}
+
+
+CELL * p_matScalar(CELL * params)
+{
+CELL * op;
+double * * A = NULL;
+double * * B = NULL;
+double * * M = NULL;
+int typeA, typeB, typeC = 0;
+int type;
+int n, m, k, l, err = 0;
+
+CELL * result;
+op = params;
+op = evaluateExpression(op);
+
+if(op->type == CELL_SYMBOL)
+    type = *((SYMBOL *)op->contents)->name;
+else if(op->type == CELL_PRIMITIVE)
+    type = *(char *)op->aux;
+else
+    return(errorProcExt(ERR_ILLEGAL_TYPE, params));
+
+params = params->next;
+
+if( (A = getMatrix(params, &typeA, &n, &m, &err)) == NULL)
+    return(errorProcExt(err, params));
+
+getEvalDefault(params->next, &result);
+if(isNumber(result->type))
+    {
+    k = n, l = m;
+    if((B = makeMatrix(result, k, l)) == NULL)
+        {
+        err = ERR_NOT_ENOUGH_MEMORY;
+        goto MAT_SCALAR_FIN;
+        }
+    typeB = CELL_EXPRESSION;
+    }
+else
+    { 
+    params = makeCell(CELL_QUOTE, (UINT)result);
+    if( (B = getMatrix(params, &typeB, &k, &l, &err)) == NULL)
+        {
+        freeMatrix(A, n);
+        return(errorProc(err));
+        }
+    else
+        {
+        params->contents = (UINT)nilCell;
+        deleteList(params);
+        }
+    }
+
+typeC = (typeA == CELL_ARRAY || typeB == CELL_ARRAY) ? CELL_ARRAY : CELL_EXPRESSION;
+
+if(n != k || m != l)
+    {
+    freeMatrix(A, n);
+    freeMatrix(B, k);
+    return(errorProc(ERR_WRONG_DIMENSIONS));
+    }
+else if((M = allocateMatrix(n, m)) == NULL)
+    err = ERR_NOT_ENOUGH_MEMORY;
+else 
+    {
+    for(k = 1; k <= n; k++)
+     for(l = 1; l <= m; l++)
+        {
+        switch(type)
+            {
+            case '+': M[k][l] = A[k][l] + B[k][l]; break;
+            case '-': M[k][l] = A[k][l] - B[k][l]; break;
+            case '*': M[k][l] = A[k][l] * B[k][l]; break;
+            case '/': M[k][l] = A[k][l] / B[k][l]; break;
+            default:
+            return(errorProcExt(ERR_ILLEGAL_TYPE, op));
+            }
+        }
+}
+
+MAT_SCALAR_FIN:
+freeMatrix(A, n);
+freeMatrix(B, n);
+if(err) return (errorProc(err));
+
+result = matrix2data(M, typeC, n, m);
+freeMatrix(M, n);
+
+return(result);
+}
+
+
+/* ------------------- C = A*B, A and B unchanged --------------------- */
+
+double * * multiply(double ** A, double ** B, int n, int m, int k, int l)
+{
+double * * C;
+int i, j, s;
+double sum;
+
+if(m != k)
+    {
+    errorProc(ERR_WRONG_DIMENSIONS);
+    return(NULL);
+    }
+
+if((C = allocateMatrix(n, l)) == NULL)
+    return(NULL);
+
+for(i = 1; i <= n; i++)
+    {
+    for(j = 1; j <= l; j++)
+        {
+        sum = 0.0;
+        for(s = 1; s <= m; s++)
+            sum += A[i][s] * B[s][j];
+        C[i][j] = sum;
+        }
+    }
+
+return(C);
+}
+
+
+/* ----- return inverse of A in Y, A will contain LU decomposition --- */
+
+double * * invert(double * * A, int n, int * err, double tiny)
+{
+double * * Y = NULL;
+double * col;
+double d;
+int i, j;
+int * indx;
+
+
+col = (double *)calloc(n + 1, sizeof(double));
+indx = (int *)calloc((n + 1), sizeof(int));
+
+if(ludcmp(A, n, indx, &d, tiny) == FALSE)
+    goto INVERT_FIN;
+
+if((Y = allocateMatrix(n, n)) == NULL)
+    {
+    *err = ERR_NOT_ENOUGH_MEMORY;
+    goto INVERT_FIN;
+    }
+
+for(j = 1; j <= n; j++)
+    {
+    for(i = 1; i <= n; i++) col[i] = 0.0;
+    col[j] = 1.0;
+    lubksb(A, n, indx, col);
+    for(i = 1; i <= n; i++) Y[i][j] = col[i];
+    }
+
+INVERT_FIN:
+free(col);
+free(indx);
+
+return(Y);
+}
+
+
+/* ------------------------- LU decomposition --------------------------- 
+// algorithms ludcmp() and lubskb() adapted from:
+// Numerical Recipes in 'C', 2nd Edition
+// W.H. Press, S.A. Teukolsky
+// W.T. Vettering, B.P. Flannery
+*/
+
+int ludcmp(double * * a, int n, int * indx, double * d, double tiny)
+{
+int i, imax = 0, j, k;
+double big, dum, sum, temp;
+double * vv;
+
+vv = (double *)calloc(n + 4, sizeof(double));
+*d = 1.0;
+
+/* find abs biggest number in each row and put 1/big in vector */
+for (i = 1; i <= n; i++)
+    {
+    big = 0.0;
+    for(j = 1;j <= n; j++)
+        if ((temp = fabs(a[i][j])) > big) big = temp;
+
+    if(big == 0.0)
+        {
+        free(vv);
+        return(FALSE);
+        }
+
+    vv[i] = 1.0 / big;
+    }
+
+for (j = 1; j <= n; j++)
+    {
+    for (i = 1; i < j; i++)
+        {
+        sum = a[i][j];
+        for(k = 1; k < i; k++) sum -= a[i][k] * a[k][j];
+        a[i][j] = sum;
+        }
+    big = 0.0;
+
+    for (i = j; i <= n; i++)
+        {
+        sum = a[i][j];
+        for(k = 1; k < j; k++)
+            sum -= a[i][k] * a[k][j];
+        a[i][j] = sum;
+
+        if ( (dum = vv[i] * fabs(sum)) >= big)
+            {
+            big = dum;
+            imax = i;
+            }
+        }
+
+    if (j != imax)
+        {
+        for (k = 1; k <= n; k++)
+            {
+            dum = a[imax][k];
+            a[imax][k] = a[j][k];
+            a[j][k] = dum;
+            }
+
+        *d = -(*d);
+        vv[imax] = vv[j];
+        }
+
+
+    indx[j] = imax;
+
+    if (a[j][j] == 0.0) 
+        {
+#ifdef FP_NAN
+        if(tiny != FP_NAN)
+#else
+        if(!isnan(tiny)) 
+#endif
+            a[j][j] = tiny;
+        else
+            {
+            free(vv);
+            return(FALSE);
+            }
+        }
+
+    if (j != n)
+        {
+        dum = 1.0 / (a[j][j]);
+        for(i = j+1; i <= n; i++) a[i][j] *= dum;
+        }
+    }
+
+free(vv);
+return(TRUE);
+}
+
+
+void lubksb(double * * a, int n, int * indx, double * b)
+{
+int i, ii = 0, ip, j;
+double sum;
+
+for (i = 1; i <= n; i++)
+    {
+    ip = indx[i];
+    sum = b[ip];
+    b[ip] = b[i];
+    if (ii)
+        for(j = ii; j <= i-1; j++) sum -= a[i][j] * b[j];
+    else
+        if(sum) ii = i;
+    b[i] = sum;
+    }
+
+for (i = n; i >= 1; i--)
+    {
+    sum = b[i];
+    for(j = i+1; j <= n; j++) sum -= a[i][j] * b[j];
+    b[i] = sum / a[i][i];
+    }
+}
+
+/* ------------ KMEANS clustering ------------------------------- */
+
+#ifdef KMEANS
+#define DOUBLE_MAX 1.0e308 /* approximate for IEEE 754 */
+
+/* (kmeans-train data k context [centroidsi [criterium]])
+   data = n * m matrix (list or array)
+   k = number of clusters
+   centroids = k * m matrix of start centroids (optional) (list or array)
+   when centroids then optional convergence criterium, 1e-10 by default
+   the m of optional centroids may be smaller than m in data to force
+   reduction of dimension, e.g. when the last column of date is pre-labeled
+
+   data and optional centroids as either array or list
+
+   if no centroids are given, they are calculated from
+   inital random membership
+
+   returns a list of idecreasing inner SSQs from start to 
+   end of iterations
+
+   result context ctx
+   ctx:centroids (m * k list)
+   ctx:clusters list with k sublists of indices into data (k sublists)
+   cts:labels list with n cluster numbers for each data records  (n list)
+
+   labels go from 1 to k
+
+   NOTE, indices in C-source are not 0-based as usually in C but 
+   go from 1 to N
+*/
+CELL * p_kmeansTrain(CELL * params)
+{
+double * * X; /* data */
+double * * C; /* centroids `*/
+int * labels; /* membership */
+int * counts; /* cluster sizes */
+double * ssqs; /* inner SSQs of clusters */
+double ssqTotal; /* total squared sum inner deviations */
+double ssqRecord; /* inner ssq of a record in a cluster */
+double ssqMin;     /* minimum ssq for one record */
+double ssqPrev = DOUBLE_MAX;
+double dist;
+double crit = 1.0e-10;
+CELL * centroids;
+CELL * clusters;
+CELL * deviations;
+CELL * SSQlist = NULL;
+CELL * membership;
+CELL * * cellArray;
+SYMBOL * ctx;
+SYMBOL * sPtr;
+int n, m, k; /* rows, columns, groups */
+int i, j, l; /* loop imdices */
+int err = 0, type;
+int kc, mc;
+UINT p;
+
+if((X = getMatrix(params, &type, &n, &m, &err)) == NULL)
+    return(errorProcExt(err, params));
+
+params = getInteger(params->next, &p);
+k = p;
+
+if((ctx = getCreateContext(params, TRUE)) == NULL)
+  return(errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, params));
+
+membership = getCell(CELL_EXPRESSION);
+sPtr = translateCreateSymbol("labels", CELL_EXPRESSION, ctx, TRUE); 
+assignSymbol(sPtr, membership);
+
+/* make centroid matrix */
+params = params->next;
+if(params == nilCell)
+    C = allocateMatrix(k, m);
+/* or get predefined centroids from user */
+else 
+    {
+    if((C = getMatrix(params, &type, &kc, &mc, &err)) == NULL)  
+        return(errorProcExt(err, params));
+    /* allow forcing less columns via optional centroids mc <= m */
+    if((kc != k) || (mc >  m)) 
+        return(errorProcExt(ERR_WRONG_DIMENSIONS, params));
+    m = mc;
+    /* optionally custom criterium */
+    if(params->next != nilCell)
+        getFloat(params->next, &crit);
+    }
+
+counts = allocMemory((k + 1) * sizeof(int));
+labels = allocMemory((n + 1) * sizeof(int));
+ssqs = callocMemory((k + 1) * sizeof(double));
+
+if(params != nilCell)
+    goto ASSIGN_MEMBERSHIP;
+
+/* asssign random membership */
+for(i = 1; i <= n; i++)
+    labels[i] = (i % k) + 1;
+
+ITERATE_KMEANS:
+/* calc KMEANS centroids from membership */
+for(l = 1; l <= k; l++)     
+    {
+    counts[l] = 0;
+    ssqs[l] = 0.0;
+    for(j = 1; j <= m; j++)
+        C[l][j] = 0;
+    }
+
+for(i = 1; i <= n; i++)
+    {
+    l = labels[i];
+    counts[l] += 1;
+    for(j = 1; j <= m; j++)
+        C[l][j] += X[i][j];
+    }
+
+for(l = 1; l <= k; l++) 
+    for(j = 1; j <= m; j++)
+        C[l][j] = C[l][j] / counts[l];
+
+/* assign each record in X to closest centroid */
+ASSIGN_MEMBERSHIP:
+ssqTotal = 0.0;
+for(i = 1; i <= n; i++)
+    {
+    ssqMin = DOUBLE_MAX;
+    for(l = 1; l <= k; l++)
+        {
+        ssqRecord = 0.0;
+        for(j = 1; j <= m; j++)
+            {
+            dist = X[i][j] - C[l][j];
+            ssqRecord += dist * dist;
+            }
+        if(ssqRecord < ssqMin)
+            {
+            ssqMin = ssqRecord;
+            labels[i] = l;
+            }
+        }
+    ssqTotal += ssqMin;
+    ssqs[labels[i]] += ssqMin;
+    }
+
+if(fabs(ssqPrev - ssqTotal) > crit)
+    {
+    ssqPrev = ssqTotal;
+    if(SSQlist == NULL) SSQlist = getCell(CELL_EXPRESSION);
+    addList(SSQlist, stuffFloat(ssqTotal));
+    goto ITERATE_KMEANS;
+    }
+            
+/* entroid matrix as nested list */
+centroids = matrix2data(C, CELL_EXPRESSION, k, m);
+sPtr = translateCreateSymbol("centroids", CELL_EXPRESSION, ctx, TRUE); 
+assignSymbol(sPtr, centroids);
+/* average intra cluster deviation */
+deviations = getCell(CELL_EXPRESSION);
+sPtr = translateCreateSymbol("deviations", CELL_EXPRESSION, ctx, TRUE); 
+assignSymbol(sPtr, deviations);
+
+/* cluster memberships, for each cluster a list of X data record indices */
+clusters = getCell(CELL_EXPRESSION);
+cellArray = (CELL * *)allocMemory(k * sizeof(CELL));
+for(l = 1; l <= k; l++)
+    {
+    cellArray[l] = getCell(CELL_EXPRESSION);
+    addList(clusters, cellArray[l]);
+    dist = sqrt(ssqs[l] / counts[l]);
+    addList(deviations, stuffFloat(dist)); 
+    }
+for(i = 1; i <= n; i++)
+    {
+    l = labels[i];
+    addList(cellArray[l], stuffInteger(i - 1));
+    }
+
+sPtr = translateCreateSymbol("clusters", CELL_EXPRESSION, ctx, TRUE); 
+assignSymbol(sPtr, clusters);
+
+for(i = 1; i <= n; i++) 
+    addList(membership, stuffInteger(labels[i]));
+
+freeMatrix(C, k);
+freeMatrix(X, n);
+free(cellArray);
+free(ssqs);
+free(labels);
+free(counts);
+
+return(SSQlist);
+}
+
+/* (kmeans-query data-record-vector centroids)
+
+   calculates eucledian distances to all centroids
+   from a previous (kmeans-train data k context [centroids])
+
+   can also be used on the original data to get
+   eucledian distance from one data record to all
+   other records (a KNN fucntion could be built this way)
+
+   (kmeans-query data-record-vector data)
+
+*/
+
+CELL * p_kmeansQuery(CELL * params)
+{
+CELL * data;
+CELL * centroids;
+CELL * dat;
+CELL * result;
+CELL * row;
+CELL * cent;
+double dist;
+double ssq;
+
+params = getEvalDefault(params, &data);
+if(data->type != CELL_EXPRESSION)
+    errorProcExt(ERR_LIST_EXPECTED, data);
+
+getEvalDefault(params, &centroids);
+if(centroids->type == CELL_ARRAY)
+    {
+    centroids = arrayList(centroids, TRUE); 
+    pushResult(centroids);
+    }
+   
+else if(centroids->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_NOT_MATRIX, centroids));
+
+row = (CELL *)centroids->contents;
+if(row->type != CELL_EXPRESSION)
+    return(errorProcExt(ERR_LIST_EXPECTED, row));
+
+result = getCell(CELL_EXPRESSION);
+while(row != nilCell) /* for each centroid */
+    {
+    cent = (CELL *)row->contents;
+    dat = (CELL *)data->contents;
+    ssq = 0.0;
+    while(cent != nilCell && dat != nilCell) 
+        {
+        dist = fabs(getDirectFloat(cent) - getDirectFloat(dat));
+        ssq += dist * dist; 
+        cent = cent->next;
+        dat = dat->next;
+        }
+    dist = sqrt(ssq);
+    addList(result, stuffFloat(dist));
+    row = row->next;
+    }
+
+return(result);
+}
+
+#endif
+
+/* ------------ make a matrix from list or array expr ----------- */
+
+double * * getMatrix(CELL * params, int * type, int * n, int * m, int *err)
+{
+CELL * data;
+double * * M;
+
+getEvalDefault(params, &data);
+
+if(data->type != CELL_EXPRESSION && data->type != CELL_ARRAY)
+    {
+    *err = ERR_NOT_MATRIX;
+    return(NULL);
+    }
+
+*type = data->type;
+
+if(getDimensions(data, n, m) == FALSE)
+    {
+    *err = ERR_NOT_MATRIX;
+    return(NULL);
+    }
+
+if( (M = data2matrix(data, *n, *m)) == NULL)
+    {
+    *err = ERR_NOT_ENOUGH_MEMORY;
+    return(NULL);
+    }
+
+return(M);
+}
+
+double * * makeMatrix(CELL * number, int n, int m)
+{
+double s;
+double * * matrix;
+int i, j;
+
+#ifndef NEWLISP64
+if(number->type == CELL_FLOAT)
+    s = *(double *)&number->aux;
+else if(number->type == CELL_INT64)
+    s = *(INT64 *)&number->aux;
+#else
+if(number->type == CELL_FLOAT)
+    s = *(double *)&number->contents;
+#endif
+else
+    s = number->contents;
+
+if((matrix = allocateMatrix(n, m)) == NULL)
+    return(NULL);
+
+for(i = 1; i <= n; i++)
+    for(j = 1; j <= m; j++)
+        matrix[i][j] = s;
+
+return(matrix);
+}
+
+/* --------------------------- get dimensons on a matrix --------------- */
+
+int getDimensions(CELL * mat, int * n, int * m)
+{
+CELL * row;
+CELL * cell;
+int rows, cols;
+CELL * * addr;
+
+if(mat->type == CELL_ARRAY)
+    {
+    addr = (CELL * *)mat->contents;
+    *n = (mat->aux - 1) / sizeof(CELL *);
+    cell = *addr;
+    if(cell->type != CELL_ARRAY)
+        {
+        errorProcExt(ERR_WRONG_DIMENSIONS, mat);
+        return(FALSE);
+        }
+    *m = (cell->aux - 1) / sizeof(CELL *);
+    return(TRUE);
+    }
+
+/* mat->type is CELL_EXPRESSSION */
+
+row = (CELL *)mat->contents;
+if(row->type != CELL_EXPRESSION)
+    {
+    errorProcExt(ERR_NOT_MATRIX, mat);
+    return(FALSE);
+    }
+
+cell = (CELL *)row->contents;
+
+rows = cols = 0;
+while(row != nilCell)
+    {
+    ++rows;
+    row = row->next;
+    }
+
+while(cell != nilCell)
+    {
+    ++cols;
+    cell = cell->next;
+    }
+
+if(rows == 0 || cols == 0)
+    {
+    errorProcExt(ERR_WRONG_DIMENSIONS, mat);
+    return(FALSE);
+    }
+
+*n = rows;
+*m = cols;
+
+return(TRUE);
+}
+
+
+/* ------------ copy array/list into a matrix of doubles -------- */
+
+
+/* xlate lists or arrays into C arrays with 1-offest for 1st element
+wrong row type result and missing row elelements result on 0.0 */
+double * * data2matrix(CELL * list, int n, int m)
+{
+double ** matrix;
+CELL * row;
+CELL * cell;
+int i, j, size;
+CELL * * addr;
+CELL * * rowAddr;
+
+if((matrix = allocateMatrix(n, m)) == NULL)
+    return(NULL);
+
+if(list->type == CELL_ARRAY)
+    {
+    addr = (CELL * *)list->contents;    
+    for(i = 1; i <= n; i++)
+        {
+        row = *(addr + i - 1);
+        if(row->type != CELL_ARRAY)
+            {
+            for(j = 1; j <= m; j++) matrix[i][j] = 0.0;
+            continue;
+            }
+        rowAddr = (CELL * *)row->contents;
+        size = (row->aux - 1)/sizeof(CELL *);
+        for(j = 1; j <= m; j++)
+            {
+            if(j <= size)
+                matrix[i][j] = getDirectFloat((CELL *)*(rowAddr + j - 1));
+            else matrix[i][j] = 0.0;
+            }
+        }
+    return(matrix);
+    }
+
+/* list->type == CELL_EXPRESSION */
+
+row = (CELL *)list->contents;
+for(i = 1; i <= n; i++)
+    {
+    if(row->type != CELL_EXPRESSION)
+        for(j = 1; j <= m; j++) matrix[i][j] = 0.0;
+    else
+        {
+        cell = (CELL *)row->contents;
+        for(j = 1; j <= m; j++)
+            {
+            matrix[i][j] = getDirectFloat(cell);
+            cell = cell->next;
+            }
+        }
+    row = row->next;
+    }
+
+return(matrix);
+}
+
+
+/* ------- allocate an array/list and copy matrix into it ---- */
+
+CELL * matrix2data(double ** matrix, int type, int n, int m)
+{
+CELL * list;
+CELL * row;
+CELL * cell;
+int i, j;
+double fnum;
+CELL * * addr;
+CELL * * rowAddr;
+
+list = getCell(type);
+
+if(type == CELL_EXPRESSION)
+    {
+    row = getCell(CELL_EXPRESSION);
+    list->contents = (UINT)row;
+    for(i = 1; i <= n; i++)
+        {
+        cell = getCell(CELL_FLOAT);
+        row->contents = (UINT)cell;
+        for(j = 1; j <= m; j++)
+            {
+            fnum = matrix[i][j];
+#ifndef NEWLISP64
+            *(double *)&cell->aux = fnum;
+#else
+            *(double *)&cell->contents = fnum;
+#endif
+            if(j == m) break;
+            cell->next = getCell(CELL_FLOAT);
+            cell = cell->next;
+            }
+        if(i == n) break;
+        row->next = getCell(CELL_EXPRESSION);
+        row = row->next;
+        }
+    }
+
+else /* type is CELL_ARRAY */
+    {
+    list->aux = n * sizeof(CELL *) + 1;
+    addr = (CELL * *)allocMemory(list->aux);
+    list->contents = (UINT)addr;
+
+    for(i = 1; i <= n; i++)
+        {
+        cell = getCell(CELL_ARRAY);
+        cell->aux = m * sizeof(CELL *) + 1;
+        rowAddr = (CELL * *)allocMemory(cell->aux);
+        cell->contents = (UINT)rowAddr;
+        *(addr + i -1) = cell;
+        for(j = 1; j <= m; j++)
+            {
+            fnum = matrix[i][j];
+            *(rowAddr + j - 1) = stuffFloat(fnum);
+            }
+        }
+    }
+
+return(list);
+}
+
+
+/* ------------------------ allocate/free a matrix ----------------- */
+
+double * * allocateMatrix(int rows, int cols)
+{
+int i;
+double * * m;
+
+m = (double **) calloc(rows + 1, sizeof(double *));
+if (!m)
+    return(NULL);
+
+for(i = 1; i <= rows; i++)
+    {
+    m[i] = (double *)calloc(cols + 1, sizeof(double));
+    if (!m[i])
+        return(NULL);
+    }
+
+return(m);
+}
+
+
+void freeMatrix(double * * m, int rows)
+{
+int i;
+
+if(m == NULL) return;
+
+for(i = 1; i <= rows; i++)
+    free(m[i]);
+
+free(m);
+}
+
+/* end of file */
diff --git a/nl-sock.c b/nl-sock.c
new file mode 100644
index 0000000..03b8b73
--- /dev/null
+++ b/nl-sock.c
@@ -0,0 +1,2534 @@
+/* nl-sock.c
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#include "newlisp.h"
+#include <string.h>
+
+#ifdef WINDOWS
+
+#include <winsock2.h>
+#pragma push_macro("UINT") 
+#undef UINT /* avoid clash with newLISP UINT */
+#include <ws2tcpip.h>
+#pragma pop_macro("UINT")
+#include <ws2spi.h>
+
+#define fdopen win_fdopen
+#define SHUT_RDWR 2
+#define gethostbyname2(A, B) gethostbyname(A)
+
+#else /* UNIX */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#define __FAVOR_BSD
+#include <netinet/in_systm.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <netinet/ip_icmp.h>
+#ifndef OS2
+#include <netinet/icmp6.h> 
+#endif
+#include <netdb.h>
+#include <arpa/inet.h>
+
+#ifndef IPPROTO_DIVERT
+#define IPPROTO_DIVERT 254
+#endif
+
+/* Android needs it */
+#ifndef ICMP6_FILTER
+#define ICMP6_FILTER 1
+#endif
+
+#endif /* end UNIX */
+
+#ifdef CYGWIN
+#include <netinet/icmp6.h> /* not on Cygwin, get from other OS */
+
+#define ICMP_ECHO 8
+
+struct icmp
+{
+   unsigned char icmp_type;
+   unsigned char icmp_code;
+   unsigned short icmp_cksum;
+   unsigned short icmp_id;
+   unsigned short icmp_seq;
+};
+#endif /* end CYGWIN */
+
+#if defined(SOLARIS) || defined(TRU64) || defined(AIX)
+#include <stropts.h>
+#include <sys/conf.h>
+#include <netinet/in_systm.h>
+#define gethostbyname2(A, B) gethostbyname(A)
+#endif
+
+#ifdef SOLARIS
+#define FIONREAD I_NREAD
+#endif
+
+#ifdef OS2 
+#define socklen_t int 
+#define SHUT_RDWR 2 
+#endif 
+
+#ifndef INADDR_NONE
+#define INADDR_NONE (unsigned) -1
+#endif
+
+#ifndef AF_UNIX
+#define AF_UNIX PF_UNIX
+#endif
+
+#ifndef SUN_LEN
+#define SUN_LEN(su) \
+    (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
+#endif
+
+#include "protos.h"
+
+#define MAX_PENDING_CONNECTS 128
+#define NO_FLAGS_SET 0
+
+#ifdef WINDOWS
+#define close closesocket /* for file operations on Windows use _close */
+#else
+#define SOCKET_ERROR -1
+#define INVALID_SOCKET -1
+#endif
+
+#define isnum(A) ((A)>= '0' && (A) <= '9')
+
+IO_SESSION * ioSessions = NULL;
+
+int isSessionSocket(int sock);
+int getSocketFamily(int sock);
+
+#ifndef EMSCRIPTEN
+#define READY_READ 0
+#define READY_WRITE 1
+
+UINT netErrorIdx = 0;
+
+extern int logTraffic;
+extern int noPromptMode;
+
+int ADDR_FAMILY = AF_INET; /* the default is IPv4 */
+int ICMP_TYPE;
+#define STRADDR_LEN 40
+
+
+/*  set the default interface and select IPv4 or IPv6 mode */
+
+struct sockaddr * defaultIn = NULL;
+void * defaultInAddr = NULL; /* either (struct in6_addr *) or (struct in_adr *) */
+char * defaultInterface = NULL;
+socklen_t defaultInLen;
+
+extern int opsys;
+void initDefaultInAddr()
+{
+struct sockaddr_in6 * address6;
+struct sockaddr_in * address;
+
+if(defaultIn != NULL) free(defaultIn);
+defaultInLen = (ADDR_FAMILY == AF_INET6) ? 
+    sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+
+defaultIn = callocMemory(defaultInLen);
+
+if(ADDR_FAMILY == AF_INET6)
+    {
+    address6 = (struct sockaddr_in6 *)defaultIn;
+    address6->sin6_addr = in6addr_any;
+    defaultInAddr = &address6->sin6_addr;
+    address6->sin6_family = AF_INET6;
+    ICMP_TYPE = IPPROTO_ICMPV6;
+    opsys |= 0x200;
+    }
+else
+    {
+    address = (struct sockaddr_in *)defaultIn;
+    address->sin_addr.s_addr = INADDR_ANY;
+    defaultInAddr = &address->sin_addr;
+    address->sin_family = AF_INET;
+    ICMP_TYPE = IPPROTO_ICMP;
+    opsys &= ~0x200;
+    }
+
+}
+#endif /* ifndef EMSCRIPTEN */
+
+/********************** IO session functions *******************/
+
+IO_SESSION * createIOsession(int handle, int family)
+{
+IO_SESSION * iSession;
+
+iSession = (IO_SESSION *)calloc(sizeof(IO_SESSION), 1);
+
+iSession->handle = handle;
+iSession->family = family;
+
+if(ioSessions == NULL)
+    {
+    ioSessions = iSession;
+    iSession->next = NULL;
+    }
+else
+    {
+    iSession->next = ioSessions;
+    ioSessions = iSession;
+    }
+
+return(iSession);
+}
+
+int deleteIOsession(int handle)
+{
+IO_SESSION * session;
+IO_SESSION * previous;
+
+if(ioSessions == NULL)
+    return(0);
+else
+    session = previous = ioSessions;
+
+while(session)
+    {
+    if(session->handle == handle)
+        {
+        if(session == ioSessions)
+            ioSessions = session->next;
+        else
+            previous->next = session->next;
+        if(session->stream != NULL)
+            fclose(session->stream);
+        else close(handle);
+        free((char *)session);
+        return(TRUE);
+        }
+    previous = session;
+    session = session->next;
+    }
+
+return(FALSE);
+}
+
+
+int isSessionSocket(int sock)
+{
+IO_SESSION * session;
+
+if(ioSessions == NULL)
+    return(FALSE);
+
+session = ioSessions;
+while(session)
+    {
+    if(session->handle == sock)
+        return(TRUE);
+    session = session->next;
+    }
+
+return(FALSE);
+}
+
+int getSocketFamily(int sock)
+{
+IO_SESSION * session;
+
+session = ioSessions;
+
+while(session)
+    {
+    if(session->handle == sock)
+        return(session->family);
+    session = session->next;
+    }
+
+return(-1);
+}
+
+
+FILE * getIOstream(int handle)
+{
+IO_SESSION * session;
+
+session = ioSessions;
+
+while(session)
+    {
+    if(session->handle == handle)
+        return(session->stream);
+    session = session->next;
+    }
+
+return(NULL);
+}
+
+/* ========================= IO session functions end ===================== */
+#ifndef EMSCRIPTEN
+#ifdef WINDOWS
+int ipstrFromSockAddr(struct sockaddr * addr, char * host, int len)
+{
+WSAAddressToString(addr, defaultInLen, NULL, host, (LPDWORD)&len);
+return(TRUE);
+}
+#else /* UNIX */
+int ipstrFromSockAddr(struct sockaddr * addr, char * host, int len)
+{
+struct sockaddr_in6 * saddr6 = (struct sockaddr_in6 *)addr;
+struct sockaddr_in * saddr =(struct sockaddr_in *)addr;
+
+if(addr->sa_family == AF_INET6)
+    inet_ntop(AF_INET6, &saddr6->sin6_addr, host, len); 
+else
+    strncpy(host, inet_ntoa(saddr->sin_addr), len);
+return(TRUE);
+}
+#endif
+
+/* ANDROID and WINDOWS need this */
+#ifndef in_port_t
+#define in_port_t short int
+#endif
+
+in_port_t portFromSockAddr(struct sockaddr * addr)
+{
+in_port_t * portPtr = (in_port_t *)&addr->sa_data[0];
+
+return(ntohs(*portPtr));
+}
+
+
+void setSockaddrPort(struct sockaddr * addr, in_port_t port)
+{
+in_port_t * portPtr = (in_port_t *)&addr->sa_data[0];
+
+*portPtr = htons(port);
+}
+
+/********************* user functions **************************/
+
+
+CELL * p_netClose(CELL * params) 
+{
+UINT sock; 
+ 
+getInteger(params, &sock); 
+if(!deleteIOsession((int)sock))
+    return(netError(ERR_INET_NOT_VALID_SOCKET));
+
+netErrorIdx = 0;
+return(trueCell);
+}
+
+
+CELL * p_netSessions(CELL * params)
+{
+IO_SESSION * session;
+IO_SESSION * sPtr;
+CELL * sList;
+
+session = ioSessions;
+sList = getCell(CELL_EXPRESSION);
+
+while(session)
+    {
+    sPtr = session;
+    session = session->next;
+    if(sPtr->family != AF_UNSPEC || getFlag(params))
+        addList(sList, stuffInteger(sPtr->handle));
+    }
+
+return(sList);
+}
+
+
+/*********************************************************************/
+
+CELL * p_netService(CELL * params) 
+{
+struct servent * pSe; 
+char * service = NULL; 
+char * protocol = NULL; 
+CELL * cell;
+UINT port; 
+ 
+params = getEvalDefault(params, &cell);
+getString(params, &protocol); 
+if(cell->type == CELL_STRING)
+    {
+    service = (char *)cell->contents;
+ 
+    if((pSe = getservbyname(service, protocol)) == NULL) 
+        return(netError(ERR_INET_INVALID_SERVICE)); 
+ 
+    port = (int)ntohs(pSe->s_port); 
+ 
+    netErrorIdx = 0; 
+    return(stuffInteger((UINT)port)); 
+    }
+if(isNumber(cell->type))
+    {
+    getIntegerExt(cell, &port, FALSE);
+
+    if((pSe = getservbyport(htons(port), protocol)) == NULL) 
+        return(netError(ERR_INET_INVALID_SERVICE)); 
+
+    netErrorIdx = 0;
+    return(stuffString(pSe->s_name));
+    }
+
+return(errorProcExt(ERR_NUMBER_OR_STRING_EXPECTED, cell));
+} 
+
+CELL * p_netConnect(CELL * params)
+{
+CELL * cell;
+char * remoteHostName; 
+UINT portNo;
+UINT topt = CONNECT_TIMEOUT; /* default ms timeout from newlisp.h */
+int sock;
+int type; 
+int protocol = 0;
+
+params = getString(params, &remoteHostName); 
+#ifndef WINDOWS
+if(params == nilCell)
+    {
+    if((sock = netConnectLocal(remoteHostName)) == SOCKET_ERROR)
+        return(netError(netErrorIdx));
+    else    
+        return(stuffInteger((UINT)sock));
+    }
+
+#endif
+
+params = getInteger(params, &portNo);
+type = SOCK_STREAM;
+if(params != nilCell)
+    {
+    cell = evaluateExpression(params);
+    if(cell->type == CELL_STRING)
+        {
+        protocol = toupper(*(char *)cell->contents);
+        if(!(protocol == 'M' || protocol == 'B' || protocol == 'U'))
+            return(errorProc(ERR_INVALID_OPTION));
+        type = SOCK_DGRAM;
+        if(protocol == 'M') /* get ttl */
+            {
+            if(params->next != nilCell)
+                /* topt is ttl in this case */
+                getInteger(params->next, &topt);
+            else topt = 3;
+            }
+        }
+    else if(isNumber(cell->type))
+        /* topt is ms timeout */
+        getIntegerExt(cell, &topt, FALSE);
+    else
+        return(errorProcExt(ERR_NUMBER_OR_STRING_EXPECTED, cell));      
+    }
+
+if((sock = netConnect(remoteHostName, 
+        (int)portNo, type, protocol, (int)topt)) == SOCKET_ERROR)
+    return(netError(netErrorIdx));
+
+createIOsession(sock, ADDR_FAMILY);
+
+netErrorIdx = 0;
+return(stuffInteger((UINT)sock)); 
+}
+
+
+#ifndef WINDOWS
+/* create local domain UNIX socket */
+int netConnectLocal(char * path)
+{
+int sock;
+struct sockaddr_un remote_sun;
+
+if((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == SOCKET_ERROR)
+    {
+    netErrorIdx = ERR_INET_OPEN_SOCKET;
+    return(SOCKET_ERROR);
+    }
+    
+remote_sun.sun_family = AF_UNIX;
+strncpy(remote_sun.sun_path, path, sizeof(remote_sun.sun_path) - 1);
+remote_sun.sun_path[sizeof (remote_sun.sun_path) - 1] = '\0';
+if (connect(sock, (struct sockaddr *)&remote_sun, SUN_LEN(&remote_sun)) == -1) 
+    {
+    close(sock);
+    netErrorIdx = ERR_INET_CONNECT_FAILED;
+    return(SOCKET_ERROR);
+    }
+
+createIOsession(sock, AF_UNIX);
+
+netErrorIdx = 0;
+return(sock); 
+}
+#endif
+
+
+int blockSocket(int sock)
+{
+#ifdef WINDOWS
+u_long arg = 0;
+return(ioctlsocket(sock, FIONBIO, &arg));
+#else /* UNIX */
+int arg;
+arg = fcntl(sock, F_GETFL, NULL);
+arg &= (~O_NONBLOCK);
+return(fcntl(sock, F_SETFL, arg));
+#endif
+}
+
+#ifdef UNBLOCK
+int unblockSocket(int sock)
+{
+#ifdef WINDOWS
+u_long arg = 1;
+return(ioctlsocket(sock, FIONBIO, &arg));
+#else /* Unix */
+int arg;
+arg = fcntl(sock, F_GETFL, NULL);
+arg &= (~O_NONBLOCK);
+return(fcntl(sock, F_SETFL, arg));
+#endif
+}
+#endif
+
+/* create internet socket
+   if prot = NULL then topt is timeout in ms, else topt is ttl (time to live)
+*/
+int netConnect(char * remoteHostName, int portNo, int type, int prot, int topt)
+{
+struct addrinfo hints, *res, *res0;
+char portStr[10];
+int sock, opt;
+#if defined(WINDOWS) || defined(EMSCRIPTEN)
+u_long arg = 1;
+#else
+int arg, value;
+socklen_t socklen = sizeof(sock);
+#endif
+int result = -1;
+int sinlen;
+
+/* create socket */
+if((sock = socket(ADDR_FAMILY, type, 0)) == INVALID_SOCKET)
+    {
+    netErrorIdx = ERR_INET_OPEN_SOCKET;
+    return(SOCKET_ERROR);
+    }
+
+if(prot == 0) /* topt is timeout in millisecs */
+    {
+#ifdef WINDOWS
+    if(ioctlsocket(sock, FIONBIO, &arg) != 0)
+        {
+        netErrorIdx = ERR_INET_CANNOT_CHANGE_SOCK_BLOCK;
+        return(SOCKET_ERROR);
+        }
+#else /* UNIX */
+    arg = fcntl(sock, F_GETFL, NULL);
+    if(fcntl(sock, F_SETFL, arg | O_NONBLOCK) < 0)
+        {
+        netErrorIdx = ERR_INET_CANNOT_CHANGE_SOCK_BLOCK;
+        return(SOCKET_ERROR);
+        }
+#endif
+    }
+else if(prot == 'M' || prot == 'B') 
+    {
+    sinlen = (ADDR_FAMILY == AF_INET6) ? sizeof(struct in6_addr) : sizeof(struct in_addr);
+
+    if(prot == 'M')
+        {
+        setsockopt(sock, 0, IP_MULTICAST_IF, (const void *)defaultInAddr, sinlen);
+        opt = topt; /* ttl time to live */
+        setsockopt(sock, 0, IP_MULTICAST_TTL, (const void *)&opt, sizeof(opt));
+        }
+
+    if(prot == 'B')
+        {
+        opt = 1;
+        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (const void *)&opt, sizeof(opt));
+        }
+    }
+
+if(type == SOCK_DGRAM && *remoteHostName == 0)
+    return(sock);
+
+memset(&hints, 0, sizeof(hints));
+hints.ai_family = (ADDR_FAMILY == AF_INET6) ? PF_INET6 : PF_INET;
+hints.ai_socktype = SOCK_STREAM;
+snprintf(portStr, 10, "%d", portNo);
+
+if(getaddrinfo(remoteHostName, portStr, &hints, &res0) != 0)
+    {
+    netErrorIdx = ERR_INET_HOST_UNKNOWN;
+    return(SOCKET_ERROR);
+    }
+
+for(res = res0; res; res = res->ai_next)
+    {
+    result = connect(sock, res->ai_addr, res->ai_addrlen);
+    if(result < 0)
+        {
+#ifdef WINDOWS
+        if(WSAGetLastError() == WSAEWOULDBLOCK)
+#else
+        if(errno == EINPROGRESS) 
+#endif
+            {
+            if((result = wait_ready(sock, topt * 1000, READY_WRITE)) <= 0)
+                {
+                netErrorIdx = result < 0 ? ERR_INET_CONNECT_FAILED : ERR_INET_TIMEOUT;
+                goto CONNECT_FAILED;
+                }
+#ifndef WINDOWS 
+            getsockopt(sock, SOL_SOCKET, SO_ERROR, (void*)&value, &socklen); 
+            if (value) 
+                { 
+                netErrorIdx =  ERR_INET_CONNECT_FAILED;
+                goto CONNECT_FAILED;
+                } 
+#endif
+            result = 0;
+            break;
+            }
+        else
+            {
+            netErrorIdx =  ERR_INET_CONNECT_FAILED;
+            goto CONNECT_FAILED;
+            }
+        break;
+        }
+    else break; /* result == 0 */
+    }
+
+if(result != 0)
+    {
+    netErrorIdx = ERR_INET_CONNECT_FAILED;
+    goto CONNECT_FAILED;
+    }
+
+if(blockSocket(sock) != 0)
+    {
+    netErrorIdx = ERR_INET_CANNOT_CHANGE_SOCK_BLOCK;
+    goto CONNECT_FAILED;
+    }
+    
+freeaddrinfo(res0);
+netErrorIdx = 0;
+return(sock);
+
+CONNECT_FAILED:
+freeaddrinfo(res0);
+close(sock);
+return(SOCKET_ERROR);
+}
+
+/* take and empty sockaddr and fill in from portNo, socket type and interface
+   if ifAddr is defined as NULL or and empty string assume sockaddr at defaultIn
+   which is initialized to INADDR_ANY in initDefaultInAddr()
+*/
+int getHostAddr(struct sockaddr * address, int stype, char * ifAddr)
+{
+struct addrinfo hints, *res;
+int error;
+
+if(ifAddr != NULL && *ifAddr != '\0')
+    {
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = (ADDR_FAMILY == AF_INET6) ? PF_INET6 : PF_INET;
+    hints.ai_socktype = stype;
+
+    if((error = getaddrinfo(ifAddr, NULL, &hints, &res)) != 0)
+        return(error);
+
+    memcpy(address, res->ai_addr, res->ai_addrlen);
+
+    freeaddrinfo(res);
+    return(0);
+    }
+
+memcpy(address, defaultIn, defaultInLen);
+return(0);
+}
+
+
+CELL * p_netInterface(CELL * params)
+{
+char * ifAddr;
+char IPaddress[STRADDR_LEN];
+
+netErrorIdx = 0;
+
+if(params != nilCell)
+    {
+    params = getString(params, &ifAddr);
+    if(getHostAddr((struct sockaddr *)defaultIn, 0, ifAddr) != 0)
+        return(netError(ERR_INET_HOST_UNKNOWN));
+    }
+
+getnameinfo((struct sockaddr *)defaultIn, defaultInLen, 
+    IPaddress, STRADDR_LEN, NULL, 0, NI_NUMERICHOST);
+return(stuffString(IPaddress));
+}
+
+
+CELL * p_netIpv(CELL * params)
+{
+UINT protocol = (ADDR_FAMILY == AF_INET6) ? 6 : 4;
+
+if(params != nilCell)
+    {
+    getInteger(params, &protocol);
+    if(protocol != 4 && protocol != 6)
+        return(errorProc(ERR_INVALID_PARAMETER));
+    if(protocol == 6) 
+        {
+        ADDR_FAMILY = AF_INET6;
+        opsys |= 512;
+        }
+    else 
+        {
+        ADDR_FAMILY = AF_INET;
+        opsys &= ~512;
+        }
+    initDefaultInAddr();
+    }
+
+return(stuffInteger(protocol));
+}
+
+
+/********* should be called after listen/accept notification **********/
+
+CELL * p_netAccept(CELL * params) 
+{
+int sock;
+UINT listenSock;
+
+getInteger(params, &listenSock); 
+
+if((sock = netAccept((int)listenSock)) == INVALID_SOCKET)
+    return(netError(ERR_INET_ACCEPT));
+
+netErrorIdx = 0;
+return(stuffInteger(sock)); 
+}
+
+
+int netAccept(int listenSock)
+{
+int sock, family;
+struct sockaddr * dest_sin;
+socklen_t dest_slen;
+#ifndef WINDOWS
+struct sockaddr_un dest_sun;
+#endif
+
+family = getSocketFamily(listenSock);
+
+#ifndef WINDOWS
+if(family == AF_UNIX)
+    {
+    dest_slen = sizeof(struct sockaddr_un);
+    sock = accept(listenSock, (struct sockaddr *) &dest_sun,  &dest_slen);
+    }
+else
+#endif
+    {
+    dest_slen = (ADDR_FAMILY == AF_INET6) ? 
+        sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+
+    dest_sin = alloca(dest_slen);
+
+    sock = accept(listenSock, dest_sin, (void *)&dest_slen);
+    }
+
+if(sock != INVALID_SOCKET) 
+    {
+    createIOsession(sock, family);
+    netErrorIdx = 0;
+    }
+
+return(sock);
+}
+
+
+/******************* returns IP and port number from socket *************/
+
+#define LOCAL_INFO 0
+#define PEER_INFO 1
+
+int getIpPortFromSocket(int sock, int peerLocalFlag, char * IPaddress)
+{
+int family;
+socklen_t address_sin_len; 
+struct sockaddr * address_sin;
+
+family = getSocketFamily(sock);
+address_sin_len = (family == AF_INET6) ? 
+        sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+address_sin = alloca(address_sin_len);
+
+*IPaddress = 0;
+
+if(family == AF_UNIX)
+    {
+    strncpy(IPaddress, "local", 6);
+    return(0);
+    }
+
+if(peerLocalFlag == LOCAL_INFO) 
+    {
+    if(getsockname(sock, address_sin, (void *)&address_sin_len) == SOCKET_ERROR)
+        return(SOCKET_ERROR);
+    }
+else 
+    if(getpeername(sock, address_sin, (void *)&address_sin_len) == SOCKET_ERROR)
+        return(SOCKET_ERROR);
+ 
+/* return address and port, IP number, address family taken fron address_sin  */
+ipstrFromSockAddr((struct sockaddr *)address_sin, IPaddress, STRADDR_LEN);
+return(portFromSockAddr((struct sockaddr *)address_sin));
+}
+
+
+CELL * p_netLocal(CELL * params) 
+{
+return(netPeerLocal(params, LOCAL_INFO));
+}
+
+CELL * p_netPeer(CELL * params)
+{
+return(netPeerLocal(params, PEER_INFO));
+}
+
+
+CELL * netPeerLocal(CELL * params, int peerLocalFlag) 
+{ 
+CELL * result; 
+CELL * cell; 
+char name[STRADDR_LEN];
+UINT addressPort, sock;
+
+getInteger(params, &sock); 
+if((addressPort = getIpPortFromSocket((int)sock, peerLocalFlag, name)) == SOCKET_ERROR)
+    return(netError(ERR_INET_NOT_VALID_SOCKET));
+
+result = makeCell(CELL_EXPRESSION, (UINT)stuffString(name));
+
+cell = (CELL *)result->contents; 
+cell->next = stuffInteger((UINT)addressPort); 
+ 
+netErrorIdx = 0; 
+return(result); 
+} 
+
+CELL * p_netLookup(CELL * params)
+{
+char * hostString;
+int forceByName = 0;
+struct addrinfo hints, *res;
+char hbuf[NI_MAXHOST];
+int flags = NI_NUMERICHOST;
+
+netErrorIdx = 0;
+params = getString(params, &hostString);
+forceByName = getFlag(params);
+
+if( ((ADDR_FAMILY == AF_INET6) && strstr(hostString, ":") && !forceByName) 
+    ||
+    ((ADDR_FAMILY == AF_INET) && isDigit((unsigned char)*hostString) && !forceByName) )
+    flags = NI_NAMEREQD;
+
+memset(&hints, 0, sizeof(hints));
+
+hints.ai_family = (ADDR_FAMILY == AF_INET6) ? PF_INET6 : PF_INET;
+hints.ai_socktype = SOCK_STREAM;
+/* hints.ai_flags = AI_ADDRCONFIG | AI_CANONNAME; */
+
+if(getaddrinfo(hostString, NULL, &hints, &res) != 0)
+    return(netError(ERR_INET_HOST_UNKNOWN));
+
+if(getnameinfo(res->ai_addr, res->ai_addrlen, hbuf, sizeof(hbuf), NULL, 0, flags) != 0)
+    {
+    freeaddrinfo(res);
+    return(netError(ERR_INET_HOST_UNKNOWN));
+    }
+
+freeaddrinfo(res);
+return(stuffString(hbuf));
+}
+
+
+CELL * netReceive(int sock, SYMBOL * readSymbol, size_t readSize, CELL * params);
+
+
+CELL * p_netReceive(CELL * params) 
+{ 
+UINT sock;
+SYMBOL * readSymbol;
+size_t readSize;
+CELL * cell;
+
+params = getInteger(params, &sock);
+params = getEvalDefault(params, &cell);
+
+if(!symbolCheck)
+    return(errorProcExt(ERR_SYMBOL_EXPECTED, cell));
+if(symbolCheck->contents != (UINT)cell)
+    return(errorProc(ERR_IS_NOT_REFERENCED));
+
+readSymbol = symbolCheck;
+params = getInteger(params, (UINT *)&readSize);
+
+return(netReceive((int)sock, readSymbol, readSize, params));
+}
+
+
+CELL * netReceive(int sock, SYMBOL * readSymbol, size_t readSize, CELL * params)
+{
+char * waitFor;
+ssize_t bytesReceived;
+size_t length;
+int found;
+STREAM netStream = {NULL, NULL, 0, 0, 0};
+char chr;
+CELL * cell;
+
+if(isProtected(readSymbol->flags))
+    return(errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(readSymbol)));
+
+if(params == nilCell)
+    {
+    openStrStream(&netStream, readSize, 0);
+    found = 1;
+    bytesReceived  = recv(sock, netStream.buffer, readSize, NO_FLAGS_SET);
+    }
+else
+    {
+    getString(params, &waitFor);
+    openStrStream(&netStream, MAX_LINE, 0);
+    found = bytesReceived = 0;
+    length = strlen(waitFor);
+    while(bytesReceived < (int)readSize)
+        {
+        if(recv(sock, &chr, 1, NO_FLAGS_SET) <= 0)
+            {
+            bytesReceived = 0;
+            break;
+            }
+        writeStreamChar(&netStream, chr); 
+         if(++bytesReceived < length) continue;
+        if(strncmp(waitFor,  netStream.ptr - length, length) == 0)
+            {
+            found = 1;
+            break;
+            }        
+        }
+            
+    }
+
+if(bytesReceived == 0 || found == 0) 
+    { 
+    closeStrStream(&netStream); 
+    deleteIOsession(sock); 
+    return(netError(ERR_INET_CONNECTION_DROPPED)); 
+    } 
+
+if(bytesReceived == SOCKET_ERROR) 
+    { 
+    closeStrStream(&netStream);         
+    deleteIOsession(sock); 
+    return(netError(ERR_INET_READ)); 
+    } 
+  
+cell = stuffStringN(netStream.buffer, bytesReceived);
+closeStrStream(&netStream);
+
+deleteList((CELL *)readSymbol->contents); 
+readSymbol->contents = (UINT)cell; 
+ 
+netErrorIdx = 0; 
+return(stuffInteger(bytesReceived)); 
+} 
+
+
+CELL * netReceiveFrom(int sock, size_t readSize, int closeFlag)
+{
+int portNo;
+int family;
+char * buffer;
+ssize_t bytesReceived;
+struct sockaddr * remote;
+char IPaddress[STRADDR_LEN];
+CELL * cell;
+CELL * result;
+#ifdef TRU64
+unsigned long remote_sin_len;
+#else
+socklen_t remote_sin_len;
+#endif
+
+buffer = (char *)allocMemory(readSize + 1);
+
+family = getSocketFamily(sock);
+remote_sin_len = (family == AF_INET6) ? 
+    sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+remote = alloca(remote_sin_len);
+memset(remote, 0, remote_sin_len);
+
+bytesReceived = recvfrom(sock, buffer, readSize, 0, 
+    (struct sockaddr *)remote, &remote_sin_len);
+
+if(bytesReceived == SOCKET_ERROR) 
+    {
+    freeMemory(buffer);
+    deleteIOsession(sock);
+    return(netError(ERR_INET_READ)); 
+    }
+
+ipstrFromSockAddr((struct sockaddr *)remote, IPaddress, STRADDR_LEN);
+portNo = portFromSockAddr((struct sockaddr *)remote);
+
+cell = result = makeCell(CELL_EXPRESSION, (UINT)stuffStringN(buffer, bytesReceived));
+
+cell = (CELL *)cell->contents;
+cell->next = stuffString(IPaddress);
+((CELL*)cell->next)->next = stuffInteger(portNo);
+
+freeMemory(buffer);
+
+if(closeFlag) 
+    {
+    deleteIOsession(sock);
+    }
+
+netErrorIdx = 0;
+return(result);
+}
+
+
+CELL * p_netReceiveUDP(CELL * params) 
+{ 
+UINT portNo;
+int sock;
+size_t readSize;
+INT64 wait = 0;
+INT64 elapsed;
+char * ifaddr = NULL;
+
+params = getInteger(params, &portNo);
+params = getInteger(params, (UINT *)&readSize);
+if(params != nilCell)
+    {
+    params = getInteger64Ext(params, &wait, TRUE);
+    if(params != nilCell)
+        getString(params, &ifaddr);
+    }
+
+if((sock = netListenOrDatagram((int)portNo, SOCK_DGRAM, ifaddr, NULL, 0)) == SOCKET_ERROR)
+    return(nilCell);
+
+/* if timeout parameter given wait for socket to be readable */
+if(wait > 0)
+        {
+        if((elapsed = wait_ready(sock, wait, READY_READ)) <= 0)
+                {
+                close(sock);
+                if(elapsed == 0) return(netError(ERR_INET_TIMEOUT));
+                else netError(ERR_INET_SELECT_FAILED);
+                }
+        }
+
+return(netReceiveFrom(sock, readSize, TRUE));
+}
+
+
+CELL * p_netReceiveFrom(CELL * params)
+{
+UINT sock;
+size_t readSize;
+
+params = getInteger(params, &sock);
+getInteger(params, (UINT*)&readSize);
+
+return(netReceiveFrom((int)sock, readSize, FALSE));
+}
+
+
+/**********************************************************************/
+
+CELL * p_netSend(CELL * params) 
+{
+UINT sock; 
+size_t size, size2; 
+char * buffer; 
+ssize_t bytesSent; 
+
+params = getInteger(params, &sock); 
+params = getStringSize(params, &buffer, &size, TRUE);
+
+if(params->type != CELL_NIL) 
+    {
+    getInteger(params, (UINT *)&size2); 
+    if(size2 < size) size = size2;
+    }
+
+if((bytesSent = sendall((int)sock, buffer, size))  == SOCKET_ERROR) 
+    { 
+    deleteIOsession((int)sock); 
+    return(netError(ERR_INET_WRITE)); 
+    }
+
+netErrorIdx = 0; 
+return(stuffInteger(bytesSent)); 
+}
+
+
+#define SEND_TO_UDP 0
+#define SEND_TO_SOCK 1
+
+CELL * netSendTo(CELL * params, int type)
+{
+char * remoteHost;
+UINT remotePort;
+struct sockaddr * destination;
+socklen_t destination_len;
+size_t size;
+char * buffer;
+ssize_t bytesSent;
+UINT sock;
+/* char one = 1; */
+int one = 1;
+
+params = getString(params, &remoteHost);
+params = getInteger(params, &remotePort);
+params = getStringSize(params, &buffer, &size, TRUE);
+
+destination_len = (ADDR_FAMILY == AF_INET6) ? 
+        sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+destination = alloca(destination_len);
+
+if(*remoteHost != 0) /* 10.0.1 */
+    {
+    if(getHostAddr(destination, 0, remoteHost) != 0)
+        return(netError(ERR_INET_HOST_UNKNOWN));
+    setSockaddrPort(destination, remotePort);
+    }
+
+if(type == SEND_TO_UDP) /* for 'net-send-udp' */
+    {
+    if((sock = socket(ADDR_FAMILY, SOCK_DGRAM, 0)) == INVALID_SOCKET)
+        return(netError(ERR_INET_OPEN_SOCKET));
+
+     if(getFlag(params))
+        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (const void *)&one, sizeof(one));
+    }
+else /* SEND_TO_SOCK , socket may or may not be UDP, for 'net-send-to' */
+    {
+    params = getInteger(params, &sock);
+    }
+
+
+/* for socket opened with ip-address in (net-connect host port "udp") 
+   in this case issue (net-send-to "" port message socket) 10.0.1 */
+if(*remoteHost == 0) 
+    bytesSent = sendto((int)sock, buffer, size, NO_FLAGS_SET, NULL, 0);
+else
+    bytesSent = sendto((int)sock, buffer, size, NO_FLAGS_SET,
+        (struct sockaddr *)destination, destination_len);
+
+if(type == SEND_TO_UDP) close((int)sock);
+
+if(bytesSent == SOCKET_ERROR)
+        return(netError(ERR_INET_WRITE));
+
+netErrorIdx = 0;
+return(stuffInteger(bytesSent));
+}
+
+
+CELL * p_netSendUDP(CELL * params)
+{
+return(netSendTo(params, SEND_TO_UDP));
+}
+
+
+CELL * p_netSendTo(CELL * params)
+{
+return(netSendTo(params, SEND_TO_SOCK));
+}
+
+
+/************************* listen **************************************/
+
+CELL * p_netListen(CELL * params) 
+{ 
+UINT portNo;
+char * ifAddr = NULL;
+char * option = NULL;
+char * mcAddr = NULL;
+int sock, type; 
+int sockopt = 0;
+int opt;
+CELL * cell;
+ 
+type = SOCK_STREAM;
+cell = evaluateExpression(params);
+params = params->next;
+
+#ifndef WINDOWS
+if(cell->type == CELL_STRING)
+    {
+    if((sock = netListenLocal((char *)cell->contents)) == SOCKET_ERROR)
+        return(netError(netErrorIdx));
+    else
+        return(stuffInteger((UINT)sock));
+    }
+#endif
+
+getIntegerExt(cell, &portNo, FALSE); 
+
+if(params != nilCell)
+    {
+    params = getString(params, &ifAddr);
+    if(*ifAddr == 0) ifAddr = NULL;
+    if(params != nilCell)
+        {
+        params = getString(params, &option);
+        opt = toupper(*option);
+        if(opt == 'U')
+            type = SOCK_DGRAM;
+#ifndef WINDOWS
+        else if(opt == 'D')
+            {
+            type = SOCK_RAW;
+            sockopt = IPPROTO_DIVERT;
+            }
+#endif
+        else if(opt == 'M')
+            {
+            type = SOCK_DGRAM;
+            mcAddr = ifAddr;
+            ifAddr = NULL;
+            }
+        else
+            errorProc(ERR_INVALID_OPTION);
+        }
+            
+    }
+    
+
+if((sock = netListenOrDatagram((int)portNo, type, ifAddr, mcAddr, sockopt)) 
+        == SOCKET_ERROR)
+    return(nilCell);
+
+return(stuffInteger(sock));
+} 
+
+#ifndef WINDOWS
+int netListenLocal(char * name)
+{
+int sock;
+struct sockaddr_un local_sun;
+
+sock  = socket(AF_UNIX, SOCK_STREAM, 0);
+local_sun.sun_family = AF_UNIX;
+strncpy(local_sun.sun_path, name, sizeof(local_sun.sun_path) - 1);
+local_sun.sun_path[sizeof (local_sun.sun_path) - 1] = '\0';
+unlink(local_sun.sun_path);
+
+#ifdef OS2
+if(bind(sock, (struct sockaddr *)&local_sun, sizeof(struct sockaddr_un)) == -1)
+#else
+if(bind(sock, (struct sockaddr *)&local_sun, SUN_LEN(&local_sun)) != 0)
+#endif
+    {
+    close(sock);
+    netErrorIdx = ERR_INET_CANNOT_BIND;
+    return(SOCKET_ERROR);
+    }
+
+if(listen(sock, MAX_PENDING_CONNECTS) == SOCKET_ERROR)
+    {
+    close(sock);
+    netErrorIdx = ERR_INET_LISTEN_FAILED;
+    return(SOCKET_ERROR);
+    }
+
+createIOsession(sock, AF_UNIX);
+
+netErrorIdx = 0;
+return(sock);
+}
+#endif
+
+
+int netListenOrDatagram(int portNo, int stype, char * ifAddr, char * mcAddr, int option)
+{
+int sock, one = 1;
+struct sockaddr * local;
+struct ip_mreq mcast;
+socklen_t local_len;
+
+if((sock = socket(ADDR_FAMILY, stype, option)) == INVALID_SOCKET)
+    {
+    netErrorIdx = ERR_INET_OPEN_SOCKET; 
+    return SOCKET_ERROR;
+    }
+
+local_len = (ADDR_FAMILY == AF_INET6) ?
+    sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+local = alloca(local_len);
+memset(local, 0, local_len);
+
+if(getHostAddr((struct sockaddr *)local, stype, ifAddr) != 0)
+    return(SOCKET_ERROR);
+
+setSockaddrPort(local, portNo);
+
+setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void*)&one, sizeof(one));
+ 
+if(bind(sock, (struct sockaddr *)local, local_len) == SOCKET_ERROR) 
+    { 
+    close(sock);
+    netErrorIdx = ERR_INET_CANNOT_BIND; 
+    return(SOCKET_ERROR);
+    } 
+
+if(mcAddr != NULL)
+    {
+    memset(&mcast, 0, sizeof(mcast));
+    mcast.imr_multiaddr.s_addr = inet_addr(mcAddr);
+    if(ADDR_FAMILY == AF_INET)
+        mcast.imr_interface.s_addr = INADDR_ANY;    
+/* not handled/debugged
+    else
+        mcast.imr_interface.s_addr = IN6ADDR_ANY_INIT;
+*/
+    setsockopt(sock, 0, IP_ADD_MEMBERSHIP, (const void *)&mcast, sizeof(mcast));
+    }
+
+if(stype == SOCK_STREAM)
+    {
+    if(listen(sock, MAX_PENDING_CONNECTS) == SOCKET_ERROR)  
+        { 
+        close(sock); 
+        netErrorIdx = ERR_INET_LISTEN_FAILED;
+        return(SOCKET_ERROR);
+        } 
+    }
+
+createIOsession(sock, ADDR_FAMILY); 
+
+netErrorIdx = 0;
+return(sock);
+}
+
+
+/* returns number of bytes ready to read */
+CELL * p_netPeek(CELL * params)
+{
+UINT sock;
+#ifdef WINDOWS
+u_long result;
+#else
+int result;
+#endif
+
+getInteger(params, &sock);
+
+if(ioctl((int)sock, FIONREAD, &result) == SOCKET_ERROR)
+    return(netError(ERR_INET_PEEK_FAILED));
+
+netErrorIdx = 0;
+return(stuffInteger((UINT)result));
+} 
+
+
+typedef struct
+    {
+    int sock;
+    void * next;
+    } SOCKLIST;
+
+
+/* checks a socket for readability/writeability  */
+CELL * p_netSelect(CELL * params)
+{
+INT64 wait;
+char * mode;
+struct timeval timeOut;
+fd_set socketSet;
+CELL * cell;
+CELL * list;
+CELL * sockListHead = NULL;
+CELL * sockListPtr;
+struct timeval* tmvPtr;
+UINT socket;
+int setSize = 0;
+
+netErrorIdx = 0;
+
+FD_ZERO(&socketSet);
+
+cell = evaluateExpression(params);
+if(isNumber(cell->type))
+    getIntegerExt(cell, (UINT*)&socket, FALSE);
+else if(isList(cell->type))
+    {
+    cell = (CELL*)cell->contents;
+    sockListHead = cell;
+    while(cell != nilCell)
+        {
+        cell = getIntegerExt(cell, (UINT*)&socket, FALSE);
+        if(setSize == FD_SETSIZE)
+            return(netError(ERR_INET_TOO_MUCH_SOCKETS));
+        else setSize++;
+        FD_SET((int)socket, &socketSet);
+        }
+    }
+else return(errorProcExt(ERR_LIST_OR_NUMBER_EXPECTED, params));
+
+params = getString(params->next, &mode);
+getInteger64Ext(params, &wait, TRUE);
+
+tmvPtr = (wait == -1) ? NULL : &timeOut;
+timeOut.tv_sec = wait/1000000;
+timeOut.tv_usec = wait - timeOut.tv_sec * 1000000;
+
+if(sockListHead == NULL)
+    FD_SET((int)socket, &socketSet);
+
+/* printf("%d %d %d\n", timeOut.tv_sec, timeOut.tv_usec, sizeof(timeOut.tv_sec));  */
+
+if(*mode == 'r')
+    setSize = select(FD_SETSIZE, &socketSet, NULL, NULL, tmvPtr);
+else if(*mode == 'w')
+    setSize = select(FD_SETSIZE, NULL, &socketSet, NULL, tmvPtr);
+else if(*mode == 'e')
+    setSize = select(FD_SETSIZE, NULL, NULL, &socketSet, tmvPtr);
+else return(errorProcExt2(ERR_INVALID_PARAMETER, stuffString(mode)));
+
+if(setSize >= 0)
+    {
+    if(sockListHead == NULL)
+        {
+        if(setSize == 0) return(nilCell);
+        else return(trueCell);
+        }    
+
+    list = getCell(CELL_EXPRESSION);
+    if(setSize == 0) return(list);
+
+    sockListPtr = sockListHead;
+    while(sockListPtr != nilCell)
+        {
+        sockListPtr = getIntegerExt(sockListPtr, &socket, FALSE);
+        /* printf("testing %lu\n", socket); */
+        if(FD_ISSET(socket, &socketSet))
+            {
+            addList(list, stuffInteger(socket));
+            /* printf("adding %lu\n", socket); */
+            }
+        }
+
+    return(list);
+    }
+
+netError(ERR_INET_SELECT_FAILED);
+
+return(nilCell);
+}
+
+extern char logFile[];
+
+void writeLog(char * text, int newLine)
+{
+int handle;
+
+
+#ifdef WINDOWS
+handle = open(logFile, O_RDWR | O_APPEND | O_BINARY | O_CREAT, S_IREAD | S_IWRITE);
+#else
+handle = open(logFile, O_RDWR | O_APPEND | O_BINARY | O_CREAT,
+          S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR | S_IWGRP | S_IWOTH); /* rw-rw-rw */
+#endif
+
+if(write(handle, text, strlen(text)) < 0) return;
+if(newLine) 
+    if(write(handle, &LINE_FEED, LINE_FEED_LEN) < 0) return;
+#ifdef WINDOWS
+_close(handle);
+#else
+close(handle);
+#endif
+}
+
+FILE * win_fdopen(int handle, const char * mode);
+
+FILE * serverFD(int port, char * domain, int reconnect)
+{
+static int sock, connection;
+char name[STRADDR_LEN];
+char text[80];
+time_t t;
+
+text[79] = 0;
+
+if(!reconnect)
+    {
+#ifndef WINDOWS
+    if(port != 0)
+        sock = netListenOrDatagram(port, SOCK_STREAM, NULL, NULL, 0);
+    else
+        sock = netListenLocal(domain);
+#else
+    sock = netListenOrDatagram(port, SOCK_STREAM, NULL, NULL, 0);
+#endif
+
+    if(sock == SOCKET_ERROR) return(NULL);
+    else {
+        snprintf(text, 79, "newLISP v.%d listening on %s", version, domain);
+        writeLog(text, TRUE);
+        }
+    }
+else
+    {
+    deleteIOsession(connection);
+    }
+
+if((connection = netAccept(sock)) == SOCKET_ERROR)
+    return NULL;
+
+/* avoid registering socket twice */
+if(!isSessionSocket(connection))
+    createIOsession(connection, (port != 0) ? ADDR_FAMILY : AF_UNIX);
+
+/* print log */
+getIpPortFromSocket(connection, PEER_INFO, name);
+t = time(NULL);
+snprintf(text, 79, "Connected to %s on %s", name, ctime(&t));
+/* printf(text); */
+writeLog(text, 0);
+
+setenv("REMOTE_ADDR", name, 1);
+
+return(fdopen(connection, "r+")); 
+}
+
+/******************************* distributed computing ***********************/
+
+
+#define MAX_BUFF 1024
+CELL * netEvalError(int errNo);
+
+typedef struct
+    {
+    char * host;
+    int port;
+    int sock;
+    int timeOut;
+    STREAM * netStream;
+    CELL * result;
+    void * next;
+    } NETEVAL;
+
+void freeSessions(NETEVAL * base);
+
+CELL * p_netEval(CELL * params)
+{
+CELL * cell = NULL;
+CELL * list = NULL;
+NETEVAL * session = NULL;
+NETEVAL * base = NULL;
+char * host;
+char * prog;
+UINT port;
+int ready;
+int sock;
+size_t size, count = 0;
+ssize_t bytes;
+INT timeOut = 60000; /* milli secs */
+int start, elapsed = 0;
+CELL * result;
+STREAM * netStream;
+CELL * netEvalIdle = NULL;
+char buffer[MAX_BUFF];
+int rawMode = FALSE;
+int singleSession = FALSE;
+jmp_buf errorJumpSave;
+int errNo;
+UINT * resultStackIdxSave;
+
+list  = evaluateExpression(params);
+if(list->type == CELL_STRING)
+    {
+    host = (char *)list->contents;
+    params = getIntegerExt(params->next, &port, TRUE);
+    /* params = getStringSize(params, &prog, &size, TRUE); */
+    /* convert to string if required (since 10.1.1) */
+    prog = cellToString(evaluateExpression(params), &size, FALSE);
+    params = params->next;
+    list = nilCell;
+    singleSession = TRUE;
+    goto SINGLE_SESSION;
+    }
+else if(list->type == CELL_EXPRESSION)
+    {
+    list = (CELL*)list->contents;
+    params = params->next;
+    }
+else return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, params));
+
+CREATE_SESSION:
+if(!isList(list->type))
+    return(errorProcExt(ERR_LIST_EXPECTED, list));
+cell = (CELL *)list->contents;
+
+/* get node parameters, since 8.9.8 evaluated */
+memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+if((errNo = setjmp(errorJump)) != 0)
+    {
+    memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+    freeSessions(base);
+    longjmp(errorJump, errNo);
+    }
+cell = getStringSize(cell, &host, &size, TRUE);
+cell = getInteger(cell, &port);
+prog = cellToString(evaluateExpression(cell), &size, FALSE);
+rawMode = getFlag(cell->next);
+
+memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+
+SINGLE_SESSION:
+if(base == NULL)
+    {
+    base = session = allocMemory(sizeof(NETEVAL));
+    memset(base, 0, sizeof(NETEVAL));
+    }
+else
+    {
+    session->next = allocMemory(sizeof(NETEVAL));
+    session = session->next;
+    memset(session, 0, sizeof(NETEVAL));
+    }
+
+/* timeout for making connection is always 15 secs, 
+   but variable timeOut is used during connection */
+#ifndef WINDOWS
+if(port != 0)
+    sock = netConnect(host, (int)port, SOCK_STREAM, 0, 15000);
+else
+    sock = netConnectLocal(host);
+#else
+sock = netConnect(host, (int)port, SOCK_STREAM, 0, 15000);
+#endif
+
+if(sock == SOCKET_ERROR)
+        {
+        session->result = netEvalError(netErrorIdx);
+        goto CONTINUE_CREATE_SESSION;
+        }
+    
+session->host = host;
+session->port = port;
+session->sock = sock;
+
+if( sendall(sock, "[cmd]\n", 6)  == SOCKET_ERROR ||
+    sendall(sock, prog, size) == SOCKET_ERROR ||
+    sendall(sock, "(exit)\n[/cmd]\n", 14) == SOCKET_ERROR )
+    { 
+    close(sock); 
+    session->result = netEvalError(ERR_INET_WRITE); 
+    goto CONTINUE_CREATE_SESSION;
+    }
+
+session->netStream = (void *)allocMemory(sizeof(STREAM));
+memset(session->netStream, 0, sizeof(STREAM));
+openStrStream(session->netStream, MAX_BUFF, 0);
+createIOsession(sock, ADDR_FAMILY);
+count++;
+CONTINUE_CREATE_SESSION:
+list = list->next;
+if(list != nilCell) goto CREATE_SESSION;
+
+/* get timeout ms and optional handler symbol
+   this is the timeout after connections  are made
+   waiting for the result to come back */
+session = base;
+if(params != nilCell)
+    params = getInteger(params, (UINT *)&timeOut);
+if(params != nilCell)
+    netEvalIdle = params;
+   
+/* printf("timeout %d idle-loop %X\n", timeOut, netEvalIdle); */
+ 
+/* collect data from host in each active session */
+
+while(count)
+    {
+    resultStackIdxSave = resultStackIdx;
+    if( (netStream = session->netStream) == NULL) 
+        {
+        session = session->next;
+        if(session == NULL) session = base;
+        continue;
+        }
+        
+    start = milliSecTime();
+
+    if(netEvalIdle) 
+        {
+        cell = makeCell(CELL_EXPRESSION, (UINT)copyCell(netEvalIdle));
+
+        pushResult(cell);
+        if(!evaluateExpressionSafe(cell, &errNo))
+            {
+            freeSessions(base);
+            longjmp(errorJump, errNo);
+            }
+        }
+
+    bytes = -1; errNo = 0;
+    ready = wait_ready(session->sock, 100, READY_READ);
+    if(ready > 0)
+        {
+        memset(buffer, 0, MAX_BUFF);
+        bytes = recv(session->sock, buffer, MAX_BUFF, NO_FLAGS_SET);
+
+/*
+        if(bytes >= 0) printf("bytes:%ld=>%s<=\n", bytes, buffer); 
+*/
+        if(bytes) 
+            {
+	    if(bytes == -1) bytes = 0;
+            errNo = (memcmp(buffer, "\nERR: ", 6) == 0);
+            writeStreamStr(netStream, buffer, bytes);
+            }
+        }
+    if(ready < 0 || bytes == 0 || errNo || elapsed >= timeOut)
+        {
+/*
+        printf("count=%ld ready=%d bytes=%ld elapsed=%d\n", count, ready, bytes, elapsed); 
+*/
+        if(elapsed >= timeOut) result = copyCell(nilCell); 
+        else if(rawMode || errNo) /* get raw buffer without the quote */
+            result = stuffStringN(netStream->buffer, netStream->position);
+        else 
+            {
+            memcpy(errorJumpSave, errorJump, sizeof(jmp_buf));
+            if((errNo = setjmp(errorJump)) != 0)
+                {
+                memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+                freeSessions(base);
+                longjmp(errorJump, errNo);
+                }
+            /* Only one expression should be sent out by net-eval. When contained
+               in a string more than one can be sent out and will be evaluated,
+               burt net-eval will only return the result of the last(10.6.3) one */
+            result = sysEvalString(netStream->buffer, currentContext, nilCell, READ_EXPR_NET);
+            /* changed from READ_EXPR+SYNC to READ_EXPR in 10.6.3 */
+            memcpy(errorJump, errorJumpSave, sizeof(jmp_buf));
+            }
+
+        if(netEvalIdle)
+            {
+            session->result = cell = makeCell(CELL_EXPRESSION, (UINT)stuffString(session->host));
+
+            cell = (CELL *)cell->contents;
+            cell->next = stuffInteger(session->port);
+            cell = cell->next;
+            cell->next = result;
+            }
+        else
+            session->result = result;
+            
+        closeStrStream(netStream);
+        deleteIOsession(session->sock);
+        free(netStream);
+        session->netStream = NULL;
+            
+        if(netEvalIdle)
+            {
+            list = makeCell(CELL_EXPRESSION, (UINT)copyCell(netEvalIdle));
+            cell = makeCell(CELL_QUOTE, (UINT)session->result);
+
+            ((CELL*)list->contents)->next = cell;
+            pushResult(list);
+            if(!evaluateExpressionSafe(list, &errNo))
+                {
+                freeSessions(base);
+                longjmp(errorJump, errNo);
+                }
+            }
+
+        count--;
+        }
+        
+    /* check for rollover at midnight */
+    if(milliSecTime() >= start) 
+        elapsed += milliSecTime() - start;
+    else 
+        elapsed += milliSecTime();
+
+    session = session->next;
+    if(session == NULL) session = base;
+
+    cleanupResults(resultStackIdxSave);
+    }
+
+/* free all sessions and configure result */
+result = NULL;
+while(base != NULL)
+    {
+    if(netEvalIdle == NULL)
+        {
+        if(result == NULL)
+            {
+            if(singleSession)
+                result = base->result;
+            else
+                {
+                result = makeCell(CELL_EXPRESSION, (UINT)base->result);
+                cell = base->result;
+                }
+            }
+        else
+            {
+            cell->next = base->result;
+            cell = cell->next;
+            }
+        }
+    session = base;
+    base = base->next;
+    free(session);
+    }
+
+if(elapsed > timeOut) 
+    netErrorIdx = ERR_INET_TIMEOUT;
+else netErrorIdx = 0;
+if(netEvalIdle == NULL) return(result);
+return(trueCell);
+}    
+
+
+void freeSessions(NETEVAL * base)
+{
+NETEVAL * session;
+
+while(base != NULL)
+    {
+    if(base->netStream != NULL)
+        {
+        if(base->result != NULL)
+          deleteList(base->result);
+        closeStrStream(base->netStream);
+        deleteIOsession(base->sock);
+        free(base->netStream);
+        base->netStream = NULL;
+        }
+    session = base;
+    base = base->next;
+    free(session);
+    }
+}
+
+int sendall(int sock, char * buffer, int len)
+{
+int bytesSend = 0;
+int n;
+
+while(bytesSend < len)
+    {
+    if((n = send(sock, buffer + bytesSend, len - bytesSend, NO_FLAGS_SET)) == SOCKET_ERROR)
+        return(SOCKET_ERROR);
+    bytesSend += n;
+    }
+
+return(bytesSend);
+}
+
+/*********************** error handling ***************************************/
+
+char * netErrorMsg[] =
+    {
+    "No error",
+    "Cannot open socket",
+    "DNS resolution failed",
+    "Not a valid service",
+    "Connection failed",
+    "Accept failed",
+    "Connection closed",
+    "Connection broken",
+    "Socket recv failed",
+    "Socket send failed",
+    "Cannot bind socket",
+    "Too many sockets",
+    "Listen failed",
+    "Badly formed IP",
+    "Select failed",
+    "Peek failed",
+    "Not a valid socket",
+    "Cannot block or unblock socket",
+    "Operation timed out",
+/* for nl-web.c */
+    "HTTP bad formed URL",
+    "HTTP file operation failed",
+    "HTTP transfer failed",
+    "HTTP invalid response from server",
+    "HTTP no response from server",
+    "HTTP not content",
+    "HTTP error in header",
+    "HTTP error in chunked format"
+    };
+
+
+CELL * netError(int errorNo) 
+{ 
+netErrorIdx = errorNo; 
+return(nilCell); 
+} 
+
+CELL * netEvalError(int errorNo)
+{ 
+netErrorIdx = errorNo; 
+return(p_netLastError(nilCell));
+}
+
+CELL * p_netLastError(CELL * params)
+{
+CELL * result;
+char str[40];
+UINT numError = netErrorIdx;
+
+if(params != nilCell)
+    getInteger(params, &numError);
+else
+    if(numError == 0) return(nilCell);
+
+result = makeCell(CELL_EXPRESSION, (UINT)stuffInteger(numError));
+
+snprintf(str, 40, "%s", (numError > MAX_NET_ERROR) ? UNKNOWN_ERROR : netErrorMsg[numError]);
+((CELL *)result->contents)->next = stuffString(str);
+
+return(result);
+}
+
+#ifndef NO_NET_PING
+/* net-ping 
+
+   Undocumented boolean flag parameter (after count) puts error info
+   into the result list when a packet could not be sent.
+*/
+
+CELL * p_netPing(CELL * params)
+{
+CELL * address;
+UINT maxwait = 1000, listmode = 0;
+UINT flag = 0;
+UINT count = 0;
+
+params = getEvalDefault(params, &address);
+if(address->type == CELL_EXPRESSION)
+    {
+    address = (CELL *)address->contents;
+    listmode = 1;
+    }
+else if(address->type != CELL_STRING)
+  return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, address));
+
+if(params != nilCell)  
+    {
+    params = getInteger(params, &maxwait);
+    if(params != nilCell)
+        params = getInteger(params, &count);
+    flag = getFlag(params);
+    }
+
+return(ping(address, (int)maxwait, (int)listmode, (int)count, (int)flag));
+}
+
+#define PLEN 64
+
+CELL * ping(CELL * address, int maxwait, int listmode, int maxCount, int flag)
+{
+char * host;
+char * ptr;
+char * hostaddr = NULL;
+unsigned char packet[PLEN];
+struct ip *ip;
+char IPaddress[STRADDR_LEN];
+struct icmp6_filter filter;
+struct icmp6_hdr *icp6 = (struct icmp6_hdr *) packet;
+struct icmp *icp = (struct icmp *) packet;
+struct sockaddr * whereto;
+struct sockaddr * from;
+int s;
+int sockopt = 1;
+#ifdef TRU64
+unsigned long sockaddr_len;
+#else
+#ifdef OS2
+int sockaddr_len;
+#else
+socklen_t sockaddr_len;
+#endif
+#endif
+int broadcast = 0;
+int size, ipNo, startIp = 0, endIp = 0;
+int timeout = 0, tdiff;
+int sendCount = 0, receiveCount = 0;
+ssize_t len;
+struct timeval tv, tp;
+CELL * result = NULL;
+CELL * link = NULL;
+char buff[64];
+
+#ifdef MAC_OSX /* no superuser rights necessary */
+if ((s = socket(ADDR_FAMILY, SOCK_DGRAM, ICMP_TYPE)) < 0) 
+#else
+if ((s = socket(ADDR_FAMILY, SOCK_RAW, ICMP_TYPE)) < 0)
+#endif 
+    return(netError(ERR_INET_OPEN_SOCKET));
+   
+sockaddr_len = (ADDR_FAMILY == AF_INET6) ? 
+    sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+
+whereto = alloca(sockaddr_len);
+from = alloca(sockaddr_len);
+
+if(ADDR_FAMILY == AF_INET6)
+    {
+    ICMP6_FILTER_SETPASSALL (&filter);
+    setsockopt (s, IPPROTO_ICMPV6, ICMP6_FILTER, &filter, sizeof (filter));
+    }
+
+gettimeofday(&tv, NULL );
+
+/* for each list-IP */
+while(address != nilCell)
+    {
+    mySleep(1);
+    if(address->type != CELL_STRING)
+        {
+        shutdown(s, SHUT_RDWR);
+        return(errorProcExt(ERR_STRING_EXPECTED, address));
+        }
+
+    host = (char *)address->contents;
+    len = address->aux - 1;
+
+    if(ADDR_FAMILY == AF_INET) /* IPv4 */
+        {
+        if(strncmp(host + len - 2, ".*", 2) == 0)
+            {
+            startIp = 1;
+            endIp = 254;
+            len--;
+            }
+        else
+            {
+            startIp = endIp = 0;
+            ptr = host + len - 1;
+            while(isdigit((int)*ptr)) --ptr;
+            if(*ptr == '-')
+                {
+                endIp = atoi(ptr + 1);
+                --ptr;
+                while(isdigit((int)*ptr)) --ptr;
+                if(*ptr == '.')
+                    {
+                    startIp = atoi(ptr + 1);
+                    len = ptr - host + 1;
+                    }
+                else endIp = startIp = 0;
+                if(endIp < startIp) endIp = startIp;    
+                if(endIp > 254) endIp = 254;
+                }
+            }
+        }
+
+    /* ping ip range */
+    for(ipNo = startIp; ipNo <= endIp; ipNo++)
+        {
+        if(startIp)
+            {
+            if(hostaddr == NULL) hostaddr = alloca(len + 4);
+            memcpy(hostaddr, host, len);
+            snprintf(hostaddr + len, 4, "%d", ipNo);
+            }
+        else
+            hostaddr = host;
+
+        /* target host address info */
+        /* printf("->%s\n", hostaddr); */
+
+        memset((char *)whereto, 0, sockaddr_len);
+#ifdef  MAC_OSX
+        if(getHostAddr(whereto, SOCK_DGRAM, hostaddr) != 0)
+#else
+        if(getHostAddr(whereto, SOCK_RAW, hostaddr) != 0)
+#endif
+            {
+            shutdown(s, SHUT_RDWR);
+            return(netError(ERR_INET_HOST_UNKNOWN));
+            }
+
+        if(ADDR_FAMILY == AF_INET6)
+            setSockaddrPort(whereto, htons(IPPROTO_ICMPV6));
+        else if((broadcast = (strncmp(host + len - 4, ".255", 4) == 0)))
+            setsockopt(s, SOL_SOCKET, SO_BROADCAST, (void *) &sockopt, sizeof(sockopt));
+            
+        /* ping setup ICMP packet */
+        if(ADDR_FAMILY == AF_INET6)
+            {
+            memset(icp6, 0, PLEN);
+            icp6->icmp6_type = ICMP6_ECHO_REQUEST;
+            icp6->icmp6_id = getpid() & 0xFFFF; 
+            gettimeofday((struct timeval *)&icp6->icmp6_data8[4], NULL);
+            }
+        else
+            {
+            memset(icp, 0, PLEN);
+            icp->icmp_type = ICMP_ECHO;
+            icp->icmp_id = getpid() & 0xFFFF; 
+            gettimeofday((struct timeval *)&icp[1], NULL);
+            icp->icmp_cksum = in_cksum((unsigned short *) icp, PLEN );
+            }
+
+        while(wait_ready(s, 10000, READY_WRITE) <= 0)
+            {
+            gettimeofday(&tp, NULL);
+            if((timeout = (timediff_ms(tp, tv) > maxwait))) break;
+            continue;
+            }
+        
+        /* ping */  
+        size = sendto(s, packet, PLEN, 0,(struct sockaddr *)whereto, sockaddr_len);
+        if(size != PLEN)
+            {
+            if(flag)
+                {
+                snprintf(buff, 64, "%s", strerror(errno));
+                ipstrFromSockAddr((struct sockaddr *)whereto, IPaddress, STRADDR_LEN);
+                link = addResult(&result, link, 
+                    makePair(stuffString(IPaddress), stuffString(buff)));
+                }
+            if( !(listmode || startIp) ) break;
+            continue;
+            }
+
+        sendCount++;
+        }
+    if(!listmode) break;
+    address = address->next;
+    }
+
+/* wait for response(s) */
+if(maxCount == 0) maxCount = sendCount;
+while(sendCount) 
+    {
+
+    if(wait_ready(s, 1000, READY_READ) <= 0)
+        {
+        gettimeofday(&tp, NULL);
+        if((timeout = (timediff_ms(tp, tv) > maxwait))) break;
+        continue;
+        }    
+
+    memset(packet, 0, PLEN);
+    memset(from, 0, sockaddr_len);
+    if ( (len = recvfrom(s, packet, PLEN, 0, (struct sockaddr *)from, 
+                        (socklen_t *)&sockaddr_len)) < 0)
+        continue;
+    
+    ip = (struct ip *) packet;
+    gettimeofday(&tp, NULL);
+
+    if(ADDR_FAMILY == AF_INET6)
+        {
+        icp6 = (struct icmp6_hdr *)packet;
+        if(icp6->icmp6_type != ICMP6_ECHO_REPLY) continue;
+        if(icp6->icmp6_id != (getpid() & 0xFFFF)) continue; 
+        tdiff = timediff64_us(tp, *(struct timeval *)&icp6->icmp6_data8[4]);
+        }
+    else
+        {
+        icp = (struct icmp *)(packet + (ip->ip_hl << 2));
+        if(icp->icmp_id != (getpid() & 0xFFFF)) continue; 
+        tdiff = timediff64_us(tp, *(struct timeval *)&icp[1]);
+        }
+
+    ipstrFromSockAddr((struct sockaddr *)from, IPaddress, STRADDR_LEN);
+    link = addResult(&result, link, 
+            makePair(stuffString(IPaddress), stuffInteger(tdiff)));
+
+    if(++receiveCount == maxCount) break;
+    if( !(broadcast || listmode || startIp) ) break;
+    } 
+
+shutdown(s, SHUT_RDWR); 
+
+if(timeout) netErrorIdx = ERR_INET_TIMEOUT;
+else netErrorIdx = 0;
+return(result == NULL ? getCell(CELL_EXPRESSION) : result);
+}
+
+
+CELL * addResult(CELL * * result, CELL * cell, CELL * new)
+{
+if(*result == NULL)
+    *result = makeCell(CELL_EXPRESSION, (UINT)new);
+else
+    cell->next = new;   
+
+return(new);
+}
+
+CELL * makePair(CELL * left, CELL * right)
+{
+left->next = right;
+return(makeCell(CELL_EXPRESSION, (UINT)left));
+}
+
+unsigned short in_cksum(unsigned short * addr, int len)
+{
+int nleft = len;
+unsigned short *w = addr;
+unsigned short  answer;
+int sum = 0;
+
+while( nleft > 1 )  {
+    sum += *w++;
+    nleft -= 2;
+    }
+
+if( nleft == 1 ) {
+    u_short    u = 0;
+    *(unsigned char *)(&u) = *(unsigned char *)w ;
+    sum += u;
+    }
+
+sum = (sum >> 16) + (sum & 0xffff);
+sum += (sum >> 16);
+answer = ~sum;
+return (answer);
+}
+
+#endif /* NO_NET_PING */
+
+
+/* check socket for readability or error 
+   return 0 if the time limit expires or -1
+   on error
+   tie limit in wait given in micro-secs
+*/
+int wait_ready(int sock, INT64 wait_us, int mode)
+{
+struct timeval timeOut;
+fd_set socketSet;
+
+FD_ZERO(&socketSet);
+FD_SET(sock, &socketSet);
+
+timeOut.tv_sec = wait_us/1000000;
+timeOut.tv_usec = wait_us - timeOut.tv_sec * 1000000;
+
+if(mode == READY_READ)
+    return(select(sock + 1, &socketSet, NULL, NULL, &timeOut));
+else
+    return(select(sock + 1, NULL, &socketSet, NULL, &timeOut));
+}
+
+
+/* ------------------------- raw sockets ---------------------------------------
+
+   (net-packet packet)
+
+   Checksums are only gnerated if set to zero in the packet.
+
+   Packets start with the ip header followed by either a TCP, UDP or ICMP
+   header and data.
+*/
+
+/* for checksum calculation in TCP packets */
+struct pseudohdr
+    {
+    struct in_addr source_addr;
+    struct in_addr dest_addr;
+    unsigned char dummy;
+    unsigned char protocol;
+    unsigned short len;
+    };
+
+
+#ifndef NO_NET_PACKET
+unsigned short pseudo_chks( struct ip * iph, char * packet, char * header, int data_offset);
+/* (net-packet str-packeA [int-config-flags]) */
+
+CELL * p_netPacket(CELL * params)
+{
+char * packet;
+int sock;
+int one = 1;
+struct sockaddr_in dest_sin;
+size_t size;
+ssize_t bytesSent;
+struct ip * iph;
+struct tcphdr * tcph;
+struct udphdr * udph;
+struct icmp * icmph;
+int dport;
+/* ip_len  and ip_off must be check-summed in network order (big-Endian),
+   but one or both must be given to the sendto() in host byte-order on
+   some OS. As of 10.2.6 the following configFLags work for Mac OS X
+   on PPC and Intel, Linux on Intel and OpenBSD on Intel.
+
+   Curently net-packet is IPv4 only.
+*/
+#if defined(MAC_OSX)
+UINT configFlags = 3; /* ntohs() for both ip_len and ip_off */
+#elif defined(LINUX)
+UINT configFlags = 1; /* ntohs() for ip_len only */
+#else /* works for OpenBSD */
+UINT configFlags = 0; /* none */
+#endif
+
+params = getStringSize(params, &packet, &size, TRUE);
+/* undocumented user-supplied extra configFlags parameter
+   can have a value of 0,1,2,3
+*/
+if(params != nilCell)
+    getInteger(params, &configFlags);
+
+iph = (struct ip *)packet;
+
+if(iph->ip_sum == 0)
+    iph->ip_sum = in_cksum((unsigned short *)iph, sizeof(struct ip));
+
+switch(iph->ip_p)
+  {
+  case IPPROTO_TCP:
+    tcph = (struct tcphdr *)(packet + sizeof(struct ip));
+#ifdef ANDROID
+    dport = tcph->dest;
+    if(tcph->check == 0) 
+        tcph->check = pseudo_chks(iph, packet, (char *) tcph, tcph->doff * 4);
+#else
+    dport = tcph->th_dport;
+    if(tcph->th_sum == 0) 
+        tcph->th_sum = pseudo_chks(iph, packet, (char *) tcph, tcph->th_off * 4);
+#endif
+    break;
+  case IPPROTO_UDP:
+    udph = (struct udphdr *)(packet + sizeof(struct ip));
+    dport = udph->uh_dport;
+    if(udph->uh_sum == 0)
+        udph->uh_sum = pseudo_chks(iph, packet, (char *) udph, sizeof(struct udphdr));
+    break;
+  case IPPROTO_ICMP:
+    icmph = (struct icmp *)(packet + sizeof(struct ip));
+    dport = 0;
+    if(icmph->icmp_cksum == 0)
+    icmph->icmp_cksum = in_cksum((unsigned short *)icmph, 
+            ntohs(iph->ip_len) - iph->ip_hl * 4);
+    break;
+  default:
+    return(nilCell);
+  }
+
+if(configFlags & 0x1) iph->ip_len = ntohs(iph->ip_len);
+if(configFlags & 0x2) iph->ip_off = ntohs(iph->ip_off);
+
+memset(&dest_sin, 0, sizeof(dest_sin));
+dest_sin.sin_family = AF_INET;
+dest_sin.sin_port = dport;
+dest_sin.sin_addr = iph->ip_dst;
+
+if((sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
+    return(netError(ERR_INET_OPEN_SOCKET));
+  
+if(setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one)) < 0)
+    return(netError(ERR_INET_OPEN_SOCKET));
+
+if((bytesSent = sendto(sock, packet, size, NO_FLAGS_SET, 
+        (struct sockaddr *)&dest_sin, sizeof(dest_sin))) != size)
+    return(nilCell);
+
+return(stuffInteger(bytesSent));
+}
+
+unsigned short pseudo_chks(
+        struct ip * iph, char * packet, char * header, int data_offset)
+{
+/* packet was give with ip_len in net-work byte order */
+unsigned short checksum;
+int segment_len = ntohs(iph->ip_len) - iph->ip_hl * 4;
+int data_len = segment_len - data_offset;
+struct pseudohdr * pseudoh = alloca(sizeof(struct pseudohdr) + segment_len);
+
+pseudoh->source_addr = iph->ip_src; 
+pseudoh->dest_addr = iph->ip_dst;   
+pseudoh->dummy = 0;
+pseudoh->protocol = iph->ip_p;
+pseudoh->len = htons(segment_len);
+
+data_len = segment_len - data_offset;
+memcpy((char *)pseudoh + sizeof(struct pseudohdr), header, data_offset);
+memcpy((char *)pseudoh + sizeof(struct pseudohdr) + data_offset,
+    packet + iph->ip_hl * 4 + data_offset, data_len);
+
+checksum = in_cksum((unsigned short *)pseudoh, sizeof(struct pseudohdr) + segment_len);
+#ifdef DEBUG
+    printf("segment_len:%d\n", segment_len);
+    printf("data_offset:%d\n", data_offset);
+    printf("data_len:%d\n", data_len);
+    printf("checksum:%x\n", ntohs(checksum));
+#endif
+return(checksum);
+}
+#endif /* NO_NET_PACKET */
+
+/* ------------------ socket->filestream stuff for windows ------------------------*/
+
+#ifdef WINDOWS
+extern int IOchannelIsSocketStream;
+
+/*
+These functions use the FILE structure to store the raw file handle in '->_file' and
+set ->_flag to 0xFFFF, to identify this as a faked FILE structure.
+Sinc 10.0.1 the IOchannelIsSocketStream flag is used to identify IOchannel as
+a fake file struct and extract the socket. Following win_fxxx routines
+are used to define fopen(), fclose(), fprintf(), fgetc() and fgets() in some *.c
+*/
+
+FILE * win_fdopen(int handle, const char * mode)
+{
+FILE * fPtr;
+
+if((fPtr = (FILE *)malloc(sizeof(FILE))) == NULL)
+    return(NULL);
+
+memset(fPtr, 0, sizeof(FILE));
+
+fPtr->_file = handle;
+fPtr->_flag = 0xFFFF;
+
+return(fPtr);
+}
+
+int win_fclose(FILE * fPtr)
+{
+if(IOchannelIsSocketStream)
+   return(close(getSocket(fPtr)));
+
+return(fclose(fPtr));
+}
+
+
+int win_fprintf(FILE * fPtr, char * notused, char * buffer)
+{
+int pSize;
+
+if(!IOchannelIsSocketStream)
+    return(fprintf(fPtr, buffer));
+
+pSize = strlen(buffer);
+
+if((pSize = sendall(getSocket(fPtr), buffer, pSize)) == SOCKET_ERROR)
+     {
+     close(getSocket(fPtr));
+     return(-1);
+     }
+
+return(pSize);
+}
+
+int win_fgetc(FILE * fPtr)
+{
+char chr;
+
+if(!IOchannelIsSocketStream)
+    return(fgetc(fPtr));
+
+if(recv(getSocket(fPtr), &chr, 1, NO_FLAGS_SET) <= 0)
+    {
+    close(getSocket(fPtr));
+    return(-1);
+    }
+
+return(chr);
+}
+
+
+char * win_fgets(char * buffer, int size, FILE * fPtr)
+{
+int bytesReceived = 0;
+char chr;
+
+if(!IOchannelIsSocketStream)
+    return(fgets(buffer, size - 1, fPtr));
+
+while(bytesReceived < size)
+    {
+    if(recv(getSocket(fPtr), &chr, 1, NO_FLAGS_SET) <= 0)
+        {
+        close(getSocket(fPtr));
+        return(NULL);
+        }
+
+    *(buffer + bytesReceived++) = chr;
+
+    if(chr == '\n') break;
+    }
+
+*(buffer + bytesReceived) = 0;
+
+return(buffer);
+}
+
+#endif /* WINDOWS */
+
+#else /* for EMSCRIPTEN define dummy writeLog() */
+
+void writeLog(char * text, int newLine) { return; }
+
+#endif /* ifndef EMSCRIPTEN */
+/* eof */
diff --git a/nl-string.c b/nl-string.c
new file mode 100644
index 0000000..6bfd313
--- /dev/null
+++ b/nl-string.c
@@ -0,0 +1,2541 @@
+/* nl-string.c
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#ifdef SUPPORT_UTF8
+#include <wctype.h>
+#endif
+#define PCRE_STATIC
+#include "pcre.h"
+#include "protos.h"
+
+extern SYMBOL * sysSymbol[];
+extern CELL * countCell;
+extern int bigEndian;
+extern int pagesize;
+
+#define OVECCOUNT (MAX_REGEX_EXP * 3)    /*  max sub expressions in PCRE */
+
+void regexError(char * msg_1, int num, const char * msg_2);
+pcre * pcreCachedCompile(char * pattern, int options);
+
+CELL * cellTokenString(char * *source, size_t * srclen, char *separator, pcre *re);
+
+#ifdef USE_WIN_UTF16PATH
+int open_utf16(const char* a, int b, int c);
+#endif
+
+/* ---------------------------- string processing ----------------------- */
+
+int my_strnicmp(char * s1, char * s2, ssize_t size)
+{
+while(toupper(*s1) == toupper(*s2))
+    {
+    if(--size <= 0) return(0);
+    s1++, s2++;
+    }
+return(toupper(*s1) - toupper(*s2));
+}
+
+
+CELL * substring(char * string, ssize_t slen, ssize_t offset, ssize_t len)
+{
+if(offset < 0)
+    {
+    offset = slen + offset;
+    if(offset < 0)
+        return(errorProc(ERR_STRING_INDEX_INVALID));
+    }
+else
+    offset = (offset > slen) ? slen : offset;
+    
+if(len < 0) 
+    {
+    len = slen - offset + len;
+    if(len < 0) len = 0;
+    }
+
+if(len == MAX_LONG) 
+    len = slen - offset;
+else
+    len = ((offset + len) > slen) ? (slen - offset) : len;
+
+return(stuffStringN(string + offset, len));
+}
+
+
+#define SEARCH_SIZE 0x1000
+
+CELL * p_search(CELL * params)
+{
+UINT fileHandle;
+ssize_t bytesRead;
+ssize_t position;
+int flag = 0;
+CELL * next;
+
+#ifdef LFS
+off_t filePosition;
+off_t foundPosition;
+double result;
+#else
+ssize_t filePosition;
+ssize_t foundPosition;
+#endif
+
+char * searchString;
+char * buffer;
+INT options;
+size_t len;
+
+params = getInteger(params, (UINT *)&fileHandle);
+params = getStringSize(params, &searchString, &len, TRUE);
+if(len == 0) return(nilCell);
+
+options = -1;
+if(params != nilCell)
+    {
+    next = params->next;
+    params = evaluateExpression(params);
+    if(isNumber(params->type) || params->type == CELL_STRING)
+        /* 10.6.1 also accept string for options */
+        parseRegexOptions(params, (UINT *)&options, FALSE);
+    else
+        {
+        flag = (params->type != CELL_NIL);
+        if(next != nilCell)
+            /* 10.6.1 also accept string for options */
+            parseRegexOptions(next, (UINT *)&options, TRUE);
+        }
+    }
+
+buffer = (char *)allocMemory(SEARCH_SIZE + 1);
+if((filePosition = lseek((int)fileHandle, 0, SEEK_CUR)) == -1) 
+    return(nilCell);
+
+foundPosition = 0;
+
+do
+    {
+    memset(buffer, 0, SEARCH_SIZE + 1);
+    bytesRead = read((int)fileHandle, buffer, SEARCH_SIZE);
+
+    if(options == -1)
+        position = searchBuffer(buffer, bytesRead, searchString, len, 1);
+    else
+        position = searchBufferRegex(buffer, 0, searchString, bytesRead , options, &len);
+    if(position != -1)
+        {
+        if(flag)
+            foundPosition = filePosition + position + len;
+        else
+            foundPosition = filePosition + position;
+        break;
+        }
+
+    filePosition = filePosition + bytesRead - len;
+    lseek((int)fileHandle, filePosition, SEEK_SET);
+    } while (bytesRead == SEARCH_SIZE);
+
+freeMemory(buffer);
+
+if(position == -1) return(nilCell);
+
+lseek((int)fileHandle, foundPosition, SEEK_SET);
+#ifdef LFS
+result = foundPosition;
+return(stuffFloat(result));
+#else
+return(stuffInteger(foundPosition));
+#endif
+}
+
+/* returns a new string cell */
+CELL * implicitIndexString(CELL * cell, CELL * params)
+{
+ssize_t index;
+char * ptr;
+#ifndef SUPPORT_UTF8
+char str[2];
+#else
+ssize_t p;
+#endif
+
+ptr = (char*)cell->contents;
+
+getInteger(params, (UINT *)&index);
+
+stringCell = cell;
+if(cell->aux == 1 && (index == 0 || index == -1)) 
+    return(copyCell(cell));
+
+#ifndef SUPPORT_UTF8
+index = adjustNegativeIndex(index, cell->aux - 1);
+str[0] = *(ptr + index);
+str[1] = 0;
+stringIndexPtr = ptr + index;
+return(stuffStringN(str, 1));
+#else
+index = adjustNegativeIndex(index, utf8_wlen(ptr, ptr + cell->aux));
+ptr = utf8_index(ptr, index);
+p = utf8_1st_len(ptr);
+if(ptr + p > (char *)cell->contents + cell->aux)
+    return(errorProc(ERR_INVALID_UTF8));
+
+stringIndexPtr = ptr;
+return(stuffStringN(ptr, p));
+#endif
+}
+
+/* only used from setf() for string insertion
+   uses the global stringIndexPtr in insertPtr
+   the insert point set by implicitIndexString()
+
+   modifies cellStr with new and returns new
+*/
+
+CELL * setNthStr(CELL * cellStr, CELL * new, char * insertPtr)
+{
+char * newStr;
+char * oldStr;
+size_t newLen, oldLen, len, offset;
+char * str;
+
+getStringSize(new, &newStr, &newLen, FALSE);
+
+oldStr = (char*)cellStr->contents;
+oldLen = cellStr->aux - 1;
+if(oldLen == 0) return(copyCell(cellStr));
+
+#ifdef SUPPORT_UTF8
+len = utf8_1st_len(insertPtr);
+#else
+len = 1;
+#endif
+
+str = callocMemory(oldLen + newLen - len + 1);
+
+offset = insertPtr - oldStr;
+memcpy(str, oldStr, offset);
+memcpy(str + offset, newStr, newLen);
+memcpy(str + offset + newLen, oldStr + offset + len, oldLen - offset - len);
+
+cellStr->contents = (UINT)str;
+cellStr->aux = oldLen + newLen - len + 1;
+
+freeMemory(oldStr);
+return(new);
+}
+
+
+CELL * p_char(CELL * params)
+{
+char * string;
+ssize_t offset;
+size_t len;
+int  num;
+CELL * datCell;
+char buff[2];
+
+
+if(params == nilCell)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+
+params = getEvalDefault(params, &datCell);
+
+
+switch(datCell->type)
+    {
+    case CELL_STRING:
+        symbolCheck = NULL;
+        string = (char *)datCell->contents;
+
+#ifndef SUPPORT_UTF8
+        len = (size_t)datCell->aux - 1;
+        if(len == 0) return(nilCell);
+#else
+        len = utf8_wlen(string, string + datCell->aux);
+        if(len == 0)
+            {
+            if(datCell->aux - 1 == 0)
+                return(nilCell);
+            else
+                return(stuffInteger(0));
+            }
+#endif
+
+        if(params != nilCell)
+            {
+            params = getInteger(params, (UINT*)&offset);
+#ifdef SUPPORT_UTF8 
+            if(getFlag(params)) /* treat as offset into 8-bit array */
+                {
+                offset = adjustNegativeIndex(offset, (size_t)datCell->aux - 1);
+                return(stuffInteger((UINT)*((unsigned char *)string + (UINT)offset)));
+                }
+#endif
+            }
+        else offset = 0;
+
+        offset = adjustNegativeIndex(offset, (size_t)len);
+        
+#ifndef SUPPORT_UTF8
+        return(stuffInteger((UINT)*((unsigned char *)string + (UINT)offset)));
+
+    case CELL_LONG:
+        buff[0] = (int)datCell->contents;
+        break;
+#ifndef NEWLISP64
+    case CELL_INT64:
+        num = *(INT64 *)&datCell->aux;
+        buff[0] = num;
+        break;
+    case CELL_FLOAT:
+        num = *(double*)&datCell->aux;
+        buff[0] = num;
+#else /* NEWLISP64 */
+    case CELL_FLOAT:
+        num = *(double*)&datCell->contents;
+        buff[0] = num;
+#endif /* NEWLISP64 */
+        break;
+
+
+#else /* SUPPORT_UTF8 */
+        while(offset--) string += utf8_1st_len(string);
+        utf8_wchar(string, &num);   
+        return(stuffInteger(num));
+
+#ifndef NEWLISP64
+    case CELL_FLOAT:
+    case CELL_LONG:
+    case CELL_INT64:
+        string = allocMemory(UTF8_MAX_BYTES + 1);   
+        if(datCell->type == CELL_FLOAT)
+            num = *(double*)&datCell->aux;
+        else if(datCell->type == CELL_INT64)
+            num = *(INT64 *)&datCell->aux;
+        else
+            num = datCell->contents;
+#else /* NEWLISP64 */
+    case CELL_FLOAT:
+    case CELL_LONG:
+        string = allocMemory(UTF8_MAX_BYTES + 1);   
+        if(datCell->type == CELL_FLOAT)
+            num = *(double*)&datCell->contents;
+        else
+            num = (int)datCell->contents;
+#endif /* NEWLISP 64 */
+        len = wchar_utf8(num, string);      
+        datCell = stuffStringN(string, len);
+        free(string);
+        return(datCell);
+#endif /* SUPPORT_UTF8 */
+    default:
+        buff[0] = 0;
+    }
+
+return(stuffStringN(buff, 1));
+}
+
+
+CELL * p_explode(CELL * params)
+{
+char * string;
+CELL * cell;
+CELL * result;
+ssize_t size;
+ssize_t len = 1;
+int flag = 0;
+#ifdef SUPPORT_UTF8
+int clen;
+char * ptr;
+#endif
+
+params = getEvalDefault(params, &cell);
+if(isList(cell->type))
+    return(explodeList((CELL*)cell->contents, params));
+
+if(cell->type == CELL_STRING)
+    {
+    string = (char *)cell->contents;
+    size = cell->aux - 1;
+    }
+else
+    return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, cell));
+
+if(params != nilCell)
+    {
+    params = getInteger(params, (UINT *)&len);
+    flag = getFlag(params);
+    if(!flag && len > size) len = size;
+    }
+
+result = cell = getCell(CELL_EXPRESSION);
+if(size == 0 || len <= 0) return(result);
+
+#ifndef SUPPORT_UTF8
+if(flag && size < len) return(result);
+
+cell->contents = (UINT)stuffStringN(string, len);
+cell = (CELL *)cell->contents;
+string += len;
+
+while((size -= len) > 0)
+    {
+    if(flag && size < len) break;
+    cell->next = stuffStringN(string, (size >= len) ? len : size);
+        cell = cell->next;
+    string += len;
+    }
+#else
+size = utf8_wlen(string, string + size + 1);
+ptr = utf8_index(string, len);
+clen = ptr - string;
+
+if(flag && size < len) return(result);
+
+cell->contents = (UINT)stuffStringN(string, clen);
+cell = (CELL *)cell->contents;
+string += clen;
+while((size -= len) > 0)
+    {
+    if(flag && size < len) break;
+    ptr = utf8_index(string, len);
+    clen = ptr - string;
+    cell->next = stuffStringN(string, clen);
+    cell = cell->next;
+    string += clen;
+    }
+#endif
+
+return(result);
+}
+
+
+#define STR_LOWER 0
+#define STR_UPPER 1
+#define STR_TITLE 2
+
+
+CELL * strUpperLower(CELL * params, int type)
+{
+#ifndef SUPPORT_UTF8
+char * string;
+char * ptr;
+#else
+char * utf8str;
+int * unicode;
+int * ptr;
+size_t size;
+#endif
+CELL * cell;
+int option = FALSE;
+
+#ifndef SUPPORT_UTF8
+params = getString(params, &string);
+option = getFlag(params);
+
+cell = stuffString(string);
+ptr = (void *)cell->contents;
+
+if(type == STR_UPPER)
+    while(*ptr) { *ptr = toupper(*ptr); ptr++; }
+else
+    {
+    if(type == STR_TITLE)
+      if(*ptr) { *ptr = toupper(*ptr); ptr++; }
+    if(((type == STR_TITLE) && option) || (type == STR_LOWER))
+      while(*ptr) { *ptr = tolower(*ptr); ptr++; }
+    }
+#else
+
+params = getStringSize(params, &utf8str, &size, TRUE);
+option = getFlag(params);
+
+size =  utf8_wlen(utf8str, utf8str + size + 1);
+
+unicode = allocMemory((size + 1) * sizeof(int));
+size = utf8_wstr(unicode, utf8str, size);
+
+ptr = unicode;
+
+/* Note that on many platforms towupper/towlower
+do not work correctly for non-ascii unicodes */
+
+if(type == STR_UPPER)
+    while(*ptr) { *ptr = towupper(*ptr); ptr++; }
+else
+    {
+    if(type == STR_TITLE)
+      if(*ptr) { *ptr = towupper(*ptr); ptr++; }
+    if(((type == STR_TITLE) && option) || (type == STR_LOWER))
+      while(*ptr) { *ptr = towlower(*ptr); ptr++; }
+    }
+
+utf8str = allocMemory(size * UTF8_MAX_BYTES + 1);
+size =  wstr_utf8(utf8str, unicode, size * UTF8_MAX_BYTES + 1);
+utf8str = reallocMemory(utf8str, size + 1);
+
+free(unicode);
+return(makeStringCell(utf8str, size));
+#endif
+
+return(cell);
+}
+
+CELL * p_upper(CELL * params) {return(strUpperLower(params, STR_UPPER));}
+CELL * p_lower(CELL * params) {return(strUpperLower(params, STR_LOWER));}
+CELL * p_title(CELL * params) {return(strUpperLower(params, STR_TITLE));}
+
+char * getFormatType(char * fmt, int * type)
+{
+PARSE_FORMAT:
+
+/* get % */
+while(*fmt != '%' && *fmt != 0) fmt++;
+if(*fmt == 0) 
+    {
+    *type = 0;
+    return(fmt);
+    }
+fmt++;
+
+/* is it double %% for '%' */
+if(*fmt == '%')
+    {
+    fmt++;
+    goto PARSE_FORMAT;
+    }
+
+/* get optional decimal format spec */
+/* this GNU extension does not work on FreeBSD, OpenBSD */
+/* works on OSX 10.9, Linux and Unix with GNU libc or alike */
+if(*fmt == '\'') fmt++;
+
+/* get width spec */
+
+/* force + before numbers */
+if(*fmt == '+') 
+    fmt++;
+else
+    {
+    /* left align numbers or strings */
+    if(*fmt == '-')
+        {
+        fmt++;
+        /* force + before numbers */
+        if(*fmt == '+') fmt++;
+        }
+    }
+
+while(isdigit((int)*fmt) && *fmt != 0) fmt++;
+if(*fmt == 0) return(NULL);
+
+/* its a float or string with dot precision*/
+if(*fmt == '.')
+    {
+    fmt++;
+    while(isdigit((int)*fmt) && *fmt !=0) fmt++;
+    if(*fmt == 0) return(NULL);
+
+    if(*fmt == 'f' || *fmt == 'g' || *fmt =='G' || *fmt == 'e' || *fmt == 'E')
+        {
+        *type = CELL_FLOAT;
+        return(++fmt);
+        }
+    if(*fmt == 's')
+        {
+        *type = CELL_STRING;
+        return(++fmt);
+        }
+    else return(NULL);
+    }
+
+/* its a float without dot */
+if(*fmt == 'f' || *fmt == 'g' || *fmt =='G' || *fmt == 'e' || *fmt == 'E')
+    {
+    *type = CELL_FLOAT;
+    return(++fmt);
+    }
+
+/* its an integer or character */
+#ifdef TRU64
+if(*fmt == 'd' || *fmt == 'i' || *fmt == 'u' || *fmt == 'x' || *fmt == 'X' || *fmt == 'c' || *fmt == 'o')
+#else
+if(*fmt == 'd' || *fmt == 'u' || *fmt == 'x' || *fmt == 'X' || *fmt == 'c' || *fmt == 'o')
+#endif
+    {
+#ifdef TRU64
+#ifndef NEWLISP64
+    *type = CELL_INT64;
+#else
+    *type = CELL_LONG;
+#endif
+#else
+    *type = CELL_LONG;
+#endif
+    return(++fmt);
+    }
+
+/* its a string */
+if(*fmt == 's')
+    {
+    *type = CELL_STRING;
+    return(++fmt);
+    }
+
+/* supporting ld, li, lu, lx, lX formats */
+if(*fmt == 'l' &&  (*(fmt + 1) == 'd' || *(fmt + 1) == 'i' || *(fmt + 1) == 'u' || *(fmt + 1) =='x' || *(fmt + 1) == 'X'))
+    {
+#ifndef NEWLISP64
+    *type = CELL_INT64;
+#else
+    *type = CELL_LONG;
+#endif
+    return(fmt+2);
+    }
+
+#ifndef TRUE64 /* UNIX except TRUE64 and WINDOWS MINGW suporting lld, llu, llx, llX formats */
+if(*fmt == 'l' && *(fmt + 1) == 'l' && (*(fmt + 2) == 'd' || *(fmt + 2) == 'u' || *(fmt + 2) =='x' || *(fmt + 2) == 'X'))
+    {
+#ifndef NEWLISP64
+    *type = CELL_INT64;
+#else
+    *type = CELL_LONG;
+#endif
+    return(fmt+3);
+    }
+#endif
+
+#ifdef WINDOWS /* on MINGW also support MS conventions */
+if(memcmp(fmt, "I64", 3) == 0 &&
+        (*(fmt + 3) == 'd' || *(fmt + 3) == 'u' || *(fmt + 3) =='x' || *(fmt + 3) == 'X'))
+    {
+#ifndef NEWLISP64
+    *type = CELL_INT64;
+#else
+    *type = CELL_LONG;
+#endif
+    return(fmt+4);
+    }
+#endif
+
+/* L and q seem not to be suported on most GCC although in the docs
+if(*fmt == 'L' && (*(fmt + 1) == 'd' || *(fmt + 1) =='x' || *(fmt + 1) == 'X'))
+    {
+    *type = CELL_INT64;
+    return(fmt+3);
+    }
+*/
+
+/* its a wchar_t unicode string */
+if(*fmt == 'l' && *(fmt + 1) == 's')
+    {
+    *type = CELL_STRING;
+    return(fmt+2);
+    }
+
+return(NULL);
+}
+
+CELL * p_format(CELL * params)
+{
+char * format;
+char * fmt;
+char * nextfmt;
+CELL * cell;
+STREAM fmtStream = {NULL, NULL, 0, 14, 0};
+int fType;
+double floatNum;
+UINT intNum;
+#ifndef NEWLISP64
+INT64 bigNum;
+#endif
+int evalFlag = TRUE;
+char saveChar;
+
+params = getString(params, &format);
+fmt = format;
+
+fmtStream.buffer = fmtStream.ptr = callocMemory(15);
+
+while(params->type != CELL_NIL)
+    {
+    /* printf("entry>%s<\n", fmt); */
+    nextfmt = getFormatType(fmt, &fType);
+    /* printf("exit>%s<\n", nextfmt); */
+
+    if(nextfmt == NULL)
+        {
+        closeStrStream(&fmtStream);
+        return(errorProcExt2(ERR_FORMAT_STRING, stuffString(format)));
+        }
+
+    if(evalFlag) 
+        cell = evaluateExpression(params);
+    else
+        cell = params;
+
+    if(cell->type == CELL_EXPRESSION && fmt == format)
+        {
+        params = (CELL *)cell->contents;
+        evalFlag = FALSE;
+        cell = params;
+        }
+
+    if(fType == 0)
+        {
+        closeStrStream(&fmtStream);
+        return(errorProcExt(ERR_NUM_ARGS, params));
+        }
+
+    saveChar = *nextfmt;
+    *nextfmt = 0;
+
+    if(fType == CELL_LONG)
+        {
+        if(isNumber(cell->type))
+            cell = getIntegerExt(cell, &intNum, FALSE);
+        else goto FORMAT_DATA_ERROR;
+
+        varPrintf((UINT)&fmtStream, fmt, intNum);
+        goto NEXT_FORMAT;
+        }
+#ifndef NEWLISP64
+    if(fType == CELL_INT64)
+        {
+        if(isNumber(cell->type))
+            cell = getInteger64Ext(cell, &bigNum, TRUE);
+        else goto FORMAT_DATA_ERROR;
+
+        varPrintf((UINT)&fmtStream, fmt, bigNum);
+        goto NEXT_FORMAT;
+        }
+#endif
+    if(fType == CELL_FLOAT)
+        {
+        if(cell->type == CELL_FLOAT)
+#ifndef NEWLISP64
+            floatNum = *(double *)&cell->aux;
+        else if(cell->type == CELL_INT64)
+            floatNum = *(INT64 *)&cell->aux;
+#else
+            floatNum = *(double *)&cell->contents;
+#endif
+        else if(cell->type == CELL_LONG)
+            floatNum = (INT)cell->contents;
+#ifdef BIGINT
+        else if(cell->type == CELL_BIGINT)
+            floatNum = bigintCellToFloat(cell);
+#endif
+        else goto FORMAT_DATA_ERROR;
+
+        varPrintf((UINT)&fmtStream, fmt, floatNum);
+        goto NEXT_FORMAT;
+        }
+
+    if(fType != cell->type)
+        goto FORMAT_DATA_ERROR;
+
+    /* printf("stream>%s< with >%s<\n", (char *)cell->contents, fmt); */
+    varPrintf((UINT)&fmtStream, fmt, cell->contents);
+
+    NEXT_FORMAT:
+    *nextfmt = saveChar;
+    fmt = nextfmt;
+    params = params->next;
+    continue;
+
+    FORMAT_DATA_ERROR:
+    *nextfmt = saveChar;
+    closeStrStream(&fmtStream);
+    return(errorProcExt(ERR_FORMAT_DATA_TYPE, params));
+    }
+
+getFormatType(fmt, &fType);
+if(fType != 0)
+    {
+    closeStrStream(&fmtStream);
+    errorProcExt2(ERR_NUM_ARGS, stuffString(format));
+    }
+
+varPrintf((UINT)&fmtStream, fmt);
+
+cell = makeStringCell(fmtStream.buffer, fmtStream.position);
+
+symbolCheck = NULL;
+return(cell);
+}
+
+void openStrStream(STREAM * stream, size_t buffSize, int reopenFlag)
+{
+if(stream->buffer != NULL && reopenFlag)
+    {
+    if(buffSize == stream->size)
+        {
+        memset(stream->buffer, 0, buffSize);
+        stream->position = stream->handle = 0;
+        stream->ptr = stream->buffer;
+        return;
+        }
+    }
+
+freeMemory(stream->buffer);
+stream->buffer = stream->ptr = callocMemory(buffSize + 1);
+stream->size = buffSize;    
+stream->position = stream->handle = 0;
+}
+
+void closeStrStream(STREAM * stream)
+{
+if(stream->buffer != NULL)
+    freeMemory(stream->buffer);
+stream->buffer = stream->ptr = NULL;
+stream->size = stream->position = 0;
+if(stream->handle != 0)
+    {
+    close((int)stream->handle);
+    stream->handle = 0;
+    }
+}
+
+char * cellToString(CELL * cell, size_t * size, int quoteFlag)
+{
+static STREAM strStream = {NULL, NULL, 0, 0, 0};
+
+if(cell->type == CELL_STRING)
+    {
+    *size = cell->aux -1;
+    return((char *)cell->contents);
+    }
+
+openStrStream(&strStream, MAX_STRING, TRUE);
+prettyPrintFlags |= PRETTYPRINT_STRING;
+printCell(cell , quoteFlag, (UINT)&strStream);
+prettyPrintFlags &= ~PRETTYPRINT_STRING;
+*size = strStream.position;
+
+return(strStream.buffer);
+}
+    
+
+void writeStreamChar(STREAM * stream, char chr)
+{
+if(stream->position == stream->size)
+    {
+    stream->size += stream->size / 2;
+    stream->buffer = reallocMemory(stream->buffer, stream->size + 1);
+    memset(stream->buffer + stream->position, 0, stream->size - stream->position + 1);
+    stream->ptr = stream->buffer + stream->position;
+    }
+*(stream->ptr++) = chr;
+stream->position++;
+}
+
+
+void writeStreamStr(STREAM * stream, char * buff, size_t length)
+{
+size_t newPosition;
+
+if(length == 0) length = strlen(buff);
+newPosition = stream->position + length;
+
+if(newPosition >=  stream->size)
+    {
+    while(newPosition >= stream->size)
+        stream->size += stream->size / 2;
+    stream->buffer = reallocMemory(stream->buffer, stream->size + 1);
+    memset(stream->buffer + stream->position, 0, stream->size - stream->position + 1);
+    stream->ptr = stream->buffer + stream->position;
+    }
+    
+memcpy(stream->ptr, buff, length);
+stream->ptr += length;
+stream->position = newPosition;
+}
+
+
+/* creates a memory buffer and reads byte into it until  
+   the [/text] is found 
+*/
+
+#define LLEN 7
+#define LIMIT "[/text]"
+
+char * readStreamText(STREAM * stream, int * size)
+{
+STREAM outStream = {NULL, NULL, 0, 0, 0};
+ssize_t findPos = -1;
+size_t searchLen;
+char * result;
+
+openStrStream(&outStream, MAX_STRING, 0);
+while(findPos == -1)
+    {
+    if((searchLen = strlen(stream->ptr)) < LLEN)
+        break;
+    findPos = searchBuffer(stream->ptr, searchLen, LIMIT, LLEN, TRUE);
+    if(findPos != -1)
+        {
+        if(findPos > 0) 
+            writeStreamStr(&outStream, stream->ptr, findPos);
+        stream->ptr += findPos + LLEN;
+        result = allocMemory(outStream.position + 1);
+        memcpy(result, outStream.buffer, outStream.position);
+        *size = outStream.position;
+        *(result + outStream.position) = 0; 
+        closeStrStream(&outStream);
+        return(result);
+        }
+
+    writeStreamStr(&outStream, stream->ptr, searchLen - LLEN);
+
+    stream->position += (stream->ptr - stream->buffer); 
+
+    stream->position += searchLen - LLEN;
+
+    if(stream->handle == 0) /* its not a file */
+        {
+        stream->buffer = stream->ptr;
+        break;
+        }
+    else
+        {
+        if(searchLen == LLEN) break;
+        lseek(stream->handle, stream->position, SEEK_SET);
+        memset(stream->buffer, 0, stream->size + 1);
+        if(read(stream->handle, stream->buffer, stream->size) > 0)
+            stream->ptr = stream->buffer;
+        else 
+            {
+            *stream->ptr = 0; 
+            break;
+            }
+        }
+    }
+
+closeStrStream(&outStream);
+
+return(NULL);
+}
+
+
+/* this is only used for reading with getToken()
+   stream->size does not reflect the real size of
+   the buffer as in makeStreamFromFile() 
+*/
+int makeStreamFromString(STREAM * stream, char * str)
+{
+int len = strlen(str);
+
+stream->handle = stream->position = 0;
+stream->buffer = stream->ptr = str;
+/* make getToken work to the end of str */
+stream->size = len + 4 * MAX_STRING;
+
+return(len);
+}
+
+int makeStreamFromFile(STREAM * stream, char * fileName, size_t size, size_t offset)
+{
+int result;
+
+if((stream->handle = openFile(fileName, "r", NULL)) == -1)
+    return(0);
+
+stream->ptr = stream->buffer = (char *)callocMemory(size + 1);
+if(offset != 0)
+    lseek((int)stream->handle, offset, SEEK_SET);
+
+stream->position = offset;
+stream->size = size;
+
+/* load first buffer */
+if((result = read(stream->handle, stream->buffer, size)) < 0)
+    {
+    closeStrStream(stream);
+    return(0);
+    }
+
+return(TRUE);
+}
+
+
+ssize_t searchBuffer(char * buffer,  size_t length, char * string, size_t size, int caseFlag)
+{
+size_t position = 0;
+
+if(caseFlag == FALSE)
+    {
+    while(position < length)
+        {
+        if(toupper(*buffer) == toupper(*string))
+            if(my_strnicmp(buffer, string, size) == 0) break;
+        position++;
+        buffer++;
+        }
+    }
+else /* case sensitive */
+    {
+    while(position < length)
+        {
+        if(*buffer == *string)
+            if(memcmp(buffer, string, size) == 0) break;
+        position++;
+        buffer++;
+        }
+    }
+
+if(position == length) return(-1);
+return(position);
+}
+
+/* eliminated in v.8.4.1
+CELL * patternMatchS(char * pattern, char * string)
+{
+CELL * cell;
+CELL * match;
+CELL * star, * plus;
+char * start;
+int starLen, len;
+
+start = string; starLen = len = 0;
+MATCH:
+switch(*pattern)
+    {
+    case '\\':
+        ++pattern;
+        if(*pattern != *string) return(nilCell);
+        break;
+    case 0:
+        if(*string != 0) return(nilCell);
+        return(stuffStringN(start, len));
+    case '?':
+        if(*string == 0) return(nilCell);
+        break;
+    case '#':
+        if(*string == 0) return(nilCell);
+        if(!isDigit((unsigned char)*string)) return(nilCell);
+        break;
+
+    case '+':   
+        if(*(pattern + 1) == 0)
+            {
+            if(*string == 0)
+                plus = stuffString("");
+            else if(*(string + 1) == 0)
+                plus = stuffStringN(string, 1);
+            else return(nilCell);
+
+            if(len == 0) return(plus);
+            cell = stuffStringN(start, len);
+            cell->next = plus;
+            return(cell);
+            }
+            
+        if((match = patternMatchS(pattern+1, string)) != nilCell)
+            plus = stuffString("");
+        else if((match = patternMatchS(pattern+1, string+1)) != nilCell)
+            plus = stuffStringN(string, 1);
+        else return(nilCell);
+            
+        if(len == 0) cell = plus;
+        else
+            {
+            cell = stuffStringN(start, len);
+            cell->next = plus;
+            }
+        plus->next = match;
+        return(cell);
+
+    case '*':
+        if(*(pattern + 1) == 0)
+            {
+            if(len == 0) return(stuffString(string));
+            cell = stuffStringN(start, len);
+            cell->next = stuffString(string);
+            return(cell);
+            }
+
+        if((match = patternMatchS(pattern+1, string)) != nilCell)
+            {
+            star = stuffStringN(start+len, starLen);
+            if(len == 0) cell = star;
+            else
+                {
+                cell = stuffStringN(start, len);
+                cell->next = star;
+                }
+            star->next = match;
+            return(cell);
+            }
+
+        if(*string != 0) ++string, ++starLen;
+        else return(nilCell);
+        goto MATCH;
+
+    default:
+        if(*pattern != *string) return(nilCell);
+        break;
+    }
+++pattern;
+++string;
+++len;
+goto MATCH;
+}
+*/
+
+
+CELL * p_integer(CELL * params)
+{
+char * intString;
+INT64 num;
+INT base;
+CELL * deflt, * cell;
+INT64 result;
+
+deflt = getEvalDefault(params, &cell);
+symbolCheck = NULL;
+
+if(cell->type == CELL_STRING)
+    intString = (char *)cell->contents;
+else if(isNumber(cell->type))
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        num = bigintToInt64(cell);
+    else
+#endif
+    getInteger64Ext(cell, &num, FALSE);
+    return(stuffInteger64(num));
+    }
+else 
+    return(copyCell(evaluateExpression(deflt)));
+
+while(isspace((int)*intString)) intString++;
+if(deflt->next != nilCell)
+    getInteger(deflt->next, (UINT *)&base);
+else base = 0;
+
+if(base == 16)
+    {
+    if(!isxdigit((unsigned char)*intString))
+        {
+        if(*intString != '-' && *intString != '+')
+            goto INT_DEFAULT;
+        if(!isxdigit((unsigned char)*(intString+1)))
+            goto INT_DEFAULT;
+        }
+    }
+else if(!isDigit((unsigned char)*intString))
+    {
+    if(*intString != '-' && *intString != '+')
+        goto INT_DEFAULT;
+    if(!isDigit((unsigned char)*(intString+1)))
+        goto INT_DEFAULT;
+    }
+
+else if(*intString == '0' && (*(intString + 1) == 'b' || *(intString + 1) == 'B'))
+    {
+    intString += 2;
+    base = 2;
+    }
+     
+#ifdef TRU64 
+result = strtoul(intString, NULL, base); 
+#else 
+result = strtoull(intString,(char **)0, base); 
+#endif 
+    
+return(stuffInteger64(result)); 
+INT_DEFAULT:
+return(copyCell(evaluateExpression(deflt)));
+}
+
+CELL * p_float(CELL * params)
+{
+char * fltString;
+double value;
+CELL * deflt;
+CELL * cell;
+
+deflt = getEvalDefault(params, &cell);
+symbolCheck = NULL;
+
+if(cell->type == CELL_STRING)
+    fltString = (char *)cell->contents;
+else if(isNumber(cell->type))
+    {
+#ifdef BIGINT
+    if(cell->type == CELL_BIGINT)
+        value = bigintCellToFloat(cell);
+    else
+#endif
+    getFloat(cell, &value);
+    return(stuffFloat(value));
+    }
+else
+    return(copyCell(evaluateExpression(deflt)));
+
+while(isspace((int)*fltString)) fltString++;
+if(!isDigit((unsigned char)*fltString))
+    {
+    if(*fltString != '-' && *fltString != '+' && *fltString != lc_decimal_point)
+        return(copyCell(evaluateExpression(deflt)));
+    if(!isDigit((unsigned char)*(fltString+1)))
+        return(copyCell(evaluateExpression(deflt)));
+    }
+
+value = atof(fltString);
+return( stuffFloat(value) );
+}
+
+
+CELL * p_symbol(CELL * params)
+{
+char * token;
+char number[32];
+SYMBOL * context;
+SYMBOL * sPtr;
+CELL * cell;
+
+
+cell = evaluateExpression(params);
+switch(cell->type)
+    {
+    case CELL_LONG:
+        snprintf(number, 30, "%"PRIdPTR, cell->contents);
+        token = number;
+        break;
+#ifndef NEWLISP64
+    case CELL_INT64:
+        token = number;
+        snprintf(number, 30, "%"PRId64, *(INT64 *)&cell->aux);
+        break;
+#endif /* NEWLISP64 */
+    case CELL_FLOAT:
+#ifndef NEWLISP64
+        snprintf(number, 30, "%1.10g",*(double *)&cell->aux);
+#else
+        snprintf(number, 30, "%1.10g",*(double *)&cell->contents);
+#endif
+        token = number;
+        break;
+    case CELL_STRING:
+        token = (char*)cell->contents;
+        if((cell->aux - 1) > MAX_SYMBOL)
+            errorProcExt(ERR_STRING_TOO_LONG, cell);
+        break;
+    case CELL_SYMBOL:
+        sPtr = (SYMBOL*)cell->contents;
+        token = sPtr->name;
+        break;
+    default:
+        return(errorProcExt(ERR_NUMBER_OR_STRING_EXPECTED, params));
+    }
+
+if((params = params->next) == nilCell)
+    context = currentContext;
+else if((context = getCreateContext(params, TRUE)) == NULL)
+    return(errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, params));
+
+if(params->next != nilCell)
+    {
+    cell = evaluateExpression(params->next);
+    if(isNil(cell))
+        {
+        sPtr = lookupSymbol(token, context);
+        if(sPtr == NULL) return(nilCell);
+        return(stuffSymbol(sPtr));
+        }
+    }
+
+sPtr = translateCreateSymbol(token, CELL_NIL, context, TRUE);
+return(stuffSymbol(sPtr));
+}
+
+
+CELL * p_symbolSource(CELL * params)
+{
+STREAM strStream = {NULL, NULL, 0, 0, 0};
+CELL * cell;
+
+openStrStream(&strStream, MAX_STRING, 0);
+serializeSymbols(params, (UINT)&strStream);
+cell = stuffString(strStream.buffer);
+closeStrStream(&strStream);
+return(cell);
+}
+
+
+CELL * p_string(CELL * params)
+{
+CELL * cell;
+STREAM strStream = {NULL, NULL, 0, 14, 0};
+
+strStream.buffer = strStream.ptr = callocMemory(15);
+prettyPrintFlags |= PRETTYPRINT_STRING;
+while (params != nilCell)
+    {
+    cell = evaluateExpression(params);
+    if(cell->type == CELL_STRING) /* speed optimization for strings */
+        writeStreamStr(&strStream, (char *)cell->contents, 0);
+    else
+        printCell(cell , FALSE, (UINT)&strStream);                                                    
+    params = params->next;
+    }
+prettyPrintFlags &= ~PRETTYPRINT_STRING;
+
+/* cell = stuffStringN(strStream.buffer, strStream.position); */
+cell = makeStringCell(strStream.buffer, strStream.position);
+
+return(cell);
+}
+
+
+UINT getAddress(CELL * params)
+{
+UINT num;
+
+
+if(params == nilCell)
+    {
+    errorProc(ERR_MISSING_ARGUMENT);
+    return(0);
+    }
+
+getEvalDefault(params, &params);
+
+#ifndef NEWLISP64
+if(params->type == CELL_INT64)
+    {
+    num = *(INT64 *)&params->aux;
+    return(num);
+    }
+else if(params->type == CELL_FLOAT)
+    {
+    num = *(INT64 *)&params->aux;
+    return(num);
+    }
+#else
+if(params->type == CELL_FLOAT)
+    {
+    num = *(double *)&params->contents;
+    return(num);
+    }
+#endif
+
+return(params->contents);
+}
+
+CELL * p_getChar(CELL * params)
+{
+return(stuffInteger((UINT)*(char*)getAddress(params)));
+}
+
+CELL * p_getString(CELL * params)
+{
+UINT size, len;
+UINT address;
+UINT offset = 0;
+int inc = 1;
+char * limit;
+char zeros[4] = {0,0,0,0};
+
+address = getAddress(params);
+if(address == 0)
+    errorProc(ERR_CANNOT_CONVERT_NULL);
+
+/* (get-string <address>) ; get zero terminated ASCII or UTF-8 */ 
+if(params->next == nilCell) 
+    return(stuffString((char *)address));
+
+params = getInteger(params->next, &size);
+/* (get-string <address> <int-bytes>) ; get no bytes binary data */
+if(params == nilCell) 
+    return(stuffStringN((char *)address, size));
+
+getStringSize(params, &limit, (size_t *)&len, TRUE);
+/* (get-string <address> <int-bytes> <str-limit>) ; get until limit or bytes read */
+if(len == 4 || len == 2) if(memcmp(limit, zeros, len) == 0) inc = len;
+while(offset < size)
+    {
+    if(offset < (size - len) &&
+        memcmp((char *)(address + offset), limit, len) == 0) break;
+    offset += inc;
+    }
+
+/* printf("size: %ld, len: %ld, inc: %d, offset: %ld\n", size, len, inc, offset); */
+
+return(stuffStringN((char *)address, offset));
+}
+
+CELL * p_getInteger(CELL * params)
+{
+return(stuffInteger(*(int *)getAddress(params)));
+}
+
+CELL * p_getLong(CELL * params)
+{
+return(stuffInteger64(*(INT64 *)getAddress(params)));
+}
+
+CELL * p_getFloat(CELL * params)
+{
+return(stuffFloat(*(double*)getAddress(params)));
+}
+
+CELL * p_address(CELL * params)
+{
+if(params == nilCell)
+    return(errorProc(ERR_MISSING_ARGUMENT));
+
+getEvalDefault(params, &params);
+
+switch(params->type)
+    {
+    case CELL_LONG:
+        return(stuffInteger((UINT)&params->contents));
+#ifndef NEWLISP64
+    case CELL_INT64:
+    case CELL_FLOAT:
+        return(stuffInteger((UINT)&params->aux));
+#else
+    case CELL_FLOAT:
+        return(stuffInteger((UINT)&params->contents));
+#endif
+    default:
+        break;
+    }
+
+return(stuffInteger(params->contents));
+}
+
+
+CELL * p_copyMemory(CELL * params)
+{
+UINT toAddress, fromAddress, nBytes;
+CELL * cell;
+
+cell = evaluateExpression(params);
+params = params->next;
+fromAddress = getAddress(cell);
+
+cell = evaluateExpression(params);
+toAddress = getAddress(cell);
+
+getInteger(params->next, &nBytes);
+
+memcpy((char*)toAddress, (char*)fromAddress, nBytes);
+
+return(stuffInteger(nBytes));
+}
+
+
+CELL * cellTokenString(char * * source, size_t * srclen, char * separator, pcre * re)
+{
+char * start;
+char * src;
+ssize_t len, slen;
+int ovector[OVECCOUNT];
+int rc;
+
+if(*source == NULL) return(stuffString(""));
+start = src = *source;
+len = 0;
+slen = strlen(separator);
+
+if(re == NULL)
+    {
+    while(*src != 0)
+    {
+        if(*src == *separator)
+            {
+            if(strncmp(src, separator, slen) == 0)
+                {
+                *source = src+slen;
+                if(**source == 0) /* last token is separator */
+                     *source = NULL;
+                return(stuffStringN(start, len));
+                }
+            }
+    src++;
+    len++;
+        }
+    *source = src;
+    if(len == 0) return(NULL);
+    return(stuffStringN(start, len));
+    }
+else  if(*src != 0)
+    {
+    len = *srclen;
+    rc = pcre_exec(re, NULL, src, len, 0, 0, ovector, OVECCOUNT);
+
+    /* matching failed */
+    if (rc == -1)  
+        {
+        *source = src + len;
+        return(stuffStringN(src, len));
+        }
+
+    /* error in pcre_exec() */
+    if (rc < 0) 
+        regexError("error", rc, "when executing");
+
+    *source = src + ovector[1];
+    *srclen -= ovector[1];
+    if(**source == 0) /* last token is separator */
+        *source = NULL;
+
+    if(ovector[1] - ovector[0] == 0)
+        return(NULL);
+
+    return(stuffStringN(src, ovector[0]));
+    }
+
+return(NULL);
+}
+
+
+CELL * p_parse(CELL * params)
+{
+CELL * cell;
+CELL * newCell;
+CELL * result;
+char * string;
+char * separator;
+char token[MAX_STRING];
+STREAM stream = {NULL, NULL, 0, 0, 0};
+int tklen;
+size_t srclen;
+/* PCRE stuff */
+INT options = 0;
+pcre *re = NULL;
+
+params = getStringSize(params, &string, &srclen, TRUE);
+if(params == nilCell) separator = NULL;
+else 
+    {
+    params = getString(params, &separator);
+    if(params != nilCell) 
+        {
+        /* 10.6.1 also accept string for options */
+        parseRegexOptions(params, (UINT *)&options, TRUE);
+        /* Compile the regular expression in separator */
+        re = pcreCachedCompile(separator, options); 
+        }
+    else re = NULL;
+    }
+
+if(separator == NULL) 
+    makeStreamFromString(&stream, string);
+
+result = cell = getCell(CELL_EXPRESSION);
+while(string != NULL)
+    {
+    if(separator != NULL)
+        {
+        if((newCell = cellTokenString(&string, &srclen, separator, re)) == NULL)
+            break;
+        }
+    else
+        {
+        if(getToken(&stream, token, &tklen) == TKN_EMPTY) break;
+        newCell = stuffString(token);
+        }
+
+    if(cell == result)
+        result->contents = (UINT)newCell;
+    else 
+        cell->next = newCell;
+
+    cell = newCell;
+        if(string == NULL) 
+            newCell->next = stuffString("");
+    }
+
+return(result);
+}
+
+#define PACK_NONE 0
+#define PACK_CHAR 1
+#define PACK_BYTE 2
+#define PACK_INT 3
+#define PACK_UNSIGNED_INT 4
+#define PACK_LONG 5
+#define PACK_UNSIGNED_LONG 6
+#define PACK_LONG_LONG 7
+#define PACK_UNSIGNED_LONG_LONG 8
+#define PACK_FLOAT 9
+#define PACK_DOUBLE 10
+#define PACK_STRING 11
+#define PACK_NULL 12
+#define PACK_BIG_ENDIAN 13
+#define PACK_LITTLE_ENDIAN 14
+
+
+void swapEndian(char * data, int n)
+{
+char tmp[8];
+int i;
+
+i = n;
+while(i) { tmp[n - i] = data[i - 1]; i--; }
+   
+memcpy(data, &tmp[0], n);
+}
+
+
+CELL * p_pack(CELL * params)
+{
+char * format;
+char * source;
+char * packed;
+char * pPtr;
+CELL * cell;
+ssize_t length, ln;
+int len, type;
+int listFlag = 0;
+int endianSwitch = 0;
+char chrV;
+unsigned char byteV;
+short int shortV;
+unsigned short int uint16V;  /* 16 bit */
+unsigned int uint32V;         /* 32 bit */
+unsigned long long  uint64V; /* 64 bit */
+float floatV;
+double doubleV;
+
+#ifdef FFI
+cell = evaluateExpression(params);
+params = params->next;
+if(cell->type == CELL_IMPORT_FFI)
+    return(packFFIstruct(cell, params)); /* nl-import.c */
+if(cell->type != CELL_STRING)
+    return(errorProc(ERR_INVALID_PARAMETER));
+format = (char *)cell->contents;
+#else
+params = getString(params, &format);
+#endif
+
+source = format;
+length = 0;
+while((source = parsePackFormat(source, &len, &type)) != NULL)
+    length += len;
+
+if(length == 0) return(stuffString(""));
+pPtr = packed = allocMemory(length);
+source = format;
+length = 0;
+
+while((source = parsePackFormat(source, &len, &type)) != NULL)
+    {
+    if(type == PACK_NULL)
+        {
+        memset(pPtr, 0, len);
+        pPtr += len;
+        length += len;
+        continue;
+        }
+        
+    else if(type == PACK_LITTLE_ENDIAN || type == PACK_BIG_ENDIAN)
+        {
+        endianSwitch = ((type == PACK_BIG_ENDIAN) != bigEndian);
+        continue;
+        }
+
+    if(params->type == CELL_NIL) break;
+    if(listFlag)
+        cell = params;
+    else
+        cell = evaluateExpression(params);
+    /* accept data in a list */
+    if(isList(cell->type))
+        {
+        cell = (CELL *)cell->contents;
+        params = cell;
+        listFlag = 1;
+        }
+#ifndef NEWLISP64
+    if(cell->type == CELL_FLOAT || cell->type == CELL_INT64)
+        uint64V = *(INT64 *)&cell->aux;
+    else /* CELL_LONG and CELL_STRING */
+        uint64V = cell->contents;
+#else
+    uint64V = cell->contents;
+#endif
+
+    if(type < PACK_FLOAT && cell->type == CELL_FLOAT)
+        uint64V = *(double *)&cell->aux;
+    
+    switch(type)
+        {
+        case PACK_NONE:
+            break;
+
+        case PACK_BYTE:
+            byteV = (char)uint64V;
+            memcpy(pPtr, &byteV, 1);
+            break;
+
+        case PACK_CHAR:
+            chrV = (char)uint64V;
+            memcpy(pPtr, &chrV, 1);
+            break;
+
+        case PACK_INT:
+            shortV = (short int)uint64V;
+            memcpy(pPtr, &shortV, 2);
+            if(endianSwitch) swapEndian(pPtr, 2);
+            break;
+
+        case PACK_UNSIGNED_INT:
+            uint16V = (unsigned short int)uint64V;
+            memcpy(pPtr, &uint16V, 2);
+            if(endianSwitch) swapEndian(pPtr, 2);
+            break;
+
+        case PACK_LONG:
+        case PACK_UNSIGNED_LONG:
+            uint32V = (unsigned int)uint64V;
+            memcpy(pPtr, &uint32V, 4);
+            if(endianSwitch) swapEndian(pPtr, 4);
+            break;
+
+        case PACK_LONG_LONG:
+        case PACK_UNSIGNED_LONG_LONG:
+            memcpy(pPtr, &uint64V, 8);
+            if(endianSwitch) swapEndian(pPtr, 8);
+            break;
+
+        case PACK_FLOAT:
+        case PACK_DOUBLE:
+            if(cell->type == CELL_FLOAT)
+                doubleV = *(double *)&uint64V;
+            else doubleV = (double)uint64V;
+            if(type == PACK_FLOAT)
+                {
+                floatV = doubleV;
+                memcpy(pPtr, &floatV, 4);
+                if(endianSwitch) swapEndian(pPtr, 4);
+                }
+            else
+                {
+                memcpy(pPtr, &doubleV, 8);
+                if(endianSwitch) swapEndian(pPtr, 8);
+                }
+            break;
+            
+        case PACK_STRING:
+            if(cell->type == CELL_STRING)
+                {
+                ln = cell->aux - 1;
+                if(len <= ln)
+                    memcpy(pPtr, (void *)cell->contents, len);
+                else
+                    {
+                    memcpy(pPtr, (void*)cell->contents, ln);
+                    memset(pPtr + ln, 0, len - ln);
+                    }
+                }
+            else memset(pPtr,  0, len);
+            break;
+
+        default:
+            break;
+        }
+
+    pPtr += len;
+    params = params->next;
+    length += len;
+    }
+
+cell = stuffStringN(packed, length);
+free(packed);
+return(cell);
+}
+
+
+char * parsePackFormat(char * format, int * length, int * type)
+{
+*length = 0;
+while(*format == ' ') format++;
+
+if(*format == 0) return(NULL);
+
+switch(*format)
+    {
+    case '<':
+        *type = PACK_LITTLE_ENDIAN;
+        format++;
+        break;
+            
+    case '>':
+        *type = PACK_BIG_ENDIAN;
+        format++;
+        break;
+                
+    case 'b':
+        *length = 1;    
+        *type = PACK_BYTE;
+        format++;
+        break;
+
+    case 'c':
+        *length = 1;    
+        *type = PACK_CHAR;
+        format++;
+        break;
+    case 's':
+    case 'n':
+        *type = (*format == 's') ? PACK_STRING : PACK_NULL;
+        format++;
+        if(isdigit((int)*format) )
+            {
+            *length = atol(format);
+            while(isdigit((int)*format)) format++;
+            }
+        else *length = 1;
+        
+        break;
+    case 'd':
+    case 'u':
+        *type = (*format == 'd') ? PACK_INT : PACK_UNSIGNED_INT;
+        *length = 2;
+        format++;
+        break;
+    case 'l':
+        if(*(format + 1) == 'd' || *(format + 1) == 'u')
+            {
+            *length = 4;
+            *type = (*(format + 1) == 'd') ? PACK_LONG : PACK_UNSIGNED_LONG;
+            format += 2;
+            }
+        else if(*(format + 1) == 'f')
+            {
+            *length = 8;
+            *type = PACK_DOUBLE;
+            format += 2;
+            }
+        else 
+            {
+            *type = PACK_NONE;
+            format++;
+            }
+        break;
+    case 'L':
+        if(*(format + 1) == 'd' || *(format + 1) == 'u')
+            {
+            *length = 8;
+            *type = (*(format + 1) == 'd') ? PACK_LONG_LONG : PACK_UNSIGNED_LONG_LONG;
+            format += 2;
+            }
+        else 
+            {
+            *type = PACK_NONE;
+            format++;
+            }
+        break;
+    case 'f':
+        *length = 4;
+        *type = PACK_FLOAT;
+        format++;
+        break;
+    default:
+        *type = PACK_NONE;
+        format++;
+        break;
+    }
+
+return(format);
+}
+
+
+CELL * p_unpack(CELL * params)
+{
+CELL * cell;
+char * format;
+char * source;
+char * pPtr;
+CELL * result;
+CELL * next = NULL;
+size_t length, maxlen;
+int len;
+int type;
+int endianSwitch = 0;
+char chrV;
+unsigned char byteV;
+short shortV;
+unsigned short uint16V;
+int int32V;
+unsigned int uint32V;
+unsigned long long int uint64V;
+float floatV;
+double doubleV;
+
+cell = evaluateExpression(params->next);
+if(cell->type == CELL_STRING)
+    {
+    pPtr = (char *)cell->contents; 
+    maxlen = cell->aux - 1;
+    }
+else
+    {
+    getIntegerExt(cell, (void*)&pPtr, FALSE);
+    maxlen = MAX_LONG;
+    }
+
+#ifdef FFI
+cell = evaluateExpression(params);
+if(cell->type == CELL_IMPORT_FFI)
+    return(unpackFFIstruct(cell, pPtr)); /* nl-import.c */
+if(cell->type != CELL_STRING)
+    return(errorProc(ERR_INVALID_PARAMETER));
+format = (char *)cell->contents;
+#else
+params = getString(params, &format);
+#endif
+
+    
+length = 0;
+source = format;
+result = getCell(CELL_EXPRESSION);
+next = NULL;
+
+while( (source = parsePackFormat(source, &len, &type))!= NULL)
+    {
+    if(length + len > maxlen) break;
+
+    if(type == PACK_LITTLE_ENDIAN || type == PACK_BIG_ENDIAN)
+        {
+        endianSwitch = ((type == PACK_BIG_ENDIAN) != bigEndian);
+        continue;
+        }
+                
+    switch(type)
+        {       
+        case PACK_NULL:
+            pPtr += len;
+            length += len;
+            continue;
+    
+        case PACK_BYTE:
+            memcpy(&byteV, pPtr, 1);
+            cell = makeCell(CELL_LONG, byteV);
+            break;
+
+        case PACK_CHAR:
+            memcpy(&chrV, pPtr, 1);
+            cell = makeCell(CELL_LONG, chrV);
+            break;
+
+        case PACK_INT:
+            memcpy(&shortV, pPtr, 2);
+                if(endianSwitch) swapEndian((char*)&shortV, 2);
+            cell = makeCell(CELL_LONG, shortV);
+            break;
+
+        case PACK_UNSIGNED_INT:
+            memcpy(&uint16V, pPtr, 2);
+                if(endianSwitch) swapEndian((char*)&uint16V, 2);
+            cell = makeCell(CELL_LONG, uint16V);
+            break;
+
+        case PACK_LONG:
+            memcpy(&int32V, pPtr, 4);
+            if(endianSwitch) swapEndian((char *)&int32V, 4);
+#ifndef NEWLISP64
+            cell = getCell(CELL_INT64);
+            *(INT64 *)&cell->aux = int32V;
+#else
+            cell = getCell(CELL_LONG);
+            *(INT *)&cell->contents = int32V;
+#endif
+            break;
+
+        case PACK_UNSIGNED_LONG:
+            memcpy(&uint32V, pPtr, 4);
+            if(endianSwitch) swapEndian((char*)&uint32V, 4);
+#ifndef NEWLISP64
+            cell = getCell(CELL_INT64);
+            *(INT64 *)&cell->aux = uint32V;
+#else
+            cell = makeCell(CELL_LONG, uint32V);
+#endif
+            break;
+
+        case PACK_LONG_LONG:
+        case PACK_UNSIGNED_LONG_LONG:
+            memcpy(&uint64V, pPtr, 8);
+                if(endianSwitch) swapEndian((char*)&uint64V, 8);
+#ifndef NEWLISP64
+            cell = getCell(CELL_INT64);
+            memcpy(&cell->aux, &uint64V, 8);
+#else
+            cell = makeCell(CELL_LONG, uint64V);
+#endif
+            break;
+
+        case PACK_FLOAT:
+            memcpy(&floatV, pPtr, 4);
+                if(endianSwitch) swapEndian((char*)&floatV, 4);
+            doubleV = floatV;
+            cell = stuffFloat(doubleV);
+            break;
+
+        case PACK_DOUBLE:
+            memcpy(&doubleV, pPtr, 8);
+            if(endianSwitch) swapEndian((char*)&doubleV, 8);
+            cell = stuffFloat(doubleV);
+            break;
+            
+        case PACK_STRING:
+            if(pPtr == NULL)
+                errorProc(ERR_CANNOT_CONVERT_NULL);
+
+            cell = stuffStringN(pPtr, len);
+            break;
+
+        default:
+            cell = getCell(CELL_NIL);
+            break;
+        }
+
+    pPtr += len; length += len;
+    if(next == NULL)
+        result->contents = (UINT)cell;
+    else    
+        next->next = cell;
+    
+    next = cell;
+    }
+
+return(result);
+}
+
+
+CELL * p_trim(CELL * params)
+{
+char * str;
+char * ptr;
+size_t left = 0, right = 0, len;
+char * trimChr;
+int lchr, rchr;
+#ifdef SUPPORT_UTF8
+int * wstr;
+int * wptr;
+CELL * result;
+#endif
+
+params = getStringSize(params, &str, &len, TRUE);
+if(params == nilCell)   
+    {
+    ptr = str;
+    while((unsigned char)*str <= 32 && *str != 0) str++, left++;
+    if(left == len) 
+        return(stuffString(""));
+    str = ptr + len -1;
+    while((unsigned char)*str <= 32) str--, right++;
+    return(stuffStringN(ptr + left, len - left - right));
+    }
+
+#ifndef SUPPORT_UTF8
+ptr = str;
+#else
+len = utf8_wlen(str, str + len + 1);
+wptr = wstr = allocMemory((len + 1) * sizeof(int));
+len = utf8_wstr(wstr, str, len);
+#endif
+
+if(len == 0)
+    return(stuffString(str));
+
+params = getString(params, &trimChr);
+#ifndef SUPPORT_UTF8
+lchr = *trimChr;
+#else
+utf8_wchar(trimChr, &lchr);
+#endif
+if(params != nilCell)
+    {
+    getString(params, &trimChr);
+#ifndef SUPPORT_UTF8
+    rchr = *trimChr;
+#else
+    utf8_wchar(trimChr, &rchr);
+#endif
+    }       
+else rchr = lchr;
+
+#ifndef SUPPORT_UTF8
+while(*str == lchr) str++, left++;
+#else
+while(*wstr == lchr) wstr++, left++;
+#endif
+
+if(left == len)
+    return(stuffString(""));
+
+#ifndef SUPPORT_UTF8
+str = ptr + len - 1;
+while(*str == rchr && right < len) str--, ++right;
+
+return(stuffStringN(ptr + left, len - left - right));
+
+#else
+
+wstr = wptr + len - 1;
+while(*wstr == rchr && right < len) wstr--, ++right;
+
+*(wptr + len - right) = 0;
+
+str = allocMemory((len - left - right + 1) * UTF8_MAX_BYTES);
+len = wstr_utf8(str, wptr + left, (len - left - right) * UTF8_MAX_BYTES);
+free(wptr);
+result = stuffStringN(str, len);
+free(str);
+return(result);
+#endif
+
+}
+
+
+
+/* ------- PRCE Perl Compatible Regular Expressions for all platforms ------- */
+/*                    see also http://www.pcre.org/                           */
+
+/* currently PCRE v.5.0 from 13-Sep-2004  -> pcre.h */
+
+/* additional regex option */
+#define REPLACE_ONCE 0x8000
+#define PRECOMPILED 0x10000
+
+void regexError(char * msg_1, int num, const char * msg_2);
+
+/* PCRE options from manual not allowed from newLISP regex options in pcre_compile() */
+#define PCRE_NOT_COMPILE (PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY)
+
+/* PCRE options from manual allowed for pcre_exec() */
+#define PCRE_EXEC_OPTIONS (PCRE_ANCHORED | PCRE_NOTBOL | PCRE_NOTEOL | PCRE_NOTEMPTY)
+
+
+CELL * p_regex(CELL * params)
+{
+pcre *re;
+int ovector[OVECCOUNT];
+int rc, idx;
+char * pattern;
+char * subject;
+#ifdef SUPPORT_UTF8
+char * string;
+#endif
+INT options = 0;
+UINT offset = 0;
+int len;
+size_t size;
+CELL * cell, * result, * strCell;
+
+params = getString(params, &pattern);
+params = getStringSize(params, &subject, &size, TRUE);
+
+if(params != nilCell)
+    {
+    /* 10.6.1 also accept string for options */
+    params = parseRegexOptions(params, (UINT *)&options, TRUE);
+    if(params != nilCell)
+        getInteger(params, &offset);
+    }
+
+
+/* Compile the regular expression in the first argument */
+re = pcreCachedCompile(pattern, (int)options);
+
+/* Compilation succeeded: match the subject in the second argument */
+rc = pcre_exec(
+    re,            /* the compiled pattern */
+    NULL,          /* no extra data - we didn't study the pattern */
+    subject,       /* the subject string */
+    size,          /* the length of the subject */
+    (int)offset,   /* start at offset 0 in the subject */
+    (int)options & PCRE_EXEC_OPTIONS, 
+    ovector,       /* output vector for substring information */
+    OVECCOUNT);    /* number of elements in the output vector */
+
+/* Matching failed */
+if (rc == -1)
+    return(nilCell);
+
+/* error in pcre_exec() */
+if (rc < 0) 
+    regexError("error", rc, "when executing");
+
+/* Match succeded */
+
+/* Show substrings stored in the output vector */
+result = cell = getCell(CELL_EXPRESSION);
+for(idx = 0; idx < rc; idx++)
+    {
+    len = ovector[2*idx+1] - ovector[2*idx];
+    strCell = stuffStringN(subject + ovector[2*idx], len);
+
+    deleteList((CELL*)sysSymbol[idx]->contents);
+    sysSymbol[idx]->contents = (UINT)copyCell(strCell);
+
+    if(idx == 0)
+        {
+        cell->contents = (UINT)strCell;
+        cell = (CELL *)cell->contents;
+        }
+    else    
+        {
+        cell->next = strCell;
+        cell = cell->next;
+        }
+
+#ifdef SUPPORT_UTF8
+    if(2048 & options)
+        cell->next = stuffInteger(utf8_wlen(subject, subject + ovector[2*idx] + 1));
+    else
+#endif
+    cell->next = stuffInteger(ovector[2*idx]);
+    cell = cell->next;
+#ifdef SUPPORT_UTF8
+    if(2048 & options)
+        {
+        string = (char *)strCell->contents;
+        cell->next = stuffInteger(utf8_wlen(string, string + len + 1));
+        }
+    else
+#endif
+    cell->next = stuffInteger(len);
+    cell = cell->next;
+    }
+
+return(result);
+}
+
+
+CELL * p_regexComp(CELL * params)
+{
+char * pattern;
+INT options = 0;
+pcre * re;
+int rc;
+size_t size;
+CELL * result;
+
+params = getString(params, &pattern);
+if(params != nilCell)
+    /* 10.6.1 also accept string for options */
+    params = parseRegexOptions(params, (UINT *)&options, TRUE);
+
+/* Compile the regular expression in the first argument */
+re = pcreCachedCompile(pattern, (int)options);
+rc = pcre_fullinfo(re, NULL, PCRE_INFO_SIZE, &size);
+
+if(rc < 0) return(nilCell);
+
+result = stuffStringN((char *)re, size);
+
+return(result);
+}
+
+
+ssize_t searchBufferRegex(char * string,  size_t offset, 
+                          char * pattern, size_t length, int options, size_t * len)
+{
+pcre *re;
+int ovector[OVECCOUNT];
+int rc, idx;
+CELL * cell;
+
+options &= ~REPLACE_ONCE ; /* turn custom bits off for PCRE */
+
+/* Compile the regular expression in the first argument */
+re = pcreCachedCompile(pattern, options);
+
+/* Compilation succeeded: match the subject in the second argument */
+rc = pcre_exec(re, NULL, string, length, offset, options & PCRE_EXEC_OPTIONS, ovector, OVECCOUNT);
+
+/* matching failed */
+if (rc == -1)  
+    return(-1);
+
+/* error in pcre_exec() */
+if (rc < 0) 
+    regexError("error", rc, "when executing");
+
+
+for(idx = 0; idx < rc; idx++)
+    {
+    cell = stuffStringN(string  + ovector[2*idx], ovector[2*idx+1] - ovector[2*idx]);
+    deleteList((CELL*)sysSymbol[idx]->contents);
+    sysSymbol[idx]->contents = (UINT)cell;
+    }
+
+if(len != NULL)
+    *len = ovector[1] - ovector[0];
+
+return((UINT)ovector[0]);
+}
+
+
+pcre * pcreCachedCompile(char * pattern, int options)
+{
+const char * error;
+int errOffset;
+static char * cPattern = NULL;
+static pcre * re = NULL;
+static int cacheOptions = -1;
+UINT len;
+
+if(options & 0x10000) return((pcre *)pattern);
+
+if((cPattern == NULL) || (strcmp(cPattern, pattern) != 0) || (options != cacheOptions))
+    {
+    cacheOptions = options;
+    if(cPattern != NULL) freeMemory(cPattern);
+    len = strlen(pattern);
+    cPattern = (char *)allocMemory(len + 1);
+    memcpy(cPattern, pattern, len + 1);
+    if(re != NULL) (pcre_free)(re);
+
+
+    options = options & ~PCRE_NOT_COMPILE;
+    re = pcre_compile(pattern, options, &error, &errOffset, NULL); 
+
+    /* Compilation failed: print the error message and exit */
+    if (re == NULL) 
+        {
+        freeMemory(cPattern);
+        cPattern = NULL;
+        regexError("offset", errOffset, error);
+        }
+    } 
+
+return(re);
+}
+    
+
+void regexError(char * msg_1, int number, const char * msg_2)
+{
+CELL * cell;
+char * errorBuff = malloc(256);
+snprintf(errorBuff, 256,  "%s %d %s", msg_1, number, msg_2);
+cell = stuffString(errorBuff);
+free(errorBuff);
+fatalError(ERR_REGEX, cell, 0);
+}
+
+
+
+/* replace string with or without (options = -1) regular expressions */
+
+typedef struct {
+    int offset;
+    int length;
+    char * repStr;
+    int repLen;
+    void * next;
+    } REGEX;
+
+void freeRegex(REGEX * regex);
+
+char * replaceString
+   (char * keyStr, size_t keyLen, char * buff, size_t buffLen, CELL * exprCell, 
+    UINT * cnt, int options, size_t * newLen)
+{
+ssize_t oldLen, findPos;
+size_t count, offset;
+size_t repLen;
+char * newBuff;
+CELL * cell;
+REGEX * start_rx = NULL, * end_rx = NULL;
+UINT * resultStackIdxSave;
+int errNo;
+int bias = 0;
+
+*newLen = oldLen = 0;
+*cnt = 0;
+offset = count = 0;
+
+/* save all found string and fill sys variables $0, $1 ... etc */
+while(offset <= buffLen)
+    {
+    if(options == -1)
+        findPos = searchBuffer(buff + offset, buffLen - offset, keyStr, keyLen, TRUE);
+    else
+        {
+        findPos = searchBufferRegex(buff, offset, keyStr, buffLen, options, &keyLen);
+        itSymbol->contents = sysSymbol[0]->contents;
+        }
+
+    if(findPos == -1) break;
+    
+    if(options != -1) findPos -= offset;
+
+    if(count == 0)
+        start_rx = end_rx = (REGEX *)callocMemory(sizeof(REGEX));
+    else
+        {
+        end_rx->next = callocMemory(sizeof(REGEX));
+        end_rx = end_rx->next;
+        }
+
+    end_rx->next = NULL;
+    end_rx->offset = findPos + offset; /* pos where pattern found */
+
+    resultStackIdxSave = resultStackIdx; 
+
+    countCell->contents++;
+    if((cell = evaluateExpressionSafe(exprCell, &errNo)) == NULL)
+        {
+        freeRegex(start_rx);
+        longjmp(errorJump, errNo);
+        }   
+
+    end_rx->length = keyLen;           /* length of pattern found */
+    if(cell->type == CELL_STRING)
+        {
+        repLen = end_rx->repLen = cell->aux-1;
+        end_rx->repStr = (char *)allocMemory(repLen + 1); /* replacement string */
+        memcpy(end_rx->repStr, (char *)cell->contents, cell->aux); 
+        }
+    else /* if replacement expression is not string leave old content */
+        {
+        repLen = end_rx->repLen = keyLen;
+        end_rx->repStr = (char *)callocMemory(repLen + 1);
+        memcpy(end_rx->repStr, buff + offset + findPos, keyLen);
+        }
+
+    cleanupResults(resultStackIdxSave); 
+
+    count++;
+    offset += findPos + keyLen; /* next start for search */
+    oldLen += keyLen; /* space occupied by old content */
+    *newLen += repLen; /* space needed by new replacement content */
+
+    bias = (keyLen == 0);
+    offset += bias;
+
+    if(options != -1)
+    if(options & REPLACE_ONCE) break; 
+    }
+
+if(count == 0) return(NULL);
+
+*newLen = buffLen - oldLen + *newLen;
+newBuff = callocMemory(*newLen + 1);
+
+end_rx = start_rx;
+
+/* count is now offset into the new buffer */
+*cnt = count;
+count = start_rx->offset;
+memcpy(newBuff, buff, count);  
+
+while(start_rx != NULL) /* replace */
+    {
+    repLen = start_rx->repLen;
+    memcpy(newBuff + count, start_rx->repStr, repLen);
+    count += repLen;
+    freeMemory(start_rx->repStr);
+
+    end_rx = start_rx->next;
+    if(end_rx != NULL) /* copy from buffer */
+      {
+      repLen =  end_rx->offset - start_rx->offset - start_rx->length;
+      memcpy(newBuff + count, buff + start_rx->offset + start_rx->length, repLen);
+      count += repLen;
+      }                   
+    
+    freeMemory(start_rx);
+    start_rx = end_rx;
+    }
+/*
+printf("count %d buffLen %d offset %d bias %d str %s lencpy %d\n",  
+        count, buffLen, offset, bias, buff + offset - bias, buffLen - offset + bias);
+*/
+memcpy(newBuff + count, buff + offset - bias, buffLen - offset + bias);
+
+itSymbol->contents = (UINT)nilCell;
+return(newBuff);
+}
+
+
+void freeRegex(REGEX * regex)
+{
+REGEX * oldRegex;
+
+while(regex != NULL)
+    {
+    if(regex->repStr != NULL)
+        freeMemory(regex->repStr);
+    oldRegex = regex;
+    regex = regex->next;
+    free(oldRegex);
+    }
+}
+
+
+/* support strings in the integer-options field of:
+    directory, ends-with, find, find-all, parse, regex, replace, search, starts-with
+   instead of: (find "xyz" buff (| 1 4 2048))
+   example: (find "x.z" "abcX\nZ" "is") => 3
+   for PCRE_CASELESS, PCRE_DOTALL
+*/
+
+CELL* parseRegexOptions(CELL* params, UINT * options, int evalFlag)
+{
+CELL* cell;
+int i;
+char* buffer;
+
+if (evalFlag)
+    cell = evaluateExpression(params);
+else
+    cell = params;
+
+*options = 0;
+
+if (cell->type == CELL_STRING) 
+    {
+    buffer = (char*)cell->contents;
+    for (i = 0; i < cell->aux - 1; i ++) {
+        switch (buffer[i]) {
+            case 'i': *options |= 1; break;         /* PCRE_CASELESS */
+            case 'm': *options |= 2; break;         /* PCRE_MULTILINE */
+            case 's': *options |= 4; break;         /* PCRE_DOTALL */
+            case 'x': *options |= 8; break;         /* PCRE_EXTENDED */
+            case 'A': *options |= 16; break;        /* PCRE_ANCHORED */
+            case 'D': *options |= 32; break;        /* PCRE_DOLLAR_ENDONLY */
+            case 'U': *options |= 512; break;       /* PCRE_UNGREEDY */
+            case 'u': *options |= 2048; break;      /* PCRE_UTF8 */
+            default: return(errorProcExt(ERR_INVALID_OPTION, cell));
+            }
+        }
+    } else { getIntegerExt(cell, options, FALSE); }
+
+return (params->next);
+}
+
+/* eof */
+
+
diff --git a/nl-symbol.c b/nl-symbol.c
new file mode 100644
index 0000000..1bc2276
--- /dev/null
+++ b/nl-symbol.c
@@ -0,0 +1,962 @@
+/* nl-symbol.c --- symbol handling routines for newLISP
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+
+#include "newlisp.h"
+#include "protos.h"
+
+#ifdef MAC_OSX
+#include <sys/mman.h>
+#endif
+
+
+#define str2cmp(s1,s2) \
+    (( (*(unsigned char *)(s1) << 8) |  *((unsigned char *)(s1) + 1) ) - \
+     ( (*(unsigned char *)(s2) << 8) |  *((unsigned char *)(s2) + 1) )  )
+                         
+
+extern CELL * cellMemory;
+extern SYMBOL * trueSymbol;
+extern SYMBOL * orSymbol;
+
+SYMBOL * findInsertSymbol(char * key, int forceCreation);
+int deleteSymbol(char * key);
+void deleteContextSymbols(CELL * cell, int checkReferences);
+void changeContextCells(SYMBOL * contextPtr);
+CELL dumpSymbol(char * name);
+void collectSymbols(SYMBOL * sPtr, CELL * symbolList);
+void collectSymbolAssocs(SYMBOL * sPtr, CELL * assocList);
+static SYMBOL * root;   /* root symbol derived from context */
+
+/* --------- return a list of all symbols in a context -------------- */
+
+
+CELL * p_symbols(CELL * params)
+{
+SYMBOL * context;
+CELL * symbolList;
+
+symbolList = getCell(CELL_EXPRESSION);
+
+if(params->type == CELL_NIL) 
+    context = currentContext;
+else
+    getContext(params, &context);
+
+if(context) /* check in case we are in debug mode */
+    collectSymbols((SYMBOL *)((CELL *)context->contents)->aux, symbolList);
+return(symbolList);
+}
+
+
+void collectSymbols(SYMBOL * sPtr, CELL * symbolList)
+{
+CELL * cell;
+
+if(sPtr != NIL_SYM && sPtr != NULL)
+    {
+    collectSymbols(sPtr->left, symbolList);
+    if(symbolList->contents == (UINT)nilCell)
+        {
+        symbolList->contents = (UINT)stuffSymbol(sPtr);
+        symbolList->aux = symbolList->contents;
+        }
+    else 
+        {
+        cell = (CELL *)symbolList->aux;
+        cell->next = stuffSymbol(sPtr);
+        symbolList->aux = (UINT)cell->next;
+        }
+    collectSymbols(sPtr->right, symbolList);
+    }
+}
+
+
+CELL * associationsFromTree(SYMBOL * context)
+{
+CELL * assocsList;
+
+assocsList = getCell(CELL_EXPRESSION);
+collectSymbolAssocs((SYMBOL *)((CELL *)context->contents)->aux, assocsList);
+
+return(assocsList);
+}
+
+/* only for symbols starting with underscore character _ */
+void collectSymbolAssocs(SYMBOL * sPtr, CELL * assocList)
+{
+CELL * cell;
+
+if(sPtr != NIL_SYM && sPtr != NULL)
+    {
+    collectSymbolAssocs(sPtr->left, assocList);
+    if(*sPtr->name == '_')
+        {
+        cell = makeCell(CELL_EXPRESSION, (UINT)stuffString(sPtr->name + 1));
+        ((CELL *)cell->contents)->next = copyCell((CELL *)sPtr->contents);
+
+        if(assocList->contents == (UINT)nilCell)
+            assocList->contents = (UINT)cell;
+        else 
+            ((CELL *)assocList->aux)->next = cell;
+        assocList->aux = (UINT)cell;
+        }
+    collectSymbolAssocs(sPtr->right, assocList);
+    }
+}
+
+
+SYMBOL * lookupSymbol(char * token, SYMBOL * context)
+{
+root = (SYMBOL *)((CELL *)context->contents)->aux;
+
+return(findInsertSymbol(token, LOOKUP_ONLY));
+}
+
+
+SYMBOL * makeSafeSymbol(CELL * cell, SYMBOL * context, int flag)
+{
+char * token;
+UINT number;
+
+if(isNumber(cell->type))
+    {
+    token = alloca(32);
+    getIntegerExt(cell, &number, FALSE);
+    snprintf(token, 31, "_%"PRIdPTR, number);
+    }
+else
+    {
+    token = alloca(cell->aux + 1);
+    *token = '_';
+    memcpy(token + 1, (char *)cell->contents, cell->aux);
+    }
+    
+if(flag)
+        return(translateCreateSymbol(token, CELL_NIL, context, TRUE));
+
+root = (SYMBOL *)((CELL *)context->contents)->aux;
+return(findInsertSymbol(token, LOOKUP_ONLY));
+}
+
+
+/* 
+   if forceFlag is TRUE then 
+       create the symbol, if not found in the context 
+       specified in that context
+   else
+       if not found try to inherit from MAIN as a global
+       or primitive, else create it in context specified
+*/
+
+
+SYMBOL * translateCreateSymbol
+    (char * token, int type, SYMBOL * context, int forceFlag)
+{
+SYMBOL * sPtr;
+CELL * cell = NULL;
+size_t len;
+
+cell = (CELL *)context->contents;
+root = (SYMBOL *)cell->aux;
+
+if(forceFlag)
+    sPtr = findInsertSymbol(token, FORCE_CREATION);
+else /* try to inherit from MAIN, if not here create in current context */
+    {
+    sPtr = findInsertSymbol(token, LOOKUP_ONLY);
+    if(sPtr == NULL)
+        {
+        if(context != mainContext)
+            {
+            root = (SYMBOL *)((CELL *)mainContext->contents)->aux;
+            sPtr = findInsertSymbol(token, LOOKUP_ONLY);
+            /* since 7.2.7 only inherit primitives and other globals */
+            if(sPtr != NULL && !(sPtr->flags & SYMBOL_GLOBAL))
+                {
+                if(symbolType(sPtr) != CELL_CONTEXT
+                    || (SYMBOL *)((CELL*)sPtr->contents)->contents != sPtr)
+                    sPtr = NULL;
+                }
+            root = (SYMBOL *)cell->aux;
+            }
+        if(sPtr == NULL)
+            sPtr = findInsertSymbol(token, FORCE_CREATION);
+        }
+    }
+
+
+/* the symbol existed already, return */
+if(sPtr->contents != 0) 
+    return(sPtr);
+
+/* root might have changed, after symbol insertion */
+cell->aux = (UINT)root;
+    
+/* a new symbol has been allocated by findInsertSymbol() */
+if(type != CELL_PRIMITIVE)
+    {
+    len = strlen(token);
+    sPtr->name = (char *)allocMemory(len + 1);
+    memcpy(sPtr->name, token, len + 1);
+    cell = copyCell(nilCell); 
+    sPtr->contents = (UINT)cell;
+    /* make a new context symbol */
+    if(type == CELL_CONTEXT && context == mainContext)
+        {
+        cell->type = CELL_CONTEXT;
+        cell->contents = (UINT)sPtr;
+        cell->aux = 0;
+        sPtr->flags |= (SYMBOL_PROTECTED | SYMBOL_GLOBAL);
+        }
+    }
+else
+    {
+    sPtr->name = token;
+    sPtr->contents = (UINT)nilCell;
+    }
+
+sPtr->context = context;
+return(sPtr);
+}
+
+CELL * assignSymbol(SYMBOL * sPtr, CELL * content)
+{
+deleteList((CELL*)sPtr->contents);
+sPtr->contents = (UINT)content;
+
+return(content);
+}
+
+/* ------------------------- dump RB tree info of a symbol -------------------- */
+
+#ifdef SYMBOL_DEBUG
+CELL * p_dumpSymbol(CELL * params)
+{
+char * name;
+SYMBOL * sPtr;
+
+getString(params, &name);
+
+sPtr = findInsertSymbol(name, LOOKUP_ONLY);
+
+if(sPtr == NULL)
+    return(nilCell);
+
+varPrintf(OUT_DEVICE, "name=%s color=%s parent=%s left=%s right=%s\n", 
+    sPtr->name,
+    (sPtr->color == RED) ? "red" : "black",
+    (sPtr->parent) ? sPtr->parent->name : "ROOT",
+    sPtr->left->name,
+    sPtr->right->name);
+
+return(trueCell);
+}
+#endif
+
+
+
+/* ----------------------------- delete a symbol --------------------------- */
+int references(SYMBOL * sPtr, int replaceFlag);
+int externalContextReferences(SYMBOL * contextPtr, int replaceFlag);
+
+CELL * p_deleteSymbol(CELL * params)
+{
+SYMBOL * sPtr = NULL;
+CELL * cell;
+CELL * ctx;
+int checkReferences = TRUE;
+
+cell = evaluateExpression(params);
+if(cell->type != CELL_SYMBOL)
+    return(errorProcExt(ERR_SYMBOL_EXPECTED, params));
+sPtr = (SYMBOL*)cell->contents;
+
+if(sPtr == mainContext) return(nilCell);
+
+if(symbolType(sPtr) == CELL_CONTEXT)
+    {
+    ctx = (CELL*)sPtr->contents;
+    if(ctx->contents == (UINT)sPtr)
+        {
+        sPtr->flags &= ~SYMBOL_PROTECTED;
+        cell = ctx;
+        }
+    }
+
+if(sPtr->flags & (SYMBOL_PROTECTED | SYMBOL_BUILTIN)) 
+    return(nilCell);
+
+/* nil as extra parameter deletes without reference checking.
+   true as extra parameter deletes only if no references are found,
+   No extra parameter assumes reference checking is on and if
+   a reference is found it is replaced with nil.
+*/
+params = params->next;
+/* extra parameter is specified as nil */
+if(params != nilCell && !getFlag(params))
+    checkReferences = FALSE;
+/* extra parameter is specified as true */
+else if(getFlag(params))
+    {
+    if(cell->type == CELL_CONTEXT)
+        {
+        if(externalContextReferences(sPtr, FALSE) > 1)
+            {
+            sPtr->flags |= SYMBOL_PROTECTED;
+            return(nilCell);
+            }
+        checkReferences = FALSE;
+        }
+    else
+        {
+        if(references(sPtr, FALSE) > 1)
+            return(nilCell);
+        checkReferences = FALSE;
+        }
+    }
+
+if(cell->type == CELL_CONTEXT)
+    {
+    deleteContextSymbols(cell, checkReferences);
+    deleteList((CELL *)sPtr->contents); 
+    sPtr->contents = (UINT)copyCell(nilCell);
+    }
+else 
+    {
+    deleteAndFreeSymbol(sPtr, checkReferences);
+    }
+return(trueCell);
+}
+
+
+void deleteContextSymbols(CELL * cell, int checkReferences)
+{
+SYMBOL * context;
+CELL * symbolList;
+CELL * nextSymbol;
+
+context = (SYMBOL *)cell->contents;
+
+if(checkReferences)
+    externalContextReferences(context, TRUE);
+
+symbolList = getCell(CELL_EXPRESSION);
+collectSymbols((SYMBOL *)((CELL *)context->contents)->aux, symbolList);
+
+nextSymbol = (CELL *)symbolList->contents;
+while(nextSymbol != nilCell)
+    {
+    deleteAndFreeSymbol((SYMBOL*)nextSymbol->contents, FALSE);
+    nextSymbol = nextSymbol->next;
+    }
+
+if(checkReferences)
+    changeContextCells(context);
+
+deleteList(symbolList);
+}
+
+
+void deleteAndFreeSymbol(SYMBOL * sPtr, int checkReferences)
+{
+SYMBOL * context;
+
+context = sPtr->context;
+root = (SYMBOL *)((CELL *)context->contents)->aux;
+
+if(!deleteSymbol(sPtr->name))
+    return;
+
+((CELL *)context->contents)->aux = (UINT)root; /* root may have changed */
+
+deleteList((CELL *)sPtr->contents);
+
+if(checkReferences) references(sPtr, TRUE);
+freeMemory(sPtr->name);
+freeMemory(sPtr);
+}
+
+
+void makeContextFromSymbol(SYMBOL * symbol, SYMBOL * treePtr)
+{
+CELL * contextCell;
+UINT * idx = envStackIdx;
+
+/* make sure symbol is not used as local in call hierachy 
+   and symbol is legal */
+while(idx > envStack)
+    {
+    if(symbol == (SYMBOL *)*(--idx))
+        {
+        symbol->contents = (UINT)copyCell(nilCell);
+        errorProcExt2(ERR_CANNOT_PROTECT_LOCAL, stuffSymbol(symbol));
+        }
+    --idx;
+    }
+
+if(!isLegalSymbol(symbol->name))
+    {
+    symbol->contents = (UINT)copyCell(nilCell);
+    errorProcExt2(ERR_INVALID_PARAMETER, stuffString(symbol->name));
+    }
+
+
+contextCell = makeCell(CELL_CONTEXT, (UINT)symbol);
+
+contextCell->aux = (UINT)treePtr;
+symbol->contents = (UINT)contextCell;
+symbol->context = mainContext;
+symbol->flags |= (SYMBOL_PROTECTED | SYMBOL_GLOBAL);
+}
+
+/* only used when S in (delete 'S) is not a context */
+int references(SYMBOL * sPtr, int replaceFlag)
+{
+CELL * blockPtr;
+int i, count;
+
+blockPtr = cellMemory;
+count = 0;
+while(blockPtr != NULL)
+    {
+    for(i = 0; i < MAX_BLOCK; i++)
+        {
+        if( (blockPtr->contents == (UINT)sPtr &&
+            (*(UINT *)blockPtr == CELL_SYMBOL || *(UINT *)blockPtr == CELL_CONTEXT))
+            ||
+            ( *(UINT *)blockPtr == CELL_DYN_SYMBOL && blockPtr->aux == (UINT)sPtr ) )
+            {
+            count++;
+            if(replaceFlag)
+                {
+                blockPtr->type = CELL_SYMBOL;
+                blockPtr->aux = (UINT)nilCell;  
+                if(*(UINT *)blockPtr == CELL_DYN_SYMBOL) 
+                    free((void *)blockPtr->contents);
+                blockPtr->contents = (UINT)nilSymbol;
+                }
+            }
+        blockPtr++;
+        }
+    blockPtr = blockPtr->next;
+    }
+
+return(count);
+}
+
+int externalContextReferences(SYMBOL * contextPtr, int replaceFlag)
+{
+CELL * blockPtr;
+int i, count = 0;
+SYMBOL * sPtr;
+
+blockPtr = cellMemory;
+while(blockPtr != NULL)
+    {
+    for(i = 0; i < MAX_BLOCK; i++)
+        {
+        if(blockPtr->type == CELL_SYMBOL)
+            {
+            sPtr = (SYMBOL *)blockPtr->contents;
+            if(sPtr->context == contextPtr)     
+                {
+                count++;
+                if(replaceFlag) 
+                    blockPtr->contents = (UINT)nilSymbol;
+                }
+            }
+        if(blockPtr->type == CELL_CONTEXT)
+            {
+            if((SYMBOL *)blockPtr->contents == contextPtr)
+                count++;
+            }
+        blockPtr++;
+        }
+    blockPtr = blockPtr->next;
+    }
+
+return(count);
+}
+
+void changeContextCells(SYMBOL * contextPtr)
+{
+CELL * blockPtr;
+int i; 
+
+blockPtr = cellMemory;
+while(blockPtr != NULL)
+    {
+    for(i = 0; i < MAX_BLOCK; i++)
+        {
+        if (blockPtr->type == CELL_CONTEXT)
+            {
+            if((SYMBOL *)blockPtr->contents == contextPtr)
+                {
+                blockPtr->type = CELL_NIL;
+                blockPtr->contents = (UINT)nilCell;
+                blockPtr->aux = (UINT)nilCell;
+                }
+            }
+        blockPtr++;
+        }
+    blockPtr = blockPtr->next;
+    }
+}
+
+/* renamed to 'term' in v.10.1.11 */
+CELL * p_term(CELL * params)
+{
+SYMBOL * sPtr;
+
+params = evaluateExpression(params);
+if(params->type == CELL_SYMBOL || params->type == CELL_CONTEXT)
+    sPtr = (SYMBOL *)params->contents;
+else
+    return(errorProcExt(ERR_SYMBOL_OR_CONTEXT_EXPECTED, params));
+
+return(stuffString(sPtr->name));
+}
+
+CELL * p_prefix(CELL * params)
+{
+SYMBOL * sPtr;
+
+getSymbol(params, &sPtr);
+
+return(makeCell(CELL_CONTEXT, (UINT)sPtr->context));
+}
+
+/* -------------------------------------------------------------------------
+
+   Red-Black Balanced Binary Tree Algorithm adapted from:
+
+   Thomas Niemann thomasn@epaperpress.com
+
+   See also:
+
+   http://epaperpress.com/sortsearch/index.html
+
+   and:
+
+   Thomas H. Cormen, et al
+   Introduction to Algorithms
+   (MIT Electrical Engineering and Computer Science)
+   (C) 1990 MIT Press
+
+*/
+
+
+#define compLT(a,b) (a < b)
+#define compEQ(a,b) (a == b)
+
+#define BLACK 0
+#define RED 1
+
+#define NIL_SYM &sentinel   /* all leafs are sentinels */
+
+SYMBOL sentinel = {
+    0,      /* pretty print */
+    BLACK,      /* color */
+    "NIL",      /* name */
+    0,      /* contents */
+    NULL,       /* context */
+    NULL,       /* parent */
+    NIL_SYM,    /* left */
+    NIL_SYM     /* right */
+    };
+
+void rotateLeft(SYMBOL* x);
+void rotateRight(SYMBOL * x);
+static void insertFixup(SYMBOL * x);
+void deleteFixup(SYMBOL *x);
+
+
+SYMBOL * createRootContext(char * token)
+{
+SYMBOL * sPtr;
+
+root = NULL;
+mainContext = sPtr = findInsertSymbol(token, TRUE);
+sPtr->name = token;
+makeContextFromSymbol(sPtr, sPtr);
+
+return(sPtr);
+}
+
+/* --------------------------------------------------------------------
+
+   lookup the symbol with name key, if it does not exist and the
+   forceCreation flag is set, create and insert the symbol and
+   return a pointer to the new symbol. If the context passed is empty
+   then it's treePtr (root) will be the new symbol.
+
+*/
+
+
+SYMBOL * findInsertSymbol(char * key, int forceCreation) 
+{
+SYMBOL *current, *parent, *x;
+int c;
+
+/* find future parent */
+current = (root == NULL) ? NIL_SYM : root;
+parent = 0;
+
+while (current != NIL_SYM)
+    {
+    if( ((c = str2cmp(key, current->name)) == 0) && ((c = strcmp(key, current->name)) == 0) )
+            return(current);
+
+    parent = current;
+    current = (c < 0) ? current->left : current->right;
+    }
+
+/* if forceCreation not specified just return */
+if(forceCreation == LOOKUP_ONLY) return(NULL);
+
+/* allocate new symbol */
+x = (SYMBOL *)callocMemory(sizeof(SYMBOL));
+
+x->parent = parent;
+x->left = NIL_SYM;
+x->right = NIL_SYM;
+x->color = RED;
+
+/* insert node in tree */
+if(parent)
+    {
+    if( (c = str2cmp(key, parent->name)) < 0)
+        parent->left = x;
+    else if(c > 0)
+        parent->right = x;
+    else if(strcmp(key, parent->name) < 0)
+        parent->left = x;
+    else
+        parent->right = x;
+    }
+else
+    root =x;
+
+insertFixup(x);
+
+/* return new node */
+
+++symbolCount;
+return(x);
+}
+
+
+/* --------------------------------------------------------------------
+   extract symbol in context from tree, return 1 if deleted or 0 if it 
+   couldn't be found.
+
+*/
+
+int deleteSymbol(char * key)
+{
+SYMBOL *x, *y, *z;
+int color, c;
+
+/* find node in tree */
+z = (root == NULL) ? NIL_SYM : root;
+
+while(z != NIL_SYM)
+    {
+    if( ((c = str2cmp(key, z->name)) == 0) && ((c = strcmp(key, z->name)) == 0) )
+        break;
+    else
+        z = (c < 0) ? z->left : z->right;
+    }
+
+if (z == NIL_SYM) return(0); /* key to delete not found */
+
+
+if (z->left == NIL_SYM || z->right == NIL_SYM)
+    {
+    /* y has a NIL_SYM node as a child */
+    y = z;
+    }
+else 
+    {
+    /* find tree successor with a NIL_SYM node as a child */
+    y = z->right;
+    while (y->left != NIL_SYM) y = y->left;
+    }
+
+/* x is y's only child */
+if (y->left != NIL_SYM)
+    x = y->left;
+else
+    x = y->right;
+
+/* remove y from the parent chain */
+x->parent = y->parent;
+if (y->parent)
+    {
+    if (y == y->parent->left)
+        y->parent->left = x;
+        else
+            y->parent->right = x;
+    }
+else
+    root = x;
+
+
+color = y->color;
+if (y != z)
+    {
+    /* swap y and z */
+    y->left = z->left;
+    y->right = z->right;
+    y->parent = z->parent;
+
+    if(z->parent)
+        {
+        if(z->parent->left == z)
+            z->parent->left = y;
+        else
+            z->parent->right = y;
+        }
+    else root = y;
+
+    y->right->parent = y;
+    y->left->parent = y;
+
+    y->color = z->color;
+    }
+
+if (color == BLACK)
+    deleteFixup (x);
+
+--symbolCount;
+return TRUE;
+}
+
+
+
+/* -------------------------------------------------------------------- */
+
+void rotateLeft(SYMBOL* x) 
+{
+SYMBOL* y;
+
+y = x->right;
+
+/* establish x->right link */
+x->right = y->left;
+if (y->left != NIL_SYM) 
+    y->left->parent = x;
+
+/* establish y->parent link */
+if(y != NIL_SYM) 
+    y->parent = x->parent;
+
+if (x->parent)
+    {
+    if (x == x->parent->left)
+        x->parent->left = y;
+      else
+        x->parent->right = y;
+    } 
+else 
+    root = y;
+
+
+/* link x and y */
+y->left = x;
+if (x != NIL_SYM) 
+    x->parent = y;
+}
+
+
+void rotateRight(SYMBOL * x)
+{
+SYMBOL * y;
+
+y = x->left;
+
+/* establish x->left link */
+x->left = y->right;
+if (y->right != NIL_SYM)
+    y->right->parent = x;
+
+/* establish y->parent link */
+if (y != NIL_SYM) 
+    y->parent = x->parent;
+
+if (x->parent) 
+    {
+      if (x == x->parent->right)
+            x->parent->right = y;
+      else
+            x->parent->left = y;
+    }
+else
+    root = y;
+
+/* link x and y */
+y->right = x;
+if (x != NIL_SYM) 
+    x->parent = y;
+}
+
+
+static void insertFixup(SYMBOL * x)
+{
+SYMBOL * y;
+
+/* check Red-Black properties */
+while (x != root && x->parent->color == RED)
+    {
+    /* we have a violation */
+    if (x->parent == x->parent->parent->left)
+        {
+        y = x->parent->parent->right;
+        if (y->color == RED) 
+            {
+            /* uncle is RED */
+            x->parent->color = BLACK;
+            y->color = BLACK;
+            x->parent->parent->color = RED;
+            x = x->parent->parent;
+            } 
+        else 
+            {
+            /* uncle is BLACK */
+            if (x == x->parent->right)
+                {
+                /* make x a left child */
+                x = x->parent;
+                rotateLeft(x);
+                }
+
+            /* recolor and rotate */
+            x->parent->color = BLACK;
+            x->parent->parent->color = RED;
+            rotateRight(x->parent->parent);
+           }
+        } 
+    else 
+        {
+
+        /* mirror image of above code */
+        y = x->parent->parent->left;
+        if (y->color == RED) 
+            {
+            /* uncle is RED */
+            x->parent->color = BLACK;
+            y->color = BLACK;
+            x->parent->parent->color = RED;
+            x = x->parent->parent;
+            } 
+        else 
+            {
+            /* uncle is BLACK */
+            if (x == x->parent->left) 
+                {
+                x = x->parent;
+                rotateRight(x);
+                }
+            x->parent->color = BLACK;
+            x->parent->parent->color = RED;
+            rotateLeft(x->parent->parent);
+            }
+        }
+    }
+
+root->color = BLACK;
+}
+
+
+void deleteFixup(SYMBOL *x)
+{
+SYMBOL * w;
+
+while (x != root && x->color == BLACK)
+    {
+    if (x == x->parent->left)
+        {
+            w = x->parent->right;
+            if (w->color == RED)
+            {
+            w->color = BLACK;
+            x->parent->color = RED;
+            rotateLeft (x->parent);
+            w = x->parent->right;
+            }
+            if (w->left->color == BLACK && w->right->color == BLACK)
+            {
+            w->color = RED;
+            x = x->parent;
+            } 
+        else 
+            {
+            if (w->right->color == BLACK)
+                {
+                w->left->color = BLACK;
+                w->color = RED;
+                rotateRight (w);
+                w = x->parent->right;
+                }
+            w->color = x->parent->color;
+            x->parent->color = BLACK;
+            w->right->color = BLACK;
+            rotateLeft (x->parent);
+            x = root;
+            }
+        } 
+    else 
+        {
+            w = x->parent->left;
+            if (w->color == RED)
+            {
+            w->color = BLACK;
+            x->parent->color = RED;
+            rotateRight (x->parent);
+            w = x->parent->left;
+            }
+            if (w->right->color == BLACK && w->left->color == BLACK)
+            {
+            w->color = RED;
+            x = x->parent;
+            } 
+        else 
+            {
+            if (w->left->color == BLACK)
+                {
+                w->right->color = BLACK;
+                w->color = RED;
+                rotateLeft (w);
+                w = x->parent->left;
+                }
+            w->color = x->parent->color;
+            x->parent->color = BLACK;
+            w->left->color = BLACK;
+            rotateRight (x->parent);
+            x = root;
+            }
+        }
+    }
+
+x->color = BLACK;
+}
+
+/* eof */
+
diff --git a/nl-utf8.c b/nl-utf8.c
new file mode 100644
index 0000000..11d1989
--- /dev/null
+++ b/nl-utf8.c
@@ -0,0 +1,325 @@
+/* nl-utf8.c --- functions for UTF-8 unicode support
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+//
+// portions are copied from pcre.c by: Philip Hazel <ph10@cam.ac.uk>
+// and Copyright (c) 1997-2003 University of Cambridge
+//
+*/
+
+
+#include "newlisp.h"
+#include <wchar.h>
+#include <wctype.h>
+#include "protos.h"
+
+/* from win-path.c */
+CELL * utf8_from_mbcs(void * mbcs_str);
+
+/*************************************************
+*    Macros and tables for character handling    *
+*        by Philip Hazel <ph10@cam.ac.uk>        *
+*************************************************/
+
+/* These are the breakpoints for different numbers of bytes in a UTF-8
+character. */
+
+static const int utf8_table1[] =
+  { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff};
+
+/* These are the indicator bits and the mask for the data bits to set in the
+first byte of a character, indexed by the number of additional bytes. */
+
+static const int utf8_table2[] = { 0,    0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
+static const int utf8_table3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
+
+/* Table of the number of extra characters, indexed by the first character
+masked with 0x3f. The highest number for a valid UTF-8 character is in fact
+0x3d. */
+
+static const char utf8_table4[] = {
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
+
+/* Get the next UTF-8 character, advancing the pointer. This is called when we
+know we are in UTF-8 mode. */
+
+#define GETCHARINC(c, eptr) \
+  c = (unsigned char)*eptr++; \
+  if ((c & 0xc0) == 0xc0) \
+    { \
+    int gcaa = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+    int gcss = 6*gcaa; \
+    c = (c & utf8_table3[gcaa]) << gcss; \
+    while (gcaa-- > 0) \
+      { \
+      gcss -= 6; \
+      c |= (*eptr++ & 0x3f) << gcss; \
+      } \
+    }
+
+/* This function takes an integer value in the range 0 - 0x7fffffff
+and encodes it as a UTF-8 character in 0 to 6 bytes.
+
+Arguments:
+  cvalue     the character value
+  buffer     pointer to buffer for result - at least 6 bytes long
+
+Returns:     number of characters placed in the buffer
+*/
+
+int wchar_utf8(int cvalue, char *buffer)
+{
+register int i, j;
+for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
+  if (cvalue <= utf8_table1[i]) break;
+buffer += i;
+for (j = i; j > 0; j--)
+ {
+ *buffer-- = 0x80 | (cvalue & 0x3f);
+ cvalue >>= 6;
+ }
+*buffer = utf8_table2[i] | cvalue;
+return i + 1;
+}
+
+
+/* ---------------------- UTF-8 utility fuctions --------------------------- */
+
+/* get utf8 string from unicode wide character
+ * 
+ * int wchar_utf8(int wchar, char * utf8str)
+ * 
+ * the string is not nullterminated for contiguos filling
+ * of longer strings
+ * returns number of bytes placed in utf8str
+*/
+
+
+/* get a unicode wide character from the utf8 string
+ * return advanced utf8 string pointer
+*/
+
+char * utf8_wchar(char * utf8str, int * chr)
+{
+GETCHARINC(*chr, utf8str)
+
+return(utf8str);
+}
+
+/* return the number of characters encoded in utf8 string
+ * without counting the zero terminator
+ * new limit param in 10.4.5 to avoid overrun on invalid utf8 strings
+*/
+
+size_t utf8_wlen(char * utf8str, char * limit)
+{
+int gcaa;
+int c;
+size_t count = 0;
+
+while((c = *utf8str++) != 0 && utf8str < limit)
+    {
+    count++;
+    if ((c & 0xc0) == 0xc0)
+        {
+        gcaa = utf8_table4[c & 0x3f];
+        utf8str += gcaa;
+        }
+    }
+
+/* now handled by while loop 10.6.1
+if(utf8str > limit)
+    errorProc(ERR_INVALID_UTF8);
+*/
+
+return(count);
+}
+
+/* return ptr to character at index, added by LM 2012-06-10
+*/
+
+char * utf8_index(char * utf8str, int idx)
+{
+int c;
+
+while((c = *utf8str) != 0 && idx-- != 0)
+    {
+    if ((c & 0xc0) == 0xc0)
+        utf8str += utf8_table4[c & 0x3f] + 1;
+    else    
+        utf8str++;
+    }
+
+return(utf8str);
+}
+
+
+/* return the length of the first utf8 character
+*/
+
+int utf8_1st_len(char * utf8str)
+{
+int c;
+
+if((c = *utf8str) != 0)
+    {
+    if((c & 0xc0) == 0xc0)
+        return(utf8_table4[c & 0x3f] + 1);
+    else return(1);
+    }
+
+return(0);
+}
+
+
+/* convert utf8 string to vector of maxwc wide characters
+ * unicode vector is zero terminated
+ * return number of unicode characters (excluding zero int)
+*/
+
+int utf8_wstr(int * unicode, char * utf8str, int maxwc)
+{
+int wchar;
+int count = 0;
+
+while(maxwc-- && *utf8str != 0)
+    {
+    count++;
+    GETCHARINC(wchar, utf8str);
+/*  utf8str = utf8_wchar(utf8str, &wchar); */
+    *(unicode++) = wchar;
+    }
+*unicode = 0;
+
+return(count);
+}
+
+/* convert zero terminated unicode vector into utf8 string
+ * return number of bytes stored in utr8 string excluding terminator
+ * don't use more then maxstr bytes (excluding  zero terminator)
+*/
+
+int wstr_utf8(char * utf8str, int * unicode, int maxstr)
+{
+int len, size = 0;
+
+while(*unicode != 0 && size < maxstr)
+    {
+    len = wchar_utf8(*unicode, utf8str);
+    utf8str += len;
+    size += len;
+    unicode++;
+    }
+
+*utf8str = 0;
+
+return(size);
+}
+
+/* -------------------------------------- newLISP API -----------------------------------*/
+
+CELL * p_unicode(CELL * params)
+{
+char * utf8str;
+size_t size;
+int * unicode;
+
+getStringSize(params, &utf8str, &size, TRUE);
+unicode = allocMemory((size + 1) * sizeof(int));
+
+size = utf8_wstr(unicode, utf8str, size);
+unicode = reallocMemory(unicode, (size + 1) * sizeof(int) + 1);
+
+/*
+cell = getCell(CELL_STRING);
+cell->contents = (UINT)unicode;
+cell->aux = (size + 1) * sizeof(int) + 1;
+*/
+
+return(makeStringCell((char *)unicode, (size + 1) * sizeof(int)));
+}
+
+
+CELL * p_utf8(CELL * params)
+{
+int * unicode;
+size_t size;
+char * utf8str;
+
+params = getStringSize(params, (void *)&unicode, &size, TRUE);
+#ifdef WINDOWS
+if(getFlag(params)) /* its a MBCS string */
+    return(utf8_from_mbcs((void *)unicode));
+#endif
+    
+
+utf8str = callocMemory(size * UTF8_MAX_BYTES + 1);
+
+size = wstr_utf8(utf8str, unicode, size);
+utf8str = reallocMemory(utf8str, size + 1);
+*(utf8str + size) = 0;
+
+return(makeStringCell(utf8str, size));
+}
+
+
+CELL * p_utf8len(CELL * params)
+{
+char * str;
+size_t size;
+
+getStringSize(params, &str, &size, TRUE);
+
+return(stuffInteger(utf8_wlen(str, str + size + 1)));
+}
+
+/* reads a UTF-8 character */
+CELL * p_readUTF8(CELL * params)
+{
+UINT handle;
+int utf8C, gcaa, gcss;
+char chr;
+
+getInteger(params, &handle);
+if(read((int)handle, &chr, 1) <= 0)
+    return(nilCell);
+
+utf8C = chr;
+    
+if((chr & 0xc0) == 0xc0)
+    {
+    gcaa = utf8_table4[chr & 0x3f];  /* Number of additional bytes */
+    gcss = 6*gcaa;
+    utf8C = (chr & utf8_table3[gcaa]) << gcss;
+    while (gcaa-- > 0) \
+        {
+        gcss -= 6;
+        
+        if(read((int)handle, &chr, 1) <= 0)
+            return(nilCell);
+
+        utf8C |= (chr & 0x3f) << gcss;
+        }
+    }
+
+return(stuffInteger(utf8C));
+}
+
+/* eof */
diff --git a/nl-web.c b/nl-web.c
new file mode 100644
index 0000000..9757286
--- /dev/null
+++ b/nl-web.c
@@ -0,0 +1,1484 @@
+/* nl-web.c --- HTTP network protocol routines for newLISPD
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include <errno.h>
+#include "protos.h"
+
+#ifdef WINDOWS
+#include <winsock2.h>
+#else
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+#define BUFFSIZE 10240
+
+#ifndef WINDOWS
+#define SOCKET_ERROR -1
+#else
+#define fgets win_fgets
+#define close closesocket  /* for file operations on Windows use _close */
+#endif
+
+/* from nl-sock.c */
+extern UINT netErrorIdx;
+extern char * netErrorMsg[];
+
+#define OK_FILE_DELETED "file deleted"
+
+#define MAX_PROTOCOL 8
+#define NO_FLAGS_SET 0
+
+char * requestMethod[] = {"GET", "HEAD", "PUT", "PUT", "POST", "DELETE"};
+
+/* with MinGW gcc 3.4.5 not needed
+#ifdef WINDOWS
+struct timezone {
+       int     tz_minuteswest;
+       int     tz_dsttime;
+};
+
+int gettimeofday( struct timeval *tp, struct timezone *tzp );
+#endif
+*/
+
+#ifdef WINDOWS
+extern int IOchannelIsSocketStream;
+#endif
+
+extern SYMBOL * transferEvent;
+
+ssize_t readFile(char * fileName, char * * buffer);
+int writeFile(char * fileName, char * buffer, size_t size, char * type);
+int parseUrl(char *url, char * protocol, char * host, int * port, char * path, size_t bufflen);
+void parsePath(char * url, char * path, size_t bufflen);
+size_t parseValue(char * str);
+void trimTrailing(char * ptr);
+CELL * webError(int no);
+CELL * base64(CELL * params, int type);
+
+#ifndef EMSCRIPTEN
+jmp_buf socketTimeoutJump;
+INT socketTimeout = 0;
+struct timeval socketStart;
+
+/* socket send and receive routines with timeout */
+int recvc_tm(int sock)
+{
+struct timeval tm;
+unsigned char chr;
+ssize_t bytes;
+
+while(wait_ready(sock, 1000, 0) <= 0)
+  {
+  if(socketTimeout)
+    {
+    gettimeofday(&tm, NULL);
+    if(timediff_ms(tm, socketStart) > socketTimeout)
+        longjmp(socketTimeoutJump, 1);
+    }
+  } 
+   
+bytes = recv(sock, (void *)&chr, 1, NO_FLAGS_SET);
+if(bytes <= 0) return(-1);
+
+return(chr);
+}
+
+
+char * recvs_tm(char * buffer, size_t size, int sock)
+{
+ssize_t bytesReceived = 0;
+int chr;
+
+while(bytesReceived < size)
+    {
+    if((chr = recvc_tm(sock)) < 0)
+        {
+        if(bytesReceived == 0)
+            return(NULL);
+        else break;
+        }
+
+    *(buffer + bytesReceived++) = chr;
+    if(chr == '\n') break;
+    }
+
+*(buffer + bytesReceived) = 0;
+return(buffer);
+}
+
+void wait_until_read_ready(int sock)
+{
+struct timeval tm;
+
+while(wait_ready(sock, 1000, 0) <= 0)
+    {
+    if(socketTimeout)
+        {
+        gettimeofday(&tm, NULL);
+        if(timediff_ms(tm, socketStart) > socketTimeout)
+        longjmp(socketTimeoutJump, 1);
+        }
+    }
+}
+
+size_t recvsize_tm(char * buffer, size_t size, int sock, int flag)
+{
+ssize_t sizeRead = 0;
+size_t resultSize = 0;
+
+wait_until_read_ready(sock);
+memset(buffer, 0, size);
+while(size)
+  { 
+  sizeRead = recv(sock, buffer + resultSize, size, NO_FLAGS_SET);
+  if(sizeRead <= 0)
+      {
+      sizeRead = 0;
+      break;
+      }
+  resultSize += sizeRead;
+  size -= sizeRead;
+  if(flag && transferEvent != nilSymbol)
+        executeSymbol(transferEvent, stuffInteger(sizeRead), NULL);
+  wait_until_read_ready(sock);
+  }
+
+return(resultSize);
+}
+
+ssize_t sendf(int sock, int debug, char * format, ...)
+{
+char * buffer;
+va_list argptr;
+int result;
+ 
+va_start(argptr,format);
+/* new in 7201 , defined in nl-filesys.c if not in libc */
+vasprintf(&buffer, format, argptr); 
+
+result = send(sock, buffer, strlen(buffer), NO_FLAGS_SET);
+if(debug) varPrintf(OUT_CONSOLE, "%s", buffer);
+
+freeMemory(buffer);
+va_end(argptr);
+
+return(result);
+}
+
+CELL * p_getUrl(CELL * params)
+{
+return(getPutPostDeleteUrl(NULL, params, HTTP_GET, CONNECT_TIMEOUT));
+}
+
+
+CELL * p_putUrl(CELL * params)
+{
+return(getPutPostDeleteUrl(NULL, params, HTTP_PUT, CONNECT_TIMEOUT));
+}
+
+
+CELL * p_postUrl(CELL * params)
+{
+return(getPutPostDeleteUrl(NULL, params, HTTP_POST, CONNECT_TIMEOUT));
+}
+
+CELL * p_deleteUrl(CELL * params)
+{
+return(getPutPostDeleteUrl(NULL, params, HTTP_DELETE, CONNECT_TIMEOUT));
+}
+
+int transfer(int sock, char * buff, int len)
+{
+int bytesSend = 0, n;
+
+while(bytesSend < len)
+    {
+    if((n = sendall(sock, buff + bytesSend, 
+                (len - bytesSend) > BUFFSIZE ? BUFFSIZE : len - bytesSend) )
+        == SOCKET_ERROR)
+        return(SOCKET_ERROR);
+    bytesSend += n;
+    if(transferEvent != nilSymbol)
+        executeSymbol(transferEvent, stuffInteger(bytesSend), NULL);
+    }
+
+return(bytesSend);
+}
+
+CELL * getPutPostDeleteUrl(char * url, CELL * params, int type, int timeout)
+{
+char * proxyUrl, * putPostStr = NULL, *contentType;
+char * protocol;
+char * host;
+char * pHost;
+char * path;
+char * customHeader = NULL;
+size_t bufflen;
+int port, pPort, sock = 0;
+char * option, * method = NULL;
+char * buff;
+char resultTxt[128];
+char * buffPtr;
+char * resultPtr = NULL;
+int haveContentLength = FALSE, headRequest = FALSE, listFlag = FALSE, debugFlag = FALSE, rawFlag = FALSE;
+int chunked = FALSE;
+ssize_t sizeRead = 0;
+size_t resultSize = 0, fSize = 0, size = 0;
+CELL * result, * cell;
+CELL * headerCell = NULL;
+int ch, len;
+int responseLoop;
+int statusCode;
+
+buff = alloca(BUFFSIZE);
+
+/* reset net-error */
+netErrorIdx = 0;
+
+/* get parameters */
+
+if(url == NULL)
+    params = getString(params, &url);
+
+if(type == HTTP_PUT || type == HTTP_PUT_APPEND || type == HTTP_POST)
+    params = getStringSize(params, &putPostStr, &size, TRUE);
+
+
+if(my_strnicmp(url, "file://", 7) == 0)
+    {
+    if(type == HTTP_GET)
+        {
+        if((size = readFile(url, &buffPtr)) == -1)
+            return(webError(ERROR_FILE_OP));
+        return(makeStringCell(buffPtr, size));
+        }
+    if(type == HTTP_PUT)
+        {
+        if(writeFile(url, putPostStr, size, "w") == -1)
+            return(webError(ERROR_FILE_OP));
+        snprintf(resultTxt, 64, "%u bytes written", (unsigned int)size);
+        return(stuffString(resultTxt)); /* not an error */
+        }
+    if(type == HTTP_DELETE)
+        {
+        url = getLocalPath(url);
+        return(unlink(url) == 0 ? stuffString(OK_FILE_DELETED) : webError(ERROR_FILE_OP));
+        }
+
+    return(webError(ERROR_BAD_URL));
+    }
+
+
+if(type == HTTP_POST)
+    {
+    if(params->type != CELL_NIL)
+        params = getString(params, &contentType);
+    else 
+        contentType = "application/x-www-form-urlencoded";
+    }
+
+result = evaluateExpression(params);
+params = params->next;
+
+if(isNumber(result->type))
+    {
+    getIntegerExt(result, (UINT*)&socketTimeout, FALSE);
+    /* set connection timeout to total-timeout specified by user */
+    timeout = socketTimeout;
+    }
+
+else if(result->type == CELL_STRING)
+    {
+    option = (char *)result->contents;    
+    len = result->aux - 1;
+    if(searchBuffer(option, len, "header", 6, 0) != -1)
+      headRequest = TRUE;
+    if(searchBuffer(option, len, "list", 4, 0) != -1)
+      listFlag = TRUE;
+    if(searchBuffer(option, len, "debug", 5, 0) != -1)
+      debugFlag = TRUE;
+    if(searchBuffer(option, len, "raw", 3, 0) != -1)
+      rawFlag = TRUE;
+
+    if(params != nilCell)
+        params = getInteger(params, (UINT*)&socketTimeout);
+    }
+else if(result != nilCell)
+    return(errorProcExt(ERR_NUMBER_OR_STRING_EXPECTED, result));
+
+/* if total timeout is specified, custom-header can be specified too */
+if(socketTimeout && params != nilCell)
+        getString(params, &customHeader);
+
+bufflen = strlen(url) + 1;
+if(bufflen < MAX_URL_LEN + 1) bufflen = MAX_URL_LEN + 1;
+
+protocol = alloca(8);
+host = alloca(bufflen);
+pHost = alloca(bufflen);
+path = alloca(bufflen);
+
+/* parse URL for parameters */
+if(parseUrl(url, protocol, host, &port, path, bufflen) == FALSE)
+    return(webError(ERROR_BAD_URL));
+
+/* printf("protocol: %s host:%s port %d path:%s\n", protocol, host, port, path); */
+
+proxyUrl = getenv("HTTP_PROXY");
+
+if(proxyUrl == NULL)
+    {
+    strncpy(pHost, host, bufflen);
+    pPort = port;
+    }
+else
+    {
+    if(parseUrl(proxyUrl, protocol, pHost, &pPort, NULL, bufflen) == FALSE)
+        return(webError(ERROR_BAD_URL));
+    }
+
+/* start timer */
+gettimeofday(&socketStart, NULL);
+/* connect to host */
+CONNECT_TO_HOST:
+if(sock) 
+    close(sock);
+
+
+if((sock = netConnect(pHost, pPort, SOCK_STREAM, 0, timeout)) == SOCKET_ERROR)
+    return(webError(netErrorIdx));
+
+if(type == HTTP_GET)
+    if(headRequest == TRUE) type = HTTP_HEAD;
+method = requestMethod[type];
+
+/* send header */
+if(proxyUrl != NULL)
+    sendf(sock, debugFlag, "%s %s://%s:%d/%s HTTP/1.1\r\n", method, protocol, host, port, path);
+else
+    sendf(sock, debugFlag, "%s /%s HTTP/1.1\r\n", method, path);
+
+/* obligatory host spec */
+sendf(sock, debugFlag, "Host: %s\r\n", host);
+
+/* send optional custom header entries */
+if (customHeader != NULL)
+    sendf(sock, debugFlag, "%s", customHeader);
+else
+    sendf(sock, debugFlag, "User-Agent: newLISP v%d\r\n", version);
+
+sendf(sock, debugFlag, "%s", "Connection: close\r\n");
+
+/* expanded header for PUT, POST and body */
+if(type == HTTP_PUT || type == HTTP_PUT_APPEND)
+    {
+    if(type == HTTP_PUT_APPEND) sendf(sock, debugFlag, "%s", "Pragma: append\r\n");
+    if(customHeader == NULL)
+        sendf(sock, debugFlag, "Content-type: text/html\r\nContent-length: %d\r\n\r\n", size);
+    else
+        sendf(sock, debugFlag, "Content-length: %d\r\n\r\n", size);
+
+    if(transfer(sock, putPostStr, size) == SOCKET_ERROR) 
+        return(webError(ERROR_TRANSFER));
+    if(debugFlag) varPrintf(OUT_CONSOLE, "%s", putPostStr);
+    }
+else if(type == HTTP_POST)
+    {
+    sendf(sock, debugFlag, "Content-type: %s\r\nContent-length: %d\r\n\r\n", contentType, size);
+    if(transfer(sock, putPostStr, size) == SOCKET_ERROR) 
+        return(webError(ERROR_TRANSFER));
+    if(debugFlag) varPrintf(OUT_CONSOLE, "%s", putPostStr);
+    }
+else /* HTTP_GET, HTTP_DELETE */
+    sendf(sock, debugFlag, "%s", "\r\n");
+
+if(setjmp(socketTimeoutJump) != 0)
+    {
+    if(sock) close(sock);
+    if(resultPtr != NULL) free(resultPtr);
+    return(webError(ERR_INET_TIMEOUT));
+    }
+  
+/* Retrieve HTTP response and check for status code. */
+responseLoop = 0;
+READ_RESPONSE:
+if(++responseLoop == 4)
+        return(webError(ERROR_INVALID_RESPONSE));
+
+
+if (recvs_tm(buff, BUFFSIZE, sock) == NULL) 
+   return(webError(ERROR_NO_RESPONSE));
+
+if(debugFlag) varPrintf(OUT_CONSOLE, "\n%s\n", buff);
+
+/* go past first token */
+for (buffPtr = buff; *buffPtr != '\0' && !isspace((int)*buffPtr); ++buffPtr) {;}
+
+/* trim leading spaces */
+while(isspace((int)*buffPtr)) ++buffPtr;
+
+/* get status code */
+statusCode = atoi(buffPtr);
+if(statusCode >= 400)
+    snprintf(resultTxt, 128, "ERR: %s", buff);
+else
+    snprintf(resultTxt, 128, "%s", buff);
+
+switch (statusCode) 
+    {
+    case 0:
+    case 100:
+        /* drain and continue */
+        while (ch = recvc_tm(sock), ch != EOF && ch != '\n') {;}
+        goto READ_RESPONSE;
+    case 200:
+    case 201:
+    case 202:
+    case 203:
+    case 204:
+    case 205:
+    case 206:
+    case 300:
+    case 301:
+    case 302:
+    case 303:
+    case 307:
+        break;
+    default:
+        break;
+    }
+
+/* Retrieve HTTP headers. */
+memset(buff, 0, BUFFSIZE);
+if(listFlag || headRequest)
+    headerCell = stuffString("");
+
+/* Retrieve header */
+while(strcmp(buff, "\r\n") != 0 && strcmp(buff, "\n") != 0)
+    {
+    if(recvs_tm(buff, BUFFSIZE, sock) == NULL)
+        return(webError(ERROR_HEADER));
+
+    if(listFlag || headRequest) appendCellString(headerCell, buff, strlen(buff));
+
+    if(my_strnicmp(buff, "content-length:", 15) == 0)
+        {
+        fSize = parseValue(buff + 15);
+        haveContentLength = TRUE;
+        }
+    /* 302 contradicts standard for redirection but is common practice */
+    if(my_strnicmp(buff, "location:", 9) == 0 && !rawFlag &&
+                (statusCode == 301 || statusCode == 302 || statusCode == 303))
+        {
+        buffPtr = buff + 9;
+        while(isspace((int)*buffPtr)) ++buffPtr;
+        if(*buffPtr == '/')
+            strncpy(path, buffPtr + 1, bufflen);
+        else /* its a url or path */
+            {
+            if(parseUrl(buffPtr, protocol, host, &port, path, bufflen) == FALSE)
+                /* path only */
+                parsePath(buffPtr, path, buffPtr - buff);
+
+            if(proxyUrl == NULL)
+                {
+                strncpy(pHost, host, bufflen);
+                pPort = port;
+                }
+            }
+
+        if(headerCell) deleteList(headerCell);  
+        goto CONNECT_TO_HOST;
+        }
+
+    if(my_strnicmp(buff, "Transfer-Encoding:", 18) == 0 
+        && searchBuffer(buff, strlen(buff), "chunked", 7, 0) != -1)
+        chunked = TRUE;
+    }
+    
+if(headRequest)
+    return(headerCell);
+
+/* changed in 10.6.4 should allow 0-length contents and 204 handled earlier */
+/* if((haveContentLength == TRUE && fSize == 0) || statusCode == 204) */
+if(statusCode == 204)
+    {
+    return(webError(ERROR_NO_CONTENT));
+    resultPtr = NULL;
+    }
+
+/* Retrieve HTTP body. */
+else if(chunked == TRUE)
+    {
+    resultPtr = NULL;
+    if(recvs_tm(buff, BUFFSIZE, sock) == NULL)
+        return(webError(ERROR_NO_CONTENT));
+    while((size = strtoul(buff, NULL, 16)) > 0)
+        {
+        if(resultSize == 0)
+            resultPtr = allocMemory(size + 1);
+        else 
+            resultPtr = reallocMemory(resultPtr, resultSize + size + 1);
+        if(recvsize_tm(resultPtr + resultSize, size, sock, TRUE) != size)
+            {
+            free(resultPtr);
+            return(webError(ERROR_CHUNKED_FORMAT));
+            }
+        resultSize += size;
+        recvs_tm(buff, BUFFSIZE, sock); /* empty line */
+        recvs_tm(buff, BUFFSIZE, sock); /*  chunck size  */
+        }
+    }
+
+else if(haveContentLength == TRUE && fSize)
+    {
+    resultPtr = allocMemory(fSize + 1);
+    if((resultSize = recvsize_tm(resultPtr, fSize, sock, TRUE)) == 0)
+        {
+        free(resultPtr);
+        return(webError(ERROR_NO_CONTENT));
+        }
+    }
+    
+else /* no content length given, relies on host closing the connection */
+    {
+    resultPtr = allocMemory(BUFFSIZE + 1);
+    resultSize = 0;
+    size = BUFFSIZE;
+    while ((sizeRead = recvsize_tm(buff, BUFFSIZE, sock, FALSE)) > 0)
+        {
+        if((resultSize + sizeRead) > size)
+            {
+            size = resultSize + BUFFSIZE;
+            resultPtr = reallocMemory(resultPtr, size + 1);
+            }
+        memcpy(resultPtr + resultSize, buff, sizeRead);
+        resultSize += sizeRead;
+        if(transferEvent != nilSymbol)
+            executeSymbol(transferEvent, stuffInteger(sizeRead), NULL);
+        }
+    }
+
+
+if(resultPtr == NULL)
+    {
+    if(statusCode < 400)
+        result = stuffString("");
+    else 
+        result = stuffString(resultTxt);
+    }
+else
+    {
+    result = getCell(CELL_STRING);
+    if(statusCode >= 400 && listFlag == FALSE)
+        {
+        bufflen = strlen(resultTxt);
+        buffPtr = allocMemory(bufflen + resultSize + 1);
+        memcpy(buffPtr, resultTxt, bufflen);
+        memcpy(buffPtr + bufflen, resultPtr, resultSize);
+        free(resultPtr);
+        resultPtr = buffPtr;
+        resultSize += bufflen;
+        }       
+    *(resultPtr + resultSize) = 0;
+    result->contents = (UINT)resultPtr;
+    result->aux = resultSize + 1;
+    }
+
+close(sock);
+
+if(listFlag)
+    {
+    cell = getCell(CELL_EXPRESSION);
+    addList(cell, headerCell); 
+    addList(cell, result);
+    addList(cell, stuffString(statusCode >= 400 ? resultTxt + 5 : resultTxt));
+    addList(cell, stuffInteger(statusCode));
+    return(cell);
+    }
+
+return(result);
+}
+
+
+int parseUrl(char * url, char * protocol, char * host, int * port, char * path, size_t bufflen)
+{
+char * bracketPtr = NULL;
+char * colonPtr = NULL;
+char * slashPtr;
+int len;
+
+/* trim trailing whitespace like '/r/n' from url */
+len = strlen(url);
+while(*(url + len) <= ' ' && len > 0)
+    {
+    *(url + len) = 0;
+    len--;
+    }
+
+*port = 80;
+
+if(my_strnicmp(url, "http://", 7) == 0)
+    {
+    strncpy(protocol,"http", MAX_PROTOCOL );
+    if( (ADDR_FAMILY == AF_INET6) && (*(url + 7) == '[') )
+        strncpy(host, url+8, bufflen);
+    else
+        strncpy(host, url+7, bufflen);
+    }
+else if( my_strnicmp(url, "https://", 8) == 0)
+    {
+    strncpy(protocol, "https", MAX_PROTOCOL);
+    if( (ADDR_FAMILY == AF_INET6) && (*(url + 8) == '[') )
+        strncpy(host, url+9, bufflen);
+    else
+        strncpy(host, url+8, bufflen);
+    }
+else 
+    return(FALSE);
+
+if(ADDR_FAMILY == AF_INET6)
+    bracketPtr = strchr(host, ']');
+else
+    colonPtr = strchr(host, ':');
+
+slashPtr = strchr(host, '/');
+
+if(ADDR_FAMILY == AF_INET6)
+    {
+    if (bracketPtr != NULL && (slashPtr == NULL || bracketPtr < slashPtr))
+        {
+        *bracketPtr = '\0';
+        if(*(bracketPtr + 1) == ':')
+            *port = atoi(bracketPtr + 2);
+        }
+    else
+        {
+        colonPtr = strchr(host, ':');
+        if (colonPtr != NULL && (slashPtr == NULL || colonPtr < slashPtr)) 
+            {
+            *colonPtr++ = '\0';
+            *port = atoi(colonPtr);
+            }
+        }
+    }
+else
+    {   
+    if (colonPtr != NULL && (slashPtr == NULL || colonPtr < slashPtr)) 
+        {
+        *colonPtr++ = '\0';
+        *port = atoi(colonPtr);
+        }
+    }
+
+if(path == NULL) return(TRUE);
+
+if (slashPtr != NULL) 
+    {
+    *slashPtr++ = '\0';
+    strncpy(path, slashPtr, bufflen);
+    } 
+else
+    strncpy(path, "", bufflen);
+
+/* printf("protocol:%s host:%s port:%d path:%s\n", protocol, host, *port, path); */
+
+return(TRUE);
+}
+
+void parsePath(char * url, char * path, size_t bufflen)
+{
+int len;
+
+/* trim trailing whitespace like '/r/n' from url */
+len = strlen(url);
+while(*(url + len) <= ' ' && len > 0)
+    {
+    *(url + len) = 0;
+    len--;
+    }
+    
+/* trim leading whitespace */
+while(*url <= ' ') url++;
+strncpy(path, url, bufflen);
+}
+
+size_t parseValue(char * str)
+{
+while(!isDigit((unsigned char)*str) && *str != 0) ++str;
+return atol(str);
+}
+
+CELL * webError(int errorNo)
+{
+char msg[64];
+
+netErrorIdx = errorNo;
+snprintf(msg, 64, "ERR: %s", netErrorMsg[errorNo]);
+
+return(stuffString(msg));
+}
+#endif /* ifndef EMSCRIPTEN */
+
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * $Id: base64.c,v 1.32 2004/12/15 01:38:25 danf Exp $
+ ***************************************************************************/
+
+/* Base64 encoding/decoding
+
+   this file from the cURL project is included in nl-web.c for the
+   newLISP functions 'base64-enc' and 'base64-dec' 
+
+   all #include statements have and the test harness rootines have
+   been stripped.  2005-1-6 Lutz Mueller
+*/
+
+
+static void decodeQuantum(unsigned char *dest, const char *src)
+{
+  unsigned int x = 0;
+  int i;
+  for(i = 0; i < 4; i++) {
+    if(src[i] >= 'A' && src[i] <= 'Z')
+      x = (x << 6) + (unsigned int)(src[i] - 'A' + 0);
+    else if(src[i] >= 'a' && src[i] <= 'z')
+      x = (x << 6) + (unsigned int)(src[i] - 'a' + 26);
+    else if(src[i] >= '0' && src[i] <= '9')
+      x = (x << 6) + (unsigned int)(src[i] - '0' + 52);
+    else if(src[i] == '+')
+      x = (x << 6) + 62;
+    else if(src[i] == '/')
+      x = (x << 6) + 63;
+    else if(src[i] == '=')
+      x = (x << 6);
+  }
+
+  dest[2] = (unsigned char)(x & 255);
+  x >>= 8;
+  dest[1] = (unsigned char)(x & 255);
+  x >>= 8;
+  dest[0] = (unsigned char)(x & 255);
+}
+
+/*
+ * Curl_base64_decode()
+ *
+ * Given a base64 string at src, decode it into the memory pointed to by
+ * dest. Returns the length of the decoded data.
+ */
+size_t Curl_base64_decode(const char *src, char *dest)
+{
+  int length = 0;
+  int equalsTerm = 0;
+  int i;
+  int numQuantums;
+  unsigned char lastQuantum[3];
+  size_t rawlen=0;
+
+  while((src[length] != '=') && src[length])
+    length++;
+  while(src[length+equalsTerm] == '=')
+    equalsTerm++;
+
+  if(equalsTerm > 3) equalsTerm = 3; /* LM added 2006-09-08 */
+
+  numQuantums = (length + equalsTerm) / 4;
+
+  if(numQuantums == 0) return(0);
+
+  rawlen = (numQuantums * 3) - equalsTerm;
+
+  for(i = 0; i < numQuantums - 1; i++) {
+    decodeQuantum((unsigned char *)dest, src);
+    dest += 3; src += 4;
+  }
+
+  decodeQuantum(lastQuantum, src);
+  for(i = 0; i < 3 - equalsTerm; i++)
+    dest[i] = lastQuantum[i];
+
+  return rawlen;
+}
+
+#define BASE64_ENC 0
+#define BASE64_DEC 1
+
+CELL * p_base64Enc(CELL * params) { return(base64(params, BASE64_ENC)); }
+CELL * p_base64Dec(CELL * params) { return(base64(params, BASE64_DEC)); }
+
+CELL * base64(CELL * params, int type)
+{
+char * inPtr;
+char * outPtr;
+size_t sizein, sizeout;
+int emptyFlag = 0;
+
+params = getStringSize(params, &inPtr, &sizein, TRUE);
+emptyFlag = getFlag(params);
+
+if(type == BASE64_ENC)
+    {
+    if(sizein == 0)
+        return(emptyFlag ? stuffString("") : stuffString("===="));
+    if((sizeout = Curl_base64_encode(inPtr, sizein, &outPtr)) == 0)
+        return(stuffString(""));
+    }
+else    /* BASE64_DEC */
+    {
+    outPtr = allocMemory((sizein * 3) / 4 + 9);
+    sizeout = Curl_base64_decode(inPtr, outPtr);
+    *(outPtr + sizeout) = 0;
+    }
+    
+/*
+strCell = getCell(CELL_STRING);
+strCell->contents = (UINT)outPtr;
+strCell->aux = sizeout + 1;
+return(strCell);
+*/
+
+return(makeStringCell(outPtr, sizeout));
+}
+
+/* ---- Base64 Encoding --- */
+static const char table64[]=
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/*
+ * Curl_base64_encode()
+ *
+ * Returns the length of the newly created base64 string. The third argument
+ * is a pointer to an allocated area holding the base64 data. If something
+ * went wrong, -1 is returned.
+ *
+ */
+size_t Curl_base64_encode(const char *inp, size_t insize, char **outptr)
+{
+  unsigned char ibuf[3];
+  unsigned char obuf[4];
+  int i;
+  int inputparts;
+  char *output;
+  char *base64data;
+
+  char *indata = (char *)inp;
+
+  *outptr = NULL; /* set to NULL in case of failure before we reach the end */
+
+  if(0 == insize)
+    insize = strlen(indata);
+
+  base64data = output = (char*)malloc(insize*4/3+4);
+  if(NULL == output)
+    return 0;
+
+  while(insize > 0) {
+    for (i = inputparts = 0; i < 3; i++) {
+      if(insize > 0) {
+        inputparts++;
+        ibuf[i] = *indata;
+        indata++;
+        insize--;
+      }
+      else
+        ibuf[i] = 0;
+    }
+
+    obuf [0] = (ibuf [0] & 0xFC) >> 2;
+    obuf [1] = ((ibuf [0] & 0x03) << 4) | ((ibuf [1] & 0xF0) >> 4);
+    obuf [2] = ((ibuf [1] & 0x0F) << 2) | ((ibuf [2] & 0xC0) >> 6);
+    obuf [3] = ibuf [2] & 0x3F;
+
+    switch(inputparts) {
+    case 1: /* only one byte read */
+      snprintf(output, 5, "%c%c==",
+               table64[obuf[0]],
+               table64[obuf[1]]);
+      break;
+    case 2: /* two bytes read */
+      snprintf(output, 5, "%c%c%c=",
+               table64[obuf[0]],
+               table64[obuf[1]],
+               table64[obuf[2]]);
+      break;
+    default:
+      snprintf(output, 5, "%c%c%c%c",
+               table64[obuf[0]],
+               table64[obuf[1]],
+               table64[obuf[2]],
+               table64[obuf[3]] );
+      break;
+    }
+    output += 4;
+  }
+  *output=0;
+  *outptr = base64data; /* make it return the actual data memory */
+
+  return strlen(base64data); /* return the length of the new data */
+}
+/* ---- End of Base64 Encoding ---- */
+
+
+#ifndef EMSCRIPTEN
+/* --------------------------- HTTP server mode -----------------------------
+   Handles GET, POST, PUT and DELETE requests
+   handles queries in GET requests and sets environment variables 
+   DOCUMENT_ROOT, REQUEST_METHOD, SERVER_SOFTWARE and QUERY_STRING,
+   and when present in client request header HTTP_HOST, HTTP_USER_AGENT
+   and HTTP_COOKIE. REMOTE_ADDR is set when the client connects.
+   Subset HTTP/1.0 compliant.
+*/
+#ifndef LIBRARY
+/* #define DEBUGHTTP  */
+#define SERVER_SOFTWARE "newLISP/10.7.0"
+
+int sendHTTPmessage(int status, char * description, char * request);
+void handleHTTPcgi(char * command, char * query, ssize_t querySize);
+size_t readHeader(char * buff, int * pragmaFlag);
+ssize_t readPayLoad(ssize_t size, char * content, int outFile, char * request);
+int endsWith(char * str, char * ext);
+char * getMediaType(char * request);
+void url_decode(char *dest, char *src);
+
+void sendHTTPpage(char * content, size_t size, char * media)
+{
+int pos = 0;
+char status[128];
+
+memset(status, 0, 128);
+if(strncmp(content, "Status:", 7) == 0)
+    {
+    /* get content after */
+    while(*(content + pos) >= 32) pos++;
+    memcpy(status, content + 7, pos - 7); 
+    content = content + pos;
+    if(size) size -= pos;
+    while(*content == '\r' || *content == '\n') { content++; size--; }
+    }
+else
+    strncpy(status, "200 OK", 6);
+
+varPrintf(OUT_CONSOLE, "HTTP/1.0 %s\r\n", status);
+varPrintf(OUT_CONSOLE, "Server: newLISP v.%d (%s)\r\n", version, OSTYPE);
+#ifdef DEBUGHTTP
+puts("# Header sent:");
+printf("HTTP/1.0 %s\r\n", status);
+printf("Server: newLISP v.%d (%s)\r\n", version, OSTYPE);
+#endif
+
+if(media != NULL)
+    {
+    varPrintf(OUT_CONSOLE, "Content-length: %d\r\nContent-type: %s\r\n\r\n", size, media);
+#ifdef DEBUGHTTP
+    printf("Content-length: %d\r\nContent-type: %s\r\n\r\n", (int)size, media);
+#endif
+    }
+#ifndef WINDOWS
+size = write(fileno(IOchannel), content, size); 
+fflush(IOchannel); 
+fclose(IOchannel); 
+IOchannel = NULL;
+#else /* it is WINDOWS */
+if(IOchannel != NULL && IOchannelIsSocketStream)
+    {
+    sendall(getSocket(IOchannel), content, size);
+    close(getSocket(IOchannel));
+    }
+else 
+    varPrintf(OUT_CONSOLE, "%s", content);
+return;
+#endif
+#ifdef DEBUGHTTP
+printf("# content:%s:\r\n", content);
+fflush(stdout);
+#endif
+}
+
+#define MAX_BUFF 1024
+#define ERROR_404 "File or Directory not found"
+#define ERROR_411 "Length required for"
+#define ERROR_500 "Server error"
+#define DEFAULT_PAGE_1 "index.html"
+#define DEFAULT_PAGE_2 "index.cgi"
+#define CGI_EXTENSION ".cgi"
+#define MEDIA_TEXT "text/plain"
+
+
+int executeHTTPrequest(char * request, int type)
+{
+char * sptr;
+char * query;
+char * content = NULL;
+char * decoded;
+char buff[MAX_BUFF];
+ssize_t transferred, size;
+char * mediaType;
+CELL * result = NULL;
+int outFile;
+int pragmaFlag;
+int len;
+char * fileMode = "w";
+
+if(chdir(startupDir) < 0)
+    fatalError(ERR_IO_ERROR, 0, 0);
+query = sptr = request;
+
+setenv("DOCUMENT_ROOT", startupDir, 1);
+setenv("SERVER_SOFTWARE", SERVER_SOFTWARE, 1);
+setenv("REQUEST_METHOD", requestMethod[type], 1);
+
+#ifdef DEBUGHTTP
+printf("# HTTP request:%s:%s:\r\n", request, requestMethod[type]);
+#endif
+
+/* stuff after request */
+while(*sptr > ' ') ++sptr;
+*sptr = 0;
+while(*query != 0 && *query != '?') ++query;
+if(*query == '?')
+    {
+    *query = 0;
+    query++;
+    }
+
+setenv("QUERY_STRING", query, 1);
+
+/* do url_decode */
+decoded = alloca(strlen(request) + 1);
+url_decode(decoded, request);
+request = decoded;
+
+/* change to base dir of request file */
+sptr = request + strlen(request);
+while(*sptr != '/' && sptr != request) --sptr;
+if(*sptr == '/') 
+    {
+    *sptr = 0;
+    sptr++;
+    if(chdir(request))
+        {
+        sendHTTPmessage(404, ERROR_404, request);
+        return(TRUE);
+        }
+    request = sptr;
+    }
+
+if((len = strlen(request)) == 0)
+    {
+    if(isFile(DEFAULT_PAGE_2, 0) == 0) 
+        request = DEFAULT_PAGE_2;
+    else
+        request = DEFAULT_PAGE_1;
+    len = strlen(request);
+    }
+
+size = readHeader(buff, &pragmaFlag);
+switch(type)
+    {
+    case HTTP_GET:
+    case HTTP_HEAD:
+        if(endsWith(request, CGI_EXTENSION))
+            handleHTTPcgi(request, query, strlen(query));
+        else
+            {
+            mediaType = getMediaType(request);
+
+            if(type == HTTP_HEAD)
+                {
+                snprintf(buff, MAX_BUFF - 1, 
+                    "Content-length: %"PRId64"\r\nContent-type: %s\r\n\r\n",
+                    fileSize(request), mediaType);
+                sendHTTPpage(buff, strlen(buff), NULL);
+                }
+            else
+                {
+                if((size = readFile(request, &content)) == -1)
+                    sendHTTPmessage(404, ERROR_404, request);
+                else
+                    sendHTTPpage(content, size, mediaType);
+                if(content) free(content);
+                }
+            }
+        break;
+
+    case HTTP_DELETE:
+        if(unlink(request) != 0)    
+            sendHTTPmessage(500, "Could not delete", request);
+        else
+            sendHTTPpage("File deleted", 12, MEDIA_TEXT);
+        break;
+
+    case HTTP_POST:
+        if(!size)
+            {
+            sendHTTPmessage(411, ERROR_411, request);
+            break;
+            }
+
+        query = callocMemory(size + 1);
+
+        if(readPayLoad(size, query, 0, request) == -1)
+            {
+            free(query);
+            break;
+            }
+
+        handleHTTPcgi(request, query, size);
+        free(query); 
+        break;
+
+    case HTTP_PUT:
+        if(pragmaFlag) fileMode = "a";
+
+        if(!size)
+            {
+            sendHTTPmessage(411, ERROR_411, request);
+            break;
+            }
+
+        if( (outFile = openFile(request, fileMode, NULL)) == (int)-1)
+            {
+            sendHTTPmessage(500, "Cannot create file", request);
+            break;
+            }
+
+        transferred = readPayLoad(size, buff, outFile, request);
+#ifdef WINDOWS
+        _close(outFile);
+#else
+        close(outFile);
+#endif
+        if(transferred != -1)
+            {
+            snprintf(buff, 255, "%d bytes transferred for %s\r\n", (int)transferred, request);
+            sendHTTPpage(buff, strlen(buff), MEDIA_TEXT);
+            }
+        break;
+
+    default:
+        break;
+    }
+
+if(chdir(startupDir) < 0) fatalError(ERR_IO_ERROR, 0, 0);
+if(result != NULL) deleteList(result);
+return(TRUE);
+}
+
+
+int sendHTTPmessage(int status, char * desc, char * req)
+{
+char msg[256];
+
+snprintf(msg, 256, "Status:%d %s\r\nERR:%d %s: %s\r\n", status, desc, status, desc, req);
+sendHTTPpage(msg, strlen(msg), MEDIA_TEXT);
+return(0);
+}
+
+
+/* remove leading white space */ 
+char * trim(char * buff) 
+{
+char * ptr = buff;
+while(*ptr <= ' ') ptr++;
+return(ptr);
+}
+
+/* retrieve rest of header */
+size_t readHeader(char * buff, int * pragmaFlag)
+{
+size_t size = 0;
+int offset;
+char numStr[16];
+
+*pragmaFlag = 0;
+
+memset(buff, 0, MAX_LINE);
+
+setenv("HTTP_HOST", "", 1);
+setenv("HTTP_USER_AGENT", "", 1);
+setenv("HTTP_COOKIE", "", 1);
+setenv("HTTP_AUTHORIZATION", "", 1);
+
+while(fgets(buff, MAX_LINE - 1, IOchannel) != NULL)
+    {
+    if(strcmp(buff, "\r\n") == 0 || strcmp(buff, "\n") == 0) break;
+
+    /* trim trailing white space */
+    offset = strlen(buff) - 1;
+    while(offset > 0 && *(buff + offset) <= ' ') 
+        *(buff + offset--) = 0; 
+
+    if(my_strnicmp(buff, "content-length:", 15) == 0)
+        {
+        size = parseValue(buff + 15);
+#if defined(WINDOWS) || defined(TRU64)
+        snprintf(numStr, 16, "%lu", (long unsigned int)size);
+#else
+        snprintf(numStr, 16, "%llu", (long long unsigned int)size);
+#endif
+        setenv("CONTENT_LENGTH", numStr, 1);
+        }
+    if(my_strnicmp(buff, "pragma: append", 14) == 0)
+        *pragmaFlag = TRUE;
+
+    /* trim leading white space */
+    if(my_strnicmp(buff, "content-type:", 13) == 0)
+        setenv("CONTENT_TYPE", trim(buff + 13), 1);
+    if(my_strnicmp(buff, "Host:", 5) == 0)
+        setenv("HTTP_HOST", trim(buff + 5), 1);
+    if(my_strnicmp(buff, "User-Agent:", 11) == 0)
+        setenv("HTTP_USER_AGENT", trim(buff + 11), 1);
+    if(my_strnicmp(buff, "Cookie:", 7) == 0)
+        setenv("HTTP_COOKIE", trim(buff + 7), 1);
+    if(my_strnicmp(buff, "Authorization:", 14) == 0)
+        setenv("HTTP_AUTHORIZATION", trim(buff + 14), 1);
+    }
+
+
+return(size);
+}
+
+
+ssize_t readPayLoad(ssize_t size, char * buff, int outFile, char * request)
+{
+ssize_t bytes, readsize;
+size_t offset = 0, transferred = 0;
+
+#ifdef DEBUGHTTP
+printf("# Payload size:%ld\r\n", (long)size);
+#endif
+
+while(size > 0)
+    {
+    readsize = (size > MAX_BUFF) ? MAX_BUFF : size;
+#ifndef WINDOWS
+    bytes = read(fileno(IOchannel), buff + offset, readsize); 
+#else /* it is WINDOWS */
+    if(IOchannel != NULL && IOchannelIsSocketStream)
+        bytes = recv(getSocket(IOchannel), buff + offset, readsize, NO_FLAGS_SET);
+    else
+        bytes = read(fileno(IOchannel), buff + offset, readsize);
+#endif
+
+#ifdef DEBUGHTTP
+    printf("Payload bytes:%ld:%s:\r\n", (long)bytes, buff + offset);
+#endif
+
+    if(bytes <= 0)
+        {
+        sendHTTPmessage(500, "Problem reading data", request);
+        return(-1);
+        }
+
+    if(outFile)
+        {
+        if(write(outFile, buff + offset, bytes) != bytes)
+            {
+            sendHTTPmessage(500, "Cannot create file", request);
+            return(-1);
+            }
+        }
+    else
+        offset += bytes;
+
+    transferred += bytes;
+    size -= bytes;
+    }   
+#ifndef WINDOWS
+fflush(NULL); 
+#endif
+return(transferred);
+}
+
+
+
+void handleHTTPcgi(char * request, char * query, ssize_t querySize)
+{
+FILE * handle;
+char * command;
+char * content = NULL;
+ssize_t size;
+char tempfile[PATH_MAX];
+#ifdef WINDOWS_BEFORE_SETTING_BINARYMODE
+char * ptr;
+char * pos;
+int bytes = 0;
+#endif
+
+srandom(milliSecTime());
+
+#ifdef DEBUGHTTP
+printf("# CGI request:%s:%s:\r\n", request, query);
+#endif
+
+if(isFile(request, 0) != 0)
+    {
+    sendHTTPmessage(404, ERROR_404, request);
+    return;
+    }
+
+if(isFile(tempDir, 0) != 0)
+    {
+    sendHTTPmessage(500, "cannot find tmp directory", request);
+    return;
+    }
+
+size = strlen(request) + PATH_MAX;
+command = alloca(size);
+snprintf(tempfile, PATH_MAX, "%s/nl%04x-%08x-%08x", 
+    tempDir, (unsigned int)size, (unsigned int)random(), (unsigned int)random());
+
+#if defined (WINDOWS) || (OS2)
+snprintf(command, size - 1, "newlisp \"%s\" > %s", request, tempfile);
+#else
+snprintf(command, size - 1, "./\"%s\" > %s", request, tempfile);
+#endif
+
+if((handle = popen(command, "w")) == NULL)
+    {
+    sendHTTPmessage(500, "failed creating pipe", request);
+    return;
+    }
+
+if((size = fwrite(query, 1, querySize, handle)) < 0)
+    fatalError(ERR_IO_ERROR, 0, 0);
+
+fflush(handle);
+pclose(handle);
+
+size = readFile(tempfile, &content);
+if(size == -1)  
+    sendHTTPmessage(500, "cannot read output of", tempfile);
+else
+    sendHTTPpage(content, size, NULL);
+    
+#ifdef DEBUGHTTP
+printf("# Temporary file: %s\n", tempfile);
+#else
+unlink(tempfile);
+#endif
+
+if(content) free(content);
+}   
+
+
+int endsWith(char * str, char * ext)
+{
+size_t size, len;
+
+size = strlen(str);
+len =  strlen(ext);
+
+return(strncmp(str + size - len, ext, len) == 0);
+}
+
+
+typedef struct
+    {
+    char * extension;
+    char * type;
+    } T_MEDIA_TYPE;
+
+/* T_ prefix added in 10.4.8 to compile on later MinGW */
+
+T_MEDIA_TYPE mediaType[] = {
+    {".avi", "video/x-msvideo"},
+    {".css", "text/css"},
+    {".gif", "image/gif"},
+    {".htm", "text/html"},
+    {".html","text/html"},
+    {".jpg", "image/jpeg"},
+    {".js", "application/javascript"},
+    {".mov", "video/quicktime"},
+    {".mp3", "audio/mpeg"},
+    {".mpg", "video/mpeg"},
+    {".pdf", "application/pdf"},
+    {".png", "image/png"},
+    {".wav", "audio/x-wav"},
+    {".zip", "application/zip"},
+    { NULL, NULL},
+};
+
+char * getMediaType(char * request)
+{
+int i;
+
+for(i = 0; mediaType[i].extension != NULL; i++)
+    {
+    if(endsWith(request, mediaType[i].extension))
+        return(mediaType[i].type);
+    }
+    
+return(MEDIA_TEXT);
+}
+
+ 
+void url_decode(char *dest, char *src)
+{
+char code[3] = {0};
+unsigned int ascii = 0;
+char *end = NULL;
+
+while(*src)
+    {
+    if(*src == '%')
+        {
+        memcpy(code, ++src, 2);
+        ascii = strtoul(code, &end, 16);
+        *dest++ = (char)ascii;
+        src += 2;
+        }
+    else
+        *dest++ = *src++;
+    }
+*dest = 0;
+}
+
+#endif /* ifndef EMSCRIPTEN */
+#endif /* ifndef LIBRARY */
+/* eof */
+
diff --git a/nl-xml-json.c b/nl-xml-json.c
new file mode 100644
index 0000000..8b69e25
--- /dev/null
+++ b/nl-xml-json.c
@@ -0,0 +1,1051 @@
+/* nl-xml-json.c - newLISP XML and JSON interface 
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+
+#ifdef XML_SUPPORT
+
+#define XML_TEXT 0
+#define XML_CDATA 1
+#define XML_COMMENT 2
+#define XML_ELEMENT 3
+
+int isWhiteSpaceStringN(char * source, int tagPos);
+CELL * makeTagSymbolCell(char * tagStart, int tagLen);
+void performXmlCallback(CELL * cell, char * start);
+
+char * typeNames[] =
+  {
+  "TEXT",
+  "CDATA",
+  "COMMENT",
+  "ELEMENT"
+  };
+
+CELL * xmlTags = NULL;
+CELL * typeCell[4];
+
+static char * xmlError;
+static char xmlMsg[64];
+static char * sourceOrg;
+static char * source;
+
+static SYMBOL * XMLcontext;
+
+UINT optionsFlag;
+#define OPTION_NO_OPTION 0
+#define OPTION_NO_WHITESPACE 1
+#define OPTION_NO_EMPTY_ATTRIBUTES 2
+#define OPTION_NO_COMMENTS 4
+#define OPTION_TAGS_TO_SYMBOLS 8
+#define OPTION_SXML_ATTRIBUTES 16
+
+
+typedef struct
+    {
+    char * name;
+    void * next;
+    } TAG_STACK;
+
+TAG_STACK * tagStack = NULL;
+
+CELL * xmlCallback = NULL;
+
+/* setup type tag default cells, if done already just relink */
+CELL * setupTypeTagCells(void)
+{
+int i;
+
+if(xmlTags == NULL)
+    {
+    xmlTags = getCell(CELL_EXPRESSION);
+    for(i = 0; i < 4; i++)
+        typeCell[i] = stuffString(typeNames[i]);
+    }
+    
+/* link cells in a list */
+xmlTags->contents = (UINT)typeCell[0];
+for(i = 0; i < 3; i++)
+    typeCell[i]->next = typeCell[i+1];
+    
+return(xmlTags);
+}
+
+CELL * p_XMLtypeTags(CELL * params)
+{
+int i;
+
+if(params == nilCell) 
+    return(copyCell(setupTypeTagCells()));
+
+if(xmlTags != NULL)
+    deleteList(xmlTags);
+
+xmlTags = getCell(CELL_EXPRESSION);
+    
+for(i = 0; i < 4; i++)
+    {
+    typeCell[i] = copyCell(evaluateExpression(params));
+    params = params->next;
+    }
+
+return(copyCell(setupTypeTagCells()));
+}
+
+CELL * p_XMLparse(CELL * params)
+{
+CELL * result;
+
+if(xmlCallback != NULL)
+    errorProc(ERR_NOT_REENTRANT);
+
+params = getString(params, &source);
+if(params != nilCell)
+    {
+    params = getInteger(params, &optionsFlag);
+    if(params != nilCell)
+        {
+        XMLcontext = getCreateContext(params, TRUE);
+        if(XMLcontext == NULL)
+            return(errorProc(ERR_SYMBOL_OR_CONTEXT_EXPECTED));
+        if(params->next != nilCell)
+            xmlCallback = params->next; 
+        else
+            xmlCallback = NULL;
+        }
+    else
+        XMLcontext = currentContext;
+    }
+else 
+    optionsFlag = OPTION_NO_OPTION;
+
+setupTypeTagCells();
+
+xmlError = NULL;
+sourceOrg = source;
+deleteTagStack();
+
+result = parseDoc();
+deleteTagStack();
+
+xmlCallback = NULL;
+
+if(xmlError != NULL)
+    return nilCell;
+else
+    return result;
+}
+
+
+CELL * p_XMLerror(CELL * params)
+{
+CELL * errorCell;
+CELL * cell;
+
+if(xmlError == NULL)
+    return(nilCell);
+
+cell = stuffString(xmlError);
+errorCell = makeCell(CELL_EXPRESSION, (UINT)cell);
+
+cell->next = stuffInteger((UINT)(source - sourceOrg));
+
+return errorCell;
+}
+
+void deleteTagStack(void)
+{
+TAG_STACK * oldTagStack;
+
+while(tagStack != NULL)
+    {
+    oldTagStack = tagStack;
+    freeMemory(tagStack->name);
+    tagStack = tagStack->next;
+    freeMemory(oldTagStack);
+    }
+}
+
+
+CELL * parseDoc(void)
+{
+CELL * node;
+CELL * lastNode;
+int closingFlag = FALSE;
+int tagPos;
+
+lastNode = node = getCell(CELL_EXPRESSION);
+
+while(!xmlError && !closingFlag)
+    {
+    if((tagPos = find("<", source)) == -1) break;
+    if(tagPos > 0)
+        {
+        if( (tagStack != NULL) || (node->contents != (UINT)nilCell))
+            {
+            if((optionsFlag & OPTION_NO_WHITESPACE) && isWhiteSpaceStringN(source, tagPos))
+                        {;}
+            else lastNode = appendNode(lastNode, makeTextNode(XML_TEXT, stuffStringN(source, tagPos)));
+            }
+        source = source + tagPos;
+        }
+
+    if(strncmp(source, "<!DOCTYPE", 9) == 0)
+        {
+        parseDTD();
+        continue;
+        }
+
+    if(*source == '<' && *(source + 1) == '?')
+        {
+        parseProcessingInstruction();
+        continue;
+        }
+
+    if(memcmp(source, "<!--", 4) == 0)
+        {
+        if(optionsFlag & OPTION_NO_COMMENTS)
+            parseTag("-->");
+        else
+            lastNode = appendNode(lastNode, parseTag("-->"));
+        continue;
+        }
+    if(memcmp(source, "<![CDATA[", 9) == 0)
+        {
+        lastNode = appendNode(lastNode, parseTag("]]>"));
+        continue;
+        }
+
+    if(*source == '<' && *(source + 1) == '/')
+        {
+        closingFlag = TRUE;
+        parseClosing();
+        continue;
+        }
+
+    lastNode = appendNode(lastNode, parseTag(">"));
+    }
+
+
+if(xmlError != NULL)
+    {
+    deleteList(node);
+    return nilCell;
+    }
+
+return node;
+}
+
+
+void parseDTD(void)
+{
+int closeTag, squareTag;
+int closePos = 0;
+char * closeTagStr;
+
+if((closeTag = find(">", source)) == -1)
+    {
+    xmlError = "error in DTD: expected '>'";
+    return;
+    }
+
+squareTag = find("[", source);
+if(squareTag != -1 && squareTag < closeTag)
+    closeTagStr = "]>";
+else
+    closeTagStr = ">";
+
+while(!xmlError)
+    {
+    if((closePos = find(closeTagStr, source)) == -1)
+        {
+        snprintf(xmlMsg, 63, "expected: %s", closeTagStr);
+        xmlError = xmlMsg;
+        return;
+        }
+    if(*(source + closePos - 1) != ']')
+        break;
+    source = source + closePos + strlen(closeTagStr);
+    }
+
+source = source + closePos + strlen(closeTagStr);
+return;
+}
+
+
+void parseProcessingInstruction(void)
+{
+int closeTag;
+
+if((closeTag = find("?>", source)) == -1)
+    {
+    xmlError = "expecting closing tag sequence '?>'";
+    return;
+    }
+
+source = source + closeTag + 2;
+}
+
+
+void parseClosing(void)
+{
+int closeTag;
+char * tagName;
+TAG_STACK * oldTagStack;
+
+if((closeTag = find(">", source)) == -1)
+    {
+    xmlError = "missing closing >";
+    return;
+    }
+
+if(tagStack == NULL)
+    {
+    xmlError = "closing tag has no opening";
+    return;
+    }
+
+tagName = tagStack->name;
+if(strncmp(source + 2, tagName, strlen(tagName)) != 0)
+    {
+    xmlError = "closing tag doesn't match";
+    return;
+    }
+
+/* pop tagStack */
+freeMemory(tagName);
+oldTagStack = tagStack;
+tagStack = tagStack->next;
+
+freeMemory(oldTagStack);
+
+source = source + closeTag + 1;
+}
+
+
+CELL * parseTag(char * closeTagStr)
+{
+char * newSrc;
+char * tagStart;
+int closeTag;
+CELL * cell;
+
+tagStart = source;
+
+cell = NULL;
+closeTag = find(closeTagStr, source);
+if(*(source + closeTag - 1) == '/')
+    {
+    if(memcmp(closeTagStr,"]]>",3) != 0)
+        {
+        --closeTag;
+        closeTagStr = "/>";
+        }
+    }
+
+if(closeTag == -1)
+    {
+    snprintf(xmlMsg, 63, "expected closing tag: %s", closeTagStr);
+    xmlError = xmlMsg;
+    return nilCell;
+    }
+
+if(memcmp(source, "<!--", 4) == 0)
+    {
+    if(optionsFlag & OPTION_NO_COMMENTS)
+        cell = nilCell;
+    else
+        {
+        cell = stuffStringN(source + 4, closeTag - 4);
+        cell = makeTextNode(XML_COMMENT, cell);
+        }
+    }
+
+if(memcmp(source, "<![CDATA[", 9) == 0)
+    {
+    cell = stuffStringN(source + 9, closeTag - 9);
+    cell = makeTextNode(XML_CDATA, cell);
+    }
+
+if(*source == '<' && *(source + 1) == '/')
+    {
+    xmlError = "closing node has no opening";
+    return nilCell;
+    }
+
+newSrc = source + closeTag + strlen(closeTagStr);
+
+if(cell == NULL)
+    cell = parseNormalTag(source + closeTag, newSrc);
+else
+    source = newSrc;
+
+/* call back with closed tag expression found
+   and opening start and end of source of this
+   tag expression
+*/
+
+if(xmlCallback) 
+    performXmlCallback(cell, tagStart);
+
+return(cell);
+}
+
+
+void performXmlCallback(CELL * result, char * tagStart)
+{
+CELL * list;
+CELL * cell;
+CELL * next;
+int errNo;
+
+list = makeCell(CELL_EXPRESSION, (UINT)copyCell(xmlCallback));
+cell = makeCell(CELL_QUOTE, (UINT)copyCell(result));
+
+cell->next = stuffInteger((UINT)(tagStart - sourceOrg));
+next = cell->next;
+next->next = stuffInteger((UINT)(source - tagStart));
+((CELL*)list->contents)->next = cell;
+pushResult(list);
+if(!evaluateExpressionSafe(list, &errNo))
+    {
+    deleteTagStack();
+    longjmp(errorJump, errNo);
+    }
+}
+
+
+CELL * parseNormalTag(char * endSrc, char * newSrc)
+{
+char * tagStart;
+int tagLen;
+CELL * attributes;
+CELL * childs;
+CELL * tagCell;
+TAG_STACK * tag;
+
+++source; /* skip '/' */
+
+while((unsigned char)*source <= ' ' && source < endSrc) ++source; /* skip whitespace */
+
+tagStart = source;
+tagLen = 0;
+while((unsigned char)*source > ' ' && source < endSrc) ++source, ++tagLen; /* find tag end */
+
+if(tagLen > MAX_SYMBOL)
+    {
+    xmlError = "tag name too long";
+    return nilCell;
+    }
+
+attributes = parseAttributes(endSrc);
+if(optionsFlag & OPTION_SXML_ATTRIBUTES)
+    {
+    childs = (CELL*)attributes->contents;
+    if(! (childs == nilCell && (optionsFlag & OPTION_NO_EMPTY_ATTRIBUTES)))
+        {
+        attributes->contents = (UINT)stuffSymbol(atSymbol);
+        ((CELL*)(attributes->contents))->next = childs;
+        }
+    }
+
+if(xmlError) 
+    return nilCell;
+
+if(*source == '/' && *(source + 1) == '>')
+    {
+    source = newSrc;
+    if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
+        tagCell = makeTagSymbolCell(tagStart, tagLen);
+    else
+        tagCell = stuffStringN(tagStart, tagLen);
+    return makeElementNode(tagCell, attributes, getCell(CELL_EXPRESSION));
+    }
+
+/* push tag on tagstack */
+tag = (TAG_STACK*)allocMemory(sizeof(TAG_STACK));
+tag->name = (char *)callocMemory(tagLen + 1);
+memcpy(tag->name, tagStart, tagLen);
+tag->next = tagStack;
+tagStack = tag;
+
+source = newSrc;
+childs = parseDoc();
+
+if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
+    tagCell = makeTagSymbolCell(tagStart, tagLen);
+else
+    tagCell = stuffStringN(tagStart, tagLen);
+
+return makeElementNode(tagCell, attributes, childs);
+}
+
+
+CELL * makeTagSymbolCell(char * tagStart, int tagLen)
+{
+char * name;
+char * ptr;
+CELL * cell;
+
+name = (char *)callocMemory(tagLen + 1);
+memcpy(name, tagStart, tagLen);
+
+if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
+    if((ptr = strstr(name, ":")))  *ptr = '.';
+
+cell = stuffSymbol(translateCreateSymbol(name, CELL_NIL, XMLcontext, 1));
+freeMemory(name);
+return(cell);
+}
+
+
+CELL * parseAttributes(char * endSrc)
+{
+CELL * attributes;
+CELL * att;
+CELL * cell;
+CELL * lastAtt;
+char * namePos;
+char * valPos;
+char quoteChar;
+int  nameLen, valLen;
+
+attributes = getCell(CELL_EXPRESSION);
+lastAtt = NULL;
+
+while(!xmlError && source < endSrc)
+    {
+    while((unsigned char)*source <= ' ' && source < endSrc) source++; /* strip leading space */
+    namePos = source;
+    nameLen = 0;
+    while((unsigned char)*source > ' ' && *source != '=' && source < endSrc) source++, nameLen++; /* get end */
+    if(nameLen == 0) break;
+    if(nameLen > MAX_SYMBOL)
+        {
+        xmlError = "attribute name too long";
+        return nilCell;
+        }
+    while((unsigned char)*source <= ' ' && source < endSrc) source++; /* strip leading space */
+    if(*source != '=')
+        {
+        xmlError = "expected '=' in attributes";
+        deleteList(attributes);
+        return nilCell;
+        }
+    else source++;
+    while((unsigned char)*source <= ' ' && source < endSrc) source++; /* strip spaces */
+    if(*source != '\"' && *source != '\'')
+        {
+        xmlError = "attribute values must be delimited by \" or \' ";
+        deleteList(attributes);
+        return nilCell;
+        }
+    quoteChar = *source;
+    source++;
+    valPos = source;
+    valLen = 0;
+    while(*source != quoteChar && source < endSrc) source++, valLen++;
+    if(*source != quoteChar) valLen = -1;
+    else source++;
+    if(nameLen == 0 || valLen == -1)
+        {
+        xmlError = "incorrect attribute";
+        deleteList(attributes);
+        return nilCell;
+        }
+    att = getCell(CELL_EXPRESSION);
+    if(optionsFlag & OPTION_TAGS_TO_SYMBOLS)
+            cell = makeTagSymbolCell(namePos, nameLen);
+    else
+        cell = stuffStringN(namePos, nameLen);
+    cell->next = stuffStringN(valPos, valLen);
+    att->contents = (UINT)cell;
+    if(lastAtt == NULL)
+        attributes->contents = (UINT)att;
+    else 
+        lastAtt->next = att;
+    lastAtt = att;
+    }
+
+return attributes;
+}
+
+
+CELL * appendNode(CELL * node, CELL * newNode)
+{
+if(node->contents == (UINT)nilCell)
+    node->contents = (UINT)newNode;
+else
+    node->next = newNode;
+
+return newNode;
+}
+
+
+CELL * makeTextNode(int type, CELL * contents)
+{
+CELL * cell;
+
+/* unwrap text node if nil xml-type-tag */
+if(typeCell[type]->type == CELL_NIL)
+    return(contents);
+
+cell = copyCell(typeCell[type]);
+cell->next = contents;
+
+return(makeCell(CELL_EXPRESSION, (UINT)cell));
+}
+
+
+CELL * makeElementNode(CELL * tagNode, CELL * attributesNode, CELL * childrenNode)
+{
+CELL * newNode;
+CELL * cell;
+
+/* unwrap children node, if nil in xml-type-tag */
+if(typeCell[XML_ELEMENT]->type == CELL_NIL)
+    {
+    cell = childrenNode;
+    childrenNode = (CELL *)childrenNode->contents;
+    cell->contents = (UINT)nilCell;
+    deleteList(cell);
+    }
+
+newNode = getCell(CELL_EXPRESSION);
+if(typeCell[XML_ELEMENT]->type == CELL_NIL)
+    newNode->contents = (UINT)tagNode;
+else
+    {
+    cell = copyCell(typeCell[XML_ELEMENT]);
+    newNode->contents = (UINT)cell;
+    cell->next = tagNode;
+    }
+
+if( (attributesNode->contents == (UINT)nilCell) && 
+    (optionsFlag & OPTION_NO_EMPTY_ATTRIBUTES))
+    {
+    tagNode->next = childrenNode;
+    deleteList(attributesNode);
+    }
+else
+    {
+    tagNode->next = attributesNode;
+    attributesNode->next = childrenNode;
+    }
+
+return newNode;
+}
+    
+
+int find(char * key, char * source)
+{
+char * ptr;
+
+ptr = strstr(source, key);
+if(ptr == NULL) return -1;
+
+return(ptr - source);
+}
+    
+
+int isWhiteSpaceStringN(char * source, int tagPos)
+{
+while(tagPos--) if((unsigned char)*source++ > 32) return(FALSE);
+return(TRUE);
+}
+
+#endif /* XML_SUPPORT */
+
+/* --------------------------------- JSON interface ------------------------- */
+
+CELL * getJSONobject(char * jsonStr, char * * restStr);
+CELL * getJSONstring(char * jsonStr, char * * restStr);
+CELL * getJSONvalue(char * jsonStr, char * * restStr);
+CELL * setJSONerror(char * errorText, char * jsonStr);
+
+#define ERR_JSON_MISSING_BRACE "missing {"
+#define ERR_JSON_MISSING_COLON "missing : colon"
+#define ERR_JSON_INVALID_OBJECT "invalid JSON object"
+#define ERR_JSON_MISSING_KEY "missing key"
+#define ERR_JSON_CLOSING_QUOTE "missing closing quote"
+#define ERR_JSON_INVALID_UNICODE "invalid unicode"
+#define ERR_JSON_INVALID_NUMBER "invalid JSON number format"
+#define ERR_JSON_INVALID_ARRAY "invalid JSON array format"
+#define ERR_JSON_INVALID_VALUE "invalid JSON value format"
+
+CELL * lastJSONerror = NULL;
+char * jsonStrStart;
+
+CELL * p_JSONparse(CELL * params)
+{
+char * restStr;
+
+if(lastJSONerror) deleteList(lastJSONerror);
+lastJSONerror = nilCell;
+getString(params, &jsonStrStart);
+return(getJSONvalue(jsonStrStart, &restStr));
+}
+
+
+CELL * getJSONobject(char * jsonStr, char * * restStr)
+{
+CELL * object;
+CELL * pair = NULL;
+CELL * key;
+char * ptr;
+
+
+/* a JSON object is a (key value) association expression */
+while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr; /* whitespace */
+
+if(*jsonStr != '{') 
+    return(setJSONerror(ERR_JSON_MISSING_BRACE, jsonStr));
+
+++jsonStr;
+/* make object envelope */
+while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr; /* whitespace */
+object = getCell(CELL_EXPRESSION);
+if(*jsonStr == '}')
+    {
+    *restStr = jsonStr + 1;
+    return(object);
+    }
+
+/* get a key : value pair */
+GET_PAIR:
+if(pair == NULL)
+    {
+    pair = getCell(CELL_EXPRESSION);
+    object->contents = (UINT)pair; /* !!! only the first time then pair->next */
+    }
+else
+    {
+    pair->next = getCell(CELL_EXPRESSION);
+    pair = pair->next;
+    }
+
+/* get key string */
+if((key = getJSONstring(jsonStr, &ptr)) == nilCell)
+    {
+    deleteList(object);
+    return(nilCell);
+    }
+pair->contents = (UINT)key;
+jsonStr = ptr;
+
+/* key and value must be separated by : colon */
+while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr; /* whitespace */
+if(*jsonStr != ':') 
+    {
+    deleteList(object);
+    return(setJSONerror(ERR_JSON_MISSING_COLON, jsonStr));
+    }
+
+if((key->next = getJSONvalue(++jsonStr, &ptr)) == nilCell)
+    {
+    deleteList(object);
+    return(nilCell);
+    }
+
+jsonStr = ptr;
+
+while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr; /* whitespace */
+if(*jsonStr == '}')
+    {
+    *restStr = jsonStr + 1;
+    return(object);
+    }
+
+if(*jsonStr == ',')
+    {
+    ++jsonStr;
+    goto GET_PAIR;
+    }
+
+deleteList(object);
+return(setJSONerror(ERR_JSON_INVALID_OBJECT, jsonStr));
+}
+
+
+CELL * getJSONstring(char * jsonStr, char * * restStr)
+{
+char * token;
+char * xlated;
+size_t size;
+int i, j;
+#ifdef SUPPORT_UTF8
+int len;
+char buff[8];
+#endif
+
+/* get key string */
+while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr; /* whitespace */
+
+if(*jsonStr != '"') return(setJSONerror(ERR_JSON_MISSING_KEY, jsonStr));
+
+token = ++jsonStr, size = 0;
+while(*jsonStr != '"' && *jsonStr != 0) 
+    {
+    if(*jsonStr == '\\')
+        ++jsonStr, ++size;
+    ++jsonStr, ++size;
+    }
+
+if(*jsonStr++ != '"') return(setJSONerror(ERR_JSON_CLOSING_QUOTE, jsonStr));
+
+*restStr = jsonStr;
+
+xlated = alloca(size + 1);
+i = j = 0;
+while(i < size)
+    {
+    if(*(token + i) == '\\')
+        {
+        ++i;
+        switch(*(token + i))
+            {
+            case '\\':
+                *(xlated + j++) = '\\';
+                break;
+            case '"': 
+                *(xlated + j++) = '"';
+                break;
+            case '/':
+                *(xlated + j++) = '/';
+                break;
+            case 'b': 
+                *(xlated + j++) = '\b';
+                break;
+            case 'f': 
+                *(xlated + j++) = '\f';
+                break;
+            case 'n': 
+                *(xlated + j++) = '\n';
+                break;
+            case 'r': 
+                *(xlated + j++) = '\r';
+                break;
+            case 't': 
+                *(xlated + j++) = '\t';
+                break;
+            case 'u': 
+                if(isxdigit((unsigned char)*(token + i + 1)) &&
+                   isxdigit((unsigned char)*(token + i + 2)) &&
+                   isxdigit((unsigned char)*(token + i + 3)) &&
+                   isxdigit((unsigned char)*(token + i + 4)))
+                    {
+#ifdef SUPPORT_UTF8
+                    buff[0] = '0';
+                    buff[1] = 'x';
+                    memcpy(buff + 2, token + i + 1, 4);
+                    buff[6] = 0;
+                    len = wchar_utf8(strtol(buff, NULL, 16), xlated + j);
+                    j += len;
+#else
+                    *(xlated + j) = '\\';
+                    memcpy(xlated + j + 1, token + i, 5);
+                    j += 6;
+#endif
+                    i += 4;
+                    }
+                else
+                    return(setJSONerror(ERR_JSON_INVALID_UNICODE, jsonStr));
+                break;
+            default:
+                *(xlated + j++) = *(token + i);
+                break;
+            }
+        ++i;
+        }
+    else
+        *(xlated + j++) = *(token + i++);
+    }
+
+*(xlated + j) = 0;
+return(stuffStringN(xlated, j));
+}
+
+
+/* get value as one of: string, number, object, array, true, false, null */
+CELL * getJSONvalue(char * jsonStr, char * * restStr)
+{
+CELL * cell;
+CELL * array = NULL;
+CELL * next = NULL;
+char * ptr;
+char * number;
+size_t len;
+int isFloat = FALSE;
+double floatNumber;
+SYMBOL * falseSymbol;
+SYMBOL * nullSymbol;
+
+while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr; /* whitespace */
+
+/* string value */
+if(*jsonStr == '"')
+    {
+    cell = getJSONstring(jsonStr, &ptr);
+    *restStr = ptr;
+    return(cell);
+    }
+    
+/* check if number digit or + - */
+if(isDigit((unsigned char)*jsonStr))
+    ptr = jsonStr++;
+else if((*jsonStr == '-' || *jsonStr == '+') && isDigit((unsigned char)*(jsonStr + 1)))
+    ptr = jsonStr++;
+else goto NOT_STRING_OR_NUMBER;
+
+number = alloca(32);
+while(isDigit((unsigned char)*jsonStr)) ++jsonStr;
+if(*jsonStr == '.')
+    {
+    isFloat = TRUE;
+    ++jsonStr;
+    while(isDigit((unsigned char)*jsonStr)) ++jsonStr;
+    }
+
+if(*jsonStr == 'e' || *jsonStr == 'E') 
+    {
+    isFloat = TRUE;
+    ++jsonStr;
+    if(*jsonStr == '-' || *jsonStr == '+')
+        ++jsonStr;
+    if(!isDigit((unsigned char)*jsonStr))
+        return(setJSONerror(ERR_JSON_INVALID_NUMBER, jsonStr));
+        while(isDigit((unsigned char)*jsonStr)) ++jsonStr;
+    }
+
+/* number must end with space or control character  or white space*/
+if(*jsonStr != ' ' && *jsonStr != '\n' && *jsonStr != '\n' && *jsonStr != '\t' && *jsonStr != '\f' &&
+   *jsonStr != ',' && *jsonStr != '}' && *jsonStr != ']' && *jsonStr != 0)
+    return(setJSONerror(ERR_JSON_INVALID_NUMBER, jsonStr));
+
+len = (size_t)jsonStr - (size_t)ptr;
+memcpy(number, ptr, len);
+number[len] = 0;
+*restStr = jsonStr;
+
+if(isFloat)
+    {
+    floatNumber = atof(number);
+    return(stuffFloat(floatNumber));
+    }
+else
+    return(stuffInteger64(atoll(number)));
+
+
+NOT_STRING_OR_NUMBER:
+/* it's one of object, array, true, false, null */
+
+switch(*jsonStr)
+    {
+    case '{':
+        cell = getJSONobject(jsonStr, &ptr);
+        break;
+    case '[':
+        GET_ARRAY_ELEMENT:
+        ++jsonStr;
+        while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr;
+        if(*jsonStr == ']')
+            {
+            *restStr = jsonStr + 1;
+            if(array) return(array);
+            return(getCell(CELL_EXPRESSION));
+            }
+        if((cell = getJSONvalue(jsonStr, &ptr)) == nilCell)
+            {
+            if(array) deleteList(array);
+            return(nilCell);
+            }
+        if(array == NULL)
+            {
+            array = getCell(CELL_EXPRESSION);
+            array->contents = (UINT)cell;
+            }
+        else
+            next->next = cell;
+        next = cell;
+        jsonStr = ptr;
+        /* whitespace */
+        while((unsigned char)*jsonStr <= ' ' && *jsonStr != 0) ++jsonStr;
+        if(*jsonStr == ',') goto GET_ARRAY_ELEMENT;
+        if(*jsonStr == ']')
+            {
+            *restStr = jsonStr + 1;
+            return(array);
+            }
+        deleteList(array);
+        return(setJSONerror(ERR_JSON_INVALID_ARRAY, jsonStr));
+    case 't':
+        if(strncmp(jsonStr, "true", 4) == 0)
+            {
+            cell = stuffSymbol(trueSymbol);
+            ptr = jsonStr + 4;
+            break;
+            }
+    case 'f':
+        if(strncmp(jsonStr, "false", 5) == 0)
+            {
+            falseSymbol = translateCreateSymbol("false", CELL_SYMBOL, mainContext, TRUE);
+            cell = stuffSymbol(falseSymbol);
+            ptr = jsonStr + 5;
+            break;
+            }
+    case 'n':
+        if(strncmp(jsonStr, "null", 4) == 0)
+            {
+            nullSymbol = translateCreateSymbol("null", CELL_SYMBOL, mainContext, TRUE);
+            cell = stuffSymbol(nullSymbol);
+            ptr = jsonStr + 4;
+            break;
+            }
+    default:
+    return(setJSONerror(ERR_JSON_INVALID_VALUE, jsonStr));
+    }
+
+*restStr = ptr;
+return(cell);
+}
+
+
+CELL * p_JSONerror(CELL * params)
+{
+return( lastJSONerror == NULL ? nilCell : copyCell(lastJSONerror));
+}
+
+
+CELL * setJSONerror(char * errorText, char * jsonStr)
+{
+CELL * cell = stuffString(errorText);
+
+if(lastJSONerror) deleteList(lastJSONerror);
+
+lastJSONerror = getCell(CELL_EXPRESSION);
+lastJSONerror->contents = (UINT)cell;
+cell->next = stuffInteger((UINT)jsonStr - (UINT)jsonStrStart);
+
+return(nilCell);
+}
+
+/* eof */
+
+
diff --git a/pcre-chartables.c b/pcre-chartables.c
new file mode 100644
index 0000000..55e413c
--- /dev/null
+++ b/pcre-chartables.c
@@ -0,0 +1,183 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* This file is automatically written by the dftables auxiliary 
+program. If you edit it by hand, you might like to edit the Makefile to 
+prevent its ever being regenerated.
+
+This file is #included in the compilation of pcre.c to build the default
+character tables which are used when no tables are passed to the compile
+function. */
+
+static unsigned char pcre_default_tables[] = {
+
+/* This table is a lower casing table. */
+
+    0,  1,  2,  3,  4,  5,  6,  7,
+    8,  9, 10, 11, 12, 13, 14, 15,
+   16, 17, 18, 19, 20, 21, 22, 23,
+   24, 25, 26, 27, 28, 29, 30, 31,
+   32, 33, 34, 35, 36, 37, 38, 39,
+   40, 41, 42, 43, 44, 45, 46, 47,
+   48, 49, 50, 51, 52, 53, 54, 55,
+   56, 57, 58, 59, 60, 61, 62, 63,
+   64, 97, 98, 99,100,101,102,103,
+  104,105,106,107,108,109,110,111,
+  112,113,114,115,116,117,118,119,
+  120,121,122, 91, 92, 93, 94, 95,
+   96, 97, 98, 99,100,101,102,103,
+  104,105,106,107,108,109,110,111,
+  112,113,114,115,116,117,118,119,
+  120,121,122,123,124,125,126,127,
+  128,129,130,131,132,133,134,135,
+  136,137,138,139,140,141,142,143,
+  144,145,146,147,148,149,150,151,
+  152,153,154,155,156,157,158,159,
+  160,161,162,163,164,165,166,167,
+  168,169,170,171,172,173,174,175,
+  176,177,178,179,180,181,182,183,
+  184,185,186,187,188,189,190,191,
+  192,193,194,195,196,197,198,199,
+  200,201,202,203,204,205,206,207,
+  208,209,210,211,212,213,214,215,
+  216,217,218,219,220,221,222,223,
+  224,225,226,227,228,229,230,231,
+  232,233,234,235,236,237,238,239,
+  240,241,242,243,244,245,246,247,
+  248,249,250,251,252,253,254,255,
+
+/* This table is a case flipping table. */
+
+    0,  1,  2,  3,  4,  5,  6,  7,
+    8,  9, 10, 11, 12, 13, 14, 15,
+   16, 17, 18, 19, 20, 21, 22, 23,
+   24, 25, 26, 27, 28, 29, 30, 31,
+   32, 33, 34, 35, 36, 37, 38, 39,
+   40, 41, 42, 43, 44, 45, 46, 47,
+   48, 49, 50, 51, 52, 53, 54, 55,
+   56, 57, 58, 59, 60, 61, 62, 63,
+   64, 97, 98, 99,100,101,102,103,
+  104,105,106,107,108,109,110,111,
+  112,113,114,115,116,117,118,119,
+  120,121,122, 91, 92, 93, 94, 95,
+   96, 65, 66, 67, 68, 69, 70, 71,
+   72, 73, 74, 75, 76, 77, 78, 79,
+   80, 81, 82, 83, 84, 85, 86, 87,
+   88, 89, 90,123,124,125,126,127,
+  128,129,130,131,132,133,134,135,
+  136,137,138,139,140,141,142,143,
+  144,145,146,147,148,149,150,151,
+  152,153,154,155,156,157,158,159,
+  160,161,162,163,164,165,166,167,
+  168,169,170,171,172,173,174,175,
+  176,177,178,179,180,181,182,183,
+  184,185,186,187,188,189,190,191,
+  192,193,194,195,196,197,198,199,
+  200,201,202,203,204,205,206,207,
+  208,209,210,211,212,213,214,215,
+  216,217,218,219,220,221,222,223,
+  224,225,226,227,228,229,230,231,
+  232,233,234,235,236,237,238,239,
+  240,241,242,243,244,245,246,247,
+  248,249,250,251,252,253,254,255,
+
+/* This table contains bit maps for various character classes.
+Each map is 32 bytes long and the bits run from the least
+significant end of each byte. The classes that have their own
+maps are: space, xdigit, digit, upper, lower, word, graph
+print, punct, and cntrl. Other classes are built from combinations. */
+
+  0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
+  0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
+  0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
+  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
+  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,
+  0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+/* This table identifies various classes of character by individual bits:
+  0x01   white space character
+  0x02   letter
+  0x04   decimal digit
+  0x08   hexadecimal digit
+  0x10   alphanumeric or '_'
+  0x80   regular expression metacharacter or binary zero
+*/
+
+  0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
+  0x00,0x01,0x01,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+  0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /*    - '  */
+  0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /*  ( - /  */
+  0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
+  0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /*  8 - ?  */
+  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  @ - G  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  H - O  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  P - W  */
+  0x12,0x12,0x12,0x80,0x00,0x00,0x80,0x10, /*  X - _  */
+  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  ` - g  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  h - o  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  p - w  */
+  0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /*  x -127 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
+
+/* End of chartables.c */
diff --git a/pcre-config.h b/pcre-config.h
new file mode 100644
index 0000000..6949290
--- /dev/null
+++ b/pcre-config.h
@@ -0,0 +1,119 @@
+/* config.h.  Generated by configure.  */
+
+/* On Unix systems config.in is converted by configure into config.h. PCRE is
+written in Standard C, but there are a few non-standard things it can cope
+with, allowing it to run on SunOS4 and other "close to standard" systems.
+
+On a non-Unix system you should just copy this file into config.h, and set up
+the macros the way you need them. You should normally change the definitions of
+HAVE_STRERROR and HAVE_MEMMOVE to 1. Unfortunately, because of the way autoconf
+works, these cannot be made the defaults. If your system has bcopy() and not
+memmove(), change the definition of HAVE_BCOPY instead of HAVE_MEMMOVE. If your
+system has neither bcopy() nor memmove(), leave them both as 0; an emulation
+function will be used. */
+
+/* If you are compiling for a system that uses EBCDIC instead of ASCII
+character codes, define this macro as 1. On systems that can use "configure",
+this can be done via --enable-ebcdic. */
+
+
+/* for newlisp compiled with configure-alt */
+#ifdef NEWCONFIG
+#include "config.h"
+#endif
+
+#ifndef PCRE_CONFIG_H
+#define PCRE_CONFIG_H
+
+#ifndef EBCDIC
+#define EBCDIC 0
+#endif
+
+/* If you are compiling for a system that needs some magic to be inserted
+before the definition of an exported function, define this macro to contain the
+relevant magic. It apears at the start of every exported function. */
+
+#define EXPORT
+
+/* Define to empty if the "const" keyword does not work. */
+
+/* #undef const */
+
+/* Define to "unsigned" if <stddef.h> doesn't define size_t. */
+
+/* #undef size_t */
+
+/* The following two definitions are mainly for the benefit of SunOS4, which
+doesn't have the strerror() or memmove() functions that should be present in
+all Standard C libraries. The macros HAVE_STRERROR and HAVE_MEMMOVE should
+normally be defined with the value 1 for other systems, but unfortunately we
+can't make this the default because "configure" files generated by autoconf
+will only change 0 to 1; they won't change 1 to 0 if the functions are not
+found. */
+
+#define HAVE_STRERROR 1
+#define HAVE_MEMMOVE 1
+
+/* There are some non-Unix systems that don't even have bcopy(). If this macro
+is false, an emulation is used. If HAVE_MEMMOVE is set to 1, the value of
+HAVE_BCOPY is not relevant. */
+
+#define HAVE_BCOPY 1
+
+/* The value of NEWLINE determines the newline character. The default is to
+leave it up to the compiler, but some sites want to force a particular value.
+On Unix systems, "configure" can be used to override this default. */
+
+#ifndef NEWLINE
+#define NEWLINE '\n'
+#endif
+
+/* The value of LINK_SIZE determines the number of bytes used to store
+links as offsets within the compiled regex. The default is 2, which allows for
+compiled patterns up to 64K long. This covers the vast majority of cases.
+However, PCRE can also be compiled to use 3 or 4 bytes instead. This allows for
+longer patterns in extreme cases. On Unix systems, "configure" can be used to
+override this default. */
+
+#ifndef LINK_SIZE
+#define LINK_SIZE   2
+#endif
+
+/* The value of MATCH_LIMIT determines the default number of times the match()
+function can be called during a single execution of pcre_exec(). (There is a
+runtime method of setting a different limit.) The limit exists in order to
+catch runaway regular expressions that take for ever to determine that they do
+not match. The default is set very large so that it does not accidentally catch
+legitimate cases. On Unix systems, "configure" can be used to override this
+default default. */
+
+#ifndef MATCH_LIMIT
+#define MATCH_LIMIT 10000000
+#endif
+
+/* When calling PCRE via the POSIX interface, additional working storage is
+required for holding the pointers to capturing substrings because PCRE requires
+three integers per substring, whereas the POSIX interface provides only two. If
+the number of expected substrings is small, the wrapper function uses space on
+the stack, because this is faster than using malloc() for each call. The
+threshold above which the stack is no longer use is defined by POSIX_MALLOC_
+THRESHOLD. On Unix systems, "configure" can be used to override this default.
+*/
+
+#ifndef POSIX_MALLOC_THRESHOLD
+#define POSIX_MALLOC_THRESHOLD 10
+#endif
+
+/* PCRE uses recursive function calls to handle backtracking while matching.
+This can sometimes be a problem on systems that have stacks of limited size.
+Define NO_RECURSE to get a version that doesn't use recursion in the match()
+function; instead it creates its own stack by steam using pcre_recurse_malloc
+to get memory. For more detail, see comments and other stuff just above the
+match() function. On Unix systems, "configure" can be used to set this in the
+Makefile (use --disable-stack-for-recursion). */
+
+/* #define NO_RECURSE */
+
+/* End */
+
+#endif /* PCRE_CONFIG_H */
diff --git a/pcre-internal.h b/pcre-internal.h
new file mode 100644
index 0000000..cf230e5
--- /dev/null
+++ b/pcre-internal.h
@@ -0,0 +1,758 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+
+/* This is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language. See
+the file doc/Tech.Notes for some information on the internals.
+
+Written by: Philip Hazel <ph10@cam.ac.uk>
+
+           Copyright (c) 1997-2004 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef PCRE_INTERNAL_H
+#define PCRE_INTERNAL_H
+
+/* This header contains definitions that are shared between the different
+modules, but which are not relevant to the outside. */
+
+/* Get the definitions provided by running "configure" */
+
+#include "pcre-config.h"
+
+/* Standard C headers plus the external interface definition. The only time
+setjmp and stdarg are used is when NO_RECURSE is set. */
+
+#include <ctype.h>
+#include <limits.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef PCRE_SPY
+#define PCRE_DEFINITION       /* Win32 __declspec(export) trigger for .dll */
+#endif
+
+/* We need to have types that specify unsigned 16-bit and 32-bit integers. We
+cannot determine these outside the compilation (e.g. by running a program as
+part of "configure") because PCRE is often cross-compiled for use on other
+systems. Instead we make use of the maximum sizes that are available at
+preprocessor time in standard C environments. */
+
+#if USHRT_MAX == 65535
+  typedef unsigned short pcre_uint16;
+#elif UINT_MAX == 65535
+  typedef unsigned int pcre_uint16;
+#else
+  #error Cannot determine a type for 16-bit unsigned integers
+#endif
+
+#if UINT_MAX == 4294967295
+  typedef unsigned int pcre_uint32;
+#elif ULONG_MAX == 4294967295
+  typedef unsigned long int pcre_uint32;
+#else
+  #error Cannot determine a type for 32-bit unsigned integers
+#endif
+
+/* All character handling must be done as unsigned characters. Otherwise there
+are problems with top-bit-set characters and functions such as isspace().
+However, we leave the interface to the outside world as char *, because that
+should make things easier for callers. We define a short type for unsigned char
+to save lots of typing. I tried "uchar", but it causes problems on Digital
+Unix, where it is defined in sys/types, so use "uschar" instead. */
+
+typedef unsigned char uschar;
+
+/* Include the public PCRE header */
+
+#include "pcre.h"
+
+/* When compiling for use with the Virtual Pascal compiler, these functions
+need to have their names changed. PCRE must be compiled with the -DVPCOMPAT
+option on the command line. */
+
+#ifdef VPCOMPAT
+#define strncmp(s1,s2,m) _strncmp(s1,s2,m)
+#define memcpy(d,s,n)    _memcpy(d,s,n)
+#define memmove(d,s,n)   _memmove(d,s,n)
+#define memset(s,c,n)    _memset(s,c,n)
+#else  /* VPCOMPAT */
+
+/* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),
+define a macro for memmove() if HAVE_MEMMOVE is false, provided that HAVE_BCOPY
+is set. Otherwise, include an emulating function for those systems that have
+neither (there some non-Unix environments where this is the case). This assumes
+that all calls to memmove are moving strings upwards in store, which is the
+case in PCRE. */
+
+#if ! HAVE_MEMMOVE
+#undef  memmove        /* some systems may have a macro */
+#if HAVE_BCOPY
+#define memmove(a, b, c) bcopy(b, a, c)
+#else  /* HAVE_BCOPY */
+void *
+pcre_memmove(unsigned char *dest, const unsigned char *src, size_t n)
+{
+int i;
+dest += n;
+src += n;
+for (i = 0; i < n; ++i) *(--dest) =  *(--src);
+}
+#define memmove(a, b, c) pcre_memmove(a, b, c)
+#endif   /* not HAVE_BCOPY */
+#endif   /* not HAVE_MEMMOVE */
+#endif   /* not VPCOMPAT */
+
+
+/* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
+in big-endian order) by default. These are used, for example, to link from the
+start of a subpattern to its alternatives and its end. The use of 2 bytes per
+offset limits the size of the compiled regex to around 64K, which is big enough
+for almost everybody. However, I received a request for an even bigger limit.
+For this reason, and also to make the code easier to maintain, the storing and
+loading of offsets from the byte string is now handled by the macros that are
+defined here.
+
+The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
+the config.h file, but can be overridden by using -D on the command line. This
+is automated on Unix systems via the "configure" command. */
+
+#if LINK_SIZE == 2
+
+#define PUT(a,n,d)   \
+  (a[n] = (d) >> 8), \
+  (a[(n)+1] = (d) & 255)
+
+#define GET(a,n) \
+  (((a)[n] << 8) | (a)[(n)+1])
+
+#define MAX_PATTERN_SIZE (1 << 16)
+
+
+#elif LINK_SIZE == 3
+
+#define PUT(a,n,d)       \
+  (a[n] = (d) >> 16),    \
+  (a[(n)+1] = (d) >> 8), \
+  (a[(n)+2] = (d) & 255)
+
+#define GET(a,n) \
+  (((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])
+
+#define MAX_PATTERN_SIZE (1 << 24)
+
+
+#elif LINK_SIZE == 4
+
+#define PUT(a,n,d)        \
+  (a[n] = (d) >> 24),     \
+  (a[(n)+1] = (d) >> 16), \
+  (a[(n)+2] = (d) >> 8),  \
+  (a[(n)+3] = (d) & 255)
+
+#define GET(a,n) \
+  (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
+
+#define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */
+
+
+#else
+#error LINK_SIZE must be either 2, 3, or 4
+#endif
+
+
+/* Convenience macro defined in terms of the others */
+
+#define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE
+
+
+/* PCRE uses some other 2-byte quantities that do not change when the size of
+offsets changes. There are used for repeat counts and for other things such as
+capturing parenthesis numbers in back references. */
+
+#define PUT2(a,n,d)   \
+  a[n] = (d) >> 8; \
+  a[(n)+1] = (d) & 255
+
+#define GET2(a,n) \
+  (((a)[n] << 8) | (a)[(n)+1])
+
+#define PUT2INC(a,n,d)  PUT2(a,n,d), a += 2
+
+
+/* In case there is no definition of offsetof() provided - though any proper
+Standard C system should have one. */
+
+#ifndef offsetof
+#define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
+#endif
+
+
+/* These are the public options that can change during matching. */
+
+#define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)
+
+/* Private options flags start at the most significant end of the four bytes,
+but skip the top bit so we can use ints for convenience without getting tangled
+with negative values. The public options defined in pcre.h start at the least
+significant end. Make sure they don't overlap, though now that we have expanded
+to four bytes, there is plenty of space. */
+
+#define PCRE_FIRSTSET      0x40000000  /* first_byte is set */
+#define PCRE_REQCHSET      0x20000000  /* req_byte is set */
+#define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */
+#define PCRE_ICHANGED      0x08000000  /* i option changes within regex */
+#define PCRE_NOPARTIAL     0x04000000  /* can't use partial with this regex */
+
+/* Options for the "extra" block produced by pcre_study(). */
+
+#define PCRE_STUDY_MAPPED   0x01     /* a map of starting chars exists */
+
+/* Masks for identifying the public options which are permitted at compile
+time, run time or study time, respectively. */
+
+#define PUBLIC_OPTIONS \
+  (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
+   PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
+   PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT)
+
+#define PUBLIC_EXEC_OPTIONS \
+  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
+   PCRE_PARTIAL)
+
+#define PUBLIC_STUDY_OPTIONS 0   /* None defined */
+
+/* Magic number to provide a small check against being handed junk. */
+
+#define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */
+
+/* Negative values for the firstchar and reqchar variables */
+
+#define REQ_UNSET (-2)
+#define REQ_NONE  (-1)
+
+/* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
+variable-length repeat, or a anything other than literal characters. */
+
+#define REQ_CASELESS 0x0100    /* indicates caselessness */
+#define REQ_VARY     0x0200    /* reqbyte followed non-literal item */
+
+/* Miscellaneous definitions */
+
+typedef int BOOL;
+
+#define FALSE   0
+#define TRUE    1
+
+/* Escape items that are just an encoding of a particular data value. Note that
+ESC_n is defined as yet another macro, which is set in config.h to either \n
+(the default) or \r (which some people want). */
+
+#ifndef ESC_e
+#define ESC_e 27
+#endif
+
+#ifndef ESC_f
+#define ESC_f '\f'
+#endif
+
+#ifndef ESC_n
+#define ESC_n NEWLINE
+#endif
+
+#ifndef ESC_r
+#define ESC_r '\r'
+#endif
+
+/* We can't officially use ESC_t because it is a POSIX reserved identifier
+(presumably because of all the others like size_t). */
+
+#ifndef ESC_tee
+#define ESC_tee '\t'
+#endif
+
+/* These are escaped items that aren't just an encoding of a particular data
+value such as \n. They must have non-zero values, as check_escape() returns
+their negation. Also, they must appear in the same order as in the opcode
+definitions below, up to ESC_z. There's a dummy for OP_ANY because it
+corresponds to "." rather than an escape sequence. The final one must be
+ESC_REF as subsequent values are used for \1, \2, \3, etc. There is are two
+tests in the code for an escape greater than ESC_b and less than ESC_Z to
+detect the types that may be repeated. These are the types that consume
+characters. If any new escapes are put in between that don't consume a
+character, that code will have to change. */
+
+enum { ESC_A = 1, ESC_G, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W,
+       ESC_w, ESC_dum1, ESC_C, ESC_P, ESC_p, ESC_X, ESC_Z, ESC_z, ESC_E,
+       ESC_Q, ESC_REF };
+
+/* Flag bits and data types for the extended class (OP_XCLASS) for classes that
+contain UTF-8 characters with values greater than 255. */
+
+#define XCL_NOT    0x01    /* Flag: this is a negative class */
+#define XCL_MAP    0x02    /* Flag: a 32-byte map is present */
+
+#define XCL_END       0    /* Marks end of individual items */
+#define XCL_SINGLE    1    /* Single item (one multibyte char) follows */
+#define XCL_RANGE     2    /* A range (two multibyte chars) follows */
+#define XCL_PROP      3    /* Unicode property (one property code) follows */
+#define XCL_NOTPROP   4    /* Unicode inverted property (ditto) */
+
+
+/* Opcode table: OP_BRA must be last, as all values >= it are used for brackets
+that extract substrings. Starting from 1 (i.e. after OP_END), the values up to
+OP_EOD must correspond in order to the list of escapes immediately above.
+Note that whenever this list is updated, the two macro definitions that follow
+must also be updated to match. */
+
+enum {
+  OP_END,            /* 0 End of pattern */
+
+  /* Values corresponding to backslashed metacharacters */
+
+  OP_SOD,            /* 1 Start of data: \A */
+  OP_SOM,            /* 2 Start of match (subject + offset): \G */
+  OP_NOT_WORD_BOUNDARY,  /*  3 \B */
+  OP_WORD_BOUNDARY,      /*  4 \b */
+  OP_NOT_DIGIT,          /*  5 \D */
+  OP_DIGIT,              /*  6 \d */
+  OP_NOT_WHITESPACE,     /*  7 \S */
+  OP_WHITESPACE,         /*  8 \s */
+  OP_NOT_WORDCHAR,       /*  9 \W */
+  OP_WORDCHAR,           /* 10 \w */
+  OP_ANY,            /* 11 Match any character */
+  OP_ANYBYTE,        /* 12 Match any byte (\C); different to OP_ANY for UTF-8 */
+  OP_NOTPROP,        /* 13 \P (not Unicode property) */
+  OP_PROP,           /* 14 \p (Unicode property) */
+  OP_EXTUNI,         /* 15 \X (extended Unicode sequence */
+  OP_EODN,           /* 16 End of data or \n at end of data: \Z. */
+  OP_EOD,            /* 17 End of data: \z */
+
+  OP_OPT,            /* 18 Set runtime options */
+  OP_CIRC,           /* 19 Start of line - varies with multiline switch */
+  OP_DOLL,           /* 20 End of line - varies with multiline switch */
+  OP_CHAR,           /* 21 Match one character, casefully */
+  OP_CHARNC,         /* 22 Match one character, caselessly */
+  OP_NOT,            /* 23 Match anything but the following char */
+
+  OP_STAR,           /* 24 The maximizing and minimizing versions of */
+  OP_MINSTAR,        /* 25 all these opcodes must come in pairs, with */
+  OP_PLUS,           /* 26 the minimizing one second. */
+  OP_MINPLUS,        /* 27 This first set applies to single characters */
+  OP_QUERY,          /* 28 */
+  OP_MINQUERY,       /* 29 */
+  OP_UPTO,           /* 30 From 0 to n matches */
+  OP_MINUPTO,        /* 31 */
+  OP_EXACT,          /* 32 Exactly n matches */
+
+  OP_NOTSTAR,        /* 33 The maximizing and minimizing versions of */
+  OP_NOTMINSTAR,     /* 34 all these opcodes must come in pairs, with */
+  OP_NOTPLUS,        /* 35 the minimizing one second. */
+  OP_NOTMINPLUS,     /* 36 This set applies to "not" single characters */
+  OP_NOTQUERY,       /* 37 */
+  OP_NOTMINQUERY,    /* 38 */
+  OP_NOTUPTO,        /* 39 From 0 to n matches */
+  OP_NOTMINUPTO,     /* 40 */
+  OP_NOTEXACT,       /* 41 Exactly n matches */
+
+  OP_TYPESTAR,       /* 42 The maximizing and minimizing versions of */
+  OP_TYPEMINSTAR,    /* 43 all these opcodes must come in pairs, with */
+  OP_TYPEPLUS,       /* 44 the minimizing one second. These codes must */
+  OP_TYPEMINPLUS,    /* 45 be in exactly the same order as those above. */
+  OP_TYPEQUERY,      /* 46 This set applies to character types such as \d */
+  OP_TYPEMINQUERY,   /* 47 */
+  OP_TYPEUPTO,       /* 48 From 0 to n matches */
+  OP_TYPEMINUPTO,    /* 49 */
+  OP_TYPEEXACT,      /* 50 Exactly n matches */
+
+  OP_CRSTAR,         /* 51 The maximizing and minimizing versions of */
+  OP_CRMINSTAR,      /* 52 all these opcodes must come in pairs, with */
+  OP_CRPLUS,         /* 53 the minimizing one second. These codes must */
+  OP_CRMINPLUS,      /* 54 be in exactly the same order as those above. */
+  OP_CRQUERY,        /* 55 These are for character classes and back refs */
+  OP_CRMINQUERY,     /* 56 */
+  OP_CRRANGE,        /* 57 These are different to the three sets above. */
+  OP_CRMINRANGE,     /* 58 */
+
+  OP_CLASS,          /* 59 Match a character class, chars < 256 only */
+  OP_NCLASS,         /* 60 Same, but the bitmap was created from a negative
+                           class - the difference is relevant only when a UTF-8
+                           character > 255 is encountered. */
+
+  OP_XCLASS,         /* 61 Extended class for handling UTF-8 chars within the
+                           class. This does both positive and negative. */
+
+  OP_REF,            /* 62 Match a back reference */
+  OP_RECURSE,        /* 63 Match a numbered subpattern (possibly recursive) */
+  OP_CALLOUT,        /* 64 Call out to external function if provided */
+
+  OP_ALT,            /* 65 Start of alternation */
+  OP_KET,            /* 66 End of group that doesn't have an unbounded repeat */
+  OP_KETRMAX,        /* 67 These two must remain together and in this */
+  OP_KETRMIN,        /* 68 order. They are for groups the repeat for ever. */
+
+  /* The assertions must come before ONCE and COND */
+
+  OP_ASSERT,         /* 69 Positive lookahead */
+  OP_ASSERT_NOT,     /* 70 Negative lookahead */
+  OP_ASSERTBACK,     /* 71 Positive lookbehind */
+  OP_ASSERTBACK_NOT, /* 72 Negative lookbehind */
+  OP_REVERSE,        /* 73 Move pointer back - used in lookbehind assertions */
+
+  /* ONCE and COND must come after the assertions, with ONCE first, as there's
+  a test for >= ONCE for a subpattern that isn't an assertion. */
+
+  OP_ONCE,           /* 74 Once matched, don't back up into the subpattern */
+  OP_COND,           /* 75 Conditional group */
+  OP_CREF,           /* 76 Used to hold an extraction string number (cond ref) */
+
+  OP_BRAZERO,        /* 77 These two must remain together and in this */
+  OP_BRAMINZERO,     /* 78 order. */
+
+  OP_BRANUMBER,      /* 79 Used for extracting brackets whose number is greater
+                           than can fit into an opcode. */
+
+  OP_BRA             /* 80 This and greater values are used for brackets that
+                           extract substrings up to EXTRACT_BASIC_MAX. After
+                           that, use is made of OP_BRANUMBER. */
+};
+
+/* WARNING WARNING WARNING: There is an implicit assumption in pcre.c and
+study.c that all opcodes are less than 128 in value. This makes handling UTF-8
+character sequences easier. */
+
+/* The highest extraction number before we have to start using additional
+bytes. (Originally PCRE didn't have support for extraction counts highter than
+this number.) The value is limited by the number of opcodes left after OP_BRA,
+i.e. 255 - OP_BRA. We actually set it a bit lower to leave room for additional
+opcodes. */
+
+#define EXTRACT_BASIC_MAX  100
+
+
+/* This macro defines textual names for all the opcodes. There are used only
+for debugging, in pcre.c when DEBUG is defined, and also in pcretest.c. The
+macro is referenced only in printint.c. */
+
+#define OP_NAME_LIST \
+  "End", "\\A", "\\G", "\\B", "\\b", "\\D", "\\d",                \
+  "\\S", "\\s", "\\W", "\\w", "Any", "Anybyte",                   \
+  "notprop", "prop", "extuni",                                    \
+  "\\Z", "\\z",                                                   \
+  "Opt", "^", "$", "char", "charnc", "not",                       \
+  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+  "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
+  "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \
+  "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
+  "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cond ref",\
+  "Brazero", "Braminzero", "Branumber", "Bra"
+
+
+/* This macro defines the length of fixed length operations in the compiled
+regex. The lengths are used when searching for specific things, and also in the
+debugging printing of a compiled regex. We use a macro so that it can be
+incorporated both into pcre.c and pcretest.c without being publicly exposed.
+
+As things have been extended, some of these are no longer fixed lenths, but are
+minima instead. For example, the length of a single-character repeat may vary
+in UTF-8 mode. The code that uses this table must know about such things. */
+
+#define OP_LENGTHS \
+  1,                             /* End                                    */ \
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* \A, \G, \B, \B, \D, \d, \S, \s, \W, \w */ \
+  1, 1,                          /* Any, Anybyte                           */ \
+  2, 2, 1,                       /* NOTPROP, PROP, EXTUNI                  */ \
+  1, 1, 2, 1, 1,                 /* \Z, \z, Opt, ^, $                      */ \
+  2,                             /* Char  - the minimum length             */ \
+  2,                             /* Charnc  - the minimum length           */ \
+  2,                             /* not                                    */ \
+  /* Positive single-char repeats                            ** These are  */ \
+  2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \
+  4, 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \
+  /* Negative single-char repeats - only for chars < 256                   */ \
+  2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
+  4, 4, 4,                       /* NOT upto, minupto, exact               */ \
+  /* Positive type repeats                                                 */ \
+  2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
+  4, 4, 4,                       /* Type upto, minupto, exact              */ \
+  /* Character class & ref repeats                                         */ \
+  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
+  5, 5,                          /* CRRANGE, CRMINRANGE                    */ \
+ 33,                             /* CLASS                                  */ \
+ 33,                             /* NCLASS                                 */ \
+  0,                             /* XCLASS - variable length               */ \
+  3,                             /* REF                                    */ \
+  1+LINK_SIZE,                   /* RECURSE                                */ \
+  2+2*LINK_SIZE,                 /* CALLOUT                                */ \
+  1+LINK_SIZE,                   /* Alt                                    */ \
+  1+LINK_SIZE,                   /* Ket                                    */ \
+  1+LINK_SIZE,                   /* KetRmax                                */ \
+  1+LINK_SIZE,                   /* KetRmin                                */ \
+  1+LINK_SIZE,                   /* Assert                                 */ \
+  1+LINK_SIZE,                   /* Assert not                             */ \
+  1+LINK_SIZE,                   /* Assert behind                          */ \
+  1+LINK_SIZE,                   /* Assert behind not                      */ \
+  1+LINK_SIZE,                   /* Reverse                                */ \
+  1+LINK_SIZE,                   /* Once                                   */ \
+  1+LINK_SIZE,                   /* COND                                   */ \
+  3,                             /* CREF                                   */ \
+  1, 1,                          /* BRAZERO, BRAMINZERO                    */ \
+  3,                             /* BRANUMBER                              */ \
+  1+LINK_SIZE                    /* BRA                                    */ \
+
+
+/* A magic value for OP_CREF to indicate the "in recursion" condition. */
+
+#define CREF_RECURSE  0xffff
+
+/* The texts of compile-time error messages are defined as macros here so that
+they can be accessed by the POSIX wrapper and converted into error codes.  Yes,
+I could have used error codes in the first place, but didn't feel like changing
+just to accommodate the POSIX wrapper. */
+
+#define ERR1  "\\ at end of pattern"
+#define ERR2  "\\c at end of pattern"
+#define ERR3  "unrecognized character follows \\"
+#define ERR4  "numbers out of order in {} quantifier"
+#define ERR5  "number too big in {} quantifier"
+#define ERR6  "missing terminating ] for character class"
+#define ERR7  "invalid escape sequence in character class"
+#define ERR8  "range out of order in character class"
+#define ERR9  "nothing to repeat"
+#define ERR10 "operand of unlimited repeat could match the empty string"
+#define ERR11 "internal error: unexpected repeat"
+#define ERR12 "unrecognized character after (?"
+#define ERR13 "POSIX named classes are supported only within a class"
+#define ERR14 "missing )"
+#define ERR15 "reference to non-existent subpattern"
+#define ERR16 "erroffset passed as NULL"
+#define ERR17 "unknown option bit(s) set"
+#define ERR18 "missing ) after comment"
+#define ERR19 "parentheses nested too deeply"
+#define ERR20 "regular expression too large"
+#define ERR21 "failed to get memory"
+#define ERR22 "unmatched parentheses"
+#define ERR23 "internal error: code overflow"
+#define ERR24 "unrecognized character after (?<"
+#define ERR25 "lookbehind assertion is not fixed length"
+#define ERR26 "malformed number after (?("
+#define ERR27 "conditional group contains more than two branches"
+#define ERR28 "assertion expected after (?("
+#define ERR29 "(?R or (?digits must be followed by )"
+#define ERR30 "unknown POSIX class name"
+#define ERR31 "POSIX collating elements are not supported"
+#define ERR32 "this version of PCRE is not compiled with PCRE_UTF8 support"
+#define ERR33 "spare error"
+#define ERR34 "character value in \\x{...} sequence is too large"
+#define ERR35 "invalid condition (?(0)"
+#define ERR36 "\\C not allowed in lookbehind assertion"
+#define ERR37 "PCRE does not support \\L, \\l, \\N, \\U, or \\u"
+#define ERR38 "number after (?C is > 255"
+#define ERR39 "closing ) for (?C expected"
+#define ERR40 "recursive call could loop indefinitely"
+#define ERR41 "unrecognized character after (?P"
+#define ERR42 "syntax error after (?P"
+#define ERR43 "two named groups have the same name"
+#define ERR44 "invalid UTF-8 string"
+#define ERR45 "support for \\P, \\p, and \\X has not been compiled"
+#define ERR46 "malformed \\P or \\p sequence"
+#define ERR47 "unknown property name after \\P or \\p"
+
+/* The real format of the start of the pcre block; the index of names and the
+code vector run on as long as necessary after the end. We store an explicit
+offset to the name table so that if a regex is compiled on one host, saved, and
+then run on another where the size of pointers is different, all might still
+be well. For the case of compiled-on-4 and run-on-8, we include an extra
+pointer that is always NULL. For future-proofing, we also include a few dummy
+fields - even though you can never get this planning right!
+
+NOTE NOTE NOTE:
+Because people can now save and re-use compiled patterns, any additions to this
+structure should be made at the end, and something earlier (e.g. a new
+flag in the options or one of the dummy fields) should indicate that the new
+fields are present. Currently PCRE always sets the dummy fields to zero.
+NOTE NOTE NOTE:
+*/
+
+typedef struct real_pcre {
+  pcre_uint32 magic_number;
+  pcre_uint32 size;               /* Total that was malloced */
+  pcre_uint32 options;
+  pcre_uint32 dummy1;             /* For future use, maybe */
+
+  pcre_uint16 top_bracket;
+  pcre_uint16 top_backref;
+  pcre_uint16 first_byte;
+  pcre_uint16 req_byte;
+  pcre_uint16 name_table_offset;  /* Offset to name table that follows */
+  pcre_uint16 name_entry_size;    /* Size of any name items */
+  pcre_uint16 name_count;         /* Number of name items */
+  pcre_uint16 dummy2;             /* For future use, maybe */
+
+  const unsigned char *tables;    /* Pointer to tables or NULL for std */
+  const unsigned char *nullpad;   /* NULL padding */
+} real_pcre;
+
+/* The format of the block used to store data from pcre_study(). The same
+remark (see NOTE above) about extending this structure applies. */
+
+typedef struct pcre_study_data {
+  pcre_uint32 size;               /* Total that was malloced */
+  pcre_uint32 options;
+  uschar start_bits[32];
+} pcre_study_data;
+
+/* Structure for passing "static" information around between the functions
+doing the compiling, so that they are thread-safe. */
+
+typedef struct compile_data {
+  const uschar *lcc;            /* Points to lower casing table */
+  const uschar *fcc;            /* Points to case-flipping table */
+  const uschar *cbits;          /* Points to character type table */
+  const uschar *ctypes;         /* Points to table of type maps */
+  const uschar *start_code;     /* The start of the compiled code */
+  const uschar *start_pattern;  /* The start of the pattern */
+  uschar *name_table;           /* The name/number table */
+  int  names_found;             /* Number of entries so far */
+  int  name_entry_size;         /* Size of each entry */
+  int  top_backref;             /* Maximum back reference */
+  unsigned int backref_map;     /* Bitmap of low back refs */
+  int  req_varyopt;             /* "After variable item" flag for reqbyte */
+  BOOL nopartial;               /* Set TRUE if partial won't work */
+} compile_data;
+
+/* Structure for maintaining a chain of pointers to the currently incomplete
+branches, for testing for left recursion. */
+
+typedef struct branch_chain {
+  struct branch_chain *outer;
+  uschar *current;
+} branch_chain;
+
+/* Structure for items in a linked list that represents an explicit recursive
+call within the pattern. */
+
+typedef struct recursion_info {
+  struct recursion_info *prevrec; /* Previous recursion record (or NULL) */
+  int group_num;                /* Number of group that was called */
+  const uschar *after_call;     /* "Return value": points after the call in the expr */
+  const uschar *save_start;     /* Old value of md->start_match */
+  int *offset_save;             /* Pointer to start of saved offsets */
+  int saved_max;                /* Number of saved offsets */
+} recursion_info;
+
+/* When compiling in a mode that doesn't use recursive calls to match(),
+a structure is used to remember local variables on the heap. It is defined in
+pcre.c, close to the match() function, so that it is easy to keep it in step
+with any changes of local variable. However, the pointer to the current frame
+must be saved in some "static" place over a longjmp(). We declare the
+structure here so that we can put a pointer in the match_data structure.
+NOTE: This isn't used for a "normal" compilation of pcre. */
+
+struct heapframe;
+
+/* Structure for passing "static" information around between the functions
+doing the matching, so that they are thread-safe. */
+
+typedef struct match_data {
+  unsigned long int match_call_count; /* As it says */
+  unsigned long int match_limit;/* As it says */
+  int   *offset_vector;         /* Offset vector */
+  int    offset_end;            /* One past the end */
+  int    offset_max;            /* The maximum usable for return data */
+  const uschar *lcc;            /* Points to lower casing table */
+  const uschar *ctypes;         /* Points to table of type maps */
+  BOOL   offset_overflow;       /* Set if too many extractions */
+  BOOL   notbol;                /* NOTBOL flag */
+  BOOL   noteol;                /* NOTEOL flag */
+  BOOL   utf8;                  /* UTF8 flag */
+  BOOL   endonly;               /* Dollar not before final \n */
+  BOOL   notempty;              /* Empty string match not wanted */
+  BOOL   partial;               /* PARTIAL flag */
+  BOOL   hitend;                /* Hit the end of the subject at some point */
+  const uschar *start_code;     /* For use when recursing */
+  const uschar *start_subject;  /* Start of the subject string */
+  const uschar *end_subject;    /* End of the subject string */
+  const uschar *start_match;    /* Start of this match attempt */
+  const uschar *end_match_ptr;  /* Subject position at end match */
+  int    end_offset_top;        /* Highwater mark at end of match */
+  int    capture_last;          /* Most recent capture number */
+  int    start_offset;          /* The start offset value */
+  recursion_info *recursive;    /* Linked list of recursion data */
+  void  *callout_data;          /* To pass back to callouts */
+  struct heapframe *thisframe;  /* Used only when compiling for no recursion */
+} match_data;
+
+/* Bit definitions for entries in the pcre_ctypes table. */
+
+#define ctype_space   0x01
+#define ctype_letter  0x02
+#define ctype_digit   0x04
+#define ctype_xdigit  0x08
+#define ctype_word    0x10   /* alphameric or '_' */
+#define ctype_meta    0x80   /* regexp meta char or zero (end pattern) */
+
+/* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
+of bits for a class map. Some classes are built by combining these tables. */
+
+#define cbit_space     0      /* [:space:] or \s */
+#define cbit_xdigit   32      /* [:xdigit:] */
+#define cbit_digit    64      /* [:digit:] or \d */
+#define cbit_upper    96      /* [:upper:] */
+#define cbit_lower   128      /* [:lower:] */
+#define cbit_word    160      /* [:word:] or \w */
+#define cbit_graph   192      /* [:graph:] */
+#define cbit_print   224      /* [:print:] */
+#define cbit_punct   256      /* [:punct:] */
+#define cbit_cntrl   288      /* [:cntrl:] */
+#define cbit_length  320      /* Length of the cbits table */
+
+/* Offsets of the various tables from the base tables pointer, and
+total length. */
+
+#define lcc_offset      0
+#define fcc_offset    256
+#define cbits_offset  512
+#define ctypes_offset (cbits_offset + cbit_length)
+#define tables_length (ctypes_offset + 256)
+
+/* End of internal.h */
+
+#endif /* PCRE_INTERNAL_H */
+
diff --git a/pcre.c b/pcre.c
new file mode 100644
index 0000000..11ecc96
--- /dev/null
+++ b/pcre.c
@@ -0,0 +1,9195 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/*
+This is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language. See
+the file Tech.Notes for some information on the internals.
+
+Written by: Philip Hazel <ph10@cam.ac.uk>
+
+           Copyright (c) 1997-2004 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+
+/* Define DEBUG to get debugging output on stdout. */
+/* #define DEBUG */
+
+/* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
+inline, and there are *still* stupid compilers about that don't like indented
+pre-processor statements. I suppose it's only been 10 years... */
+
+#ifdef DEBUG
+#define DPRINTF(p) printf p
+#else
+#define DPRINTF(p) /*nothing*/
+#endif
+
+/* Include the internals header, which itself includes "config.h", the Standard
+C headers, and the external pcre header. */
+
+#include "pcre-internal.h"
+
+/* If Unicode Property support is wanted, include a private copy of the
+function that does it, and the table that translates names to numbers. */
+
+#ifdef SUPPORT_UCP
+#include "ucp.c"
+#include "ucptypetable.c"
+#endif
+
+/* Maximum number of items on the nested bracket stacks at compile time. This
+applies to the nesting of all kinds of parentheses. It does not limit
+un-nested, non-capturing parentheses. This number can be made bigger if
+necessary - it is used to dimension one int and one unsigned char vector at
+compile time. */
+
+#define BRASTACK_SIZE 200
+
+
+/* Maximum number of ints of offset to save on the stack for recursive calls.
+If the offset vector is bigger, malloc is used. This should be a multiple of 3,
+because the offset vector is always a multiple of 3 long. */
+
+#define REC_STACK_SAVE_MAX 30
+
+
+/* The maximum remaining length of subject we are prepared to search for a
+req_byte match. */
+
+#define REQ_BYTE_MAX 1000
+
+
+/* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
+the definition is next to the definition of the opcodes in internal.h. */
+
+static const uschar OP_lengths[] = { OP_LENGTHS };
+
+/* Min and max values for the common repeats; for the maxima, 0 => infinity */
+
+static const char rep_min[] = { 0, 0, 1, 1, 0, 0 };
+static const char rep_max[] = { 0, 0, 0, 0, 1, 1 };
+
+/* Table for handling escaped characters in the range '0'-'z'. Positive returns
+are simple data values; negative values are for special things like \d and so
+on. Zero means further processing is needed (for things like \x), or the escape
+is invalid. */
+
+#if !EBCDIC   /* This is the "normal" table for ASCII systems */
+static const short int escapes[] = {
+     0,      0,      0,      0,      0,      0,      0,      0,   /* 0 - 7 */
+     0,      0,    ':',    ';',    '<',    '=',    '>',    '?',   /* 8 - ? */
+   '@', -ESC_A, -ESC_B, -ESC_C, -ESC_D, -ESC_E,      0, -ESC_G,   /* @ - G */
+     0,      0,      0,      0,      0,      0,      0,      0,   /* H - O */
+-ESC_P, -ESC_Q,      0, -ESC_S,      0,      0,      0, -ESC_W,   /* P - W */
+-ESC_X,      0, -ESC_Z,    '[',   '\\',    ']',    '^',    '_',   /* X - _ */
+   '`',      7, -ESC_b,      0, -ESC_d,  ESC_e,  ESC_f,      0,   /* ` - g */
+     0,      0,      0,      0,      0,      0,  ESC_n,      0,   /* h - o */
+-ESC_p,      0,  ESC_r, -ESC_s,  ESC_tee,    0,      0, -ESC_w,   /* p - w */
+     0,      0, -ESC_z                                            /* x - z */
+};
+
+#else         /* This is the "abnormal" table for EBCDIC systems */
+static const short int escapes[] = {
+/*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',
+/*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,
+/*  58 */     0,     0,    '!',     '$',    '*',   ')',    ';',    '~',
+/*  60 */   '-',   '/',      0,       0,      0,     0,      0,      0,
+/*  68 */     0,     0,    '|',     ',',    '%',   '_',    '>',    '?',
+/*  70 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',
+/*  80 */     0,     7, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,
+/*  88 */     0,     0,      0,     '{',      0,     0,      0,      0,
+/*  90 */     0,     0,      0,     'l',      0, ESC_n,      0, -ESC_p,
+/*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,
+/*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,     0, -ESC_w,      0,
+/*  A8 */     0,-ESC_z,      0,       0,      0,   '[',      0,      0,
+/*  B0 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
+/*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
+/*  C8 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  D0 */   '}',     0,      0,       0,      0,     0,      0, -ESC_P,
+/*  D8 */-ESC_Q,     0,      0,       0,      0,     0,      0,      0,
+/*  E0 */  '\\',     0, -ESC_S,       0,      0,     0, -ESC_W, -ESC_X,
+/*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
+/*  F0 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  F8 */     0,     0,      0,       0,      0,     0,      0,      0
+};
+#endif
+
+
+/* Tables of names of POSIX character classes and their lengths. The list is
+terminated by a zero length entry. The first three must be alpha, upper, lower,
+as this is assumed for handling case independence. */
+
+static const char *const posix_names[] = {
+  "alpha", "lower", "upper",
+  "alnum", "ascii", "blank", "cntrl", "digit", "graph",
+  "print", "punct", "space", "word",  "xdigit" };
+
+static const uschar posix_name_lengths[] = {
+  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
+
+/* Table of class bit maps for each POSIX class; up to three may be combined
+to form the class. The table for [:blank:] is dynamically modified to remove
+the vertical space characters. */
+
+static const int posix_class_maps[] = {
+  cbit_lower, cbit_upper, -1,             /* alpha */
+  cbit_lower, -1,         -1,             /* lower */
+  cbit_upper, -1,         -1,             /* upper */
+  cbit_digit, cbit_lower, cbit_upper,     /* alnum */
+  cbit_print, cbit_cntrl, -1,             /* ascii */
+  cbit_space, -1,         -1,             /* blank - a GNU extension */
+  cbit_cntrl, -1,         -1,             /* cntrl */
+  cbit_digit, -1,         -1,             /* digit */
+  cbit_graph, -1,         -1,             /* graph */
+  cbit_print, -1,         -1,             /* print */
+  cbit_punct, -1,         -1,             /* punct */
+  cbit_space, -1,         -1,             /* space */
+  cbit_word,  -1,         -1,             /* word - a Perl extension */
+  cbit_xdigit,-1,         -1              /* xdigit */
+};
+
+/* Table to identify digits and hex digits. This is used when compiling
+patterns. Note that the tables in chartables are dependent on the locale, and
+may mark arbitrary characters as digits - but the PCRE compiling code expects
+to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
+a private table here. It costs 256 bytes, but it is a lot faster than doing
+character value tests (at least in some simple cases I timed), and in some
+applications one wants PCRE to compile efficiently as well as match
+efficiently.
+
+For convenience, we use the same bit definitions as in chartables:
+
+  0x04   decimal digit
+  0x08   hexadecimal digit
+
+Then we can use ctype_digit and ctype_xdigit in the code. */
+
+#if !EBCDIC    /* This is the "normal" case, for ASCII systems */
+static const unsigned char digitab[] =
+  {
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */
+  0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  */
+  0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  @ - G  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H - O  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  P - W  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  X - _  */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  ` - g  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h - o  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  p - w  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  x -127 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
+
+#else          /* This is the "abnormal" case, for EBCDIC systems */
+static const unsigned char digitab[] =
+  {
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 10 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  32- 39 20 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 30 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 40 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  72- |     */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 50 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  88- ฌ     */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 60 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ?     */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "     */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g  80 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p  90 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x  A0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 B0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191    */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  { - G  C0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  } - P  D0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  \ - X  E0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239    */
+  0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  F0 */
+  0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255    */
+
+static const unsigned char ebcdic_chartab[] = { /* chartable partial dup */
+  0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*   0-  7 */
+  0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
+  0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  16- 23 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+  0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  32- 39 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63 */
+  0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 */
+  0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /*  72- |  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 */
+  0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /*  88- ฌ  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 */
+  0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ?  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "  */
+  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143 */
+  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159 */
+  0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175 */
+  0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 */
+  0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+  0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  { - G  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207 */
+  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  } - P  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223 */
+  0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /*  \ - X  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239 */
+  0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
+  0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255 */
+#endif
+
+
+/* Definition to allow mutual recursion */
+
+static BOOL
+  compile_regex(int, int, int *, uschar **, const uschar **, const char **,
+    BOOL, int, int *, int *, branch_chain *, compile_data *);
+
+/* Structure for building a chain of data that actually lives on the
+stack, for holding the values of the subject pointer at the start of each
+subpattern, so as to detect when an empty string has been matched by a
+subpattern - to break infinite loops. When NO_RECURSE is set, these blocks
+are on the heap, not on the stack. */
+
+typedef struct eptrblock {
+  struct eptrblock *epb_prev;
+  const uschar *epb_saved_eptr;
+} eptrblock;
+
+/* Flag bits for the match() function */
+
+#define match_condassert   0x01    /* Called to check a condition assertion */
+#define match_isgroup      0x02    /* Set if start of bracketed group */
+
+/* Non-error returns from the match() function. Error returns are externally
+defined PCRE_ERROR_xxx codes, which are all negative. */
+
+#define MATCH_MATCH        1
+#define MATCH_NOMATCH      0
+
+
+
+/*************************************************
+*               Global variables                 *
+*************************************************/
+
+/* PCRE is thread-clean and doesn't use any global variables in the normal
+sense. However, it calls memory allocation and free functions via the four
+indirections below, and it can optionally do callouts. These values can be
+changed by the caller, but are shared between all threads. However, when
+compiling for Virtual Pascal, things are done differently (see pcre.in). */
+
+#ifndef VPCOMPAT
+#ifdef __cplusplus
+extern "C" void *(*pcre_malloc)(size_t) = malloc;
+extern "C" void  (*pcre_free)(void *) = free;
+extern "C" void *(*pcre_stack_malloc)(size_t) = malloc;
+extern "C" void  (*pcre_stack_free)(void *) = free;
+extern "C" int   (*pcre_callout)(pcre_callout_block *) = NULL;
+#else
+void *(*pcre_malloc)(size_t) = malloc;
+void  (*pcre_free)(void *) = free;
+void *(*pcre_stack_malloc)(size_t) = malloc;
+void  (*pcre_stack_free)(void *) = free;
+int   (*pcre_callout)(pcre_callout_block *) = NULL;
+#endif
+#endif
+
+
+/*************************************************
+*    Macros and tables for character handling    *
+*************************************************/
+
+/* When UTF-8 encoding is being used, a character is no longer just a single
+byte. The macros for character handling generate simple sequences when used in
+byte-mode, and more complicated ones for UTF-8 characters. */
+
+#ifndef SUPPORT_UTF8
+#define GETCHAR(c, eptr) c = *eptr;
+#define GETCHARINC(c, eptr) c = *eptr++;
+#define GETCHARINCTEST(c, eptr) c = *eptr++;
+#define GETCHARLEN(c, eptr, len) c = *eptr;
+#define BACKCHAR(eptr)
+
+#else   /* SUPPORT_UTF8 */
+
+/* Get the next UTF-8 character, not advancing the pointer. This is called when
+we know we are in UTF-8 mode. */
+
+#define GETCHAR(c, eptr) \
+  c = *eptr; \
+  if ((c & 0xc0) == 0xc0) \
+    { \
+    int gcii; \
+    int gcaa = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+    int gcss = 6*gcaa; \
+    c = (c & utf8_table3[gcaa]) << gcss; \
+    for (gcii = 1; gcii <= gcaa; gcii++) \
+      { \
+      gcss -= 6; \
+      c |= (eptr[gcii] & 0x3f) << gcss; \
+      } \
+    }
+
+/* Get the next UTF-8 character, advancing the pointer. This is called when we
+know we are in UTF-8 mode. */
+
+#define GETCHARINC(c, eptr) \
+  c = *eptr++; \
+  if ((c & 0xc0) == 0xc0) \
+    { \
+    int gcaa = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+    int gcss = 6*gcaa; \
+    c = (c & utf8_table3[gcaa]) << gcss; \
+    while (gcaa-- > 0) \
+      { \
+      gcss -= 6; \
+      c |= (*eptr++ & 0x3f) << gcss; \
+      } \
+    }
+
+/* Get the next character, testing for UTF-8 mode, and advancing the pointer */
+
+#define GETCHARINCTEST(c, eptr) \
+  c = *eptr++; \
+  if (md->utf8 && (c & 0xc0) == 0xc0) \
+    { \
+    int gcaa = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+    int gcss = 6*gcaa; \
+    c = (c & utf8_table3[gcaa]) << gcss; \
+    while (gcaa-- > 0) \
+      { \
+      gcss -= 6; \
+      c |= (*eptr++ & 0x3f) << gcss; \
+      } \
+    }
+
+/* Get the next UTF-8 character, not advancing the pointer, incrementing length
+if there are extra bytes. This is called when we know we are in UTF-8 mode. */
+
+#define GETCHARLEN(c, eptr, len) \
+  c = *eptr; \
+  if ((c & 0xc0) == 0xc0) \
+    { \
+    int gcii; \
+    int gcaa = utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+    int gcss = 6*gcaa; \
+    c = (c & utf8_table3[gcaa]) << gcss; \
+    for (gcii = 1; gcii <= gcaa; gcii++) \
+      { \
+      gcss -= 6; \
+      c |= (eptr[gcii] & 0x3f) << gcss; \
+      } \
+    len += gcaa; \
+    }
+
+/* If the pointer is not at the start of a character, move it back until
+it is. Called only in UTF-8 mode. */
+
+#define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--;
+
+#endif
+
+
+
+/*************************************************
+*             Default character tables           *
+*************************************************/
+
+/* A default set of character tables is included in the PCRE binary. Its source
+is built by the maketables auxiliary program, which uses the default C ctypes
+functions, and put in the file chartables.c. These tables are used by PCRE
+whenever the caller of pcre_compile() does not provide an alternate set of
+tables. */
+
+#include "pcre-chartables.c"
+
+
+
+#ifdef SUPPORT_UTF8
+/*************************************************
+*           Tables for UTF-8 support             *
+*************************************************/
+
+/* These are the breakpoints for different numbers of bytes in a UTF-8
+character. */
+
+static const int utf8_table1[] =
+  { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff};
+
+/* These are the indicator bits and the mask for the data bits to set in the
+first byte of a character, indexed by the number of additional bytes. */
+
+static const int utf8_table2[] = { 0,    0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
+static const int utf8_table3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
+
+/* Table of the number of extra characters, indexed by the first character
+masked with 0x3f. The highest number for a valid UTF-8 character is in fact
+0x3d. */
+
+static const uschar utf8_table4[] = {
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
+
+
+/*************************************************
+*       Convert character value to UTF-8         *
+*************************************************/
+
+/* This function takes an integer value in the range 0 - 0x7fffffff
+and encodes it as a UTF-8 character in 0 to 6 bytes.
+
+Arguments:
+  cvalue     the character value
+  buffer     pointer to buffer for result - at least 6 bytes long
+
+Returns:     number of characters placed in the buffer
+*/
+
+static int
+ord2utf8(int cvalue, uschar *buffer)
+{
+register int i, j;
+for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
+  if (cvalue <= utf8_table1[i]) break;
+buffer += i;
+for (j = i; j > 0; j--)
+ {
+ *buffer-- = 0x80 | (cvalue & 0x3f);
+ cvalue >>= 6;
+ }
+*buffer = utf8_table2[i] | cvalue;
+return i + 1;
+}
+#endif
+
+
+
+/*************************************************
+*         Print compiled regex                   *
+*************************************************/
+
+/* The code for doing this is held in a separate file that is also included in
+pcretest.c. It defines a function called print_internals(). */
+
+#ifdef DEBUG
+#include "printint.c"
+#endif
+
+
+
+/*************************************************
+*          Return version string                 *
+*************************************************/
+
+#define STRING(a)  # a
+#define XSTRING(s) STRING(s)
+
+EXPORT const char *
+pcre_version(void)
+{
+return XSTRING(PCRE_MAJOR) "." XSTRING(PCRE_MINOR) " " XSTRING(PCRE_DATE);
+}
+
+
+
+
+/*************************************************
+*         Flip bytes in an integer               *
+*************************************************/
+
+/* This function is called when the magic number in a regex doesn't match in
+order to flip its bytes to see if we are dealing with a pattern that was
+compiled on a host of different endianness. If so, this function is used to
+flip other byte values.
+
+Arguments:
+  value        the number to flip
+  n            the number of bytes to flip (assumed to be 2 or 4)
+
+Returns:       the flipped value
+*/
+
+static long int
+byteflip(long int value, int n)
+{
+if (n == 2) return ((value & 0x00ff) << 8) | ((value & 0xff00) >> 8);
+return ((value & 0x000000ff) << 24) |
+       ((value & 0x0000ff00) <<  8) |
+       ((value & 0x00ff0000) >>  8) |
+       ((value & 0xff000000) >> 24);
+}
+
+
+
+/*************************************************
+*       Test for a byte-flipped compiled regex   *
+*************************************************/
+
+/* This function is called from pce_exec() and also from pcre_fullinfo(). Its
+job is to test whether the regex is byte-flipped - that is, it was compiled on
+a system of opposite endianness. The function is called only when the native
+MAGIC_NUMBER test fails. If the regex is indeed flipped, we flip all the
+relevant values into a different data block, and return it.
+
+Arguments:
+  re               points to the regex
+  study            points to study data, or NULL
+  internal_re      points to a new regex block
+  internal_study   points to a new study block
+
+Returns:           the new block if is is indeed a byte-flipped regex
+                   NULL if it is not
+*/
+
+static real_pcre *
+try_flipped(const real_pcre *re, real_pcre *internal_re,
+  const pcre_study_data *study, pcre_study_data *internal_study)
+{
+if (byteflip(re->magic_number, sizeof(re->magic_number)) != MAGIC_NUMBER)
+  return NULL;
+
+*internal_re = *re;           /* To copy other fields */
+internal_re->size = byteflip(re->size, sizeof(re->size));
+internal_re->options = byteflip(re->options, sizeof(re->options));
+internal_re->top_bracket = byteflip(re->top_bracket, sizeof(re->top_bracket));
+internal_re->top_backref = byteflip(re->top_backref, sizeof(re->top_backref));
+internal_re->first_byte = byteflip(re->first_byte, sizeof(re->first_byte));
+internal_re->req_byte = byteflip(re->req_byte, sizeof(re->req_byte));
+internal_re->name_table_offset = byteflip(re->name_table_offset,
+  sizeof(re->name_table_offset));
+internal_re->name_entry_size = byteflip(re->name_entry_size,
+  sizeof(re->name_entry_size));
+internal_re->name_count = byteflip(re->name_count, sizeof(re->name_count));
+
+if (study != NULL)
+  {
+  *internal_study = *study;   /* To copy other fields */
+  internal_study->size = byteflip(study->size, sizeof(study->size));
+  internal_study->options = byteflip(study->options, sizeof(study->options));
+  }
+
+return internal_re;
+}
+
+
+
+/*************************************************
+* (Obsolete) Return info about compiled pattern  *
+*************************************************/
+
+/* This is the original "info" function. It picks potentially useful data out
+of the private structure, but its interface was too rigid. It remains for
+backwards compatibility. The public options are passed back in an int - though
+the re->options field has been expanded to a long int, all the public options
+at the low end of it, and so even on 16-bit systems this will still be OK.
+Therefore, I haven't changed the API for pcre_info().
+
+Arguments:
+  argument_re   points to compiled code
+  optptr        where to pass back the options
+  first_byte    where to pass back the first character,
+                or -1 if multiline and all branches start ^,
+                or -2 otherwise
+
+Returns:        number of capturing subpatterns
+                or negative values on error
+*/
+
+EXPORT int
+pcre_info(const pcre *argument_re, int *optptr, int *first_byte)
+{
+real_pcre internal_re;
+const real_pcre *re = (const real_pcre *)argument_re;
+if (re == NULL) return PCRE_ERROR_NULL;
+if (re->magic_number != MAGIC_NUMBER)
+  {
+  re = try_flipped(re, &internal_re, NULL, NULL);
+  if (re == NULL) return PCRE_ERROR_BADMAGIC;
+  }
+if (optptr != NULL) *optptr = (int)(re->options & PUBLIC_OPTIONS);
+if (first_byte != NULL)
+  *first_byte = ((re->options & PCRE_FIRSTSET) != 0)? re->first_byte :
+     ((re->options & PCRE_STARTLINE) != 0)? -1 : -2;
+return re->top_bracket;
+}
+
+
+
+/*************************************************
+*        Return info about compiled pattern      *
+*************************************************/
+
+/* This is a newer "info" function which has an extensible interface so
+that additional items can be added compatibly.
+
+Arguments:
+  argument_re      points to compiled code
+  extra_data       points extra data, or NULL
+  what             what information is required
+  where            where to put the information
+
+Returns:           0 if data returned, negative on error
+*/
+
+EXPORT int
+pcre_fullinfo(const pcre *argument_re, const pcre_extra *extra_data, int what,
+  void *where)
+{
+real_pcre internal_re;
+pcre_study_data internal_study;
+const real_pcre *re = (const real_pcre *)argument_re;
+const pcre_study_data *study = NULL;
+
+if (re == NULL || where == NULL) return PCRE_ERROR_NULL;
+
+if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
+  study = (const pcre_study_data *)extra_data->study_data;
+
+if (re->magic_number != MAGIC_NUMBER)
+  {
+  re = try_flipped(re, &internal_re, study, &internal_study);
+  if (re == NULL) return PCRE_ERROR_BADMAGIC;
+  if (study != NULL) study = &internal_study;
+  }
+
+switch (what)
+  {
+  case PCRE_INFO_OPTIONS:
+  *((unsigned long int *)where) = re->options & PUBLIC_OPTIONS;
+  break;
+
+  case PCRE_INFO_SIZE:
+  *((size_t *)where) = re->size;
+  break;
+
+  case PCRE_INFO_STUDYSIZE:
+  *((size_t *)where) = (study == NULL)? 0 : study->size;
+  break;
+
+  case PCRE_INFO_CAPTURECOUNT:
+  *((int *)where) = re->top_bracket;
+  break;
+
+  case PCRE_INFO_BACKREFMAX:
+  *((int *)where) = re->top_backref;
+  break;
+
+  case PCRE_INFO_FIRSTBYTE:
+  *((int *)where) =
+    ((re->options & PCRE_FIRSTSET) != 0)? re->first_byte :
+    ((re->options & PCRE_STARTLINE) != 0)? -1 : -2;
+  break;
+
+  /* Make sure we pass back the pointer to the bit vector in the external
+  block, not the internal copy (with flipped integer fields). */
+
+  case PCRE_INFO_FIRSTTABLE:
+  *((const uschar **)where) =
+    (study != NULL && (study->options & PCRE_STUDY_MAPPED) != 0)?
+      ((const pcre_study_data *)extra_data->study_data)->start_bits : NULL;
+  break;
+
+  case PCRE_INFO_LASTLITERAL:
+  *((int *)where) =
+    ((re->options & PCRE_REQCHSET) != 0)? re->req_byte : -1;
+  break;
+
+  case PCRE_INFO_NAMEENTRYSIZE:
+  *((int *)where) = re->name_entry_size;
+  break;
+
+  case PCRE_INFO_NAMECOUNT:
+  *((int *)where) = re->name_count;
+  break;
+
+  case PCRE_INFO_NAMETABLE:
+  *((const uschar **)where) = (const uschar *)re + re->name_table_offset;
+  break;
+
+  case PCRE_INFO_DEFAULT_TABLES:
+  *((const uschar **)where) = (const uschar *)pcre_default_tables;
+  break;
+
+  default: return PCRE_ERROR_BADOPTION;
+  }
+
+return 0;
+}
+
+
+
+/*************************************************
+* Return info about what features are configured *
+*************************************************/
+
+/* This is function which has an extensible interface so that additional items
+can be added compatibly.
+
+Arguments:
+  what             what information is required
+  where            where to put the information
+
+Returns:           0 if data returned, negative on error
+*/
+
+EXPORT int
+pcre_config(int what, void *where)
+{
+switch (what)
+  {
+  case PCRE_CONFIG_UTF8:
+#ifdef SUPPORT_UTF8
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+
+  case PCRE_CONFIG_UNICODE_PROPERTIES:
+#ifdef SUPPORT_UCP
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+
+  case PCRE_CONFIG_NEWLINE:
+  *((int *)where) = NEWLINE;
+  break;
+
+  case PCRE_CONFIG_LINK_SIZE:
+  *((int *)where) = LINK_SIZE;
+  break;
+
+  case PCRE_CONFIG_POSIX_MALLOC_THRESHOLD:
+  *((int *)where) = POSIX_MALLOC_THRESHOLD;
+  break;
+
+  case PCRE_CONFIG_MATCH_LIMIT:
+  *((unsigned int *)where) = MATCH_LIMIT;
+  break;
+
+  case PCRE_CONFIG_STACKRECURSE:
+#ifdef NO_RECURSE
+  *((int *)where) = 0;
+#else
+  *((int *)where) = 1;
+#endif
+  break;
+
+  default: return PCRE_ERROR_BADOPTION;
+  }
+
+return 0;
+}
+
+
+
+#ifdef DEBUG
+/*************************************************
+*        Debugging function to print chars       *
+*************************************************/
+
+/* Print a sequence of chars in printable format, stopping at the end of the
+subject if the requested.
+
+Arguments:
+  p           points to characters
+  length      number to print
+  is_subject  TRUE if printing from within md->start_subject
+  md          pointer to matching data block, if is_subject is TRUE
+
+Returns:     nothing
+*/
+
+static void
+pchars(const uschar *p, int length, BOOL is_subject, match_data *md)
+{
+int c;
+if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
+while (length-- > 0)
+  if (isprint(c = *(p++))) printf("%c", c); else printf("\\x%02x", c);
+}
+#endif
+
+
+
+
+/*************************************************
+*            Handle escapes                      *
+*************************************************/
+
+/* This function is called when a \ has been encountered. It either returns a
+positive value for a simple escape such as \n, or a negative value which
+encodes one of the more complicated things such as \d. When UTF-8 is enabled,
+a positive value greater than 255 may be returned. On entry, ptr is pointing at
+the \. On exit, it is on the final character of the escape sequence.
+
+Arguments:
+  ptrptr     points to the pattern position pointer
+  errorptr   points to the pointer to the error message
+  bracount   number of previous extracting brackets
+  options    the options bits
+  isclass    TRUE if inside a character class
+
+Returns:     zero or positive => a data character
+             negative => a special escape sequence
+             on error, errorptr is set
+*/
+
+static int
+check_escape(const uschar **ptrptr, const char **errorptr, int bracount,
+  int options, BOOL isclass)
+{
+const uschar *ptr = *ptrptr;
+int c, i;
+
+/* If backslash is at the end of the pattern, it's an error. */
+
+c = *(++ptr);
+if (c == 0) *errorptr = ERR1;
+
+/* Non-alphamerics are literals. For digits or letters, do an initial lookup in
+a table. A non-zero result is something that can be returned immediately.
+Otherwise further processing may be required. */
+
+#if !EBCDIC    /* ASCII coding */
+else if (c < '0' || c > 'z') {}                           /* Not alphameric */
+else if ((i = escapes[c - '0']) != 0) c = i;
+
+#else          /* EBCDIC coding */
+else if (c < 'a' || (ebcdic_chartab[c] & 0x0E) == 0) {}   /* Not alphameric */
+else if ((i = escapes[c - 0x48]) != 0)  c = i;
+#endif
+
+/* Escapes that need further processing, or are illegal. */
+
+else
+  {
+  const uschar *oldptr;
+  switch (c)
+    {
+    /* A number of Perl escapes are not handled by PCRE. We give an explicit
+    error. */
+
+    case 'l':
+    case 'L':
+    case 'N':
+    case 'u':
+    case 'U':
+    *errorptr = ERR37;
+    break;
+
+    /* The handling of escape sequences consisting of a string of digits
+    starting with one that is not zero is not straightforward. By experiment,
+    the way Perl works seems to be as follows:
+
+    Outside a character class, the digits are read as a decimal number. If the
+    number is less than 10, or if there are that many previous extracting
+    left brackets, then it is a back reference. Otherwise, up to three octal
+    digits are read to form an escaped byte. Thus \123 is likely to be octal
+    123 (cf \0123, which is octal 012 followed by the literal 3). If the octal
+    value is greater than 377, the least significant 8 bits are taken. Inside a
+    character class, \ followed by a digit is always an octal number. */
+
+    case '1': case '2': case '3': case '4': case '5':
+    case '6': case '7': case '8': case '9':
+
+    if (!isclass)
+      {
+      oldptr = ptr;
+      c -= '0';
+      while ((digitab[ptr[1]] & ctype_digit) != 0)
+        c = c * 10 + *(++ptr) - '0';
+      if (c < 10 || c <= bracount)
+        {
+        c = -(ESC_REF + c);
+        break;
+        }
+      ptr = oldptr;      /* Put the pointer back and fall through */
+      }
+
+    /* Handle an octal number following \. If the first digit is 8 or 9, Perl
+    generates a binary zero byte and treats the digit as a following literal.
+    Thus we have to pull back the pointer by one. */
+
+    if ((c = *ptr) >= '8')
+      {
+      ptr--;
+      c = 0;
+      break;
+      }
+
+    /* \0 always starts an octal number, but we may drop through to here with a
+    larger first octal digit. */
+
+    case '0':
+    c -= '0';
+    while(i++ < 2 && ptr[1] >= '0' && ptr[1] <= '7')
+        c = c * 8 + *(++ptr) - '0';
+    c &= 255;     /* Take least significant 8 bits */
+    break;
+
+    /* \x is complicated when UTF-8 is enabled. \x{ddd} is a character number
+    which can be greater than 0xff, but only if the ddd are hex digits. */
+
+    case 'x':
+#ifdef SUPPORT_UTF8
+    if (ptr[1] == '{' && (options & PCRE_UTF8) != 0)
+      {
+      const uschar *pt = ptr + 2;
+      register int count = 0;
+      c = 0;
+      while ((digitab[*pt] & ctype_xdigit) != 0)
+        {
+        int cc = *pt++;
+        count++;
+#if !EBCDIC    /* ASCII coding */
+        if (cc >= 'a') cc -= 32;               /* Convert to upper case */
+        c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
+#else          /* EBCDIC coding */
+        if (cc >= 'a' && cc <= 'z') cc += 64;  /* Convert to upper case */
+        c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
+#endif
+        }
+      if (*pt == '}')
+        {
+        if (c < 0 || count > 8) *errorptr = ERR34;
+        ptr = pt;
+        break;
+        }
+      /* If the sequence of hex digits does not end with '}', then we don't
+      recognize this construct; fall through to the normal \x handling. */
+      }
+#endif
+
+    /* Read just a single hex char */
+
+    c = 0;
+    while (i++ < 2 && (digitab[ptr[1]] & ctype_xdigit) != 0)
+      {
+      int cc;                               /* Some compilers don't like ++ */
+      cc = *(++ptr);                        /* in initializers */
+#if !EBCDIC    /* ASCII coding */
+      if (cc >= 'a') cc -= 32;              /* Convert to upper case */
+      c = c * 16 + cc - ((cc < 'A')? '0' : ('A' - 10));
+#else          /* EBCDIC coding */
+      if (cc <= 'z') cc += 64;              /* Convert to upper case */
+      c = c * 16 + cc - ((cc >= '0')? '0' : ('A' - 10));
+#endif
+      }
+    break;
+
+    /* Other special escapes not starting with a digit are straightforward */
+
+    case 'c':
+    c = *(++ptr);
+    if (c == 0)
+      {
+      *errorptr = ERR2;
+      return 0;
+      }
+
+    /* A letter is upper-cased; then the 0x40 bit is flipped. This coding
+    is ASCII-specific, but then the whole concept of \cx is ASCII-specific.
+    (However, an EBCDIC equivalent has now been added.) */
+
+#if !EBCDIC    /* ASCII coding */
+    if (c >= 'a' && c <= 'z') c -= 32;
+    c ^= 0x40;
+#else          /* EBCDIC coding */
+    if (c >= 'a' && c <= 'z') c += 64;
+    c ^= 0xC0;
+#endif
+    break;
+
+    /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
+    other alphameric following \ is an error if PCRE_EXTRA was set; otherwise,
+    for Perl compatibility, it is a literal. This code looks a bit odd, but
+    there used to be some cases other than the default, and there may be again
+    in future, so I haven't "optimized" it. */
+
+    default:
+    if ((options & PCRE_EXTRA) != 0) switch(c)
+      {
+      default:
+      *errorptr = ERR3;
+      break;
+      }
+    break;
+    }
+  }
+
+*ptrptr = ptr;
+return c;
+}
+
+
+
+#ifdef SUPPORT_UCP
+/*************************************************
+*               Handle \P and \p                 *
+*************************************************/
+
+/* This function is called after \P or \p has been encountered, provided that
+PCRE is compiled with support for Unicode properties. On entry, ptrptr is
+pointing at the P or p. On exit, it is pointing at the final character of the
+escape sequence.
+
+Argument:
+  ptrptr     points to the pattern position pointer
+  negptr     points to a boolean that is set TRUE for negation else FALSE
+  errorptr   points to the pointer to the error message
+
+Returns:     value from ucp_type_table, or -1 for an invalid type
+*/
+
+static int
+get_ucp(const uschar **ptrptr, BOOL *negptr, const char **errorptr)
+{
+int c, i, bot, top;
+const uschar *ptr = *ptrptr;
+char name[4];
+
+c = *(++ptr);
+if (c == 0) goto ERROR_RETURN;
+
+*negptr = FALSE;
+
+/* \P or \p can be followed by a one- or two-character name in {}, optionally
+preceded by ^ for negation. */
+
+if (c == '{')
+  {
+  if (ptr[1] == '^')
+    {
+    *negptr = TRUE;
+    ptr++;
+    }
+  for (i = 0; i <= 2; i++)
+    {
+    c = *(++ptr);
+    if (c == 0) goto ERROR_RETURN;
+    if (c == '}') break;
+    name[i] = c;
+    }
+  if (c !='}')   /* Try to distinguish error cases */
+    {
+    while (*(++ptr) != 0 && *ptr != '}');
+    if (*ptr == '}') goto UNKNOWN_RETURN; else goto ERROR_RETURN;
+    }
+  name[i] = 0;
+  }
+
+/* Otherwise there is just one following character */
+
+else
+  {
+  name[0] = c;
+  name[1] = 0;
+  }
+
+*ptrptr = ptr;
+
+/* Search for a recognized property name using binary chop */
+
+bot = 0;
+top = sizeof(utt)/sizeof(ucp_type_table);
+
+while (bot < top)
+  {
+  i = (bot + top)/2;
+  c = strcmp(name, utt[i].name);
+  if (c == 0) return utt[i].value;
+  if (c > 0) bot = i + 1; else top = i;
+  }
+
+UNKNOWN_RETURN:
+*errorptr = ERR47;
+*ptrptr = ptr;
+return -1;
+
+ERROR_RETURN:
+*errorptr = ERR46;
+*ptrptr = ptr;
+return -1;
+}
+#endif
+
+
+
+
+/*************************************************
+*            Check for counted repeat            *
+*************************************************/
+
+/* This function is called when a '{' is encountered in a place where it might
+start a quantifier. It looks ahead to see if it really is a quantifier or not.
+It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
+where the ddds are digits.
+
+Arguments:
+  p         pointer to the first char after '{'
+
+Returns:    TRUE or FALSE
+*/
+
+static BOOL
+is_counted_repeat(const uschar *p)
+{
+if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
+while ((digitab[*p] & ctype_digit) != 0) p++;
+if (*p == '}') return TRUE;
+
+if (*p++ != ',') return FALSE;
+if (*p == '}') return TRUE;
+
+if ((digitab[*p++] & ctype_digit) == 0) return FALSE;
+while ((digitab[*p] & ctype_digit) != 0) p++;
+
+return (*p == '}');
+}
+
+
+
+/*************************************************
+*         Read repeat counts                     *
+*************************************************/
+
+/* Read an item of the form {n,m} and return the values. This is called only
+after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
+so the syntax is guaranteed to be correct, but we need to check the values.
+
+Arguments:
+  p          pointer to first char after '{'
+  minp       pointer to int for min
+  maxp       pointer to int for max
+             returned as -1 if no max
+  errorptr   points to pointer to error message
+
+Returns:     pointer to '}' on success;
+             current ptr on error, with errorptr set
+*/
+
+static const uschar *
+read_repeat_counts(const uschar *p, int *minp, int *maxp, const char **errorptr)
+{
+int min = 0;
+int max = -1;
+
+while ((digitab[*p] & ctype_digit) != 0) min = min * 10 + *p++ - '0';
+
+if (*p == '}') max = min; else
+  {
+  if (*(++p) != '}')
+    {
+    max = 0;
+    while((digitab[*p] & ctype_digit) != 0) max = max * 10 + *p++ - '0';
+    if (max < min)
+      {
+      *errorptr = ERR4;
+      return p;
+      }
+    }
+  }
+
+/* Do paranoid checks, then fill in the required variables, and pass back the
+pointer to the terminating '}'. */
+
+if (min > 65535 || max > 65535)
+  *errorptr = ERR5;
+else
+  {
+  *minp = min;
+  *maxp = max;
+  }
+return p;
+}
+
+
+
+/*************************************************
+*      Find first significant op code            *
+*************************************************/
+
+/* This is called by several functions that scan a compiled expression looking
+for a fixed first character, or an anchoring op code etc. It skips over things
+that do not influence this. For some calls, a change of option is important.
+For some calls, it makes sense to skip negative forward and all backward
+assertions, and also the \b assertion; for others it does not.
+
+Arguments:
+  code         pointer to the start of the group
+  options      pointer to external options
+  optbit       the option bit whose changing is significant, or
+                 zero if none are
+  skipassert   TRUE if certain assertions are to be skipped
+
+Returns:       pointer to the first significant opcode
+*/
+
+static const uschar*
+first_significant_code(const uschar *code, int *options, int optbit,
+  BOOL skipassert)
+{
+for (;;)
+  {
+  switch ((int)*code)
+    {
+    case OP_OPT:
+    if (optbit > 0 && ((int)code[1] & optbit) != (*options & optbit))
+      *options = (int)code[1];
+    code += 2;
+    break;
+
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    if (!skipassert) return code;
+    do code += GET(code, 1); while (*code == OP_ALT);
+    code += OP_lengths[*code];
+    break;
+
+    case OP_WORD_BOUNDARY:
+    case OP_NOT_WORD_BOUNDARY:
+    if (!skipassert) return code;
+    /* Fall through */
+
+    case OP_CALLOUT:
+    case OP_CREF:
+    case OP_BRANUMBER:
+    code += OP_lengths[*code];
+    break;
+
+    default:
+    return code;
+    }
+  }
+/* Control never reaches here */
+}
+
+
+
+
+/*************************************************
+*        Find the fixed length of a pattern      *
+*************************************************/
+
+/* Scan a pattern and compute the fixed length of subject that will match it,
+if the length is fixed. This is needed for dealing with backward assertions.
+In UTF8 mode, the result is in characters rather than bytes.
+
+Arguments:
+  code     points to the start of the pattern (the bracket)
+  options  the compiling options
+
+Returns:   the fixed length, or -1 if there is no fixed length,
+             or -2 if \C was encountered
+*/
+
+static int
+find_fixedlength(uschar *code, int options)
+{
+int length = -1;
+
+register int branchlength = 0;
+register uschar *cc = code + 1 + LINK_SIZE;
+
+/* Scan along the opcodes for this branch. If we get to the end of the
+branch, check the length against that of the other branches. */
+
+for (;;)
+  {
+  int d;
+  register int op = *cc;
+  if (op >= OP_BRA) op = OP_BRA;
+
+  switch (op)
+    {
+    case OP_BRA:
+    case OP_ONCE:
+    case OP_COND:
+    d = find_fixedlength(cc, options);
+    if (d < 0) return d;
+    branchlength += d;
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* Reached end of a branch; if it's a ket it is the end of a nested
+    call. If it's ALT it is an alternation in a nested call. If it is
+    END it's the end of the outer call. All can be handled by the same code. */
+
+    case OP_ALT:
+    case OP_KET:
+    case OP_KETRMAX:
+    case OP_KETRMIN:
+    case OP_END:
+    if (length < 0) length = branchlength;
+      else if (length != branchlength) return -1;
+    if (*cc != OP_ALT) return length;
+    cc += 1 + LINK_SIZE;
+    branchlength = 0;
+    break;
+
+    /* Skip over assertive subpatterns */
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    /* Fall through */
+
+    /* Skip over things that don't match chars */
+
+    case OP_REVERSE:
+    case OP_BRANUMBER:
+    case OP_CREF:
+    case OP_OPT:
+    case OP_CALLOUT:
+    case OP_SOD:
+    case OP_SOM:
+    case OP_EOD:
+    case OP_EODN:
+    case OP_CIRC:
+    case OP_DOLL:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    cc += OP_lengths[*cc];
+    break;
+
+    /* Handle literal characters */
+
+    case OP_CHAR:
+    case OP_CHARNC:
+    branchlength++;
+    cc += 2;
+#ifdef SUPPORT_UTF8
+    if ((options & PCRE_UTF8) != 0)
+      {
+      while ((*cc & 0xc0) == 0x80) cc++;
+      }
+#endif
+    break;
+
+    /* Handle exact repetitions. The count is already in characters, but we
+    need to skip over a multibyte character in UTF8 mode.  */
+
+    case OP_EXACT:
+    branchlength += GET2(cc,1);
+    cc += 4;
+#ifdef SUPPORT_UTF8
+    if ((options & PCRE_UTF8) != 0)
+      {
+      while((*cc & 0x80) == 0x80) cc++;
+      }
+#endif
+    break;
+
+    case OP_TYPEEXACT:
+    branchlength += GET2(cc,1);
+    cc += 4;
+    break;
+
+    /* Handle single-char matchers */
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    cc++;
+    /* Fall through */
+
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+    case OP_ANY:
+    branchlength++;
+    cc++;
+    break;
+
+    /* The single-byte matcher isn't allowed */
+
+    case OP_ANYBYTE:
+    return -2;
+
+    /* Check a class for variable quantification */
+
+#ifdef SUPPORT_UTF8
+    case OP_XCLASS:
+    cc += GET(cc, 1) - 33;
+    /* Fall through */
+#endif
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    cc += 33;
+
+    switch (*cc)
+      {
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      return -1;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      if (GET2(cc,1) != GET2(cc,3)) return -1;
+      branchlength += GET2(cc,1);
+      cc += 5;
+      break;
+
+      default:
+      branchlength++;
+      }
+    break;
+
+    /* Anything else is variable length */
+
+    default:
+    return -1;
+    }
+  }
+/* Control never gets here */
+}
+
+
+
+
+/*************************************************
+*    Scan compiled regex for numbered bracket    *
+*************************************************/
+
+/* This little function scans through a compiled pattern until it finds a
+capturing bracket with the given number.
+
+Arguments:
+  code        points to start of expression
+  utf8        TRUE in UTF-8 mode
+  number      the required bracket number
+
+Returns:      pointer to the opcode for the bracket, or NULL if not found
+*/
+
+static const uschar *
+find_bracket(const uschar *code, BOOL utf8, int number)
+{
+#ifndef SUPPORT_UTF8
+utf8 = utf8;               /* Stop pedantic compilers complaining */
+#endif
+
+for (;;)
+  {
+  register int c = *code;
+  if (c == OP_END) return NULL;
+  else if (c > OP_BRA)
+    {
+    int n = c - OP_BRA;
+    if (n > EXTRACT_BASIC_MAX) n = GET2(code, 2+LINK_SIZE);
+    if (n == number) return (uschar *)code;
+    code += OP_lengths[OP_BRA];
+    }
+  else
+    {
+    code += OP_lengths[c];
+
+#ifdef SUPPORT_UTF8
+
+    /* In UTF-8 mode, opcodes that are followed by a character may be followed
+    by a multi-byte character. The length in the table is a minimum, so we have
+    to scan along to skip the extra bytes. All opcodes are less than 128, so we
+    can use relatively efficient code. */
+
+    if (utf8) switch(c)
+      {
+      case OP_CHAR:
+      case OP_CHARNC:
+      case OP_EXACT:
+      case OP_UPTO:
+      case OP_MINUPTO:
+      case OP_STAR:
+      case OP_MINSTAR:
+      case OP_PLUS:
+      case OP_MINPLUS:
+      case OP_QUERY:
+      case OP_MINQUERY:
+      while ((*code & 0xc0) == 0x80) code++;
+      break;
+
+      /* XCLASS is used for classes that cannot be represented just by a bit
+      map. This includes negated single high-valued characters. The length in
+      the table is zero; the actual length is stored in the compiled code. */
+
+      case OP_XCLASS:
+      code += GET(code, 1) + 1;
+      break;
+      }
+#endif
+    }
+  }
+}
+
+
+
+/*************************************************
+*   Scan compiled regex for recursion reference  *
+*************************************************/
+
+/* This little function scans through a compiled pattern until it finds an
+instance of OP_RECURSE.
+
+Arguments:
+  code        points to start of expression
+  utf8        TRUE in UTF-8 mode
+
+Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
+*/
+
+static const uschar *
+find_recurse(const uschar *code, BOOL utf8)
+{
+#ifndef SUPPORT_UTF8
+utf8 = utf8;               /* Stop pedantic compilers complaining */
+#endif
+
+for (;;)
+  {
+  register int c = *code;
+  if (c == OP_END) return NULL;
+  else if (c == OP_RECURSE) return code;
+  else if (c > OP_BRA)
+    {
+    code += OP_lengths[OP_BRA];
+    }
+  else
+    {
+    code += OP_lengths[c];
+
+#ifdef SUPPORT_UTF8
+
+    /* In UTF-8 mode, opcodes that are followed by a character may be followed
+    by a multi-byte character. The length in the table is a minimum, so we have
+    to scan along to skip the extra bytes. All opcodes are less than 128, so we
+    can use relatively efficient code. */
+
+    if (utf8) switch(c)
+      {
+      case OP_CHAR:
+      case OP_CHARNC:
+      case OP_EXACT:
+      case OP_UPTO:
+      case OP_MINUPTO:
+      case OP_STAR:
+      case OP_MINSTAR:
+      case OP_PLUS:
+      case OP_MINPLUS:
+      case OP_QUERY:
+      case OP_MINQUERY:
+      while ((*code & 0xc0) == 0x80) code++;
+      break;
+
+      /* XCLASS is used for classes that cannot be represented just by a bit
+      map. This includes negated single high-valued characters. The length in
+      the table is zero; the actual length is stored in the compiled code. */
+
+      case OP_XCLASS:
+      code += GET(code, 1) + 1;
+      break;
+      }
+#endif
+    }
+  }
+}
+
+
+
+/*************************************************
+*    Scan compiled branch for non-emptiness      *
+*************************************************/
+
+/* This function scans through a branch of a compiled pattern to see whether it
+can match the empty string or not. It is called only from could_be_empty()
+below. Note that first_significant_code() skips over assertions. If we hit an
+unclosed bracket, we return "empty" - this means we've struck an inner bracket
+whose current branch will already have been scanned.
+
+Arguments:
+  code        points to start of search
+  endcode     points to where to stop
+  utf8        TRUE if in UTF8 mode
+
+Returns:      TRUE if what is matched could be empty
+*/
+
+static BOOL
+could_be_empty_branch(const uschar *code, const uschar *endcode, BOOL utf8)
+{
+register int c;
+for (code = first_significant_code(code + 1 + LINK_SIZE, NULL, 0, TRUE);
+     code < endcode;
+     code = first_significant_code(code + OP_lengths[c], NULL, 0, TRUE))
+  {
+  const uschar *ccode;
+
+  c = *code;
+
+  if (c >= OP_BRA)
+    {
+    BOOL empty_branch;
+    if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
+
+    /* Scan a closed bracket */
+
+    empty_branch = FALSE;
+    do
+      {
+      if (!empty_branch && could_be_empty_branch(code, endcode, utf8))
+        empty_branch = TRUE;
+      code += GET(code, 1);
+      }
+    while (*code == OP_ALT);
+    if (!empty_branch) return FALSE;   /* All branches are non-empty */
+    code += 1 + LINK_SIZE;
+    c = *code;
+    }
+
+  else switch (c)
+    {
+    /* Check for quantifiers after a class */
+
+#ifdef SUPPORT_UTF8
+    case OP_XCLASS:
+    ccode = code + GET(code, 1);
+    goto CHECK_CLASS_REPEAT;
+#endif
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    ccode = code + 33;
+
+#ifdef SUPPORT_UTF8
+    CHECK_CLASS_REPEAT:
+#endif
+
+    switch (*ccode)
+      {
+      case OP_CRSTAR:            /* These could be empty; continue */
+      case OP_CRMINSTAR:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      break;
+
+      default:                   /* Non-repeat => class must match */
+      case OP_CRPLUS:            /* These repeats aren't empty */
+      case OP_CRMINPLUS:
+      return FALSE;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */
+      break;
+      }
+    break;
+
+    /* Opcodes that must match a character */
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    case OP_EXTUNI:
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+    case OP_ANY:
+    case OP_ANYBYTE:
+    case OP_CHAR:
+    case OP_CHARNC:
+    case OP_NOT:
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_EXACT:
+    case OP_NOTPLUS:
+    case OP_NOTMINPLUS:
+    case OP_NOTEXACT:
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEEXACT:
+    return FALSE;
+
+    /* End of branch */
+
+    case OP_KET:
+    case OP_KETRMAX:
+    case OP_KETRMIN:
+    case OP_ALT:
+    return TRUE;
+
+    /* In UTF-8 mode, STAR, MINSTAR, QUERY, MINQUERY, UPTO, and MINUPTO  may be
+    followed by a multibyte character */
+
+#ifdef SUPPORT_UTF8
+    case OP_STAR:
+    case OP_MINSTAR:
+    case OP_QUERY:
+    case OP_MINQUERY:
+    case OP_UPTO:
+    case OP_MINUPTO:
+    if (utf8) while ((code[2] & 0xc0) == 0x80) code++;
+    break;
+#endif
+    }
+  }
+
+return TRUE;
+}
+
+
+
+/*************************************************
+*    Scan compiled regex for non-emptiness       *
+*************************************************/
+
+/* This function is called to check for left recursive calls. We want to check
+the current branch of the current pattern to see if it could match the empty
+string. If it could, we must look outwards for branches at other levels,
+stopping when we pass beyond the bracket which is the subject of the recursion.
+
+Arguments:
+  code        points to start of the recursion
+  endcode     points to where to stop (current RECURSE item)
+  bcptr       points to the chain of current (unclosed) branch starts
+  utf8        TRUE if in UTF-8 mode
+
+Returns:      TRUE if what is matched could be empty
+*/
+
+static BOOL
+could_be_empty(const uschar *code, const uschar *endcode, branch_chain *bcptr,
+  BOOL utf8)
+{
+while (bcptr != NULL && bcptr->current >= code)
+  {
+  if (!could_be_empty_branch(bcptr->current, endcode, utf8)) return FALSE;
+  bcptr = bcptr->outer;
+  }
+return TRUE;
+}
+
+
+
+/*************************************************
+*           Check for POSIX class syntax         *
+*************************************************/
+
+/* This function is called when the sequence "[:" or "[." or "[=" is
+encountered in a character class. It checks whether this is followed by an
+optional ^ and then a sequence of letters, terminated by a matching ":]" or
+".]" or "=]".
+
+Argument:
+  ptr      pointer to the initial [
+  endptr   where to return the end pointer
+  cd       pointer to compile data
+
+Returns:   TRUE or FALSE
+*/
+
+static BOOL
+check_posix_syntax(const uschar *ptr, const uschar **endptr, compile_data *cd)
+{
+int terminator;          /* Don't combine these lines; the Solaris cc */
+terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
+if (*(++ptr) == '^') ptr++;
+while ((cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
+if (*ptr == terminator && ptr[1] == ']')
+  {
+  *endptr = ptr;
+  return TRUE;
+  }
+return FALSE;
+}
+
+
+
+
+/*************************************************
+*          Check POSIX class name                *
+*************************************************/
+
+/* This function is called to check the name given in a POSIX-style class entry
+such as [:alnum:].
+
+Arguments:
+  ptr        points to the first letter
+  len        the length of the name
+
+Returns:     a value representing the name, or -1 if unknown
+*/
+
+static int
+check_posix_name(const uschar *ptr, int len)
+{
+register int yield = 0;
+while (posix_name_lengths[yield] != 0)
+  {
+  if (len == posix_name_lengths[yield] &&
+    strncmp((const char *)ptr, posix_names[yield], len) == 0) return yield;
+  yield++;
+  }
+return -1;
+}
+
+
+/*************************************************
+*    Adjust OP_RECURSE items in repeated group   *
+*************************************************/
+
+/* OP_RECURSE items contain an offset from the start of the regex to the group
+that is referenced. This means that groups can be replicated for fixed
+repetition simply by copying (because the recursion is allowed to refer to
+earlier groups that are outside the current group). However, when a group is
+optional (i.e. the minimum quantifier is zero), OP_BRAZERO is inserted before
+it, after it has been compiled. This means that any OP_RECURSE items within it
+that refer to the group itself or any contained groups have to have their
+offsets adjusted. That is the job of this function. Before it is called, the
+partially compiled regex must be temporarily terminated with OP_END.
+
+Arguments:
+  group      points to the start of the group
+  adjust     the amount by which the group is to be moved
+  utf8       TRUE in UTF-8 mode
+  cd         contains pointers to tables etc.
+
+Returns:     nothing
+*/
+
+static void
+adjust_recurse(uschar *group, int adjust, BOOL utf8, compile_data *cd)
+{
+uschar *ptr = group;
+while ((ptr = (uschar *)find_recurse(ptr, utf8)) != NULL)
+  {
+  int offset = GET(ptr, 1);
+  if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
+  ptr += 1 + LINK_SIZE;
+  }
+}
+
+
+
+/*************************************************
+*        Insert an automatic callout point       *
+*************************************************/
+
+/* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
+callout points before each pattern item.
+
+Arguments:
+  code           current code pointer
+  ptr            current pattern pointer
+  cd             pointers to tables etc
+
+Returns:         new code pointer
+*/
+
+static uschar *
+auto_callout(uschar *code, const uschar *ptr, compile_data *cd)
+{
+*code++ = OP_CALLOUT;
+*code++ = 255;
+PUT(code, 0, ptr - cd->start_pattern);  /* Pattern offset */
+PUT(code, LINK_SIZE, 0);                /* Default length */
+return code + 2*LINK_SIZE;
+}
+
+
+
+/*************************************************
+*         Complete a callout item                *
+*************************************************/
+
+/* A callout item contains the length of the next item in the pattern, which
+we can't fill in till after we have reached the relevant point. This is used
+for both automatic and manual callouts.
+
+Arguments:
+  previous_callout   points to previous callout item
+  ptr                current pattern pointer
+  cd                 pointers to tables etc
+
+Returns:             nothing
+*/
+
+static void
+complete_callout(uschar *previous_callout, const uschar *ptr, compile_data *cd)
+{
+int length = ptr - cd->start_pattern - GET(previous_callout, 2);
+PUT(previous_callout, 2 + LINK_SIZE, length);
+}
+
+
+
+#ifdef SUPPORT_UCP
+/*************************************************
+*           Get othercase range                  *
+*************************************************/
+
+/* This function is passed the start and end of a class range, in UTF-8 mode
+with UCP support. It searches up the characters, looking for internal ranges of
+characters in the "other" case. Each call returns the next one, updating the
+start address.
+
+Arguments:
+  cptr        points to starting character value; updated
+  d           end value
+  ocptr       where to put start of othercase range
+  odptr       where to put end of othercase range
+
+Yield:        TRUE when range returned; FALSE when no more
+*/
+
+static BOOL
+get_othercase_range(int *cptr, int d, int *ocptr, int *odptr)
+{
+int c, chartype, othercase, next;
+
+for (c = *cptr; c <= d; c++)
+  {
+  if (ucp_findchar(c, &chartype, &othercase) == ucp_L && othercase != 0) break;
+  }
+
+if (c > d) return FALSE;
+
+*ocptr = othercase;
+next = othercase + 1;
+
+for (++c; c <= d; c++)
+  {
+  if (ucp_findchar(c, &chartype, &othercase) != ucp_L || othercase != next)
+    break;
+  next++;
+  }
+
+*odptr = next - 1;
+*cptr = c;
+
+return TRUE;
+}
+#endif  /* SUPPORT_UCP */
+
+
+/*************************************************
+*           Compile one branch                   *
+*************************************************/
+
+/* Scan the pattern, compiling it into the code vector. If the options are
+changed during the branch, the pointer is used to change the external options
+bits.
+
+Arguments:
+  optionsptr     pointer to the option bits
+  brackets       points to number of extracting brackets used
+  codeptr        points to the pointer to the current code point
+  ptrptr         points to the current pattern pointer
+  errorptr       points to pointer to error message
+  firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
+  reqbyteptr     set to the last literal character required, else < 0
+  bcptr          points to current branch chain
+  cd             contains pointers to tables etc.
+
+Returns:         TRUE on success
+                 FALSE, with *errorptr set on error
+*/
+
+static BOOL
+compile_branch(int *optionsptr, int *brackets, uschar **codeptr,
+  const uschar **ptrptr, const char **errorptr, int *firstbyteptr,
+  int *reqbyteptr, branch_chain *bcptr, compile_data *cd)
+{
+int repeat_type, op_type;
+int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
+int bravalue = 0;
+int greedy_default, greedy_non_default;
+int firstbyte, reqbyte;
+int zeroreqbyte, zerofirstbyte;
+int req_caseopt, reqvary, tempreqvary;
+int condcount = 0;
+int options = *optionsptr;
+int after_manual_callout = 0;
+register int c;
+register uschar *code = *codeptr;
+uschar *tempcode;
+BOOL inescq = FALSE;
+BOOL groupsetfirstbyte = FALSE;
+const uschar *ptr = *ptrptr;
+const uschar *tempptr;
+uschar *previous = NULL;
+uschar *previous_callout = NULL;
+uschar classbits[32];
+
+#ifdef SUPPORT_UTF8
+BOOL class_utf8;
+BOOL utf8 = (options & PCRE_UTF8) != 0;
+uschar *class_utf8data;
+uschar utf8_char[6];
+#else
+BOOL utf8 = FALSE;
+#endif
+
+/* Set up the default and non-default settings for greediness */
+
+greedy_default = ((options & PCRE_UNGREEDY) != 0);
+greedy_non_default = greedy_default ^ 1;
+
+/* Initialize no first byte, no required byte. REQ_UNSET means "no char
+matching encountered yet". It gets changed to REQ_NONE if we hit something that
+matches a non-fixed char first char; reqbyte just remains unset if we never
+find one.
+
+When we hit a repeat whose minimum is zero, we may have to adjust these values
+to take the zero repeat into account. This is implemented by setting them to
+zerofirstbyte and zeroreqbyte when such a repeat is encountered. The individual
+item types that can be repeated set these backoff variables appropriately. */
+
+firstbyte = reqbyte = zerofirstbyte = zeroreqbyte = REQ_UNSET;
+
+/* The variable req_caseopt contains either the REQ_CASELESS value or zero,
+according to the current setting of the caseless flag. REQ_CASELESS is a bit
+value > 255. It is added into the firstbyte or reqbyte variables to record the
+case status of the value. This is used only for ASCII characters. */
+
+req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
+
+/* Switch on next character until the end of the branch */
+
+for (;; ptr++)
+  {
+  BOOL negate_class;
+  BOOL possessive_quantifier;
+  BOOL is_quantifier;
+  int class_charcount;
+  int class_lastchar;
+  int newoptions;
+  int recno;
+  int skipbytes;
+  int subreqbyte;
+  int subfirstbyte;
+  int mclength;
+  uschar mcbuffer[8];
+
+  /* Next byte in the pattern */
+
+  c = *ptr;
+
+  /* If in \Q...\E, check for the end; if not, we have a literal */
+
+  if (inescq && c != 0)
+    {
+    if (c == '\\' && ptr[1] == 'E')
+      {
+      inescq = FALSE;
+      ptr++;
+      continue;
+      }
+    else
+      {
+      if (previous_callout != NULL)
+        {
+        complete_callout(previous_callout, ptr, cd);
+        previous_callout = NULL;
+        }
+      if ((options & PCRE_AUTO_CALLOUT) != 0)
+        {
+        previous_callout = code;
+        code = auto_callout(code, ptr, cd);
+        }
+      goto NORMAL_CHAR;
+      }
+    }
+
+  /* Fill in length of a previous callout, except when the next thing is
+  a quantifier. */
+
+  is_quantifier = c == '*' || c == '+' || c == '?' ||
+    (c == '{' && is_counted_repeat(ptr+1));
+
+  if (!is_quantifier && previous_callout != NULL &&
+       after_manual_callout-- <= 0)
+    {
+    complete_callout(previous_callout, ptr, cd);
+    previous_callout = NULL;
+    }
+
+  /* In extended mode, skip white space and comments */
+
+  if ((options & PCRE_EXTENDED) != 0)
+    {
+    if ((cd->ctypes[c] & ctype_space) != 0) continue;
+    if (c == '#')
+      {
+      /* The space before the ; is to avoid a warning on a silly compiler
+      on the Macintosh. */
+      while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
+      if (c != 0) continue;   /* Else fall through to handle end of string */
+      }
+    }
+
+  /* No auto callout for quantifiers. */
+
+  if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier)
+    {
+    previous_callout = code;
+    code = auto_callout(code, ptr, cd);
+    }
+
+  switch(c)
+    {
+    /* The branch terminates at end of string, |, or ). */
+
+    case 0:
+    case '|':
+    case ')':
+    *firstbyteptr = firstbyte;
+    *reqbyteptr = reqbyte;
+    *codeptr = code;
+    *ptrptr = ptr;
+    return TRUE;
+
+    /* Handle single-character metacharacters. In multiline mode, ^ disables
+    the setting of any following char as a first character. */
+
+    case '^':
+    if ((options & PCRE_MULTILINE) != 0)
+      {
+      if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+      }
+    previous = NULL;
+    *code++ = OP_CIRC;
+    break;
+
+    case '$':
+    previous = NULL;
+    *code++ = OP_DOLL;
+    break;
+
+    /* There can never be a first char if '.' is first, whatever happens about
+    repeats. The value of reqbyte doesn't change either. */
+
+    case '.':
+    if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+    zerofirstbyte = firstbyte;
+    zeroreqbyte = reqbyte;
+    previous = code;
+    *code++ = OP_ANY;
+    break;
+
+    /* Character classes. If the included characters are all < 255 in value, we
+    build a 32-byte bitmap of the permitted characters, except in the special
+    case where there is only one such character. For negated classes, we build
+    the map as usual, then invert it at the end. However, we use a different
+    opcode so that data characters > 255 can be handled correctly.
+
+    If the class contains characters outside the 0-255 range, a different
+    opcode is compiled. It may optionally have a bit map for characters < 256,
+    but those above are are explicitly listed afterwards. A flag byte tells
+    whether the bitmap is present, and whether this is a negated class or not.
+    */
+
+    case '[':
+    previous = code;
+
+    /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
+    they are encountered at the top level, so we'll do that too. */
+
+    if ((ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
+        check_posix_syntax(ptr, &tempptr, cd))
+      {
+      *errorptr = (ptr[1] == ':')? ERR13 : ERR31;
+      goto FAILED;
+      }
+
+    /* If the first character is '^', set the negation flag and skip it. */
+
+    if ((c = *(++ptr)) == '^')
+      {
+      negate_class = TRUE;
+      c = *(++ptr);
+      }
+    else
+      {
+      negate_class = FALSE;
+      }
+
+    /* Keep a count of chars with values < 256 so that we can optimize the case
+    of just a single character (as long as it's < 256). For higher valued UTF-8
+    characters, we don't yet do any optimization. */
+
+    class_charcount = 0;
+    class_lastchar = -1;
+
+#ifdef SUPPORT_UTF8
+    class_utf8 = FALSE;                       /* No chars >= 256 */
+    class_utf8data = code + LINK_SIZE + 34;   /* For UTF-8 items */
+#endif
+
+    /* Initialize the 32-char bit map to all zeros. We have to build the
+    map in a temporary bit of store, in case the class contains only 1
+    character (< 256), because in that case the compiled code doesn't use the
+    bit map. */
+
+    memset(classbits, 0, 32 * sizeof(uschar));
+
+    /* Process characters until ] is reached. By writing this as a "do" it
+    means that an initial ] is taken as a data character. The first pass
+    through the regex checked the overall syntax, so we don't need to be very
+    strict here. At the start of the loop, c contains the first byte of the
+    character. */
+
+    do
+      {
+#ifdef SUPPORT_UTF8
+      if (utf8 && c > 127)
+        {                           /* Braces are required because the */
+        GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
+        }
+#endif
+
+      /* Inside \Q...\E everything is literal except \E */
+
+      if (inescq)
+        {
+        if (c == '\\' && ptr[1] == 'E')
+          {
+          inescq = FALSE;
+          ptr++;
+          continue;
+          }
+        else goto LONE_SINGLE_CHARACTER;
+        }
+
+      /* Handle POSIX class names. Perl allows a negation extension of the
+      form [:^name:]. A square bracket that doesn't match the syntax is
+      treated as a literal. We also recognize the POSIX constructions
+      [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
+      5.6 and 5.8 do. */
+
+      if (c == '[' &&
+          (ptr[1] == ':' || ptr[1] == '.' || ptr[1] == '=') &&
+          check_posix_syntax(ptr, &tempptr, cd))
+        {
+        BOOL local_negate = FALSE;
+        int posix_class, i;
+        register const uschar *cbits = cd->cbits;
+
+        if (ptr[1] != ':')
+          {
+          *errorptr = ERR31;
+          goto FAILED;
+          }
+
+        ptr += 2;
+        if (*ptr == '^')
+          {
+          local_negate = TRUE;
+          ptr++;
+          }
+
+        posix_class = check_posix_name(ptr, tempptr - ptr);
+        if (posix_class < 0)
+          {
+          *errorptr = ERR30;
+          goto FAILED;
+          }
+
+        /* If matching is caseless, upper and lower are converted to
+        alpha. This relies on the fact that the class table starts with
+        alpha, lower, upper as the first 3 entries. */
+
+        if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
+          posix_class = 0;
+
+        /* Or into the map we are building up to 3 of the static class
+        tables, or their negations. The [:blank:] class sets up the same
+        chars as the [:space:] class (all white space). We remove the vertical
+        white space chars afterwards. */
+
+        posix_class *= 3;
+        for (i = 0; i < 3; i++)
+          {
+          BOOL blankclass = strncmp((char *)ptr, "blank", 5) == 0;
+          int taboffset = posix_class_maps[posix_class + i];
+          if (taboffset < 0) break;
+          if (local_negate)
+            {
+            if (i == 0)
+              for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+taboffset];
+            else
+              for (c = 0; c < 32; c++) classbits[c] &= ~cbits[c+taboffset];
+            if (blankclass) classbits[1] |= 0x3c;
+            }
+          else
+            {
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+taboffset];
+            if (blankclass) classbits[1] &= ~0x3c;
+            }
+          }
+
+        ptr = tempptr + 1;
+        class_charcount = 10;  /* Set > 1; assumes more than 1 per class */
+        continue;    /* End of POSIX syntax handling */
+        }
+
+      /* Backslash may introduce a single character, or it may introduce one
+      of the specials, which just set a flag. Escaped items are checked for
+      validity in the pre-compiling pass. The sequence \b is a special case.
+      Inside a class (and only there) it is treated as backspace. Elsewhere
+      it marks a word boundary. Other escapes have preset maps ready to
+      or into the one we are building. We assume they have more than one
+      character in them, so set class_charcount bigger than one. */
+
+      if (c == '\\')
+        {
+        c = check_escape(&ptr, errorptr, *brackets, options, TRUE);
+
+        if (-c == ESC_b) c = '\b';       /* \b is backslash in a class */
+        else if (-c == ESC_X) c = 'X';   /* \X is literal X in a class */
+        else if (-c == ESC_Q)            /* Handle start of quoted string */
+          {
+          if (ptr[1] == '\\' && ptr[2] == 'E')
+            {
+            ptr += 2; /* avoid empty string */
+            }
+          else inescq = TRUE;
+          continue;
+          }
+
+        if (c < 0)
+          {
+          register const uschar *cbits = cd->cbits;
+          class_charcount += 2;     /* Greater than 1 is what matters */
+          switch (-c)
+            {
+            case ESC_d:
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
+            continue;
+
+            case ESC_D:
+            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
+            continue;
+
+            case ESC_w:
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
+            continue;
+
+            case ESC_W:
+            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
+            continue;
+
+            case ESC_s:
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
+            classbits[1] &= ~0x08;   /* Perl 5.004 onwards omits VT from \s */
+            continue;
+
+            case ESC_S:
+            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
+            classbits[1] |= 0x08;    /* Perl 5.004 onwards omits VT from \s */
+            continue;
+
+#ifdef SUPPORT_UCP
+            case ESC_p:
+            case ESC_P:
+              {
+              BOOL negated;
+              int property = get_ucp(&ptr, &negated, errorptr);
+              if (property < 0) goto FAILED;
+              class_utf8 = TRUE;
+              *class_utf8data++ = ((-c == ESC_p) != negated)?
+                XCL_PROP : XCL_NOTPROP;
+              *class_utf8data++ = property;
+              class_charcount -= 2;   /* Not a < 256 character */
+              }
+            continue;
+#endif
+
+            /* Unrecognized escapes are faulted if PCRE is running in its
+            strict mode. By default, for compatibility with Perl, they are
+            treated as literals. */
+
+            default:
+            if ((options & PCRE_EXTRA) != 0)
+              {
+              *errorptr = ERR7;
+              goto FAILED;
+              }
+            c = *ptr;              /* The final character */
+            class_charcount -= 2;  /* Undo the default count from above */
+            }
+          }
+
+        /* Fall through if we have a single character (c >= 0). This may be
+        > 256 in UTF-8 mode. */
+
+        }   /* End of backslash handling */
+
+      /* A single character may be followed by '-' to form a range. However,
+      Perl does not permit ']' to be the end of the range. A '-' character
+      here is treated as a literal. */
+
+      if (ptr[1] == '-' && ptr[2] != ']')
+        {
+        int d;
+        ptr += 2;
+
+#ifdef SUPPORT_UTF8
+        if (utf8)
+          {                           /* Braces are required because the */
+          GETCHARLEN(d, ptr, ptr);    /* macro generates multiple statements */
+          }
+        else
+#endif
+        d = *ptr;  /* Not UTF-8 mode */
+
+        /* The second part of a range can be a single-character escape, but
+        not any of the other escapes. Perl 5.6 treats a hyphen as a literal
+        in such circumstances. */
+
+        if (d == '\\')
+          {
+          const uschar *oldptr = ptr;
+          d = check_escape(&ptr, errorptr, *brackets, options, TRUE);
+
+          /* \b is backslash; \X is literal X; any other special means the '-'
+          was literal */
+
+          if (d < 0)
+            {
+            if (d == -ESC_b) d = '\b';
+            else if (d == -ESC_X) d = 'X'; else
+              {
+              ptr = oldptr - 2;
+              goto LONE_SINGLE_CHARACTER;  /* A few lines below */
+              }
+            }
+          }
+
+        /* The check that the two values are in the correct order happens in
+        the pre-pass. Optimize one-character ranges */
+
+        if (d == c) goto LONE_SINGLE_CHARACTER;  /* A few lines below */
+
+        /* In UTF-8 mode, if the upper limit is > 255, or > 127 for caseless
+        matching, we have to use an XCLASS with extra data items. Caseless
+        matching for characters > 127 is available only if UCP support is
+        available. */
+
+#ifdef SUPPORT_UTF8
+        if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
+          {
+          class_utf8 = TRUE;
+
+          /* With UCP support, we can find the other case equivalents of
+          the relevant characters. There may be several ranges. Optimize how
+          they fit with the basic range. */
+
+#ifdef SUPPORT_UCP
+          if ((options & PCRE_CASELESS) != 0)
+            {
+            int occ, ocd;
+            int cc = c;
+            int origd = d;
+            while (get_othercase_range(&cc, origd, &occ, &ocd))
+              {
+              if (occ >= c && ocd <= d) continue;  /* Skip embedded ranges */
+
+              if (occ < c  && ocd >= c - 1)        /* Extend the basic range */
+                {                                  /* if there is overlap,   */
+                c = occ;                           /* noting that if occ < c */
+                continue;                          /* we can't have ocd > d  */
+                }                                  /* because a subrange is  */
+              if (ocd > d && occ <= d + 1)         /* always shorter than    */
+                {                                  /* the basic range.       */
+                d = ocd;
+                continue;
+                }
+
+              if (occ == ocd)
+                {
+                *class_utf8data++ = XCL_SINGLE;
+                }
+              else
+                {
+                *class_utf8data++ = XCL_RANGE;
+                class_utf8data += ord2utf8(occ, class_utf8data);
+                }
+              class_utf8data += ord2utf8(ocd, class_utf8data);
+              }
+            }
+#endif  /* SUPPORT_UCP */
+
+          /* Now record the original range, possibly modified for UCP caseless
+          overlapping ranges. */
+
+          *class_utf8data++ = XCL_RANGE;
+          class_utf8data += ord2utf8(c, class_utf8data);
+          class_utf8data += ord2utf8(d, class_utf8data);
+
+          /* With UCP support, we are done. Without UCP support, there is no
+          caseless matching for UTF-8 characters > 127; we can use the bit map
+          for the smaller ones. */
+
+#ifdef SUPPORT_UCP
+          continue;    /* With next character in the class */
+#else
+          if ((options & PCRE_CASELESS) == 0 || c > 127) continue;
+
+          /* Adjust upper limit and fall through to set up the map */
+
+          d = 127;
+
+#endif  /* SUPPORT_UCP */
+          }
+#endif  /* SUPPORT_UTF8 */
+
+        /* We use the bit map for all cases when not in UTF-8 mode; else
+        ranges that lie entirely within 0-127 when there is UCP support; else
+        for partial ranges without UCP support. */
+
+        for (; c <= d; c++)
+          {
+          classbits[c/8] |= (1 << (c&7));
+          if ((options & PCRE_CASELESS) != 0)
+            {
+            int uc = cd->fcc[c];           /* flip case */
+            classbits[uc/8] |= (1 << (uc&7));
+            }
+          class_charcount++;                /* in case a one-char range */
+          class_lastchar = c;
+          }
+
+        continue;   /* Go get the next char in the class */
+        }
+
+      /* Handle a lone single character - we can get here for a normal
+      non-escape char, or after \ that introduces a single character or for an
+      apparent range that isn't. */
+
+      LONE_SINGLE_CHARACTER:
+
+      /* Handle a character that cannot go in the bit map */
+
+#ifdef SUPPORT_UTF8
+      if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
+        {
+        class_utf8 = TRUE;
+        *class_utf8data++ = XCL_SINGLE;
+        class_utf8data += ord2utf8(c, class_utf8data);
+
+#ifdef SUPPORT_UCP
+        if ((options & PCRE_CASELESS) != 0)
+          {
+          int chartype;
+          int othercase;
+          if (ucp_findchar(c, &chartype, &othercase) >= 0 && othercase > 0)
+            {
+            *class_utf8data++ = XCL_SINGLE;
+            class_utf8data += ord2utf8(othercase, class_utf8data);
+            }
+          }
+#endif  /* SUPPORT_UCP */
+
+        }
+      else
+#endif  /* SUPPORT_UTF8 */
+
+      /* Handle a single-byte character */
+        {
+        classbits[c/8] |= (1 << (c&7));
+        if ((options & PCRE_CASELESS) != 0)
+          {
+          c = cd->fcc[c];   /* flip case */
+          classbits[c/8] |= (1 << (c&7));
+          }
+        class_charcount++;
+        class_lastchar = c;
+        }
+      }
+
+    /* Loop until ']' reached; the check for end of string happens inside the
+    loop. This "while" is the end of the "do" above. */
+
+    while ((c = *(++ptr)) != ']' || inescq);
+
+    /* If class_charcount is 1, we saw precisely one character whose value is
+    less than 256. In non-UTF-8 mode we can always optimize. In UTF-8 mode, we
+    can optimize the negative case only if there were no characters >= 128
+    because OP_NOT and the related opcodes like OP_NOTSTAR operate on
+    single-bytes only. This is an historical hangover. Maybe one day we can
+    tidy these opcodes to handle multi-byte characters.
+
+    The optimization throws away the bit map. We turn the item into a
+    1-character OP_CHAR[NC] if it's positive, or OP_NOT if it's negative. Note
+    that OP_NOT does not support multibyte characters. In the positive case, it
+    can cause firstbyte to be set. Otherwise, there can be no first char if
+    this item is first, whatever repeat count may follow. In the case of
+    reqbyte, save the previous value for reinstating. */
+
+#ifdef SUPPORT_UTF8
+    if (class_charcount == 1 &&
+          (!utf8 ||
+          (!class_utf8 && (!negate_class || class_lastchar < 128))))
+
+#else
+    if (class_charcount == 1)
+#endif
+      {
+      zeroreqbyte = reqbyte;
+
+      /* The OP_NOT opcode works on one-byte characters only. */
+
+      if (negate_class)
+        {
+        if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+        zerofirstbyte = firstbyte;
+        *code++ = OP_NOT;
+        *code++ = class_lastchar;
+        break;
+        }
+
+      /* For a single, positive character, get the value into mcbuffer, and
+      then we can handle this with the normal one-character code. */
+
+#ifdef SUPPORT_UTF8
+      if (utf8 && class_lastchar > 127)
+        mclength = ord2utf8(class_lastchar, mcbuffer);
+      else
+#endif
+        {
+        mcbuffer[0] = class_lastchar;
+        mclength = 1;
+        }
+      goto ONE_CHAR;
+      }       /* End of 1-char optimization */
+
+    /* The general case - not the one-char optimization. If this is the first
+    thing in the branch, there can be no first char setting, whatever the
+    repeat count. Any reqbyte setting must remain unchanged after any kind of
+    repeat. */
+
+    if (firstbyte == REQ_UNSET) firstbyte = REQ_NONE;
+    zerofirstbyte = firstbyte;
+    zeroreqbyte = reqbyte;
+
+    /* If there are characters with values > 255, we have to compile an
+    extended class, with its own opcode. If there are no characters < 256,
+    we can omit the bitmap. */
+
+#ifdef SUPPORT_UTF8
+    if (class_utf8)
+      {
+      *class_utf8data++ = XCL_END;    /* Marks the end of extra data */
+      *code++ = OP_XCLASS;
+      code += LINK_SIZE;
+      *code = negate_class? XCL_NOT : 0;
+
+      /* If the map is required, install it, and move on to the end of
+      the extra data */
+
+      if (class_charcount > 0)
+        {
+        *code++ |= XCL_MAP;
+        memcpy(code, classbits, 32);
+        code = class_utf8data;
+        }
+
+      /* If the map is not required, slide down the extra data. */
+
+      else
+        {
+        int len = class_utf8data - (code + 33);
+        memmove(code + 1, code + 33, len);
+        code += len + 1;
+        }
+
+      /* Now fill in the complete length of the item */
+
+      PUT(previous, 1, code - previous);
+      break;   /* End of class handling */
+      }
+#endif
+
+    /* If there are no characters > 255, negate the 32-byte map if necessary,
+    and copy it into the code vector. If this is the first thing in the branch,
+    there can be no first char setting, whatever the repeat count. Any reqbyte
+    setting must remain unchanged after any kind of repeat. */
+
+    if (negate_class)
+      {
+      *code++ = OP_NCLASS;
+      for (c = 0; c < 32; c++) code[c] = ~classbits[c];
+      }
+    else
+      {
+      *code++ = OP_CLASS;
+      memcpy(code, classbits, 32);
+      }
+    code += 32;
+    break;
+
+    /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
+    has been tested above. */
+
+    case '{':
+    if (!is_quantifier) goto NORMAL_CHAR;
+    ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorptr);
+    if (*errorptr != NULL) goto FAILED;
+    goto REPEAT;
+
+    case '*':
+    repeat_min = 0;
+    repeat_max = -1;
+    goto REPEAT;
+
+    case '+':
+    repeat_min = 1;
+    repeat_max = -1;
+    goto REPEAT;
+
+    case '?':
+    repeat_min = 0;
+    repeat_max = 1;
+
+    REPEAT:
+    if (previous == NULL)
+      {
+      *errorptr = ERR9;
+      goto FAILED;
+      }
+
+    if (repeat_min == 0)
+      {
+      firstbyte = zerofirstbyte;    /* Adjust for zero repeat */
+      reqbyte = zeroreqbyte;        /* Ditto */
+      }
+
+    /* Remember whether this is a variable length repeat */
+
+    reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
+
+    op_type = 0;                    /* Default single-char op codes */
+    possessive_quantifier = FALSE;  /* Default not possessive quantifier */
+
+    /* Save start of previous item, in case we have to move it up to make space
+    for an inserted OP_ONCE for the additional '+' extension. */
+
+    tempcode = previous;
+
+    /* If the next character is '+', we have a possessive quantifier. This
+    implies greediness, whatever the setting of the PCRE_UNGREEDY option.
+    If the next character is '?' this is a minimizing repeat, by default,
+    but if PCRE_UNGREEDY is set, it works the other way round. We change the
+    repeat type to the non-default. */
+
+    if (ptr[1] == '+')
+      {
+      repeat_type = 0;                  /* Force greedy */
+      possessive_quantifier = TRUE;
+      ptr++;
+      }
+    else if (ptr[1] == '?')
+      {
+      repeat_type = greedy_non_default;
+      ptr++;
+      }
+    else repeat_type = greedy_default;
+
+    /* If previous was a recursion, we need to wrap it inside brackets so that
+    it can be replicated if necessary. */
+
+    if (*previous == OP_RECURSE)
+      {
+      memmove(previous + 1 + LINK_SIZE, previous, 1 + LINK_SIZE);
+      code += 1 + LINK_SIZE;
+      *previous = OP_BRA;
+      PUT(previous, 1, code - previous);
+      *code = OP_KET;
+      PUT(code, 1, code - previous);
+      code += 1 + LINK_SIZE;
+      }
+
+    /* If previous was a character match, abolish the item and generate a
+    repeat item instead. If a char item has a minumum of more than one, ensure
+    that it is set in reqbyte - it might not be if a sequence such as x{3} is
+    the first thing in a branch because the x will have gone into firstbyte
+    instead.  */
+
+    if (*previous == OP_CHAR || *previous == OP_CHARNC)
+      {
+      /* Deal with UTF-8 characters that take up more than one byte. It's
+      easier to write this out separately than try to macrify it. Use c to
+      hold the length of the character in bytes, plus 0x80 to flag that it's a
+      length rather than a small character. */
+
+#ifdef SUPPORT_UTF8
+      if (utf8 && (code[-1] & 0x80) != 0)
+        {
+        uschar *lastchar = code - 1;
+        while((*lastchar & 0xc0) == 0x80) lastchar--;
+        c = code - lastchar;            /* Length of UTF-8 character */
+        memcpy(utf8_char, lastchar, c); /* Save the char */
+        c |= 0x80;                      /* Flag c as a length */
+        }
+      else
+#endif
+
+      /* Handle the case of a single byte - either with no UTF8 support, or
+      with UTF-8 disabled, or for a UTF-8 character < 128. */
+
+        {
+        c = code[-1];
+        if (repeat_min > 1) reqbyte = c | req_caseopt | cd->req_varyopt;
+        }
+
+      goto OUTPUT_SINGLE_REPEAT;   /* Code shared with single character types */
+      }
+
+    /* If previous was a single negated character ([^a] or similar), we use
+    one of the special opcodes, replacing it. The code is shared with single-
+    character repeats by setting opt_type to add a suitable offset into
+    repeat_type. OP_NOT is currently used only for single-byte chars. */
+
+    else if (*previous == OP_NOT)
+      {
+      op_type = OP_NOTSTAR - OP_STAR;  /* Use "not" opcodes */
+      c = previous[1];
+      goto OUTPUT_SINGLE_REPEAT;
+      }
+
+    /* If previous was a character type match (\d or similar), abolish it and
+    create a suitable repeat item. The code is shared with single-character
+    repeats by setting op_type to add a suitable offset into repeat_type. Note
+    the the Unicode property types will be present only when SUPPORT_UCP is
+    defined, but we don't wrap the little bits of code here because it just
+    makes it horribly messy. */
+
+    else if (*previous < OP_EODN)
+      {
+      uschar *oldcode;
+      int prop_type;
+      op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
+      c = *previous;
+
+      OUTPUT_SINGLE_REPEAT:
+      prop_type = (*previous == OP_PROP || *previous == OP_NOTPROP)?
+        previous[1] : -1;
+
+      oldcode = code;
+      code = previous;                  /* Usually overwrite previous item */
+
+      /* If the maximum is zero then the minimum must also be zero; Perl allows
+      this case, so we do too - by simply omitting the item altogether. */
+
+      if (repeat_max == 0) goto END_REPEAT;
+
+      /* All real repeats make it impossible to handle partial matching (maybe
+      one day we will be able to remove this restriction). */
+
+      if (repeat_max != 1) cd->nopartial = TRUE;
+
+      /* Combine the op_type with the repeat_type */
+
+      repeat_type += op_type;
+
+      /* A minimum of zero is handled either as the special case * or ?, or as
+      an UPTO, with the maximum given. */
+
+      if (repeat_min == 0)
+        {
+        if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
+          else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
+        else
+          {
+          *code++ = OP_UPTO + repeat_type;
+          PUT2INC(code, 0, repeat_max);
+          }
+        }
+
+      /* A repeat minimum of 1 is optimized into some special cases. If the
+      maximum is unlimited, we use OP_PLUS. Otherwise, the original item it
+      left in place and, if the maximum is greater than 1, we use OP_UPTO with
+      one less than the maximum. */
+
+      else if (repeat_min == 1)
+        {
+        if (repeat_max == -1)
+          *code++ = OP_PLUS + repeat_type;
+        else
+          {
+          code = oldcode;                 /* leave previous item in place */
+          if (repeat_max == 1) goto END_REPEAT;
+          *code++ = OP_UPTO + repeat_type;
+          PUT2INC(code, 0, repeat_max - 1);
+          }
+        }
+
+      /* The case {n,n} is just an EXACT, while the general case {n,m} is
+      handled as an EXACT followed by an UPTO. */
+
+      else
+        {
+        *code++ = OP_EXACT + op_type;  /* NB EXACT doesn't have repeat_type */
+        PUT2INC(code, 0, repeat_min);
+
+        /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
+        we have to insert the character for the previous code. For a repeated
+        Unicode property match, there is an extra byte that defines the
+        required property. In UTF-8 mode, long characters have their length in
+        c, with the 0x80 bit as a flag. */
+
+        if (repeat_max < 0)
+          {
+#ifdef SUPPORT_UTF8
+          if (utf8 && c >= 128)
+            {
+            memcpy(code, utf8_char, c & 7);
+            code += c & 7;
+            }
+          else
+#endif
+            {
+            *code++ = c;
+            if (prop_type >= 0) *code++ = prop_type;
+            }
+          *code++ = OP_STAR + repeat_type;
+          }
+
+        /* Else insert an UPTO if the max is greater than the min, again
+        preceded by the character, for the previously inserted code. */
+
+        else if (repeat_max != repeat_min)
+          {
+#ifdef SUPPORT_UTF8
+          if (utf8 && c >= 128)
+            {
+            memcpy(code, utf8_char, c & 7);
+            code += c & 7;
+            }
+          else
+#endif
+          *code++ = c;
+          if (prop_type >= 0) *code++ = prop_type;
+          repeat_max -= repeat_min;
+          *code++ = OP_UPTO + repeat_type;
+          PUT2INC(code, 0, repeat_max);
+          }
+        }
+
+      /* The character or character type itself comes last in all cases. */
+
+#ifdef SUPPORT_UTF8
+      if (utf8 && c >= 128)
+        {
+        memcpy(code, utf8_char, c & 7);
+        code += c & 7;
+        }
+      else
+#endif
+      *code++ = c;
+
+      /* For a repeated Unicode property match, there is an extra byte that
+      defines the required property. */
+
+#ifdef SUPPORT_UCP
+      if (prop_type >= 0) *code++ = prop_type;
+#endif
+      }
+
+    /* If previous was a character class or a back reference, we put the repeat
+    stuff after it, but just skip the item if the repeat was {0,0}. */
+
+    else if (*previous == OP_CLASS ||
+             *previous == OP_NCLASS ||
+#ifdef SUPPORT_UTF8
+             *previous == OP_XCLASS ||
+#endif
+             *previous == OP_REF)
+      {
+      if (repeat_max == 0)
+        {
+        code = previous;
+        goto END_REPEAT;
+        }
+
+      /* All real repeats make it impossible to handle partial matching (maybe
+      one day we will be able to remove this restriction). */
+
+      if (repeat_max != 1) cd->nopartial = TRUE;
+
+      if (repeat_min == 0 && repeat_max == -1)
+        *code++ = OP_CRSTAR + repeat_type;
+      else if (repeat_min == 1 && repeat_max == -1)
+        *code++ = OP_CRPLUS + repeat_type;
+      else if (repeat_min == 0 && repeat_max == 1)
+        *code++ = OP_CRQUERY + repeat_type;
+      else
+        {
+        *code++ = OP_CRRANGE + repeat_type;
+        PUT2INC(code, 0, repeat_min);
+        if (repeat_max == -1) repeat_max = 0;  /* 2-byte encoding for max */
+        PUT2INC(code, 0, repeat_max);
+        }
+      }
+
+    /* If previous was a bracket group, we may have to replicate it in certain
+    cases. */
+
+    else if (*previous >= OP_BRA || *previous == OP_ONCE ||
+             *previous == OP_COND)
+      {
+      register int i;
+      int ketoffset = 0;
+      int len = code - previous;
+      uschar *bralink = NULL;
+
+      /* If the maximum repeat count is unlimited, find the end of the bracket
+      by scanning through from the start, and compute the offset back to it
+      from the current code pointer. There may be an OP_OPT setting following
+      the final KET, so we can't find the end just by going back from the code
+      pointer. */
+
+      if (repeat_max == -1)
+        {
+        register uschar *ket = previous;
+        do ket += GET(ket, 1); while (*ket != OP_KET);
+        ketoffset = code - ket;
+        }
+
+      /* The case of a zero minimum is special because of the need to stick
+      OP_BRAZERO in front of it, and because the group appears once in the
+      data, whereas in other cases it appears the minimum number of times. For
+      this reason, it is simplest to treat this case separately, as otherwise
+      the code gets far too messy. There are several special subcases when the
+      minimum is zero. */
+
+      if (repeat_min == 0)
+        {
+        /* If the maximum is also zero, we just omit the group from the output
+        altogether. */
+
+        if (repeat_max == 0)
+          {
+          code = previous;
+          goto END_REPEAT;
+          }
+
+        /* If the maximum is 1 or unlimited, we just have to stick in the
+        BRAZERO and do no more at this point. However, we do need to adjust
+        any OP_RECURSE calls inside the group that refer to the group itself or
+        any internal group, because the offset is from the start of the whole
+        regex. Temporarily terminate the pattern while doing this. */
+
+        if (repeat_max <= 1)
+          {
+          *code = OP_END;
+          adjust_recurse(previous, 1, utf8, cd);
+          memmove(previous+1, previous, len);
+          code++;
+          *previous++ = OP_BRAZERO + repeat_type;
+          }
+
+        /* If the maximum is greater than 1 and limited, we have to replicate
+        in a nested fashion, sticking OP_BRAZERO before each set of brackets.
+        The first one has to be handled carefully because it's the original
+        copy, which has to be moved up. The remainder can be handled by code
+        that is common with the non-zero minimum case below. We have to
+        adjust the value or repeat_max, since one less copy is required. Once
+        again, we may have to adjust any OP_RECURSE calls inside the group. */
+
+        else
+          {
+          int offset;
+          *code = OP_END;
+          adjust_recurse(previous, 2 + LINK_SIZE, utf8, cd);
+          memmove(previous + 2 + LINK_SIZE, previous, len);
+          code += 2 + LINK_SIZE;
+          *previous++ = OP_BRAZERO + repeat_type;
+          *previous++ = OP_BRA;
+
+          /* We chain together the bracket offset fields that have to be
+          filled in later when the ends of the brackets are reached. */
+
+          offset = (bralink == NULL)? 0 : previous - bralink;
+          bralink = previous;
+          PUTINC(previous, 0, offset);
+          }
+
+        repeat_max--;
+        }
+
+      /* If the minimum is greater than zero, replicate the group as many
+      times as necessary, and adjust the maximum to the number of subsequent
+      copies that we need. If we set a first char from the group, and didn't
+      set a required char, copy the latter from the former. */
+
+      else
+        {
+        if (repeat_min > 1)
+          {
+          if (groupsetfirstbyte && reqbyte < 0) reqbyte = firstbyte;
+          for (i = 1; i < repeat_min; i++)
+            {
+            memcpy(code, previous, len);
+            code += len;
+            }
+          }
+        if (repeat_max > 0) repeat_max -= repeat_min;
+        }
+
+      /* This code is common to both the zero and non-zero minimum cases. If
+      the maximum is limited, it replicates the group in a nested fashion,
+      remembering the bracket starts on a stack. In the case of a zero minimum,
+      the first one was set up above. In all cases the repeat_max now specifies
+      the number of additional copies needed. */
+
+      if (repeat_max >= 0)
+        {
+        for (i = repeat_max - 1; i >= 0; i--)
+          {
+          *code++ = OP_BRAZERO + repeat_type;
+
+          /* All but the final copy start a new nesting, maintaining the
+          chain of brackets outstanding. */
+
+          if (i != 0)
+            {
+            int offset;
+            *code++ = OP_BRA;
+            offset = (bralink == NULL)? 0 : code - bralink;
+            bralink = code;
+            PUTINC(code, 0, offset);
+            }
+
+          memcpy(code, previous, len);
+          code += len;
+          }
+
+        /* Now chain through the pending brackets, and fill in their length
+        fields (which are holding the chain links pro tem). */
+
+        while (bralink != NULL)
+          {
+          int oldlinkoffset;
+          int offset = code - bralink + 1;
+          uschar *bra = code - offset;
+          oldlinkoffset = GET(bra, 1);
+          bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
+          *code++ = OP_KET;
+          PUTINC(code, 0, offset);
+          PUT(bra, 1, offset);
+          }
+        }
+
+      /* If the maximum is unlimited, set a repeater in the final copy. We
+      can't just offset backwards from the current code point, because we
+      don't know if there's been an options resetting after the ket. The
+      correct offset was computed above. */
+
+      else code[-ketoffset] = OP_KETRMAX + repeat_type;
+      }
+
+    /* Else there's some kind of shambles */
+
+    else
+      {
+      *errorptr = ERR11;
+      goto FAILED;
+      }
+
+    /* If the character following a repeat is '+', we wrap the entire repeated
+    item inside OP_ONCE brackets. This is just syntactic sugar, taken from
+    Sun's Java package. The repeated item starts at tempcode, not at previous,
+    which might be the first part of a string whose (former) last char we
+    repeated. However, we don't support '+' after a greediness '?'. */
+
+    if (possessive_quantifier)
+      {
+      int len = code - tempcode;
+      memmove(tempcode + 1+LINK_SIZE, tempcode, len);
+      code += 1 + LINK_SIZE;
+      len += 1 + LINK_SIZE;
+      tempcode[0] = OP_ONCE;
+      *code++ = OP_KET;
+      PUTINC(code, 0, len);
+      PUT(tempcode, 1, len);
+      }
+
+    /* In all case we no longer have a previous item. We also set the
+    "follows varying string" flag for subsequently encountered reqbytes if
+    it isn't already set and we have just passed a varying length item. */
+
+    END_REPEAT:
+    previous = NULL;
+    cd->req_varyopt |= reqvary;
+    break;
+
+
+    /* Start of nested bracket sub-expression, or comment or lookahead or
+    lookbehind or option setting or condition. First deal with special things
+    that can come after a bracket; all are introduced by ?, and the appearance
+    of any of them means that this is not a referencing group. They were
+    checked for validity in the first pass over the string, so we don't have to
+    check for syntax errors here.  */
+
+    case '(':
+    newoptions = options;
+    skipbytes = 0;
+
+    if (*(++ptr) == '?')
+      {
+      int set, unset;
+      int *optset;
+
+      switch (*(++ptr))
+        {
+        case '#':                 /* Comment; skip to ket */
+        ptr++;
+        while (*ptr != ')') ptr++;
+        continue;
+
+        case ':':                 /* Non-extracting bracket */
+        bravalue = OP_BRA;
+        ptr++;
+        break;
+
+        case '(':
+        bravalue = OP_COND;       /* Conditional group */
+
+        /* Condition to test for recursion */
+
+        if (ptr[1] == 'R')
+          {
+          code[1+LINK_SIZE] = OP_CREF;
+          PUT2(code, 2+LINK_SIZE, CREF_RECURSE);
+          skipbytes = 3;
+          ptr += 3;
+          }
+
+        /* Condition to test for a numbered subpattern match. We know that
+        if a digit follows ( then there will just be digits until ) because
+        the syntax was checked in the first pass. */
+
+        else if ((digitab[ptr[1]] & ctype_digit) != 0) /* change && to & LM 10.4.4 */
+          {
+          int condref;                 /* Don't amalgamate; some compilers */
+          condref = *(++ptr) - '0';    /* grumble at autoincrement in declaration */
+          while (*(++ptr) != ')') condref = condref*10 + *ptr - '0';
+          if (condref == 0)
+            {
+            *errorptr = ERR35;
+            goto FAILED;
+            }
+          ptr++;
+          code[1+LINK_SIZE] = OP_CREF;
+          PUT2(code, 2+LINK_SIZE, condref);
+          skipbytes = 3;
+          }
+        /* For conditions that are assertions, we just fall through, having
+        set bravalue above. */
+        break;
+
+        case '=':                 /* Positive lookahead */
+        bravalue = OP_ASSERT;
+        ptr++;
+        break;
+
+        case '!':                 /* Negative lookahead */
+        bravalue = OP_ASSERT_NOT;
+        ptr++;
+        break;
+
+        case '<':                 /* Lookbehinds */
+        switch (*(++ptr))
+          {
+          case '=':               /* Positive lookbehind */
+          bravalue = OP_ASSERTBACK;
+          ptr++;
+          break;
+
+          case '!':               /* Negative lookbehind */
+          bravalue = OP_ASSERTBACK_NOT;
+          ptr++;
+          break;
+          }
+        break;
+
+        case '>':                 /* One-time brackets */
+        bravalue = OP_ONCE;
+        ptr++;
+        break;
+
+        case 'C':                 /* Callout - may be followed by digits; */
+        previous_callout = code;  /* Save for later completion */
+        after_manual_callout = 1; /* Skip one item before completing */
+        *code++ = OP_CALLOUT;     /* Already checked that the terminating */
+          {                       /* closing parenthesis is present. */
+          int n = 0;
+          while ((digitab[*(++ptr)] & ctype_digit) != 0)
+            n = n * 10 + *ptr - '0';
+          if (n > 255)
+            {
+            *errorptr = ERR38;
+            goto FAILED;
+            }
+          *code++ = n;
+          PUT(code, 0, ptr - cd->start_pattern + 1);  /* Pattern offset */
+          PUT(code, LINK_SIZE, 0);                    /* Default length */
+          code += 2 * LINK_SIZE;
+          }
+        previous = NULL;
+        continue;
+
+        case 'P':                 /* Named subpattern handling */
+        if (*(++ptr) == '<')      /* Definition */
+          {
+          int i, namelen;
+          uschar *slot = cd->name_table;
+          const uschar *name;     /* Don't amalgamate; some compilers */
+          name = ++ptr;           /* grumble at autoincrement in declaration */
+
+          while (*ptr++ != '>');
+          namelen = ptr - name - 1;
+
+          for (i = 0; i < cd->names_found; i++)
+            {
+            int crc = memcmp(name, slot+2, namelen);
+            if (crc == 0)
+              {
+              if (slot[2+namelen] == 0)
+                {
+                *errorptr = ERR43;
+                goto FAILED;
+                }
+              crc = -1;             /* Current name is substring */
+              }
+            if (crc < 0)
+              {
+              memmove(slot + cd->name_entry_size, slot,
+                (cd->names_found - i) * cd->name_entry_size);
+              break;
+              }
+            slot += cd->name_entry_size;
+            }
+
+          PUT2(slot, 0, *brackets + 1);
+          memcpy(slot + 2, name, namelen);
+          slot[2+namelen] = 0;
+          cd->names_found++;
+          goto NUMBERED_GROUP;
+          }
+
+        if (*ptr == '=' || *ptr == '>')  /* Reference or recursion */
+          {
+          int i, namelen;
+          int type = *ptr++;
+          const uschar *name = ptr;
+          uschar *slot = cd->name_table;
+
+          while (*ptr != ')') ptr++;
+          namelen = ptr - name;
+
+          for (i = 0; i < cd->names_found; i++)
+            {
+            if (strncmp((char *)name, (char *)slot+2, namelen) == 0) break;
+            slot += cd->name_entry_size;
+            }
+          if (i >= cd->names_found)
+            {
+            *errorptr = ERR15;
+            goto FAILED;
+            }
+
+          recno = GET2(slot, 0);
+
+          if (type == '>') goto HANDLE_RECURSION;  /* A few lines below */
+
+          /* Back reference */
+
+          previous = code;
+          *code++ = OP_REF;
+          PUT2INC(code, 0, recno);
+          cd->backref_map |= (recno < 32)? (1 << recno) : 1;
+          if (recno > cd->top_backref) cd->top_backref = recno;
+          continue;
+          }
+
+        /* Should never happen */
+        break;
+
+        case 'R':                 /* Pattern recursion */
+        ptr++;                    /* Same as (?0)      */
+        /* Fall through */
+
+        /* Recursion or "subroutine" call */
+
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+          {
+          const uschar *called;
+          recno = 0;
+          while((digitab[*ptr] & ctype_digit) != 0)
+            recno = recno * 10 + *ptr++ - '0';
+
+          /* Come here from code above that handles a named recursion */
+
+          HANDLE_RECURSION:
+
+          previous = code;
+
+          /* Find the bracket that is being referenced. Temporarily end the
+          regex in case it doesn't exist. */
+
+          *code = OP_END;
+          called = (recno == 0)?
+            cd->start_code : find_bracket(cd->start_code, utf8, recno);
+
+          if (called == NULL)
+            {
+            *errorptr = ERR15;
+            goto FAILED;
+            }
+
+          /* If the subpattern is still open, this is a recursive call. We
+          check to see if this is a left recursion that could loop for ever,
+          and diagnose that case. */
+
+          if (GET(called, 1) == 0 && could_be_empty(called, code, bcptr, utf8))
+            {
+            *errorptr = ERR40;
+            goto FAILED;
+            }
+
+          /* Insert the recursion/subroutine item */
+
+          *code = OP_RECURSE;
+          PUT(code, 1, called - cd->start_code);
+          code += 1 + LINK_SIZE;
+          }
+        continue;
+
+        /* Character after (? not specially recognized */
+
+        default:                  /* Option setting */
+        set = unset = 0;
+        optset = &set;
+
+        while (*ptr != ')' && *ptr != ':')
+          {
+          switch (*ptr++)
+            {
+            case '-': optset = &unset; break;
+
+            case 'i': *optset |= PCRE_CASELESS; break;
+            case 'm': *optset |= PCRE_MULTILINE; break;
+            case 's': *optset |= PCRE_DOTALL; break;
+            case 'x': *optset |= PCRE_EXTENDED; break;
+            case 'U': *optset |= PCRE_UNGREEDY; break;
+            case 'X': *optset |= PCRE_EXTRA; break;
+            }
+          }
+
+        /* Set up the changed option bits, but don't change anything yet. */
+
+        newoptions = (options | set) & (~unset);
+
+        /* If the options ended with ')' this is not the start of a nested
+        group with option changes, so the options change at this level. Compile
+        code to change the ims options if this setting actually changes any of
+        them. We also pass the new setting back so that it can be put at the
+        start of any following branches, and when this group ends (if we are in
+        a group), a resetting item can be compiled.
+
+        Note that if this item is right at the start of the pattern, the
+        options will have been abstracted and made global, so there will be no
+        change to compile. */
+
+        if (*ptr == ')')
+          {
+          if ((options & PCRE_IMS) != (newoptions & PCRE_IMS))
+            {
+            *code++ = OP_OPT;
+            *code++ = newoptions & PCRE_IMS;
+            }
+
+          /* Change options at this level, and pass them back for use
+          in subsequent branches. Reset the greedy defaults and the case
+          value for firstbyte and reqbyte. */
+
+          *optionsptr = options = newoptions;
+          greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
+          greedy_non_default = greedy_default ^ 1;
+          req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS : 0;
+
+          previous = NULL;       /* This item can't be repeated */
+          continue;              /* It is complete */
+          }
+
+        /* If the options ended with ':' we are heading into a nested group
+        with possible change of options. Such groups are non-capturing and are
+        not assertions of any kind. All we need to do is skip over the ':';
+        the newoptions value is handled below. */
+
+        bravalue = OP_BRA;
+        ptr++;
+        }
+      }
+
+    /* If PCRE_NO_AUTO_CAPTURE is set, all unadorned brackets become
+    non-capturing and behave like (?:...) brackets */
+
+    else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
+      {
+      bravalue = OP_BRA;
+      }
+
+    /* Else we have a referencing group; adjust the opcode. If the bracket
+    number is greater than EXTRACT_BASIC_MAX, we set the opcode one higher, and
+    arrange for the true number to follow later, in an OP_BRANUMBER item. */
+
+    else
+      {
+      NUMBERED_GROUP:
+      if (++(*brackets) > EXTRACT_BASIC_MAX)
+        {
+        bravalue = OP_BRA + EXTRACT_BASIC_MAX + 1;
+        code[1+LINK_SIZE] = OP_BRANUMBER;
+        PUT2(code, 2+LINK_SIZE, *brackets);
+        skipbytes = 3;
+        }
+      else bravalue = OP_BRA + *brackets;
+      }
+
+    /* Process nested bracketed re. Assertions may not be repeated, but other
+    kinds can be. We copy code into a non-register variable in order to be able
+    to pass its address because some compilers complain otherwise. Pass in a
+    new setting for the ims options if they have changed. */
+
+    previous = (bravalue >= OP_ONCE)? code : NULL;
+    *code = bravalue;
+    tempcode = code;
+    tempreqvary = cd->req_varyopt;     /* Save value before bracket */
+
+    if (!compile_regex(
+         newoptions,                   /* The complete new option state */
+         options & PCRE_IMS,           /* The previous ims option state */
+         brackets,                     /* Extracting bracket count */
+         &tempcode,                    /* Where to put code (updated) */
+         &ptr,                         /* Input pointer (updated) */
+         errorptr,                     /* Where to put an error message */
+         (bravalue == OP_ASSERTBACK ||
+          bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
+         skipbytes,                    /* Skip over OP_COND/OP_BRANUMBER */
+         &subfirstbyte,                /* For possible first char */
+         &subreqbyte,                  /* For possible last char */
+         bcptr,                        /* Current branch chain */
+         cd))                          /* Tables block */
+      goto FAILED;
+
+    /* At the end of compiling, code is still pointing to the start of the
+    group, while tempcode has been updated to point past the end of the group
+    and any option resetting that may follow it. The pattern pointer (ptr)
+    is on the bracket. */
+
+    /* If this is a conditional bracket, check that there are no more than
+    two branches in the group. */
+
+    else if (bravalue == OP_COND)
+      {
+      uschar *tc = code;
+      condcount = 0;
+
+      do {
+         condcount++;
+         tc += GET(tc,1);
+         }
+      while (*tc != OP_KET);
+
+      if (condcount > 2)
+        {
+        *errorptr = ERR27;
+        goto FAILED;
+        }
+
+      /* If there is just one branch, we must not make use of its firstbyte or
+      reqbyte, because this is equivalent to an empty second branch. */
+
+      if (condcount == 1) subfirstbyte = subreqbyte = REQ_NONE;
+      }
+
+    /* Handle updating of the required and first characters. Update for normal
+    brackets of all kinds, and conditions with two branches (see code above).
+    If the bracket is followed by a quantifier with zero repeat, we have to
+    back off. Hence the definition of zeroreqbyte and zerofirstbyte outside the
+    main loop so that they can be accessed for the back off. */
+
+    zeroreqbyte = reqbyte;
+    zerofirstbyte = firstbyte;
+    groupsetfirstbyte = FALSE;
+
+    if (bravalue >= OP_BRA || bravalue == OP_ONCE || bravalue == OP_COND)
+      {
+      /* If we have not yet set a firstbyte in this branch, take it from the
+      subpattern, remembering that it was set here so that a repeat of more
+      than one can replicate it as reqbyte if necessary. If the subpattern has
+      no firstbyte, set "none" for the whole branch. In both cases, a zero
+      repeat forces firstbyte to "none". */
+
+      if (firstbyte == REQ_UNSET)
+        {
+        if (subfirstbyte >= 0)
+          {
+          firstbyte = subfirstbyte;
+          groupsetfirstbyte = TRUE;
+          }
+        else firstbyte = REQ_NONE;
+        zerofirstbyte = REQ_NONE;
+        }
+
+      /* If firstbyte was previously set, convert the subpattern's firstbyte
+      into reqbyte if there wasn't one, using the vary flag that was in
+      existence beforehand. */
+
+      else if (subfirstbyte >= 0 && subreqbyte < 0)
+        subreqbyte = subfirstbyte | tempreqvary;
+
+      /* If the subpattern set a required byte (or set a first byte that isn't
+      really the first byte - see above), set it. */
+
+      if (subreqbyte >= 0) reqbyte = subreqbyte;
+      }
+
+    /* For a forward assertion, we take the reqbyte, if set. This can be
+    helpful if the pattern that follows the assertion doesn't set a different
+    char. For example, it's useful for /(?=abcde).+/. We can't set firstbyte
+    for an assertion, however because it leads to incorrect effect for patterns
+    such as /(?=a)a.+/ when the "real" "a" would then become a reqbyte instead
+    of a firstbyte. This is overcome by a scan at the end if there's no
+    firstbyte, looking for an asserted first char. */
+
+    else if (bravalue == OP_ASSERT && subreqbyte >= 0) reqbyte = subreqbyte;
+
+    /* Now update the main code pointer to the end of the group. */
+
+    code = tempcode;
+
+    /* Error if hit end of pattern */
+
+    if (*ptr != ')')
+      {
+      *errorptr = ERR14;
+      goto FAILED;
+      }
+    break;
+
+    /* Check \ for being a real metacharacter; if not, fall through and handle
+    it as a data character at the start of a string. Escape items are checked
+    for validity in the pre-compiling pass. */
+
+    case '\\':
+    tempptr = ptr;
+    c = check_escape(&ptr, errorptr, *brackets, options, FALSE);
+
+    /* Handle metacharacters introduced by \. For ones like \d, the ESC_ values
+    are arranged to be the negation of the corresponding OP_values. For the
+    back references, the values are ESC_REF plus the reference number. Only
+    back references and those types that consume a character may be repeated.
+    We can test for values between ESC_b and ESC_Z for the latter; this may
+    have to change if any new ones are ever created. */
+
+    if (c < 0)
+      {
+      if (-c == ESC_Q)            /* Handle start of quoted string */
+        {
+        if (ptr[1] == '\\' && ptr[2] == 'E') ptr += 2; /* avoid empty string */
+          else inescq = TRUE;
+        continue;
+        }
+
+      /* For metasequences that actually match a character, we disable the
+      setting of a first character if it hasn't already been set. */
+
+      if (firstbyte == REQ_UNSET && -c > ESC_b && -c < ESC_Z)
+        firstbyte = REQ_NONE;
+
+      /* Set values to reset to if this is followed by a zero repeat. */
+
+      zerofirstbyte = firstbyte;
+      zeroreqbyte = reqbyte;
+
+      /* Back references are handled specially */
+
+      if (-c >= ESC_REF)
+        {
+        int number = -c - ESC_REF;
+        previous = code;
+        *code++ = OP_REF;
+        PUT2INC(code, 0, number);
+        }
+
+      /* So are Unicode property matches, if supported. We know that get_ucp
+      won't fail because it was tested in the pre-pass. */
+
+#ifdef SUPPORT_UCP
+      else if (-c == ESC_P || -c == ESC_p)
+        {
+        BOOL negated;
+        int value = get_ucp(&ptr, &negated, errorptr);
+        previous = code;
+        *code++ = ((-c == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
+        *code++ = value;
+        }
+#endif
+
+      /* For the rest, we can obtain the OP value by negating the escape
+      value */
+
+      else
+        {
+        previous = (-c > ESC_b && -c < ESC_Z)? code : NULL;
+        *code++ = -c;
+        }
+      continue;
+      }
+
+    /* We have a data character whose value is in c. In UTF-8 mode it may have
+    a value > 127. We set its representation in the length/buffer, and then
+    handle it as a data character. */
+
+#ifdef SUPPORT_UTF8
+    if (utf8 && c > 127)
+      mclength = ord2utf8(c, mcbuffer);
+    else
+#endif
+
+     {
+     mcbuffer[0] = c;
+     mclength = 1;
+     }
+
+    goto ONE_CHAR;
+
+    /* Handle a literal character. It is guaranteed not to be whitespace or #
+    when the extended flag is set. If we are in UTF-8 mode, it may be a
+    multi-byte literal character. */
+
+    default:
+    NORMAL_CHAR:
+    mclength = 1;
+    mcbuffer[0] = c;
+
+#ifdef SUPPORT_UTF8
+    if (utf8 && (c & 0xc0) == 0xc0)
+      {
+      while ((ptr[1] & 0xc0) == 0x80)
+        mcbuffer[mclength++] = *(++ptr);
+      }
+#endif
+
+    /* At this point we have the character's bytes in mcbuffer, and the length
+    in mclength. When not in UTF-8 mode, the length is always 1. */
+
+    ONE_CHAR:
+    previous = code;
+    *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARNC : OP_CHAR;
+    for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
+
+    /* Set the first and required bytes appropriately. If no previous first
+    byte, set it from this character, but revert to none on a zero repeat.
+    Otherwise, leave the firstbyte value alone, and don't change it on a zero
+    repeat. */
+
+    if (firstbyte == REQ_UNSET)
+      {
+      zerofirstbyte = REQ_NONE;
+      zeroreqbyte = reqbyte;
+
+      /* If the character is more than one byte long, we can set firstbyte
+      only if it is not to be matched caselessly. */
+
+      if (mclength == 1 || req_caseopt == 0)
+        {
+        firstbyte = mcbuffer[0] | req_caseopt;
+        if (mclength != 1) reqbyte = code[-1] | cd->req_varyopt;
+        }
+      else firstbyte = reqbyte = REQ_NONE;
+      }
+
+    /* firstbyte was previously set; we can set reqbyte only the length is
+    1 or the matching is caseful. */
+
+    else
+      {
+      zerofirstbyte = firstbyte;
+      zeroreqbyte = reqbyte;
+      if (mclength == 1 || req_caseopt == 0)
+        reqbyte = code[-1] | req_caseopt | cd->req_varyopt;
+      }
+
+    break;            /* End of literal character handling */
+    }
+  }                   /* end of big loop */
+
+/* Control never reaches here by falling through, only by a goto for all the
+error states. Pass back the position in the pattern so that it can be displayed
+to the user for diagnosing the error. */
+
+FAILED:
+*ptrptr = ptr;
+return FALSE;
+}
+
+
+
+
+/*************************************************
+*     Compile sequence of alternatives           *
+*************************************************/
+
+/* On entry, ptr is pointing past the bracket character, but on return
+it points to the closing bracket, or vertical bar, or end of string.
+The code variable is pointing at the byte into which the BRA operator has been
+stored. If the ims options are changed at the start (for a (?ims: group) or
+during any branch, we need to insert an OP_OPT item at the start of every
+following branch to ensure they get set correctly at run time, and also pass
+the new options into every subsequent branch compile.
+
+Argument:
+  options        option bits, including any changes for this subpattern
+  oldims         previous settings of ims option bits
+  brackets       -> int containing the number of extracting brackets used
+  codeptr        -> the address of the current code pointer
+  ptrptr         -> the address of the current pattern pointer
+  errorptr       -> pointer to error message
+  lookbehind     TRUE if this is a lookbehind assertion
+  skipbytes      skip this many bytes at start (for OP_COND, OP_BRANUMBER)
+  firstbyteptr   place to put the first required character, or a negative number
+  reqbyteptr     place to put the last required character, or a negative number
+  bcptr          pointer to the chain of currently open branches
+  cd             points to the data block with tables pointers etc.
+
+Returns:      TRUE on success
+*/
+
+static BOOL
+compile_regex(int options, int oldims, int *brackets, uschar **codeptr,
+  const uschar **ptrptr, const char **errorptr, BOOL lookbehind, int skipbytes,
+  int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd)
+{
+const uschar *ptr = *ptrptr;
+uschar *code = *codeptr;
+uschar *last_branch = code;
+uschar *start_bracket = code;
+uschar *reverse_count = NULL;
+int firstbyte, reqbyte;
+int branchfirstbyte, branchreqbyte;
+branch_chain bc;
+
+bc.outer = bcptr;
+bc.current = code;
+
+firstbyte = reqbyte = REQ_UNSET;
+
+/* Offset is set zero to mark that this bracket is still open */
+
+PUT(code, 1, 0);
+code += 1 + LINK_SIZE + skipbytes;
+
+/* Loop for each alternative branch */
+
+for (;;)
+  {
+  /* Handle a change of ims options at the start of the branch */
+
+  if ((options & PCRE_IMS) != oldims)
+    {
+    *code++ = OP_OPT;
+    *code++ = options & PCRE_IMS;
+    }
+
+  /* Set up dummy OP_REVERSE if lookbehind assertion */
+
+  if (lookbehind)
+    {
+    *code++ = OP_REVERSE;
+    reverse_count = code;
+    PUTINC(code, 0, 0);
+    }
+
+  /* Now compile the branch */
+
+  if (!compile_branch(&options, brackets, &code, &ptr, errorptr,
+        &branchfirstbyte, &branchreqbyte, &bc, cd))
+    {
+    *ptrptr = ptr;
+    return FALSE;
+    }
+
+  /* If this is the first branch, the firstbyte and reqbyte values for the
+  branch become the values for the regex. */
+
+  if (*last_branch != OP_ALT)
+    {
+    firstbyte = branchfirstbyte;
+    reqbyte = branchreqbyte;
+    }
+
+  /* If this is not the first branch, the first char and reqbyte have to
+  match the values from all the previous branches, except that if the previous
+  value for reqbyte didn't have REQ_VARY set, it can still match, and we set
+  REQ_VARY for the regex. */
+
+  else
+    {
+    /* If we previously had a firstbyte, but it doesn't match the new branch,
+    we have to abandon the firstbyte for the regex, but if there was previously
+    no reqbyte, it takes on the value of the old firstbyte. */
+
+    if (firstbyte >= 0 && firstbyte != branchfirstbyte)
+      {
+      if (reqbyte < 0) reqbyte = firstbyte;
+      firstbyte = REQ_NONE;
+      }
+
+    /* If we (now or from before) have no firstbyte, a firstbyte from the
+    branch becomes a reqbyte if there isn't a branch reqbyte. */
+
+    if (firstbyte < 0 && branchfirstbyte >= 0 && branchreqbyte < 0)
+        branchreqbyte = branchfirstbyte;
+
+    /* Now ensure that the reqbytes match */
+
+    if ((reqbyte & ~REQ_VARY) != (branchreqbyte & ~REQ_VARY))
+      reqbyte = REQ_NONE;
+    else reqbyte |= branchreqbyte;   /* To "or" REQ_VARY */
+    }
+
+  /* If lookbehind, check that this branch matches a fixed-length string,
+  and put the length into the OP_REVERSE item. Temporarily mark the end of
+  the branch with OP_END. */
+
+  if (lookbehind)
+    {
+    int length;
+    *code = OP_END;
+    length = find_fixedlength(last_branch, options);
+    DPRINTF(("fixed length = %d\n", length));
+    if (length < 0)
+      {
+      *errorptr = (length == -2)? ERR36 : ERR25;
+      *ptrptr = ptr;
+      return FALSE;
+      }
+    PUT(reverse_count, 0, length);
+    }
+
+  /* Reached end of expression, either ')' or end of pattern. Go back through
+  the alternative branches and reverse the chain of offsets, with the field in
+  the BRA item now becoming an offset to the first alternative. If there are
+  no alternatives, it points to the end of the group. The length in the
+  terminating ket is always the length of the whole bracketed item. If any of
+  the ims options were changed inside the group, compile a resetting op-code
+  following, except at the very end of the pattern. Return leaving the pointer
+  at the terminating char. */
+
+  if (*ptr != '|')
+    {
+    int length = code - last_branch;
+    do
+      {
+      int prev_length = GET(last_branch, 1);
+      PUT(last_branch, 1, length);
+      length = prev_length;
+      last_branch -= length;
+      }
+    while (length > 0);
+
+    /* Fill in the ket */
+
+    *code = OP_KET;
+    PUT(code, 1, code - start_bracket);
+    code += 1 + LINK_SIZE;
+
+    /* Resetting option if needed */
+
+    if ((options & PCRE_IMS) != oldims && *ptr == ')')
+      {
+      *code++ = OP_OPT;
+      *code++ = oldims;
+      }
+
+    /* Set values to pass back */
+
+    *codeptr = code;
+    *ptrptr = ptr;
+    *firstbyteptr = firstbyte;
+    *reqbyteptr = reqbyte;
+    return TRUE;
+    }
+
+  /* Another branch follows; insert an "or" node. Its length field points back
+  to the previous branch while the bracket remains open. At the end the chain
+  is reversed. It's done like this so that the start of the bracket has a
+  zero offset until it is closed, making it possible to detect recursion. */
+
+  *code = OP_ALT;
+  PUT(code, 1, code - last_branch);
+  bc.current = last_branch = code;
+  code += 1 + LINK_SIZE;
+  ptr++;
+  }
+/* Control never reaches here */
+}
+
+
+
+
+/*************************************************
+*          Check for anchored expression         *
+*************************************************/
+
+/* Try to find out if this is an anchored regular expression. Consider each
+alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
+all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
+it's anchored. However, if this is a multiline pattern, then only OP_SOD
+counts, since OP_CIRC can match in the middle.
+
+We can also consider a regex to be anchored if OP_SOM starts all its branches.
+This is the code for \G, which means "match at start of match position, taking
+into account the match offset".
+
+A branch is also implicitly anchored if it starts with .* and DOTALL is set,
+because that will try the rest of the pattern at all possible matching points,
+so there is no point trying again.... er ....
+
+.... except when the .* appears inside capturing parentheses, and there is a
+subsequent back reference to those parentheses. We haven't enough information
+to catch that case precisely.
+
+At first, the best we could do was to detect when .* was in capturing brackets
+and the highest back reference was greater than or equal to that level.
+However, by keeping a bitmap of the first 31 back references, we can catch some
+of the more common cases more precisely.
+
+Arguments:
+  code           points to start of expression (the bracket)
+  options        points to the options setting
+  bracket_map    a bitmap of which brackets we are inside while testing; this
+                  handles up to substring 31; after that we just have to take
+                  the less precise approach
+  backref_map    the back reference bitmap
+
+Returns:     TRUE or FALSE
+*/
+
+static BOOL
+is_anchored(register const uschar *code, int *options, unsigned int bracket_map,
+  unsigned int backref_map)
+{
+do {
+   const uschar *scode =
+     first_significant_code(code + 1+LINK_SIZE, options, PCRE_MULTILINE, FALSE);
+   register int op = *scode;
+
+   /* Capturing brackets */
+
+   if (op > OP_BRA)
+     {
+     int new_map;
+     op -= OP_BRA;
+     if (op > EXTRACT_BASIC_MAX) op = GET2(scode, 2+LINK_SIZE);
+     new_map = bracket_map | ((op < 32)? (1 << op) : 1);
+     if (!is_anchored(scode, options, new_map, backref_map)) return FALSE;
+     }
+
+   /* Other brackets */
+
+   else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
+     {
+     if (!is_anchored(scode, options, bracket_map, backref_map)) return FALSE;
+     }
+
+   /* .* is not anchored unless DOTALL is set and it isn't in brackets that
+   are or may be referenced. */
+
+   else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR) &&
+            (*options & PCRE_DOTALL) != 0)
+     {
+     if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
+     }
+
+   /* Check for explicit anchoring */
+
+   else if (op != OP_SOD && op != OP_SOM &&
+           ((*options & PCRE_MULTILINE) != 0 || op != OP_CIRC))
+     return FALSE;
+   code += GET(code, 1);
+   }
+while (*code == OP_ALT);   /* Loop for each alternative */
+return TRUE;
+}
+
+
+
+/*************************************************
+*         Check for starting with ^ or .*        *
+*************************************************/
+
+/* This is called to find out if every branch starts with ^ or .* so that
+"first char" processing can be done to speed things up in multiline
+matching and for non-DOTALL patterns that start with .* (which must start at
+the beginning or after \n). As in the case of is_anchored() (see above), we
+have to take account of back references to capturing brackets that contain .*
+because in that case we can't make the assumption.
+
+Arguments:
+  code           points to start of expression (the bracket)
+  bracket_map    a bitmap of which brackets we are inside while testing; this
+                  handles up to substring 31; after that we just have to take
+                  the less precise approach
+  backref_map    the back reference bitmap
+
+Returns:         TRUE or FALSE
+*/
+
+static BOOL
+is_startline(const uschar *code, unsigned int bracket_map,
+  unsigned int backref_map)
+{
+do {
+   const uschar *scode = first_significant_code(code + 1+LINK_SIZE, NULL, 0,
+     FALSE);
+   register int op = *scode;
+
+   /* Capturing brackets */
+
+   if (op > OP_BRA)
+     {
+     int new_map;
+     op -= OP_BRA;
+     if (op > EXTRACT_BASIC_MAX) op = GET2(scode, 2+LINK_SIZE);
+     new_map = bracket_map | ((op < 32)? (1 << op) : 1);
+     if (!is_startline(scode, new_map, backref_map)) return FALSE;
+     }
+
+   /* Other brackets */
+
+   else if (op == OP_BRA || op == OP_ASSERT || op == OP_ONCE || op == OP_COND)
+     { if (!is_startline(scode, bracket_map, backref_map)) return FALSE; }
+
+   /* .* means "start at start or after \n" if it isn't in brackets that
+   may be referenced. */
+
+   else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR)
+     {
+     if (scode[1] != OP_ANY || (bracket_map & backref_map) != 0) return FALSE;
+     }
+
+   /* Check for explicit circumflex */
+
+   else if (op != OP_CIRC) return FALSE;
+
+   /* Move on to the next alternative */
+
+   code += GET(code, 1);
+   }
+while (*code == OP_ALT);  /* Loop for each alternative */
+return TRUE;
+}
+
+
+
+/*************************************************
+*       Check for asserted fixed first char      *
+*************************************************/
+
+/* During compilation, the "first char" settings from forward assertions are
+discarded, because they can cause conflicts with actual literals that follow.
+However, if we end up without a first char setting for an unanchored pattern,
+it is worth scanning the regex to see if there is an initial asserted first
+char. If all branches start with the same asserted char, or with a bracket all
+of whose alternatives start with the same asserted char (recurse ad lib), then
+we return that char, otherwise -1.
+
+Arguments:
+  code       points to start of expression (the bracket)
+  options    pointer to the options (used to check casing changes)
+  inassert   TRUE if in an assertion
+
+Returns:     -1 or the fixed first char
+*/
+
+static int
+find_firstassertedchar(const uschar *code, int *options, BOOL inassert)
+{
+register int c = -1;
+do {
+   int d;
+   const uschar *scode =
+     first_significant_code(code + 1+LINK_SIZE, options, PCRE_CASELESS, TRUE);
+   register int op = *scode;
+
+   if (op >= OP_BRA) op = OP_BRA;
+
+   switch(op)
+     {
+     default:
+     return -1;
+
+     case OP_BRA:
+     case OP_ASSERT:
+     case OP_ONCE:
+     case OP_COND:
+     if ((d = find_firstassertedchar(scode, options, op == OP_ASSERT)) < 0)
+       return -1;
+     if (c < 0) c = d; else if (c != d) return -1;
+     break;
+
+     case OP_EXACT:       /* Fall through */
+     scode += 2;
+
+     case OP_CHAR:
+     case OP_CHARNC:
+     case OP_PLUS:
+     case OP_MINPLUS:
+     if (!inassert) return -1;
+     if (c < 0)
+       {
+       c = scode[1];
+       if ((*options & PCRE_CASELESS) != 0) c |= REQ_CASELESS;
+       }
+     else if (c != scode[1]) return -1;
+     break;
+     }
+
+   code += GET(code, 1);
+   }
+while (*code == OP_ALT);
+return c;
+}
+
+
+
+
+#ifdef SUPPORT_UTF8
+/*************************************************
+*         Validate a UTF-8 string                *
+*************************************************/
+
+/* This function is called (optionally) at the start of compile or match, to
+validate that a supposed UTF-8 string is actually valid. The early check means
+that subsequent code can assume it is dealing with a valid string. The check
+can be turned off for maximum performance, but then consequences of supplying
+an invalid string are then undefined.
+
+Arguments:
+  string       points to the string
+  length       length of string, or -1 if the string is zero-terminated
+
+Returns:       < 0    if the string is a valid UTF-8 string
+               >= 0   otherwise; the value is the offset of the bad byte
+*/
+
+static int
+valid_utf8(const uschar *string, int length)
+{
+register const uschar *p;
+
+if (length < 0)
+  {
+  for (p = string; *p != 0; p++);
+  length = p - string;
+  }
+
+for (p = string; length-- > 0; p++)
+  {
+  register int ab;
+  register int c = *p;
+  if (c < 128) continue;
+  if ((c & 0xc0) != 0xc0) return p - string;
+  ab = utf8_table4[c & 0x3f];  /* Number of additional bytes */
+  if (length < ab) return p - string;
+  length -= ab;
+
+  /* Check top bits in the second byte */
+  if ((*(++p) & 0xc0) != 0x80) return p - string;
+
+  /* Check for overlong sequences for each different length */
+  switch (ab)
+    {
+    /* Check for xx00 000x */
+    case 1:
+    if ((c & 0x3e) == 0) return p - string;
+    continue;   /* We know there aren't any more bytes to check */
+
+    /* Check for 1110 0000, xx0x xxxx */
+    case 2:
+    if (c == 0xe0 && (*p & 0x20) == 0) return p - string;
+    break;
+
+    /* Check for 1111 0000, xx00 xxxx */
+    case 3:
+    if (c == 0xf0 && (*p & 0x30) == 0) return p - string;
+    break;
+
+    /* Check for 1111 1000, xx00 0xxx */
+    case 4:
+    if (c == 0xf8 && (*p & 0x38) == 0) return p - string;
+    break;
+
+    /* Check for leading 0xfe or 0xff, and then for 1111 1100, xx00 00xx */
+    case 5:
+    if (c == 0xfe || c == 0xff ||
+       (c == 0xfc && (*p & 0x3c) == 0)) return p - string;
+    break;
+    }
+
+  /* Check for valid bytes after the 2nd, if any; all must start 10 */
+  while (--ab > 0)
+    {
+    if ((*(++p) & 0xc0) != 0x80) return p - string;
+    }
+  }
+
+return -1;
+}
+#endif
+
+
+
+/*************************************************
+*        Compile a Regular Expression            *
+*************************************************/
+
+/* This function takes a string and returns a pointer to a block of store
+holding a compiled version of the expression.
+
+Arguments:
+  pattern      the regular expression
+  options      various option bits
+  errorptr     pointer to pointer to error text
+  erroroffset  ptr offset in pattern where error was detected
+  tables       pointer to character tables or NULL
+
+Returns:       pointer to compiled data block, or NULL on error,
+               with errorptr and erroroffset set
+*/
+
+EXPORT pcre *
+pcre_compile(const char *pattern, int options, const char **errorptr,
+  int *erroroffset, const unsigned char *tables)
+{
+real_pcre *re;
+int length = 1 + LINK_SIZE;      /* For initial BRA plus length */
+/* int runlength; not used L.M. 2004-09-14 */
+int c, firstbyte, reqbyte;
+int bracount = 0;
+int branch_extra = 0;
+int branch_newextra;
+int item_count = -1;
+int name_count = 0;
+int max_name_size = 0;
+int lastitemlength = 0;
+#ifdef SUPPORT_UTF8
+BOOL utf8;
+BOOL class_utf8;
+#endif
+BOOL inescq = FALSE;
+unsigned int brastackptr = 0;
+size_t size;
+uschar *code;
+const uschar *codestart;
+const uschar *ptr;
+compile_data compile_block;
+int brastack[BRASTACK_SIZE];
+uschar bralenstack[BRASTACK_SIZE];
+
+/* We can't pass back an error message if errorptr is NULL; I guess the best we
+can do is just return NULL. */
+
+if (errorptr == NULL) return NULL;
+*errorptr = NULL;
+
+/* However, we can give a message for this error */
+
+if (erroroffset == NULL)
+  {
+  *errorptr = ERR16;
+  return NULL;
+  }
+*erroroffset = 0;
+
+/* Can't support UTF8 unless PCRE has been compiled to include the code. */
+
+#ifdef SUPPORT_UTF8
+utf8 = (options & PCRE_UTF8) != 0;
+if (utf8 && (options & PCRE_NO_UTF8_CHECK) == 0 &&
+     (*erroroffset = valid_utf8((uschar *)pattern, -1)) >= 0)
+  {
+  *errorptr = ERR44;
+  return NULL;
+  }
+#else
+if ((options & PCRE_UTF8) != 0)
+  {
+  *errorptr = ERR32;
+  return NULL;
+  }
+#endif
+
+if ((options & ~PUBLIC_OPTIONS) != 0)
+  {
+  *errorptr = ERR17;
+  return NULL;
+  }
+
+/* Set up pointers to the individual character tables */
+
+if (tables == NULL) tables = pcre_default_tables;
+compile_block.lcc = tables + lcc_offset;
+compile_block.fcc = tables + fcc_offset;
+compile_block.cbits = tables + cbits_offset;
+compile_block.ctypes = tables + ctypes_offset;
+
+/* Maximum back reference and backref bitmap. This is updated for numeric
+references during the first pass, but for named references during the actual
+compile pass. The bitmap records up to 31 back references to help in deciding
+whether (.*) can be treated as anchored or not. */
+
+compile_block.top_backref = 0;
+compile_block.backref_map = 0;
+
+/* Reflect pattern for debugging output */
+
+DPRINTF(("------------------------------------------------------------------\n"));
+DPRINTF(("%s\n", pattern));
+
+/* The first thing to do is to make a pass over the pattern to compute the
+amount of store required to hold the compiled code. This does not have to be
+perfect as long as errors are overestimates. At the same time we can detect any
+flag settings right at the start, and extract them. Make an attempt to correct
+for any counted white space if an "extended" flag setting appears late in the
+pattern. We can't be so clever for #-comments. */
+
+ptr = (const uschar *)(pattern - 1);
+while ((c = *(++ptr)) != 0)
+  {
+  int min, max;
+  int class_optcount;
+  int bracket_length;
+  int duplength;
+
+  /* If we are inside a \Q...\E sequence, all chars are literal */
+
+  if (inescq)
+    {
+    if ((options & PCRE_AUTO_CALLOUT) != 0) length += 2 + 2*LINK_SIZE;
+    goto NORMAL_CHAR;
+    }
+
+  /* Otherwise, first check for ignored whitespace and comments */
+
+  if ((options & PCRE_EXTENDED) != 0)
+    {
+    if ((compile_block.ctypes[c] & ctype_space) != 0) continue;
+    if (c == '#')
+      {
+      /* The space before the ; is to avoid a warning on a silly compiler
+      on the Macintosh. */
+      while ((c = *(++ptr)) != 0 && c != NEWLINE) ;
+      if (c == 0) break;
+      continue;
+      }
+    }
+
+  item_count++;    /* Is zero for the first non-comment item */
+
+  /* Allow space for auto callout before every item except quantifiers. */
+
+  if ((options & PCRE_AUTO_CALLOUT) != 0 &&
+       c != '*' && c != '+' && c != '?' &&
+       (c != '{' || !is_counted_repeat(ptr + 1)))
+    length += 2 + 2*LINK_SIZE;
+
+  switch(c)
+    {
+    /* A backslashed item may be an escaped data character or it may be a
+    character type. */
+
+    case '\\':
+    c = check_escape(&ptr, errorptr, bracount, options, FALSE);
+    if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+
+    lastitemlength = 1;     /* Default length of last item for repeats */
+
+    if (c >= 0)             /* Data character */
+      {
+      length += 2;          /* For a one-byte character */
+
+#ifdef SUPPORT_UTF8
+      if (utf8 && c > 127)
+        {
+        int i;
+        for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
+          if (c <= utf8_table1[i]) break;
+        length += i;
+        lastitemlength += i;
+        }
+#endif
+
+      continue;
+      }
+
+    /* If \Q, enter "literal" mode */
+
+    if (-c == ESC_Q)
+      {
+      inescq = TRUE;
+      continue;
+      }
+
+    /* \X is supported only if Unicode property support is compiled */
+
+#ifndef SUPPORT_UCP
+    if (-c == ESC_X)
+      {
+      *errorptr = ERR45;
+      goto PCRE_ERROR_RETURN;
+      }
+#endif
+
+    /* \P and \p are for Unicode properties, but only when the support has
+    been compiled. Each item needs 2 bytes. */
+
+    else if (-c == ESC_P || -c == ESC_p)
+      {
+#ifdef SUPPORT_UCP
+      BOOL negated;
+      length += 2;
+      lastitemlength = 2;
+      if (get_ucp(&ptr, &negated, errorptr) < 0) goto PCRE_ERROR_RETURN;
+      continue;
+#else
+      *errorptr = ERR45;
+      goto PCRE_ERROR_RETURN;
+#endif
+      }
+
+    /* Other escapes need one byte */
+
+    length++;
+
+    /* A back reference needs an additional 2 bytes, plus either one or 5
+    bytes for a repeat. We also need to keep the value of the highest
+    back reference. */
+
+    if (c <= -ESC_REF)
+      {
+      int refnum = -c - ESC_REF;
+      compile_block.backref_map |= (refnum < 32)? (1 << refnum) : 1;
+      if (refnum > compile_block.top_backref)
+        compile_block.top_backref = refnum;
+      length += 2;   /* For single back reference */
+      if (ptr[1] == '{' && is_counted_repeat(ptr+2))
+        {
+        ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+        if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+        if ((min == 0 && (max == 1 || max == -1)) ||
+          (min == 1 && max == -1))
+            length++;
+        else length += 5;
+        if (ptr[1] == '?') ptr++;
+        }
+      }
+    continue;
+
+    case '^':     /* Single-byte metacharacters */
+    case '.':
+    case '$':
+    length++;
+    lastitemlength = 1;
+    continue;
+
+    case '*':            /* These repeats won't be after brackets; */
+    case '+':            /* those are handled separately */
+    case '?':
+    length++;
+    goto POSESSIVE;      /* A few lines below */
+
+    /* This covers the cases of braced repeats after a single char, metachar,
+    class, or back reference. */
+
+    case '{':
+    if (!is_counted_repeat(ptr+1)) goto NORMAL_CHAR;
+    ptr = read_repeat_counts(ptr+1, &min, &max, errorptr);
+    if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+
+    /* These special cases just insert one extra opcode */
+
+    if ((min == 0 && (max == 1 || max == -1)) ||
+      (min == 1 && max == -1))
+        length++;
+
+    /* These cases might insert additional copies of a preceding character. */
+
+    else
+      {
+      if (min != 1)
+        {
+        length -= lastitemlength;   /* Uncount the original char or metachar */
+        if (min > 0) length += 3 + lastitemlength;
+        }
+      length += lastitemlength + ((max > 0)? 3 : 1);
+      }
+
+    if (ptr[1] == '?') ptr++;      /* Needs no extra length */
+
+    POSESSIVE:                     /* Test for possessive quantifier */
+    if (ptr[1] == '+')
+      {
+      ptr++;
+      length += 2 + 2*LINK_SIZE;   /* Allow for atomic brackets */
+      }
+    continue;
+
+    /* An alternation contains an offset to the next branch or ket. If any ims
+    options changed in the previous branch(es), and/or if we are in a
+    lookbehind assertion, extra space will be needed at the start of the
+    branch. This is handled by branch_extra. */
+
+    case '|':
+    length += 1 + LINK_SIZE + branch_extra;
+    continue;
+
+    /* A character class uses 33 characters provided that all the character
+    values are less than 256. Otherwise, it uses a bit map for low valued
+    characters, and individual items for others. Don't worry about character
+    types that aren't allowed in classes - they'll get picked up during the
+    compile. A character class that contains only one single-byte character
+    uses 2 or 3 bytes, depending on whether it is negated or not. Notice this
+    where we can. (In UTF-8 mode we can do this only for chars < 128.) */
+
+    case '[':
+    if (*(++ptr) == '^')
+      {
+      class_optcount = 10;  /* Greater than one */
+      ptr++;
+      }
+    else class_optcount = 0;
+
+#ifdef SUPPORT_UTF8
+    class_utf8 = FALSE;
+#endif
+
+    /* Written as a "do" so that an initial ']' is taken as data */
+
+    if (*ptr != 0) do
+      {
+      /* Inside \Q...\E everything is literal except \E */
+
+      if (inescq)
+        {
+        if (*ptr != '\\' || ptr[1] != 'E') goto GET_ONE_CHARACTER;
+        inescq = FALSE;
+        ptr += 1;
+        continue;
+        }
+
+      /* Outside \Q...\E, check for escapes */
+
+      if (*ptr == '\\')
+        {
+        c = check_escape(&ptr, errorptr, bracount, options, TRUE);
+        if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+
+        /* \b is backspace inside a class; \X is literal */
+
+        if (-c == ESC_b) c = '\b';
+        else if (-c == ESC_X) c = 'X';
+
+        /* \Q enters quoting mode */
+
+        else if (-c == ESC_Q)
+          {
+          inescq = TRUE;
+          continue;
+          }
+
+        /* Handle escapes that turn into characters */
+
+        if (c >= 0) goto NON_SPECIAL_CHARACTER;
+
+        /* Escapes that are meta-things. The normal ones just affect the
+        bit map, but Unicode properties require an XCLASS extended item. */
+
+        else
+          {
+          class_optcount = 10;         /* \d, \s etc; make sure > 1 */
+#ifdef SUPPORT_UTF8
+          if (-c == ESC_p || -c == ESC_P)
+            {
+            if (!class_utf8)
+              {
+              class_utf8 = TRUE;
+              length += LINK_SIZE + 2;
+              }
+            length += 2;
+            }
+#endif
+          }
+        }
+
+      /* Check the syntax for POSIX stuff. The bits we actually handle are
+      checked during the real compile phase. */
+
+      else if (*ptr == '[' && check_posix_syntax(ptr, &ptr, &compile_block))
+        {
+        ptr++;
+        class_optcount = 10;    /* Make sure > 1 */
+        }
+
+      /* Anything else increments the possible optimization count. We have to
+      detect ranges here so that we can compute the number of extra ranges for
+      caseless wide characters when UCP support is available. If there are wide
+      characters, we are going to have to use an XCLASS, even for single
+      characters. */
+
+      else
+        {
+        int d;
+
+        GET_ONE_CHARACTER:
+
+#ifdef SUPPORT_UTF8
+        if (utf8)
+          {
+          int extra = 0;
+          GETCHARLEN(c, ptr, extra);
+          ptr += extra;
+          }
+        else c = *ptr;
+#else
+        c = *ptr;
+#endif
+
+        /* Come here from handling \ above when it escapes to a char value */
+
+        NON_SPECIAL_CHARACTER:
+        class_optcount++;
+
+        d = -1;
+        if (ptr[1] == '-')
+          {
+          uschar const *hyptr = ptr++;
+          if (ptr[1] == '\\')
+            {
+            ptr++;
+            d = check_escape(&ptr, errorptr, bracount, options, TRUE);
+            if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+            if (-d == ESC_b) d = '\b';        /* backspace */
+            else if (-d == ESC_X) d = 'X';    /* literal X in a class */
+            }
+          else if (ptr[1] != 0 && ptr[1] != ']')
+            {
+            ptr++;
+#ifdef SUPPORT_UTF8
+            if (utf8)
+              {
+              int extra = 0;
+              GETCHARLEN(d, ptr, extra);
+              ptr += extra;
+              }
+            else
+#endif
+            d = *ptr;
+            }
+          if (d < 0) ptr = hyptr;      /* go back to hyphen as data */
+          }
+
+        /* If d >= 0 we have a range. In UTF-8 mode, if the end is > 255, or >
+        127 for caseless matching, we will need to use an XCLASS. */
+
+        if (d >= 0)
+          {
+          class_optcount = 10;     /* Ensure > 1 */
+          if (d < c)
+            {
+            *errorptr = ERR8;
+            goto PCRE_ERROR_RETURN;
+            }
+
+#ifdef SUPPORT_UTF8
+          if (utf8 && (d > 255 || ((options & PCRE_CASELESS) != 0 && d > 127)))
+            {
+            uschar buffer[6];
+            if (!class_utf8)         /* Allow for XCLASS overhead */
+              {
+              class_utf8 = TRUE;
+              length += LINK_SIZE + 2;
+              }
+
+#ifdef SUPPORT_UCP
+            /* If we have UCP support, find out how many extra ranges are
+            needed to map the other case of characters within this range. We
+            have to mimic the range optimization here, because extending the
+            range upwards might push d over a boundary that makes is use
+            another byte in the UTF-8 representation. */
+
+            if ((options & PCRE_CASELESS) != 0)
+              {
+              int occ, ocd;
+              int cc = c;
+              int origd = d;
+              while (get_othercase_range(&cc, origd, &occ, &ocd))
+                {
+                if (occ >= c && ocd <= d) continue;   /* Skip embedded */
+
+                if (occ < c  && ocd >= c - 1)  /* Extend the basic range */
+                  {                            /* if there is overlap,   */
+                  c = occ;                     /* noting that if occ < c */
+                  continue;                    /* we can't have ocd > d  */
+                  }                            /* because a subrange is  */
+                if (ocd > d && occ <= d + 1)   /* always shorter than    */
+                  {                            /* the basic range.       */
+                  d = ocd;
+                  continue;
+                  }
+
+                /* An extra item is needed */
+
+                length += 1 + ord2utf8(occ, buffer) +
+                  ((occ == ocd)? 0 : ord2utf8(ocd, buffer));
+                }
+              }
+#endif  /* SUPPORT_UCP */
+
+            /* The length of the (possibly extended) range */
+
+            length += 1 + ord2utf8(c, buffer) + ord2utf8(d, buffer);
+            }
+#endif  /* SUPPORT_UTF8 */
+
+          }
+
+        /* We have a single character. There is nothing to be done unless we
+        are in UTF-8 mode. If the char is > 255, or 127 when caseless, we must
+        allow for an XCL_SINGLE item, doubled for caselessness if there is UCP
+        support. */
+
+        else
+          {
+#ifdef SUPPORT_UTF8
+          if (utf8 && (c > 255 || ((options & PCRE_CASELESS) != 0 && c > 127)))
+            {
+            uschar buffer[6];
+            class_optcount = 10;     /* Ensure > 1 */
+            if (!class_utf8)         /* Allow for XCLASS overhead */
+              {
+              class_utf8 = TRUE;
+              length += LINK_SIZE + 2;
+              }
+#ifdef SUPPORT_UCP
+            length += (((options & PCRE_CASELESS) != 0)? 2 : 1) *
+              (1 + ord2utf8(c, buffer));
+#else   /* SUPPORT_UCP */
+            length += 1 + ord2utf8(c, buffer);
+#endif  /* SUPPORT_UCP */
+            }
+#endif  /* SUPPORT_UTF8 */
+          }
+        }
+      }
+    while (*(++ptr) != 0 && (inescq || *ptr != ']')); /* Concludes "do" above */
+
+    if (*ptr == 0)                          /* Missing terminating ']' */
+      {
+      *errorptr = ERR6;
+      goto PCRE_ERROR_RETURN;
+      }
+
+    /* We can optimize when there was only one optimizable character. Repeats
+    for positive and negated single one-byte chars are handled by the general
+    code. Here, we handle repeats for the class opcodes. */
+
+    if (class_optcount == 1) length += 3; else
+      {
+      length += 33;
+
+      /* A repeat needs either 1 or 5 bytes. If it is a possessive quantifier,
+      we also need extra for wrapping the whole thing in a sub-pattern. */
+
+      if (*ptr != 0 && ptr[1] == '{' && is_counted_repeat(ptr+2))
+        {
+        ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+        if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+        if ((min == 0 && (max == 1 || max == -1)) ||
+          (min == 1 && max == -1))
+            length++;
+        else length += 5;
+        if (ptr[1] == '+')
+          {
+          ptr++;
+          length += 2 + 2*LINK_SIZE;
+          }
+        else if (ptr[1] == '?') ptr++;
+        }
+      }
+    continue;
+
+    /* Brackets may be genuine groups or special things */
+
+    case '(':
+    branch_newextra = 0;
+    bracket_length = 1 + LINK_SIZE;
+
+    /* Handle special forms of bracket, which all start (? */
+
+    if (ptr[1] == '?')
+      {
+      int set, unset;
+      int *optset;
+
+      switch (c = ptr[2])
+        {
+        /* Skip over comments entirely */
+        case '#':
+        ptr += 3;
+        while (*ptr != 0 && *ptr != ')') ptr++;
+        if (*ptr == 0)
+          {
+          *errorptr = ERR18;
+          goto PCRE_ERROR_RETURN;
+          }
+        continue;
+
+        /* Non-referencing groups and lookaheads just move the pointer on, and
+        then behave like a non-special bracket, except that they don't increment
+        the count of extracting brackets. Ditto for the "once only" bracket,
+        which is in Perl from version 5.005. */
+
+        case ':':
+        case '=':
+        case '!':
+        case '>':
+        ptr += 2;
+        break;
+
+        /* (?R) specifies a recursive call to the regex, which is an extension
+        to provide the facility which can be obtained by (?p{perl-code}) in
+        Perl 5.6. In Perl 5.8 this has become (??{perl-code}).
+
+        From PCRE 4.00, items such as (?3) specify subroutine-like "calls" to
+        the appropriate numbered brackets. This includes both recursive and
+        non-recursive calls. (?R) is now synonymous with (?0). */
+
+        case 'R':
+        ptr++;
+
+        case '0': case '1': case '2': case '3': case '4':
+        case '5': case '6': case '7': case '8': case '9':
+        ptr += 2;
+        if (c != 'R')
+          while ((digitab[*(++ptr)] & ctype_digit) != 0);
+        if (*ptr != ')')
+          {
+          *errorptr = ERR29;
+          goto PCRE_ERROR_RETURN;
+          }
+        length += 1 + LINK_SIZE;
+
+        /* If this item is quantified, it will get wrapped inside brackets so
+        as to use the code for quantified brackets. We jump down and use the
+        code that handles this for real brackets. */
+
+        if (ptr[1] == '+' || ptr[1] == '*' || ptr[1] == '?' || ptr[1] == '{')
+          {
+          length += 2 + 2 * LINK_SIZE;       /* to make bracketed */
+          duplength = 5 + 3 * LINK_SIZE;
+          goto HANDLE_QUANTIFIED_BRACKETS;
+          }
+        continue;
+
+        /* (?C) is an extension which provides "callout" - to provide a bit of
+        the functionality of the Perl (?{...}) feature. An optional number may
+        follow (default is zero). */
+
+        case 'C':
+        ptr += 2;
+        while ((digitab[*(++ptr)] & ctype_digit) != 0);
+        if (*ptr != ')')
+          {
+          *errorptr = ERR39;
+          goto PCRE_ERROR_RETURN;
+          }
+        length += 2 + 2*LINK_SIZE;
+        continue;
+
+        /* Named subpatterns are an extension copied from Python */
+
+        case 'P':
+        ptr += 3;
+        if (*ptr == '<')
+          {
+          const uschar *p;    /* Don't amalgamate; some compilers */
+          p = ++ptr;          /* grumble at autoincrement in declaration */
+          while ((compile_block.ctypes[*ptr] & ctype_word) != 0) ptr++;
+          if (*ptr != '>')
+            {
+            *errorptr = ERR42;
+            goto PCRE_ERROR_RETURN;
+            }
+          name_count++;
+          if (ptr - p > max_name_size) max_name_size = (ptr - p);
+          break;
+          }
+
+        if (*ptr == '=' || *ptr == '>')
+          {
+          while ((compile_block.ctypes[*(++ptr)] & ctype_word) != 0);
+          if (*ptr != ')')
+            {
+            *errorptr = ERR42;
+            goto PCRE_ERROR_RETURN;
+            }
+          break;
+          }
+
+        /* Unknown character after (?P */
+
+        *errorptr = ERR41;
+        goto PCRE_ERROR_RETURN;
+
+        /* Lookbehinds are in Perl from version 5.005 */
+
+        case '<':
+        ptr += 3;
+        if (*ptr == '=' || *ptr == '!')
+          {
+          branch_newextra = 1 + LINK_SIZE;
+          length += 1 + LINK_SIZE;         /* For the first branch */
+          break;
+          }
+        *errorptr = ERR24;
+        goto PCRE_ERROR_RETURN;
+
+        /* Conditionals are in Perl from version 5.005. The bracket must either
+        be followed by a number (for bracket reference) or by an assertion
+        group, or (a PCRE extension) by 'R' for a recursion test. */
+
+        case '(':
+        if (ptr[3] == 'R' && ptr[4] == ')')
+          {
+          ptr += 4;
+          length += 3;
+          }
+        else if ((digitab[ptr[3]] & ctype_digit) != 0)
+          {
+          ptr += 4;
+          length += 3;
+          while ((digitab[*ptr] & ctype_digit) != 0) ptr++;
+          if (*ptr != ')')
+            {
+            *errorptr = ERR26;
+            goto PCRE_ERROR_RETURN;
+            }
+          }
+        else   /* An assertion must follow */
+          {
+          ptr++;   /* Can treat like ':' as far as spacing is concerned */
+          if (ptr[2] != '?' ||
+             (ptr[3] != '=' && ptr[3] != '!' && ptr[3] != '<') )
+            {
+            ptr += 2;    /* To get right offset in message */
+            *errorptr = ERR28;
+            goto PCRE_ERROR_RETURN;
+            }
+          }
+        break;
+
+        /* Else loop checking valid options until ) is met. Anything else is an
+        error. If we are without any brackets, i.e. at top level, the settings
+        act as if specified in the options, so massage the options immediately.
+        This is for backward compatibility with Perl 5.004. */
+
+        default:
+        set = unset = 0;
+        optset = &set;
+        ptr += 2;
+
+        for (;; ptr++)
+          {
+          c = *ptr;
+          switch (c)
+            {
+            case 'i':
+            *optset |= PCRE_CASELESS;
+            continue;
+
+            case 'm':
+            *optset |= PCRE_MULTILINE;
+            continue;
+
+            case 's':
+            *optset |= PCRE_DOTALL;
+            continue;
+
+            case 'x':
+            *optset |= PCRE_EXTENDED;
+            continue;
+
+            case 'X':
+            *optset |= PCRE_EXTRA;
+            continue;
+
+            case 'U':
+            *optset |= PCRE_UNGREEDY;
+            continue;
+
+            case '-':
+            optset = &unset;
+            continue;
+
+            /* A termination by ')' indicates an options-setting-only item; if
+            this is at the very start of the pattern (indicated by item_count
+            being zero), we use it to set the global options. This is helpful
+            when analyzing the pattern for first characters, etc. Otherwise
+            nothing is done here and it is handled during the compiling
+            process.
+
+            [Historical note: Up to Perl 5.8, options settings at top level
+            were always global settings, wherever they appeared in the pattern.
+            That is, they were equivalent to an external setting. From 5.8
+            onwards, they apply only to what follows (which is what you might
+            expect).] */
+
+            case ')':
+            if (item_count == 0)
+              {
+              options = (options | set) & (~unset);
+              set = unset = 0;     /* To save length */
+              item_count--;        /* To allow for several */
+              }
+
+            /* Fall through */
+
+            /* A termination by ':' indicates the start of a nested group with
+            the given options set. This is again handled at compile time, but
+            we must allow for compiled space if any of the ims options are
+            set. We also have to allow for resetting space at the end of
+            the group, which is why 4 is added to the length and not just 2.
+            If there are several changes of options within the same group, this
+            will lead to an over-estimate on the length, but this shouldn't
+            matter very much. We also have to allow for resetting options at
+            the start of any alternations, which we do by setting
+            branch_newextra to 2. Finally, we record whether the case-dependent
+            flag ever changes within the regex. This is used by the "required
+            character" code. */
+
+            case ':':
+            if (((set|unset) & PCRE_IMS) != 0)
+              {
+              length += 4;
+              branch_newextra = 2;
+              if (((set|unset) & PCRE_CASELESS) != 0) options |= PCRE_ICHANGED;
+              }
+            goto END_OPTIONS;
+
+            /* Unrecognized option character */
+
+            default:
+            *errorptr = ERR12;
+            goto PCRE_ERROR_RETURN;
+            }
+          }
+
+        /* If we hit a closing bracket, that's it - this is a freestanding
+        option-setting. We need to ensure that branch_extra is updated if
+        necessary. The only values branch_newextra can have here are 0 or 2.
+        If the value is 2, then branch_extra must either be 2 or 5, depending
+        on whether this is a lookbehind group or not. */
+
+        END_OPTIONS:
+        if (c == ')')
+          {
+          if (branch_newextra == 2 &&
+              (branch_extra == 0 || branch_extra == 1+LINK_SIZE))
+            branch_extra += branch_newextra;
+          continue;
+          }
+
+        /* If options were terminated by ':' control comes here. Fall through
+        to handle the group below. */
+        }
+      }
+
+    /* Extracting brackets must be counted so we can process escapes in a
+    Perlish way. If the number exceeds EXTRACT_BASIC_MAX we are going to
+    need an additional 3 bytes of store per extracting bracket. However, if
+    PCRE_NO_AUTO)CAPTURE is set, unadorned brackets become non-capturing, so we
+    must leave the count alone (it will aways be zero). */
+
+    else if ((options & PCRE_NO_AUTO_CAPTURE) == 0)
+      {
+      bracount++;
+      if (bracount > EXTRACT_BASIC_MAX) bracket_length += 3;
+      }
+
+    /* Save length for computing whole length at end if there's a repeat that
+    requires duplication of the group. Also save the current value of
+    branch_extra, and start the new group with the new value. If non-zero, this
+    will either be 2 for a (?imsx: group, or 3 for a lookbehind assertion. */
+
+    if (brastackptr >= sizeof(brastack)/sizeof(int))
+      {
+      *errorptr = ERR19;
+      goto PCRE_ERROR_RETURN;
+      }
+
+    bralenstack[brastackptr] = branch_extra;
+    branch_extra = branch_newextra;
+
+    brastack[brastackptr++] = length;
+    length += bracket_length;
+    continue;
+
+    /* Handle ket. Look for subsequent max/min; for certain sets of values we
+    have to replicate this bracket up to that many times. If brastackptr is
+    0 this is an unmatched bracket which will generate an error, but take care
+    not to try to access brastack[-1] when computing the length and restoring
+    the branch_extra value. */
+
+    case ')':
+    length += 1 + LINK_SIZE;
+    if (brastackptr > 0)
+      {
+      duplength = length - brastack[--brastackptr];
+      branch_extra = bralenstack[brastackptr];
+      }
+    else duplength = 0;
+
+    /* The following code is also used when a recursion such as (?3) is
+    followed by a quantifier, because in that case, it has to be wrapped inside
+    brackets so that the quantifier works. The value of duplength must be
+    set before arrival. */
+
+    HANDLE_QUANTIFIED_BRACKETS:
+
+    /* Leave ptr at the final char; for read_repeat_counts this happens
+    automatically; for the others we need an increment. */
+
+    if ((c = ptr[1]) == '{' && is_counted_repeat(ptr+2))
+      {
+      ptr = read_repeat_counts(ptr+2, &min, &max, errorptr);
+      if (*errorptr != NULL) goto PCRE_ERROR_RETURN;
+      }
+    else if (c == '*') { min = 0; max = -1; ptr++; }
+    else if (c == '+') { min = 1; max = -1; ptr++; }
+    else if (c == '?') { min = 0; max = 1;  ptr++; }
+    else { min = 1; max = 1; }
+
+    /* If the minimum is zero, we have to allow for an OP_BRAZERO before the
+    group, and if the maximum is greater than zero, we have to replicate
+    maxval-1 times; each replication acquires an OP_BRAZERO plus a nesting
+    bracket set. */
+
+    if (min == 0)
+      {
+      length++;
+      if (max > 0) length += (max - 1) * (duplength + 3 + 2*LINK_SIZE);
+      }
+
+    /* When the minimum is greater than zero, we have to replicate up to
+    minval-1 times, with no additions required in the copies. Then, if there
+    is a limited maximum we have to replicate up to maxval-1 times allowing
+    for a BRAZERO item before each optional copy and nesting brackets for all
+    but one of the optional copies. */
+
+    else
+      {
+      length += (min - 1) * duplength;
+      if (max > min)   /* Need this test as max=-1 means no limit */
+        length += (max - min) * (duplength + 3 + 2*LINK_SIZE)
+          - (2 + 2*LINK_SIZE);
+      }
+
+    /* Allow space for once brackets for "possessive quantifier" */
+
+    if (ptr[1] == '+')
+      {
+      ptr++;
+      length += 2 + 2*LINK_SIZE;
+      }
+    continue;
+
+    /* Non-special character. It won't be space or # in extended mode, so it is
+    always a genuine character. If we are in a \Q...\E sequence, check for the
+    end; if not, we have a literal. */
+
+    default:
+    NORMAL_CHAR:
+
+    if (inescq && c == '\\' && ptr[1] == 'E')
+      {
+      inescq = FALSE;
+      ptr++;
+      continue;
+      }
+
+    length += 2;          /* For a one-byte character */
+    lastitemlength = 1;   /* Default length of last item for repeats */
+
+    /* In UTF-8 mode, check for additional bytes. */
+
+#ifdef SUPPORT_UTF8
+    if (utf8 && (c & 0xc0) == 0xc0)
+      {
+      while ((ptr[1] & 0xc0) == 0x80)         /* Can't flow over the end */
+        {                                     /* because the end is marked */
+        lastitemlength++;                     /* by a zero byte. */
+        length++;
+        ptr++;
+        }
+      }
+#endif
+
+    continue;
+    }
+  }
+
+length += 2 + LINK_SIZE;    /* For final KET and END */
+
+if ((options & PCRE_AUTO_CALLOUT) != 0)
+  length += 2 + 2*LINK_SIZE;  /* For final callout */
+
+if (length > MAX_PATTERN_SIZE)
+  {
+  *errorptr = ERR20;
+  return NULL;
+  }
+
+/* Compute the size of data block needed and get it, either from malloc or
+externally provided function. */
+
+size = length + sizeof(real_pcre) + name_count * (max_name_size + 3);
+re = (real_pcre *)(pcre_malloc)(size);
+
+if (re == NULL)
+  {
+  *errorptr = ERR21;
+  return NULL;
+  }
+
+/* Put in the magic number, and save the sizes, options, and character table
+pointer. NULL is used for the default character tables. The nullpad field is at
+the end; it's there to help in the case when a regex compiled on a system with
+4-byte pointers is run on another with 8-byte pointers. */
+
+re->magic_number = MAGIC_NUMBER;
+re->size = size;
+re->options = options;
+re->dummy1 = re->dummy2 = 0;
+re->name_table_offset = sizeof(real_pcre);
+re->name_entry_size = max_name_size + 3;
+re->name_count = name_count;
+re->tables = (tables == pcre_default_tables)? NULL : tables;
+re->nullpad = NULL;
+
+/* The starting points of the name/number translation table and of the code are
+passed around in the compile data block. */
+
+compile_block.names_found = 0;
+compile_block.name_entry_size = max_name_size + 3;
+compile_block.name_table = (uschar *)re + re->name_table_offset;
+codestart = compile_block.name_table + re->name_entry_size * re->name_count;
+compile_block.start_code = codestart;
+compile_block.start_pattern = (const uschar *)pattern;
+compile_block.req_varyopt = 0;
+compile_block.nopartial = FALSE;
+
+/* Set up a starting, non-extracting bracket, then compile the expression. On
+error, *errorptr will be set non-NULL, so we don't need to look at the result
+of the function here. */
+
+ptr = (const uschar *)pattern;
+code = (uschar *)codestart;
+*code = OP_BRA;
+bracount = 0;
+(void)compile_regex(options, options & PCRE_IMS, &bracount, &code, &ptr,
+  errorptr, FALSE, 0, &firstbyte, &reqbyte, NULL, &compile_block);
+re->top_bracket = bracount;
+re->top_backref = compile_block.top_backref;
+
+if (compile_block.nopartial) re->options |= PCRE_NOPARTIAL;
+
+/* If not reached end of pattern on success, there's an excess bracket. */
+
+if (*errorptr == NULL && *ptr != 0) *errorptr = ERR22;
+
+/* Fill in the terminating state and check for disastrous overflow, but
+if debugging, leave the test till after things are printed out. */
+
+*code++ = OP_END;
+
+#ifndef DEBUG
+if (code - codestart > length) *errorptr = ERR23;
+#endif
+
+/* Give an error if there's back reference to a non-existent capturing
+subpattern. */
+
+if (re->top_backref > re->top_bracket) *errorptr = ERR15;
+
+/* Failed to compile, or error while post-processing */
+
+if (*errorptr != NULL)
+  {
+  (pcre_free)(re);
+  PCRE_ERROR_RETURN:
+  *erroroffset = ptr - (const uschar *)pattern;
+  return NULL;
+  }
+
+/* If the anchored option was not passed, set the flag if we can determine that
+the pattern is anchored by virtue of ^ characters or \A or anything else (such
+as starting with .* when DOTALL is set).
+
+Otherwise, if we know what the first character has to be, save it, because that
+speeds up unanchored matches no end. If not, see if we can set the
+PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
+start with ^. and also when all branches start with .* for non-DOTALL matches.
+*/
+
+if ((options & PCRE_ANCHORED) == 0)
+  {
+  int temp_options = options;
+  if (is_anchored(codestart, &temp_options, 0, compile_block.backref_map))
+    re->options |= PCRE_ANCHORED;
+  else
+    {
+    if (firstbyte < 0)
+      firstbyte = find_firstassertedchar(codestart, &temp_options, FALSE);
+    if (firstbyte >= 0)   /* Remove caseless flag for non-caseable chars */
+      {
+      int ch = firstbyte & 255;
+      re->first_byte = ((firstbyte & REQ_CASELESS) != 0 &&
+         compile_block.fcc[ch] == ch)? ch : firstbyte;
+      re->options |= PCRE_FIRSTSET;
+      }
+    else if (is_startline(codestart, 0, compile_block.backref_map))
+      re->options |= PCRE_STARTLINE;
+    }
+  }
+
+/* For an anchored pattern, we use the "required byte" only if it follows a
+variable length item in the regex. Remove the caseless flag for non-caseable
+bytes. */
+
+if (reqbyte >= 0 &&
+     ((re->options & PCRE_ANCHORED) == 0 || (reqbyte & REQ_VARY) != 0))
+  {
+  int ch = reqbyte & 255;
+  re->req_byte = ((reqbyte & REQ_CASELESS) != 0 &&
+    compile_block.fcc[ch] == ch)? (reqbyte & ~REQ_CASELESS) : reqbyte;
+  re->options |= PCRE_REQCHSET;
+  }
+
+/* Print out the compiled data for debugging */
+
+#ifdef DEBUG
+
+printf("Length = %d top_bracket = %d top_backref = %d\n",
+  length, re->top_bracket, re->top_backref);
+
+if (re->options != 0)
+  {
+  printf("%s%s%s%s%s%s%s%s%s%s\n",
+    ((re->options & PCRE_NOPARTIAL) != 0)? "nopartial " : "",
+    ((re->options & PCRE_ANCHORED) != 0)? "anchored " : "",
+    ((re->options & PCRE_CASELESS) != 0)? "caseless " : "",
+    ((re->options & PCRE_ICHANGED) != 0)? "case state changed " : "",
+    ((re->options & PCRE_EXTENDED) != 0)? "extended " : "",
+    ((re->options & PCRE_MULTILINE) != 0)? "multiline " : "",
+    ((re->options & PCRE_DOTALL) != 0)? "dotall " : "",
+    ((re->options & PCRE_DOLLAR_ENDONLY) != 0)? "endonly " : "",
+    ((re->options & PCRE_EXTRA) != 0)? "extra " : "",
+    ((re->options & PCRE_UNGREEDY) != 0)? "ungreedy " : "");
+  }
+
+if ((re->options & PCRE_FIRSTSET) != 0)
+  {
+  int ch = re->first_byte & 255;
+  const char *caseless = ((re->first_byte & REQ_CASELESS) == 0)? "" : " (caseless)";
+  if (isprint(ch)) printf("First char = %c%s\n", ch, caseless);
+    else printf("First char = \\x%02x%s\n", ch, caseless);
+  }
+
+if ((re->options & PCRE_REQCHSET) != 0)
+  {
+  int ch = re->req_byte & 255;
+  const char *caseless = ((re->req_byte & REQ_CASELESS) == 0)? "" : " (caseless)";
+  if (isprint(ch)) printf("Req char = %c%s\n", ch, caseless);
+    else printf("Req char = \\x%02x%s\n", ch, caseless);
+  }
+
+print_internals(re, stdout);
+
+/* This check is done here in the debugging case so that the code that
+was compiled can be seen. */
+
+if (code - codestart > length)
+  {
+  *errorptr = ERR23;
+  (pcre_free)(re);
+  *erroroffset = ptr - (uschar *)pattern;
+  return NULL;
+  }
+#endif
+
+return (pcre *)re;
+}
+
+
+
+/*************************************************
+*          Match a back-reference                *
+*************************************************/
+
+/* If a back reference hasn't been set, the length that is passed is greater
+than the number of characters left in the string, so the match fails.
+
+Arguments:
+  offset      index into the offset vector
+  eptr        points into the subject
+  length      length to be matched
+  md          points to match data block
+  ims         the ims flags
+
+Returns:      TRUE if matched
+*/
+
+static BOOL
+match_ref(int offset, register const uschar *eptr, int length, match_data *md,
+  unsigned long int ims)
+{
+const uschar *p = md->start_subject + md->offset_vector[offset];
+
+#ifdef DEBUG
+if (eptr >= md->end_subject)
+  printf("matching subject <null>");
+else
+  {
+  printf("matching subject ");
+  pchars(eptr, length, TRUE, md);
+  }
+printf(" against backref ");
+pchars(p, length, FALSE, md);
+printf("\n");
+#endif
+
+/* Always fail if not enough characters left */
+
+if (length > md->end_subject - eptr) return FALSE;
+
+/* Separate the caselesss case for speed */
+
+if ((ims & PCRE_CASELESS) != 0)
+  {
+  while (length-- > 0)
+    if (md->lcc[*p++] != md->lcc[*eptr++]) return FALSE;
+  }
+else
+  { while (length-- > 0) if (*p++ != *eptr++) return FALSE; }
+
+return TRUE;
+}
+
+
+#ifdef SUPPORT_UTF8
+/*************************************************
+*       Match character against an XCLASS        *
+*************************************************/
+
+/* This function is called from within the XCLASS code below, to match a
+character against an extended class which might match values > 255.
+
+Arguments:
+  c           the character
+  data        points to the flag byte of the XCLASS data
+
+Returns:      TRUE if character matches, else FALSE
+*/
+
+static BOOL
+match_xclass(int c, const uschar *data)
+{
+int t;
+BOOL negated = (*data & XCL_NOT) != 0;
+
+/* Character values < 256 are matched against a bitmap, if one is present. If
+not, we still carry on, because there may be ranges that start below 256 in the
+additional data. */
+
+if (c < 256)
+  {
+  if ((*data & XCL_MAP) != 0 && (data[1 + c/8] & (1 << (c&7))) != 0)
+    return !negated;   /* char found */
+  }
+
+/* First skip the bit map if present. Then match against the list of Unicode
+properties or large chars or ranges that end with a large char. We won't ever
+encounter XCL_PROP or XCL_NOTPROP when UCP support is not compiled. */
+
+if ((*data++ & XCL_MAP) != 0) data += 32;
+
+while ((t = *data++) != XCL_END)
+  {
+  int x, y;
+  if (t == XCL_SINGLE)
+    {
+    GETCHARINC(x, data);
+    if (c == x) return !negated;
+    }
+  else if (t == XCL_RANGE)
+    {
+    GETCHARINC(x, data);
+    GETCHARINC(y, data);
+    if (c >= x && c <= y) return !negated;
+    }
+
+#ifdef SUPPORT_UCP
+  else  /* XCL_PROP & XCL_NOTPROP */
+    {
+    int chartype, othercase;
+    int rqdtype = *data++;
+    int category = ucp_findchar(c, &chartype, &othercase);
+    if (rqdtype >= 128)
+      {
+      if ((rqdtype - 128 == category) == (t == XCL_PROP)) return !negated;
+      }
+    else
+      {
+      if ((rqdtype == chartype) == (t == XCL_PROP)) return !negated;
+      }
+    }
+#endif  /* SUPPORT_UCP */
+  }
+
+return negated;   /* char did not match */
+}
+#endif
+
+
+/***************************************************************************
+****************************************************************************
+                   RECURSION IN THE match() FUNCTION
+
+The match() function is highly recursive. Some regular expressions can cause
+it to recurse thousands of times. I was writing for Unix, so I just let it
+call itself recursively. This uses the stack for saving everything that has
+to be saved for a recursive call. On Unix, the stack can be large, and this
+works fine.
+
+It turns out that on non-Unix systems there are problems with programs that
+use a lot of stack. (This despite the fact that every last chip has oodles
+of memory these days, and techniques for extending the stack have been known
+for decades.) So....
+
+There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
+calls by keeping local variables that need to be preserved in blocks of memory
+obtained from malloc instead instead of on the stack. Macros are used to
+achieve this so that the actual code doesn't look very different to what it
+always used to.
+****************************************************************************
+***************************************************************************/
+
+
+/* These versions of the macros use the stack, as normal */
+
+#ifndef NO_RECURSE
+#define REGISTER register
+#define RMATCH(rx,ra,rb,rc,rd,re,rf,rg) rx = match(ra,rb,rc,rd,re,rf,rg)
+#define RRETURN(ra) return ra
+#else
+
+
+/* These versions of the macros manage a private stack on the heap. Note
+that the rd argument of RMATCH isn't actually used. It's the md argument of
+match(), which never changes. */
+
+#define REGISTER
+
+#define RMATCH(rx,ra,rb,rc,rd,re,rf,rg)\
+  {\
+  heapframe *newframe = (pcre_stack_malloc)(sizeof(heapframe));\
+  if (setjmp(frame->Xwhere) == 0)\
+    {\
+    newframe->Xeptr = ra;\
+    newframe->Xecode = rb;\
+    newframe->Xoffset_top = rc;\
+    newframe->Xims = re;\
+    newframe->Xeptrb = rf;\
+    newframe->Xflags = rg;\
+    newframe->Xprevframe = frame;\
+    frame = newframe;\
+    DPRINTF(("restarting from line %d\n", __LINE__));\
+    goto HEAP_RECURSE;\
+    }\
+  else\
+    {\
+    DPRINTF(("longjumped back to line %d\n", __LINE__));\
+    frame = md->thisframe;\
+    rx = frame->Xresult;\
+    }\
+  }
+
+#define RRETURN(ra)\
+  {\
+  heapframe *newframe = frame;\
+  frame = newframe->Xprevframe;\
+  (pcre_stack_free)(newframe);\
+  if (frame != NULL)\
+    {\
+    frame->Xresult = ra;\
+    md->thisframe = frame;\
+    longjmp(frame->Xwhere, 1);\
+    }\
+  return ra;\
+  }
+
+
+/* Structure for remembering the local variables in a private frame */
+
+typedef struct heapframe {
+  struct heapframe *Xprevframe;
+
+  /* Function arguments that may change */
+
+  const uschar *Xeptr;
+  const uschar *Xecode;
+  int Xoffset_top;
+  long int Xims;
+  eptrblock *Xeptrb;
+  int Xflags;
+
+  /* Function local variables */
+
+  const uschar *Xcallpat;
+  const uschar *Xcharptr;
+  const uschar *Xdata;
+  const uschar *Xnext;
+  const uschar *Xpp;
+  const uschar *Xprev;
+  const uschar *Xsaved_eptr;
+
+  recursion_info Xnew_recursive;
+
+  BOOL Xcur_is_word;
+  BOOL Xcondition;
+  BOOL Xminimize;
+  BOOL Xprev_is_word;
+
+  unsigned long int Xoriginal_ims;
+
+#ifdef SUPPORT_UCP
+  int Xprop_type;
+  int Xprop_fail_result;
+  int Xprop_category;
+  int Xprop_chartype;
+  int Xprop_othercase;
+  int Xprop_test_against;
+  int *Xprop_test_variable;
+#endif
+
+  int Xctype;
+  int Xfc;
+  int Xfi;
+  int Xlength;
+  int Xmax;
+  int Xmin;
+  int Xnumber;
+  int Xoffset;
+  int Xop;
+  int Xsave_capture_last;
+  int Xsave_offset1, Xsave_offset2, Xsave_offset3;
+  int Xstacksave[REC_STACK_SAVE_MAX];
+
+  eptrblock Xnewptrb;
+
+  /* Place to pass back result, and where to jump back to */
+
+  int  Xresult;
+  jmp_buf Xwhere;
+
+} heapframe;
+
+#endif
+
+
+/***************************************************************************
+***************************************************************************/
+
+
+
+/*************************************************
+*         Match from current position            *
+*************************************************/
+
+/* On entry ecode points to the first opcode, and eptr to the first character
+in the subject string, while eptrb holds the value of eptr at the start of the
+last bracketed group - used for breaking infinite loops matching zero-length
+strings. This function is called recursively in many circumstances. Whenever it
+returns a negative (error) response, the outer incarnation must also return the
+same response.
+
+Performance note: It might be tempting to extract commonly used fields from the
+md structure (e.g. utf8, end_subject) into individual variables to improve
+performance. Tests using gcc on a SPARC disproved this; in the first case, it
+made performance worse.
+
+Arguments:
+   eptr        pointer in subject
+   ecode       position in code
+   offset_top  current top pointer
+   md          pointer to "static" info for the match
+   ims         current /i, /m, and /s options
+   eptrb       pointer to chain of blocks containing eptr at start of
+                 brackets - for testing for empty matches
+   flags       can contain
+                 match_condassert - this is an assertion condition
+                 match_isgroup - this is the start of a bracketed group
+
+Returns:       MATCH_MATCH if matched            )  these values are >= 0
+               MATCH_NOMATCH if failed to match  )
+               a negative PCRE_ERROR_xxx value if aborted by an error condition
+                 (e.g. stopped by recursion limit)
+*/
+
+static int
+match(REGISTER const uschar *eptr, REGISTER const uschar *ecode,
+  int offset_top, match_data *md, unsigned long int ims, eptrblock *eptrb,
+  int flags)
+{
+/* These variables do not need to be preserved over recursion in this function,
+so they can be ordinary variables in all cases. Mark them with "register"
+because they are used a lot in loops. */
+
+register int rrc;    /* Returns from recursive calls */
+register int i;      /* Used for loops not involving calls to RMATCH() */
+register int c;      /* Character values not kept over RMATCH() calls */
+
+/* When recursion is not being used, all "local" variables that have to be
+preserved over calls to RMATCH() are part of a "frame" which is obtained from
+heap storage. Set up the top-level frame here; others are obtained from the
+heap whenever RMATCH() does a "recursion". See the macro definitions above. */
+
+#ifdef NO_RECURSE
+heapframe *frame = (pcre_stack_malloc)(sizeof(heapframe));
+frame->Xprevframe = NULL;            /* Marks the top level */
+
+/* Copy in the original argument variables */
+
+frame->Xeptr = eptr;
+frame->Xecode = ecode;
+frame->Xoffset_top = offset_top;
+frame->Xims = ims;
+frame->Xeptrb = eptrb;
+frame->Xflags = flags;
+
+/* This is where control jumps back to to effect "recursion" */
+
+HEAP_RECURSE:
+
+/* Macros make the argument variables come from the current frame */
+
+#define eptr               frame->Xeptr
+#define ecode              frame->Xecode
+#define offset_top         frame->Xoffset_top
+#define ims                frame->Xims
+#define eptrb              frame->Xeptrb
+#define flags              frame->Xflags
+
+/* Ditto for the local variables */
+
+#ifdef SUPPORT_UTF8
+#define charptr            frame->Xcharptr
+#endif
+#define callpat            frame->Xcallpat
+#define data               frame->Xdata
+#define next               frame->Xnext
+#define pp                 frame->Xpp
+#define prev               frame->Xprev
+#define saved_eptr         frame->Xsaved_eptr
+
+#define new_recursive      frame->Xnew_recursive
+
+#define cur_is_word        frame->Xcur_is_word
+#define condition          frame->Xcondition
+#define minimize           frame->Xminimize
+#define prev_is_word       frame->Xprev_is_word
+
+#define original_ims       frame->Xoriginal_ims
+
+#ifdef SUPPORT_UCP
+#define prop_type          frame->Xprop_type
+#define prop_fail_result   frame->Xprop_fail_result
+#define prop_category      frame->Xprop_category
+#define prop_chartype      frame->Xprop_chartype
+#define prop_othercase     frame->Xprop_othercase
+#define prop_test_against  frame->Xprop_test_against
+#define prop_test_variable frame->Xprop_test_variable
+#endif
+
+#define ctype              frame->Xctype
+#define fc                 frame->Xfc
+#define fi                 frame->Xfi
+#define length             frame->Xlength
+#define max                frame->Xmax
+#define min                frame->Xmin
+#define number             frame->Xnumber
+#define offset             frame->Xoffset
+#define op                 frame->Xop
+#define save_capture_last  frame->Xsave_capture_last
+#define save_offset1       frame->Xsave_offset1
+#define save_offset2       frame->Xsave_offset2
+#define save_offset3       frame->Xsave_offset3
+#define stacksave          frame->Xstacksave
+
+#define newptrb            frame->Xnewptrb
+
+/* When recursion is being used, local variables are allocated on the stack and
+get preserved during recursion in the normal way. In this environment, fi and
+i, and fc and c, can be the same variables. */
+
+#else
+#define fi i
+#define fc c
+
+
+#ifdef SUPPORT_UTF8                /* Many of these variables are used ony */
+const uschar *charptr;             /* small blocks of the code. My normal  */
+#endif                             /* style of coding would have declared  */
+const uschar *callpat;             /* them within each of those blocks.    */
+const uschar *data;                /* However, in order to accommodate the */
+const uschar *next;                /* version of this code that uses an    */
+const uschar *pp;                  /* external "stack" implemented on the  */
+const uschar *prev;                /* heap, it is easier to declare them   */
+const uschar *saved_eptr;          /* all here, so the declarations can    */
+                                   /* be cut out in a block. The only      */
+recursion_info new_recursive;      /* declarations within blocks below are */
+                                   /* for variables that do not have to    */
+BOOL cur_is_word;                  /* be preserved over a recursive call   */
+BOOL condition;                    /* to RMATCH().                         */
+BOOL minimize;
+BOOL prev_is_word;
+
+unsigned long int original_ims;
+
+#ifdef SUPPORT_UCP
+int prop_type;
+int prop_fail_result;
+int prop_category;
+int prop_chartype;
+int prop_othercase;
+int prop_test_against;
+int *prop_test_variable;
+#endif
+
+int ctype;
+int length;
+int max;
+int min;
+int number;
+int offset;
+int op;
+int save_capture_last;
+int save_offset1, save_offset2, save_offset3;
+int stacksave[REC_STACK_SAVE_MAX];
+
+eptrblock newptrb;
+#endif
+
+/* These statements are here to stop the compiler complaining about unitialized
+variables. */
+
+#ifdef SUPPORT_UCP
+prop_fail_result = 0;
+prop_test_against = 0;
+prop_test_variable = NULL;
+#endif
+
+/* OK, now we can get on with the real code of the function. Recursion is
+specified by the macros RMATCH and RRETURN. When NO_RECURSE is *not* defined,
+these just turn into a recursive call to match() and a "return", respectively.
+However, RMATCH isn't like a function call because it's quite a complicated
+macro. It has to be used in one particular way. This shouldn't, however, impact
+performance when true recursion is being used. */
+
+if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
+
+original_ims = ims;    /* Save for resetting on ')' */
+
+/* At the start of a bracketed group, add the current subject pointer to the
+stack of such pointers, to be re-instated at the end of the group when we hit
+the closing ket. When match() is called in other circumstances, we don't add to
+this stack. */
+
+if ((flags & match_isgroup) != 0)
+  {
+  newptrb.epb_prev = eptrb;
+  newptrb.epb_saved_eptr = eptr;
+  eptrb = &newptrb;
+  }
+
+/* Now start processing the operations. */
+
+for (;;)
+  {
+  op = *ecode;
+  minimize = FALSE;
+
+  /* For partial matching, remember if we ever hit the end of the subject after
+  matching at least one subject character. */
+
+  if (md->partial &&
+      eptr >= md->end_subject &&
+      eptr > md->start_match)
+    md->hitend = TRUE;
+
+  /* Opening capturing bracket. If there is space in the offset vector, save
+  the current subject position in the working slot at the top of the vector. We
+  mustn't change the current values of the data slot, because they may be set
+  from a previous iteration of this group, and be referred to by a reference
+  inside the group.
+
+  If the bracket fails to match, we need to restore this value and also the
+  values of the final offsets, in case they were set by a previous iteration of
+  the same bracket.
+
+  If there isn't enough space in the offset vector, treat this as if it were a
+  non-capturing bracket. Don't worry about setting the flag for the error case
+  here; that is handled in the code for KET. */
+
+  if (op > OP_BRA)
+    {
+    number = op - OP_BRA;
+
+    /* For extended extraction brackets (large number), we have to fish out the
+    number from a dummy opcode at the start. */
+
+    if (number > EXTRACT_BASIC_MAX)
+      number = GET2(ecode, 2+LINK_SIZE);
+    offset = number << 1;
+
+#ifdef DEBUG
+    printf("start bracket %d subject=", number);
+    pchars(eptr, 16, TRUE, md);
+    printf("\n");
+#endif
+
+    if (offset < md->offset_max)
+      {
+      save_offset1 = md->offset_vector[offset];
+      save_offset2 = md->offset_vector[offset+1];
+      save_offset3 = md->offset_vector[md->offset_end - number];
+      save_capture_last = md->capture_last;
+
+      DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
+      md->offset_vector[md->offset_end - number] = eptr - md->start_subject;
+
+      do
+        {
+        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+          match_isgroup);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        md->capture_last = save_capture_last;
+        ecode += GET(ecode, 1);
+        }
+      while (*ecode == OP_ALT);
+
+      DPRINTF(("bracket %d failed\n", number));
+
+      md->offset_vector[offset] = save_offset1;
+      md->offset_vector[offset+1] = save_offset2;
+      md->offset_vector[md->offset_end - number] = save_offset3;
+
+      RRETURN(MATCH_NOMATCH);
+      }
+
+    /* Insufficient room for saving captured contents */
+
+    else op = OP_BRA;
+    }
+
+  /* Other types of node can be handled by a switch */
+
+  switch(op)
+    {
+    case OP_BRA:     /* Non-capturing bracket: optimized */
+    DPRINTF(("start bracket 0\n"));
+    do
+      {
+      RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+        match_isgroup);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += GET(ecode, 1);
+      }
+    while (*ecode == OP_ALT);
+    DPRINTF(("bracket 0 failed\n"));
+    RRETURN(MATCH_NOMATCH);
+
+    /* Conditional group: compilation checked that there are no more than
+    two branches. If the condition is false, skipping the first branch takes us
+    past the end if there is only one branch, but that's OK because that is
+    exactly what going to the ket would do. */
+
+    case OP_COND:
+    if (ecode[LINK_SIZE+1] == OP_CREF) /* Condition extract or recurse test */
+      {
+      offset = GET2(ecode, LINK_SIZE+2) << 1;  /* Doubled ref number */
+      condition = (offset == CREF_RECURSE * 2)?
+        (md->recursive != NULL) :
+        (offset < offset_top && md->offset_vector[offset] >= 0);
+      RMATCH(rrc, eptr, ecode + (condition?
+        (LINK_SIZE + 4) : (LINK_SIZE + 1 + GET(ecode, 1))),
+        offset_top, md, ims, eptrb, match_isgroup);
+      RRETURN(rrc);
+      }
+
+    /* The condition is an assertion. Call match() to evaluate it - setting
+    the final argument TRUE causes it to stop at the end of an assertion. */
+
+    else
+      {
+      RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+          match_condassert | match_isgroup);
+      if (rrc == MATCH_MATCH)
+        {
+        ecode += 1 + LINK_SIZE + GET(ecode, LINK_SIZE+2);
+        while (*ecode == OP_ALT) ecode += GET(ecode, 1);
+        }
+      else if (rrc != MATCH_NOMATCH)
+        {
+        RRETURN(rrc);         /* Need braces because of following else */
+        }
+      else ecode += GET(ecode, 1);
+      RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb,
+        match_isgroup);
+      RRETURN(rrc);
+      }
+    /* Control never reaches here */
+
+    /* Skip over conditional reference or large extraction number data if
+    encountered. */
+
+    case OP_CREF:
+    case OP_BRANUMBER:
+    ecode += 3;
+    break;
+
+    /* End of the pattern. If we are in a recursion, we should restore the
+    offsets appropriately and continue from after the call. */
+
+    case OP_END:
+    if (md->recursive != NULL && md->recursive->group_num == 0)
+      {
+      recursion_info *rec = md->recursive;
+      DPRINTF(("Hit the end in a (?0) recursion\n"));
+      md->recursive = rec->prevrec;
+      memmove(md->offset_vector, rec->offset_save,
+        rec->saved_max * sizeof(int));
+      md->start_match = rec->save_start;
+      ims = original_ims;
+      ecode = rec->after_call;
+      break;
+      }
+
+    /* Otherwise, if PCRE_NOTEMPTY is set, fail if we have matched an empty
+    string - backtracking will then try other alternatives, if any. */
+
+    if (md->notempty && eptr == md->start_match) RRETURN(MATCH_NOMATCH);
+    md->end_match_ptr = eptr;          /* Record where we ended */
+    md->end_offset_top = offset_top;   /* and how many extracts were taken */
+    RRETURN(MATCH_MATCH);
+
+    /* Change option settings */
+
+    case OP_OPT:
+    ims = ecode[1];
+    ecode += 2;
+    DPRINTF(("ims set to %02lx\n", ims));
+    break;
+
+    /* Assertion brackets. Check the alternative branches in turn - the
+    matching won't pass the KET for an assertion. If any one branch matches,
+    the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
+    start of each branch to move the current point backwards, so the code at
+    this level is identical to the lookahead case. */
+
+    case OP_ASSERT:
+    case OP_ASSERTBACK:
+    do
+      {
+      RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+        match_isgroup);
+      if (rrc == MATCH_MATCH) break;
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += GET(ecode, 1);
+      }
+    while (*ecode == OP_ALT);
+    if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
+
+    /* If checking an assertion for a condition, return MATCH_MATCH. */
+
+    if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
+
+    /* Continue from after the assertion, updating the offsets high water
+    mark, since extracts may have been taken during the assertion. */
+
+    do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+    ecode += 1 + LINK_SIZE;
+    offset_top = md->end_offset_top;
+    continue;
+
+    /* Negative assertion: all branches must fail to match */
+
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK_NOT:
+    do
+      {
+      RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, NULL,
+        match_isgroup);
+      if (rrc == MATCH_MATCH) RRETURN(MATCH_NOMATCH);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += GET(ecode,1);
+      }
+    while (*ecode == OP_ALT);
+
+    if ((flags & match_condassert) != 0) RRETURN(MATCH_MATCH);
+
+    ecode += 1 + LINK_SIZE;
+    continue;
+
+    /* Move the subject pointer back. This occurs only at the start of
+    each branch of a lookbehind assertion. If we are too close to the start to
+    move back, this match function fails. When working with UTF-8 we move
+    back a number of characters, not bytes. */
+
+    case OP_REVERSE:
+#ifdef SUPPORT_UTF8
+    if (md->utf8)
+      {
+      c = GET(ecode,1);
+      for (i = 0; i < c; i++)
+        {
+        eptr--;
+        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+        BACKCHAR(eptr)
+        }
+      }
+    else
+#endif
+
+    /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
+
+      {
+      eptr -= GET(ecode,1);
+      if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+      }
+
+    /* Skip to next op code */
+
+    ecode += 1 + LINK_SIZE;
+    break;
+
+    /* The callout item calls an external function, if one is provided, passing
+    details of the match so far. This is mainly for debugging, though the
+    function is able to force a failure. */
+
+    case OP_CALLOUT:
+    if (pcre_callout != NULL)
+      {
+      pcre_callout_block cb;
+      cb.version          = 1;   /* Version 1 of the callout block */
+      cb.callout_number   = ecode[1];
+      cb.offset_vector    = md->offset_vector;
+      cb.subject          = (const char *)md->start_subject;
+      cb.subject_length   = md->end_subject - md->start_subject;
+      cb.start_match      = md->start_match - md->start_subject;
+      cb.current_position = eptr - md->start_subject;
+      cb.pattern_position = GET(ecode, 2);
+      cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
+      cb.capture_top      = offset_top/2;
+      cb.capture_last     = md->capture_last;
+      cb.callout_data     = md->callout_data;
+      if ((rrc = (*pcre_callout)(&cb)) > 0) RRETURN(MATCH_NOMATCH);
+      if (rrc < 0) RRETURN(rrc);
+      }
+    ecode += 2 + 2*LINK_SIZE;
+    break;
+
+    /* Recursion either matches the current regex, or some subexpression. The
+    offset data is the offset to the starting bracket from the start of the
+    whole pattern. (This is so that it works from duplicated subpatterns.)
+
+    If there are any capturing brackets started but not finished, we have to
+    save their starting points and reinstate them after the recursion. However,
+    we don't know how many such there are (offset_top records the completed
+    total) so we just have to save all the potential data. There may be up to
+    65535 such values, which is too large to put on the stack, but using malloc
+    for small numbers seems expensive. As a compromise, the stack is used when
+    there are no more than REC_STACK_SAVE_MAX values to store; otherwise malloc
+    is used. A problem is what to do if the malloc fails ... there is no way of
+    returning to the top level with an error. Save the top REC_STACK_SAVE_MAX
+    values on the stack, and accept that the rest may be wrong.
+
+    There are also other values that have to be saved. We use a chained
+    sequence of blocks that actually live on the stack. Thanks to Robin Houston
+    for the original version of this logic. */
+
+    case OP_RECURSE:
+      {
+      callpat = md->start_code + GET(ecode, 1);
+      new_recursive.group_num = *callpat - OP_BRA;
+
+      /* For extended extraction brackets (large number), we have to fish out
+      the number from a dummy opcode at the start. */
+
+      if (new_recursive.group_num > EXTRACT_BASIC_MAX)
+        new_recursive.group_num = GET2(callpat, 2+LINK_SIZE);
+
+      /* Add to "recursing stack" */
+
+      new_recursive.prevrec = md->recursive;
+      md->recursive = &new_recursive;
+
+      /* Find where to continue from afterwards */
+
+      ecode += 1 + LINK_SIZE;
+      new_recursive.after_call = ecode;
+
+      /* Now save the offset data. */
+
+      new_recursive.saved_max = md->offset_end;
+      if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
+        new_recursive.offset_save = stacksave;
+      else
+        {
+        new_recursive.offset_save =
+          (int *)(pcre_malloc)(new_recursive.saved_max * sizeof(int));
+        if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
+        }
+
+      memcpy(new_recursive.offset_save, md->offset_vector,
+            new_recursive.saved_max * sizeof(int));
+      new_recursive.save_start = md->start_match;
+      md->start_match = eptr;
+
+      /* OK, now we can do the recursion. For each top-level alternative we
+      restore the offset and recursion data. */
+
+      DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
+      do
+        {
+        RMATCH(rrc, eptr, callpat + 1 + LINK_SIZE, offset_top, md, ims,
+            eptrb, match_isgroup);
+        if (rrc == MATCH_MATCH)
+          {
+          md->recursive = new_recursive.prevrec;
+          if (new_recursive.offset_save != stacksave)
+            (pcre_free)(new_recursive.offset_save);
+          RRETURN(MATCH_MATCH);
+          }
+        else if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+
+        md->recursive = &new_recursive;
+        memcpy(md->offset_vector, new_recursive.offset_save,
+            new_recursive.saved_max * sizeof(int));
+        callpat += GET(callpat, 1);
+        }
+      while (*callpat == OP_ALT);
+
+      DPRINTF(("Recursion didn't match\n"));
+      md->recursive = new_recursive.prevrec;
+      if (new_recursive.offset_save != stacksave)
+        (pcre_free)(new_recursive.offset_save);
+      RRETURN(MATCH_NOMATCH);
+      }
+    /* Control never reaches here */
+
+    /* "Once" brackets are like assertion brackets except that after a match,
+    the point in the subject string is not moved back. Thus there can never be
+    a move back into the brackets. Friedl calls these "atomic" subpatterns.
+    Check the alternative branches in turn - the matching won't pass the KET
+    for this kind of subpattern. If any one branch matches, we carry on as at
+    the end of a normal bracket, leaving the subject pointer. */
+
+    case OP_ONCE:
+      {
+      prev = ecode;
+      saved_eptr = eptr;
+
+      do
+        {
+        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims,
+          eptrb, match_isgroup);
+        if (rrc == MATCH_MATCH) break;
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        ecode += GET(ecode,1);
+        }
+      while (*ecode == OP_ALT);
+
+      /* If hit the end of the group (which could be repeated), fail */
+
+      if (*ecode != OP_ONCE && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
+
+      /* Continue as from after the assertion, updating the offsets high water
+      mark, since extracts may have been taken. */
+
+      do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+
+      offset_top = md->end_offset_top;
+      eptr = md->end_match_ptr;
+
+      /* For a non-repeating ket, just continue at this level. This also
+      happens for a repeating ket if no characters were matched in the group.
+      This is the forcible breaking of infinite loops as implemented in Perl
+      5.005. If there is an options reset, it will get obeyed in the normal
+      course of events. */
+
+      if (*ecode == OP_KET || eptr == saved_eptr)
+        {
+        ecode += 1+LINK_SIZE;
+        break;
+        }
+
+      /* The repeating kets try the rest of the pattern or restart from the
+      preceding bracket, in the appropriate order. We need to reset any options
+      that changed within the bracket before re-running it, so check the next
+      opcode. */
+
+      if (ecode[1+LINK_SIZE] == OP_OPT)
+        {
+        ims = (ims & ~PCRE_IMS) | ecode[4];
+        DPRINTF(("ims set to %02lx at group repeat\n", ims));
+        }
+
+      if (*ecode == OP_KETRMIN)
+        {
+        RMATCH(rrc, eptr, ecode + 1 + LINK_SIZE, offset_top, md, ims, eptrb, 0);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        }
+      else  /* OP_KETRMAX */
+        {
+        RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        }
+      }
+    RRETURN(MATCH_NOMATCH);
+
+    /* An alternation is the end of a branch; scan along to find the end of the
+    bracketed group and go to there. */
+
+    case OP_ALT:
+    do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+    break;
+
+    /* BRAZERO and BRAMINZERO occur just before a bracket group, indicating
+    that it may occur zero times. It may repeat infinitely, or not at all -
+    i.e. it could be ()* or ()? in the pattern. Brackets with fixed upper
+    repeat limits are compiled as a number of copies, with the optional ones
+    preceded by BRAZERO or BRAMINZERO. */
+
+    case OP_BRAZERO:
+      {
+      next = ecode+1;
+      RMATCH(rrc, eptr, next, offset_top, md, ims, eptrb, match_isgroup);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      do next += GET(next,1); while (*next == OP_ALT);
+      ecode = next + 1+LINK_SIZE;
+      }
+    break;
+
+    case OP_BRAMINZERO:
+      {
+      next = ecode+1;
+      do next += GET(next,1); while (*next == OP_ALT);
+      RMATCH(rrc, eptr, next + 1+LINK_SIZE, offset_top, md, ims, eptrb,
+        match_isgroup);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode++;
+      }
+    break;
+
+    /* End of a group, repeated or non-repeating. If we are at the end of
+    an assertion "group", stop matching and return MATCH_MATCH, but record the
+    current high water mark for use by positive assertions. Do this also
+    for the "once" (not-backup up) groups. */
+
+    case OP_KET:
+    case OP_KETRMIN:
+    case OP_KETRMAX:
+      {
+      prev = ecode - GET(ecode, 1);
+      saved_eptr = eptrb->epb_saved_eptr;
+
+      /* Back up the stack of bracket start pointers. */
+
+      eptrb = eptrb->epb_prev;
+
+      if (*prev == OP_ASSERT || *prev == OP_ASSERT_NOT ||
+          *prev == OP_ASSERTBACK || *prev == OP_ASSERTBACK_NOT ||
+          *prev == OP_ONCE)
+        {
+        md->end_match_ptr = eptr;      /* For ONCE */
+        md->end_offset_top = offset_top;
+        RRETURN(MATCH_MATCH);
+        }
+
+      /* In all other cases except a conditional group we have to check the
+      group number back at the start and if necessary complete handling an
+      extraction by setting the offsets and bumping the high water mark. */
+
+      if (*prev != OP_COND)
+        {
+        number = *prev - OP_BRA;
+
+        /* For extended extraction brackets (large number), we have to fish out
+        the number from a dummy opcode at the start. */
+
+        if (number > EXTRACT_BASIC_MAX) number = GET2(prev, 2+LINK_SIZE);
+        offset = number << 1;
+
+#ifdef DEBUG
+        printf("end bracket %d", number);
+        printf("\n");
+#endif
+
+        /* Test for a numbered group. This includes groups called as a result
+        of recursion. Note that whole-pattern recursion is coded as a recurse
+        into group 0, so it won't be picked up here. Instead, we catch it when
+        the OP_END is reached. */
+
+        if (number > 0)
+          {
+          md->capture_last = number;
+          if (offset >= md->offset_max) md->offset_overflow = TRUE; else
+            {
+            md->offset_vector[offset] =
+              md->offset_vector[md->offset_end - number];
+            md->offset_vector[offset+1] = eptr - md->start_subject;
+            if (offset_top <= offset) offset_top = offset + 2;
+            }
+
+          /* Handle a recursively called group. Restore the offsets
+          appropriately and continue from after the call. */
+
+          if (md->recursive != NULL && md->recursive->group_num == number)
+            {
+            recursion_info *rec = md->recursive;
+            DPRINTF(("Recursion (%d) succeeded - continuing\n", number));
+            md->recursive = rec->prevrec;
+            md->start_match = rec->save_start;
+            memcpy(md->offset_vector, rec->offset_save,
+              rec->saved_max * sizeof(int));
+            ecode = rec->after_call;
+            ims = original_ims;
+            break;
+            }
+          }
+        }
+
+      /* Reset the value of the ims flags, in case they got changed during
+      the group. */
+
+      ims = original_ims;
+      DPRINTF(("ims reset to %02lx\n", ims));
+
+      /* For a non-repeating ket, just continue at this level. This also
+      happens for a repeating ket if no characters were matched in the group.
+      This is the forcible breaking of infinite loops as implemented in Perl
+      5.005. If there is an options reset, it will get obeyed in the normal
+      course of events. */
+
+      if (*ecode == OP_KET || eptr == saved_eptr)
+        {
+        ecode += 1 + LINK_SIZE;
+        break;
+        }
+
+      /* The repeating kets try the rest of the pattern or restart from the
+      preceding bracket, in the appropriate order. */
+
+      if (*ecode == OP_KETRMIN)
+        {
+        RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        }
+      else  /* OP_KETRMAX */
+        {
+        RMATCH(rrc, eptr, prev, offset_top, md, ims, eptrb, match_isgroup);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        RMATCH(rrc, eptr, ecode + 1+LINK_SIZE, offset_top, md, ims, eptrb, 0);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        }
+      }
+
+    RRETURN(MATCH_NOMATCH);
+
+    /* Start of subject unless notbol, or after internal newline if multiline */
+
+    case OP_CIRC:
+    if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
+    if ((ims & PCRE_MULTILINE) != 0)
+      {
+      if (eptr != md->start_subject && eptr[-1] != NEWLINE)
+        RRETURN(MATCH_NOMATCH);
+      ecode++;
+      break;
+      }
+    /* ... else fall through */
+
+    /* Start of subject assertion */
+
+    case OP_SOD:
+    if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* Start of match assertion */
+
+    case OP_SOM:
+    if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* Assert before internal newline if multiline, or before a terminating
+    newline unless endonly is set, else end of subject unless noteol is set. */
+
+    case OP_DOLL:
+    if ((ims & PCRE_MULTILINE) != 0)
+      {
+      if (eptr < md->end_subject)
+        { if (*eptr != NEWLINE) RRETURN(MATCH_NOMATCH); }
+      else
+        { if (md->noteol) RRETURN(MATCH_NOMATCH); }
+      ecode++;
+      break;
+      }
+    else
+      {
+      if (md->noteol) RRETURN(MATCH_NOMATCH);
+      if (!md->endonly)
+        {
+        if (eptr < md->end_subject - 1 ||
+           (eptr == md->end_subject - 1 && *eptr != NEWLINE))
+          RRETURN(MATCH_NOMATCH);
+        ecode++;
+        break;
+        }
+      }
+    /* ... else fall through */
+
+    /* End of subject assertion (\z) */
+
+    case OP_EOD:
+    if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* End of subject or ending \n assertion (\Z) */
+
+    case OP_EODN:
+    if (eptr < md->end_subject - 1 ||
+       (eptr == md->end_subject - 1 && *eptr != NEWLINE)) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* Word boundary assertions */
+
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+      {
+
+      /* Find out if the previous and current characters are "word" characters.
+      It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
+      be "non-word" characters. */
+
+#ifdef SUPPORT_UTF8
+      if (md->utf8)
+        {
+        if (eptr == md->start_subject) prev_is_word = FALSE; else
+          {
+          const uschar *lastptr = eptr - 1;
+          while((*lastptr & 0xc0) == 0x80) lastptr--;
+          GETCHAR(c, lastptr);
+          prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
+          }
+        if (eptr >= md->end_subject) cur_is_word = FALSE; else
+          {
+          GETCHAR(c, eptr);
+          cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
+          }
+        }
+      else
+#endif
+
+      /* More streamlined when not in UTF-8 mode */
+
+        {
+        prev_is_word = (eptr != md->start_subject) &&
+          ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+        cur_is_word = (eptr < md->end_subject) &&
+          ((md->ctypes[*eptr] & ctype_word) != 0);
+        }
+
+      /* Now see if the situation is what we want */
+
+      if ((*ecode++ == OP_WORD_BOUNDARY)?
+           cur_is_word == prev_is_word : cur_is_word != prev_is_word)
+        RRETURN(MATCH_NOMATCH);
+      }
+    break;
+
+    /* Match a single character type; inline for speed */
+
+    case OP_ANY:
+    if ((ims & PCRE_DOTALL) == 0 && eptr < md->end_subject && *eptr == NEWLINE)
+      RRETURN(MATCH_NOMATCH);
+    if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+#ifdef SUPPORT_UTF8
+    if (md->utf8)
+      while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+#endif
+    ecode++;
+    break;
+
+    /* Match a single byte, even in UTF-8 mode. This opcode really does match
+    any byte, even newline, independent of the setting of PCRE_DOTALL. */
+
+    case OP_ANYBYTE:
+    if (eptr++ >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_NOT_DIGIT:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+    if (
+#ifdef SUPPORT_UTF8
+       c < 256 &&
+#endif
+       (md->ctypes[c] & ctype_digit) != 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_DIGIT:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+    if (
+#ifdef SUPPORT_UTF8
+       c >= 256 ||
+#endif
+       (md->ctypes[c] & ctype_digit) == 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_NOT_WHITESPACE:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+    if (
+#ifdef SUPPORT_UTF8
+       c < 256 &&
+#endif
+       (md->ctypes[c] & ctype_space) != 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_WHITESPACE:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+    if (
+#ifdef SUPPORT_UTF8
+       c >= 256 ||
+#endif
+       (md->ctypes[c] & ctype_space) == 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_NOT_WORDCHAR:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+    if (
+#ifdef SUPPORT_UTF8
+       c < 256 &&
+#endif
+       (md->ctypes[c] & ctype_word) != 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_WORDCHAR:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+    if (
+#ifdef SUPPORT_UTF8
+       c >= 256 ||
+#endif
+       (md->ctypes[c] & ctype_word) == 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+#ifdef SUPPORT_UCP
+    /* Check the next character by Unicode property. We will get here only
+    if the support is in the binary; otherwise a compile-time error occurs. */
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+      {
+      int chartype, rqdtype;
+      int othercase;
+      int category = ucp_findchar(c, &chartype, &othercase);
+
+      rqdtype = *(++ecode);
+      ecode++;
+
+      if (rqdtype >= 128)
+        {
+        if ((rqdtype - 128 != category) == (op == OP_PROP))
+          RRETURN(MATCH_NOMATCH);
+        }
+      else
+        {
+        if ((rqdtype != chartype) == (op == OP_PROP))
+          RRETURN(MATCH_NOMATCH);
+        }
+      }
+    break;
+
+    /* Match an extended Unicode sequence. We will get here only if the support
+    is in the binary; otherwise a compile-time error occurs. */
+
+    case OP_EXTUNI:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    GETCHARINCTEST(c, eptr);
+      {
+      int chartype;
+      int othercase;
+      int category = ucp_findchar(c, &chartype, &othercase);
+      if (category == ucp_M) RRETURN(MATCH_NOMATCH);
+      while (eptr < md->end_subject)
+        {
+        int len = 1;
+        if (!md->utf8) c = *eptr; else
+          {
+          GETCHARLEN(c, eptr, len);
+          }
+        category = ucp_findchar(c, &chartype, &othercase);
+        if (category != ucp_M) break;
+        eptr += len;
+        }
+      }
+    ecode++;
+    break;
+#endif
+
+
+    /* Match a back reference, possibly repeatedly. Look past the end of the
+    item to see if there is repeat information following. The code is similar
+    to that for character classes, but repeated for efficiency. Then obey
+    similar code to character type repeats - written out again for speed.
+    However, if the referenced string is the empty string, always treat
+    it as matched, any number of times (otherwise there could be infinite
+    loops). */
+
+    case OP_REF:
+      {
+      offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
+      ecode += 3;                                 /* Advance past item */
+
+      /* If the reference is unset, set the length to be longer than the amount
+      of subject left; this ensures that every attempt at a match fails. We
+      can't just fail here, because of the possibility of quantifiers with zero
+      minima. */
+
+      length = (offset >= offset_top || md->offset_vector[offset] < 0)?
+        md->end_subject - eptr + 1 :
+        md->offset_vector[offset+1] - md->offset_vector[offset];
+
+      /* Set up for repetition, or handle the non-repeated case */
+
+      switch (*ecode)
+        {
+        case OP_CRSTAR:
+        case OP_CRMINSTAR:
+        case OP_CRPLUS:
+        case OP_CRMINPLUS:
+        case OP_CRQUERY:
+        case OP_CRMINQUERY:
+        c = *ecode++ - OP_CRSTAR;
+        minimize = (c & 1) != 0;
+        min = rep_min[c];                 /* Pick up values from tables; */
+        max = rep_max[c];                 /* zero for max => infinity */
+        if (max == 0) max = INT_MAX;
+        break;
+
+        case OP_CRRANGE:
+        case OP_CRMINRANGE:
+        minimize = (*ecode == OP_CRMINRANGE);
+        min = GET2(ecode, 1);
+        max = GET2(ecode, 3);
+        if (max == 0) max = INT_MAX;
+        ecode += 5;
+        break;
+
+        default:               /* No repeat follows */
+        if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+        eptr += length;
+        continue;              /* With the main loop */
+        }
+
+      /* If the length of the reference is zero, just continue with the
+      main loop. */
+
+      if (length == 0) continue;
+
+      /* First, ensure the minimum number of matches are present. We get back
+      the length of the reference string explicitly rather than passing the
+      address of eptr, so that eptr can be a register variable. */
+
+      for (i = 1; i <= min; i++)
+        {
+        if (!match_ref(offset, eptr, length, md, ims)) RRETURN(MATCH_NOMATCH);
+        eptr += length;
+        }
+
+      /* If min = max, continue at the same level without recursion.
+      They are not both allowed to be zero. */
+
+      if (min == max) continue;
+
+      /* If minimizing, keep trying and advancing the pointer */
+
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || !match_ref(offset, eptr, length, md, ims))
+            RRETURN(MATCH_NOMATCH);
+          eptr += length;
+          }
+        /* Control never gets here */
+        }
+
+      /* If maximizing, find the longest string and work backwards */
+
+      else
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          if (!match_ref(offset, eptr, length, md, ims)) break;
+          eptr += length;
+          }
+        while (eptr >= pp)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          eptr -= length;
+          }
+        RRETURN(MATCH_NOMATCH);
+        }
+      }
+    /* Control never gets here */
+
+
+
+    /* Match a bit-mapped character class, possibly repeatedly. This op code is
+    used when all the characters in the class have values in the range 0-255,
+    and either the matching is caseful, or the characters are in the range
+    0-127 when UTF-8 processing is enabled. The only difference between
+    OP_CLASS and OP_NCLASS occurs when a data character outside the range is
+    encountered.
+
+    First, look past the end of the item to see if there is repeat information
+    following. Then obey similar code to character type repeats - written out
+    again for speed. */
+
+    case OP_NCLASS:
+    case OP_CLASS:
+      {
+      data = ecode + 1;                /* Save for matching */
+      ecode += 33;                     /* Advance past the item */
+
+      switch (*ecode)
+        {
+        case OP_CRSTAR:
+        case OP_CRMINSTAR:
+        case OP_CRPLUS:
+        case OP_CRMINPLUS:
+        case OP_CRQUERY:
+        case OP_CRMINQUERY:
+        c = *ecode++ - OP_CRSTAR;
+        minimize = (c & 1) != 0;
+        min = rep_min[c];                 /* Pick up values from tables; */
+        max = rep_max[c];                 /* zero for max => infinity */
+        if (max == 0) max = INT_MAX;
+        break;
+
+        case OP_CRRANGE:
+        case OP_CRMINRANGE:
+        minimize = (*ecode == OP_CRMINRANGE);
+        min = GET2(ecode, 1);
+        max = GET2(ecode, 3);
+        if (max == 0) max = INT_MAX;
+        ecode += 5;
+        break;
+
+        default:               /* No repeat follows */
+        min = max = 1;
+        break;
+        }
+
+      /* First, ensure the minimum number of matches are present. */
+
+#ifdef SUPPORT_UTF8
+      /* UTF-8 mode */
+      if (md->utf8)
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          GETCHARINC(c, eptr);
+          if (c > 255)
+            {
+            if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+            }
+          else
+            {
+            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        }
+      else
+#endif
+      /* Not UTF-8 mode */
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          c = *eptr++;
+          if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+          }
+        }
+
+      /* If max == min we can continue with the main loop without the
+      need to recurse. */
+
+      if (min == max) continue;
+
+      /* If minimizing, keep testing the rest of the expression and advancing
+      the pointer while it matches the class. */
+
+      if (minimize)
+        {
+#ifdef SUPPORT_UTF8
+        /* UTF-8 mode */
+        if (md->utf8)
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+            GETCHARINC(c, eptr);
+            if (c > 255)
+              {
+              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+              }
+            else
+              {
+              if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+              }
+            }
+          }
+        else
+#endif
+        /* Not UTF-8 mode */
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+            c = *eptr++;
+            if ((data[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* If maximizing, find the longest possible run, then work backwards. */
+
+      else
+        {
+        pp = eptr;
+
+#ifdef SUPPORT_UTF8
+        /* UTF-8 mode */
+        if (md->utf8)
+          {
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c > 255)
+              {
+              if (op == OP_CLASS) break;
+              }
+            else
+              {
+              if ((data[c/8] & (1 << (c&7))) == 0) break;
+              }
+            eptr += len;
+            }
+          for (;;)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (eptr-- == pp) break;        /* Stop if tried at original pos */
+            BACKCHAR(eptr);
+            }
+          }
+        else
+#endif
+          /* Not UTF-8 mode */
+          {
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject) break;
+            c = *eptr;
+            if ((data[c/8] & (1 << (c&7))) == 0) break;
+            eptr++;
+            }
+          while (eptr >= pp)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            eptr--;
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            }
+          }
+
+        RRETURN(MATCH_NOMATCH);
+        }
+      }
+    /* Control never gets here */
+
+
+    /* Match an extended character class. This opcode is encountered only
+    in UTF-8 mode, because that's the only time it is compiled. */
+
+#ifdef SUPPORT_UTF8
+    case OP_XCLASS:
+      {
+      data = ecode + 1 + LINK_SIZE;                /* Save for matching */
+      ecode += GET(ecode, 1);                      /* Advance past the item */
+
+      switch (*ecode)
+        {
+        case OP_CRSTAR:
+        case OP_CRMINSTAR:
+        case OP_CRPLUS:
+        case OP_CRMINPLUS:
+        case OP_CRQUERY:
+        case OP_CRMINQUERY:
+        c = *ecode++ - OP_CRSTAR;
+        minimize = (c & 1) != 0;
+        min = rep_min[c];                 /* Pick up values from tables; */
+        max = rep_max[c];                 /* zero for max => infinity */
+        if (max == 0) max = INT_MAX;
+        break;
+
+        case OP_CRRANGE:
+        case OP_CRMINRANGE:
+        minimize = (*ecode == OP_CRMINRANGE);
+        min = GET2(ecode, 1);
+        max = GET2(ecode, 3);
+        if (max == 0) max = INT_MAX;
+        ecode += 5;
+        break;
+
+        default:               /* No repeat follows */
+        min = max = 1;
+        break;
+        }
+
+      /* First, ensure the minimum number of matches are present. */
+
+      for (i = 1; i <= min; i++)
+        {
+        if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+        GETCHARINC(c, eptr);
+        if (!match_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+        }
+
+      /* If max == min we can continue with the main loop without the
+      need to recurse. */
+
+      if (min == max) continue;
+
+      /* If minimizing, keep testing the rest of the expression and advancing
+      the pointer while it matches the class. */
+
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          GETCHARINC(c, eptr);
+          if (!match_xclass(c, data)) RRETURN(MATCH_NOMATCH);
+          }
+        /* Control never gets here */
+        }
+
+      /* If maximizing, find the longest possible run, then work backwards. */
+
+      else
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          int len = 1;
+          if (eptr >= md->end_subject) break;
+          GETCHARLEN(c, eptr, len);
+          if (!match_xclass(c, data)) break;
+          eptr += len;
+          }
+        for(;;)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (eptr-- == pp) break;        /* Stop if tried at original pos */
+          BACKCHAR(eptr)
+          }
+        RRETURN(MATCH_NOMATCH);
+        }
+
+      /* Control never gets here */
+      }
+#endif    /* End of XCLASS */
+
+    /* Match a single character, casefully */
+
+    case OP_CHAR:
+#ifdef SUPPORT_UTF8
+    if (md->utf8)
+      {
+      length = 1;
+      ecode++;
+      GETCHARLEN(fc, ecode, length);
+      if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+      while (length-- > 0) if (*ecode++ != *eptr++) RRETURN(MATCH_NOMATCH);
+      }
+    else
+#endif
+
+    /* Non-UTF-8 mode */
+      {
+      if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
+      if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
+      ecode += 2;
+      }
+    break;
+
+    /* Match a single character, caselessly */
+
+    case OP_CHARNC:
+#ifdef SUPPORT_UTF8
+    if (md->utf8)
+      {
+      length = 1;
+      ecode++;
+      GETCHARLEN(fc, ecode, length);
+
+      if (length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+
+      /* If the pattern character's value is < 128, we have only one byte, and
+      can use the fast lookup table. */
+
+      if (fc < 128)
+        {
+        if (md->lcc[*ecode++] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+        }
+
+      /* Otherwise we must pick up the subject character */
+
+      else
+        {
+        int dc;
+        GETCHARINC(dc, eptr);
+        ecode += length;
+
+        /* If we have Unicode property support, we can use it to test the other
+        case of the character, if there is one. The result of ucp_findchar() is
+        < 0 if the char isn't found, and othercase is returned as zero if there
+        isn't one. */
+
+        if (fc != dc)
+          {
+#ifdef SUPPORT_UCP
+          int chartype;
+          int othercase;
+          if (ucp_findchar(fc, &chartype, &othercase) < 0 || dc != othercase)
+#endif
+            RRETURN(MATCH_NOMATCH);
+          }
+        }
+      }
+    else
+#endif   /* SUPPORT_UTF8 */
+
+    /* Non-UTF-8 mode */
+      {
+      if (md->end_subject - eptr < 1) RRETURN(MATCH_NOMATCH);
+      if (md->lcc[ecode[1]] != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+      ecode += 2;
+      }
+    break;
+
+    /* Match a single character repeatedly; different opcodes share code. */
+
+    case OP_EXACT:
+    min = max = GET2(ecode, 1);
+    ecode += 3;
+    goto REPEATCHAR;
+
+    case OP_UPTO:
+    case OP_MINUPTO:
+    min = 0;
+    max = GET2(ecode, 1);
+    minimize = *ecode == OP_MINUPTO;
+    ecode += 3;
+    goto REPEATCHAR;
+
+    case OP_STAR:
+    case OP_MINSTAR:
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_QUERY:
+    case OP_MINQUERY:
+    c = *ecode++ - OP_STAR;
+    minimize = (c & 1) != 0;
+    min = rep_min[c];                 /* Pick up values from tables; */
+    max = rep_max[c];                 /* zero for max => infinity */
+    if (max == 0) max = INT_MAX;
+
+    /* Common code for all repeated single-character matches. We can give
+    up quickly if there are fewer than the minimum number of characters left in
+    the subject. */
+
+    REPEATCHAR:
+#ifdef SUPPORT_UTF8
+    if (md->utf8)
+      {
+      length = 1;
+      charptr = ecode;
+      GETCHARLEN(fc, ecode, length);
+      if (min * length > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+      ecode += length;
+
+      /* Handle multibyte character matching specially here. There is
+      support for caseless matching if UCP support is present. */
+
+      if (length > 1)
+        {
+        int oclength = 0;
+        uschar occhars[8];
+
+#ifdef SUPPORT_UCP
+        int othercase;
+        int chartype;
+        if ((ims & PCRE_CASELESS) != 0 &&
+             ucp_findchar(fc, &chartype, &othercase) >= 0 &&
+             othercase > 0)
+          oclength = ord2utf8(othercase, occhars);
+#endif  /* SUPPORT_UCP */
+
+        for (i = 1; i <= min; i++)
+          {
+          if (memcmp(eptr, charptr, length) == 0) eptr += length;
+          /* Need braces because of following else */
+          else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
+          else
+            {
+            if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
+            eptr += oclength;
+            }
+          }
+
+        if (min == max) continue;
+
+        if (minimize)
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+            if (memcmp(eptr, charptr, length) == 0) eptr += length;
+            /* Need braces because of following else */
+            else if (oclength == 0) { RRETURN(MATCH_NOMATCH); }
+            else
+              {
+              if (memcmp(eptr, occhars, oclength) != 0) RRETURN(MATCH_NOMATCH);
+              eptr += oclength;
+              }
+            }
+          /* Control never gets here */
+          }
+        else
+          {
+          pp = eptr;
+          for (i = min; i < max; i++)
+            {
+            if (eptr > md->end_subject - length) break;
+            if (memcmp(eptr, charptr, length) == 0) eptr += length;
+            else if (oclength == 0) break;
+            else
+              {
+              if (memcmp(eptr, occhars, oclength) != 0) break;
+              eptr += oclength;
+              }
+            }
+          while (eptr >= pp)
+           {
+           RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+           if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+           eptr -= length;
+           }
+          RRETURN(MATCH_NOMATCH);
+          }
+        /* Control never gets here */
+        }
+
+      /* If the length of a UTF-8 character is 1, we fall through here, and
+      obey the code as for non-UTF-8 characters below, though in this case the
+      value of fc will always be < 128. */
+      }
+    else
+#endif  /* SUPPORT_UTF8 */
+
+    /* When not in UTF-8 mode, load a single-byte character. */
+      {
+      if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+      fc = *ecode++;
+      }
+
+    /* The value of fc at this point is always less than 256, though we may or
+    may not be in UTF-8 mode. The code is duplicated for the caseless and
+    caseful cases, for speed, since matching characters is likely to be quite
+    common. First, ensure the minimum number of matches are present. If min =
+    max, continue at the same level without recursing. Otherwise, if
+    minimizing, keep trying the rest of the expression and advancing one
+    matching character if failing, up to the maximum. Alternatively, if
+    maximizing, find the maximum number of characters and work backwards. */
+
+    DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
+      max, eptr));
+
+    if ((ims & PCRE_CASELESS) != 0)
+      {
+      fc = md->lcc[fc];
+      for (i = 1; i <= min; i++)
+        if (fc != md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+      if (min == max) continue;
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject ||
+              fc != md->lcc[*eptr++])
+            RRETURN(MATCH_NOMATCH);
+          }
+        /* Control never gets here */
+        }
+      else
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          if (eptr >= md->end_subject || fc != md->lcc[*eptr]) break;
+          eptr++;
+          }
+        while (eptr >= pp)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          eptr--;
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          }
+        RRETURN(MATCH_NOMATCH);
+        }
+      /* Control never gets here */
+      }
+
+    /* Caseful comparisons (includes all multi-byte characters) */
+
+    else
+      {
+      for (i = 1; i <= min; i++) if (fc != *eptr++) RRETURN(MATCH_NOMATCH);
+      if (min == max) continue;
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject || fc != *eptr++)
+            RRETURN(MATCH_NOMATCH);
+          }
+        /* Control never gets here */
+        }
+      else
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          if (eptr >= md->end_subject || fc != *eptr) break;
+          eptr++;
+          }
+        while (eptr >= pp)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          eptr--;
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          }
+        RRETURN(MATCH_NOMATCH);
+        }
+      }
+    /* Control never gets here */
+
+    /* Match a negated single one-byte character. The character we are
+    checking can be multibyte. */
+
+    case OP_NOT:
+    if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    GETCHARINCTEST(c, eptr);
+    if ((ims & PCRE_CASELESS) != 0)
+      {
+#ifdef SUPPORT_UTF8
+      if (c < 256)
+#endif
+      c = md->lcc[c];
+      if (md->lcc[*ecode++] == c) RRETURN(MATCH_NOMATCH);
+      }
+    else
+      {
+      if (*ecode++ == c) RRETURN(MATCH_NOMATCH);
+      }
+    break;
+
+    /* Match a negated single one-byte character repeatedly. This is almost a
+    repeat of the code for a repeated single character, but I haven't found a
+    nice way of commoning these up that doesn't require a test of the
+    positive/negative option for each character match. Maybe that wouldn't add
+    very much to the time taken, but character matching *is* what this is all
+    about... */
+
+    case OP_NOTEXACT:
+    min = max = GET2(ecode, 1);
+    ecode += 3;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTUPTO:
+    case OP_NOTMINUPTO:
+    min = 0;
+    max = GET2(ecode, 1);
+    minimize = *ecode == OP_NOTMINUPTO;
+    ecode += 3;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTSTAR:
+    case OP_NOTMINSTAR:
+    case OP_NOTPLUS:
+    case OP_NOTMINPLUS:
+    case OP_NOTQUERY:
+    case OP_NOTMINQUERY:
+    c = *ecode++ - OP_NOTSTAR;
+    minimize = (c & 1) != 0;
+    min = rep_min[c];                 /* Pick up values from tables; */
+    max = rep_max[c];                 /* zero for max => infinity */
+    if (max == 0) max = INT_MAX;
+
+    /* Common code for all repeated single-byte matches. We can give up quickly
+    if there are fewer than the minimum number of bytes left in the
+    subject. */
+
+    REPEATNOTCHAR:
+    if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+    fc = *ecode++;
+
+    /* The code is duplicated for the caseless and caseful cases, for speed,
+    since matching characters is likely to be quite common. First, ensure the
+    minimum number of matches are present. If min = max, continue at the same
+    level without recursing. Otherwise, if minimizing, keep trying the rest of
+    the expression and advancing one matching character if failing, up to the
+    maximum. Alternatively, if maximizing, find the maximum number of
+    characters and work backwards. */
+
+    DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
+      max, eptr));
+
+    if ((ims & PCRE_CASELESS) != 0)
+      {
+      fc = md->lcc[fc];
+
+#ifdef SUPPORT_UTF8
+      /* UTF-8 mode */
+      if (md->utf8)
+        {
+        register int d;
+        for (i = 1; i <= min; i++)
+          {
+          GETCHARINC(d, eptr);
+          if (d < 256) d = md->lcc[d];
+          if (fc == d) RRETURN(MATCH_NOMATCH);
+          }
+        }
+      else
+#endif
+
+      /* Not UTF-8 mode */
+        {
+        for (i = 1; i <= min; i++)
+          if (fc == md->lcc[*eptr++]) RRETURN(MATCH_NOMATCH);
+        }
+
+      if (min == max) continue;
+
+      if (minimize)
+        {
+#ifdef SUPPORT_UTF8
+        /* UTF-8 mode */
+        if (md->utf8)
+          {
+          register int d;
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            GETCHARINC(d, eptr);
+            if (d < 256) d = md->lcc[d];
+            if (fi >= max || eptr >= md->end_subject || fc == d)
+              RRETURN(MATCH_NOMATCH);
+            }
+          }
+        else
+#endif
+        /* Not UTF-8 mode */
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max || eptr >= md->end_subject || fc == md->lcc[*eptr++])
+              RRETURN(MATCH_NOMATCH);
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* Maximize case */
+
+      else
+        {
+        pp = eptr;
+
+#ifdef SUPPORT_UTF8
+        /* UTF-8 mode */
+        if (md->utf8)
+          {
+          register int d;
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(d, eptr, len);
+            if (d < 256) d = md->lcc[d];
+            if (fc == d) break;
+            eptr += len;
+            }
+          for(;;)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (eptr-- == pp) break;        /* Stop if tried at original pos */
+            BACKCHAR(eptr);
+            }
+          }
+        else
+#endif
+        /* Not UTF-8 mode */
+          {
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || fc == md->lcc[*eptr]) break;
+            eptr++;
+            }
+          while (eptr >= pp)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            }
+          }
+
+        RRETURN(MATCH_NOMATCH);
+        }
+      /* Control never gets here */
+      }
+
+    /* Caseful comparisons */
+
+    else
+      {
+#ifdef SUPPORT_UTF8
+      /* UTF-8 mode */
+      if (md->utf8)
+        {
+        register int d;
+        for (i = 1; i <= min; i++)
+          {
+          GETCHARINC(d, eptr);
+          if (fc == d) RRETURN(MATCH_NOMATCH);
+          }
+        }
+      else
+#endif
+      /* Not UTF-8 mode */
+        {
+        for (i = 1; i <= min; i++)
+          if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+        }
+
+      if (min == max) continue;
+
+      if (minimize)
+        {
+#ifdef SUPPORT_UTF8
+        /* UTF-8 mode */
+        if (md->utf8)
+          {
+          register int d;
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            GETCHARINC(d, eptr);
+            if (fi >= max || eptr >= md->end_subject || fc == d)
+              RRETURN(MATCH_NOMATCH);
+            }
+          }
+        else
+#endif
+        /* Not UTF-8 mode */
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max || eptr >= md->end_subject || fc == *eptr++)
+              RRETURN(MATCH_NOMATCH);
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* Maximize case */
+
+      else
+        {
+        pp = eptr;
+
+#ifdef SUPPORT_UTF8
+        /* UTF-8 mode */
+        if (md->utf8)
+          {
+          register int d;
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(d, eptr, len);
+            if (fc == d) break;
+            eptr += len;
+            }
+          for(;;)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (eptr-- == pp) break;        /* Stop if tried at original pos */
+            BACKCHAR(eptr);
+            }
+          }
+        else
+#endif
+        /* Not UTF-8 mode */
+          {
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || fc == *eptr) break;
+            eptr++;
+            }
+          while (eptr >= pp)
+            {
+            RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            }
+          }
+
+        RRETURN(MATCH_NOMATCH);
+        }
+      }
+    /* Control never gets here */
+
+    /* Match a single character type repeatedly; several different opcodes
+    share code. This is very similar to the code for single characters, but we
+    repeat it in the interests of efficiency. */
+
+    case OP_TYPEEXACT:
+    min = max = GET2(ecode, 1);
+    minimize = TRUE;
+    ecode += 3;
+    goto REPEATTYPE;
+
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    min = 0;
+    max = GET2(ecode, 1);
+    minimize = *ecode == OP_TYPEMINUPTO;
+    ecode += 3;
+    goto REPEATTYPE;
+
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    c = *ecode++ - OP_TYPESTAR;
+    minimize = (c & 1) != 0;
+    min = rep_min[c];                 /* Pick up values from tables; */
+    max = rep_max[c];                 /* zero for max => infinity */
+    if (max == 0) max = INT_MAX;
+
+    /* Common code for all repeated single character type matches. Note that
+    in UTF-8 mode, '.' matches a character of any length, but for the other
+    character types, the valid characters are all one-byte long. */
+
+    REPEATTYPE:
+    ctype = *ecode++;      /* Code for the character type */
+
+#ifdef SUPPORT_UCP
+    if (ctype == OP_PROP || ctype == OP_NOTPROP)
+      {
+      prop_fail_result = ctype == OP_NOTPROP;
+      prop_type = *ecode++;
+      if (prop_type >= 128)
+        {
+        prop_test_against = prop_type - 128;
+        prop_test_variable = &prop_category;
+        }
+      else
+        {
+        prop_test_against = prop_type;
+        prop_test_variable = &prop_chartype;
+        }
+      }
+    else prop_type = -1;
+#endif
+
+    /* First, ensure the minimum number of matches are present. Use inline
+    code for maximizing the speed, and do the type test once at the start
+    (i.e. keep it out of the loop). Also we can test that there are at least
+    the minimum number of bytes before we start. This isn't as effective in
+    UTF-8 mode, but it does no harm. Separate the UTF-8 code completely as that
+    is tidier. Also separate the UCP code, which can be the same for both UTF-8
+    and single-bytes. */
+
+    if (min > md->end_subject - eptr) RRETURN(MATCH_NOMATCH);
+    if (min > 0)
+      {
+#ifdef SUPPORT_UCP
+      if (prop_type > 0)
+        {
+        for (i = 1; i <= min; i++)
+          {
+          GETCHARINC(c, eptr);
+          prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+          if ((*prop_test_variable == prop_test_against) == prop_fail_result)
+            RRETURN(MATCH_NOMATCH);
+          }
+        }
+
+      /* Match extended Unicode sequences. We will get here only if the
+      support is in the binary; otherwise a compile-time error occurs. */
+
+      else if (ctype == OP_EXTUNI)
+        {
+        for (i = 1; i <= min; i++)
+          {
+          GETCHARINCTEST(c, eptr);
+          prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+          if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
+          while (eptr < md->end_subject)
+            {
+            int len = 1;
+            if (!md->utf8) c = *eptr; else
+              {
+              GETCHARLEN(c, eptr, len);
+              }
+            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+            if (prop_category != ucp_M) break;
+            eptr += len;
+            }
+          }
+        }
+
+      else
+#endif     /* SUPPORT_UCP */
+
+/* Handle all other cases when the coding is UTF-8 */
+
+#ifdef SUPPORT_UTF8
+      if (md->utf8) switch(ctype)
+        {
+        case OP_ANY:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject ||
+             (*eptr++ == NEWLINE && (ims & PCRE_DOTALL) == 0))
+            RRETURN(MATCH_NOMATCH);
+          while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+          }
+        break;
+
+        case OP_ANYBYTE:
+        eptr += min;
+        break;
+
+        case OP_NOT_DIGIT:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          GETCHARINC(c, eptr);
+          if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
+            RRETURN(MATCH_NOMATCH);
+          }
+        break;
+
+        case OP_DIGIT:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject ||
+             *eptr >= 128 || (md->ctypes[*eptr++] & ctype_digit) == 0)
+            RRETURN(MATCH_NOMATCH);
+          /* No need to skip more bytes - we know it's a 1-byte character */
+          }
+        break;
+
+        case OP_NOT_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject ||
+             (*eptr < 128 && (md->ctypes[*eptr++] & ctype_space) != 0))
+            RRETURN(MATCH_NOMATCH);
+          while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+          }
+        break;
+
+        case OP_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject ||
+             *eptr >= 128 || (md->ctypes[*eptr++] & ctype_space) == 0)
+            RRETURN(MATCH_NOMATCH);
+          /* No need to skip more bytes - we know it's a 1-byte character */
+          }
+        break;
+
+        case OP_NOT_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject ||
+             (*eptr < 128 && (md->ctypes[*eptr++] & ctype_word) != 0))
+            RRETURN(MATCH_NOMATCH);
+          while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+          }
+        break;
+
+        case OP_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject ||
+             *eptr >= 128 || (md->ctypes[*eptr++] & ctype_word) == 0)
+            RRETURN(MATCH_NOMATCH);
+          /* No need to skip more bytes - we know it's a 1-byte character */
+          }
+        break;
+
+        default:
+        RRETURN(PCRE_ERROR_INTERNAL);
+        }  /* End switch(ctype) */
+
+      else
+#endif     /* SUPPORT_UTF8 */
+
+      /* Code for the non-UTF-8 case for minimum matching of operators other
+      than OP_PROP and OP_NOTPROP. */
+
+      switch(ctype)
+        {
+        case OP_ANY:
+        if ((ims & PCRE_DOTALL) == 0)
+          {
+          for (i = 1; i <= min; i++)
+            if (*eptr++ == NEWLINE) RRETURN(MATCH_NOMATCH);
+          }
+        else eptr += min;
+        break;
+
+        case OP_ANYBYTE:
+        eptr += min;
+        break;
+
+        case OP_NOT_DIGIT:
+        for (i = 1; i <= min; i++)
+          if ((md->ctypes[*eptr++] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+        break;
+
+        case OP_DIGIT:
+        for (i = 1; i <= min; i++)
+          if ((md->ctypes[*eptr++] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+        break;
+
+        case OP_NOT_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          if ((md->ctypes[*eptr++] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+        break;
+
+        case OP_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          if ((md->ctypes[*eptr++] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+        break;
+
+        case OP_NOT_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          if ((md->ctypes[*eptr++] & ctype_word) != 0)
+            RRETURN(MATCH_NOMATCH);
+        break;
+
+        case OP_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          if ((md->ctypes[*eptr++] & ctype_word) == 0)
+            RRETURN(MATCH_NOMATCH);
+        break;
+
+        default:
+        RRETURN(PCRE_ERROR_INTERNAL);
+        }
+      }
+
+    /* If min = max, continue at the same level without recursing */
+
+    if (min == max) continue;
+
+    /* If minimizing, we have to test the rest of the pattern before each
+    subsequent match. Again, separate the UTF-8 case for speed, and also
+    separate the UCP cases. */
+
+    if (minimize)
+      {
+#ifdef SUPPORT_UCP
+      if (prop_type > 0)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          GETCHARINC(c, eptr);
+          prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+          if ((*prop_test_variable == prop_test_against) == prop_fail_result)
+            RRETURN(MATCH_NOMATCH);
+          }
+        }
+
+      /* Match extended Unicode sequences. We will get here only if the
+      support is in the binary; otherwise a compile-time error occurs. */
+
+      else if (ctype == OP_EXTUNI)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          GETCHARINCTEST(c, eptr);
+          prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+          if (prop_category == ucp_M) RRETURN(MATCH_NOMATCH);
+          while (eptr < md->end_subject)
+            {
+            int len = 1;
+            if (!md->utf8) c = *eptr; else
+              {
+              GETCHARLEN(c, eptr, len);
+              }
+            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+            if (prop_category != ucp_M) break;
+            eptr += len;
+            }
+          }
+        }
+
+      else
+#endif     /* SUPPORT_UCP */
+
+#ifdef SUPPORT_UTF8
+      /* UTF-8 mode */
+      if (md->utf8)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+
+          GETCHARINC(c, eptr);
+          switch(ctype)
+            {
+            case OP_ANY:
+            if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_ANYBYTE:
+            break;
+
+            case OP_NOT_DIGIT:
+            if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_DIGIT:
+            if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WHITESPACE:
+            if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WHITESPACE:
+            if  (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WORDCHAR:
+            if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WORDCHAR:
+            if (c >= 256 && (md->ctypes[c] & ctype_word) == 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            default:
+            RRETURN(PCRE_ERROR_INTERNAL);
+            }
+          }
+        }
+      else
+#endif
+      /* Not UTF-8 mode */
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max || eptr >= md->end_subject) RRETURN(MATCH_NOMATCH);
+          c = *eptr++;
+          switch(ctype)
+            {
+            case OP_ANY:
+            if ((ims & PCRE_DOTALL) == 0 && c == NEWLINE) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_ANYBYTE:
+            break;
+
+            case OP_NOT_DIGIT:
+            if ((md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_DIGIT:
+            if ((md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WHITESPACE:
+            if ((md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WHITESPACE:
+            if  ((md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WORDCHAR:
+            if ((md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WORDCHAR:
+            if ((md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            default:
+            RRETURN(PCRE_ERROR_INTERNAL);
+            }
+          }
+        }
+      /* Control never gets here */
+      }
+
+    /* If maximizing it is worth using inline code for speed, doing the type
+    test once at the start (i.e. keep it out of the loop). Again, keep the
+    UTF-8 and UCP stuff separate. */
+
+    else
+      {
+      pp = eptr;  /* Remember where we started */
+
+#ifdef SUPPORT_UCP
+      if (prop_type > 0)
+        {
+        for (i = min; i < max; i++)
+          {
+          int len = 1;
+          if (eptr >= md->end_subject) break;
+          GETCHARLEN(c, eptr, len);
+          prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+          if ((*prop_test_variable == prop_test_against) == prop_fail_result)
+            break;
+          eptr+= len;
+          }
+
+        /* eptr is now past the end of the maximum run */
+
+        for(;;)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (eptr-- == pp) break;        /* Stop if tried at original pos */
+          BACKCHAR(eptr);
+          }
+        }
+
+      /* Match extended Unicode sequences. We will get here only if the
+      support is in the binary; otherwise a compile-time error occurs. */
+
+      else if (ctype == OP_EXTUNI)
+        {
+        for (i = min; i < max; i++)
+          {
+          if (eptr >= md->end_subject) break;
+          GETCHARINCTEST(c, eptr);
+          prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+          if (prop_category == ucp_M) break;
+          while (eptr < md->end_subject)
+            {
+            int len = 1;
+            if (!md->utf8) c = *eptr; else
+              {
+              GETCHARLEN(c, eptr, len);
+              }
+            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+            if (prop_category != ucp_M) break;
+            eptr += len;
+            }
+          }
+
+        /* eptr is now past the end of the maximum run */
+
+        for(;;)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (eptr-- == pp) break;        /* Stop if tried at original pos */
+          for (;;)                        /* Move back over one extended */
+            {
+            int len = 1;
+            BACKCHAR(eptr);
+            if (!md->utf8) c = *eptr; else
+              {
+              GETCHARLEN(c, eptr, len);
+              }
+            prop_category = ucp_findchar(c, &prop_chartype, &prop_othercase);
+            if (prop_category != ucp_M) break;
+            eptr--;
+            }
+          }
+        }
+
+      else
+#endif   /* SUPPORT_UCP */
+
+#ifdef SUPPORT_UTF8
+      /* UTF-8 mode */
+
+      if (md->utf8)
+        {
+        switch(ctype)
+          {
+          case OP_ANY:
+
+          /* Special code is required for UTF8, but when the maximum is unlimited
+          we don't need it, so we repeat the non-UTF8 code. This is probably
+          worth it, because .* is quite a common idiom. */
+
+          if (max < INT_MAX)
+            {
+            if ((ims & PCRE_DOTALL) == 0)
+              {
+              for (i = min; i < max; i++)
+                {
+                if (eptr >= md->end_subject || *eptr == NEWLINE) break;
+                eptr++;
+                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+                }
+              }
+            else
+              {
+              for (i = min; i < max; i++)
+                {
+                eptr++;
+                while (eptr < md->end_subject && (*eptr & 0xc0) == 0x80) eptr++;
+                }
+              }
+            }
+
+          /* Handle unlimited UTF-8 repeat */
+
+          else
+            {
+            if ((ims & PCRE_DOTALL) == 0)
+              {
+              for (i = min; i < max; i++)
+                {
+                if (eptr >= md->end_subject || *eptr == NEWLINE) break;
+                eptr++;
+                }
+              break;
+              }
+            else
+              {
+              c = max - min;
+              if (c > md->end_subject - eptr) c = md->end_subject - eptr;
+              eptr += c;
+              }
+            }
+          break;
+
+          /* The byte case is the same as non-UTF8 */
+
+          case OP_ANYBYTE:
+          c = max - min;
+          if (c > md->end_subject - eptr) c = md->end_subject - eptr;
+          eptr += c;
+          break;
+
+          case OP_NOT_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_NOT_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_NOT_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject) break;
+            GETCHARLEN(c, eptr, len);
+            if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
+            eptr+= len;
+            }
+          break;
+
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+
+        /* eptr is now past the end of the maximum run */
+
+        for(;;)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (eptr-- == pp) break;        /* Stop if tried at original pos */
+          BACKCHAR(eptr);
+          }
+        }
+      else
+#endif
+
+      /* Not UTF-8 mode */
+        {
+        switch(ctype)
+          {
+          case OP_ANY:
+          if ((ims & PCRE_DOTALL) == 0)
+            {
+            for (i = min; i < max; i++)
+              {
+              if (eptr >= md->end_subject || *eptr == NEWLINE) break;
+              eptr++;
+              }
+            break;
+            }
+          /* For DOTALL case, fall through and treat as \C */
+
+          case OP_ANYBYTE:
+          c = max - min;
+          if (c > md->end_subject - eptr) c = md->end_subject - eptr;
+          eptr += c;
+          break;
+
+          case OP_NOT_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) != 0)
+              break;
+            eptr++;
+            }
+          break;
+
+          case OP_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_digit) == 0)
+              break;
+            eptr++;
+            }
+          break;
+
+          case OP_NOT_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) != 0)
+              break;
+            eptr++;
+            }
+          break;
+
+          case OP_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_space) == 0)
+              break;
+            eptr++;
+            }
+          break;
+
+          case OP_NOT_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) != 0)
+              break;
+            eptr++;
+            }
+          break;
+
+          case OP_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject || (md->ctypes[*eptr] & ctype_word) == 0)
+              break;
+            eptr++;
+            }
+          break;
+
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+
+        /* eptr is now past the end of the maximum run */
+
+        while (eptr >= pp)
+          {
+          RMATCH(rrc, eptr, ecode, offset_top, md, ims, eptrb, 0);
+          eptr--;
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          }
+        }
+
+      /* Get here if we can't make it match with any permitted repetitions */
+
+      RRETURN(MATCH_NOMATCH);
+      }
+    /* Control never gets here */
+
+    /* There's been some horrible disaster. Since all codes > OP_BRA are
+    for capturing brackets, and there shouldn't be any gaps between 0 and
+    OP_BRA, arrival here can only mean there is something seriously wrong
+    in the code above or the OP_xxx definitions. */
+
+    default:
+    DPRINTF(("Unknown opcode %d\n", *ecode));
+    RRETURN(PCRE_ERROR_UNKNOWN_NODE);
+    }
+
+  /* Do not stick any code in here without much thought; it is assumed
+  that "continue" in the code above comes out to here to repeat the main
+  loop. */
+
+  }             /* End of main loop */
+/* Control never reaches here */
+}
+
+
+/***************************************************************************
+****************************************************************************
+                   RECURSION IN THE match() FUNCTION
+
+Undefine all the macros that were defined above to handle this. */
+
+#ifdef NO_RECURSE
+#undef eptr
+#undef ecode
+#undef offset_top
+#undef ims
+#undef eptrb
+#undef flags
+
+#undef callpat
+#undef charptr
+#undef data
+#undef next
+#undef pp
+#undef prev
+#undef saved_eptr
+
+#undef new_recursive
+
+#undef cur_is_word
+#undef condition
+#undef minimize
+#undef prev_is_word
+
+#undef original_ims
+
+#undef ctype
+#undef length
+#undef max
+#undef min
+#undef number
+#undef offset
+#undef op
+#undef save_capture_last
+#undef save_offset1
+#undef save_offset2
+#undef save_offset3
+#undef stacksave
+
+#undef newptrb
+
+#endif
+
+/* These two are defined as macros in both cases */
+
+#undef fc
+#undef fi
+
+/***************************************************************************
+***************************************************************************/
+
+
+
+/*************************************************
+*         Execute a Regular Expression           *
+*************************************************/
+
+/* This function applies a compiled re to a subject string and picks out
+portions of the string if it matches. Two elements in the vector are set for
+each substring: the offsets to the start and end of the substring.
+
+Arguments:
+  argument_re     points to the compiled expression
+  extra_data      points to extra data or is NULL
+  subject         points to the subject string
+  length          length of subject string (may contain binary zeros)
+  start_offset    where to start in the subject string
+  options         option bits
+  offsets         points to a vector of ints to be filled in with offsets
+  offsetcount     the number of elements in the vector
+
+Returns:          > 0 => success; value is the number of elements filled in
+                  = 0 => success, but offsets is not big enough
+                   -1 => failed to match
+                 < -1 => some kind of unexpected problem
+*/
+
+EXPORT int
+pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
+  const char *subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount)
+{
+int rc, resetcount, ocount;
+int first_byte = -1;
+int req_byte = -1;
+int req_byte2 = -1;
+unsigned long int ims = 0;
+BOOL using_temporary_offsets = FALSE;
+BOOL anchored;
+BOOL startline;
+BOOL first_byte_caseless = FALSE;
+BOOL req_byte_caseless = FALSE;
+match_data match_block;
+const uschar *tables;
+const uschar *start_bits = NULL;
+const uschar *start_match = (const uschar *)subject + start_offset;
+const uschar *end_subject;
+const uschar *req_byte_ptr = start_match - 1;
+
+pcre_study_data internal_study;
+const pcre_study_data *study;
+
+real_pcre internal_re;
+const real_pcre *external_re = (const real_pcre *)argument_re;
+const real_pcre *re = external_re;
+
+/* Plausibility checks */
+
+if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
+if (re == NULL || subject == NULL ||
+   (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
+if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
+
+/* Fish out the optional data from the extra_data structure, first setting
+the default values. */
+
+study = NULL;
+match_block.match_limit = MATCH_LIMIT;
+match_block.callout_data = NULL;
+
+/* The table pointer is always in native byte order. */
+
+tables = external_re->tables;
+
+if (extra_data != NULL)
+  {
+  register unsigned int flags = extra_data->flags;
+  if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
+    study = (const pcre_study_data *)extra_data->study_data;
+  if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
+    match_block.match_limit = extra_data->match_limit;
+  if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
+    match_block.callout_data = extra_data->callout_data;
+  if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
+  }
+
+/* If the exec call supplied NULL for tables, use the inbuilt ones. This
+is a feature that makes it possible to save compiled regex and re-use them
+in other programs later. */
+
+if (tables == NULL) tables = pcre_default_tables;
+
+/* Check that the first field in the block is the magic number. If it is not,
+test for a regex that was compiled on a host of opposite endianness. If this is
+the case, flipped values are put in internal_re and internal_study if there was
+study data too. */
+
+if (re->magic_number != MAGIC_NUMBER)
+  {
+  re = try_flipped(re, &internal_re, study, &internal_study);
+  if (re == NULL) return PCRE_ERROR_BADMAGIC;
+  if (study != NULL) study = &internal_study;
+  }
+
+/* Set up other data */
+
+anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
+startline = (re->options & PCRE_STARTLINE) != 0;
+
+/* The code starts after the real_pcre block and the capture name table. */
+
+match_block.start_code = (const uschar *)external_re + re->name_table_offset +
+  re->name_count * re->name_entry_size;
+
+match_block.start_subject = (const uschar *)subject;
+match_block.start_offset = start_offset;
+match_block.end_subject = match_block.start_subject + length;
+end_subject = match_block.end_subject;
+
+match_block.endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
+match_block.utf8 = (re->options & PCRE_UTF8) != 0;
+
+match_block.notbol = (options & PCRE_NOTBOL) != 0;
+match_block.noteol = (options & PCRE_NOTEOL) != 0;
+match_block.notempty = (options & PCRE_NOTEMPTY) != 0;
+match_block.partial = (options & PCRE_PARTIAL) != 0;
+match_block.hitend = FALSE;
+
+match_block.recursive = NULL;                   /* No recursion at top level */
+
+match_block.lcc = tables + lcc_offset;
+match_block.ctypes = tables + ctypes_offset;
+
+/* Partial matching is supported only for a restricted set of regexes at the
+moment. */
+
+if (match_block.partial && (re->options & PCRE_NOPARTIAL) != 0)
+  return PCRE_ERROR_BADPARTIAL;
+
+/* Check a UTF-8 string if required. Unfortunately there's no way of passing
+back the character offset. */
+
+#ifdef SUPPORT_UTF8
+if (match_block.utf8 && (options & PCRE_NO_UTF8_CHECK) == 0)
+  {
+  if (valid_utf8((uschar *)subject, length) >= 0)
+    return PCRE_ERROR_BADUTF8;
+  if (start_offset > 0 && start_offset < length)
+    {
+    int tb = ((uschar *)subject)[start_offset];
+    if (tb > 127)
+      {
+      tb &= 0xc0;
+      if (tb != 0 && tb != 0xc0) return PCRE_ERROR_BADUTF8_OFFSET;
+      }
+    }
+  }
+#endif
+
+/* The ims options can vary during the matching as a result of the presence
+of (?ims) items in the pattern. They are kept in a local variable so that
+restoring at the exit of a group is easy. */
+
+ims = re->options & (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL);
+
+/* If the expression has got more back references than the offsets supplied can
+hold, we get a temporary chunk of working store to use during the matching.
+Otherwise, we can use the vector supplied, rounding down its size to a multiple
+of 3. */
+
+ocount = offsetcount - (offsetcount % 3);
+
+if (re->top_backref > 0 && re->top_backref >= ocount/3)
+  {
+  ocount = re->top_backref * 3 + 3;
+  match_block.offset_vector = (int *)(pcre_malloc)(ocount * sizeof(int));
+  if (match_block.offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
+  using_temporary_offsets = TRUE;
+  DPRINTF(("Got memory to hold back references\n"));
+  }
+else match_block.offset_vector = offsets;
+
+match_block.offset_end = ocount;
+match_block.offset_max = (2*ocount)/3;
+match_block.offset_overflow = FALSE;
+match_block.capture_last = -1;
+
+/* Compute the minimum number of offsets that we need to reset each time. Doing
+this makes a huge difference to execution time when there aren't many brackets
+in the pattern. */
+
+resetcount = 2 + re->top_bracket * 2;
+if (resetcount > offsetcount) resetcount = ocount;
+
+/* Reset the working variable associated with each extraction. These should
+never be used unless previously set, but they get saved and restored, and so we
+initialize them to avoid reading uninitialized locations. */
+
+if (match_block.offset_vector != NULL)
+  {
+  register int *iptr = match_block.offset_vector + ocount;
+  register int *iend = iptr - resetcount/2 + 1;
+  while (--iptr >= iend) *iptr = -1;
+  }
+
+/* Set up the first character to match, if available. The first_byte value is
+never set for an anchored regular expression, but the anchoring may be forced
+at run time, so we have to test for anchoring. The first char may be unset for
+an unanchored pattern, of course. If there's no first char and the pattern was
+studied, there may be a bitmap of possible first characters. */
+
+if (!anchored)
+  {
+  if ((re->options & PCRE_FIRSTSET) != 0)
+    {
+    first_byte = re->first_byte & 255;
+    if ((first_byte_caseless = ((re->first_byte & REQ_CASELESS) != 0)) == TRUE)
+      first_byte = match_block.lcc[first_byte];
+    }
+  else
+    if (!startline && study != NULL &&
+      (study->options & PCRE_STUDY_MAPPED) != 0)
+        start_bits = study->start_bits;
+  }
+
+/* For anchored or unanchored matches, there may be a "last known required
+character" set. */
+
+if ((re->options & PCRE_REQCHSET) != 0)
+  {
+  req_byte = re->req_byte & 255;
+  req_byte_caseless = (re->req_byte & REQ_CASELESS) != 0;
+  req_byte2 = (tables + fcc_offset)[req_byte];  /* case flipped */
+  }
+
+/* Loop for handling unanchored repeated matching attempts; for anchored regexs
+the loop runs just once. */
+
+do
+  {
+  /* Reset the maximum number of extractions we might see. */
+
+  if (match_block.offset_vector != NULL)
+    {
+    register int *iptr = match_block.offset_vector;
+    register int *iend = iptr + resetcount;
+    while (iptr < iend) *iptr++ = -1;
+    }
+
+  /* Advance to a unique first char if possible */
+
+  if (first_byte >= 0)
+    {
+    if (first_byte_caseless)
+      while (start_match < end_subject &&
+             match_block.lcc[*start_match] != first_byte)
+        start_match++;
+    else
+      while (start_match < end_subject && *start_match != first_byte)
+        start_match++;
+    }
+
+  /* Or to just after \n for a multiline match if possible */
+
+  else if (startline)
+    {
+    if (start_match > match_block.start_subject + start_offset)
+      {
+      while (start_match < end_subject && start_match[-1] != NEWLINE)
+        start_match++;
+      }
+    }
+
+  /* Or to a non-unique first char after study */
+
+  else if (start_bits != NULL)
+    {
+    while (start_match < end_subject)
+      {
+      register unsigned int c = *start_match;
+      if ((start_bits[c/8] & (1 << (c&7))) == 0) start_match++; else break;
+      }
+    }
+
+#ifdef DEBUG  /* Sigh. Some compilers never learn. */
+  printf(">>>> Match against: ");
+  pchars(start_match, end_subject - start_match, TRUE, &match_block);
+  printf("\n");
+#endif
+
+  /* If req_byte is set, we know that that character must appear in the subject
+  for the match to succeed. If the first character is set, req_byte must be
+  later in the subject; otherwise the test starts at the match point. This
+  optimization can save a huge amount of backtracking in patterns with nested
+  unlimited repeats that aren't going to match. Writing separate code for
+  cased/caseless versions makes it go faster, as does using an autoincrement
+  and backing off on a match.
+
+  HOWEVER: when the subject string is very, very long, searching to its end can
+  take a long time, and give bad performance on quite ordinary patterns. This
+  showed up when somebody was matching /^C/ on a 32-megabyte string... so we
+  don't do this when the string is sufficiently long.
+
+  ALSO: this processing is disabled when partial matching is requested.
+  */
+
+  if (req_byte >= 0 &&
+      end_subject - start_match < REQ_BYTE_MAX &&
+      !match_block.partial)
+    {
+    register const uschar *p = start_match + ((first_byte >= 0)? 1 : 0);
+
+    /* We don't need to repeat the search if we haven't yet reached the
+    place we found it at last time. */
+
+    if (p > req_byte_ptr)
+      {
+      if (req_byte_caseless)
+        {
+        while (p < end_subject)
+          {
+          register int pp = *p++;
+          if (pp == req_byte || pp == req_byte2) { p--; break; }
+          }
+        }
+      else
+        {
+        while (p < end_subject)
+          {
+          if (*p++ == req_byte) { p--; break; }
+          }
+        }
+
+      /* If we can't find the required character, break the matching loop */
+
+      if (p >= end_subject) break;
+
+      /* If we have found the required character, save the point where we
+      found it, so that we don't search again next time round the loop if
+      the start hasn't passed this character yet. */
+
+      req_byte_ptr = p;
+      }
+    }
+
+  /* When a match occurs, substrings will be set for all internal extractions;
+  we just need to set up the whole thing as substring 0 before returning. If
+  there were too many extractions, set the return code to zero. In the case
+  where we had to get some local store to hold offsets for backreferences, copy
+  those back references that we can. In this case there need not be overflow
+  if certain parts of the pattern were not used. */
+
+  match_block.start_match = start_match;
+  match_block.match_call_count = 0;
+
+  rc = match(start_match, match_block.start_code, 2, &match_block, ims, NULL,
+    match_isgroup);
+
+  if (rc == MATCH_NOMATCH)
+    {
+    start_match++;
+#ifdef SUPPORT_UTF8
+    if (match_block.utf8)
+      while(start_match < end_subject && (*start_match & 0xc0) == 0x80)
+        start_match++;
+#endif
+    continue;
+    }
+
+  if (rc != MATCH_MATCH)
+    {
+    DPRINTF((">>>> error: returning %d\n", rc));
+    return rc;
+    }
+
+  /* We have a match! Copy the offset information from temporary store if
+  necessary */
+
+  if (using_temporary_offsets)
+    {
+    if (offsetcount >= 4)
+      {
+      memcpy(offsets + 2, match_block.offset_vector + 2,
+        (offsetcount - 2) * sizeof(int));
+      DPRINTF(("Copied offsets from temporary memory\n"));
+      }
+    if (match_block.end_offset_top > offsetcount)
+      match_block.offset_overflow = TRUE;
+
+    DPRINTF(("Freeing temporary memory\n"));
+    (pcre_free)(match_block.offset_vector);
+    }
+
+  rc = match_block.offset_overflow? 0 : match_block.end_offset_top/2;
+
+  if (offsetcount < 2) rc = 0; else
+    {
+    offsets[0] = start_match - match_block.start_subject;
+    offsets[1] = match_block.end_match_ptr - match_block.start_subject;
+    }
+
+  DPRINTF((">>>> returning %d\n", rc));
+  return rc;
+  }
+
+/* This "while" is the end of the "do" above */
+
+while (!anchored && start_match <= end_subject);
+
+if (using_temporary_offsets)
+  {
+  DPRINTF(("Freeing temporary memory\n"));
+  (pcre_free)(match_block.offset_vector);
+  }
+
+if (match_block.partial && match_block.hitend)
+  {
+  DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
+  return PCRE_ERROR_PARTIAL;
+  }
+else
+  {
+  DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
+  return PCRE_ERROR_NOMATCH;
+  }
+}
+
+/* End of pcre.c */
diff --git a/pcre.h b/pcre.h
new file mode 100644
index 0000000..ee5bf16
--- /dev/null
+++ b/pcre.h
@@ -0,0 +1,239 @@
+/*************************************************
+*       Perl-Compatible Regular Expressions      *
+*************************************************/
+
+/* In its original form, this is the .in file that is transformed by
+"configure" into pcre.h.
+
+           Copyright (c) 1997-2004 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef _PCRE_H
+#define _PCRE_H
+
+/* The file pcre.h is build by "configure". Do not edit it; instead
+make changes to pcre.in. */
+
+#define PCRE_MAJOR          5
+#define PCRE_MINOR          0
+#define PCRE_DATE           13-Sep-2004
+
+/* Win32 uses DLL by default */
+
+#ifdef _WIN32
+#  ifdef PCRE_DEFINITION
+#    ifdef DLL_EXPORT
+#      define PCRE_DATA_SCOPE __declspec(dllexport)
+#    endif
+#  else
+#    ifndef PCRE_STATIC
+#      define PCRE_DATA_SCOPE extern __declspec(dllimport)
+#    endif
+#  endif
+#endif
+#ifndef PCRE_DATA_SCOPE
+#  define PCRE_DATA_SCOPE     extern
+#endif
+
+/* Have to include stdlib.h in order to ensure that size_t is defined;
+it is needed here for malloc. */
+
+#include <stdlib.h>
+
+/* Allow for C++ users */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Options */
+
+#define PCRE_CASELESS           0x0001
+#define PCRE_MULTILINE          0x0002
+#define PCRE_DOTALL             0x0004
+#define PCRE_EXTENDED           0x0008
+#define PCRE_ANCHORED           0x0010
+#define PCRE_DOLLAR_ENDONLY     0x0020
+#define PCRE_EXTRA              0x0040
+#define PCRE_NOTBOL             0x0080
+#define PCRE_NOTEOL             0x0100
+#define PCRE_UNGREEDY           0x0200
+#define PCRE_NOTEMPTY           0x0400
+#define PCRE_UTF8               0x0800
+#define PCRE_NO_AUTO_CAPTURE    0x1000
+#define PCRE_NO_UTF8_CHECK      0x2000
+#define PCRE_AUTO_CALLOUT       0x4000
+#define PCRE_PARTIAL            0x8000
+
+/* Exec-time and get/set-time error codes */
+
+#define PCRE_ERROR_NOMATCH         (-1)
+#define PCRE_ERROR_NULL            (-2)
+#define PCRE_ERROR_BADOPTION       (-3)
+#define PCRE_ERROR_BADMAGIC        (-4)
+#define PCRE_ERROR_UNKNOWN_NODE    (-5)
+#define PCRE_ERROR_NOMEMORY        (-6)
+#define PCRE_ERROR_NOSUBSTRING     (-7)
+#define PCRE_ERROR_MATCHLIMIT      (-8)
+#define PCRE_ERROR_CALLOUT         (-9)  /* Never used by PCRE itself */
+#define PCRE_ERROR_BADUTF8        (-10)
+#define PCRE_ERROR_BADUTF8_OFFSET (-11)
+#define PCRE_ERROR_PARTIAL        (-12)
+#define PCRE_ERROR_BADPARTIAL     (-13)
+#define PCRE_ERROR_INTERNAL       (-14)
+#define PCRE_ERROR_BADCOUNT       (-15)
+
+/* Request types for pcre_fullinfo() */
+
+#define PCRE_INFO_OPTIONS            0
+#define PCRE_INFO_SIZE               1
+#define PCRE_INFO_CAPTURECOUNT       2
+#define PCRE_INFO_BACKREFMAX         3
+#define PCRE_INFO_FIRSTBYTE          4
+#define PCRE_INFO_FIRSTCHAR          4  /* For backwards compatibility */
+#define PCRE_INFO_FIRSTTABLE         5
+#define PCRE_INFO_LASTLITERAL        6
+#define PCRE_INFO_NAMEENTRYSIZE      7
+#define PCRE_INFO_NAMECOUNT          8
+#define PCRE_INFO_NAMETABLE          9
+#define PCRE_INFO_STUDYSIZE         10
+#define PCRE_INFO_DEFAULT_TABLES    11
+
+/* Request types for pcre_config() */
+
+#define PCRE_CONFIG_UTF8                    0
+#define PCRE_CONFIG_NEWLINE                 1
+#define PCRE_CONFIG_LINK_SIZE               2
+#define PCRE_CONFIG_POSIX_MALLOC_THRESHOLD  3
+#define PCRE_CONFIG_MATCH_LIMIT             4
+#define PCRE_CONFIG_STACKRECURSE            5
+#define PCRE_CONFIG_UNICODE_PROPERTIES      6
+
+/* Bit flags for the pcre_extra structure */
+
+#define PCRE_EXTRA_STUDY_DATA          0x0001
+#define PCRE_EXTRA_MATCH_LIMIT         0x0002
+#define PCRE_EXTRA_CALLOUT_DATA        0x0004
+#define PCRE_EXTRA_TABLES              0x0008
+
+/* Types */
+
+struct real_pcre;                 /* declaration; the definition is private  */
+typedef struct real_pcre pcre;
+
+/* The structure for passing additional data to pcre_exec(). This is defined in
+such as way as to be extensible. Always add new fields at the end, in order to
+remain compatible. */
+
+typedef struct pcre_extra {
+  unsigned long int flags;        /* Bits for which fields are set */
+  void *study_data;               /* Opaque data from pcre_study() */
+  unsigned long int match_limit;  /* Maximum number of calls to match() */
+  void *callout_data;             /* Data passed back in callouts */
+  const unsigned char *tables;    /* Pointer to character tables */
+} pcre_extra;
+
+/* The structure for passing out data via the pcre_callout_function. We use a
+structure so that new fields can be added on the end in future versions,
+without changing the API of the function, thereby allowing old clients to work
+without modification. */
+
+typedef struct pcre_callout_block {
+  int          version;           /* Identifies version of block */
+  /* ------------------------ Version 0 ------------------------------- */
+  int          callout_number;    /* Number compiled into pattern */
+  int         *offset_vector;     /* The offset vector */
+  const char  *subject;           /* The subject being matched */
+  int          subject_length;    /* The length of the subject */
+  int          start_match;       /* Offset to start of this match attempt */
+  int          current_position;  /* Where we currently are in the subject */
+  int          capture_top;       /* Max current capture */
+  int          capture_last;      /* Most recently closed capture */
+  void        *callout_data;      /* Data passed in with the call */
+  /* ------------------- Added for Version 1 -------------------------- */
+  int          pattern_position;  /* Offset to next item in the pattern */
+  int          next_item_length;  /* Length of next item in the pattern */
+  /* ------------------------------------------------------------------ */
+} pcre_callout_block;
+
+/* Indirection for store get and free functions. These can be set to
+alternative malloc/free functions if required. Special ones are used in the
+non-recursive case for "frames". There is also an optional callout function
+that is triggered by the (?) regex item. Some magic is required for Win32 DLL;
+it is null on other OS. For Virtual Pascal, these have to be different again.
+*/
+
+#ifndef VPCOMPAT
+PCRE_DATA_SCOPE void *(*pcre_malloc)(size_t);
+PCRE_DATA_SCOPE void  (*pcre_free)(void *);
+PCRE_DATA_SCOPE void *(*pcre_stack_malloc)(size_t);
+PCRE_DATA_SCOPE void  (*pcre_stack_free)(void *);
+PCRE_DATA_SCOPE int   (*pcre_callout)(pcre_callout_block *);
+#else   /* VPCOMPAT */
+extern void *pcre_malloc(size_t);
+extern void  pcre_free(void *);
+extern void *pcre_stack_malloc(size_t);
+extern void  pcre_stack_free(void *);
+extern int   pcre_callout(pcre_callout_block *);
+#endif  /* VPCOMPAT */
+
+/* Exported PCRE functions */
+
+extern pcre *pcre_compile(const char *, int, const char **,
+              int *, const unsigned char *);
+extern int  pcre_config(int, void *);
+extern int  pcre_copy_named_substring(const pcre *, const char *,
+              int *, int, const char *, char *, int);
+extern int  pcre_copy_substring(const char *, int *, int, int,
+              char *, int);
+extern int  pcre_exec(const pcre *, const pcre_extra *,
+              const char *, int, int, int, int *, int);
+extern void pcre_free_substring(const char *);
+extern void pcre_free_substring_list(const char **);
+extern int  pcre_fullinfo(const pcre *, const pcre_extra *, int,
+              void *);
+extern int  pcre_get_named_substring(const pcre *, const char *,
+              int *, int,  const char *, const char **);
+extern int  pcre_get_stringnumber(const pcre *, const char *);
+extern int  pcre_get_substring(const char *, int *, int, int,
+              const char **);
+extern int  pcre_get_substring_list(const char *, int *, int,
+              const char ***);
+extern int  pcre_info(const pcre *, int *, int *);
+extern const unsigned char *pcre_maketables(void);
+extern pcre_extra *pcre_study(const pcre *, int, const char **);
+extern const char *pcre_version(void);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif /* End of pcre.h */
diff --git a/primes.h b/primes.h
new file mode 100644
index 0000000..c77be76
--- /dev/null
+++ b/primes.h
@@ -0,0 +1,468 @@
+/* primes.h - table of primitives
+
+    Copyright (C) 2015 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef PRIMES_H
+#define PRIMES_H
+
+PRIMITIVE primitive[] =
+	{
+	/* --------- core ------------------ */
+#ifdef SYMBOL_DEBUG
+	{"dump-symbol",		p_dumpSymbol,	0},
+#endif
+	{"while",		p_while,	2},
+	{"until",		p_until,	2},
+	{"do-while",	p_doWhile,	2},
+	{"do-until",	p_doUntil,	2},
+	{"dotimes",		p_dotimes,	2},
+	{"for",			p_for,		2},
+	{"sequence",	p_sequence,	0},
+	{"series",		p_series,	0},
+	{"doargs",		p_doargs,	2},
+	{"dolist",		p_dolist,	2},
+	{"dostring",	p_dostring, 2},
+	{"dotree",		p_dotree,	2},
+	{"case",		p_case,		2},
+	{"cond",		p_condition,1},
+	{"begin",		p_evalBlock,1}, 
+	{"and",			p_and,		0},
+	{"if",			p_if,		2},
+	{"if-not",		p_ifNot,	2},
+	{"unless",		p_unless,	2},
+	{"when",		p_when, 	2},
+	{"or",			p_or,		0},
+	{"quote",		p_quote,	0},
+	{"silent",		p_silent,	0},
+	{"eval",		p_eval,		0},
+	{"amb",			p_amb,		0},
+	{"catch",		p_catch,	0},
+	{"throw",       p_throw,    0},
+	{"apply",		p_apply,	0},
+	{"curry",		p_curry,	0},
+	{"args",		p_args,		0},
+	{"map",			p_map,		0},
+	{"term",       	p_term, 	0},
+	{"filter",		p_filter,	0},
+	{"clean",		p_clean,	0},
+	{"index",		p_index,	0},
+	{"define",		p_define,	0x402},
+	{"define-macro",	p_defineMacro,	0x402},
+    {"macro",       p_macro,    2},
+	{"expand",		p_expand,	0},
+	{"constant",	p_constant,	0x400},
+	{"global",		p_global,	0},
+	{"set",			p_set,		0x400},
+	{"setf",		p_setf,		0x400},
+	{"setq",		p_setf,		0x400},
+	{"let",			p_let,		0x402},
+	{"local",		p_local,	2},
+	{"letn",		p_letn,		0x002},
+	{"letex",		p_letExpand,0x403},
+	{"first",		p_first,	0},
+	{"flat",		p_flat,		0},
+	{"last",		p_last,		0},
+	{"rest",		p_rest,		0},
+	{"cons",		p_cons,		0},
+	{"append",		p_append,	0},
+	{"extend",		p_extend,	0x400},
+	{"list",		p_list,		0},
+	{"nth",			p_nth,		0},
+	{"ref",			p_ref,		0},
+	{"ref-all",		p_refAll,	0},
+	{"set-ref",		p_setRef,	0x400},
+	{"set-ref-all",	p_setRefAll,0x400},
+	{"select",		p_select,	0},
+	{"collect",		p_collect,	0},
+	{"swap",		p_swap,		0}, 
+	{"slice",		p_slice,	0},
+	{"length",		p_length,	0},
+	{"find",		p_find,		0},
+	{"search",		p_search,	0},
+	{"member",		p_member,	0},
+	{"intersect",	p_intersect,	0},
+	{"difference",	p_difference,	0},
+	{"union",	    p_union,	0},
+	{"unique",		p_unique,	0},
+	{"assoc",		p_assoc,	0},
+	{"lookup",		p_lookup,	0},
+	{"count",		p_count,	0},
+	{"pop-assoc",	p_popAssoc,	0x400},
+	{"replace",		p_replace,	0x400},
+	{"sort",		p_sort,		0x400},
+	{"push",		p_push,		0x400},
+	{"pop",			p_pop,		0x400},
+	{"reverse",		p_reverse,	0x400},
+	{"rotate",		p_rotate,	0x400},
+	{"dup",			p_dup,		0},
+	{"not",			p_not,		0},
+	{"+",			p_add,		0},
+	{"-",			p_subtract,	0},
+	{"*",			p_multiply,	0},
+	{"/",			p_divide,	0},
+	{"%",			p_modulo,	0},
+	{"<",			p_less,	0},
+	{">",			p_greater,	0},
+	{"<=",			p_lessEqual,0},
+	{">=",			p_greaterEqual,0},
+	{"=",			p_equal,	0},
+	{"!=",			p_notEqual,	0},
+	{"++",			p_incrementI,0x400},
+	{"--",			p_decrementI,0x400},
+
+	/* --------- bit ops --------------- */
+	{"<<",			p_shiftLeft,0},
+	{">>",			p_shiftRight,	0},
+	{"&",			p_bitAnd,	0},
+	{"|",			p_bitOr,	0},
+	{"^",			p_bitXor,	0},
+	{"~",			p_bitNot,	0},
+
+	/* --------- math and float ------- */
+	{"inc",		    p_incrementF,0x400},
+	{"dec",		    p_decrementF,0x400},
+	{"add",		    p_addFloat,	0},
+	{"sub",		    p_subFloat,	0},
+	{"mul",		    p_mulFloat,	0},
+	{"div",		    p_divFloat,	0},
+	{"abs",		    p_abs,		0},
+	{"ceil",		p_ceil,     0},
+	{"floor",		p_floor,	0},
+	{"erf",			p_erf,		0},
+	{"sgn",			p_sgn,		0},
+	{"sin",		    p_sin,		0},
+	{"cos",		    p_cos,		0},
+	{"tan",		    p_tan,		0},
+	{"asin",		p_asin,	    0},
+	{"acos",		p_acos,	    0},
+	{"atan",		p_atan,	    0},
+	{"atan2",		p_atan2,	0},
+	{"sinh",		p_sinh,		0},
+	{"cosh",		p_cosh,		0},
+	{"tanh",		p_tanh,		0},
+	{"asinh",		p_asinh,	0},
+	{"acosh",		p_acosh,	0},
+	{"atanh",		p_atanh,	0},
+	{"round",		p_round,	0},
+	{"exp",		    p_exp,		0},
+	{"log",		    p_log,		0},
+	{"sqrt",		p_sqrt,     0},
+	{"ssq",		    p_ssq,      0},
+	{"rand",		p_rand, 	0},
+	{"seed",		p_seed,     0},
+	{"random",      p_random,	0},
+	{"normal",		p_normal,	0},
+	{"randomize",	p_randomize,0},
+	{"encrypt",		p_encrypt,	0},
+	{"min",		    p_minFloat,	0},
+	{"max",		    p_maxFloat,	0},
+	{"pow",		    p_powFloat,	0},
+	{"mod",		    p_modFloat,	0},
+	{"prob-z",		p_probabilityZ, 0},
+	{"prob-chi2",	p_probabilityChi2, 0},
+	{"prob-t",		p_probabilityT, 0},
+	{"prob-f",		p_probabilityF, 0},
+	{"crit-chi2",	p_criticalChi2,	0},
+	{"crit-z",		p_criticalZ,	0},
+	{"crit-t",		p_criticalT,	0},
+	{"crit-f",		p_criticalF,	0},
+	{"fft",		    p_fft,		0},
+	{"ifft",		p_ifft,	        0},
+	{"beta",		p_beta,	        0},
+	{"betai",		p_betai,	0},
+	{"gammaln",		p_gammaln,	0},
+	{"gammai",		p_gammai,	0},
+	{"binomial",	p_binomial,	0},
+	{"factor",	p_factor,	0},
+	{"pmt",         p_pmt,          0},
+	{"pv",          p_pv,           0},
+	{"fv",          p_fv,           0},
+	{"nper",        p_nper,         0},
+	{"npv",         p_npv,          0},
+	{"irr",			p_irr,		0},
+	{"transpose",	p_matTranspose, 0},
+	{"multiply",	p_matMultiply,  0},
+	{"invert",		p_matInvert,    0},
+	{"det",			p_determinant,  0},
+	{"mat",			p_matScalar,		0},
+	{"array",		p_array,	0},
+	{"array-list",	p_arrayList,	0},
+	{"flt",			p_flt,		0},
+	{"bayes-train",	p_bayesTrain,	0},
+	{"bayes-query",	p_bayesQuery,	0},
+#ifdef KMEANS
+    {"kmeans-train",p_kmeansTrain, 0},
+    {"kmeans-query",p_kmeansQuery, 0},
+#endif
+    {"stats",       p_stats,        0},
+    {"t-test",      p_ttest,        0},
+    {"corr",        p_corr,         0},
+	{"unify",		p_unify,		0},
+	{"bind",		p_bind,			0x400},
+	{"uuid",		p_uuid,			0},
+	{"gcd",			p_gcd,			0},
+	
+	/* ------------ string ops ------------- */
+	{"eval-string",	p_evalString,	0},
+#ifdef EMSCRIPTEN
+    {"eval-string-js", p_evalStringJS, 0},
+#endif
+	{"read-expr",	p_readExpr,		0},
+	{"join",		p_join,	        0},
+	{"chop",		p_chop,	        0},
+	{"explode",		p_explode,		0},
+	{"trim",		p_trim,	        0},
+	{"char",		p_char,	        0},
+	{"starts-with",	p_startsWith,	0},
+	{"ends-with",	p_endsWith,	0},
+	{"upper-case",	p_upper,	0},
+	{"lower-case",	p_lower,	0},
+	{"title-case",	p_title,	0},
+	{"format",		p_format,	0},
+	{"match",		p_match,	0},
+	{"regex",		p_regex,	0},
+	{"regex-comp",	p_regexComp,0},
+	{"int",			p_integer,	0},
+	{"integer",		p_integer,	0},
+	{"float",		p_float,	0},
+	{"string",		p_string,	0},
+	{"bits",		p_bits,		0},
+	{"get-float",	p_getFloat,	0},
+	{"get-string",	p_getString,	0},
+	{"get-int",		p_getInteger,	0},
+	{"get-long",	p_getLong,	0},
+	{"get-char",	p_getChar,	0},
+	{"sym",			p_symbol,	0},
+	{"parse",		p_parse,	0},
+	{"pack",		p_pack, 	0},
+	{"unpack",		p_unpack, 	0},
+#ifdef XML_SUPPORT
+	{"xml-parse",	p_XMLparse, 	0},
+	{"xml-error",	p_XMLerror,	0},
+	{"xml-type-tags",   p_XMLtypeTags,  0},
+#endif
+    {"json-parse",  p_JSONparse, 0},
+    {"json-error",  p_JSONerror, 0},
+	{"base64-enc",		p_base64Enc,	0},
+	{"base64-dec",		p_base64Dec,	0},
+	{"crc32",		p_crc32,	0},
+	{"find-all",	p_findAll,	0},
+#ifdef SUPPORT_UTF8
+	{"unicode",		p_unicode,	0},
+	{"utf8",		p_utf8,		0},
+	{"utf8len",		p_utf8len,	0},
+#endif
+
+	/* -------------- I/O ------------------ */
+	{"pretty-print",	p_prettyPrint,	0},
+	{"print",		p_print,	0},
+	{"println",		p_println,	0},
+	{"read-line",	p_readLine,	0},
+	{"write-line",	p_writeLine,	0},
+	{"current-line",p_currentLine,0},
+	{"device",		p_device,	0},
+	{"load",		p_load,		0},
+	{"save",		p_save,		0},
+	{"source",		p_symbolSource,	0},
+	{"open",		p_open,		0},
+	{"seek",		p_seek,		0},
+	{"close",		p_close,	0},
+	{"read-char",	p_readChar,	0},
+#ifdef SUPPORT_UTF8
+	{"read-utf8",	p_readUTF8,	0},
+#endif
+	{"write-char",	p_writeChar,0},
+	{"read-buffer",	p_readBuffer,0x400},
+	{"read",		p_readBuffer,0x400},
+	{"write-buffer",p_writeBuffer,0},
+	{"write",		p_writeBuffer,0},
+	{"write-file",	p_writeFile,0},
+	{"append-file",	p_appendFile,	0},
+	{"read-file",	p_readFile, 0},
+	{"read-key",	p_readKey,	0},
+#ifndef EMSCRIPTEN
+	{"get-url",		p_getUrl,	0},
+	{"put-url",		p_putUrl, 	0},
+	{"post-url",	p_postUrl,	0},
+	{"delete-url",	p_deleteUrl,0},
+	{"destroy",		p_destroyProcess, 0},
+	{"exec",        p_exec,     0},
+	{"process",		p_process,	0},
+	{"pipe",		p_pipe,		0}, 
+#ifndef NO_FORK
+	{"fork",		p_fork,		0},
+	{"wait-pid",	p_waitpid,	0},
+#endif
+#ifndef NO_SPAWN
+	{"spawn",		p_spawn,	0},
+	{"sync",		p_sync,		0},
+	{"abort",		p_abort,	0},
+	{"send",		p_send,		0},
+	{"receive",		p_receive,	0},
+#endif
+#ifndef NO_SHARE
+	{"share",		p_share,	0},
+#endif
+#ifndef NO_SEMAPHORE
+	{"semaphore",	p_semaphore,0},
+#endif
+#ifndef WINDOWS
+	{"peek",		p_peek,		0},
+#endif
+
+#endif /* ifndef EMSCRIPTEN */
+
+	
+	/* ---------  system --------- */
+	{"set-locale",		p_setLocale,	0},
+	{"for-all",		p_forAll,	0},
+	{"exists",		p_exists,	0},
+	{"symbols",		p_symbols,	0},
+	{"exit",		p_exit,		0},
+#ifdef DEBUGGER
+	{"debug",		p_debug,	0},
+	{"trace-highlight", 	p_traceHighlight,0},
+#endif
+	{"trace",		p_trace,	0},
+	{"reset",		p_reset,	0},
+	{"throw-error",	p_throwError,	0},
+	{"error-event",	p_errorEvent,	0},
+	{"prompt-event",p_promptEvent,	0},
+	{"command-event", p_commandEvent, 0},
+	{"xfer-event", 	p_transferEvent, 0},
+	{"reader-event", 	p_readerEvent, 0},
+	{"last-error", 	p_lastError, 0},
+#ifndef EMSCRIPTEN
+#ifndef NO_SIGNAL
+	{"signal",		p_signal,	0},
+#endif
+#endif
+	{"sys-info",	p_systemInfo,	0},
+	{"sys-error",	p_systemError,	0},
+	{"!",			p_system,	0},
+	{"file-info",	p_fileInfo,	0},
+	{"copy",		p_copy,	0},
+	{"copy-file",	p_copyFile,	0},
+	{"rename-file",	p_renameFile,	0},
+	{"delete-file",	p_deleteFile,	0},
+	{"make-dir",	p_makeDir,	0},
+	{"remove-dir",	p_removeDir,	0},
+	{"change-dir",	p_changeDir,	0},
+	{"directory",	p_directory,	0},
+	{"real-path",	p_realpath,		0},
+	{"main-args",	p_mainArgs,	0},
+	{"env",			p_env,		0},
+	{"context",		p_context,	0},
+	{":",			p_colon,	0},
+	{"self",		p_self,		0},
+	{"prefix",		p_prefix,	0},
+	{"default",		p_default,	0},
+#ifndef EMSCRIPTEN
+	{"timer",       p_timerEvent,	0},
+	{"import",		p_importLib,	0},
+	{"callback",	p_callback,		0},
+#ifdef FFI
+    {"struct",      p_struct,       0},
+#endif
+#endif /* ifndef EMSCRIPTEN */
+	{"delete",		p_deleteSymbol,	0},
+	{"new",			p_new,		0},
+	{"def-new",		p_defineNew,	0},
+	{"address",		p_address,	0},
+	{"dump",		p_dump,	        0},
+	{"cpymem",		p_copyMemory,	0},
+	{"sleep",		p_sleep,	0},
+	{"$",			p_systemSymbol, 0},
+
+    /* --------- predicates ------ */
+	{"nil?",		p_isNil,	0},
+	{"true?",		p_isTrue,	0},
+	{"NaN?",		p_isnan,	0},
+	{"inf?",		p_isinf,	0},
+	{"integer?",	p_isInteger,	0},
+#ifdef BIGINT
+	{"bigint?",	p_isBigInteger,	0},
+	{"bigint",	    p_bigInt,	0},
+#endif
+	{"float?",		p_isFloat,	0},
+	{"number?",		p_isNumber,	0},
+	{"string?",		p_isString,	0},
+	{"symbol?",		p_isSymbol,	0},
+	{"legal?",		p_isLegal,	0},
+	{"context?",	p_isContext,	0},
+	{"primitive?",	p_isPrimitive,	0},
+	{"atom?",		p_isAtom,	0},
+	{"quote?",		p_isQuote,	0},
+	{"list?",		p_isList,	0},
+	{"lambda?",		p_isLambda,	0},
+	{"macro?",		p_isMacro,	0},
+	{"array?",		p_isArray,	0},
+	{"empty?",		p_isEmpty,	0},
+	{"null?",		p_isNull,	0},
+	{"zero?",		p_isZero,	0},
+	{"file?",		p_isFile,	0},
+	{"directory?",	p_isDirectory,	0},
+	{"global?",		p_isGlobal,	0},
+	{"protected?",	p_isProtected,	0},
+	{"odd?",	    p_isOdd,	0},
+	{"even?",	    p_isEven,	0},
+
+	/* ------------ date and time --------- */
+	{"date",		p_date,		0},
+	{"time",		p_time,	        0},
+	{"time-of-day",	p_timeOfDay,    0},
+	{"now",			p_now,			0},
+#ifndef WINDOWS
+	{"date-parse",	p_dateParse,	0},
+	{"parse-date",	p_dateParse,	0},
+#endif
+	{"date-list",	p_dateList,		0},
+	{"date-value",  p_dateValue,	0},
+
+	/* ------------ net working ------------ */
+#ifndef EMSCRIPTEN
+	{"net-close",		p_netClose,	0},
+	{"net-service",		p_netService,	0},
+	{"net-connect",		p_netConnect,	0},
+	{"net-accept",		p_netAccept,	0},
+	{"net-local",		p_netLocal,	0},
+	{"net-peer",		p_netPeer,	0},
+	{"net-ipv",			p_netIpv,	0},
+	{"net-lookup",		p_netLookup,	0},
+	{"net-receive",		p_netReceive,	0x400},
+	{"net-receive-from",p_netReceiveFrom,0},
+	{"net-receive-udp",	p_netReceiveUDP,0},
+	{"net-send",		p_netSend,	0},
+	{"net-send-to",		p_netSendTo,	0},
+	{"net-send-udp",	p_netSendUDP,	0},
+	{"net-listen",		p_netListen,	0},
+#ifndef WINDOWS
+	{"net-packet",		p_netPacket,	0},
+	{"net-ping",		p_netPing,	0},
+#endif
+	{"net-peek",		p_netPeek,	0},
+	{"net-select",		p_netSelect,	0},
+	{"net-sessions",	p_netSessions,	0},
+	{"net-eval",		p_netEval,	0},
+	{"net-interface",	p_netInterface, 0},
+ 	{"net-error",		p_netLastError,	0},
+#endif
+	{NULL,NULL,0},
+};
+
+#endif /* PRIMES_H */
diff --git a/protos.h b/protos.h
new file mode 100644
index 0000000..f5f1b30
--- /dev/null
+++ b/protos.h
@@ -0,0 +1,730 @@
+/* protos.h function prototypes fo6 newLISP
+
+    Copyright (C) 2015 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef PROTOS_H
+#define PROTOS_H
+CELL * addResult(CELL * * result, CELL * cell, CELL * newCell);
+CELL * appendArray(CELL * cell, CELL * params);
+CELL * appendNode(CELL * node, CELL * newNode);
+CELL * appendString(CELL * cell, CELL * params, char * joint, size_t jointLen, int trailJoint, int evalFlag);
+CELL * appendWriteFile(CELL * params, char * type);
+CELL * arithmetikOp(CELL * params, int operand);
+CELL * arrayList(CELL * params, int flag);
+CELL * arrayTranspose(CELL * params);
+CELL * assignSymbol(SYMBOL * sPtr, CELL * content);
+CELL * associationsFromTree(SYMBOL * context);
+CELL * bindList(CELL * list, int flag);
+CELL * compareOp(CELL * params, int operand);
+CELL * copyCell(CELL * cell);
+CELL * copyList(CELL * cell);
+CELL * defineOrMacro(CELL * params, UINT type, int flags);
+CELL * p_deleteFile(CELL * params);
+CELL * dolist(CELL * params, int argsFlag);
+CELL * environment(void);
+CELL * errorProc(int errorNumber);
+CELL * errorProcArgs(int errorNumber, CELL * expr);
+CELL * errorProcExt(int errorNumber, CELL * expr);
+CELL * errorProcExt2(int errorNumber, CELL * expr);
+CELL * evalCheckSymbol(CELL * cell);
+CELL * evaluateBlock(CELL * cell);
+CELL * evaluateExpression(CELL * cell);
+CELL * evaluateExpressionSafe(CELL * cell, int * errNo);
+CELL * evaluateLambda(CELL * lambda, CELL * arg, SYMBOL * newContext);
+CELL * evaluateLambdaMacro(CELL * macro, CELL * arg, SYMBOL * newContext);
+CELL * evaluateNamespaceHash(CELL * args, SYMBOL * newContext);
+CELL * evaluateStream(STREAM * stream, UINT printDevice, int flag);
+CELL * executeLibfunction(CELL * pcell, CELL * params);
+#ifdef FFI
+CELL * executeLibFFI(CELL * pcell, CELL * params);
+#endif
+CELL * expand(CELL * expr, SYMBOL * symbol);
+CELL * explodeList(CELL * list, CELL * params);
+CELL * floatOp(CELL * params, int operand);
+CELL * functionFloat(CELL * params, int operand);
+CELL * getCell(int type);
+CELL * getFloat(CELL * params, double * floatNumber);
+CELL * getInteger(CELL * params, UINT * number);
+CELL * getInteger64Ext(CELL * params, INT64 * number, int evalFlag);
+CELL * getIntegerExt(CELL * params, UINT * number, int evalFlag);
+CELL * getListHead(CELL * params, CELL * * list);
+CELL * getEvalDefault(CELL * params, CELL * * result);
+CELL * getListSpec(CELL * params, CELL * * result, int setFlag);
+CELL * getPutPostDeleteUrl(char * url, CELL * params, int type, int timeout);
+CELL * getServicePort(CELL * params, int * portNo, char * protocol);
+CELL * getString(CELL * params, char * * stringPtr);
+CELL * getStringSize(CELL * params, char * * stringPtr, size_t * size, int evalFlag);
+CELL * getSymbol(CELL * params, SYMBOL * * symbol);
+CELL * getContext(CELL * params, SYMBOL * * context);
+CELL * ifUnless(CELL * params, int ifUnlessFlag);
+CELL * incDecF(CELL * params, int type);
+CELL * incDecI(CELL * params, int type);
+CELL * initIteratorIndex(void);
+CELL * isType(CELL * params, int operand);
+CELL * isEmptyFunc(CELL * params);
+CELL * loop(CELL * params, int flag);
+CELL * implicitIndexArray(CELL * cell, CELL * params);
+CELL * implicitIndexList (CELL * list, CELL * params);
+CELL * implicitNrestSlice(CELL * num, CELL * params);
+CELL * implicitIndexString(CELL * cell, CELL * params);
+CELL * initArray(CELL * array, CELL * list, CELL * * next);
+CELL * loadFile(char * fileName, UINT offset, int encryptFlag, SYMBOL * context);
+CELL * makeArray(ssize_t * index, int p);
+CELL * makeCell(int type, UINT contents);
+CELL * makeCellFromStream(STREAM * stream);
+CELL * makeStringCell(char * contents, size_t size);
+CELL * makePair(CELL * left, CELL * right);
+CELL * makeElementNode(CELL * tagNode, CELL * attributesNode, CELL * childrenNode);
+CELL * makeTextNode(int type, CELL * contents);
+CELL * matScalar(CELL * params, char type);
+CELL * mpdArithmetik(CELL * num, CELL * params, int op);
+CELL * netError(int errorNo);
+CELL * netPeerLocal(CELL * params, int peerLocalFlag);
+#ifdef FFI
+CELL * packFFIstruct(CELL * cell, CELL * params);
+CELL * unpackFFIstruct(CELL * cell, char * data);
+#endif
+CELL* parseRegexOptions(CELL* params, UINT * options, int evalFlag);
+CELL * setEvent(CELL * params, SYMBOL * * eventSymPtr, char * sysSymName);
+CELL * setNthStr(CELL * cellStr, CELL * new, char * insertPtr);
+CELL * subarray(CELL * array, ssize_t offset, ssize_t length);
+CELL * transposeArray(CELL * array);
+CELL * p_JSONparse(CELL * params);
+CELL * p_JSONerror(CELL * params);
+CELL * p_XMLerror(CELL * params);
+CELL * p_XMLparse(CELL * params);
+CELL * p_XMLtypeTags(CELL * params);
+CELL * p_abort(CELL * params);
+CELL * p_abs(CELL * params);
+CELL * p_acos(CELL * params);
+CELL * p_add(CELL * params);
+CELL * p_addFloat(CELL * params);
+CELL * p_address(CELL * params);
+CELL * p_amb(CELL * params);
+CELL * p_and(CELL * params);
+CELL * p_append(CELL * params);
+CELL * p_appendFile(CELL * params);
+CELL * p_apply(CELL * params);
+CELL * p_args(CELL * params);
+CELL * p_array(CELL * params);
+CELL * p_arrayList(CELL * params);
+CELL * p_asin(CELL * params);
+CELL * p_asinh(CELL * params);
+CELL * p_assoc(CELL * params);
+CELL * p_atan(CELL * params);
+CELL * p_atan2(CELL * params);
+CELL * p_atanh(CELL * params);
+CELL * p_base64Enc(CELL * params);
+CELL * p_base64Dec(CELL * params);
+CELL * p_bayesTrain(CELL * params);
+CELL * p_bayesQuery(CELL * params);
+CELL * p_kmeansTrain(CELL * params);
+CELL * p_kmeansQuery(CELL * params);
+CELL * p_beta(CELL * params);
+CELL * p_betai(CELL * params);
+CELL * p_bind(CELL * params);
+CELL * p_binomial(CELL * params);
+CELL * p_bits(CELL * params);
+CELL * p_bitAnd(CELL * params);
+CELL * p_bitNot(CELL * params);
+CELL * p_bitOr(CELL * params);
+CELL * p_bitXor(CELL * params);
+CELL * p_callback(CELL * params);
+CELL * p_case(CELL * params);
+CELL * p_catch(CELL * params);
+CELL * p_ceil(CELL * params);
+CELL * p_changeDir(CELL * params);
+CELL * p_char(CELL * params);
+CELL * p_chop(CELL * params);
+CELL * p_clean(CELL * params);
+CELL * p_close(CELL * params);
+CELL * p_collect(CELL * params);
+CELL * p_colon(CELL * params);
+CELL * p_commandEvent(CELL * params);
+CELL * p_continue(CELL * params);
+CELL * p_condition(CELL * params);
+CELL * p_cons(CELL * params);
+CELL * p_constant(CELL * params);
+CELL * p_context(CELL * params);
+CELL * p_copy(CELL * params);
+CELL * p_copyFile(CELL * params);
+CELL * p_copyMemory(CELL * params);
+CELL * p_corr(CELL * params);
+CELL * p_cos(CELL * params);
+CELL * p_cosh(CELL * params);
+CELL * p_acosh(CELL * params);
+CELL * p_count(CELL * params);
+CELL * p_crc32(CELL * params);
+CELL * p_criticalChi2(CELL  * params);
+CELL * p_criticalZ(CELL * params);
+CELL * p_criticalT(CELL * params);
+CELL * p_criticalF(CELL * params);
+CELL * p_currentLine(CELL * params);
+CELL * p_curry(CELL * params);
+CELL * p_date(CELL * params);
+CELL * p_dateList(CELL * params);
+CELL * p_dateParse(CELL * params);
+CELL * p_dateValue(CELL * params);
+CELL * p_debug(CELL * params);
+CELL * p_decrementF(CELL * params);
+CELL * p_decrementI(CELL * params);
+CELL * p_default(CELL * params);
+CELL * p_define(CELL * params);
+CELL * p_defineMacro(CELL * params);
+CELL * p_defineNew(CELL * params);
+CELL * p_deleteSymbol(CELL * params);
+CELL * p_destroyProcess(CELL * params);
+CELL * p_determinant(CELL * params);
+CELL * p_device(CELL * params);
+CELL * p_difference(CELL * params);
+CELL * p_union(CELL * params);
+CELL * p_directory(CELL * params);
+CELL * p_divFloat(CELL * params);
+CELL * p_divide(CELL * params);
+CELL * p_doargs(CELL * params);
+CELL * p_dolist(CELL * params);
+CELL * p_dostring(CELL * params);
+CELL * p_dotimes(CELL * params);
+CELL * p_dotree(CELL * params);
+CELL * p_doWhile(CELL * params);
+CELL * p_doUntil(CELL * params);
+CELL * p_dump(CELL * params);
+CELL * p_dumpSymbol(CELL* params);
+CELL * p_dup(CELL * params);
+CELL * p_encrypt(CELL * params);
+CELL * p_endsWith(CELL * params);
+CELL * p_env(CELL * params);
+CELL * p_equal(CELL * params);
+CELL * p_erf(CELL * params);
+CELL * p_errorEvent(CELL * params);
+CELL * p_lastError(CELL * params);
+/*
+CELL * p_errorNumber(CELL * params);
+CELL * p_errorText(CELL * params);
+*/
+CELL * p_eval(CELL * params);
+CELL * p_evalBlock(CELL * params);
+CELL * p_evalString(CELL * params);
+#ifdef EMSCRIPTEN
+CELL * p_evalStringJS(CELL * params);
+#endif
+CELL * p_exec(CELL * params);
+CELL * p_exists(CELL * params);
+CELL * p_exit(CELL * params);
+CELL * p_exp(CELL * params);
+CELL * p_expand(CELL * params);
+CELL * p_explode(CELL * params);
+CELL * p_extend(CELL * params);
+CELL * p_factor(CELL * params);
+CELL * p_fft(CELL * params);
+CELL * p_fileInfo(CELL * params);
+CELL * p_filter(CELL * params);
+CELL * p_find(CELL * params);
+CELL * p_findAll(CELL * params);
+CELL * p_first(CELL * params);
+CELL * p_flat(CELL * params);
+CELL * p_float(CELL * params);
+CELL * p_flt(CELL * params);
+CELL * p_floor(CELL * params);
+CELL * p_for(CELL * params);
+CELL * p_forAll(CELL * params);
+CELL * p_fork(CELL * params);
+CELL * p_format(CELL * params);
+CELL * p_fv(CELL * params);
+CELL * p_gammai(CELL * params);
+CELL * p_gammaln(CELL * params);
+CELL * p_gcd(CELL * params);
+CELL * p_getChar(CELL * params);
+CELL * p_getFloat(CELL * params);
+CELL * p_getInteger(CELL * params);
+CELL * p_getLong(CELL * params);
+CELL * p_getString(CELL * params);
+CELL * p_getUrl(CELL * params);
+CELL * p_getenv(CELL * params);
+CELL * p_global(CELL * params);
+CELL * p_greater(CELL * params);
+CELL * p_greaterEqual(CELL * params);
+CELL * p_if(CELL * params);
+CELL * p_ifNot(CELL * params);
+CELL * p_ifft(CELL * params);
+CELL * p_importLib(CELL * params);
+CELL * p_incrementF(CELL * params);
+CELL * p_incrementI(CELL * params);
+CELL * p_index(CELL * params);
+CELL * p_integer(CELL * params);
+CELL * p_intersect(CELL * params);
+CELL * p_irr(CELL * params);
+CELL * p_isAtom(CELL * params);
+CELL * p_isContext(CELL * params);
+CELL * p_isEven(CELL * params);
+CELL * p_isGlobal(CELL * params);
+CELL * p_isNil(CELL * params);
+CELL * p_isNull(CELL * params);
+CELL * p_isNumber(CELL * params);
+CELL * p_isOdd(CELL * params);
+CELL * p_isProtected(CELL * params);
+CELL * p_isTrue(CELL * params);
+CELL * p_isZero(CELL * params);
+CELL * p_isDirectory(CELL * params);
+CELL * p_isEmpty(CELL * params);
+CELL * p_isFile(CELL * params);
+CELL * p_isFloat(CELL * params);
+CELL * p_isInteger(CELL * params);
+CELL * p_isBigInteger(CELL * params);
+CELL * p_isLambda(CELL * params);
+CELL * p_isLegal(CELL * params);
+CELL * p_isList(CELL * params);
+CELL * p_isMacro(CELL * params);
+CELL * p_isArray(CELL * params);
+CELL * p_isPrimitive(CELL * params);
+CELL * p_isQuote(CELL * params);
+CELL * p_isString(CELL * params);
+CELL * p_isSymbol(CELL * params);
+CELL * p_isinf(CELL * params);
+CELL * p_isnan(CELL * params);
+CELL * p_join(CELL * params);
+CELL * p_last(CELL * params);
+CELL * p_length(CELL * params);
+CELL * p_less(CELL * params);
+CELL * p_lessEqual(CELL * params);
+CELL * p_let(CELL * params);
+CELL * p_letn(CELL * params);
+CELL * p_letExpand(CELL * params);
+CELL * p_list(CELL * params);
+CELL * p_load(CELL * params);
+CELL * p_local(CELL * params);
+CELL * p_log(CELL * params);
+CELL * p_lookup(CELL * params);
+CELL * p_lower(CELL * params);
+CELL * p_macro(CELL * params);
+CELL * p_mainArgs(CELL * params);
+CELL * p_makeDir(CELL * params);
+CELL * p_map(CELL * params);
+CELL * p_matScalar(CELL * params);
+CELL * p_matInvert(CELL * params);
+CELL * p_matMultiply(CELL * params);
+CELL * p_matTranspose(CELL * params);
+CELL * p_match(CELL * params);
+CELL * p_maxFloat(CELL * params);
+CELL * p_member(CELL * params);
+CELL * p_minFloat(CELL * params);
+CELL * p_modFloat(CELL * params);
+CELL * p_modulo(CELL * params);
+CELL * p_mulFloat(CELL * params);
+CELL * p_multiply(CELL * params);
+CELL * p_netAccept(CELL * params);
+CELL * p_netClose(CELL * params);
+CELL * p_netConnect(CELL * params);
+CELL * p_netEval(CELL * params);
+CELL * p_netInterface(CELL * params);
+CELL * p_netIpv(CELL * params);
+CELL * p_netLastError(CELL * params);
+CELL * p_netListen(CELL * params);
+CELL * p_netLocal(CELL * params);
+CELL * p_netLookup(CELL * params);
+CELL * p_netPacket(CELL * params);
+CELL * p_netPeek(CELL * params);
+CELL * p_netPeer(CELL * params);
+CELL * p_netPing(CELL * params);
+CELL * p_netReceive(CELL * params);
+CELL * p_netReceiveFrom(CELL * params);
+CELL * p_netReceiveUDP(CELL * params);
+CELL * p_netSelect(CELL * params);
+CELL * p_netSend(CELL * params);
+CELL * p_netSendTo(CELL * params);
+CELL * p_netSendUDP(CELL * params);
+CELL * p_netService(CELL * params);
+CELL * p_netSessions(CELL * params);
+CELL * p_new(CELL * params);
+CELL * p_normal(CELL * params);
+CELL * p_not(CELL * params);
+CELL * p_notEqual(CELL * params);
+CELL * p_now(CELL * params);
+CELL * p_nper(CELL * params);
+CELL * p_npv(CELL * params);
+CELL * p_nth(CELL * params);
+CELL * p_open(CELL * params);
+CELL * p_or(CELL * params);
+CELL * p_pack(CELL * params);
+CELL * p_parse(CELL * params);
+CELL * p_peek(CELL * params);
+CELL * p_pipe(CELL * params);
+CELL * p_pmt(CELL * params);
+CELL * p_pop(CELL * params);
+CELL * p_popAssoc(CELL * params);
+CELL * p_postUrl(CELL * params);
+CELL * p_powFloat(CELL * params);
+CELL * p_prefix(CELL * params);
+CELL * p_prettyPrint(CELL * params);
+CELL * p_print(CELL * params);
+CELL * p_println(CELL * params);
+CELL * p_probabilityChi2(CELL * params);
+CELL * p_probabilityZ(CELL * params);
+CELL * p_probabilityT(CELL * params);
+CELL * p_probabilityF(CELL * params);
+CELL * p_process(CELL * params);
+CELL * p_promptEvent(CELL * params);
+CELL * p_push(CELL * params);
+CELL * p_putUrl(CELL * params);
+CELL * p_deleteUrl(CELL * params);
+CELL * p_pv(CELL * params);
+CELL * p_quote(CELL * params);
+CELL * p_rand(CELL * params);
+CELL * p_random(CELL * params);
+CELL * p_randomize(CELL * params);
+CELL * p_readBuffer(CELL * params);
+CELL * p_readChar(CELL * params);
+CELL * p_readerEvent(CELL * params);
+CELL * p_readUTF8(CELL * params);
+CELL * p_readExpr(CELL * params);
+CELL * p_readFile(CELL * params);
+CELL * p_readKey(CELL * params);
+CELL * p_readLine(CELL * params);
+CELL * p_realpath(CELL * params);
+CELL * p_receive(CELL * params);
+CELL * p_ref(CELL * params);
+CELL * p_refAll(CELL * params);
+CELL * p_regex(CELL * params);
+CELL * p_regexComp(CELL * params);
+CELL * p_remove(CELL * params);
+CELL * p_removeDir(CELL * params);
+CELL * p_renameFile(CELL * params);
+CELL * p_replace(CELL * params);
+CELL * p_replaceAssoc(CELL * params);
+CELL * p_reset(CELL * params);
+CELL * p_rest(CELL * params);
+CELL * p_reverse(CELL * params);
+CELL * p_rotate(CELL * params);
+CELL * p_round(CELL * params);
+CELL * p_save(CELL * params);
+CELL * p_search(CELL * params);
+CELL * p_seed(CELL * params);
+CELL * p_seek(CELL * params);
+CELL * p_select(CELL * params);
+CELL * p_self(CELL * params);
+CELL * p_semaphore(CELL * params);
+CELL * p_send(CELL * params);
+CELL * p_sequence(CELL * params);
+CELL * p_series(CELL * params);
+CELL * p_set(CELL * params);
+CELL * p_setLocale(CELL * params);
+CELL * p_setf(CELL * params);
+CELL * p_setq(CELL * params);
+CELL * p_setRef(CELL * params);
+CELL * p_setRefAll(CELL * params);
+CELL * p_sgn(CELL * params);
+CELL * p_share(CELL * params);
+CELL * p_shiftLeft(CELL * params);
+CELL * p_shiftRight(CELL * params);
+CELL * p_signal(CELL * params);
+CELL * p_silent(CELL * params);
+CELL * p_sin(CELL * params);
+CELL * p_sinh(CELL * params);
+CELL * p_sleep(CELL * params);
+CELL * p_slice(CELL * params);
+CELL * p_sort(CELL * params);
+CELL * p_spawn(CELL * params);
+CELL * p_sqrt(CELL * params);
+CELL * p_ssq(CELL * params);
+CELL * p_startsWith(CELL * params);
+CELL * p_stats(CELL * params);
+CELL * p_string(CELL * params);
+#ifdef FFI
+CELL * p_struct(CELL * params);
+#endif
+CELL * p_subFloat(CELL * params);
+CELL * p_subtract(CELL * params);
+CELL * p_swap(CELL * params);
+CELL * p_symbol(CELL * params);
+CELL * p_symbolSource(CELL * params);
+CELL * p_symbols(CELL * params);
+CELL * p_sync(CELL * params);
+CELL * p_systemSymbol(CELL * params);
+CELL * p_references(CELL * params);
+CELL * p_system(CELL * params);
+CELL * p_systemError(CELL * params);
+CELL * p_systemInfo(CELL * params);
+CELL * p_tan(CELL * params);
+CELL * p_tanh(CELL * params);
+CELL * p_term(CELL* params);
+CELL * p_ttest(CELL * params);
+CELL * p_throw(CELL * params);
+CELL * p_throwError(CELL * params);
+CELL * p_time(CELL * params);
+CELL * p_timeOfDay(CELL * params);
+CELL * p_timerEvent(CELL * params);
+CELL * p_title(CELL * params);
+CELL * p_trace(CELL * params);
+CELL * p_traceHighlight(CELL * params);
+CELL * p_transferEvent(CELL * params);
+CELL * p_trim(CELL * params);
+CELL * p_unique(CELL * params);
+CELL * p_unicode(CELL * params);
+CELL * p_unify(CELL * params);
+CELL * p_unless(CELL * params);
+CELL * p_unpack(CELL * params);
+CELL * p_until(CELL * params);
+CELL * p_upper(CELL * params);
+CELL * p_utf8(CELL * params);
+CELL * p_utf8len(CELL * params);
+CELL * p_uuid(CELL * params);
+CELL * p_waitpid(CELL * params);
+CELL * p_when(CELL * params);
+CELL * p_while(CELL * params);
+CELL * p_writeBuffer(CELL * params);
+CELL * p_writeChar(CELL * params);
+CELL * p_writeFile(CELL * params);
+CELL * p_writeLine(CELL * params);
+CELL * parseAttributes(char * endSrc);
+CELL * parseDoc(void);
+CELL * parseNormalTag(char * endSrc, char * newSrc);
+CELL * parseTag(char * closeTagStr);
+CELL * patternMatchL(CELL * pattern, CELL * list, int flag);
+CELL * patternMatchS(char * pattern, char * string);
+CELL * ping(CELL * address, int timeout, int mode, int count, int option);
+CELL * popString(CELL * str, CELL * params);
+CELL * pushOnString(CELL * newStr, CELL * str, CELL * idx);
+CELL * println(CELL * params, int flag);
+CELL * repeat(CELL * params, int type);
+CELL * setDefine(SYMBOL * symbol, CELL * params, int force);
+CELL * setInterDiff(CELL * params, int mode);
+CELL * setRef(CELL * params, int mode);
+CELL * strUpperLower(CELL * params, int type);
+CELL * stuffFloat(double floatPtr);
+CELL * stuffInteger(UINT contents);
+#ifndef NEWLISP64
+CELL * stuffInteger64(INT64 contents);
+#endif
+CELL * stuffIntegerList(int argc, ...);
+CELL * stuffBigint(char * token);
+CELL * stuffString(char * string);
+CELL * stuffStringN(char * string, int len);
+CELL * stuffSymbol(SYMBOL * sPtr);
+CELL * sublist(CELL * list, ssize_t offset, ssize_t length);
+CELL * substring(char * string, ssize_t slen, ssize_t offset, ssize_t len);
+CELL * sysEvalString(char * str, SYMBOL * context, CELL * proc, int mode);
+CELL * whileUntil(CELL * params, int whileUntilFlag);
+FILE * getIOstream(int handle);
+FILE * serverFD(int port, char * domain, int reconnect);
+FILE * win_fdopen(int handle, const char * mode);
+SYMBOL * createRootContext(char * token);
+SYMBOL * getCreateContext(CELL * params, int eval);
+SYMBOL * getDynamicSymbol(CELL * cell);
+SYMBOL * getSymbolCheckProtected(CELL * params);
+SYMBOL * lookupSymbol(char * token, SYMBOL * context);
+SYMBOL * makeSafeSymbol(CELL * cell, SYMBOL * context, int flag);
+SYMBOL * translateCreateSymbol(char * token, int type, SYMBOL * context, int forceFlag);
+size_t adjustNegativeIndex(ssize_t index, size_t length);
+ssize_t searchBuffer(char * buffer,  size_t length, char * string, size_t size, int caseFlag);
+ssize_t searchBufferRegex(char * string,  size_t offset, char * pattern, size_t length, int options, size_t * len);
+INT64 fileSize(char * pathName);
+char * cellToString(CELL * cell, size_t * size, int quoteFlag);
+char * getFormatType(char * fmt, int * type);
+char * getLocalPath(char * fileUrlName);
+char * netLastError(void);
+char * parsePackFormat(char * format, int * length, int * type);
+char * prompt(void);
+char * readStreamText(STREAM * stream, int * size);
+char * replaceString (char * keyStr, size_t keyLen, char * buff, size_t buffLen, CELL * exprCell, 
+    					UINT * cnt, int options, size_t * newLen);
+#ifdef WINDOWS
+char * win_fgets(char * buffer, int  size, FILE * fPtr);
+char * win_realpath(const char * filepath, char * realpath);
+char * win_getExePath(char *);
+#endif
+
+char * which(char * name, char * path);
+size_t Curl_base64_encode(const char *inp, size_t insize, char **outptr);
+size_t Curl_base64_decode(const char *src, char *dest);
+double getDirectFloat(CELL * param);
+int compareArrays(CELL * left, CELL * right);
+int compareCells(CELL * left, CELL * right);
+int compareFloats(CELL * left, CELL * right);
+int compareFunc(CELL * left, CELL * right, CELL * func);
+int compareLists(CELL * left, CELL * right);
+int compileExpression(STREAM * stream, CELL * cell);
+IO_SESSION * createIOsession(int handle, int family);
+int deleteIOsession(int sock);
+int elmntInList(CELL * elmnt, CELL * listHead);
+int evalHttpRequest(char * command, UINT outDevice);
+int sendHTTPmessage(int status, char * description, char * request);
+int executeHTTPrequest(char * request, int type);
+int executeSymbol(SYMBOL * symbol, CELL * params, CELL * * result);
+int find(char * key, char * source);
+int getFlag(CELL * params);
+int getToken(STREAM * stream, char * token, int * tklen);
+int getRegexOptions(CELL * params);
+int isLegalSymbol(char * symName);
+unsigned short in_cksum(unsigned short * addr, int len);
+int isDir(char * fileName);
+int isFile(char * fileName, int flag);
+int main(int argc, char * argv[]);
+int makeStreamFromFile(STREAM * stream, char * fileName, size_t size, size_t offset);
+int makeStreamFromString(STREAM * stream, char * str);
+int milliSecTime(void);
+INT64 microSecTime(void);
+int my_setenv(const char * varName, const char * varValue, int flag);
+int my_strnicmp(char * s1, char * s2, ssize_t size);
+int my_vasprintf(char * * buffer, const char * format, va_list argptr);
+int netConnect(char * name, int port, int type, int protocol, int ttl);
+int netConnectLocal(char * path);
+int netAccept(int listenSock);
+int netListenLocal(char * name);
+int netListenOrDatagram(int portNo, int type, char * ifAddr, char * mcAddr, int option);
+int openFile(char * fileName, char * accessMode, char * option);
+int process(char * command, int inpipe, int outpipe, int errpipe);
+int semaphore(UINT sem_id, int value, int type);
+int sendall(int sock, char * buffer, int len);
+int sortFunc(const void * left, const void *right);
+int timediff_ms(struct timeval end, struct timeval start);
+int waitPeek(int handle, int microsecs);
+int wait_ready(int sock, INT64 wait, int mode);
+int win_fclose(FILE * fPtr);
+int win_fgetc(FILE * fPtr);
+int win_fprintf(FILE * fPtr, char * dummy, char * buffer);
+int writeFile(char * fileName, char * buffer, size_t size, char * type);
+size_t listlen(CELL * listHead);
+ssize_t convertNegativeOffset(ssize_t offset, CELL * list);
+ssize_t readFile(char * fileName, char * * buffer);
+unsigned int asciiIPtoLong(char *ptr);
+unsigned int update_crc(unsigned int crc, unsigned char *buf, int len);
+
+void * allocMemory(size_t nbytes);
+void * callocMemory(size_t nbytes);
+void * reallocMemory(void * prevPtr, UINT size);
+void addList(CELL * list, CELL * newCell);
+void allocBlock(void);
+void cardioBeat(void);
+void cleanupResults(UINT * from);
+void closeStrStream(STREAM * stream);
+void closeTrace(void);
+void freeCellBlocks();
+void returnBlockMemory(void);
+void collectSymbols(SYMBOL * context, CELL * list);
+void deleteArray(CELL * cell);
+void deleteAndFreeSymbol(SYMBOL * sPtr, int checkReferences);
+void deleteList(CELL * cell);
+void deleteTagStack(void);
+void encryptPad(char * encrypted, char * data, char * key, size_t dataLen, size_t keyLen);
+void executeCommandLine(char * command, UINT outDevice, STREAM * cmdStream);
+void expandExprSymbol(CELL * cell, SYMBOL * sPtr);
+void errorMissingPar(STREAM * stream);
+void fatalError(int errorNumber, CELL * expr, int deleteFlag);
+#ifdef FFI
+void initFFI(void);
+#endif
+void initLocale(void);
+void initStacks(void);
+void initialize(void);
+void initDefaultInAddr(void);
+void linkCell(CELL * left, CELL * right, int linkFlag);
+void makeContextFromSymbol(SYMBOL * symbol, SYMBOL * treePtr);
+void mySleep(int ms);
+void myNanoSleep(int nanosec);
+void openStrStream(STREAM * stream, size_t buffSize, int reopenFlag);
+void openTrace(void);
+void parseClosing(void);
+void parseDTD(void);
+void parseProcessingInstruction(void);
+void prettyPrint(UINT device);
+void printArray(CELL * array, UINT device);
+void printArrayDimensions(CELL * array, UINT device);
+void printCell(CELL * cell, UINT printFlag, UINT device);
+void printErrorMessage(UINT errorNumber, CELL * expr, int deleteFlag);
+void printExpression(CELL * cell, UINT device);
+void printLambda(SYMBOL * sPtr, UINT device);
+void printString(char * str, UINT device, int size);
+void printSymbol(SYMBOL * sPtr, UINT device);
+void printSymbolName(UINT device, SYMBOL * sPtr);
+void printSymbolNameExt(UINT device, SYMBOL * sPtr);
+void protectDefaultSymbol(char * name);
+void purgeSpawnList(int flag);
+void recoverEnvironment(UINT * idx);
+void recoverIteratorIndex(CELL * cellIdx);
+void recoverObjectStack(UINT * idx);
+void relinkCells(void);
+void reset(void);
+void saveContext(SYMBOL * sPtr, UINT device);
+void saveSymbols(SYMBOL * sPtr, UINT device);
+void serializeSymbols(CELL * params, UINT device);
+void setupAllSignals(void);
+void setupServer(int reconnect);
+void setupSignalHandler(int sig, void (* handler)(int));
+void signal_handler(int sig);
+void sigchld_handler(int sig);
+void swapEndian(char * data, int n);
+void traceEntry(CELL * cell, CELL * pCell, CELL * args);
+void traceExit(CELL * result, CELL * cell, CELL * pCell, CELL * args);
+void tracePrint(char * label, CELL * expr);
+void updateCell(CELL * cell, CELL * newCell);
+void varPrintf(UINT device, char *format, ...);
+void writeLog(char * text, int newLine);
+void writeStreamChar(STREAM * stream, char chr);
+void writeStreamStr(STREAM * stream, char * buff, size_t length);
+size_t appendCellString(CELL * cell, char * buffer, size_t size);
+UINT * copyArray(CELL * params);
+UINT64 timediff64_us(struct timeval end, struct timeval start);
+
+#ifdef BIGINT
+int * getBigintSizeDirect(CELL * params, int * * numPtr, int * len);
+int * mulBigint(int * x, int nx, int * y, int ny, int * p, int * n);
+int * divModBigint(int * x, int nx, int * y, int ny, int rmndr, int * n);
+int * addBigint(int * x, int nx, int * y, int ny, int * sm, int * nsm);
+int * subBigint(int * x, int nx, int * y, int ny, int * sm, int * nsm);
+int cmpBigint(int * x, int nx, int * y, int ny);
+int cmpAbsBigint(int * x, int nx, int * y, int ny);
+int * strToBigint(char * str, int len, int * intlen);
+char * bigintToDigits(int * num, int n, int offset, int * slen);
+INT64 bigintToInt64(CELL * cell);
+double bigintCellToFloat(CELL * cell);
+double bigintToAbsFloat(int * num, int n);
+CELL * p_bigInt(CELL * params);
+int * intToBigint(INT64 num, int * len);
+int * floatToBigint(double fnum, int * len);
+int lengthBigint(int * num, int len);
+#endif
+
+#ifdef SUPPORT_UTF8
+int utf8_1st_len(char * utf8str);
+int utf8_wstr(int * unicode, char * utf8str, int maxwc);
+int wstr_utf8(char * utf8str, int * unicode, int maxstr);
+char * utf8_wchar(char * utf8str, int * chr);
+size_t utf8_wlen(char * utf8str, char * limit);
+int wchar_utf8(int cvalue, char *buffer);
+char * utf8_index(char * utf8str, int idx);
+
+#ifdef USE_WIN_UTF16PATH
+WCHAR *ansi_mbcs_to_utf16(const char *);
+char * utf16_to_utf8(const WCHAR *utf16str);
+WCHAR * utf8_to_utf16(const char *utf8str);
+int utf16_to_utf8ptr(const WCHAR *utf16str, char * utf8str, int size) ;
+INT64 fileSize_utf16(char * pathName8);
+char *win_realpath(const char *filepath, char *realpath);
+int	rename_utf16(const char* oldname8, const char* newname8);
+int stat_utf16(const char* filename8, struct stat* buf);
+int chdir_utf16(const char* filename8);
+int open_utf16(const char* filename8, int flags, int mode);
+int mkdir_utf16(const char* filename8);
+int rmdir_utf16(const char* filename8);
+int unlink_utf16(const char* filename8);
+_WDIR * opendir_utf16(const char* dirname8);
+#endif
+#endif
+
+/* eof */
+
+#endif /* PROTOS_H */
diff --git a/qa-comma b/qa-comma
new file mode 100755
index 0000000..60c0989
--- /dev/null
+++ b/qa-comma
@@ -0,0 +1,3661 @@
+#!/usr/bin/env newlisp
+(set 'start-of-qa (time-of-day))
+;;
+;; General test suite testing functioning of all built in primitives.
+;;
+;; use from inside the newlisp-x.x.x/ directory
+;;
+;;   ./newlisp qa-dot
+;;
+;;   or for countries and configurations with decimal 
+;;
+;;   ./newlisp qa-comma (for countries and configurations with decimal , )
+;;
+
+(set (sym "test-:" 'QA) (lambda () true))
+(context 'Lex)  ; predeclare/create context for bayes-train
+(context MAIN)
+
+;;  changed for a locale where the comma ',' is the decimal separator
+;;  instead of the decimal point, i.e. Germany
+;;
+
+;; set a locale which uses the decimal comma
+(setq LOCALE (if (find ostype '("Windows")) "German_Germany.1252" "de_DE.UTF-8"))
+(unless (set-locale LOCALE)
+    (println "Cannot set locale to '" LOCALE "' - must exit")
+    (exit))
+
+(unless (= (last (set-locale)) ",")
+    (println "Cannot set comma locale - must exit")
+    (exit))
+
+(when utf8
+ (set 'unicodelist '(913 914 915 916 937 945 946 947 948 969 32 
+                 1040 1041 1042 1043 1044 1072 1073 1074 1075 1076 13 10))
+ (set 'utf8str (join (map char unicodelist)))
+ (unless (catch (regex-comp (join (map char '(12411 12370 12411 12370)))) 'result)
+	(println "Problem compiling utf-8 regular expressions."))
+)
+
+(define (utf8qa)
+ (if (not (= (length (char 937)) 2)) (QA:failed "UTF-8 char: failed"))
+
+ (if (not (and
+    (= (map char (explode (chop utf8str))) (chop unicodelist)) 
+    (= (map char (explode (chop utf8str 3))) (chop unicodelist 3))
+    (= (map char (explode (chop utf8str 5))) (chop unicodelist 5)))) (QA:failed "UTF-8 chop: failed"))
+
+ (if (not (= (map char (explode utf8str)) unicodelist)) (QA:failed "UTF-8 explode: failed"))
+
+ (if (not (= (map char (explode (upper-case utf8str))) 
+    '(913 914 915 916 937 913 914 915 916 937 32 1040 1041 1042 1043 1044 1040 1041 1042 1043 1044 13 10)))
+    (println "upper-case of UTF8 characters not available - not critical -"))
+
+ (if (not (= (map char (explode (lower-case utf8str))) 
+    '(945 946 947 948 969 945 946 947 948 969 32 1072 1073 1074 1075 1076 1072 1073 1074 1075 1076 13 10)))
+    (println "lower-case of UTF8 characters not available - not critical -"))
+
+ (if (not (= (map char (explode (first utf8str))) '(913))) (QA:failed "UTF-8 first: failed"))
+
+ (if (not (= (map char (explode (last utf8str))) '(10))) (QA:failed "UTF-8 last: failed"))
+
+ (if (not (= (map char (explode (rest utf8str))) 
+    '(914 915 916 937 945 946 947 948 969 32 1040 1041 1042 1043 1044 1072 1073 1074 1075 1076 13 10)))
+    (QA:failed "UTF-8 rest: failed"))
+
+ (if (not (= (map char (explode (first (rest utf8str)))) '(914))) (QA:failed "UTF-8 first, rest: failed"))
+
+ (if (not 
+  (and (= (map char (explode (select utf8str 1 2 3))) '(914 915 916))
+       (= (map char (explode (select utf8str -1 -2 -3))) '(10 13 1076))
+       (= (map char (explode (select utf8str 2 4 6))) '(915 937 946))))
+  (QA:failed "UTF-8 select: failed"))
+
+ (if (not (= (map char (explode (select utf8str '(1 2 3)))) '(914 915 916))) (QA:failed "UTF-8 select: failed"))
+
+ (if (not (and
+    (= (map char (explode (nth 1 utf8str))) '(914))
+    (= (map char (explode (nth -5 utf8str))) '(1074))))
+ (QA:failed "UTF-8 nth: failed"))
+
+
+ (setf (nth 2 utf8str) (char 937))
+
+ (if (not (= (map char (explode utf8str) )
+    '(913 914 937 916 937 945 946 947 948 969 32 1040 1041 1042 1043 1044 1072 1073 1074 1075 1076 13 10)))
+    (QA:failed "UTF-8 set-nth: failed"))
+
+true
+)
+
+
+
+(global 'global-myvar)
+(set 'global-myvar 123)
+
+; testing the default functor
+		
+(define (double:double x) (+ x x))
+
+(define (test-default-functor)
+	(and
+		(= (map double '(1 2 3 4 5)) '(2 4 6 8 10))
+		(= (map 'double '(1 2 3 4 5)) '(2 4 6 8 10))
+		(set 'dflt:dflt '(a b c d e f g))
+		(= (map dflt '(1 2 6)) '(b c g))
+		(set 'i 0 'j -1 'k 6)
+		(= (dflt i) 'a)
+		(= (dflt k) 'g)
+		(= (dflt j) 'g)
+		(set 'ctx dflt)
+		(= (default ctx) dflt:dflt)
+		(= (default dflt) dflt:dflt)
+		(sort (default ctx) >)
+		(= (default dflt) '(g f e d c b a))
+))
+
+(context 'QA)
+
+(define (cleanup)
+  (delete-file "junk")
+  (delete-file "junk2"))
+
+(set 'failed-messages '())
+
+(define (check-case x)
+  (case x 
+   (1 "one") 
+   (2 "two") 
+   (3 "three")))
+
+(define (check-cond x)
+  (cond 
+   ((= x 1) 1) 
+   ((= x 2) 2) 
+   ((= x 3) 3)))
+
+(define (checkqa )
+  (dolist (p (symbols 'MAIN)) 
+   (if (primitive? (eval p)) 
+    (begin 
+     (set 'sm (sym (append "test-" (string p)))) 
+     (if (not (lambda? (eval sm))) 
+      (print sm "\n"))))))
+
+(define-macro (do-args p)
+  (= (args) '(2 "3 4" 5 (x y)))
+  (= (args 3 -1) 'y))	
+
+(define (failed msg)
+;  (println msg)
+  (push msg failed-messages))
+
+(define (file-copy from-file to-file)
+  (set 'in-file (open from-file "read"))
+  (set 'out-file (open to-file "write"))
+  (while (set 'chr (read-char in-file)) 
+   (if (not (= chr 95)) 
+    (write-char out-file chr)))
+  (close in-file)
+  (close out-file))
+
+(define (line-count file)
+  (device (open file "read"))
+  (set 'cnt 0)
+  (while (read-line) 
+   (inc cnt))
+  (close (device))cnt)
+
+(define (myappend x y)
+  (cond 
+   ((= '() x) y) 
+   (true (cons (first x) (myappend (rest x) y)))))
+
+(define (qa )
+  (set 'sm-cnt 0)
+  (dolist (sm (symbols 'MAIN)) 
+   (if (not 
+     (if (and (primitive? (eval sm)) (< sm 'zzzz)) 
+       (begin 
+          (inc sm-cnt (+ (length (term sm)) 1))
+          (if (> sm-cnt 79)
+            (begin
+              (set 'sm-cnt 0)
+              (println)))
+          (print (term sm) " ")
+          (set 'func (eval (sym (append "test-" (string sm)))) )
+          (and (catch (apply func) 'result)  result))
+       true)) 
+     (failed (string " >>>> " sm " failed " result) )))
+  (println))
+
+(define (test-$) (find "a|b" "xtzabc" 0) (= ($ 0) $0))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; test-functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (test-!)
+  (integer? (! "")))
+
+(define (test-!= )
+  (and (not (!= -9223372036854775808 (& -9223372036854775808 -1))) (!= "abc" "ABC")
+   (!= "a" "?")
+   (!= 1,000000001 1)
+   (!= "?" "a")))
+
+(define (test-$)
+	(set '$0 123)
+	(= ($ 0) 123))
+
+(define (test-% )
+  (and
+    (= (% 10 3) 1)
+    (not (catch (%) 'result))))
+
+(define (test-& )
+  (= -9223372036854775808 (& -9223372036854775808 -1)))
+
+(define (test-* )
+  (and
+    (= (* (* 123456789 123456789)) 15241578750190521)
+    (= (*) 1)
+  ))
+
+(define (test-+ )
+  (and
+    (= (+ 999999999999999999 1) 1000000000000000000)
+    (= (+ 9223372036854775807 -9223372036854775808) -1)
+    (= (+ -9223372036854775808 -1) 9223372036854775807) ; wraps around
+    (= (+) 0)
+  ))
+
+(define (test-- )
+  (= (- 100000000 1) 99999999))
+
+(define (test-/ )
+  (= (/ 15241578750190521 123456789) 123456789)
+  (= (/ -10 5) -2))
+
+(define (test-< )
+  (and 
+   (< -9223372036854775808 9223372036854775807)
+   (< "abcdefg" "abcdefgh")
+   (< 1 1,000000001) 
+   (< 1 "a") 
+   (< "a" 'a)
+   (< '(a b) '(b c) '(c d))
+   (not (< '(a b) '(b d) '(b c)))
+   (< '(((a b))) '(((b c))))
+   (< '(a (b c)) '(a (b d)) '(a (b (d))))
+   (< -1)
+   (< -1,23)
+   (not (< "1"))
+   (not (< '()))
+))
+
+(define (test-<< )
+  (= (<< 1 63) -9223372036854775808))
+
+(define (test-<= )
+  (and (<= -2147483648 2147483647) (<= 1 1,00000001)))
+
+(define (test-= )
+  (and (= 1,23456789 1,23456789) 
+       (= 123456789 123456789) 
+       (= 0xFFFFFFFFFFFFFFFF -1)
+       (= 0b1111111111111111111111111111111111111111111111111111111111111111 -1)
+       (= '(1 2 3 (4 5) (a b ("CDEFG" "HIJK") 'u 'v 'w)) 
+          '(1 2 3 (4 5) (a b ("CDEFG" "HIJK") 'u 'v 'w))) 
+       (= "้โไแํ๓๚๑ั๖๒" "้โไแํ๓๚๑ั๖๒")
+       (= '())
+       (= 0)
+       (= "")
+       (not (= 1))
+       (not (= "abc"))
+       (not (= '(1 2 3)))
+))
+
+
+(define (test-> )
+  (and (> 2147483647 -2147483648) (> "abcdefgh" "abcdefg") (> 1,000000001 
+    1) 
+   (> "a" 1) 
+   (> "z" "aaaaa")
+   (> "aaa" "a")
+   (> 'a "a") 
+   (> '(a) 'a)
+   (> 1)
+   (> 1,23)
+   (> "abc")
+   (> '(1 2 3))
+   (not (> ""))
+   (not (> '()))   
+))
+
+(define (test->= )
+  (and (>= 1 0) (>= 1,00000001 1)))
+
+(define (test->> )
+  (= (>> 1073741824 30) 1))
+
+(define (test-NaN? )
+  (and (NaN? (sqrt -1))
+       (set 'NaN (sqrt -1)) 
+       (not (= NaN NaN))
+       (= 1 (+ 1 NaN)) 
+       (= 0 (* 2 NaN)) 
+       (NaN? (add 1 (sqrt -1))) 
+       (NaN? (abs (sqrt -1)))))
+
+(define (test-^ )
+  (= (^ 1431655765 -1431655766) -1))
+
+(define (test-abs )
+  (and (= (abs -1) 1) (= (abs -9,9) 9,9)))
+
+(define (test-acos )
+  (= 0 (acos (cos (acos (cos 0))))))
+
+(define (test-acosh)
+	(= (cosh (acosh 1)) 1))
+
+(define (test-add , l)
+  (and
+    (= (add) 0)
+    (dotimes (x 100) 
+      (push x l))
+    (= 4950 (apply add l))
+))
+
+(define (test-address s)
+  (and
+	(set 's "foo")
+	(= (address s) (last (dump s)))
+	(set 'D:D "foo")
+	(= (address D) (last (dump D:D)))
+))
+
+(define (test-amb)
+	(set 'x (amb 1 2))
+	(or (= x 1) (= x 2)))
+
+(define (test-and )
+  (and (and true true true) (not (and true true nil))))
+
+(define (test-append )
+  (and
+	(= '(1 2 3 4) (append '(1 2) '(3 4)))
+	(= '(1 2 3 4 5) (append '(1 2) '(3) '(4 5)))
+	(= '(1 2 3 4) (append '(1 2) '(3 4) '()))
+	(= '(1 2 3 4 5) (append '(1 2) '(3 4) '() '(5)))
+	(= '(1 2 3 4 5) (append '() '(1 2) '(3 4) '() '(5)))
+	(= '() (append '()) (append '() '()) (append))
+	(= "abcdefg" (append "" "a" "bcd" "" "ef" "g" ""))
+	(= "" (append ""))
+	(set 'A (array 3 2 (sequence 1 6)))
+	(set 'B (array 2 2 (sequence 7 10)))
+	(= (array 5 2 (sequence 1 10)) (append A B))
+	(lambda? (append '(lambda)))
+	; default functor
+	(set 'D:D '(a b c))
+	(= '(a b c a b c a b c) (append D D D))
+))
+
+(define (test-append-file)
+  (append-file "junk" "ABC")
+  (append-file "file://junk" "DEF")
+  (= (read-file "junk") "ABCDEF")
+)
+
+
+(define (test-apply )
+  (and (= (apply + '(1 2)) 3) 
+       (= (apply append '("a" "b" "c")) "abc")
+       (= (apply (fn (x y) (+ x y)) '(3 4)) 7)
+       (= (apply list '(a b c d e f) 2) '(((((a b) c) d) e) f))
+       (= (inc (apply set '(x 123))) 124 x)
+       (= (apply + (array 100 (sequence 1 100))) 
+          (apply + (sequence 1 100)) 
+          (apply + (0 100 (array 100 (sequence 1 100)))))
+))
+
+(define (test-args )
+  (do-args 1 2 "3 4" 5 (x y)))
+
+
+(define (test-array) 
+  (and
+    (= (array-list (array 3 2 (sequence 1 6))) '((1 2) (3 4) (5 6)))
+    (set 'A (array 3 2 (sequence 1 6)))
+    (= (array-list (nth 0 A)) '(1 2))
+    (= (nth '(0 0) A) 1)
+    (= (nth '(2 1) A) 6)
+    (= (nth '(-1 -1) A) 6)
+    (not (catch (nth '(10 10) A)  'result))
+    (not (catch (nth '(-10 -10) A) 'result))
+    (= (nth 0 A) (array 2 '(1 2)))
+    (= (array-list (nth 0 A)) '(1 2))
+    (< (nth 0 A) (nth 1 A))
+    (> (nth 2 A) (nth 1 A))
+    (setf (A 1 0) 1)
+    (= (nth '(1 0) A) 1)
+    (setf (A 1 1) 1)
+    (= (array-list A) '((1 2) (1 1) (5 6)))
+    (< (nth 1 A) (nth 0 A))
+))
+
+(define (test-array-list)
+	(and 
+		(set 'a (array 3 4 (sequence 1 12)))
+		(array? a) 
+		(list? (array-list a))
+		; default functor
+		(set 'D:D (array 3 4 (sequence 1 12)))
+		(array? D:D)
+		(list? (array-list D))
+		(= (array-list D) '((1 2 3 4) (5 6 7 8) (9 10 11 12)))
+))
+
+(define (test-array?) (test-array-list))
+
+(define (test-asin )
+  (= (round (asin (sin (asin (sin 1)))) -9) 1))
+
+(define (test-asinh)
+  (= (round (sinh (asinh 1)) -12) 1))
+
+(define (test-assoc)
+ (and
+	(set 'L '((a 1) (b (c (d 2) (e 3) (e 4))) ("a" 5) ((a) 6)))	
+	(= (assoc 'a L) '(a 1))	
+	(= (assoc 'b L) '(b (c (d 2) (e 3) (e 4))))
+	(= (assoc "a" L) '("a" 5))
+	(= (assoc '((a)) L) '((a) 6))
+
+	(= (assoc '(b c) L) '(c (d 2) (e 3) (e 4)))
+	(= (assoc '(b c d) L) '(d 2))
+	(= (assoc '(b c e) L) '(e 3))
+	; default functor
+	(set 'D:D '((a 1) (b (c (d 2) (e 3) (e 4))) ("a" 5) ((a) 6)))	
+	(= (assoc 'a D) '(a 1))
+))
+
+
+(define (test-atan )
+	(< (sub 1 (atan (tan (atan (tan 1))))) 1e-15))
+
+; old test broke after Mac OS X update to 10.5.2
+;  (= 1 (atan (tan (atan (tan 1)))))
+
+(define (test-atanh)
+	(< (sub (tanh (atanh 0,5)) 0,5) 0,0000000001))
+
+(define (test-atan2 )
+  (= (div (acos 0) (atan 1 1)) 2))
+
+(define (test-atom? )
+  (and (atom? 1) (atom? 1,23) (atom? "hello") (atom? 'x) (atom? nil) (atom? true)))
+
+(define (test-base64-enc)
+  (and
+    (= "" (base64-dec (base64-enc "")))
+    (= "1" (base64-dec (base64-enc "1")))
+    (= "12" (base64-dec (base64-enc "12")))
+    (= "123" (base64-dec (base64-enc "123")))
+    (= "1234" (base64-dec (base64-enc "1234")))
+))
+
+(define (test-base64-dec)
+  (test-base64-enc))
+
+;; context Lex was previously created
+
+(define (test-bayes-train)
+  (and
+    (= (bayes-train '(F F F B B) '(F B B B B) 'Lex) '(5 5))
+    (> 0,001 (apply add (map sub (bayes-query '(F) Lex) '(0,75 0,25))))
+    (> 0,001 (apply add (map sub (bayes-query '(F) Lex true) '(0,75 0,25))))
+    (> 0,001 (apply add (map sub (bayes-query '(F F) Lex) '(0,8251777681 0,1748222319))))
+    (> 0,001 (apply add (map sub (bayes-query '(F F) Lex true) '(0,9 0,1))))
+  )
+)
+
+(define (test-bayes-query) 
+	(set 'Lex:F '(0 0))
+	(set 'Lex:B '(0 0))
+	(set 'Lex:total '(0 0))
+	true)
+
+(define (test-begin )
+  (begin 
+   (set 'x 0) 
+   (inc x) 
+   (inc x) 
+   (= x 2)))
+
+(define (test-beta )
+  (< (abs (sub (beta 1 2) 0,5)) 1e-05))
+
+(define (test-betai )
+  (< (abs (sub (betai 0,5 5 10) 0,910217)) 1e-05))
+
+(define (test-bigint?)
+    (and
+        (bigint? 123456789012345678901234567890)
+        (bigint? 123456789012345678901234567890L)
+        (bigint? 0L)
+        (bigint? 123L)
+        (bigint? (bigint 12345))
+        (bigint? (bigint 12345.678))
+        (bigint? (bigint "12345"))
+        (bigint? (bigint "12345"))
+        (bigint? (bigint "123hello"))
+        (nil? (bigint "hello")) 
+    ))
+
+(define (test-bigint)
+    (and
+        (= 12345L (bigint 12345))
+        (= 12345 (bigint 12345.678))
+        (= 12345 (bigint "12345"))
+))
+
+(define (test-bind)
+	(bind '((a 1) (b "hello") (c (3 4))))
+	(and
+		(= a 1)
+		(= b "hello")
+		(= c '(3 4))
+		(= 7 (bind '((a (+ 3 4))) true))
+	)
+)
+
+(define (test-binomial )
+  (< (sub (binomial 2 1 0,5) 0,5) 1e-09))
+
+(define (test-bits)
+  (and
+	(= (int (bits 0x7fffffffffffffff) 0 2) 0x7fffffffffffffff)
+	(= (int (bits 0x8000000000000000) 0 2) 0x8000000000000000)
+	(= 64 (length (bits 0x8000000000000000)))
+	(= (bits 0) "0")
+	(= (bits 1234) "10011010010")
+	(= (bits 1234 true) '(nil true nil nil true nil true true nil nil true))
+))
+
+(define (test-break )
+  (break true)
+  (= true (break))
+  (not (break nil)))
+
+(define (test-case )
+  (and (= (check-case 1) "one") (= (check-case 2) "two") (= (check-case 
+     9) nil)))
+
+(define (test-callback) true)
+
+(define (test-catch )
+  (and 
+	(catch (+ 3 4) 'result) 
+        (= result 7)
+	(= (catch (+ 3 4)) 7)
+        (= (catch (dotimes (x 100) (if (= x 7) (throw x)))) 7)
+))
+
+(define (test-ceil )
+  (= 2 (ceil 1,5)))
+
+(define (test-change-dir )
+  (make-dir "adir")
+  (change-dir "adir")
+  (change-dir "..")
+  (remove-dir "adir"))
+
+(define (test-char )
+  (and 
+    (= (format "%c" (char "a" 0)) "a") 
+    (= (char "A") 65) (= (char 65) "A")
+    (= (map char (sequence 65 67)) '("A" "B" "C"))
+    (= (char 0) "\000")
+	(set 'D:D "ABCDEFG")
+	(= (char D 0) 65)
+	(= (char D -1) 71)
+	(if utf8
+      (let (s (char 937))
+        (and
+            (= (char s 0 true) 206)
+            (= (char s 1 true) 169)
+            (= (char s -1 true) 169)
+            (= (char s -2 true) 206)
+        )
+	  )
+	  true
+    )
+))
+
+(define (test-chop )
+  (and 
+    (= (chop "newlisp") "newlis") 
+    (= (chop "newlisp" 4) "new")
+	(= (chop "abc" 5) "")
+	(= (chop "abc" -5) "")
+    (= (chop '(a b (c d) e)) '(a b (c d)))
+    (= (chop '(a b (c d) e) 2) '(a b))
+	(set 'D:D "newlisp")
+	(= (chop D) "newlis")
+	(= (chop D 4) "new")
+))
+
+(define (test-clean )
+  (and
+    (= (clean integer? '(1 1,1 2 2,2 3 3,3)) '(1,1 2,2 3,3))
+    (= (clean true? '(a nil b nil c nil)) '(nil nil nil))))
+
+(define (test-close , fno)
+  (and 
+    (set 'fno (open "qa-comma" "read")) 
+    (close fno)))
+
+(define (test-collect)
+    (= (let (x 0) (collect (if (<= (inc x) 5) x))) '(1 2 3 4 5))
+)
+
+(define (test-corr)
+    (< (apply add (map sub (corr '(1 3 5 8 9 9) '(2 2 3 4 6 8)) 
+        '(0,868724789 0,5571847507 0,6187683284 3,507907832 4 0,0247186268))) 0,000000001)
+)
+
+(define (test-crc32)
+    (and
+        (= (crc32 "abcdefghijklmnopqrstuvwxyz") 1277644989)
+        (= (crc32 "HELLO") 3242484790))
+)
+
+(define (test-select-collect )
+  (and
+    (set 'l '(0 1 2 3 4 5 6 7 8 9))
+    (= (select l '()) '())
+    (= (select l 0 9 9 0 1 8 8 1) '(0 9 9 0 1 8 8 1)) 
+    (= (select "2001-09-20" 5 6 8 9 0 1 2 3) "09202001") 
+    (set 'a 0 'b 1 'c 2)
+    (= (select '(w x y z) a b c) '(w x y))
+    (= (select '(w x y z) (inc a) (inc b) (inc c)) '(x y z))
+))
+
+(define (test-command-event) true) /* test interactively */
+
+(define (test-cond )
+  (and 
+      (= (check-cond 1) 1)
+      (= (check-cond 2) 2)
+      (not (check-cond 99)) 
+      (= (cond ((+ 3 4))) 7)
+      (= (cond (nil 1) ('())) '())
+      (= (cond (nil 1) (nil)) nil)
+      (= (cond (nil 1) (true nil)) nil)
+      (= (cond ('())) '())
+      (= (cond (nil 1) ('() 2)) '())
+))
+
+(define (test-cons )
+  (= (myappend '(1 2 3) '(4 5 6)) '(1 2 3 4 5 6))
+)
+
+(define (test-constant )
+  (constant 'cs 123)
+  (= cs 123)
+  (protected? 'cs))
+
+(define (test-context )
+  (and (context 'TEST) (context 'QA)))
+
+(define (test-context? )
+  (and (context? MAIN) (context? QA)))
+
+(define (test-continue)
+	(let (cnt 0)
+		(= 1000 (catch (begin (if (< (inc cnt) 1000) (continue) cnt)))))
+)
+
+(define (test-copy)
+  (and
+	(set 'aList '(a b c))
+	(= (replace 'b (copy aList)) '(a c))
+	(= aList '(a b c))
+	(find-all "12" "12345" (replace "1" (copy $0) "N"))
+	(= (rotate (copy "abcdefg")) "gabcdef")
+))
+
+(define (test-copy-file ) 
+  (and (copy-file "qa-comma" "junk") (delete-file "junk")))
+
+(define (test-cos )
+  (= 1 (cos (acos (cos (acos 1))))))
+
+(define (test-cosh)
+	(= (cosh 1) (div (add (exp 1) (exp -1)) 2)))
+
+(define (test-count )
+  (and (= (count '(1 2) '(2 1 2 1)) '(2 2)) 
+       (= (count '(a b) '(a a b c a b b)) '(3 3))
+       (= (count '(a b c) '()) '(0 0 0))
+  )
+)
+
+(define (test-cpymem)  
+  (set 'from "12345")
+  (set 'to "     ")
+  (cpymem (address from) (address to) 5)
+  (= from to))
+
+(define (test-crit-chi2)
+  (and
+    (< (abs (sub (crit-chi2 (prob-chi2 4,605 2) 2) 4,605)) 0,001)
+    (< (abs (sub (crit-chi2 (prob-chi2 51,805 40) 40) 51,805)) 0,001)
+    (< (abs (sub (crit-chi2 (prob-chi2 9,210 2) 2) 9,210)) 0,001)
+    (< (abs (sub (crit-chi2 (prob-chi2 63,691 40) 40) 63,691)) 0,001)
+))
+
+(define (test-crit-f)
+  (and
+    (< (abs (sub (crit-f (prob-f 6,59 3 4) 3 4) 6,59)) 0,001)
+    (< (abs (sub (crit-f (prob-f 2,79 12 11) 12 11) 2,79)) 0,001)
+    (< (abs (sub (crit-f (prob-f 16,59 3 4) 3 4) 16,59)) 0,001)
+    (< (abs (sub (crit-f (prob-f 4,40 12 11) 12 11) 4,40)) 0,001)
+))
+
+(define (test-crit-t)
+  (and
+    (< (abs (sub (crit-t (prob-t 1,886 2) 2) 1,886)) 0,001)
+    (< (abs (sub (crit-t (prob-t 1,303 40) 40) 1,303)) 0,001)
+    (< (abs (sub (crit-t (prob-t 6,965 2) 2) 6,965)) 0,001)
+    (< (abs (sub (crit-t (prob-t 2,423 40) 40) 2,423)) 0,001)
+))
+
+(define (test-crit-z)
+(for (z -6 6 0,3)
+  (let (flag true)
+    (if (> (abs (sub (crit-z (prob-z z)) z)) 0,0001)
+        (set 'flag nil))
+  flag)
+))
+
+(define (test-current-line , handle)
+  (and
+    (set 'handle (open "qa-comma" "r"))
+    (= (read-line handle) "#!/usr/bin/env newlisp") 
+    (= (current-line) "#!/usr/bin/env newlisp") 
+    (close handle)))
+
+(define (test-curry)
+  (and
+    (= (set 'f (curry + 10)) (lambda ($x) (+ 10 $x)))
+    (= (filter (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+       '((a 10) (a 3) (a 9)))
+    (= (clean (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+       '((b 5) (c 8)))
+    (= (map (curry list 'x) (sequence 1 5))
+       '((x 1) (x 2) (x 3) (x 4) (x 5)))
+))
+
+(define (test-date )
+  (= (date) (date (date-value)) (date (apply date-value (now)))))
+
+(define (test-date-parse)
+	(and
+		(= (date-parse "2007.1.3" "%Y.%m.%d") 1167782400)
+		(= (date-parse "20091014" "%Y%m%d") 1255478400)
+; note that the month name here is in German
+		(= (date-parse "Januar 10, 07" "%B %d, %y") 1168387200)
+))
+
+(define (test-parse-date) (test-date-parse))
+
+(define (test-date-list)
+    (let (value (date-value) vlist (now))
+        (= (apply date-value (date-list value)) value)
+        (= (vlist -4) ((date-list (apply date-value vlist)) -2))
+        (= (date-list 0) '(1970 1 1 0 0 0 1 4))
+    )
+)
+
+(define (test-date-value )
+  (= 0 
+        (date-value 1970 1 1 0 0 0) 
+        (date-value (+ 1970) (+ 1) (+ 1) (+ 0) (+ 0) (+ 0)) 
+        (date-value '(1970 1 1 0 0 0))) )
+
+(define (test-debug )
+  (= (debug (+ 3 4)) 7))
+
+(define (test-dec , x)
+	(test-inc))
+
+(define (test-define , foo)
+  (and 
+	(lambda? (define (foo (x 1) (y 2)) (list x y)))
+    (= (foo) '(1 2))
+	(= (foo 3) '(3 2))
+	(= (foo 3 4) '(3 4))
+	(define (foo (x 10) (y (div x 2))) (list x y))
+	(= (foo) '(10 5))
+	(= (foo 20) '(20 10))
+	(= (foo 3 4) '(3 4))
+))
+
+(define (test-def-new)
+  (and
+    (set 'fooctx:x 123)
+    (new fooctx)
+    (= fooctx:x 123)
+    (set 'barctx:bar 999)
+    (def-new 'barctx:bar)
+    (= bar 999)
+    (def-new 'barctx:bar 'foobar)
+    (= foobar 999)
+    (def-new 'barctx:bar 'foofoo:foo)
+    (= foofoo:foo 999)
+))
+
+
+(define (test-define-macro , foo)
+  (and 
+	(macro? (define-macro (foo (x 1) (y 2)) (list x y)))
+    (= (foo) '(1 2))
+	(= (foo 3) '(3 2))
+	(= (foo 3 4) '(3 4))
+	(define-macro (foo (x 10) (y (div x 2))) (list x y))
+	(= (foo) '(10 5))
+	(= (foo 20) '(20 10))
+	(= (foo 3 4) '(3 4))
+))
+
+(define (test-default)
+	(MAIN:test-default-functor))
+
+(define (test-delete )
+  (and
+    (set 'l (list (sym "xxx")))
+    (not (delete (sym "xxx") true))
+	(delete (sym "xxx")))
+)
+
+
+(define (test-delete-file ) 
+  (and (copy-file "qa-comma" "junk") (delete-file "junk")))
+
+(define (test-delete-url )
+  (= "ERR: HTTP bad formed URL" (delete-url "")))
+
+(define (test-destroy)
+ 	(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+		(set 'pid (fork (dotimes (t 100) (sleep 100))))
+		(set 'pid (process "newlisp"))	)
+	(if (= ostype "Cygwin") (sleep 1000))
+	(destroy pid))
+
+(define (test-det) 
+    (and 
+        (set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+        (<  (sub (det A) -1) 2e-10)
+        (set 'A '((1 2 3) (4 5 6)))
+        (not (catch (det A) 'result))
+        (starts-with result "ERR: wrong dimensions")
+))
+
+(define (test-device , fno)
+  (set 'fno (open "junk" "write"))
+  (device fno)
+  (if (= (device) fno) 
+   (close (device))))
+
+(define (test-difference )
+  (and
+    (= (difference '(2 5 6 0 3 0 2 5) '(1 2 3 3 2 1)) '(5 6 0))
+    (= (difference '(1 5 2 3 2 2 4 5 3 4 5 1) '(3 4) true) '(1 5 2 2 2 5 5 1))
+    (= (difference '(nil nil nil) '()) '(nil))
+    (= (difference '(nil nil nil) '() true) '(nil nil nil))
+  )
+)
+
+(define (test-directory )
+  (or (find "qa-comma" (directory)) (find "QA" (directory))))
+
+(define (test-directory? )
+  (and
+      (directory? ".")
+      (directory? "modules/")
+      (directory? "modules")
+))
+(define (test-div )
+  (and (= 0,1 (div 100000000 1000000000)) 
+       (= (div 1 3) 0,3333333333333333)
+       (= (div 3) 0,3333333333333333)
+))
+
+(define (testdoargs)
+	(local (lst)
+		(doargs (i) (push i lst))
+		lst))
+
+(define (test-doargs)
+	(= (testdoargs 3 2 1) '(1 2 3)))
+
+(define (test-dolist , rList)
+  (and 
+   (dolist (x '(1 2 3 4 5 6 7 8 9)) 
+    (push x rList)) 
+   (= rList '(9 8 7 6 5 4 3 2 1)) 
+   (dolist (x rList) 
+    (pop rList))
+    (dolist (x '(1 2 3 4 5 6 7 8 9) (> x 5))
+	  (push x rList))
+   (= rList '(5 4 3 2 1))
+   (= (local (l) (dolist (e '(1 2 3)) (push $idx l)) l) '(2 1 0))
+   (= (dolist (x '(a b c d e f g)) x) 'g)
+))
+
+(define (test-dostring)
+	(local (r) 
+		(dostring (i "newlisp" (= i 108)) (push  i r)) 
+		(= r '(119 101 110))
+		(= (dostring (c "newlisp") c) 112)
+ 	)
+)
+
+(define (test-dotimes , aList)
+  (dotimes (x 2) 
+   (dotimes (y 2) 
+    (dotimes (z 2) 
+     (push z aList))))
+  (and
+     (= '(1 0 1 0 1 0 1 0) aList)
+     (not (dotimes (x 0) x))
+     (= (dotimes (x 1) x) 0)
+
+     ; dotimes returns nil when ever executed since 8.9.7
+     (not (= (dotimes (x -1) x) 0))
+     (not (= (dotimes (x -1,8) x) 0))
+
+     (= (dotimes (x 1,8) x) 0)
+	 (set 'cnt 0)
+	 (dotimes (x 10 (> x 5)) (inc cnt))
+	 (= cnt 6)
+
+))
+     
+(define (test-dotree )
+  (set 'aList '())
+  (and
+    (= (last (symbols MAIN)) (dotree (p MAIN) p))
+  	(dotree (x 'MAIN) 
+   		(push x aList))
+  	(= (length (symbols 'MAIN)) (length aList))
+))
+
+(define (test-dump )
+  ( = "hello" (get-string (last (dump "hello")))))
+
+(define (test-dump-symbol )
+  (= (length (dump nil) 4)))
+
+(define (test-dup)
+  (and
+    (= (dup "" 0) "")
+    (= (dup "" 10) "")
+    (= (dup "A" 10) "AAAAAAAAAA")
+    (= (dup "AB" 5) "ABABABABAB")
+    (= (dup 'x 5) '(x x x x x))
+	(= (dup "l" -1) "")
+	(= (dup '(1) -1) '())
+    (= (dup 1 0) '())
+    (= (dup 1 5) '(1 1 1 1 1))))
+
+(define (test-empty? , aList)
+  (set 'aList '(1 2 3 4 5 6 7 8 9 0))
+  (while aList 
+   (pop aList))
+  (and (empty? aList) (empty? "")))
+
+(define (test-encrypt )
+  (= (encrypt (encrypt "newlisp" "123") "123") "newlisp"))
+
+(define (test-ends-with )
+  (and 
+	(ends-with "newlisp" "lisp") 
+	(ends-with "newlisp" "LISP" 1) 
+	(ends-with "abc.def.ghi" "def|ghi" 1)
+	(ends-with "12345" "4|5" 1)
+   	(ends-with (explode "newlisp") "p")
+	(set 'D:D "newlisp")
+	(ends-with D "lisp") 
+	(ends-with D "LISP" 1) 
+))
+
+(define (test-env)
+  (and 
+    (list? (env))
+    (env "key" "value") 
+    (= (env "key") "value")
+	(env "key" "") ; remove key
+	(if (or (= ostype "SunOS") (= ostype "Solaris"))
+		(= (env "key" ""))
+		(not (env "key")))
+))
+
+(define (test-erf)
+   (<  (abs (sub 0,5204998778 (erf 0,5))) 0,000001))
+
+;(define (test-estack) (list? (estack)))
+
+(define (test-even?)
+    (and (even? 2) (not (even? 3)) (even? 0,9) (not (even? 3,9))))
+
+(define (alarm) (println "ring..."))
+
+(define (test-timer)
+        (timer 'alarm 2))
+
+(define (test-t-test)
+  (and
+    (< (apply add (map sub (t-test '(1 3 5 8 9 9) '(2 2 3 4 6 8)) 
+        '(5,833333333 4,166666667 3,371448749 2,401388487 0,9862873039 10 0,3472542517))) 
+        0,00000001)
+    ; related samples (before and after treatment)
+    (< (apply add (map sub (t-test '(3 0 6 7 4 3 2 1 4) '(5 1 5 7 10 9 7 11 8) true)
+        '(3,333333333 7 2,236067977 3,041381265 -3,142857143 8 0,01374582439))) 
+        0,00000001)
+    ; force Welch's Student's t for unequal variances
+    (< (apply add (map sub (t-test '(1 3 5 8 9 9) '(2 2 3 4 6 8) 1,0)
+        '(5,833333333 4,166666667 3,371448749 2,401388487 0,9862873039 9 0,3497635197))) 
+        0,00000001)
+    ; force Welch's Student's t for unequal variances and sample sizes
+    (< (apply add (map sub (t-test '(10 4 7 1 1 6 1 8 2 4) '(4 6 9 4 6 8 9 3) 1.0)
+        '(4,4 6,125 3,238655414 2,356601669 -1,30656126 15 0,2110406063))) 
+        0,00000001)
+    ; one sample t-test
+    (< (apply add (map sub (t-test '(3 5 4 2 5 7 4 3) 2,5)
+        '(4,125 2,5 1,552647509 0,548943791 2,960230221 7 0,02109816335)))
+        0,00000001)
+  ))
+
+(define (test-title-case)
+	(= (title-case "heLLo") "HeLLo")
+	(= (title-case "heLLo" true) "Hello"))
+
+(define (test-throw-error)
+    (and
+        (not (catch (throw-error "ERR: message text") 'result))
+        (starts-with result "ERR: user error :")) )
+
+(define (test-error-event )
+  (= 'nil (error-event)))
+
+(define (test-estack) (list? (estack)))
+
+(define (test-eval , x y)
+  (set 'x 123)
+  (set 'y 'x)
+  (set 'z 'y)
+  (and (= 123 (eval y)) (= 123 (eval 'x)) (= 123 (eval (eval z)))))
+
+(define (test-eval-string ) 
+  (eval-string "(set 'x 123)")
+  (eval-string "(set 'y x)")
+  (= 123 (eval-string "y"))
+  (set 'Foo:xyz 99999)
+  (= 99999 (eval-string "xyz" 'Foo))
+  (delete (sym "xyz" Foo))
+)
+
+(define (test-exec )
+  (and (sub-read-exec) (sub-write-exec)))
+
+(define (sub-read-exec ) 
+   (write-file "exectest" {(println "hello") (exit)})
+   (and
+	(set 'result (if (find ostype '("Windows" "OS/2"))
+     	(exec "newlisp exectest") 
+		(exec "./newlisp exectest")))
+	(= "hello" (last  result)) 
+	(delete-file "exectest")))
+
+(define (sub-write-exec )
+  (and 
+    (write-file "testexec" {(write-file "exectest" (read-line))})
+	(if (find ostype '("Windows" "OS/2"))
+	 (exec "newlisp testexec" "HELLO") (exec "./newlisp testexec" "HELLO"))
+    (= "HELLO" (read-file "exectest"))
+    (delete-file "testexec")
+    (delete-file "exectest")))
+
+(define (test-exit )
+  (or (primitive? exit) (lambda? exit)))
+
+(define (test-exists)
+  (and
+    (= (exists string? '(2 3 4 6 "hello" 7)) "hello")
+    (not (exists string? '(3 4 2 -7 3 0)) )
+    (= (exists zero? '(3 4 2 -7 3 0)) 0)
+    (= (exists < '(3 4 2 -7 3 0)) -7)
+    (= (exists (fn (x) (> x 3)) '(3 4 2 -7 3 0)) 4)
+    (not (exists (fn (x) (= x 10)) '(3 4 2 -7 3 0)))
+))
+
+(define (test-exp )
+  (= 1 (exp (log (exp (log (exp (log 1))))))))
+
+(define (test-expand)
+  (and
+    (set 'x 2)
+	(= (expand 'x 'x) 2)
+    (= (expand '(a x b) 'x) '(a 2 b))
+    (= (expand '(x b) 'x) '(2 b))
+    (= (expand '(a x) 'x) '(a 2))
+    (= (expand '(a (x) b) 'x) '(a (2) b))
+    (= (expand '(a ((x)) b) 'x) '(a ((2)) b))
+    (set 'a 1 'b 2 'c 3)
+    (= (expand '(a b c) 'b 'a 'c ) '(1 2 3))
+	;; prolog mode with uppercase vars
+	(set 'X 2)
+	(= (expand '(a ((X)) b)) '(a ((2)) b))
+	;; env list as parameter
+	(set 'a "a" 'B "B" 'c "c" 'd "d")
+	(= (expand '(a (B (c) (d a B))) '((a 1) (B 2) (c 3) (d 4)))
+	   '(1 (2 (3) (4 1 2))))
+	(= a "a") (= B "B") (= c "c") (= d "d")
+))
+
+
+(define (test-explode )
+	(and	
+		(= (explode "kakak" -1) '())
+		(= (explode "ABC" 4) '("ABC"))
+		(= (explode '(a b c d e f) -1) '())
+  		(= (explode "new") '("n" "e" "w"))
+		(= (explode "newlisp" 3) '("new" "lis" "p"))
+		(= (explode "newlisp" 3 true) '("new" "lis"))
+		(= (explode "newlisp" 7 true) '("newlisp"))
+		(= (explode "newlisp" 8 true) '())
+		(= (explode '(a b c d e)) '((a) (b) (c) (d) (e)))
+		(= (explode '(a b c d e) 2) '((a b) (c d) (e)))
+		(= (explode '(a b c d e)) '((a) (b) (c) (d) (e)))
+		(= (explode '(a b c d e) 2) '((a b) (c d) (e)))
+		(= (explode '(n e w l i s p)) '((n) (e) (w) (l) (i) (s) (p)))
+		(= (explode '(n e w l i s p) 3) '((n e w) (l i s) (p)))
+		(= (explode '(n e w l i s p) 7 true) '((n e w l i s p)))
+        (= (explode '(n e w l i s p) 8 true) '())
+		(set 'D:D '(a b c d e f g))
+		(= (explode D 2) '((a b) (c d) (e f) (g)))
+))
+
+(define (test-extend)
+    (and
+        (= (extend '() '(a) '(b c)) '(a b c))
+        (= (extend '(a) '() '(b)) '(a b))
+        (= (extend '(a) '(b) '(c d)) '(a b c d))
+        (not (set 'l '()))
+        (= (extend l '(a) '(b c)) '(a b c))
+        (= (extend l '(d e)) '(a b c d e))
+        (not (set 'l nil))
+        (= (extend l "abc" "def") "abcdef")
+        (not (set 'l nil))
+        (= (extend l '(a) '(b c)) '(a b c))
+    )
+)
+
+(define (test-factor)
+    (= (apply * (factor 0x7FFFFFFFFFFFFFFF)) 0x7FFFFFFFFFFFFFFF))
+
+(define (test-fcall) true)
+
+(define (test-fft )
+  (= '((1 2) (3 4)) (ifft (fft '((1 2) (3 4))))))
+
+(define (test-file-info )
+  (list? (file-info "qa-comma")))
+
+(define (test-file? )
+  (and 
+    (file? "qa-dot")
+    (= (file? "qa-dot" true) "qa-dot")
+    (file? "modules/")
+    (file? "modules")
+    (not (file? "modules" true))
+))
+
+(define (test-filter )
+  (and
+    (= (filter integer? '(1 1,1 2 2,2 3 3,3)) '(1 2 3))
+    (= (filter true? '(a nil b nil c nil)) '(a b c))
+	; default functor
+	(set 'D:D '(2 4 2 7 5 3 8))
+	(= (filter (curry < 5) D) '(7 8))
+))
+
+(define (test-find )
+  (and
+    (= 3 (find '(3 4) '(0 1 2 (3 4) 5 6 7 8)))
+    (= nil (find 9 '(1 2 3)))
+    (= 2 (find "W" "newlisp" 1))
+    (= $0 "w")
+    (= (find "newlisp" '("Perl" "Python" "newLISP") 1) 2)
+    ; use a comparison functor
+    (= (find '(1 2) '((1 4) 5 6 (1 2) (8 9))) 3)
+    (= (find 3 '(8 4 3  7 2 6) >)  4)
+    (= (find 5 '((l 3) (k 5) (a 10) (z 22)) (fn (x y) (= x (last y)))) 1)
+    (= (find '(a ?) '((l 3) (k 5) (a 10) (z 22)) match) 2)
+    (= (find '(X X) '((a b) (c d) (e e) (f g)) unify) 2)
+    (define (has-it-as-last x y) (= x (last y)))
+    (= (find 22 '((l 3) (k 5) (a 10) (z 22)) has-it-as-last) 3)
+    (= (find "newlisp" '("Perl" "Python" "newLISP") (fn (x y) (regex x y 1))) 2)
+	; default functor
+	(set 'D:D '(0 1 2 (3 4) 5 6 7 8))
+    (= 3 (find '(3 4) D))
+	(set 'D:D "newlisp")
+    (= 2 (find "W" D 1))
+))
+
+
+(define (test-find-all)
+  (and
+	(= (find-all {\d+} "asdf2kjh44hgfhgf890") '("2" "44" "890"))
+	(= (find-all {(new)(lisp)} "newLISPisNEWLISP" (append $2 $1) 1) '("LISPnew" "LISPNEW"))
+	(set 'D:D "asdf2kjh44hgfhgf890")
+	(= (find-all {\d+} D) '("2" "44" "890"))
+	(set 'D:D "newLISPisNEWLISP")
+	(= (find-all {(new)(lisp)} D (append $2 $1) 1) '("LISPnew" "LISPNEW"))
+    (= (find-all {(^|(?<=,))("(([^"]|"")*)"|([^",]*))}
+	       {Ten Thousand,10000, 2710 ,,"10,000","It's ""10 Grand"", baby",10K})
+       '("Ten Thousand" "10000" " 2710 " "" "\"10,000\"" "\"It's \"\"10 Grand\"\", baby\"" "10K"))
+))
+
+(define (test-first )
+  (= 1 (first '(1 2 3 4)))
+  (= "n" (first "ewLISP"))
+  (= (array 2 '(1 2)) (first (array 3 2 (sequence 1 6))))
+  (not (catch (first '()) 'result))
+)
+
+(define (test-flat )
+  (set 'lst '(a (b (c d))))
+  (= (map (fn (x) (ref x lst)) (flat lst)) '((0) (1 0) (1 1 0) (1 1 1))))
+
+(define (test-float )
+  (float? (float "1,234")))
+
+(define (test-flt)
+	(= (flt 1,23) 1067282596)
+	(= (flt 0,8) 1061997773)
+	(= (flt -0,8) 3209481421))
+
+(define (test-float? )
+  (float? 1,234))
+
+(define (test-floor )
+  (= 1 (floor 1,5)))
+
+(define (test-for , x lst1 lst2)
+  (set 'lst1 '())
+  (set 'lst2 '())
+  (for (x 10 0 3) 
+   (push x lst1))
+  (for (x 10 0 3 (< x 7))
+   (push x lst2))
+  (and
+   (= lst1 '(1 4 7 10))
+   (= lst2 '(7 10)) )
+)
+
+(define (test-for-all)
+  (and
+    (for-all number? '(2 3 4 6 7)) 
+    (not (for-all number? '(2 3 4 6 "hello" 7)) )
+    (for-all (fn (x) (= x 10)) '(10 10 10 10 10))
+))
+
+(define (test-fork) (integer? (fork (exit))))
+
+(define (test-format )
+  (and
+   (= (format "%d" 1,23) "1") 
+   (= (format "%5.2f" 10) "10,00") 
+   (= (format "%c %s %d %g" 65 "hello" 123 1,23) "A hello 123 1,23")
+   (= (format "%5.2s" "hello") "   he")
+   ; args passed in a list
+   (= (format "%d" '(1,23)) "1")  
+   (= (format "%5.2f" '(10)) "10,00")  
+   (= (format "%c %s %d %g" '(65 "hello" 123 1,23)) "A hello 123 1,23")
+   (= (format "%5.2s" '("hello")) "   he")
+   (set 'data '((1 "a001" "g") (2 "a101" "c") (3 "c220" "g")))
+   (set 'result (map (fn (x) (format "%3.2f %5s %2s" (nth 0 x) (nth 1 x) (nth 2 x))) data))
+   (set 'result (map (fn (x) (format "%3.2f %5s %2s" (x 0) (x 1) (x 2))) data))
+   (= result '("1,00  a001  g" "2,00  a101  c" "3,00  c220  g"))
+   (not (catch (format "%%" 1) 'result))
+   (not (catch (format "%10.2lf" 123) 'result))
+   (= (test-format-r '(("foo" "bar") ("foo" "baz"))) 
+      "[ [ 'foo', 'bar' ], [ 'foo', 'baz' ] ]")
+   ; test 64-bit formatting
+   (if (find ostype '("Windows") ) ;; Win32  Win64
+      (begin
+        (and
+         (= (format "%I64d" 0x7fffffffffffffff) "9223372036854775807")
+         (= (format "%I64x" 0x7fffffffffffffff) "7fffffffffffffff")
+         (= (format "%I64u" 0x7fffffffffffffff) "9223372036854775807")
+         (= (format "%I64d" 0x8000000000000000) "-9223372036854775808")
+         (= (format "%I64x" 0x8000000000000000) "8000000000000000")
+         (= (format "%I64u" 0x8000000000000000) "9223372036854775808")
+         (= (format "%I64d" 0xFFFFFFFFFFFFFFFF) "-1")
+         (= (format "%I64x" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+         (= (format "%I64u" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+      )
+      (begin ;; UNIX like OS 
+        (if (= ostype "Tru64Unix") ;TRU64
+          (begin
+            (and
+              (= (format "%d" 0x7fffffff) "2147483647")
+              (= (format "%d" 0xffffffff) "-1")
+              (= (format "%u" 0xffffffff) "4294967295")
+              (= (format "%i" 0x7fffffff) "2147483647")
+
+              ; truncate
+              (= (format "%d" 0x7fffffffffffffff) "-1")
+              (= (format "%u" 0x7fffffffffffffff) "4294967295")
+              (= (format "%x" 0x7fffffffffffffff) "ffffffff") 
+              (= (format "%X" 0x7fffffffffffffff) "FFFFFFFF") 
+
+              (= (format "%ld" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lu" 0xffffffffffffffff) "18446744073709551615")
+              (= (format "%li" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lx" 0x7fffffffffffffff) "7fffffffffffffff")
+              (= (format "%ld" 0x8000000000000000) "-9223372036854775808")
+              (= (format "%lx" 0x8000000000000000) "8000000000000000")
+              (= (format "%lu" 0x8000000000000000) "9223372036854775808")
+              (= (format "%ld" 0xFFFFFFFFFFFFFFFF) "-1")
+              (= (format "%lx" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+              (= (format "%lu" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+          )
+          (begin ; all other UNIX, Linux, OS X
+            (and
+              (= (format "%d" 0x7fffffff) "2147483647")
+              (= (format "%d" 0xffffffff) "-1")
+              (= (format "%u" 0xffffffff) "4294967295")
+
+              ; truncate
+              (= (format "%d" 0x7fffffffffffffff) "-1")
+              (= (format "%u" 0x7fffffffffffffff) "4294967295")
+              (= (format "%x" 0x7fffffffffffffff) "ffffffff") 
+              (= (format "%X" 0x7fffffffffffffff) "FFFFFFFF") 
+
+              (= (format "%lld" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%llx" 0x7fffffffffffffff) "7fffffffffffffff")
+              (= (format "%llu" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lld" 0x8000000000000000) "-9223372036854775808")
+              (= (format "%llx" 0x8000000000000000) "8000000000000000")
+              (= (format "%llu" 0x8000000000000000) "9223372036854775808")
+              (= (format "%lld" 0xFFFFFFFFFFFFFFFF) "-1")
+              (= (format "%llx" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+              (= (format "%llu" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+          )
+      )
+))))
+
+(define (test-format-r obj , s) 
+  (cond 
+   ((string? obj)	(format "'%s'" obj)) 
+   ((list? obj) (format "[ %s ]" (join (map test-format-r obj) ", ")))
+)) 
+
+(define (test-fv )
+  (< (sub (fv 0,1 10 1000 0 0) -15937,4246) 1e-05))
+
+(define (test-gammai )
+  (< (abs (sub (gammai 4 5) 0,734974)) 1e-05))
+
+(define (test-gammaln )
+  (< (abs (sub 120 (exp (gammaln 6)))) 1e-05))
+
+(define (test-gcd)
+ (and
+  (= (gcd 0) 0)
+  (= (gcd 1) 1)
+  (= (gcd 12 36) 12)
+  (= (gcd 12 36 6) 6)
+  (= (gcd 12 36 6 3) 3)
+))
+
+(define (test-get-char )
+ (and
+  (= 65 (get-char (address "A")) (get-char "ABC"))
+  (set 'D:D "ABC")
+  (= 65 (get-char D))
+))
+
+(define (test-get-float )
+  (= 1,234 (get-float (pack "lf" 1,234))))
+
+(define (test-get-int )
+  (and
+    (= 123456789 (get-int (pack "ld" 123456789)))
+    (set 'adr (pack "ldld" 0xaabbccdd 0xccddeeff))
+    (= (format "%x" (get-int adr)) "aabbccdd")
+    (= (format "%x" (get-int (address adr))) "aabbccdd")
+    (= (format "%x" (get-int (+ (address adr) 0))) "aabbccdd")
+    (= (format "%x" (get-int (+ (address adr) 4))) "ccddeeff")
+    (set 'adr (pack "> ldld" 0xaabbccdd 0xccddeeff))
+    (= adr "\170\187\204\221\204\221\238\255")
+    (set 'adr (pack "< ldld" 0xaabbccdd 0xccddeeff))
+    (= adr "\221\204\187\170\255\238\221\204")
+    (set 'buff (pack "lulululululululu" 1 2 3 4))
+    (apply and (map (fn (i) (= (+ i 1) (get-int (+ (* i 4) (address buff))))) '(0 1 2 3))) 
+))
+
+(define (test-get-long)
+	(set 'adr (pack "Ld" -1))
+	(= -1 (get-long adr)))
+
+(define (test-get-string )
+  (= "hello" (get-string (address "hello"))))
+
+(define (test-get-url )
+  (= "ERR: HTTP bad formed URL" (get-url "")))
+
+
+(define (test-global)
+	(= global-myvar 123))
+
+(define (test-global?)
+	(and
+		(global? 'global-myvar)
+		(global? 'println)
+))
+
+(define (test-if )
+  (and 
+   (if true true) 
+   (if nil nil true) 
+   (if 'nil nil true) 
+   (if '() nil true)
+   (= (if '()) '())
+   (= (if nil 1 '() 2) '())
+   (= (if nil '() '()) '())
+   (= (if true '() '()) '())
+   (= (if nil 1 nil 2 nil 3 true 4 3) 4)
+   (= (if nil 1 nil 2 nil 3 nil 4 3) 3)
+   ; anaphoric $it
+   (if 123 (= $it 123))
+   ))
+
+(define (test-if-not )
+  (if-not nil 
+   true nil))
+
+(define (test-ifft )
+  (= '((1 2) (3 4)) (ifft (fft '((1 2) (3 4))))))
+
+(define (test-import )
+  (primitive? import))
+
+(define (test-inc , x)
+  (and
+	(= (inc x) 1)
+	(= (inc x) 2)
+	(set 'l '(1 2 3 4))
+	(= (inc (l 1)) 3)
+	(= (dec (nth 0 l) 2) -1)
+	(= (dec (last l) 0,1) 3,9)
+	(= (inc (+ 3 4)) 8)
+	(= l '(-1 3 3 3,9))
+))
+
+(define (test---) (test-++))
+
+(define (test-++ , x)
+	(and 
+		(= (++ x) 1)
+		(= (++ x) 2)
+		(= (++ x 3) 5)
+		(set 'l '(0 nil 2,5))
+		(= (-- (l 0)) -1)
+		(= (++ (l 1)) 1)
+		(= (++ (l 2) 2) 4)
+		(= l '(-1 1 4))
+	)
+)
+
+(define (test-index )
+  (= '(1 3) (index (lambda (x) (> x 3)) '(1 5 2 6 2 0))))
+
+(define (test-inf?)
+	(inf? (div 1 0)))
+
+(define (test-int)
+  (and 
+    (integer? (int "12345"))
+    (= (int " 12345") 12345)
+    (= (int "9223372036854775807")  9223372036854775807)
+    (= (int "-9223372036854775808") -9223372036854775808)
+    (= (int 0.0) 0)
+    (= (int 1e30)  9223372036854775807)
+    (= (int -1e30) -9223372036854775808)
+    (= (int 0x8000000000000000) (int "0x8000000000000000"))
+	(set 'D:D 12345)
+	(= (int D) 12345)
+	(= (int "gg" 99) 99)
+	(= (int "ff" 99 16) 255)
+	(= (int "-ff" 99 16) -255)
+    (= (int "0b101010") 42)
+    (= (int "101010" 0 2) 42)
+))
+
+(define (test-integer) (test-int))
+
+(define (test-integer? )
+  (and
+    (integer? 12345)
+    (integer? 9223372036854775807)
+    (integer? -9223372036854775808)
+    (integer? 0x7FFFFFFFFFFFFFFF)
+    (integer? 0xFFFFFFFFFFFFFFFF)
+))
+
+(define (test-intersect )
+  (= (intersect '(3 0 2 4 1) '(1 4 2 5)) '(2 4 1)))
+
+(define (test-invert )
+  (set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+  (set 'I (multiply A (invert A)))
+  (set 'J (multiply (array 3 3 (flat A)) (invert (array 3 3 (flat A)))))
+  (and (< (sub 1 (nth 0 (nth 0 I))) 1e-06)
+       (< (sub 1 (nth 1 (nth 1 I))) 1e-06) 
+       (< (sub 1 (nth 2 (nth 2 I))) 1e-06)
+       (= I (array-list J)) 
+       (not (invert '((0 1 0) (1 0 1) (0 0 0))) )
+))
+
+(define (test-irr )
+  (< (abs (sub (irr '(-1000 500 400 300 200 100)) 0,20272)) 0,0001))
+
+(define (test-join )
+  (and 
+    (= "this is a sentence" (join '("this" "is" "a" "sentence") " ")) 
+    (= "this_is_a_sentence" (join '("this_" "is_" "a_" "sentence")))
+    (= "" (join '()))
+	(= (join '("A" "B" "C") "-") "A-B-C")
+	(= (join '("A" "B" "C") "-" true) "A-B-C-")
+))
+
+(define (test-json-error)
+    (and
+        (not (json-parse {{"key" : "value" , "hello"  "world"}}))
+        (= (json-error) '("missing : colon" 28))
+    ))
+
+; see also qa-specific-tests/qa-json
+(define (test-json-parse)
+    (and 
+        (= (json-parse { {"key" : "value" , "hello" : "world", "array" : [1, 2, 3, 4, 5]} })
+        '(("key" "value") ("hello" "world") ("array" (1 2 3 4 5))))
+        (= (json-parse { [1,2,3,4,5,6,{ "nested" : 777}, 8, 9] } )
+          '(1 2 3 4 5 6 (("nested" 777)) 8 9) )
+    ))
+
+(define (test-kmeans-query) true)
+
+(define (test-kmeans-train)
+    (let (data '(
+        (1,85 1,89 0,11)
+        (2,11 2,14 0,85)
+        (2,48 2,26 0,19)
+        (2,43 2,14 1,59)
+        (2,29 4,18 1,06)
+        (1,17 4,46 1,02)
+        (3,12 3,1 1,4)
+        (9,44 2,65 7,37)
+        (8,16 3,83 8,93)
+        (8,49 5,31 7,47)
+        (7,01 4,2 11,9)
+        (6,57 4,96 11,91)
+        (8,63 2,51 8,11)
+        (7,18 3,46 8,7)
+        (8,17 6,59 7,49)
+        (6,79 8,72 8,62)
+        (5,44 5,9 5,57)
+        (7,56 7,93 5,06)
+        (3,61 7,95 5,11)
+        (6,77 6,04 3,76) ))
+      (< (abs (apply add (map sub (kmeans-train data 3 'MAIN:KMT)
+                              '(403,8613998 122,6051922 91,49019772 85,06633163 82,74597619)))) 0,000001)
+      (= KMT:labels '(2 2 2 2 2 2 2 3 3 3 3 3 3 3 1 1 1 1 1 1))
+      (= KMT:clusters '((14 15 16 17 18 19) (0 1 2 3 4 5 6) (7 8 9 10 11 12 13)))
+      (< (abs (apply add (map sub KMT:deviations '(2,457052209 1,240236975 2,260089397)))) 0,000001)
+      (< (abs (apply add (map sub  (flat KMT:centroids) (flat '((6,39 7,188333333 5,935)
+                       (2,207142857 2,881428571 0,8885714286)
+                       (7,925714286 3,845714286 9,198571429)))))) 0,000001)
+      (< (abs (apply add (map sub (kmeans-query '(1 2 3) KMT:centroids) 
+                                '(8,036487279 2,58693657 9,475994267)))) 0,000001)
+    )
+true
+)
+
+(define (test-lambda? )
+  (lambda? qa))
+
+(define (test-last )
+  (= 'f (last '(a b c d e f)))
+  (= "p" (last "newlisp"))
+  (= (array 2 '(5 6)) (last (array 3 2 (sequence 1 6))))
+  (not (catch (last '()) 'result))
+)
+
+(define (test-last-error)
+	(= (last-error 1) '(1 "not enough memory"))
+)
+
+(define (test-legal?)
+  (and
+    (legal? "abc")
+    (not (legal? "a b c"))
+    (set 'greek (pack "cccccccccccccccccc" 206 160 206 181 206 187 206 181 206 185 206
+				172 206 180 206 181 207 137))
+    (legal? greek)
+))
+
+(define (test-length )
+  (> (length (symbols)) 100)
+  (- 7 (length "newlisp"))
+  (= 3 (length 123))
+  (= 3 (length 123,456))
+  (= 1 (length 0))
+  (= 1 (length 0,789))
+  (= 7 (length 10e5))
+)
+
+(define (test-let )
+  (set 'a 123)
+  (set 'b 456)
+  (set 'p 111)
+  (set 'q 222)
+  (and
+     (let ((a 1) (b 2)) 
+       (= (+ a b) 3))
+     (= a 123) 
+     (= b 456)
+     (let (p 3 q 4)
+       (= (+ q p) 7))
+     (= p 111)
+     (= q 222)
+))
+
+(define (test-letex)
+  (and
+	(= (letex (x '* y 3 z 4) (x y z)) 12)
+	(= (letex (x 1 y 2 z 3) (quote (x y z))) '(1 2 3))
+	(= (letex (x 1 y 2 z 3) '(x y z)) '(1 2 3))
+	(= (letex (x 1 y 2 z 3) '('x (quote y) z)) '('1 (quote 2) 3))
+	(= (letex (x 1) 'x) 1)
+    (set 'x 123 'y 456)
+    (= (letex (x 'y) 'x) 'y)
+    (= (letex (x 'y) x) 456)
+    (= (letex (x '(+ 3 4)) 'x) '(+ 3 4))
+    (= (letex (x '(+ 3 4)) x) 7)
+	))
+
+(define (test-letn)
+  (set 'x 0 'y 0 'z 0)
+  (and
+      (= (letn ((x 1) (y (+ x 1)) (z (+ y 1))) (list x y z)) '(1 2 3))
+      (= 0 x y z))
+)
+
+(define (test-list )
+  (and (list? (list 1 2 3 4 5)) (= '(1) (list 1)) (= '(1 nil) (list 
+     1 'nil))))
+
+(define (test-list? )
+  (and (list? '(1 2 3 4 5)) (list? '())))
+
+(define (test-load )
+  (write-file "junk" "(+ 3 4)")
+  (load "junk"))
+
+(define (test-local)
+	(set 'a 10 'b 20)
+	(and 
+		(= (local (a b) (set 'a 1 'b 2) (+ a b)) 3)
+		(= a 10)
+		(= b 20)))
+
+(define (test-set-locale) 
+  (list? (set-locale)))
+
+(define (test-log )
+  (and
+  	(= 1 (log (exp 1)))
+	(= 1 (log (exp 1) (exp 1)))
+  )
+)
+
+(define (test-lookup )
+  (and 
+	(= 3 (lookup 1 '((2 3 4) (1 2 3)))) 
+	(= 2 (lookup 1 '((2 3 4) (1 2 3)) 1))
+	; default functor
+	(set 'D:D '((a 1 2 3) (b 4 5 6) (c 7 8 9)))
+	(= 6 (lookup 'b D -1))
+))
+
+(define (test-lower-case )
+   (= "abcdefghijklmnopqrstuvwxyz" (lower-case "ABCDEFGHIJKLMNOPQRSTUVWXYZ")))
+
+(define (test-macro)
+    (= (unless testmacro (macro (testmacro x) (+ x x))) 
+        (lambda-macro (x) (expand '(+ x x))))
+)
+
+(define (test-macro? )
+  (macro? 
+   (define-macro (foo-macro))))
+
+(define (test-main-args )
+  (and 
+     (list? (main-args))
+     (list? $main-args)
+     (= $main-args (main-args))
+     (= ($main-args 0) ((main-args) 0) (main-args 0))
+     (= ($main-args -1) ((main-args) -1))
+     (= ($main-args -1) (main-args -1))
+))
+
+
+(define (test-make-dir )
+  (and (make-dir "foodir") (remove-dir "foodir")))
+
+(define (test-map )
+  (and (= '(11 22 33) (map + '(10 20 30) '(1 2 3))) 
+       (= '(2 4 6) (map (lambda (x) (+ x x)) '(1 2 3)))
+	   (set 'D:D '(1 2 3 4 5))
+       (= (map pow D) '(1 4 9 16 25))
+       (= (map pow (array 5 D))  '(1 4 9 16 25))
+))
+
+(define (test-mat)
+	(set 'A '((1 2 3) (4 5 6))) 
+	(set 'B A)
+	(and
+		(= (mat + A B) '((2 4 6) (8 10 12)))
+		(= (mat - A B) '((0 0 0) (0 0 0)))
+		(= (mat * A B) '((1 4 9) (16 25 36)))
+		(= (mat / A B) '((1 1 1) (1 1 1)))
+		(= (mat + A 2) '((3 4 5) (6 7 8)))
+		(= (mat - A 2) '((-1 0 1) (2 3 4)))
+		(= (mat * A 2) '((2 4 6) (8 10 12)))
+		(= (mat / A 2) '((0,5 1 1,5) (2 2,5 3)))
+
+		(= (mat + A 5) '((6 7 8) (9 10 11)))
+		(= (mat - A 2) '((-1 0 1) (2 3 4)))
+		(= (mat * A 3) '((3 6 9) (12 15 18)))
+		(= (mat / A 10) '((,1 ,2 ,3) (,4 ,5 ,6)))
+
+        (set 'op +)
+		(= (mat op A B) '((2 4 6) (8 10 12)))
+        (set 'op '+)
+		(= (mat op A B) '((2 4 6) (8 10 12)))
+		; default functor
+		(set 'DA:DA A)
+		(set 'DB:DB B)
+		(= (mat + DA DB) '((2 4 6) (8 10 12)))
+        (set 'B '((-1 1 1) (1 4 -5) (1 -2 0)))
+        (set 'A '((1 2 3) (4 5 6)))
+        (not (catch (mat + A B) 'result))
+        (starts-with result "ERR: wrong dimensions")
+	))
+
+
+(define (test-match)
+  (and 
+    (= (match '(a (b ?) d e *) '(a (b c) d e f g) true)   '(a (b c) d e (f g)) )
+    (= (match '(a (b ?) d e *) '(a (b c) d e f g) )  '(c (f g)) )
+
+    (= (match '(a * b x) '(a b c d b x e f b x) true) '(a (b c d b x e f) b x) )
+    (= (match '(a * b x) '(a b c d b x e f b x) ) '((b c d b x e f)) )
+
+
+    (= (match '(? (?) x * ? (? e)) '(a (b) x y c (d e)) true) '(a (b) x (y) c (d e)) )
+    (= (match '(? (?) x * ? (? e)) '(a (b) x y c (d e))) '(a b (y) c d) )
+
+    (= (match '(a * b) '(a x b) true) '(a (x) b) )
+    (= (match '(a * b) '(a x b)) '((x)) )
+
+
+    (= (match '(a * b) '(a b) true) '(a () b) )
+    (= (match '(a * b) '(a b)) '(()) )
+
+    (= (match '( (? ?) * ) '( (x y) ) true) '((x y) ()) )
+    (= (match '( (? ?) * ) '( (x y) )) '(x y ()) )
+    (match '(+) '(a))
+    (match '(+) '(a b))
+    (not (match '(+) '()))
+	; default functors
+	(set 'P:P '(a (b ?) d e *) )
+	(set 'M:M '(a (b c) d e f g))
+	(true? (match P M))
+  ))
+
+
+(define (test-max )
+  (and (= 10 (max 3 6 10 8)) (= 1,2 (max 0,7 0,6 1,2))))
+
+(define (test-member )
+ (and	
+  (= '(3 4) (member 3 '(1 2 3 4)))
+  (= (member "LISP" "newLISP") "LISP")
+  (= (member "LI" "newLISP") "LISP")
+  (= (member "" "newLISP") "newLISP")
+  (not (member "xyz" "newLISP"))
+  (not (member "new" "this is NEWLISP" 0))
+  (= (member "new" "this is NEWLISP" 1) "NEWLISP")
+  ; default functor
+  (set 'D:D '(1 2 3 4))
+  (= '(3 4) (member 3 D))
+  (set 'D:D "newLISP")
+  (= "LISP" (member "LI" D))
+ )  
+)
+
+(define (test-message) true)
+
+(define (test-min )
+  (and (= 3 (min 3 6 10 8)) (= 0,6 (min 0,7 0,6 1,2))))
+
+(define (test-mod )
+  (and 	(< (sub (mod 10,5 3,3) 0,6) 0,0001) 
+		(< (sub (mod 10 3) 1) 0,0001)
+		(< (sub (mod 10,5) 0,5) 0,0001)
+))
+
+(define (test-mul )
+  (= 1e-09 (mul 0,0001 1e-05)))
+
+(define (test-multiply )
+  (let ((A '((1 2 3) (4 5 6))) (B '((1 2) (1 2) (1 2)))) 
+    (and 
+       (= '((6 12) (15 30)) (multiply A B))
+       (= (array 2 2 (flat '((6 12) (15 30))))
+          (multiply (array 2 3 (flat A)) (array 3 2 (flat  B))))
+    )
+))
+
+
+(define (test-net-accept )
+  (and
+	(set 'net-listen-test (set 'listen (net-listen 12345)))
+	(if (zero? (& (sys-info -1) 512)) ; IPv4
+		(set 'net-connect-test (set 'connect (net-connect "localhost" 12345)))
+		(set 'net-connect-test (set 'connect (net-connect "::1" 12345)))
+	)
+	(set 'server (net-accept listen))
+	(set 'net-send-test (= (net-send server "hello") 5))
+	(set 'net-select-test (net-select connect "r" 100000))
+	(set 'net-peek-test (= (net-peek connect) 5))
+	(set 'net-receive-test (net-receive connect buff 20))
+	(= buff "hello")
+	(set 'net-sessions-test (and  
+	  (find listen (net-sessions))
+	  (find connect (net-sessions))
+	  (find server (net-sessions))))
+	(set 'net-local-test (= (net-local server) (net-peer connect)))
+	(set 'net-peer-test (= (net-local connect) (net-peer server)))
+	(set 'net-close-test (net-close connect))
+	(set 'net-close-test (net-close server))
+	(set 'net-close-test (net-close listen))
+	(not (net-error))
+))
+
+(define (test-net-close ) net-close-test)
+
+(define (test-net-connect )  net-connect-test)
+
+(define (test-net-error ) 
+	(and
+		(not (net-close 12345))
+		(list? (net-error))))
+
+(define (test-net-eval) true) ;; see special test prog
+
+(define (test-net-interface) true) ;; test manually on multihoned machines
+
+(define (test-net-keypad)
+	(net-keypad "1234567890"))
+
+(define (test-net-listen ) net-listen-test)
+
+(define (test-net-local ) net-local-test)
+
+(define (test-net-ipv) 
+	(and (= (net-ipv) 4) (= (net-ipv 6) 6) (= (net-ipv 4) 4)))
+
+(define (test-net-lookup )
+	(if (zero? (& (sys-info -1) 512)) ; IPv4
+	    (and (= "127.0.0.1" (net-lookup "localhost")) (string? (net-lookup "127.0.0.1")))
+		(and (= "localhost" (net-lookup "::1")) (= "::1" (net-lookup "localhost")))
+	)
+)
+
+(define (test-net-packet) true);
+
+(define (test-net-peek ) net-peek-test)
+
+(define (test-net-peer ) net-peer-test)
+
+(define (test-net-ping) true) ; test manually on UNIX as root
+
+(define (test-net-receive ) net-receive-test)
+
+(define (test-net-receive-from)
+  (and
+    (set 'sock (net-listen 1234 "localhost" "udp"))
+    (set 'net-send-to-test (net-send-to "localhost" 1234 "hello" sock))
+    (set 'net-select-test (net-select sock "r" 1000000) )
+    (= "hello" (first (net-receive-from sock 10)))
+    (net-close sock)))
+
+
+(define (test-net-receive-udp)
+    (write-file "udptest.lsp"
+[text]
+(map set '(in out sid) (map int (slice (main-args) 2)))
+(semaphore sid 1) ; signal parent to start
+(set 'msg (net-receive-udp in 20 2000000))
+(sleep 100)
+(if (not msg) (exit))
+(net-send-udp "localhost" out (upper-case (first msg)))
+(exit)
+[/text]
+    )
+  (and
+    (set 'sid (semaphore))
+    (if (find ostype '("Windows" "OS/2"))
+      (process (string "newlisp udptest.lsp " 10001 " " 10002 " " sid))
+      (process (string "./newlisp udptest.lsp " 10001 " " 10002 " " sid)))
+    ;(println "---------- testing UDP Win32/64 and OS/2 -------------")
+    ;(println "waiting ...")
+    (semaphore sid -1) ; wait for child process
+    (sleep 100)
+    ;(println "sending ...")
+    (net-send-udp "localhost" 10001 "hello") 
+    ;(println "receiving ...")
+    (set 'msg (net-receive-udp 10002 20 3000000))
+    ;(println "msg:" msg)
+    (or (delete-file "udptest.lsp") true)
+    ;(println "deleting semaphore:" (semaphore sid 0)) ; delete semaphore
+    ;(println "------------------------------------------")
+    (if msg (set 'net-send-udp-test (= "HELLO" (first msg)) ) )))
+
+
+(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "AIX" "True64Unix" "Cygwin"))  
+  (define (test-net-receive-udp)
+    (fork (begin (sleep 500) (net-send-udp "localhost" 10001 "hello")))
+    (set 'net-send-udp-test (= "hello" (first (net-receive-udp 10001 10)))))
+)
+
+
+(define (test-net-select )  net-select-test)
+
+(define (test-net-send ) net-send-test)
+
+(define (test-net-send-to ) net-send-to-test)
+
+(define (test-net-send-udp ) net-send-udp-test)
+
+(define (test-net-service ) (= 21 (net-service "ftp" "tcp")))
+
+(define (test-net-sessions ) net-sessions-test)
+
+(define (test-new) 
+  (new QA 'MAIN:QA2))
+
+(define (test-nil?)
+  (and
+    ;test symbol-nil = logic-nil in order compare of count
+	(= (count '(nil true) (map (curry < 3) '(1 2 4 5))) '(2 2))
+    (= nil (not (nil? nil)))
+    (= '(nil true) (map nil? '(a nil)))))
+
+(define (test-null?)
+	(= (map null? '(1 0 2 0,0 "hello" "" (a b c) () nil true))
+	'(nil true nil true nil true nil true true nil)))
+
+(define (test-normal )
+  (and (float? (normal)) (float? (normal 10 3)) (list? (normal 10 
+     3 100))))
+
+(define (test-not )
+  (and (not (not (not '()))) (not (not (not (not (not nil))))) (not 
+    (not (not (not true)))) 
+   (= '(true true true) (map not '(nil nil nil))) 
+   (= '(nil nil nil) (map not '(true true true)))))
+
+(define (test-now )
+  (and
+  	(= (length (now)) 11)
+	(= 3600 (round (- (apply date-value (now 60)) (date-value)) 2))
+	)
+)
+
+(define (test-nper )
+  (< (sub (nper 0,1 1000 100000 0 0) -25,15885793) 1e-08))
+
+(define (test-npv )
+  (< (sub (npv 0,1 '(-10000 3000 4200 6800)) 1188,443412) 1e-06))
+
+(define (test-nth , l)
+	(and 
+		(set 'l '(0 1 2))
+		(= 0 (nth 0 l))
+		(= 1 (nth 1 l))
+		(= 2 (nth 2 l))
+		(= 2 (nth -1 l))
+		(= (nth 0 "lisp") "l")
+		(= (nth 1 "lisp") "i")
+		(= (nth 3 "lisp") "p")
+		(= (nth -4 "lisp") "l")
+		(= (nth 0 "") "")
+		
+		(set 'l '(a b (c d) (e f)))
+		(= 'a (l 0))
+		(= '(c d) (l 2))
+		(= 'c (l 2 0))
+		(= 'f (l -1 -1))
+		(= 'c (l '(2 0)))
+		(= 'f (l '(-1 -1)))
+
+		(set 'myarray (array 3 2 (sequence 1 6)))
+		(= (array 2 '(3 4)) (myarray 1))
+		(= 6 (myarray -1 -1))
+        (= (myarray '()) myarray)
+
+		(= (array 2 '(3 4)) (myarray '(1)))
+		(= 6 (myarray '(-1 -1)))
+
+		(= "L" ("newLISP" 3))
+
+		(constant 'constL '((1 2 3) (a b c)))
+		(set 'aref '(1 2))
+		(= (constL 1 2) 'c)
+		(= (nth '(1 2) constL) 'c)
+		(= (nth (list (- 2 1) (+ 1 1)) constL) 'c)
+		(= (nth aref constL) 'c)
+         (= (nth '() constL) constL)
+
+		; default functor
+		(set 'D:D '(a b (c d) (e f)))
+		(= 'a (D 0))
+		(= '(c d) (D 2))
+		(= 'c (D 2 0))
+		(= 'f (D -1 -1))
+		(= 'c (D '(2 0)))
+		(= 'f (D '(-1 -1)))	
+		(= 'a (nth 0 D))
+		(= '(c d) (nth 2 D))
+  ))
+
+(define (test-number?)
+    (and
+        (number? 1)
+        (number? 1,23)
+        (not (number? 'x))
+        (not (number? "abc"))
+        (not (number? '(a b c)))
+    )
+)
+
+
+(define (test-open )
+  (and 
+    (set 'fle (open "qa-comma" "read"))
+    (close fle)))
+
+(define (test-or )
+  (and (or (or (= 1 2) nil nil) (or nil nil nil true)) (not (or nil 
+     (= "a" "b") nil))))
+
+(define (test-odd?)
+    (and (odd? 3) (not (odd? 2)) (odd? 3,34) (not (odd? 2,999))))
+
+(define (test-pack )
+ (and
+  (= (pack "c c c" 65 66 67) "ABC")
+  (= (unpack "c c c" "ABC") '(65 66 67))
+  (set 's (pack "c d u" 10 12345 56789))
+  (= (unpack "c d u" s) '(10 12345 56789))
+  (set 's (pack "s10 f" "result" 1,23))
+  (= (first (unpack "s10 f" s)) "result\000\000\000\000")
+  (< (- (last (unpack "s10 f" s)) 1,23) 0,00001)
+  (set 's (pack "s3 lf" "result" 1,23))
+  (= (first (unpack "s3 f" s)) "res")
+
+  (= (pack "ccc" 65 66 67) "ABC")
+  (= (unpack "ccc" "ABC") '(65 66 67))
+  (set 's (pack "cdu" 10 12345 56789))
+  (= (unpack "cdu" s) '(10 12345 56789))
+  (set 's (pack "s10f" "result" 1,23))
+  (= (first (unpack "s10f" s)) "result\000\000\000\000")
+  (< (- (last (unpack "s10f" s)) 1,23) 0,00001)
+  (set 's (pack "s3lf" "result" 1,23))
+  (= (first (unpack "s3f" s)) "res")
+
+  (= "\001\000" (pack "<d" 1))
+  (= "\000\001" (pack ">d" 1))
+  (= "\001\000\000\000" (pack "<ld" 1))
+  (= "\000\000\000\001" (pack ">ld" 1))
+  (= '(12345678) (unpack "ld" (pack "ld" 12345678)))
+  (= '(12345678) (unpack "<ld" (pack "<ld" 12345678)))
+  (= '(12345678) (unpack ">ld" (pack ">ld" 12345678)))
+  (= (unpack "bbbbbbbb" (pack "<lf" 1,234)) '(88 57 180 200 118 190 243 63))
+  (= (unpack "bbbbbbbb" (pack ">lf" 1,234)) '(63 243 190 118 200 180 57 88))
+  (= (format "%20.2f" (first (unpack "lf" (pack "lf" 1234567890123456)))) " 1234567890123456,00")
+))
+
+(define (test-parse )
+  (and 
+    (= 3 (length (parse "hello hi there"))) 
+    (= (parse "abcbdbe" "b") '("a" "c" "d" "e")) 
+    (= (parse "," ",") '("" ""))  
+    (= (parse "hello regular   expression 1, 2, 3" {,\s*|\s+} 0)
+       '("hello" "regular" "expression" "1" "2" "3"))))
+
+(define (test-prefix)
+	(set 's 'Foo:bar)
+	(= s (sym (term s) (prefix s))))
+
+(define (test-peek)
+	(set 'fle (open "qa-comma" "r"))
+	(= (peek fle) (first (file-info "qa-comma")))
+	(close fle))
+
+(define (test-pipe)
+	(write-file "pipe-child.lsp" 
+[text]
+(set 'msg (read-line (int (nth 2 (main-args)))))
+(write-line (int (nth 3 (main-args))) (upper-case msg))
+(exit)
+[/text]
+	)
+  (and
+	(set 'channel (pipe))
+	(set 'in (first channel))
+	(set 'out (last channel))
+	(if (find ostype '("Windows" "OS/2"))
+		(process (string "newlisp pipe-child.lsp " in " " out))
+		(process (string "./newlisp pipe-child.lsp " in " " out)))
+	(sleep 500)
+	(write-line out "hello there")
+	(sleep 500)
+	(= (read-line in) "HELLO THERE")
+	(delete-file "pipe-child.lsp")
+  )
+)
+
+(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "Aix" "True64Unix" "Cygwin"))
+  (define (test-pipe)
+	(set 'channel (pipe))
+	(set 'in (first channel))
+	(set 'out (last channel))
+	(fork (write-line out (upper-case (read-line in))))
+	(write-line out "hello there")
+	(sleep 1000)
+	(= (read-line in) "HELLO THERE")
+	)
+)
+
+
+(define (test-pmt ) 
+  (< (sub (pmt 0,1 10 100000 0 0) -16274,53949) 1e-05))
+
+(define (test-pop , r l)
+  (set 'r '())
+  (set 'l '(1 2 3 4 5 6 7 8 9 0))
+  (dotimes (x 10) 
+   (push (pop l) r))
+  (and (= r '(0 9 8 7 6 5 4 3 2 1))
+       (set 'l '(a b (c d (x) e)))
+       (= 'x (pop l '(2 2 0)))
+       (set 'lst '(1 2 3 (4 5)()))
+       (push 'x lst -1 -1)
+       (= lst '(1 2 3 (4 5) (x)))
+       (push 'y lst -1 0)
+       (= lst '(1 2 3 (4 5) (y x)))
+       (push 'z lst -1 1)
+       (= lst '(1 2 3 (4 5) (y z x)))
+       (push 'p lst 4)
+       (= lst '(1 2 3 (4 5) p (y z x)))
+       (push 'q lst -2)
+       (= lst '(1 2 3 (4 5) p q (y z x)))
+       (push 'a lst 3 -3)
+       (= lst '(1 2 3 (a 4 5) p q (y z x)))
+       (= (pop lst 3 -3) 'a)
+       (= (pop lst -2) 'q)
+       (= (pop lst 4) 'p)
+       (= (pop lst -1 1) 'z)
+       (= (pop lst -1 0) 'y)
+       (= (pop lst -1 -1) 'x)
+       (= lst '(1 2 3 (4 5)()))
+       ; test pop string
+       (set 's "newLISP")
+       (= (pop s) "n")
+       (= s "ewLISP")
+       (= (pop s 2) "L")
+       (= s "ewISP")
+       (= (pop s -1) "P")
+       (= s "ewIS")
+       (= (pop s -2 2) "IS")
+       (= s "ew")
+       (= (pop s -2 10) "ew")
+       (= s "")
+       (set 's "123456789")
+       (= (pop s 5) "6")
+       (= (pop s 5 -1) "")
+       (= s "12345789")
+       (set 's "123456789")
+       (= (pop s 5 5) "6789")
+       (set 's "x")
+       (= (pop s) "x")
+       (= s "")
+       (= (pop s) "")
+       (= (pop s) "")	
+       (= s "")
+		; default functor
+		(set 'D:D '(a b (c d (x) e)))
+		(= 'x (pop D '(2 2 0)))
+))
+
+(define (test-pop-assoc)
+	(and
+		(set 'L '((a (b 1) (c (d 2)))))
+		(= (pop-assoc 'a L) '(a (b 1) (c (d 2))))
+		(= L '())
+		(set 'L '((a (b 1) (c (d 2)))))
+		( = (pop-assoc '(a b) L) '(b 1))
+		(= L '((a (c (d 2)))))
+		(set 'L '((a (b 1) (c (d 2)))))
+		(= (pop-assoc '(a c) L) '(c (d 2)))
+		(= L '((a (b 1))))
+		(set 'L '((a (b 1) (c (d 2)))))
+		(= (pop-assoc (list 'a 'c 'd) L) '(d 2))
+		(= L '((a (b 1) (c))))
+		(= (pop-assoc '(a c) L) '(c))
+		(= L '((a (b 1))))
+		(= (pop-assoc '(a b) L) '(b 1))
+		(= L '((a)))
+		(= (pop-assoc 'a L) '(a))
+		(= L '())
+		; default functor
+		(set 'D:D '((a (b 1) (c (d 2)))))
+		(= (pop-assoc 'a D) '(a (b 1) (c (d 2))))
+		(= D:D '())
+	)
+)
+
+(define (test-post-url )
+  (= "ERR: HTTP bad formed URL" (post-url "" "abc" "def")))
+
+(define (test-pow )
+  (and
+    (= 1024 (pow 2 10))
+    (= 100 (pow 10))
+))
+
+(define (test-pretty-print)
+  (= (pretty-print) '(80 " " "%1.16g")))
+
+(define (test-primitive? )
+  (primitive? primitive?))
+
+(define (test-print ) 
+  (device (open "testprint" "w"))
+  (print "hello")
+  (close (device))
+  (and (= "hello" (read-file "testprint"))
+     (delete-file "testprint")))
+
+(define (test-println ) 
+  (device (open "testprintln" "w"))
+  (print "hello")
+  (close (device))
+  (and 
+     (= "hello" (slice (read-file "testprintln") 0 5))
+     (delete-file "testprintln")))
+
+(define (test-prob-f)
+  (and
+    (< (abs (sub (prob-f 6,59 3 4) 0,05)) 0,001)
+    (< (abs (sub (prob-f 2,79 12 11) 0,05)) 0,001)
+    (< (abs (sub (prob-f 16,69 3 4) 0,01)) 0,0001)
+    (< (abs (sub (prob-f 4,40 12 11) 0,01)) 0,0001)
+))
+
+(define (test-prob-chi2)
+  (and
+    (< (abs (sub (prob-chi2 4,605 2) 0,1)) 0,001)
+    (< (abs (sub (prob-chi2 51,805 40) 0,1)) 0,001)
+    (< (abs (sub (prob-chi2 9,210 2) 0,01)) 0,0001)
+    (< (abs (sub (prob-chi2 63,691 40) 0,01)) 0,0001)
+))
+
+(define (test-prob-t)
+  (and
+    (< (abs (sub (prob-t 1,886 2) 0,1)) 0,001)
+    (< (abs (sub (prob-t 1,303 40) 0,1)) 0,001)
+    (< (abs (sub (prob-t 6,965 2) 0,01)) 0,0001)
+    (< (abs (sub (prob-t 2,423 40) 0,01)) 0,0001)
+))
+
+(define (test-prob-z)
+    (and
+        (< (sub (prob-z -0,1) 0,4601721627) 0,00001)
+        (< (sub (prob-z 0,1) 0,5398278373) 0,00001)
+        (< (sub (prob-z -1) 0,1586552539) 0,00001)
+        (< (sub (prob-z 1) 0,8413447461) 0,00001)
+        (< (sub (prob-z -2) 0,02275013195) 0,00001)
+        (< (sub (prob-z 2) 0,9772498681) 0,00001)
+        (< (sub (prob-z -3) 0,001349898032) 0,00001)
+        (< (sub (prob-z 3) 0,998650102) 0,00001)
+))
+
+(define (test-process ) 
+   (write-file "processtest" {(write-file "testprocess" "hello") (exit)})
+   (if (find ostype '("Windows" "OS/2"))
+     (process "newlisp processtest") 
+     (process "./newlisp processtest"))
+   (until (file? "testprocess") (sleep 500))
+   (and
+     (= "hello" (read-file "testprocess"))
+     (delete-file "processtest")
+     (delete-file "testprocess")))
+
+(define (test-prompt-event) true) /* test interactively */
+
+(define (test-protected?)
+	(and
+		(protected? 'println)
+		(constant 'cval 123)
+		(protected? 'cval)
+		(protected? 'QA))
+)
+
+(define (test-push , l)
+  (dotimes (x 10) 
+   (push x l x))
+  (and 
+       (= l '(0 1 2 3 4 5 6 7 8 9))
+       (set 'l '(a b (c d () e)))
+       (push 'x l '(2 2 0))
+       (= (ref 'x l) '(2 2 0))
+       (set 'lst '(1 2 3 (4 5)()))
+       (push 'x lst -1 -1)
+       (= lst '(1 2 3 (4 5) (x)))
+       (push 'y lst -1 0)
+       (= lst '(1 2 3 (4 5) (y x)))
+       (push 'z lst -1 1)
+       (= lst '(1 2 3 (4 5) (y z x)))
+       (push 'p lst 4)
+       (= lst '(1 2 3 (4 5) p (y z x)))
+       (push 'q lst -2)
+       (= lst '(1 2 3 (4 5) p q (y z x)))
+       (push 'a lst 3 -3)
+       (= lst '(1 2 3 (a 4 5) p q (y z x)))
+       (= (pop lst 3 -3) 'a)
+       (= (pop lst -2) 'q)
+       (= (pop lst 4) 'p)
+       (= (pop lst -1 1) 'z)
+       (= (pop lst -1 0) 'y)
+       (= (pop lst -1 -1) 'x)
+       (= lst '(1 2 3 (4 5)()))
+       (set 'lst '((1)))
+       (push 2 lst -1 -1)
+       (= lst '((1 2)))
+       (test-push-pop)
+       (test-push-optimization-bug)
+       ; test string push
+       (set 's "newLISP")
+       (= (push "#" s) "#newLISP")
+       (= (push "#" s 1) "##newLISP")
+       (= (push "#" s 3) "##n#ewLISP")
+       (= (push "#" s -1) "##n#ewLISP#")
+       (= (push "#" s -3) "##n#ewLIS#P#")
+       (= (push "xy" s) "xy##n#ewLIS#P#")
+       (= (push "xy" s -1) "xy##n#ewLIS#P#xy")
+       (= s "xy##n#ewLIS#P#xy")
+       (set 's "")
+       (= (push "" s) "")
+       (set 's "newLISP")
+       (= (push "" s -1) "newLISP")
+       (= (push "" s) "newLISP")
+       (= s "newLISP")
+       (push "-" s 7)
+	   (= s "newLISP-")
+	   (push "-" s -9)
+	   (= s "-newLISP-")
+       (set 's "newLISP")
+       (= (push "-" s 8) "newLISP-")
+	   (= (push "-" s -10) "-newLISP-")
+
+		; default functor
+		(set 'D:D '(a b (c d () e)))
+		(push 'x D '(2 2 0))
+		(= (ref 'x D) '(2 2 0))
+		(set 'D:D "newLISP")
+		(= (push "#" D:D) "#newLISP")
+		(= D:D "#newLISP")
+
+))
+
+(define (test-push-pop)
+	; string
+	(set 's "abcdefg")
+	(= (pop (push "h" s -1)) "a")
+	(= s "bcdefgh")
+)
+
+(define (test-push-optimization-bug) ; fixed in 8.7.1
+    (set 'l nil)
+    (and (push 'x l -1)
+         (set 'lst l)
+         (push 'y lst -1)
+         (= lst '(x y))))
+
+
+(define (test-put-url ) 
+  (= "ERR: HTTP bad formed URL" (put-url "" "abc")))
+
+(define (test-pv )
+  (< (sub (pv 0,1 10 1000 100000 0 0) -44696,89605) 1e-05))
+
+(define (test-quote )
+  (= (quote x) 'x))
+
+(define (test-quote? )
+  (quote? ''quote?))
+
+(define (test-rand , sum)
+  (set 'sum 0)
+  (dotimes (x 1000) 
+   (inc sum (rand 2)))
+  (and (< sum 600) (> sum 400) (list? (rand 10 100))))
+
+(define (test-random )
+  (and (float? (random)) (= (length (random 0 1 10)) 10)))
+
+(define (test-randomize)
+  (and
+    (!= '(a b c d e f g) (randomize '(a b c d e f g)))
+    (= (difference '(a b c d e f g) (randomize '(a b c d e f g))) '())
+  )
+)
+
+(define (test-read-expr , code)
+    (and
+        (set 'code "; a statement\n(define (double x) (+ x x))\n")
+        (= (read-expr code (context)) '(define (double x) (+ x x)))
+        (= $count 41))
+)
+
+(define (test-read-buffer )
+  (and
+    (set 'file (open "qa-comma" "read"))
+    (read-buffer file buff (nth 0 (file-info "qa-comma")))
+    (close file)
+    (set 'file (open "junk" "write"))
+    (write-buffer file buff (nth 0 (file-info "qa-comma")))
+    (close file)))
+
+(define test-read test-read-buffer)
+
+(define (test-read-char )
+  (and 
+    (file-copy "qa-comma" "junk")
+    (delete-file "junk")))
+
+(define (test-read-file )
+  (read-file "qa-dot")
+  (starts-with (read-file "file://qa-dot") "#!/usr/bin/env newlisp")
+)
+
+(define (test-read-key) true)
+
+(define (test-read-line )
+  (line-count "qa-comma"))
+
+(define (test-read-utf8)
+  (and
+	(write-file "utf8text.txt" MAIN:utf8str)
+	(setq fle (open "utf8text.txt" "read"))
+	(= (read-utf8 fle) (char (MAIN:utf8str 0)))
+	(close fle)
+	(delete-file "utf8text.txt")
+))	
+
+(define (test-reader-event) true)
+
+
+(define (test-real-path) 
+  (and
+	(string? (real-path))
+    (string? (real-path "."))
+    (not (real-path "foofoo"))
+    (not (real-path "foofoo" true))
+    (if (!= ostype "Windows")
+        (let ( old-path (env "PATH"))
+            (and
+                (env "PATH" (append (real-path) ":" (env "PATH")))
+                ; on Unix newLISP's which() is used to find executable path
+                (= (real-path "newlisp" true) (append (real-path) "/newlisp"))
+                (env "PATH" old-path))
+        )
+        true
+    )
+ ))
+
+(define (test-receive) true) ; tested with qa-message
+
+(define (test-ref)
+  (and
+    (set 'pList '(a b (c d () e)))
+    (push 'x pList 2 2 0)
+    (= (ref 'x pList) '(2 2 0))
+    (= (ref '(x) pList) '(2 2))
+    (set 'v (ref '(x) pList))
+    (= (pList v) '(x))
+    ;(= (ref 'foo pList) '()) changel in 10.2.18
+    (= (ref 'foo pList) nil)
+    ; comparison functor
+    (= (ref 'e '(a b (c d (e) f)) =) '(2 2 0))
+    (= (ref 'e '(a b (c d (e) f)) >) '(0))
+    (= (ref 'e '(a b (c d (e) f)) <) '(2))
+    (= (ref 'e '(a b (c d (e) f)) (fn (x y) (or (= x y) (= y 'd)))) '(2 1))
+    (define (is-it-or-d x y) (or (= x y) (= y 'd)))
+    (= (ref 'e '(a b (c d (e) f)) is-it-or-d) '(2 1))
+    ; comparison with match and unify
+    (= (ref '(a ?) '((l 3) (a 12) (k 5) (a 10) (z 22)) match) '(1))
+    (= (ref '(X X) '( ((a b) (c d)) ((e e) (f g)) ) unify) '(1 0))
+    (= (ref '(X g) '( ((a b) (c d)) ((e e) (f g)) ) unify) '(1 1))
+	; default functor
+	(set 'D:D '((l 3) (a 12) (k 5) (a 10) (z 22)) )
+	(= (ref '(a ?) D match) '(1))
+))
+
+(define (test-ref-all)
+  (and
+    (set 'L '(a b c (d a f (a h a)) (k a (m n a) (x))))
+    (= (ref-all 'a L) '((0) (3 1) (3 3 0) (3 3 2) (4 1) (4 2 2)))
+    (= (L '(3 1)) 'a)
+    (= (map 'L (ref-all 'a L)) '(a a a a a a))
+    (= (ref-all 'a '(1 2 3 4 5 6)) '())
+    ; with comparison functor
+    (set 'L '(a b c (d f (h l a)) (k a (m n) (x))))
+    (= (ref-all 'c L =) '((2)))
+    (= (ref-all 'c L >) '((0) (1) (3 2 2) (4 1)))
+    (= (ref-all 'a L (fn (x y) (or (= x y) (= y 'k)))) ' ((0) (3 2 2) (4 0) (4 1)))
+    (define (is-long? x y) (> (length y) 2))
+    (= (ref-all nil L is-long?) '((3) (3 2) (4)))
+    (define (is-it-or-d x y) (or (= x y) (= y 'd)))
+    (= (ref-all 'e '(a b (c d (e) f)) is-it-or-d) '((2 1) (2 2 0)))
+    (= (ref-all 'b '(a b (c d (e) f)) is-it-or-d) '((1) (2 1)))
+    (= (ref-all nil '(((()))) (fn (x y) (> (length y) 0))) '((0) (0 0)))
+    ; test comparison with match and unify
+    (= (ref-all '(a ?) '((l 3) (a 12) (k 5) (a 10) (z 22)) match) '((1) (3)))
+    (= (ref-all '(X X) '( ((a b) (c d)) ((e e) (f g)) ((z) (z))) unify) '((1 0) (2)))
+    (= (ref-all '(X g) '( ((x y z) g) ((a b) (c d)) ((e e) (f g))) unify) '((0) (2 1)))
+))
+
+
+(define (test-regex )
+  (and
+   (= (regex "http://(.*):(.*)" "http://nuevatec.com:80")
+      '("http://nuevatec.com:80" 0 22 "nuevatec.com" 7 12 "80" 20 2))
+   (= $0 "http://nuevatec.com:80")
+   (= $1 "nuevatec.com")
+   (= $2 "80")
+   (= (regex "b+" "AAAABBBAAAA" 1) '("BBB" 4 3))
+   (= (regex "b+" "AABBBAAABBA" 1 4) '("B" 4 1))
+   (= (regex "b+" "AABBBAAABBA" 1 5) '("BB" 8 2))
+))
+
+ 
+(define (test-regex-comp)
+	(and
+		(set 'pattern (regex-comp "http://(.*):(.*)"))
+		(find pattern "http://nuevatec.com:80" 0x10000)
+		(= $0 "http://nuevatec.com:80")
+		(= $1 "nuevatec.com")
+		(= $2 "80")
+	))
+ 
+(define (test-remove-dir )
+  (and (make-dir "junk") (remove-dir "junk")))
+
+(define (test-rename-file )
+  (copy-file "qa-comma" "junk")
+  (rename-file "junk" "junk2"))
+
+;; this can run only once than must be reloaded
+;; because some replace's are in place with a constant
+(define (test-replace )
+ (and
+  (not (catch (replace "a" "akakak") 'result))
+  (not (catch (replace "a") 'result))
+  (not (catch (replace) 'result))
+  (catch (replace "a" '("x" "a" "y")) 'result)
+  (= (replace "a" "ababab" "b") "bbbbbb")
+  (= $count 3)
+  (= (replace 'a '(a a b a b a a a b a) 'b) '(b b b b b b b b b b))
+  (= (replace 'a '(a a b a b a a a b a)) '(b b b))
+  (= (replace 'a '(a)) '())
+;; with regular expressions option
+  (= (replace "" "abc" "x" 0) "xaxbxcx")
+  (= (replace "$" "abc" "x" 0) "abcx")
+  (= (replace "^" "abc" "x" 0) "xabc")
+  (= (replace "\\b" "abc" "x" 0) "xabcx")
+  (= (replace "(?<=[0-9])(?=(?:[0-9]{3})+(?![0-9]))" "1234567" "," 0) "1,234,567")
+  (= (replace "a" "ababab" (upper-case $0) 0) "AbAbAb")
+  (= $count 3)
+  (set 'str2 "abaBab")
+  (= (replace "b|B" str2 "z" 0) "azazaz")
+  (= $count 3)
+  (replace-once "aaa")
+  (= (replace "%([0-9A-F][0-9A-F])" "%41123%42456%43" (char (int (append "0x" $1))) 1) "A123B456C")
+  ; replace with comparison functor
+  (set 'L '(1 4 22 5 6 89 2 3 24))
+  (= (replace 10 L 10 <) '(1 4 10 5 6 10 2 3 10))
+  (set 'L '(1 4 22 5 6 89 2 3 24))
+  (= (replace 10 L 10 (fn (x y) (< x y))) '(1 4 10 5 6 10 2 3 10))
+  ;
+  (set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+  (= (replace '(mary *)  AL (list 'mary (apply + (rest $it))) match)
+    '((john 5 6 4) (mary 14) (bob 4 2 7 9) (jane 3)))
+  (set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+  (= (replace '(*) AL (list ($it 0) (apply + (rest $it))) match)
+    '((john 15) (mary 14) (bob 22) (jane 3)))
+  (set 'AL '((john 5 6 4) ("mary" 3 4 7) (bob 4 2 7 9) ("jane" 3)))
+  (= (replace nil AL (cons (sym ($it 0)) (rest $it)) (fn (x y) (string? (y 0))))
+    '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+
+  ; default functor
+  (set 'D:D '(a a b a b a a a b a) )
+  (= (replace 'a D 'b) '(b b b b b b b b b b))
+  (set 'D:D "abc")
+  (= (replace "" D "x" 0) "xaxbxcx")
+
+  ; regression for key cell part of list
+  (setq a '(b c d))
+  (= (replace (a 0) a (term (a 0))) '("b" c d))
+))
+ 
+(define (replace-once str)
+  (= (replace "a" str (upper-case $0) 0x8000) "Aaa") ;; custom option replace once
+)
+
+(define (test-reset )
+  true)
+
+(define (test-rest , l)
+  (set 'l '(a b c d e f g))
+  (and  (= (cons (first l) (rest l)) l)
+    (= (rest "newlisp") "ewlisp")
+;; implicit nrest
+        (= (1 l) '(b c d e f g))
+    (= (10 l) '())
+    (= (0 l) l)
+    (= (-3 '(a b c d e f g)) '(e f g))
+        (= (-3 "abcdefg") "efg")
+    (= (1 '(A)) '())
+    (= (1 "A") "")
+    (= (array 2 2 (sequence 3 6)) (rest (array 3 2 (sequence 1 6))))
+))
+
+(define (test-reverse )
+  (and
+    (= (reverse '(1 2 3)) '(3 2 1))
+    (= (reverse "newLISP") "PSILwen")
+	(set 'D:D '(1 2 3))
+	(= (reverse D) '(3 2 1))
+	(set 'D:D "newLISP")
+	(= (reverse D) "PSILwen")
+    (set 'a (array 2 3 '(1 2 3 4 5 6)))
+    (reverse a)
+    (= a (array 2 3 '(4 5 6 1 2 3)))
+))
+
+(define (test-rotate )
+  (and
+    (= '(8 9 0 1 2 3 4 5 6 7) (rotate '(0 1 2 3 4 5 6 7 8 9) 2))
+    (= '() (rotate '()))
+	(= (rotate '(1) -1) '(1))
+	(= (rotate "") "")
+	(= (rotate "x" -1) "x")
+	(set 'str "abcdefg")
+	(= (rotate str) "gabcdef")
+	(= (rotate str 3) "defgabc")
+	(= (rotate str -4) "abcdefg")
+    (set 'D:D '(0 1 2 3 4 5 6 7 8 9))
+    (= '(8 9 0 1 2 3 4 5 6 7) (rotate D 2))
+))
+
+(define (test-round)
+	(and
+		(= (round 1,25)  (round 1,25 0) 1)
+		(= (round 3,89) (round 3,89 0) 4)
+		(= (round 123,49 2) 100)
+		(= (round 123,49 1) 120)
+		(= (round 123,49 0) 123)
+		(= (round 123,49 -1) 123,5)
+		(= (round 123,49 -2) 123,49)
+		(= (round 123,49 -3) 123,49)
+		(!= (round 123,49 -2) 123,49000000000001)
+		(= (round 123,49 3)  0)
+        (= (round 0,05 -1) 0,1)
+		(= (round 0,5) 1)
+        (= (round 5 1) 10)    
+))
+
+(define (test-save )
+  (and (save "all") (save "save.lsp" 'test-save) (delete-file "all") 
+   (delete-file "save.lsp")))
+
+(define (test-search , file)
+  (and
+    (set 'file (open "qa-comma" "read"))
+    (search file "define")
+    (close file)))
+
+(define (test-seed )
+  (seed 123)
+  (set 'a (rand 10))
+  (seed 123)
+  (set 'b (rand 10))
+  (= a b)
+  ; built-in PRNG with state recall
+  (seed 123 true)
+  (rand 100 100)
+  (set 'state (seed)) ; save state
+  (set 'r1 (rand 100 100))
+  (rand 100 100) 
+  (normal 10 3 100)
+  (seed state true 0) ; recall state
+  (= r1 (rand 100 100))
+)
+
+(define (test-seek , file chr)
+  (set 'file (open "junk" "write"))
+  (dotimes (x 100) 
+   (write-char file x))
+  (close file)
+  (set 'file (open "junk" "read"))
+  (seek file 65)
+  (set 'chr (read-char file))
+  (close file)
+  (delete-file "junk")
+  (= chr 65))
+
+(define (test-select )
+  (set 'l '(0 1 2 3 4 5 6 7 8 9))
+  (and
+    (test-select-collect)
+    (= (select l '(0 9 9 0 1 8 8 1)) '(0 9 9 0 1 8 8 1))
+    (= (select "2001-09-20" '(5 6 8 9 0 1 2 3)) "09202001")
+	; default functor
+	(set 'D:D '(0 1 2 3 4 5 6 7 8 9))
+    (= (select D '(0 9 9 0 1 8 8 1)) '(0 9 9 0 1 8 8 1))
+))
+
+(new Class 'MAIN:Circle)
+(define (test-self)
+	(define (Circle:move dx dy) (inc (self 1) dx) (inc (self 2) dy))
+	(set 'myc (list (Circle 1 2 3) (Circle 4 5 6)))
+	(:move (myc 0) 10 20)
+	(:move (myc 1) 10 20)
+	(= myc '((Circle 11 22 3) (Circle 14 25 6)))
+)
+
+;; for testing semaphores accross processes/threads see test-share
+(define (test-semaphore)
+  (and
+    (set 'sid (semaphore))
+ 	(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+		(= (semaphore sid) 0) true) ;; no semaphore status on Win32/64
+    (semaphore sid 1)
+ 	(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+        (= (semaphore sid) 1) true) ;; no semaphore status on Win32/64
+    (semaphore sid 0)))
+
+(define (test-send) true) ; tested with qa-message
+
+(define (test-sequence )
+  (= (sequence 1 10 3) '(1 4 7 10)))
+
+(define (test-series )
+  (and
+    (= (series 2 2 5) '(2 4 8 16 32))
+    (= (series 2 2 0) '())
+    (= (series 1 2 -10) '())
+    (= (series 1 1 5) '(1 1 1 1 1))
+))
+
+(define (test-set , x y z)
+  (set 'x (set 'y (set 'z 123)))
+  (= x 123))
+
+(define (test-setf)
+ (and
+    (setf l '(a b c d e f g))
+    (setf (nth 3 l) 999)
+    (= l '(a b c 999 e f g))
+    (set 's "abcdefg")
+    (setf (s 3) (upper-case $it))
+    (= s "abcDefg")
+    (set 's "a-b-c-d-e-f-g")
+    (setf (first (replace "-" s "")) (upper-case $it))
+    (= s "Abcdefg")    
+    (setf (s 2) "CCC")
+    (= s "AbCCCdefg")
+    (= (setf ((copy '(a b c)) 1) 'B) 'B)
+))
+
+
+(define (test-setq , x y z)
+  (setq x 1 y 2 z 3)
+  (and (= x 1) (= y 2) (= z 3)))
+
+
+(define (test-set-ref)
+	(and
+		(set 'L '(z a b (z) (d (c c (c)) e f c))) 
+		(= (set-ref 'c L 'z) '(z a b (z) (d (z c (c)) e f c)))
+		(set 'L '((a 1) (b 2) (a 3) (b 4)))	
+		(= (set-ref '(a *) L '(z 99) match) '((z 99) (b 2) (a 3) (b 4)))
+		(= (set-ref '(a *) L '(z 99) match) '((z 99) (b 2) (z 99) (b 4)))
+		(set 'Ct:Ct '(a b c d e f g))
+		(= (set-ref  'c Ct 'z) '(a b z d e f g))
+		; default functor
+		(set 'D:D '(z a b (z) (d (c c (c)) e f c))) 
+		(= (set-ref 'c D 'z) '(z a b (z) (d (z c (c)) e f c)))
+	)
+)
+
+
+(define (test-set-ref-all)
+    (and
+		(set 'L '(z a b (c) (d (c c (c)) e f c))) 
+		(= (set-ref-all 'c L 'z) '(z a b (z) (d (z z (z)) e f z)))
+		(set 'L '((a 1) (b 2) (a 3) (b 4)))
+		(= (set-ref-all '(a *) L '(z 99) match) '((z 99) (b 2) (z 99) (b 4)))
+    )
+)
+
+(define (test-share)
+    (and 
+      (if (find ostype '("Windows" "OS/2"))
+          (win32-test-share)
+          (unix-test-share))
+      (set 'mvar (share))
+      (not (share mvar nil))
+      (= (share mvar) nil)
+      (share mvar true)
+      (= (share mvar) true)
+      (share mvar 123)
+      (= (share mvar) 123)
+      (share mvar 123,456)
+      (= (share mvar) 123,456)
+      (share mvar "hello")
+      (= (share mvar) "hello")
+      ; check sizes > pagesize
+	  (share mvar (dup "X" 10000))
+      (= 10000 (length (share mvar)))
+      ; force deletion of temporary file
+      (not (share mvar nil))
+))
+
+(define (win32-test-share)
+    (write-file "sharetest.lsp"
+[text]
+(map set '(sid mm) (map int (slice (main-args) 2)))
+(if (= (share mm) "hello") (share mm "HELLO"))
+(semaphore sid 1) ; signale parent to read
+(exit)
+[/text]
+    )
+  (and
+    (set 'sid (semaphore))
+    (set 'mm (share))
+    (share mm "hello")
+    (if (find ostype '("Windows" "OS/2"))
+      (process (string "newlisp sharetest.lsp " sid " " mm))
+      (process (string "./newlisp sharetest.lsp " sid " " mm)))
+    (semaphore sid -1) ; wait for child process
+    (semaphore sid 0) ;; delete semaphore
+    (= (share mm) "HELLO")
+    (or (delete-file "sharetest.lsp") true)))
+
+
+(define (unix-test-share)
+  (and
+    (set 'mm (share))
+    (share mm "hello")
+
+    (wait-pid (fork (begin
+            (if (= (share mm) "hello")
+                (share mm "HELLO"))
+                (exit ))))
+		
+    (= (share mm) "HELLO")
+    (share nil mm) ; unmap share
+))
+
+(define (test-sgn)
+ (and
+   (= 0 (sgn 0))
+   (= 1 (sgn 123))
+   (= -1 (sgn -3,5))))
+
+(define (test-signal)
+  (primitive? signal))
+
+
+(define (test-silent )
+  (primitive? silent))
+
+(define (test-sin )
+  (= 1 (sin (asin (sin (asin 1))))))
+
+(define (test-sinh)
+	(< (abs (sub (tanh 1) (div (sinh 1) (cosh 1))))  0,0000000001)
+)
+
+(define (test-sleep )
+  (set 'start (time-of-day))
+  (sleep 10)
+  (set 'start (time-of-day))
+  (sleep 1000)
+  (set 'duration (- (time-of-day) start))
+  (and (> duration 500) (< duration 1500)))
+
+(define (test-slice )
+ (and 
+   (set 'str "0123456789")
+   (= (slice str 0 1) "0") 
+   (= (slice str 0 3) "012") 
+   (= (slice str 8 2) "89") 
+   (= (slice str 8 10) "89") 
+   (= (slice str 20 10) "")
+   (= (slice str 2 -2) "234567")
+   (= (slice str 2 -5) "234")
+   (= (slice str 2 -7) "2")
+   (= (slice str 2 -8) "")
+   (= (slice str 2 -9) "")
+   (= (slice '(a b c d e f g) 3 1) '(d))
+   (= (slice '(a b c d e f g) 3 0) '())
+   (= (slice '(a b c d e f g) 0 0) '())
+   (= (slice '(a b c d e f g) 10 10) '())
+   (= (slice '(a b c d e f g) 3 2) '(d e))
+   (= (slice '(a b c d e f g) 5) '(f g))
+   (= (slice '(a b c d e f g) -5 2) '(c d))
+   (= (slice '(a b c d e f g) -1 -2) '())
+   (= (slice '(a b c d e f g) 1 -2) '(b c d e))
+   (= (slice '(a b c d e f g) 4 -2) '(e))
+   (= (slice '(a b c d e f g) 4 -3) '())
+   (= (slice '(a b c d e f g) 4 -4) '())
+   (= (slice '(a b c d e f g) -6 -3) '(b c d))
+;; implicit slice
+   (= (1 3 '(a b c d e f g)) '(b c d))
+   (= (-4 2 '(a b c d e f g)) '(d e))
+   (= (1 3 "abcdefg") "bcd")
+   (= (-4 2 "abcdefg") "de")
+   (= (1 -3 "abcdefg") "bcd")
+   (= (1 -5 "abcdefg") "b")
+   (=  (1 -7 "abcdefg") "")
+   (setq x 1 y 2)
+   (= (x y '(a b c d e f g)) '(b c))
+   (= (x y "abcdefg") "bc")
+   (= (1 -2 '(a b c d e f g)) '(b c d e))
+   (= (4 -2 '(a b c d e f g)) '(e))
+   (= (4 -3 '(a b c d e f g)) '())
+   (= (4 -4 '(a b c d e f g)) '())
+   (= (-6 -3 '(a b c d e f g)) '(b c d))
+   ; default functor
+   (set 'D:D "0123456789")
+   (= (slice D 0 1) "0") 
+   (= (slice D 0 3) "012") 
+   (set 'D:D '(a b c d e f g))
+   (= (slice D 3 1) '(d))
+   (= (1 3 D) '(b c d))
+))
+
+(define (test-sort )
+  (and
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5)))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5)))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5) <))
+    (= '(9 8 7 6 5 4 3 2 1) (sort '(9 1 8 2 7 3 6 4 5) >))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5) (fn (x y) (< x y))))
+    (= '(9 8 7 6 5 4 3 2 1) (sort '(9 1 8 2 7 3 6 4 5) (fn (x y) (> x y))))
+    (= '() (sort '()))
+	(= (sort '(1 nil)) '(nil 1))
+	(= (sort '(a nil true 1 1,2)) (sort (list 'a nil true 1 1,2)) '(nil true 1 1,2 a))
+    ;; at runtime generated sort function v10.4.6
+    (define (f<g= f g)
+        (expand (fn (a b) (f (g a) (g b))) 'f 'g))
+    (set 'lst '((c 4) (b 5) (a 2)))
+    (= (sort lst (f<g= < last)) '((a 2) (c 4) (b 5)))
+  )
+)
+
+(define (test-source)
+  (= (replace "\r|\n" (source 'test-sin) "" 0) 
+     "(define (test-sin )  (= 1 (sin (asin (sin (asin 1))))))"))
+
+(define (test-sqrt )
+  (and (= 10 (sqrt 100)) (= 1,2 (sqrt 1,44))))
+
+(define (test-ssq)
+	(= 385 (ssq (sequence 1 10)) (ssq (array 10 (sequence 1 10))))
+)
+
+(define (test-starts-with )
+  (and 
+	(starts-with "newlisp" "new") 
+	(starts-with "newlisp" "NEW" 1)
+	(set 'D:D "newlisp")
+	(starts-with D "new") 
+	(starts-with D "NEW" 1)
+))
+
+(define (test-stats)
+    (< (apply add (map sub (stats '(1 2 3 4 5)) '(5 3 1,2 1,58113883 2,5 0 -1,912))) 0,000000001)
+)
+
+(define (test-string )
+  (and (string? (string 12345)) (= (string 12345) "12345") (string? 
+    (string 1.234)) 
+   (= (string 'test-string) "test-string") 
+   (string? (string test-string)) 
+   (= (string "a" "b" "c") (append "a" "b" "c") "abc") 
+   (= (string "a" 123 "b") "a123b")))
+
+(define (test-string? )
+  (and (string? "1234") (not (string? 1234))))
+
+(define (test-struct) ; more tests in qa-libffi
+    (struct 'complex "double" "double")
+    (= (unpack complex (pack complex 1,23 4,56)) '(1,23 4,56)))
+
+
+(define (test-sub )
+  (= 0 (sub 0,99999999 0,99999999))
+  (= -123 (sub 123)))
+
+(define (test-swap )
+  (and 
+	; new (swap <place1> <place2>) in 10.0.3
+	(set 'lst '(1 2 3 4))
+	(= (swap (first lst) (last lst)) 1)
+	(= lst '(4 2 3 1))
+	(= (swap (lst 0) (lst -1)) 4)
+	(= lst '(1 2 3 4))
+	(set 'A (array 2 3 (sequence 1 6)))
+	(= (swap (A 0 0) (A -1 -1)) 1)
+	(= A (array 2 3 (flat '((6 2 3) (4 5 1)))))
+	(set 'lst '(a b c d))
+	(set 'x 'z)
+	(= (swap (lst 0) x) 'a)
+	(= lst '(z b c d))
+	(= x 'a)
+  )
+)
+
+(define (test-sym)
+  (and (= (sym "test-sym") 'test-sym) 
+       (= (sym "test-sym" 'QA) 'test-sym)))
+
+(define (test-symbol? )
+	(and
+  		(symbol? (sym "test-sym"))
+		(symbol? (sym "a b"))
+))
+
+
+(define (test-symbols )
+  (and (list? (symbols)) (> (length (symbols)) 0)))
+
+(define (test-sys-error) true)
+;	(integer? (sys-error 0) ))
+
+(define (test-sys-info )
+   (and (list? (sys-info)) (= (length (sys-info)) 10)))
+
+(define (test-tan )
+  (> 1 (tan (atan (tan (atan 1))))))
+
+(define (test-tanh)
+	(< (abs (sub (sinh 1) (div (sub (exp 1) (exp -1)) 2))) 0,0000000001)
+)
+
+(define (test-term )
+  (= "term" (term 'term)))
+
+(define test-name test-term)
+
+(define (test-throw )
+  (and (catch (throw (+ 3 4)) 'msg) (= msg 7)))
+
+(define (test-time )
+	(float? (time))
+)
+
+(define (test-time-of-day )
+  (float? (time-of-day)))
+
+(define (test-trace )
+  (trace nil)
+  (= nil (trace)))
+
+(define (test-trace-highlight )
+  (trace-highlight "#" "#"))
+
+(define (test-transpose )
+  (= '((1) (2) (3)) (transpose '((1 2 3))))
+  (= '((a b) (c d) (e f)) (transpose '((a c e) (b d f))))
+  (= '((a d f) (b e g) (c nil nil)) (transpose '((a b c) (d e) (f g))))
+  (= '((a c f) (b d g)) (transpose '((a b) (c d e) (f g)))))
+
+(define (test-trim )
+  (and 
+    (= (trim "  \n \t  h e l l o \r   ") "h e l l o") 
+    (= (trim "    hello    ") "hello") 
+    (= (trim "----hello----" "-") "hello")
+    (= (trim "----hello====" "-" "=") "hello")
+    (= (trim "000012345" "0" "") "12345")))
+
+(define (test-true?)
+ (= (map true? '(x nil  1 nil "hi" ())) '(true nil true nil true nil)))
+
+
+(define (test-unify)
+	(and
+		(= (unify 'A 'A) '())
+		(= (unify 'X 123) '((X 123)))
+        (= (unify '(Int Flt Str Sym Lst) '(123 4,56 "Hello" s '(a b c)))
+                  '((Int 123) (Flt 4,56) (Str "Hello") (Sym s) (Lst '(a b c))))
+		(= (unify '(A B "hello") '("hi" A Z)) '((A "hi") (B "hi") (Z "hello")))
+		(= (unify '(A B) '(B abc)) '((A abc) (B abc)))
+		(= (unify '(B A) '(abc B)) '((B abc) (A abc)))
+		(= (unify '(A A C D) '(B C 1 C)) '((B 1) (A 1) (C 1) (D 1)))
+		(= (unify '(D C A A) '(C 1 C B)) '((D 1) (C 1) (B 1) (A 1)))
+		(= (unify '(f A) '(f (a b c))) '((A (a b c))))
+		(= (unify '(A f) '((a b c) f)) '((A (a b c))))
+		(= (unify '(f (g A)) '(f B)) '((B (g A))))
+		(= (unify '(p X Y a) '(p Y X X)) '((Y a) (X a)))
+		(= (unify '(p X Y) '(p Y X)) '((Y X)))
+		(= (unify '(q (p X Y) (p Y X)) '(q Z Z)) '((Y X) (Z (p X X))))
+		(= (unify '(f (g A) A) '(f B xyz)) '((B (g xyz)) (A xyz)))
+		(= (unify '(A (g abc)) '(B A)) '((B (g abc)) (A (g abc))))
+		;; with additional environment list
+		(= (unify '(A (B) X) '(A (A) Z) '((A 1) (Z 4)))
+		   ' ((A 1) (Z 4) (B 1) (X 4)))
+))
+
+(define (test-unicode)
+  (= (utf8 (unicode "newLISP")) "newLISP"))
+
+(define (test-union)
+    (= (union '(1 3 1 4 4 3) '(2 1 5 6 4)) '(1 3 4 2 5 6)))
+
+(define (test-unique )
+  (= (unique '(2 3 4 4 6 7 8 7)) '(2 3 4 6 7 8)))
+
+(define (test-utf8len)
+	(= 23 (utf8len MAIN:utf8str)))
+
+(define (test-unless )
+	(and 
+		(= (unless nil (set 'x 1) (set 'y 2) (set 'z 3)) 3)
+		(= x 1) (= y 2) (= z 3)
+		(= (unless 123) 123)
+		(= (unless true) true)
+		(= (unless nil) nil)
+))
+
+(define (test-unpack )
+  (= (pack "c c c" 65 66 67) "ABC")
+  (= (unpack "c c c" "ABC") '(65 66 67)))
+
+(define (test-until , x)
+  (set 'x 0)
+  (= 10 (until (= x 10) (inc x)) x))
+
+(define (test-do-until , x)
+  (set 'x 0)
+  (and 
+   (= 10 (do-until (= x 10) (inc x)) x)
+   (= 11 (do-until (> x 0) (inc x)) x)
+))
+
+(define (test-upper-case )
+	(= (upper-case "abcdefghijklmnopqrstuvwxyz") "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+
+(define (test-utf8)
+  (and
+    (= (utf8 (unicode "newLISP")) "newLISP")
+    (MAIN:utf8qa)))
+
+(define (test-uuid)
+    (= 36 (length (uuid))))
+
+(define (test-wait-pid)
+  (set 'pid (fork (begin (sleep 200)(exit))))
+  (wait-pid pid))
+
+(define (test-when)
+	(and 
+		(= (when true (set 'x 1) (set 'y 2) (set 'z 3)) 3)
+		(= x 1) (= y 2) (= z 3)
+		(= (when 123) 123)
+		(= (when nil) nil))
+)
+
+(define (test-while , x)
+  (and
+    (set 'x 0)
+    (= 1000 (while (< x 1000) (inc x)) x)
+))
+
+(define (test-do-while, x)
+  (and
+    (set 'x 0)
+    (= 100 (do-while (< x 100) (inc x)) x)
+    (= 101 (do-while (< x 100) (inc x)) x)
+))
+
+(define (test-write-buffer )
+  (set 'str "")
+  (dotimes (x 5) (write-buffer str "hello"))
+  (set 'Bf:Bf "")
+  (set 'S:S "hello")
+  (dotimes (x 5) (write-buffer Bf S))
+  (and 
+    (= str "hellohellohellohellohello")
+    (= Bf:Bf str)
+    (test-read-buffer)
+	(set 'str "")
+	(write-buffer str S 3)
+	(= str "hel")
+))
+
+(define test-write test-write-buffer)
+
+(define (test-write-char )
+  (file-copy "qa-comma" "junk")
+  (delete-file "junk"))
+
+(define (test-write-file )
+ (and
+  (write-file "junk" "newlisp")
+  (write-file "file://junk2" "hello")
+  (= (read-file "junk") "newlisp")
+  (= (read-file "file://junk2") "hello")
+  (delete-file "file://junk2")
+))
+
+(define (test-write-line ) 
+  (and
+    (set 'fle (open "testwrite" "w"))
+    (write-line fle "hello")
+    (close fle)
+    (set 'fle (open "testwrite" "r"))
+    (= (read-line fle) "hello")
+    (close fle)
+    (delete-file "testwrite")  
+    (set 'Bf:Bf "")
+	(set 'S:S "hello world")
+	(write-line Bf S)
+	(if (find ostype '("Windows") )
+		(= Bf:Bf "hello world\r\n")
+		(= Bf:Bf "hello world\n"))
+))
+
+(define (test-xfer-event)
+  (not (xfer-event)))
+
+(define (test-xml-error )
+  (= (xml-error) nil))
+
+(define (test-xml-parse )
+  (= (xml-parse "<hello att='value'></hello>") '(("ELEMENT" "hello" 
+     (("att" "value")) 
+     ()))))
+
+(define (test-xml-type-tags )
+  (length (xml-type-tags) 4))
+
+(define (test-zero?)
+  (= (map zero? '(1 0 1,2 0,0)) '(nil true nil true)))
+
+(define (test-| )
+  (= (| -1431655766 1431655765) -1))
+
+(define (test-~ )
+  (and
+    (= (~ 0) -1)
+    (if 
+        (find ostype '("Windows" "OS/2"))
+        (= (format "%I64x" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f")
+
+        (= ostype "True64Unix")
+        (= (format "%lx" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f")
+
+        (= (format "%llx" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f"))
+))
+
+;;;;;;;;;;;;;;;; test Cilk interface, run qa-cilk for more tests ;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define (test-abort)
+	(and 
+		(spawn 'x (+ 1 2))
+		(abort)))
+
+(define (test-spawn)
+	(and 
+		(set 'px (spawn 'x (+ 1 2 3 4)))
+		(set 'py (spawn 'y (+ 5 6 7 8)))
+		(if (!= ostype "Windows") 
+			(begin
+				(find px (sync))
+        		(find py (sync)))
+			true)
+        (true? (sync 1000))
+		(empty? (sync))
+		(= x 10)
+		(= y 26)
+))
+
+(define (test-sync) true)
+(define (test-schedule) true)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; MAIN ENTRY POINT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(if (or (not (or (file? "newlisp") (file? "newlisp.exe"))) (not (file? "qa-comma")))
+	(begin
+		(println "both newlisp(.exe) and qa-comma should be in the current directory.")
+		(exit)))
+
+(cleanup)
+(println)
+(println "Testing built-in functions ...")
+(println)
+(qa)
+(cleanup)
+
+(context 'MAIN)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(println)
+(println "Testing contexts as objects and scoping rules ...")
+(println)
+
+;; check creating local symbols
+;; in case they already exist in MAIN
+(set 'var 123)
+(set 'CTX:var 456)
+(if (or (!= CTX:var 456) (!= var 123))
+	(println " >>>> problem creating local symbols"))
+
+(set 'ctx CTX)
+
+(global 'myprint)
+(set 'myprint print)
+
+;; following would fail without dynamic symbols for non-existing
+;; contexts because 'accnt' is not a context at this moment
+(define (report accnt)
+    (list accnt:name accnt:balance))
+
+;; late in ACCOUNT the definition of 'deposit' should
+;; should not fail, locals should always be created for
+;; the current context
+(constant 'amount 999)
+(constant 'stat 999)
+
+;; the symbol defined should always be forced into the current
+;; context, even if alread exists in MAIN, if not following
+;; definition of 'deposit' would fail
+(set 'deposit 999) 
+(set 'clear 999)
+(constant 'withdraw 999) 
+
+(define balance 1000.00)
+(constant 'phone "123-456-789")
+
+
+(context 'ACCOUNT)
+    (set 'ACCOUNT:term "")      ; force creation of local symbol with
+    (define balance 0,0)  	; same name as built in primitive
+    (set 'phone "")     
+    (constant 'const "foo")  ; a protected variable
+
+    (define (deposit amount)
+        (inc balance amount))
+
+    (define (withdraw amount)
+        (dec balance amount))
+    
+    ; make sure contexts are inherited
+    ; but not variables containing contexts
+    (if (not (context? CTX)) 
+	(QA:failed " >>>> problem inheriting context symbols"))
+
+    ; make sure context variables get not inherited
+    (if (= ctx CTX) (QA:failed " >>>> should not inherit context var"))
+    
+    (set 'ctx 123)
+
+    ; make sure redefined primitives get inherited
+    (if (not (primitive? myprint)) 
+    	(QA:failed " >>>> problem inheriting redefined primitives"))
+
+(set 'myprint nil)
+   
+(context 'MAIN)
+
+;; make sure again that context defs did not overwrite MAIN symbols
+(if (or (!= deposit 999) (!= clear 999) (!= withdraw 999) (!= stat 999) (!= ctx CTX)
+        (not (primitive? term)) (!= balance 1000.0) (!= phone "123-456-789"))
+	(QA:failed " >>>> context definitions are overwriting MAIN"))
+
+(new ACCOUNT 'John true)     ; this creates a new context copy of 
+                             ; ACCOUNT called 'John' if exists overwrite symbols
+
+(set 'John:name "John Doe")
+(set 'John:phone "555-123-456")
+
+(unless (protected? 'John:const)
+    (QA:failed ">>>> symbol protection has not been copied"))
+
+(John:deposit 100,00)
+(John:withdraw 60)
+
+(new ACCOUNT 'Anne true)
+
+(set 'Anne:name "Anne Somebody")
+(set 'Anne:phone "555-456-123")
+
+(Anne:deposit 120,00)
+(Anne:withdraw 50)
+(if (or (!= John:balance 40) (!= Anne:balance 70))
+	(QA:failed " >>>> problem with methods in contexts"))
+
+(if (or (!= (report John) (list John:name John:balance))
+        (!= (report Anne) (list Anne:name Anne:balance)))
+    (QA:failed " >>>> problem using context variables"))
+
+(if (!= (map report (map eval '(John Anne))) 
+       '(("John Doe" 40) ("Anne Somebody" 70)) )
+    (QA:failed " >>>> problem mapping functions using context vars"))
+
+
+;; dynamic context var as symbol to be defined
+;;
+(define (defit)
+	(define (ctx:foo x) (+ x x)))
+
+(set 'ctx ACCOUNT)
+(defit)
+(if (!= (ctx:foo 10) 20) 
+  (QA:failed " >>>> problem with dyna symbols in defined symbol"))
+
+
+;; check setq, define (as set) and inc, dec on dynamic context vars
+;;
+(define (foo-set ct value) (set 'ct:var value))
+(define (foo-setq ct value) (setq ct:var value))
+(define (foo-define ct value) (define ct:var value))
+(define (foo-inc ct value) (inc ct:var))
+(define (foo-dec ct value) (dec ct:var))
+
+(set 'CTX:var 0) ;; make sure var is existent
+(foo-set CTX 1)
+(if (!= 1 CTX:var) 
+  (QA:failed " >>>> problem with set on context vars"))
+
+(foo-setq CTX 3)
+(if (!= 3 CTX:var) 
+  (QA:failed " >>>> problem with setq on context vars"))
+
+(foo-define CTX 4)
+(if (!= 4 CTX:var) 
+  (QA:failed " >>>> problem with define on context vars"))
+
+(foo-inc CTX)
+(if (!= 5 CTX:var) 
+  (QA:failed " >>>> problem with inc on context vars"))
+
+(foo-dec CTX)
+(if (!= 4 CTX:var) 
+  (QA:failed " >>>> problem with dec on context vars"))
+
+;; dynamic context vars inside a context (since version 7.5.1)
+
+(context 'TST)
+
+(define (init ctx value)
+	(set 'ctx:foo value))
+
+;; since version 8.7.8 when calling a function in a context the current runtime
+;; context changes
+(define (test-context-change)
+	(= (context) TST))
+
+(context MAIN)
+
+;; foo does not exist in CTX
+
+(TST:init CTX 999)
+
+(if (!= 999 CTX:foo) 
+  (QA:failed " >>>> problem with dyna vars in contexts"))
+
+;; now foo does exist
+(TST:init CTX 222)
+
+(if (!= 222 CTX:foo)
+  (QA:failed " >>>> problem with dyna vars in contexts"))
+
+
+(define (cdf:cdf a b) (+ a b))
+
+(if (!= (cdf 3 4) 7) 
+  (QA:failed " >>>> problem with context default vars"))
+
+;; check for existence of dynamic context symbol
+
+(define (check-sym-existence ctx)
+  (if (symbol? 'ctx:foovar) ;; will not create is only check
+    (QA:failed " >>>> problem with symbol? for dyna vars")))
+
+(check-sym-existence CTX)
+
+;; do not overwrite existing symbols
+
+(set 'Actx:x 123)
+(set 'Actx:y 456)
+(set 'Bctx:x 999)
+
+(new Actx Bctx)
+
+(if (not (= Bctx:x 999))
+  (QA:failed " >>>> problem with new in overwriting symbols"))
+
+;; delete contexts
+ (if (not (and
+        (delete 'ACCOUNT)
+        (delete 'Anne)
+        (delete 'John)
+;		(map delete '(Actx Bctx cdf))
+      ) )
+    (QA:failed " >>>> problem deleting contexts"))
+
+;; define static default functions
+
+(define foobar:foobar)
+
+(define (def-static s contents)
+   (def-new 'contents (sym (term s) s)))
+
+(if (not 
+  (and
+    (def-static 'foobar (fn (x) (+ x x)))
+    (= foobar:foobar (lambda (foobar:x) (+ foobar:x foobar:x)))
+    (= (foobar 10) 20)))
+  (QA:failed " >>>> problem with static default function definition"))
+
+;; calling into context changes context
+(if (not TST:test-context-change)
+  (QA:failed " >>>> problem changing runtime context with symbol"))
+
+;; but calling with raw lambda doesn't
+(if ((eval TST:test-context-change))
+  (QA:failed " >>>> problem maintaining runtime context with lambda"))
+
+;; apply evaluates functor
+(if (not (apply 'TST:test-context-change))
+  (QA:failed " >>>> problem changing runtime context with apply symbol"))
+
+;; apply evaluates functor
+(if (apply TST:test-context-change)
+  (QA:failed " >>>> problem maintaining runtime context with apply lambda"))
+
+;; map evaluates functor
+(if (!= (map 'TST:test-context-change '(a b c)) '(true true true))
+  (QA:failed " >>>> problem changing runtime context with map symbol"))
+
+;; map evaluates functor
+(if (!= (map TST:test-context-change '(a b c)) '(nil nil nil))
+  (QA:failed " >>>> problem maintaining runtime context with map lambda"))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;; testing the default functor ;;;;;;;;;;;;;;;
+
+(define (double:double x) (+ x x))
+
+(define (test-default-functor)
+	(and
+		(= (map double '(1 2 3 4 5)) '(2 4 6 8 10))
+		(= (map 'double '(1 2 3 4 5)) '(2 4 6 8 10))
+		(set 'dflt:dflt '(a b c d e f g))
+		(= (map dflt '(1 2 6)) '(b c g))
+		(set 'i 0 'j -1 'k 6)
+		(= (dflt i) 'a)
+		(= (dflt k) 'g)
+		(= (dflt j) 'g)
+		 
+))
+
+(if (not (test-default-functor))
+	(QA:failed " >>>> problem testing default functor"))
+	
+;; hash-like access functions for namespaces
+(if (not (and
+	(nil? (define Foo:Foo)) ; create namespace and default functor
+	(= (Foo "bar" 123) 123)
+	(= (Foo "bar") 123)
+	(= (Foo "bar" (+ 100 23)) 123)
+	(= (Foo (append "b" "ar")) 123)
+	(= (Foo '(("var" 123) ("bar" 456) ("baz" 789))) 'Foo)
+	(= (Foo) '(("bar" 456) ("baz" 789) ("var" 123)))
+	(= (Foo "var" (* 2 (Foo "var"))) 246)
+    (= (Foo 123 "hello") "hello" (Foo 123))
+    (nil? (Foo 123 nil))
+	)) (QA:failed " >>>> problem with hash functions for namespaces") true)
+
+		
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(println)
+(if QA:failed-messages
+  (begin
+    (println "TESTING FINISHED WITH ERRORS:")
+    (println)
+    (dolist (func (reverse QA:failed-messages))
+        (println func)))
+  (println "ALL FUNCTIONS FINISHED SUCCESSFULL"))
+
+(println)
+(delete-file "sharetest.lsp")
+(delete-file "udptest.lsp")
+
+
+(println "total time: " (- (time-of-day) start-of-qa))
+
+(unless do-not-exit (exit))
+
+
+;; eof
+
diff --git a/qa-dot b/qa-dot
new file mode 100755
index 0000000..08063ba
--- /dev/null
+++ b/qa-dot
@@ -0,0 +1,3713 @@
+#!/usr/bin/env newlisp
+(set 'start-of-qa (time-of-day))
+;;
+;; General test suite testing functioning of all built in primitives.
+;;
+;; use from inside the newlisp-x.x.x/ directory
+;;
+;;   ./newlisp qa-dot
+;;
+;;   or for countries and configurations with decimal comma 
+;;
+;;   ./newlisp qa-comma (for countries and configurations with decimal , )
+;;
+
+(set (sym "test-:" 'QA) (lambda () true))
+(context 'Lex)  ; predeclare/create context for bayes-train
+(context MAIN)
+
+(set-locale "C")
+
+(when utf8
+ (set-locale "en_US")
+ (set 'unicodelist '(913 914 915 916 937 945 946 947 948 969 32 
+                 1040 1041 1042 1043 1044 1072 1073 1074 1075 1076 13 10))
+ (set 'utf8str (join (map char unicodelist)))
+ (unless (catch (regex-comp (join (map char '(12411 12370 12411 12370)))) 'result)
+	(println "Problem compiling utf-8 regular expressions."))
+)
+
+
+(define (utf8qa)
+ (if (not (= (length (char 937)) 2)) (QA:failed "UTF-8 char: failed"))
+
+ (if (not (and
+    (= (map char (explode (chop utf8str))) (chop unicodelist)) 
+    (= (map char (explode (chop utf8str 3))) (chop unicodelist 3))
+    (= (map char (explode (chop utf8str 5))) (chop unicodelist 5)))) (QA:failed "UTF-8 chop: failed"))
+
+ (if (not (= (map char (explode utf8str)) unicodelist)) (QA:failed "UTF-8 explode: failed"))
+
+ (if (not (= (map char (explode (upper-case utf8str))) 
+    '(913 914 915 916 937 913 914 915 916 937 32 1040 1041 1042 1043 1044 1040 1041 1042 1043 1044 13 10)))
+    (println "upper-case of UTF8 characters not available - not critical -"))
+
+ (if (not (= (map char (explode (lower-case utf8str))) 
+    '(945 946 947 948 969 945 946 947 948 969 32 1072 1073 1074 1075 1076 1072 1073 1074 1075 1076 13 10)))
+    (println "lower-case of UTF8 characters not available - not critical -"))
+
+ (if (not (= (map char (explode (first utf8str))) '(913))) (QA:failed "UTF-8 first: failed"))
+
+ (if (not (= (map char (explode (last utf8str))) '(10))) (QA:failed "UTF-8 last: failed"))
+
+ (if (not (= (map char (explode (rest utf8str))) 
+    '(914 915 916 937 945 946 947 948 969 32 1040 1041 1042 1043 1044 1072 1073 1074 1075 1076 13 10)))
+    (QA:failed "UTF-8 rest: failed"))
+ 
+ (if (not (= (map char (explode (first (rest utf8str)))) '(914))) (QA:failed "UTF-8 first, rest: failed"))
+
+ (if (not 
+  (and (= (map char (explode (select utf8str 1 2 3))) '(914 915 916))
+       (= (map char (explode (select utf8str -1 -2 -3))) '(10 13 1076))
+       (= (map char (explode (select utf8str 2 4 6))) '(915 937 946))))
+  (QA:failed "UTF-8 select: failed"))
+
+
+ (if (not (= (map char (explode (select utf8str '(1 2 3)))) '(914 915 916))) (QA:failed "UTF-8 select: failed"))
+
+ (if (not (and
+    (= (map char (explode (nth 1 utf8str))) '(914))
+    (= (map char (explode (nth -5 utf8str))) '(1074))))
+ (QA:failed "UTF-8 nth: failed"))
+
+; rewrite woth 'pop' and 'push', which currently do not work correctly with utf8
+;(if (not (= (map char (explode (set-nth 2 utf8str (char 937)))) 
+;    '(913 914 937 916 937 945 946 947 948 969 32 1040 1041 1042 1043 1044 1072 1073 1074 1075 1076 13 10)))
+;    (QA:failed "UTF-8 set-nth: failed"))
+
+true
+)
+
+(global 'global-myvar)
+(set 'global-myvar 123)
+
+; testing the default functor
+		
+(define (double:double x) (+ x x))
+
+(define (test-default-functor)
+	(and
+		(= (map double '(1 2 3 4 5)) '(2 4 6 8 10))
+		(= (map 'double '(1 2 3 4 5)) '(2 4 6 8 10))
+		(set 'dflt:dflt '(a b c d e f g))
+		(= (map dflt '(1 2 6)) '(b c g))
+		(set 'i 0 'j -1 'k 6)
+		(= (dflt i) 'a)
+		(= (dflt k) 'g)
+		(= (dflt j) 'g)
+		(set 'ctx dflt)
+		(= (default ctx) dflt:dflt)
+		(= (default dflt) dflt:dflt)
+		(sort (default ctx) >)
+		(= (default dflt) '(g f e d c b a))
+))
+		 
+(context 'KMT)
+
+(context 'QA)
+
+
+(define (cleanup)
+  (delete-file "junk")
+  (delete-file "junk2"))
+
+(set 'failed-messages '())
+
+(define (check-case x)
+  (case x 
+   (1 "one") 
+   (2 "two") 
+   (3 "three")))
+
+(define (check-cond x)
+  (cond 
+   ((= x 1) 1) 
+   ((= x 2) 2) 
+   ((= x 3) 3)))
+
+(define (checkqa )
+  (dolist (p (symbols 'MAIN)) 
+   (if (primitive? (eval p)) 
+    (begin 
+     (set 'sm (sym (append "test-" (string p)))) 
+     (if (not (lambda? (eval sm))) 
+      (print sm "\n"))))))
+
+(define-macro (do-args p)
+  (= (args) '(2 "3 4" 5 (x y)))
+  (= (args 3 -1) 'y))	
+
+(define (failed msg)
+;  (println msg)
+  (push msg failed-messages))
+
+(define (file-copy from-file to-file)
+  (set 'in-file (open from-file "read"))
+  (set 'out-file (open to-file "write"))
+  (while (set 'chr (read-char in-file)) 
+   (if (not (= chr 95)) 
+    (write-char out-file chr)))
+  (close in-file)
+  (close out-file))
+
+(define (line-count file)
+  (device (open file "read"))
+  (set 'cnt 0)
+  (while (read-line) 
+   (inc cnt))
+  (close (device))cnt)
+
+(define (myappend x y)
+  (cond 
+   ((= '() x) y) 
+   (true (cons (first x) (myappend (rest x) y)))))
+
+(define (qa)
+  (dolist (sm (symbols 'MAIN)) 
+   (if (not 
+     (if (and (primitive? (eval sm)) (< sm 'zzz))
+       (begin 
+          (unless MAIN:testing-cell-leaks (print "  -> " (term sm) "          \r"))
+          (set 'func (eval (sym (append "test-" (string sm)))) )
+          (and (catch (apply func) 'result)  result))
+       true)) 
+     (failed (string " >>>> " sm " failed " result) )))
+  (unless MAIN:testing-cell-leaks (print "                             \n")))
+
+(define (test-$) (find "a|b" "xtzabc" 0) (= ($ 0) $0))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; test-functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (test-!) 
+  (integer? (! "")))
+
+(define (test-!= )
+  (and (not (!= -9223372036854775808 (& -9223372036854775808 -1))) (!= "abc" "ABC") 
+   (!= "a" "ไ") 
+   (!= 1.000000001 1) 
+   (!= "แ" "a")))
+
+(define (test-$)
+	(set '$0 123)
+	(= ($ 0) 123))
+
+(define (test-% )
+  (and
+    (= (% 10 3) 1)
+    (not (catch (%) 'result))))
+
+(define (test-& )
+  (= -9223372036854775808 (& -9223372036854775808 -1)))
+
+(define (test-* )
+  (and
+    (= (* (* 123456789 123456789)) 15241578750190521)
+    (= (*) 1)
+  ))
+
+(define (test-+ )
+  (and
+    (= (+ 999999999999999999 1) 1000000000000000000)
+    (= (+ 9223372036854775807 -9223372036854775808) -1)
+    (= (+ -9223372036854775808 -1) 9223372036854775807) ; wraps around
+    (= (+) 0)
+  ))
+
+(define (test-- )
+  (= (- 100000000 1) 99999999))
+
+(define (test-/ )
+  (= (/ 15241578750190521 123456789) 123456789)
+  (= (/ -10 5) -2))
+
+(define (test-< )
+  (and 
+   (< -9223372036854775808 9223372036854775807)
+   (< "abcdefg" "abcdefgh")
+   (< 1 1.000000001) 
+   (< 1 "a") 
+   (< "a" 'a)
+   (< '(a b) '(b c) '(c d))
+   (not (< '(a b) '(b d) '(b c)))
+   (< '(((a b))) '(((b c))))
+   (< '(a (b c)) '(a (b d)) '(a (b (d))))
+   (< -1)
+   (< -1.23)
+   (not (< "1"))
+   (not (< '()))
+))
+
+(define (test-<< )
+  (= (<< 1 63) -9223372036854775808))
+
+(define (test-<= )
+  (and (<= -9223372036854775808 -9223372036854775808) (<= 1 1.00000001)))
+
+(define (test-= )
+  (and 
+    (= 1.23456789 1.23456789) 
+    (= 123456789 123456789) 
+    (= 0xFFFFFFFFFFFFFFFF -1)
+    (= 0b1111111111111111111111111111111111111111111111111111111111111111 -1)
+    (= '(1 2 3 (4 5) (a b ("CDEFG" "HIJK") 'u 'v 'w)) 
+    '(1 2 3 (4 5) (a b ("CDEFG" "HIJK") 'u 'v 'w))) 
+    (= "้โไแํ๓๚๑ั๖๒" "้โไแํ๓๚๑ั๖๒")
+    (= '())
+    (= 0)
+    (= "")
+    (not (= 1))
+    (not (= "abc"))
+    (not (= '(1 2 3)))
+))
+
+(define (test-> )
+  (and (> 9223372036854775807 -9223372036854775808) (> "abcdefgh" "abcdefg") (> 1.000000001 
+    1) 
+   (> "a" 1) 
+   (> "z" "aaaaa")
+   (> "aaa" "a")
+   (> 'a "a") 
+   (> '(a) 'a)
+   (> 1)
+   (> 1.23)
+   (> "abc")
+   (> '(1 2 3))
+   (not (> ""))
+   (not (> '()))   
+))
+
+(define (test->= )
+  (and (>= 1 0) (>= 1.00000001 1)))
+
+(define (test->> )
+  (= (>> 1073741824 30) 1))
+
+(define (test-NaN? )
+  (and (NaN? (sqrt -1))
+       (set 'NaN (sqrt -1)) 
+       (not (= NaN NaN))
+       (= 1 (+ 1 NaN)) 
+       (= 0 (* 2 NaN)) 
+       (NaN? (add 1 (sqrt -1))) 
+       (NaN? (abs (sqrt -1)))))
+
+(define (test-^ )
+  (= (^ 1431655765 -1431655766) -1))
+
+(define (test-abs )
+  (and (= (abs -1) 1) (= (abs -9.9) 9.9)))
+
+(define (test-acos )
+  (= 0 (acos (cos (acos (cos 0))))))
+
+(define (test-acosh)
+	(= (cosh (acosh 1)) 1))
+
+(define (test-add , l)
+  (and
+    (= (add) 0)
+    (dotimes (x 100) 
+      (push x l))
+    (= 4950 (apply add l))
+  ))
+
+(define (test-address s)
+  (and
+	(set 's "foo")
+	(= (address s) (last (dump s)))
+	(set 'D:D "foo")
+	(= (address D) (last (dump D:D)))
+))
+
+(define (test-amb)
+	(set 'x (amb 1 2))
+	(or (= x 1) (= x 2)))
+
+(define (test-and )
+  (and (and true true true) (not (and true true nil))))
+
+(define (test-append )
+  (and
+    (= '(1 2 3 4) (append '(1 2) '(3 4)))
+    (= '(1 2 3 4 5) (append '(1 2) '(3) '(4 5)))
+    (= '(1 2 3 4) (append '(1 2) '(3 4) '()))
+    (= '(1 2 3 4 5) (append '(1 2) '(3 4) '() '(5)))
+    (= '(1 2 3 4 5) (append '() '(1 2) '(3 4) '() '(5)))
+    (= '() (append '()) (append '() '()) (append))
+    (= "abcdefg" (append "" "a" "bcd" "" "ef" "g" ""))
+    (= "" (append ""))
+    (set 'A (array 3 2 (sequence 1 6)))
+    (set 'B (array 2 2 (sequence 7 10)))
+    (= (array 5 2 (sequence 1 10)) (append A B))
+    (lambda? (append '(lambda)))
+	; default functor
+	(set 'D:D '(a b c))
+	(= '(a b c a b c a b c) (append D D D))
+))
+
+(define (test-append-file)
+  (append-file "junk" "ABC")
+  (append-file "file://junk" "DEF")
+  (= (read-file "junk") "ABCDEF")
+)
+
+(define (test-apply )
+  (and (= (apply + '(1 2)) 3) 
+       (= (apply append '("a" "b" "c")) "abc")
+       (= (apply (fn (x y) (+ x y)) '(3 4)) 7)
+       (= (apply list '(a b c d e f) 2) '(((((a b) c) d) e) f))
+       (= (inc (apply set '(x 123))) 124 x)
+       (= (apply + (array 100 (sequence 1 100))) 
+          (apply + (sequence 1 100)) 
+          (apply + (0 100 (array 100 (sequence 1 100)))))
+))
+    
+
+
+(define (test-args )
+  (do-args 1 2 "3 4" 5 (x y)))
+
+(define (test-array) 
+  (and
+    (= (array-list (array 3 2 (sequence 1 6))) '((1 2) (3 4) (5 6)))
+    (set 'A (array 3 2 (sequence 1 6)))
+    (= (array-list (nth 0 A)) '(1 2))
+    (= (nth '(0 0) A) 1)
+    (= (nth '(2 1) A) 6)
+    (= (nth '(-1 -1) A) 6)
+    (not (catch (nth '(10 10) A)  'result))
+    (not (catch (nth '(-10 -10) A) 'result))
+    (= (nth 0 A) (array 2 '(1 2)))
+    (= (array-list (nth 0 A)) '(1 2))
+    (< (nth 0 A) (nth 1 A))
+    (> (nth 2 A) (nth 1 A))
+    (setf (A 1 0) 1)
+    (= (nth '(1 0) A) 1)
+    (setf (A 1 1) 1)
+    (= (array-list A) '((1 2) (1 1) (5 6)))
+    (< (nth 1 A) (nth 0 A))
+))
+
+
+(define (test-array-list)
+	(and 
+		(set 'a (array 3 4 (sequence 1 12)))
+		(array? a) 
+		(list? (array-list a))
+		; default functor
+		(set 'D:D (array 3 4 (sequence 1 12)))
+		(array? D:D)
+		(list? (array-list D))
+		(= (array-list D) '((1 2 3 4) (5 6 7 8) (9 10 11 12)))
+))
+
+(define (test-array?) (test-array-list))
+
+(define (test-asin )
+  (= (round (asin (sin (asin (sin 1)))) -9) 1))
+
+(define (test-asinh)
+  (= (round (sinh (asinh 1)) -12) 1))
+
+(define (test-assoc)
+ (and
+	(set 'L '((a 1) (b (c (d 2) (e 3) (e 4))) ("a" 5) ((a) 6)))	
+	(= (assoc 'a L) '(a 1))	
+	(= (assoc 'b L) '(b (c (d 2) (e 3) (e 4))))
+	(= (assoc "a" L) '("a" 5))
+	(= (assoc '((a)) L) '((a) 6))
+
+	(= (assoc '(b c) L) '(c (d 2) (e 3) (e 4)))
+	(= (assoc '(b c d) L) '(d 2))
+	(= (assoc '(b c e) L) '(e 3))
+	; default functor
+	(set 'D:D '((a 1) (b (c (d 2) (e 3) (e 4))) ("a" 5) ((a) 6)))	
+	(= (assoc 'a D) '(a 1))
+))
+
+
+(define (test-atan )
+	(< (sub 1 (atan (tan (atan (tan 1))))) 1e-15))
+
+; old test broke after Mac OS X update to 10.5.2
+;  (= 1 (atan (tan (atan (tan 1)))))
+
+(define (test-atanh)
+	(< (sub (tanh (atanh 0.5)) 0.5) 0.0000000001))
+
+(define (test-atan2 )
+  (= (div (acos 0) (atan 1 1)) 2))
+
+(define (test-atom? )
+  (and (atom? 1) (atom? 1.23) (atom? "hello") (atom? 'x) (atom? nil) (atom? true)))
+
+(define (test-base64-enc)
+  (and
+    (= "" (base64-dec (base64-enc "")))
+    (= "1" (base64-dec (base64-enc "1")))
+    (= "12" (base64-dec (base64-enc "12")))
+    (= "123" (base64-dec (base64-enc "123")))
+    (= "1234" (base64-dec (base64-enc "1234")))
+))
+
+(define (test-base64-dec)
+  (test-base64-enc))
+
+;; context Lex was previously created
+
+(define (test-bayes-train)
+  (and
+    (= (bayes-train '(F F F B B) '(F B B B B) 'Lex) '(5 5))
+    (> 0.001 (apply add (map sub (bayes-query '(F) Lex) '(0.75 0.25))))
+    (> 0.001 (apply add (map sub (bayes-query '(F) Lex true) '(0.75 0.25))))
+    (> 0.001 (apply add (map sub (bayes-query '(F F) Lex) '(0.8251777681 0.1748222319))))
+    (> 0.001 (apply add (map sub (bayes-query '(F F) Lex true) '(0.9 0.1))))
+  )
+)
+
+(define (test-bayes-query) 
+	(set 'Lex:F '(0 0))
+	(set 'Lex:B '(0 0))
+	(set 'Lex:total '(0 0))
+	true)
+
+(define (test-begin )
+  (begin 
+   (set 'x 0) 
+   (inc x) 
+   (inc x) 
+   (= x 2)))
+
+(define (test-beta )
+  (< (abs (sub (beta 1 2) 0.5)) 1e-05))
+
+(define (test-betai )
+  (< (abs (sub (betai 0.5 5 10) 0.910217)) 1e-05))
+
+(define (test-bigint?)
+    (and
+        (bigint? 123456789012345678901234567890)
+        (bigint? 123456789012345678901234567890L)
+        (bigint? 0L)
+        (bigint? 123L)
+        (bigint? (bigint 12345))
+        (bigint? (bigint 12345.678))
+        (bigint? (bigint "12345"))
+        (bigint? (bigint "123hello"))
+        (nil? (bigint "hello")) 
+    ))
+
+(define (test-bigint)
+    (and
+        (= 12345L (bigint 12345))
+        (= 12345 (bigint 12345.678))
+        (= 12345 (bigint "12345"))
+))
+
+(define (test-bind)
+	(bind '((a 1) (b "hello") (c (3 4))))
+	(and
+		(= a 1)
+		(= b "hello")
+		(= c '(3 4))
+		(= 7 (bind '((a (+ 3 4))) true))
+	)
+)
+
+(define (test-binomial )
+  (< (sub (binomial 2 1 0.5) 0.5) 1e-09))
+
+(define (test-bits)
+  (and
+	(= (int (bits 0x7fffffffffffffff) 0 2) 0x7fffffffffffffff)
+	(= (int (bits 0x8000000000000000) 0 2) 0x8000000000000000)
+	(= 64 (length (bits 0x8000000000000000)))
+	(= (bits 0) "0")
+	(= (bits 1234) "10011010010")
+	(= (bits 1234 true) '(nil true nil nil true nil true true nil nil true))
+))
+
+(define (test-break )
+  (break true)
+  (= true (break))
+  (not (break nil)))
+
+(define (test-case )
+  (and (= (check-case 1) "one") (= (check-case 2) "two") (= (check-case 
+     9) nil)))
+
+(define (test-callback) true)
+
+(define (test-catch )
+  (and 
+	(catch (+ 3 4) 'result) 
+        (= result 7)
+	(= (catch (+ 3 4)) 7)
+        (= (catch (dotimes (x 100) (if (= x 7) (throw x)))) 7)
+))
+
+(define (test-ceil )
+  (= 2 (ceil 1.5)))
+
+(define (test-change-dir )
+  (make-dir "adir")
+  (change-dir "adir")
+  (change-dir "..")
+  (remove-dir "adir"))
+
+(define (test-char )
+  (and 
+    (= (format "%c" (char "a" 0)) "a") 
+    (= (char "A") 65) (= (char 65) "A")
+    (= (map char (sequence 65 67)) '("A" "B" "C"))
+    (= (char 0) "\000")
+	(set 'D:D "ABCDEFG")
+	(= (char D 0) 65)
+	(= (char D -1) 71)
+	(if utf8
+      (let (s (char 937))
+        (and
+            (= (char s 0 true) 206)
+            (= (char s 1 true) 169)
+            (= (char s -1 true) 169)
+            (= (char s -2 true) 206)
+        )
+	  )
+	  true
+    )
+))
+
+(define (test-chop )
+  (and 
+    (= (chop "newlisp") "newlis")
+    (= (chop "newlisp" 4) "new")
+	(= (chop "abc" 5) "")
+	(= (chop "abc" -5) "")
+    (= (chop '(a b (c d) e)) '(a b (c d)))
+    (= (chop '(a b (c d) e) 2) '(a b))
+	(set 'D:D "newlisp")
+	(= (chop D) "newlis")
+	(= (chop D 4) "new")
+))
+
+(define (test-clean ) 
+  (and
+    (= (clean integer? '(1 1.1 2 2.2 3 3.3)) '(1.1 2.2 3.3))
+    (= (clean true? '(a nil b nil c nil)) '(nil nil nil))))
+
+(define (test-close , fno)
+  (and 
+    (set 'fno (open "qa-dot" "read")) 
+    (close fno)))
+
+(define (test-collect)
+    (= (let (x 0) (collect (if (<= (inc x) 5) x))) '(1 2 3 4 5))
+)
+
+(define (test-corr)
+    (< (apply add (map sub (corr '(1 3 5 8 9 9) '(2 2 3 4 6 8)) 
+        '(0.868724789 0.5571847507 0.6187683284 3.507907832 4 0.0247186268))) 0.000000001)
+)
+
+(define (test-crc32)
+    (and
+        (= (crc32 "abcdefghijklmnopqrstuvwxyz") 1277644989)
+        (= (crc32 "HELLO") 3242484790))
+)
+
+(define (test-select-collect )
+  (and
+    (set 'l '(0 1 2 3 4 5 6 7 8 9))
+    (= (select l '()) '())
+    (= (select l 0 9 9 0 1 8 8 1) '(0 9 9 0 1 8 8 1)) 
+    (= (select "2001-09-20" 5 6 8 9 0 1 2 3) "09202001") 
+    (set 'a 0 'b 1 'c 2)
+    (= (select '(w x y z) a b c) '(w x y))
+    (= (select '(w x y z) (inc a) (inc b) (inc c)) '(x y z))
+))
+
+(define (test-command-event) true) /* test interactively */
+
+(define (test-cond )
+  (and 
+      (= (check-cond 1) 1)
+      (= (check-cond 2) 2)
+      (not (check-cond 99)) 
+      (= (cond ((+ 3 4))) 7)
+      (= (cond (nil 1) ('())) '())
+      (= (cond (nil 1) (nil)) nil)
+      (= (cond (nil 1) (true nil)) nil)
+      (= (cond ('())) '())
+      (= (cond (nil 1) ('() 2)) '())
+))
+
+(define (test-cons )
+  (= (myappend '(1 2 3) '(4 5 6)) '(1 2 3 4 5 6))
+)
+
+(define (test-constant )
+  (constant 'cs 123)
+  (= cs 123)
+  (protected? 'cs))
+
+
+(define (test-context )
+  (and (context 'TEST) (context 'QA)))
+
+(define (test-context? )
+  (and (context? MAIN) (context? QA)))
+
+(define (test-continue)
+	(let (cnt 0)
+		(= 1000 (catch (begin (if (< (inc cnt) 1000) (continue) cnt)))))
+)
+
+(define (test-copy)
+ (and
+	(set 'aList '(a b c))
+	(= (replace 'b (copy aList)) '(a c))
+	(= aList '(a b c))
+	(find-all "12" "12345" (replace "1" (copy $0) "N"))
+	(= (rotate (copy "abcdefg")) "gabcdef")
+))
+
+(define (test-copy-file ) 
+  (and (copy-file "qa-dot" "junk") (delete-file "junk")))
+
+(define (test-cos )
+  (= 1 (cos (acos (cos (acos 1))))))
+
+(define (test-cosh)
+	(= (cosh 1) (div (add (exp 1) (exp -1)) 2)))
+
+(define (test-count )
+  (and (= (count '(1 2) '(2 1 2 1)) '(2 2)) 
+       (= (count '(a b) '(a a b c a b b)) '(3 3))
+       (= (count '(a b c) '()) '(0 0 0))
+       (set 'L '(a b c d e f))
+       (= (count L L) '(1 1 1 1 1 1))
+  )
+)
+
+(define (test-cpymem)  
+  (set 'from "12345")
+  (set 'to "     ")
+  (cpymem (address from) (address to) 5)
+  (= from to))
+
+(define (test-crit-chi2)
+  (and
+    (< (abs (sub (crit-chi2 (prob-chi2 4.605 2) 2) 4.605)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 51.805 40) 40) 51.805)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 9.210 2) 2) 9.210)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 63.691 40) 40) 63.691)) 0.001)
+))
+
+(define (test-crit-f)
+  (and
+    (< (abs (sub (crit-f (prob-f 6.59 3 4) 3 4) 6.59)) 0.001)
+    (< (abs (sub (crit-f (prob-f 2.79 12 11) 12 11) 2.79)) 0.001)
+    (< (abs (sub (crit-f (prob-f 16.59 3 4) 3 4) 16.59)) 0.001)
+    (< (abs (sub (crit-f (prob-f 4.40 12 11) 12 11) 4.40)) 0.001)
+))
+
+(define (test-crit-t)
+  (and
+    (< (abs (sub (crit-t (prob-t 1.886 2) 2) 1.886)) 0.001)
+    (< (abs (sub (crit-t (prob-t 1.303 40) 40) 1.303)) 0.001)
+    (< (abs (sub (crit-t (prob-t 6.965 2) 2) 6.965)) 0.001)
+    (< (abs (sub (crit-t (prob-t 2.423 40) 40) 2.423)) 0.001)
+))
+
+(define (test-crit-z)
+(for (z -6 6 0.3)
+  (let (flag true)
+    (if (> (abs (sub (crit-z (prob-z z)) z)) 0.0001)
+        (set 'flag nil))
+  flag)
+))
+
+(define (test-current-line , handle)
+  (and
+    (set 'handle (open "qa-dot" "r"))
+    (= (read-line handle) "#!/usr/bin/env newlisp") 
+    (= (current-line) "#!/usr/bin/env newlisp") 
+    (close handle)))
+
+(define (test-curry)
+  (and
+    (= (set 'f (curry + 10)) (lambda ($x) (+ 10 $x)))
+    (= (filter (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+       '((a 10) (a 3) (a 9)))
+    (= (clean (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+       '((b 5) (c 8)))
+    (= (map (curry list 'x) (sequence 1 5))
+       '((x 1) (x 2) (x 3) (x 4) (x 5)))
+))
+
+(define (test-date )
+  (= (date) (date (date-value)) (date (apply date-value (now)))))
+
+
+(define (test-date-parse)
+	(and
+		(= (date-parse "2007.1.3" "%Y.%m.%d") 1167782400)
+		(= (date-parse "20091014" "%Y%m%d") 1255478400)
+		(= (date-parse "January 10, 07" "%B %d, %y") 1168387200)
+))
+
+(define (test-date-list)
+	(let (value (date-value) vlist (now))
+		(= (apply date-value (date-list value)) value)
+        (= (vlist -4) ((date-list (apply date-value vlist)) -2))
+        (= (date-list 0) '(1970 1 1 0 0 0 1 4))
+    )
+)
+
+(define (test-date-value )
+  (= 0 
+        (date-value 1970 1 1 0 0 0) 
+        (date-value (+ 1970) (+ 1) (+ 1) (+ 0) (+ 0) (+ 0)) 
+        (date-value '(1970 1 1 0 0 0))) )
+
+
+(define (test-debug )
+  (= (debug (+ 3 4)) 7))
+
+(define (test-dec , x)
+	(test-inc))
+
+(define (test-define , foo)
+  (and 
+	(lambda? (define (foo (x 1) (y 2)) (list x y)))
+    (= (foo) '(1 2))
+	(= (foo 3) '(3 2))
+	(= (foo 3 4) '(3 4))
+	(define (foo (x 10) (y (div x 2))) (list x y))
+	(= (foo) '(10 5))
+	(= (foo 20) '(20 10))
+	(= (foo 3 4) '(3 4))
+))
+
+(define (test-def-new)
+  (and
+    (set 'fooctx:x 123)
+    (new fooctx)
+    (= fooctx:x 123)
+    (set 'barctx:bar 999)
+    (def-new 'barctx:bar)
+    (= bar 999)
+    (def-new 'barctx:bar 'foobar)
+    (= foobar 999)
+    (def-new 'barctx:bar 'foofoo:foo)
+    (= foofoo:foo 999)
+))
+
+
+(define (test-define-macro , foo)
+  (and 
+	(macro? (define-macro (foo (x 1) (y 2)) (list x y)))
+    (= (foo) '(1 2))
+	(= (foo 3) '(3 2))
+	(= (foo 3 4) '(3 4))
+	(define-macro (foo (x 10) (y (div x 2))) (list x y))
+	(= (foo) '(10 5))
+	(= (foo 20) '(20 10))
+	(= (foo 3 4) '(3 4))
+))
+
+(define (test-default)
+	(MAIN:test-default-functor))
+
+(define (test-delete )
+  (and
+    (set 'l (list (sym "xxx")))
+    (not (delete (sym "xxx") true))
+	(delete (sym "xxx")))
+)
+
+(define (test-delete-file ) 
+  (and (copy-file "qa-dot" "junk") (delete-file "junk")))
+
+(define (test-delete-url )
+  (= "ERR: HTTP bad formed URL" (delete-url "")))
+
+(define (test-destroy)
+ 	(if (find ostype '("Linux" "BSD" "OSX" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+		(set 'pid (fork (dotimes (t 100) (sleep 100))))
+		(set 'pid (process "newlisp"))	)
+	(if (= ostype "Cygwin") (sleep 1000))
+	(destroy pid))
+
+(define (test-det) 
+  (and
+    (set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+    (<  (sub (det A) -1) 2e-10)
+    (set 'A '((1 2 3) (4 5 6)))
+    (not (catch (det A) 'result))
+    (starts-with result "ERR: wrong dimensions")
+))
+
+    (define (test-device , fno)
+  (set 'fno (open "junk" "write"))
+  (device fno)
+  (if (= (device) fno) 
+   (close (device))))
+
+(define (test-difference )
+  (and
+    (= (difference '(2 5 6 0 3 0 2 5) '(1 2 3 3 2 1)) '(5 6 0))
+    (= (difference '(1 5 2 3 2 2 4 5 3 4 5 1) '(3 4) true) '(1 5 2 2 2 5 5 1))
+    (= (difference '(nil nil nil) '()) '(nil))
+    (= (difference '(nil nil nil) '() true) '(nil nil nil))
+    (set 'L '(a b c d e f))
+    (= (difference L L) '())
+  )
+)
+
+(define (test-directory )
+  (or (find "qa-dot" (directory)) (find "QA" (directory))))
+
+(define (test-directory? )
+  (and
+      (directory? ".")
+      (directory? "modules/")
+      (directory? "modules")
+))
+
+(define (test-div )
+  (and (= 0.1 (div 100000000 1000000000)) 
+       (= (div 1 3) 0.3333333333333333)
+       (= (div 3) 0.3333333333333333)
+))
+
+(define (testdoargs)
+	(local (lst)
+		(doargs (i) (push i lst))
+		lst))
+
+(define (test-doargs)
+	(= (testdoargs 3 2 1) '(1 2 3)))
+
+(define (test-dolist , rList)
+  (and 
+   (dolist (x '(1 2 3 4 5 6 7 8 9)) 
+    (push x rList)) 
+   (= rList '(9 8 7 6 5 4 3 2 1)) 
+   (dolist (x rList) 
+    (pop rList))
+    (dolist (x '(1 2 3 4 5 6 7 8 9) (> x 5))
+	  (push x rList))
+   (= rList '(5 4 3 2 1))
+   (= (local (l) (dolist (e '(1 2 3)) (push $idx l)) l) '(2 1 0))
+   (= (dolist (x '(a b c d e f g)) x) 'g)
+   ;; default functor
+   (set 'D:D (sequence 1 10))
+   (set 'cnt 0)
+   (dolist (i D) (inc cnt i))
+   (= cnt (apply add D))
+))
+
+(define (test-dostring)
+	(local (r) 
+		(dostring (i "newlisp" (= i 108)) (push  i r)) 
+		(= r '(119 101 110))
+		(= (dostring (c "newlisp") c) 112)
+ 	)
+)
+
+(define (test-dotimes , aList)
+  (dotimes (x 2) 
+   (dotimes (y 2) 
+    (dotimes (z 2) 
+     (push z aList))))
+  (and
+     (= '(1 0 1 0 1 0 1 0) aList)
+     (not (dotimes (x 0) x))
+     (= (dotimes (x 1) x) 0)
+
+     ; dotimes returns nil when ever executed since 8.9.7
+     (not (= (dotimes (x -1) x) 0))
+     (not (= (dotimes (x -1.8) x) 0))
+
+     (= (dotimes (x 1.8) x) 0)
+	 (set 'cnt 0)
+	 (dotimes (x 10 (> x 5)) (inc cnt))
+	 (= cnt 6)
+
+))
+     
+(define (test-dotree )
+  (set 'aList '())
+  (and
+    (= (last (symbols MAIN)) (dotree (p MAIN) p))
+  	(dotree (x 'MAIN) 
+   		(push x aList))
+  	(= (length (symbols 'MAIN)) (length aList))
+))
+
+(define (test-dump )
+  ( = "hello" (get-string (last (dump "hello")))))
+
+(define (test-dump-symbol )
+  (= (length (dump nil) 4)))
+
+(define (test-dup)
+  (and
+    (= (dup "" 0) "")
+    (= (dup "" 10) "")
+    (= (dup "A" 10) "AAAAAAAAAA")
+    (= (dup "AB" 5) "ABABABABAB")
+    (= (dup 'x 5) '(x x x x x))
+	(= (dup "l" -1) "")
+	(= (dup '(1) -1) '())
+    (= (dup 1 0) '())
+    (= (dup 1 5) '(1 1 1 1 1))))
+
+(define (test-empty? , aList)
+  (set 'aList '(1 2 3 4 5 6 7 8 9 0))
+  (while aList 
+   (pop aList))
+  (and 
+    (empty? aList) 
+    (empty? "")
+    (set 'D:D (sequence 1 10))
+	(while D:D (pop D))
+	(empty? D)
+))
+
+(define (test-encrypt )
+  (= (encrypt (encrypt "newlisp" "123") "123") "newlisp"))
+
+(define (test-ends-with )
+  (and 
+	(ends-with "newlisp" "lisp") 
+	(ends-with "newlisp" "LISP" 1) 
+	(ends-with "abc.def.ghi" "def|ghi" 1)
+	(ends-with "12345" "4|5" 1)
+   	(ends-with (explode "newlisp") "p")
+	(set 'D:D "newlisp")
+	(ends-with D "lisp") 
+	(ends-with D "LISP" 1) 
+))
+
+(define (test-env)
+  (and 
+    (list? (env))
+    (env "key" "value") 
+    (= (env "key") "value")
+	(env "key" "") ; remove key
+	(if (or (= ostype "SunOS") (= ostype "Solaris"))
+		(= (env "key" ""))
+		(not (env "key")))
+))
+
+(define (test-erf)
+   (<  (abs (sub 0.5204998778 (erf 0.5))) 0.000001))
+
+;(define (test-estack) (list? (estack)))
+
+(define (test-even?)
+    (and (even? 2) (not (even? 3)) (even? 0.9) (not (even? 3.9))))
+
+(define (alarm) (println "ring..."))
+
+(define (test-t-test)
+  (and
+    ; dependent samples
+    (< (apply add (map sub (t-test '(1 3 5 8 9 9) '(2 2 3 4 6 8)) 
+        '(5.833333333 4.166666667 3.371448749 2.401388487 0.9862873039 10 0.3472542517))) 
+        0.00000001)
+    ; related samples (before and after treatment)
+    (< (apply add (map sub (t-test '(3 0 6 7 4 3 2 1 4) '(5 1 5 7 10 9 7 11 8) true)
+        '(3.333333333 7 2.236067977 3.041381265 -3.142857143 8 0.01374582439))) 
+        0.00000001)
+    ; force Welch's Student's t for unequal variances
+    (< (apply add (map sub (t-test '(1 3 5 8 9 9) '(2 2 3 4 6 8) 1.0)
+        '(5.833333333 4.166666667 3.371448749 2.401388487 0.9862873039 9 0.3497635197))) 
+        0.00000001)
+    ; force Welch's Student's t for unequal variances and sample sizes
+    (< (apply add (map sub (t-test '(10 4 7 1 1 6 1 8 2 4) '(4 6 9 4 6 8 9 3) 1.0)
+        '(4.4 6.125 3.238655414 2.356601669 -1.30656126 15 0.2110406063))) 
+        0.00000001)
+    ; one sample t-test
+    (< (apply add (map sub (t-test '(3 5 4 2 5 7 4 3) 2.5)
+        '(4.125 2.5 1.552647509 0.548943791 2.960230221 7 0.02109816335)))
+        0.00000001)
+  )
+)
+
+(define (test-timer)
+        (timer 'alarm 4))
+
+(define (test-title-case)
+	(= (title-case "heLLo") "HeLLo")
+	(= (title-case "heLLo" true) "Hello"))
+
+(define (test-throw-error)
+    (and
+        (not (catch (throw-error "message text") 'result))
+        (starts-with result "ERR: user error :")) )
+
+
+(define (test-error-event )
+  (= 'nil (error-event)))
+
+(define (test-estack) (list? (estack)))
+
+(define (test-eval , x y)
+  (set 'x 123)
+  (set 'y 'x)
+  (set 'z 'y)
+  (and (= 123 (eval y)) (= 123 (eval 'x)) (= 123 (eval (eval z)))))
+
+(define (test-eval-string ) true
+  (eval-string "(set 'x 123)")
+  (eval-string "(set 'y x)")
+  (= 123 (eval-string "y"))
+  (set 'Foo:xyz 99999)
+  (= 99999 (eval-string "xyz" 'Foo))
+  (delete (sym "xyz" Foo))
+)
+
+(define (test-exec )
+	(and (sub-read-exec) (sub-write-exec))
+)
+
+(define (sub-read-exec ) 
+   (write-file "exectest" {(println "hello") (exit)})
+   (and
+	(set 'result (if (find ostype '("Windows" "OS/2"))
+     	(exec "newlisp exectest") 
+		(exec "./newlisp exectest")))
+	(= "hello" (last  result)) 
+	(delete-file "exectest")))
+
+(define (sub-write-exec )
+  (and 
+    (write-file "testexec" {(write-file "exectest" (read-line))})
+	(if (find ostype '("Windows" "OS/2"))
+	 (exec "newlisp testexec" "HELLO") (exec "./newlisp testexec" "HELLO"))
+    (= "HELLO" (read-file "exectest"))
+    (delete-file "testexec")
+    (delete-file "exectest")))
+
+
+(define (test-exit )
+  (or (primitive? exit) (lambda? exit)))
+
+(define (test-exists)
+  (and
+    (= (exists string? '(2 3 4 6 "hello" 7)) "hello")
+    (not (exists string? '(3 4 2 -7 3 0)) )
+    (= (exists zero? '(3 4 2 -7 3 0)) 0)
+    (= (exists < '(3 4 2 -7 3 0)) -7)
+    (= (exists (fn (x) (> x 3)) '(3 4 2 -7 3 0)) 4)
+    (not (exists (fn (x) (= x 10)) '(3 4 2 -7 3 0)))
+))
+
+(define (test-exp )
+  (= 1 (exp (log (exp (log (exp (log 1))))))))
+
+(define (test-expand) 
+  (and
+    (set 'x 2)
+	(= (expand 'x 'x) 2)
+    (= (expand '(a x b) 'x) '(a 2 b))
+    (= (expand '(x b) 'x) '(2 b))
+    (= (expand '(a x) 'x) '(a 2))
+    (= (expand '(a (x) b) 'x) '(a (2) b))
+    (= (expand '(a ((x)) b) 'x) '(a ((2)) b))
+    (set 'a 1 'b 2 'c 3)
+    (= (expand '(a b c) 'b 'a 'c ) '(1 2 3))
+	;; prolog mode with uppercase vars
+	(set 'X 2)
+	(= (expand '(a ((X)) b)) '(a ((2)) b))
+	;; env list as parameter
+	(set 'a "a" 'B "B" 'c "c" 'd "d")
+	(= (expand '(a (B (c) (d a B))) '((a 1) (B 2) (c 3) (d 4)))
+	   '(1 (2 (3) (4 1 2))))
+	(= a "a") (= B "B") (= c "c") (= d "d")
+	;; default functor
+	(set 'Le:Le '(a (B (c) (d a B))) )
+	(set 'p '((a 1) (B 2) (c 3) (d 4)))
+	(= (expand Le p) '(1 (2 (3) (4 1 2))))
+))
+
+(define (test-explode )
+	(and	
+		(= (explode "kakak" -1) '())
+		(= (explode "ABC" 4) '("ABC"))
+		(= (explode '(a b c d e f) -1) '())
+		(= (explode "new") '("n" "e" "w"))
+		(= (explode "newlisp" 3) '("new" "lis" "p"))
+		(= (explode "newlisp" 3 true) '("new" "lis"))
+		(= (explode "newlisp" 7 true) '("newlisp"))
+		(= (explode "newlisp" 8 true) '())
+		(= (explode '(a b c d e)) '((a) (b) (c) (d) (e)))
+		(= (explode '(a b c d e) 2) '((a b) (c d) (e)))
+		(= (explode '(n e w l i s p)) '((n) (e) (w) (l) (i) (s) (p)))
+		(= (explode '(n e w l i s p) 3) '((n e w) (l i s) (p)))
+		(= (explode '(n e w l i s p) 7 true) '((n e w l i s p)))
+        (= (explode '(n e w l i s p) 8 true) '())
+		(set 'D:D '(a b c d e f g))
+		(= (explode D 2) '((a b) (c d) (e f) (g)))
+))
+
+(define (test-extend)
+	(and
+		(= (extend '() '(a) '(b c)) '(a b c))
+		(= (extend '(a) '() '(b)) '(a b))
+		(= (extend '(a) '(b) '(c d)) '(a b c d))
+		(not (set 'l '()))
+		(= (extend l '(a) '(b c)) '(a b c))
+		(= (extend l '(d e)) '(a b c d e))
+		(not (set 'l nil))
+		(= (extend l "abc" "def") "abcdef")
+		(not (set 'l nil))
+		(= (extend l '(a) '(b c)) '(a b c))
+	)	
+)	
+
+(define (test-factor)
+	(= (apply * (factor 0x7FFFFFFFFFFFFFFF)) 0x7FFFFFFFFFFFFFFF))
+
+(define (test-fcall) true)
+
+(define (test-fft )
+  (= '((1 2) (3 4)) (ifft (fft '((1 2) (3 4))))))
+
+(define (test-file-info )
+  (list? (file-info "qa-dot")))
+
+(define (test-file? )
+  (and 
+    (file? "qa-dot")
+    (= (file? "qa-dot" true) "qa-dot")
+    (file? "modules/")
+    (file? "modules")
+    (not (file? "modules" true))
+))
+
+(define (test-filter )
+  (and
+    (= (filter integer? '(1 1.1 2 2.2 3 3.3)) '(1 2 3))
+    (= (filter true? '(a nil b nil c nil)) '(a b c))
+	; default functor
+	(set 'D:D '(2 4 2 7 5 3 8))
+	(= (filter (curry < 5) D) '(7 8))
+))
+
+(define (test-find )
+  (and 
+    (= 3 (find '(3 4) '(0 1 2 (3 4) 5 6 7 8)))
+    (= nil (find 9 '(1 2 3))) 
+    (= 2 (find "W" "newlisp" 1))
+    (= $0 "w")
+    (= (find "newlisp" '("Perl" "Python" "newLISP") 1) 2)
+    ; use a comparison functor
+    (= (find '(1 2) '((1 4) 5 6 (1 2) (8 9))) 3)
+    (= (find 3 '(8 4 3  7 2 6) >)  4)
+    (= (find 5 '((l 3) (k 5) (a 10) (z 22)) (fn (x y) (= x (last y)))) 1)
+    (= (find '(a ?) '((l 3) (k 5) (a 10) (z 22)) match) 2)
+    (= (find '(X X) '((a b) (c d) (e e) (f g)) unify) 2)
+    (define (has-it-as-last x y) (= x (last y)))
+    (= (find 22 '((l 3) (k 5) (a 10) (z 22)) has-it-as-last) 3)
+    (= (find "newlisp" '("Perl" "Python" "newLISP") (fn (x y) (regex x y 1))) 2)
+	; default functor
+	(set 'D:D '(0 1 2 (3 4) 5 6 7 8))
+    (= 3 (find '(3 4) D))
+	(set 'D:D "newlisp")
+    (= 2 (find "W" D 1))
+))
+
+
+(define (test-find-all)
+  (and
+	(= (find-all {\d+} "asdf2kjh44hgfhgf890") '("2" "44" "890"))
+	(= (find-all {(new)(lisp)} "newLISPisNEWLISP" (append $2 $1) 1) '("LISPnew" "LISPNEW"))
+	(set 'D:D "asdf2kjh44hgfhgf890")
+	(= (find-all {\d+} D) '("2" "44" "890"))
+	(set 'D:D "newLISPisNEWLISP")
+	(= (find-all {(new)(lisp)} D (append $2 $1) 1) '("LISPnew" "LISPNEW"))
+    (= (find-all {(^|(?<=,))("(([^"]|"")*)"|([^",]*))}
+	       {Ten Thousand,10000, 2710 ,,"10,000","It's ""10 Grand"", baby",10K})
+       '("Ten Thousand" "10000" " 2710 " "" "\"10,000\"" "\"It's \"\"10 Grand\"\", baby\"" "10K"))
+))
+
+(define (test-first )
+  (= 1 (first '(1 2 3 4)))
+  (= "n" (first "ewLISP"))
+  (= (array 2 '(1 2)) (first (array 3 2 (sequence 1 6))))
+  ;; default functor
+  (set 'D:D '(a b c d e f g))
+  (= (first D) 'a)
+  (set 'D:D (array 7 '(a b c d e f g)))
+  (= (first D) 'a)
+  (not (catch (first '()) 'result))
+)
+
+(define (test-flat )
+  (set 'lst '(a (b (c d))))
+  (= (map (fn (x) (ref x lst)) (flat lst)) '((0) (1 0) (1 1 0) (1 1 1))))
+
+(define (test-float )
+  (float? (float "1.234")))
+
+(define (test-flt)
+	(= (flt 1.23) 1067282596)
+	(= (flt 0.8) 1061997773)
+	(= (flt -0.8) 3209481421))
+
+(define (test-float? )
+  (float? 1.234))
+
+(define (test-floor )
+  (= 1 (floor 1.5)))
+
+(define (test-for , x lst1 lst2)
+  (set 'lst1 '())
+  (set 'lst2 '())
+  (for (x 10 0 3) 
+   (push x lst1))
+  (for (x 10 0 3 (< x 7))
+   (push x lst2))
+  (and
+   (= lst1 '(1 4 7 10))
+   (= lst2 '(7 10)) )
+)
+
+(define (test-for-all)
+  (and
+    (for-all number? '(2 3 4 6 7)) 
+    (not (for-all number? '(2 3 4 6 "hello" 7)) )
+    (for-all (fn (x) (= x 10)) '(10 10 10 10 10))
+))
+
+
+; use qa-pipe, qa-pipefork, qa-setsig in qa-specific-test/ to test fork
+(define (test-fork) (integer? (fork (exit))))
+
+(define (test-format )
+  (and
+   (= (format "%d" 1.23) "1") 
+   (= (format "%5.2f" 10) "10.00") 
+   (= (format "%c %s %d %g" 65 "hello" 123 1.23) "A hello 123 1.23")
+   (= (format "%5.2s" "hello") "   he")
+   ; args passed in a list
+   (= (format "%d" '(1.23)) "1")  
+   (= (format "%5.2f" '(10)) "10.00")  
+   (= (format "%c %s %d %g" '(65 "hello" 123 1.23)) "A hello 123 1.23")
+   (= (format "%5.2s" '("hello")) "   he")
+   (set 'data '((1 "a001" "g") (2 "a101" "c") (3 "c220" "g")))
+   (set 'result (map (fn (x) (format "%3.2f %5s %2s" (nth 0 x) (nth 1 x) (nth 2 x))) data))
+   (set 'result (map (fn (x) (format "%3.2f %5s %2s" (x 0) (x 1) (x 2))) data))
+   (= result '("1.00  a001  g" "2.00  a101  c" "3.00  c220  g"))
+   (not (catch (format "%%" 1) 'result))
+   (not (catch (format "%10.2lf" 123) 'result))
+   (= (test-format-r '(("foo" "bar") ("foo" "baz"))) 
+      "[ [ 'foo', 'bar' ], [ 'foo', 'baz' ] ]")
+   ; test 64-bit formatting
+   (if (find ostype '("Windows")) ;; Win32 and Win64
+      (begin
+        (and
+         (= (format "%I64d" 0x7fffffffffffffff) "9223372036854775807")
+         (= (format "%I64x" 0x7fffffffffffffff) "7fffffffffffffff")
+         (= (format "%I64u" 0x7fffffffffffffff) "9223372036854775807")
+         (= (format "%I64d" 0x8000000000000000) "-9223372036854775808")
+         (= (format "%I64x" 0x8000000000000000) "8000000000000000")
+         (= (format "%I64u" 0x8000000000000000) "9223372036854775808")
+         (= (format "%I64d" 0xFFFFFFFFFFFFFFFF) "-1")
+         (= (format "%I64x" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+         (= (format "%I64u" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+      )
+      (begin ;; UNIX like OS 
+        (if (= ostype "Tru64Unix") ;TRU64
+          (begin
+            (and
+              (= (format "%d" 0x7fffffff) "2147483647")
+              (= (format "%d" 0xffffffff) "-1")
+              (= (format "%u" 0xffffffff) "4294967295")
+              (= (format "%i" 0x7fffffff) "2147483647")
+
+              ; truncate
+              (= (format "%d" 0x7fffffffffffffff) "-1")
+              (= (format "%u" 0x7fffffffffffffff) "4294967295")
+              (= (format "%x" 0x7fffffffffffffff) "ffffffff") 
+              (= (format "%X" 0x7fffffffffffffff) "FFFFFFFF") 
+
+              (= (format "%ld" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lu" 0xffffffffffffffff) "18446744073709551615")
+              (= (format "%li" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lx" 0x7fffffffffffffff) "7fffffffffffffff")
+              (= (format "%ld" 0x8000000000000000) "-9223372036854775808")
+              (= (format "%lx" 0x8000000000000000) "8000000000000000")
+              (= (format "%lu" 0x8000000000000000) "9223372036854775808")
+              (= (format "%ld" 0xFFFFFFFFFFFFFFFF) "-1")
+              (= (format "%lx" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+              (= (format "%lu" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+          )
+          (begin ; all other UNIX, Linux, OS X
+            (and
+              (= (format "%d" 0x7fffffff) "2147483647")
+              (= (format "%d" 0xffffffff) "-1")
+              (= (format "%u" 0xffffffff) "4294967295")
+
+              ; truncate
+              (= (format "%d" 0x7fffffffffffffff) "-1")
+              (= (format "%u" 0x7fffffffffffffff) "4294967295")
+              (= (format "%x" 0x7fffffffffffffff) "ffffffff") 
+              (= (format "%X" 0x7fffffffffffffff) "FFFFFFFF") 
+
+              (= (format "%lld" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%llx" 0x7fffffffffffffff) "7fffffffffffffff")
+              (= (format "%llu" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lld" 0x8000000000000000) "-9223372036854775808")
+              (= (format "%llx" 0x8000000000000000) "8000000000000000")
+              (= (format "%llu" 0x8000000000000000) "9223372036854775808")
+              (= (format "%lld" 0xFFFFFFFFFFFFFFFF) "-1")
+              (= (format "%llx" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+              (= (format "%llu" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+          )
+      )
+))))
+
+(define (test-format-r obj , s) 
+  (cond 
+   ((string? obj)	(format "'%s'" obj)) 
+   ((list? obj) (format "[ %s ]" (join (map test-format-r obj) ", ")))
+)) 
+
+(define (test-fv )
+  (< (sub (fv 0.1 10 1000 0 0) -15937.4246) 1e-05))
+
+(define (test-gammai )
+  (< (abs (sub (gammai 4 5) 0.734974)) 1e-05))
+
+(define (test-gammaln )
+  (< (abs (sub 120 (exp (gammaln 6)))) 1e-05))
+
+(define (test-gcd)
+ (and
+  (= (gcd 0) 0)
+  (= (gcd 1) 1)
+  (= (gcd 12 36) 12)
+  (= (gcd 12 36 6) 6)
+  (= (gcd 12 36 6 3) 3)
+))
+
+(define (test-get-char )
+ (and
+  (= 65 (get-char (address "A")) (get-char "ABC"))
+  (set 'D:D "ABC")
+  (= 65 (get-char D))
+))
+
+(define (test-get-float )
+    (and
+        (= 1.234 (get-float (pack "lf" 1.234)))
+        (= (get-float (address (get-long (address 17.4)))) 17.4)
+        (= (get-long (address (get-float (address 4625590882276894310)))) 4625590882276894310) 
+    ) )
+
+(define (test-get-int )
+  (and
+    (= 123456789 (get-int (pack "ld" 123456789)))
+    (set 'adr (pack "ldld" 0xaabbccdd 0xccddeeff))
+    (= (format "%x" (get-int adr)) "aabbccdd")
+    (= (format "%x" (get-int (address adr))) "aabbccdd")
+    (= (format "%x" (get-int (+ (address adr) 0))) "aabbccdd")
+    (= (format "%x" (get-int (+ (address adr) 4))) "ccddeeff")
+    (set 'adr (pack "> ldld" 0xaabbccdd 0xccddeeff))
+    (= adr "\170\187\204\221\204\221\238\255")
+    (set 'adr (pack "< ldld" 0xaabbccdd 0xccddeeff))
+    (= adr "\221\204\187\170\255\238\221\204")
+    (set 'buff (pack "lulululululululu" 1 2 3 4))
+    (apply and (map (fn (i) (= (+ i 1) (get-int (+ (* i 4) (address buff))))) '(0 1 2 3))) 
+))
+
+(define (test-get-long)
+	(set 'adr (pack "Ld" -1))
+	(= -1 (get-long adr)))
+
+(define (test-get-string )
+  (= "hello" (get-string (address "hello"))))
+
+(define (test-get-url )
+  (and
+    (starts-with (get-url "file://qa-dot") "#!/usr/bin/env newlisp")
+    (= "ERR: HTTP bad formed URL" (get-url ""))
+))
+
+
+(define (test-global)
+	(= global-myvar 123))
+
+(define (test-global?)
+	(and
+		(global? 'global-myvar)
+		(global? 'println)
+))
+
+(define (test-if )
+  (and 
+   (if true true) 
+   (if nil nil true) 
+   (if 'nil nil true) 
+   (if '() nil true)
+   (= (if '()) '())
+   (= (if nil 1 '() 2) '())
+   (= (if nil '() '()) '())
+   (= (if true '() '()) '())
+   (= (if nil 1 nil 2 nil 3 true 4 3) 4)
+   (= (if nil 1 nil 2 nil 3 nil 4 3) 3)
+   ; anaphoric $it
+   (if 123 (= $it 123))
+   ))
+
+(define (test-if-not )
+  (if-not nil 
+   true nil))
+
+(define (test-ifft )
+  (= '((1 2) (3 4)) (ifft (fft '((1 2) (3 4))))))
+
+(define (test-import )
+  (primitive? import))
+
+(define (test-inc , x)
+  (and
+	(= (inc x) 1)
+	(= (inc x) 2)
+	(set 'l '(1 2 3 4))
+	(= (inc (l 1)) 3)
+	(= (dec (nth 0 l) 2) -1)
+	(= (dec (last l) 0.1) 3.9)
+	(= (inc (+ 3 4)) 8)
+	(= l '(-1 3 3 3.9))
+))
+
+(define (test---) (test-++))
+
+(define (test-++ , x)
+	(and 
+		(= (++ x) 1)
+		(= (++ x) 2)
+		(= (++ x 3) 5)
+		(set 'l '(0 nil 2.5))
+		(= (-- (l 0)) -1)
+		(= (++ (l 1)) 1)
+		(= (++ (l 2) 2) 4)
+		(= l '(-1 1 4))
+	)
+)
+
+(define (test-index )
+  (= '(1 3) (index (lambda (x) (> x 3)) '(1 5 2 6 2 0))))
+
+(define (test-inf?)
+	(inf? (div 1 0)))
+
+(define (test-integer )
+  (and 
+    (integer? (int "12345"))
+    (= (int " 12345") 12345)
+    (= (int "9223372036854775807")  9223372036854775807)
+    (= (int "-9223372036854775808") -9223372036854775808)
+    (= (int 0.0) 0)
+    (= (int 1e30)  9223372036854775807)
+    (= (int -1e30) -9223372036854775808)
+    (= (int 0x8000000000000000) (int "0x8000000000000000"))
+	(set 'D:D 12345)
+	(= (int D) 12345)
+	(= (int "gg" 99) 99)
+	(= (int "ff" 99 16) 255)
+	(= (int "-ff" 99 16) -255)
+    (= (int "0b101010") 42)
+    (= (int "101010" 0 2) 42)
+))
+
+(define (test-int) (test-integer))
+
+(define (test-integer? )
+  (and
+    (integer? 12345)
+    (integer? 9223372036854775807)
+    (integer? -9223372036854775808)
+    (integer? 0x7FFFFFFFFFFFFFFF)
+    (integer? 0xFFFFFFFFFFFFFFFF)
+))
+
+(define (test-intersect )
+  (and
+    (= (intersect '(3 0 2 4 1) '(1 4 2 5)) '(2 4 1))
+    (set 'L '(a b c d e f))
+    (= (intersect L L) L)
+  )
+)
+
+(define (test-invert )
+  (set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+  (set 'I (multiply A (invert A)))
+  (set 'J (multiply (array 3 3 (flat A)) (invert (array 3 3 (flat A)))))
+  (and (< (sub 1 (nth 0 (nth 0 I))) 1e-06)
+       (< (sub 1 (nth 1 (nth 1 I))) 1e-06) 
+       (< (sub 1 (nth 2 (nth 2 I))) 1e-06)
+       (= I (array-list J)) 
+       (not (invert '((0 1 0) (1 0 1) (0 0 0))) )
+))
+
+(define (test-irr )
+  (< (abs (sub (irr '(-1000 500 400 300 200 100)) 0.20272)) 0.0001))
+
+(define (test-join )
+  (and 
+    (= "this is a sentence" (join '("this" "is" "a" "sentence") " ")) 
+    (= "this_is_a_sentence" (join '("this_" "is_" "a_" "sentence")))
+    (= "" (join '()))
+	(= (join '("A" "B" "C") "-") "A-B-C")
+	(= (join '("A" "B" "C") "-" true) "A-B-C-")
+))
+
+(define (test-json-error)
+    (and
+        (not (json-parse {{"key" : "value" , "hello"  "world"}}))
+        (= (json-error) '("missing : colon" 28))
+    ))
+
+; see also qa-specific-tests/qa-json
+(define (test-json-parse)
+    (and 
+        (= (json-parse { {"key" : "value" , "hello" : "world", "array" : [1, 2, 3, 4, 5]} })
+        '(("key" "value") ("hello" "world") ("array" (1 2 3 4 5))))
+        (= (json-parse { [1,2,3,4,5,6,{ "nested" : 777}, 8, 9] } )
+          '(1 2 3 4 5 6 (("nested" 777)) 8 9) )
+    ))
+
+(define (test-kmeans-query) true)
+
+(define (test-kmeans-train)
+    (let (data '(
+        (1.85 1.89 0.11) 
+        (2.11 2.14 0.85) 
+        (2.48 2.26 0.19) 
+        (2.43 2.14 1.59) 
+        (2.29 4.18 1.06) 
+        (1.17 4.46 1.02) 
+        (3.12 3.1 1.4) 
+        (9.44 2.65 7.37) 
+        (8.16 3.83 8.93) 
+        (8.49 5.31 7.47) 
+        (7.01 4.2 11.9) 
+        (6.57 4.96 11.91) 
+        (8.63 2.51 8.11) 
+        (7.18 3.46 8.7) 
+        (8.17 6.59 7.49)
+        (6.79 8.72 8.62) 
+        (5.44 5.9 5.57) 
+        (7.56 7.93 5.06) 
+        (3.61 7.95 5.11) 
+        (6.77 6.04 3.76) ))
+      (< (abs (apply add (map sub (kmeans-train data 3 'MAIN:KMT) 
+                              '(403.8613998 122.6051922 91.49019772 85.06633163 82.74597619)))) 0.000001)
+      (= KMT:labels '(2 2 2 2 2 2 2 3 3 3 3 3 3 3 1 1 1 1 1 1))
+      (= KMT:clusters '((14 15 16 17 18 19) (0 1 2 3 4 5 6) (7 8 9 10 11 12 13)))
+      (< (abs (apply add (map sub KMT:deviations '(2.457052209 1.240236975 2.260089397)))) 0.000001)
+      (< (abs (apply add (map sub  (flat KMT:centroids) (flat '((6.39 7.188333333 5.935) 
+                       (2.207142857 2.881428571 0.8885714286) 
+                       (7.925714286 3.845714286 9.198571429)))))) 0.000001)
+      (< (abs (apply add (map sub (kmeans-query '(1 2 3) KMT:centroids) 
+                                '(8.036487279 2.58693657 9.475994267)))) 0.000001)
+    ) 
+)  
+
+
+
+(define (test-lambda? )
+  (lambda? qa))
+
+(define (test-last )
+  (= 'f (last '(a b c d e f)))
+  (= "p" (last "newlisp"))
+  (= (array 2 '(5 6)) (last (array 3 2 (sequence 1 6))))
+  ;; default functor
+  (set 'D:D '(a b c d e f g))
+  (= (last D) 'g)
+  (set 'D:D (array 7 '(a b c d e f g)))
+  (= (last D) 'g)
+  (not (catch (last '()) 'result))
+)
+
+(define (test-last-error)
+	(= (last-error 1) '(1 "not enough memory"))
+)
+
+(define (test-legal?)
+  (and
+    (legal? "abc")
+    (not (legal? "a b c"))
+    (set 'greek (pack "cccccccccccccccccc" 206 160 206 181 206 187 206 181 206 185 206
+				172 206 180 206 181 207 137))
+    (legal? greek)
+))
+
+
+(define (test-length )
+  (> (length (symbols)) 100)
+  (- 7 (length "newlisp"))
+  (= 3 (length 123))
+  (= 3 (length 123.456))
+  (= 1 (length 0))
+  (= 1 (length 0.789))
+  (= 7 (length 10e5))
+)
+
+(define (test-let )
+  (set 'a 123)
+  (set 'b 456)
+  (set 'p 111)
+  (set 'q 222)
+  (and
+     (let ((a 1) (b 2)) 
+       (= (+ a b) 3))
+     (= a 123) 
+     (= b 456)
+     (let (p 3 q 4)
+       (= (+ q p) 7))
+     (= p 111)
+     (= q 222)
+))
+
+(define (test-letex)
+  (and
+	(= (letex (x '* y 3 z 4) (x y z)) 12)
+	(= (letex (x 1 y 2 z 3) (quote (x y z))) '(1 2 3))
+	(= (letex (x 1 y 2 z 3) '(x y z)) '(1 2 3))
+	(= (letex (x 1 y 2 z 3) '('x (quote y) z)) '('1 (quote 2) 3))
+	(= (letex (x 1) 'x) 1)
+    (set 'x 123 'y 456)
+    (= (letex (x 'y) 'x) 'y)
+    (= (letex (x 'y) x) 456)
+    (= (letex (x '(+ 3 4)) 'x) '(+ 3 4))
+    (= (letex (x '(+ 3 4)) x) 7)
+	))
+
+(define (test-letn)
+  (set 'x 0 'y 0 'z 0)
+  (and
+      (= (letn ((x 1) (y (+ x 1)) (z (+ y 1))) (list x y z)) '(1 2 3))
+      (= 0 x y z))
+)
+
+(define (test-list )
+  (and (list? (list 1 2 3 4 5)) (= '(1) (list 1)) (= '(1 nil) (list 
+     1 'nil))))
+
+(define (test-list? )
+  (and (list? '(1 2 3 4 5)) (list? '())))
+
+(define (test-load )
+  (write-file "junk" "(+ 3 4)")
+  (load "junk"))
+
+(define (test-local)
+	(set 'a 10 'b 20)
+	(and 
+		(= (local (a b) (set 'a 1 'b 2) (+ a b)) 3)
+		(= a 10)
+		(= b 20)))
+
+(define (test-set-locale) 
+  (list? (set-locale)))
+
+(define (test-log )
+  (and
+  	(= 1 (log (exp 1)))
+	(= 1 (log (exp 1) (exp 1)))
+  )
+)
+
+(define (test-lookup )
+  (and 
+	(= 3 (lookup 1 '((2 3 4) (1 2 3)))) 
+	(= 2 (lookup 1 '((2 3 4) (1 2 3)) 1))
+	; default functor
+	(set 'D:D '((a 1 2 3) (b 4 5 6) (c 7 8 9)))
+	(= 6 (lookup 'b D -1))
+))
+
+(define (test-lower-case )
+   (= "abcdefghijklmnopqrstuvwxyz" (lower-case "ABCDEFGHIJKLMNOPQRSTUVWXYZ")))
+
+(define (test-macro)
+    (= (unless testmacro (macro (testmacro x) (+ x x))) 
+        (lambda-macro (x) (expand '(+ x x))))
+)
+
+(define (test-macro? )
+  (macro? 
+   (define-macro (foo-macro))))
+
+(define (test-main-args )
+  (and 
+     (list? (main-args))
+     (list? $main-args)
+     (= $main-args (main-args))
+     (= ($main-args 0) ((main-args) 0) (main-args 0))
+     (= ($main-args -1) ((main-args) -1))
+     (= ($main-args -1) (main-args -1))
+))
+
+(define (test-make-dir )
+  (and (make-dir "foodir") (remove-dir "foodir")))
+
+(define (test-map )
+  (and (= '(11 22 33) (map + '(10 20 30) '(1 2 3))) 
+       (= '(2 4 6) (map (lambda (x) (+ x x)) '(1 2 3)))
+	   (set 'D:D '(1 2 3 4 5))
+       (= (map pow D) '(1 4 9 16 25))
+       (= (map pow (array 5 D))  '(1 4 9 16 25))
+))
+
+(define (test-mat)
+	(set 'A '((1 2 3) (4 5 6))) 
+	(set 'B A)
+	(and
+		(= (mat + A B) '((2 4 6) (8 10 12)))
+		(= (mat - A B) '((0 0 0) (0 0 0)))
+		(= (mat * A B) '((1 4 9) (16 25 36)))
+		(= (mat / A B) '((1 1 1) (1 1 1)))
+		(= (mat + A 2) '((3 4 5) (6 7 8)))
+		(= (mat - A 2) '((-1 0 1) (2 3 4)))
+		(= (mat * A 2) '((2 4 6) (8 10 12)))
+		(= (mat / A 2) '((0.5 1 1.5) (2 2.5 3)))
+
+		(= (mat + A 5) '((6 7 8) (9 10 11)))
+		(= (mat - A 2) '((-1 0 1) (2 3 4)))
+		(= (mat * A 3) '((3 6 9) (12 15 18)))
+		(= (mat / A 10) '((.1 .2 .3) (.4 .5 .6)))
+
+        (set 'op +)
+		(= (mat op A B) '((2 4 6) (8 10 12)))
+        (set 'op '+)
+		(= (mat op A B) '((2 4 6) (8 10 12)))
+		; default functor
+		(set 'DA:DA A)
+		(set 'DB:DB B)
+		(= (mat + DA DB) '((2 4 6) (8 10 12)))
+        (set 'B '((-1 1 1) (1 4 -5) (1 -2 0)))
+        (set 'A '((1 2 3) (4 5 6)))
+        (not (catch (mat + A B) 'result))
+        (starts-with result "ERR: wrong dimensions")
+	))
+
+(define (test-match)
+  (and 
+    (= (match '(a (b ?) d e *) '(a (b c) d e f g) true)   '(a (b c) d e (f g)) )
+    (= (match '(a (b ?) d e *) '(a (b c) d e f g) )  '(c (f g)) )
+
+    (= (match '(a * b x) '(a b c d b x e f b x) true) '(a (b c d b x e f) b x) )
+    (= (match '(a * b x) '(a b c d b x e f b x) ) '((b c d b x e f)) )
+
+
+    (= (match '(? (?) x * ? (? e)) '(a (b) x y c (d e)) true) '(a (b) x (y) c (d e)) )
+    (= (match '(? (?) x * ? (? e)) '(a (b) x y c (d e))) '(a b (y) c d) )
+
+    (= (match '(a * b) '(a x b) true) '(a (x) b) )
+    (= (match '(a * b) '(a x b)) '((x)) )
+
+
+    (= (match '(a * b) '(a b) true) '(a () b) )
+    (= (match '(a * b) '(a b)) '(()) )
+
+    (= (match '( (? ?) * ) '( (x y) ) true) '((x y) ()) )
+    (= (match '( (? ?) * ) '( (x y) )) '(x y ()) )
+    (match '(+) '(a))
+    (match '(+) '(a b))
+    (not (match '(+) '()))
+	; default functors
+	(set 'P:P '(a (b ?) d e *) )
+	(set 'M:M '(a (b c) d e f g))
+	(true? (match P M))
+  ))
+
+
+(define (test-max )
+  (and (= 10 (max 3 6 10 8)) (= 1.2 (max 0.7 0.6 1.2))))
+
+(define (test-member )
+ (and	
+  (= '(3 4) (member 3 '(1 2 3 4)))
+  (= (member "LISP" "newLISP") "LISP")
+  (= (member "LI" "newLISP") "LISP")
+  (= (member "" "newLISP") "newLISP")
+  (not (member "xyz" "newLISP"))
+  (not (member "new" "this is NEWLISP" 0))
+  (= (member "new" "this is NEWLISP" 1) "NEWLISP")
+  ; default functor
+  (set 'D:D '(1 2 3 4))
+  (= '(3 4) (member 3 D))
+  (set 'D:D "newLISP")
+  (= "LISP" (member "LI" D))
+ )  
+)
+
+(define (test-min )
+  (and (= 3 (min 3 6 10 8)) (= 0.6 (min 0.7 0.6 1.2))))
+
+(define (test-mod )
+  (and 	(< (sub (mod 10.5 3.3) 0.6) 0.0001) 
+		(< (sub (mod 10 3) 1) 0.0001)
+		(< (sub (mod 10.5) 0.5) 0.0001)
+))
+
+(define (test-mul )
+  (and
+    (= (mul) 1)
+    (= 1e-09 (mul 0.0001 1e-05))
+))
+
+(define (test-multiply )
+  (let ((A '((1 2 3) (4 5 6))) (B '((1 2) (1 2) (1 2)))) 
+    (and 
+       (= '((6 12) (15 30)) (multiply A B))
+       (= (array 2 2 (flat '((6 12) (15 30))))
+          (multiply (array 2 3 (flat A)) (array 3 2 (flat  B))))
+    )
+))
+
+
+(define (test-net-accept )
+  (and
+	(set 'net-listen-test (set 'listen (net-listen 12345)))
+	(if (zero? (& (sys-info -1) 512)) ; IPv4
+		(set 'net-connect-test (set 'connect (net-connect "localhost" 12345)))
+		(set 'net-connect-test (set 'connect (net-connect "::1" 12345)))
+	)
+	(set 'server (net-accept listen))
+	(set 'net-send-test (= (net-send server "hello") 5))
+	(set 'net-select-test (net-select connect "r" 100000))
+	(set 'net-peek-test (= (net-peek connect) 5))
+	(set 'net-receive-test (net-receive connect buff 20))
+	(= buff "hello")
+	(set 'net-sessions-test (and  
+	  (find listen (net-sessions))
+	  (find connect (net-sessions))
+	  (find server (net-sessions))))
+	(set 'net-local-test (= (net-local server) (net-peer connect)))
+	(set 'net-peer-test (= (net-local connect) (net-peer server)))
+	(set 'net-close-test (net-close connect))
+	(set 'net-close-test (net-close server))
+	(set 'net-close-test (net-close listen))
+	(not (net-error))
+))
+
+(define (test-net-close ) net-close-test)
+
+(define (test-net-connect )  net-connect-test)
+
+(define (test-net-error ) 
+	(and
+		(not (net-close 12345))
+		(list? (net-error))))
+
+(define (test-net-eval) true) ;; see special test prog
+
+(define (test-net-interface) true) ;; test manually on multihoned machine
+
+(define (test-net-ipv) 
+	(and (= (net-ipv) 4) (= (net-ipv 6) 6) (= (net-ipv 4) 4)))
+
+(define (test-net-listen ) net-listen-test)
+
+(define (test-net-local ) net-local-test)
+
+(define (test-net-lookup )
+	(if (zero? (& (sys-info -1) 512)) ; IPv4
+	    (and (= "127.0.0.1" (net-lookup "localhost")) (string? (net-lookup "127.0.0.1")))
+		(and (= "localhost" (net-lookup "::1")) (= "::1" (net-lookup "localhost")))
+	)
+)
+
+(define (test-net-packet) true);
+
+(define (test-net-peek ) net-peek-test)
+
+(define (test-net-peer ) net-peer-test)
+
+(define (test-net-ping) true) ; test manualyy as superuser
+
+(define (test-net-receive ) net-receive-test)
+
+(define (test-net-receive-from)
+  (and
+    (set 'sock (net-listen 1234 "localhost" "udp"))
+    (set 'net-send-to-test (net-send-to "localhost" 1234 "hello" sock))
+    (set 'net-select-test (net-select sock "r" 1000000) )
+    (= "hello" (first (net-receive-from sock 10)))
+    (net-close sock)))
+
+
+(define (test-net-receive-udp)
+    (write-file "udptest.lsp"
+[text]
+(map set '(in out sid) (map int (slice (main-args) 2)))
+(semaphore sid 1) ; signal parent to start
+(set 'msg (net-receive-udp in 20 2000000))
+(sleep 100)
+(if (not msg) (exit))
+(net-send-udp "localhost" out (upper-case (first msg)))
+(exit)
+[/text]
+    )
+  (and
+    (set 'sid (semaphore))
+    (if (find ostype '("Windows" "OS/2"))
+      (process (string "newlisp udptest.lsp " 10001 " " 10002 " " sid))
+      (process (string "./newlisp udptest.lsp " 10001 " " 10002 " " sid)))
+    ;(println "---------- testing UDP Win32/64 and OS/2 -------------")
+    ;(println "waiting ...");
+    (semaphore sid -1) ; wait for child process
+    (sleep 100)
+    ;(println "sending ...")
+    (net-send-udp "localhost" 10001 "hello") 
+    ;(println "receiving ...")
+    (set 'msg (net-receive-udp 10002 20 3000000))
+    ;(println "msg:" msg)
+    (or (delete-file "udptest.lsp") true)
+    ;(println "deleting semaphore:" (semaphore sid 0)) ; delete semaphore
+    ;(println "------------------------------------------")
+    (if msg (set 'net-send-udp-test (= "HELLO" (first msg)) ) )))
+
+
+(if (find ostype '("Linux" "BSD" "OSX" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+  (define (test-net-receive-udp)
+    (fork (begin (sleep 500) (net-send-udp "localhost" 10001 "hello")))
+    (set 'net-send-udp-test (= "hello" (first (net-receive-udp 10001 10)))))
+)
+
+
+(define (test-net-select )  net-select-test)
+
+(define (test-net-send ) net-send-test)
+
+(define (test-net-send-to ) net-send-to-test)
+
+(define (test-net-send-udp ) net-send-udp-test)
+
+(define (test-net-service ) (= 21 (net-service "ftp" "tcp")))
+
+(define (test-net-sessions ) net-sessions-test)
+
+(define (test-new) 
+  (new QA 'MAIN:QA2))
+
+(define (test-nil?) 
+  (and
+    ;test symbol-nil = logic-nil in order compare of count
+	(= (count '(nil true) (map (curry < 3) '(1 2 4 5))) '(2 2))
+    (= nil (not (nil? nil)))
+    (= '(nil true) (map nil? '(a nil)))))
+
+(define (test-null?)
+	(= (map null? '(1 0 2 0.0 "hello" "" (a b c) () nil true (lambda) (fn) (lambda ())))
+	'(nil true nil true nil true nil true true nil true true nil)))
+
+(define (test-normal )
+  (and (float? (normal)) (float? (normal 10 3)) (list? (normal 10 
+     3 100))))
+
+(define (test-not )
+  (and (not (not (not '()))) (not (not (not (not (not nil))))) (not 
+    (not (not (not true)))) 
+   (= '(true true true) (map not '(nil nil nil))) 
+   (= '(nil nil nil) (map not '(true true true)))))
+
+(define (test-now )
+  (and
+  	(= (length (now)) 11)
+	(= 3600 (round (- (apply date-value (now 60)) (date-value)) 2))
+	)
+)
+
+(define (test-nper )
+  (< (sub (nper 0.1 1000 100000 0 0) -25.15885793) 1e-08))
+
+(define (test-npv )
+  (< (sub (npv 0.1 '(-10000 3000 4200 6800)) 1188.443412) 1e-06))
+
+(define (test-nth , l)
+	(and 
+		(set 'l '(0 1 2))
+		(= 0 (nth 0 l))
+		(= 1 (nth 1 l))
+		(= 2 (nth 2 l))
+		(= 2 (nth -1 l))
+		(= (nth 0 "lisp") "l")
+		(= (nth 1 "lisp") "i")
+		(= (nth 3 "lisp") "p")
+		(= (nth -4 "lisp") "l")
+		(= (nth 0 "") "")
+		
+		(set 'l '(a b (c d) (e f)))
+		(= 'a (l 0))
+		(= '(c d) (l 2))
+		(= 'c (l 2 0))
+		(= 'f (l -1 -1))
+		(= 'c (l '(2 0)))
+		(= 'f (l '(-1 -1)))
+        (= (l '()) l)
+
+		(set 'myarray (array 3 2 (sequence 1 6)))
+		(= (array 2 '(3 4)) (myarray 1))
+		(= 6 (myarray -1 -1))
+        (= (myarray '()) myarray)
+
+		(= (array 2 '(3 4)) (myarray '(1)))
+		(= 6 (myarray '(-1 -1)))
+
+		(= "L" ("newLISP" 3))
+
+		(constant 'constL '((1 2 3) (a b c)))
+		(set 'aref '(1 2))
+		(= (constL 1 2) 'c)
+		(= (nth '(1 2) constL) 'c)
+		(= (nth (list (- 2 1) (+ 1 1)) constL) 'c)
+		(= (nth aref constL) 'c)
+        (= (nth '() constL) constL)
+
+		; default functor
+		(set 'D:D '(a b (c d) (e f)))
+		(= 'a (D 0))
+		(= '(c d) (D 2))
+		(= 'c (D 2 0))
+		(= 'f (D -1 -1))
+		(= 'c (D '(2 0)))
+		(= 'f (D '(-1 -1)))	
+		(= 'a (nth 0 D))
+		(= '(c d) (nth 2 D))
+  ))
+
+(define (test-number?)
+    (and
+        (number? 1)
+        (number? 1.23)
+        (not (number? 'x))
+        (not (number? "abc"))
+        (not (number? '(a b c)))
+    )
+)
+
+(define (test-open )
+  (and 
+    (set 'fle (open "qa-dot" "read"))
+    (close fle)))
+
+(define (test-odd?)
+    (and (odd? 3) (not (odd? 2)) (odd? 3.34) (not (odd? 2.999))))
+
+(define (test-or )
+  (and (or (or (= 1 2) nil nil) (or nil nil nil true)) (not (or nil 
+     (= "a" "b") nil))))
+
+(define (test-pack )
+ (and
+  (= (pack "c c c" 65 66 67) "ABC")
+  (= (unpack "c c c" "ABC") '(65 66 67))
+  (set 's (pack "c d u" 10 12345 56789))
+  (= (unpack "c d u" s) '(10 12345 56789))
+  (set 's (pack "s10 f" "result" 1.23))
+  (= (first (unpack "s10 f" s)) "result\000\000\000\000")
+  (< (- (last (unpack "s10 f" s)) 1.23) 0.00001)
+  (set 's (pack "s3 lf" "result" 1.23))
+  (= (first (unpack "s3 f" s)) "res")
+
+  (= (pack "ccc" 65 66 67) "ABC")
+  (= (unpack "ccc" "ABC") '(65 66 67))
+  (set 's (pack "cdu" 10 12345 56789))
+  (= (unpack "cdu" s) '(10 12345 56789))
+  (set 's (pack "s10f" "result" 1.23))
+  (= (first (unpack "s10f" s)) "result\000\000\000\000")
+  (< (- (last (unpack "s10f" s)) 1.23) 0.00001)
+  (set 's (pack "s3lf" "result" 1.23))
+  (= (first (unpack "s3f" s)) "res")
+
+  (= "\001\000" (pack "<d" 1))
+  (= "\000\001" (pack ">d" 1))
+  (= "\001\000\000\000" (pack "<ld" 1))
+  (= "\000\000\000\001" (pack ">ld" 1))
+  (= '(12345678) (unpack "ld" (pack "ld" 12345678)))
+  (= '(12345678) (unpack "<ld" (pack "<ld" 12345678)))
+  (= '(12345678) (unpack ">ld" (pack ">ld" 12345678)))
+  (= (unpack "bbbbbbbb" (pack "<lf" 1.234)) '(88 57 180 200 118 190 243 63))
+  (= (unpack "bbbbbbbb" (pack ">lf" 1.234)) '(63 243 190 118 200 180 57 88))
+  (= (format "%20.2f" (first (unpack "lf" (pack "lf" 1234567890123456)))) " 1234567890123456.00")
+))
+
+(define (test-parse )
+  (and 
+    (= 3 (length (parse "hello hi there"))) 
+    (= (parse "abcbdbe" "b") '("a" "c" "d" "e")) 
+    (= (parse "," ",") '("" ""))  
+    (= (parse "hello regular   expression 1, 2, 3" {,\s*|\s+} 0)
+       '("hello" "regular" "expression" "1" "2" "3"))))
+
+(define (test-parse-date) (test-date-parse))
+
+(define (test-prefix)
+	(set 's 'Foo:bar)
+	(= s (sym (term s) (prefix s))))
+
+(define (test-peek)
+	(set 'fle (open "qa-dot" "r"))
+	(= (peek fle) (first (file-info "qa-dot")))
+	(close fle))
+
+(define (test-pipe)
+	(write-file "pipe-child.lsp" 
+[text]
+(set 'msg (read-line (int (nth 2 (main-args)))))
+(write-line (int (nth 3 (main-args))) (upper-case msg))
+(exit)
+[/text]
+	)
+  (and
+	(set 'channel (pipe))
+	(set 'in (first channel))
+	(set 'out (last channel))
+	(if (find ostype '("Windows" "OS/2"))
+		(process (string "newlisp pipe-child.lsp " in " " out))
+		(process (string "./newlisp pipe-child.lsp " in " " out)))
+	(sleep 500)
+	(write-line out "hello there")
+	(sleep 500)
+	(= (read-line in) "HELLO THERE")
+	(delete-file "pipe-child.lsp")
+  )
+)
+
+;(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "Aix" "True64Unix" "Cygwin"))
+(if (find ostype '("BSD" "OSX" "Solaris" "SunOS" "Aix" "True64Unix" "Cygwin"))
+  (define (test-pipe)
+	(set 'channel (pipe))
+	(set 'in (first channel))
+	(set 'out (last channel))
+	(fork (write-line out (upper-case (read-line in))))
+	(write-line out "hello there")
+	(sleep 1000)
+	(= (read-line in) "HELLO THERE")
+	)
+)
+
+
+(define (test-pmt ) 
+  (< (sub (pmt 0.1 10 100000 0 0) -16274.53949) 1e-05))
+
+(define (test-pop , r l)
+  (set 'r '())
+  (set 'l '(1 2 3 4 5 6 7 8 9 0))
+  (dotimes (x 10) 
+   (push (pop l) r))
+  (and (= r '(0 9 8 7 6 5 4 3 2 1))
+       (set 'l '(a b (c d (x) e)))
+       (= 'x (pop l '(2 2 0)))
+       (set 'lst '(1 2 3 (4 5)()))
+       (push 'x lst -1 -1)
+       (= lst '(1 2 3 (4 5) (x)))
+       (push 'y lst -1 0)
+       (= lst '(1 2 3 (4 5) (y x)))
+       (push 'z lst -1 1)
+       (= lst '(1 2 3 (4 5) (y z x)))
+       (push 'p lst 4)
+       (= lst '(1 2 3 (4 5) p (y z x)))
+       (push 'q lst -2)
+       (= lst '(1 2 3 (4 5) p q (y z x)))
+       (push 'a lst 3 -3)
+       (= lst '(1 2 3 (a 4 5) p q (y z x)))
+       (= (pop lst 3 -3) 'a)
+       (= (pop lst -2) 'q)
+       (= (pop lst 4) 'p)
+       (= (pop lst -1 1) 'z)
+       (= (pop lst -1 0) 'y)
+       (= (pop lst -1 -1) 'x)
+       (= lst '(1 2 3 (4 5)()))
+       ; test pop string
+       (set 's "newLISP")
+       (= (pop s) "n")
+       (= s "ewLISP")
+       (= (pop s 2) "L")
+       (= s "ewISP")
+       (= (pop s -1) "P")
+       (= s "ewIS")
+       (= (pop s -2 2) "IS")
+       (= s "ew")
+       (= (pop s -2 10) "ew")
+       (= s "")
+       (set 's "123456789")
+       (= (pop s 5) "6")
+       (= (pop s 5 -1) "")
+       (= s "12345789")
+       (set 's "123456789")
+       (= (pop s 5 5) "6789")
+       (set 's "x")
+       (= (pop s) "x")
+       (= s "")
+       (= (pop s) "")
+       (= (pop s) "")	
+       (= s "")
+		; default functor
+		(set 'D:D '(a b (c d (x) e)))
+		(= 'x (pop D '(2 2 0)))
+))
+
+(define (test-pop-assoc)
+	(and
+		(set 'L '((a (b 1) (c (d 2)))))
+		(= (pop-assoc 'a L) '(a (b 1) (c (d 2))))
+		(= L '())
+		(set 'L '((a (b 1) (c (d 2)))))
+		( = (pop-assoc '(a b) L) '(b 1))
+		(= L '((a (c (d 2)))))
+		(set 'L '((a (b 1) (c (d 2)))))
+		(= (pop-assoc '(a c) L) '(c (d 2)))
+		(= L '((a (b 1))))
+		(set 'L '((a (b 1) (c (d 2)))))
+		(= (pop-assoc (list 'a 'c 'd) L) '(d 2))
+		(= L '((a (b 1) (c))))
+		(= (pop-assoc '(a c) L) '(c))
+		(= L '((a (b 1))))
+		(= (pop-assoc '(a b) L) '(b 1))
+		(= L '((a)))
+		(= (pop-assoc 'a L) '(a))
+		(= L '())
+		; default functor
+		(set 'D:D '((a (b 1) (c (d 2)))))
+		(= (pop-assoc 'a D) '(a (b 1) (c (d 2))))
+		(= D:D '())
+        ; pop-assoc last, should disable nested last-element optimizations (10.5.4)
+        (= (set 'data '()) '())
+        (push '(1 (k_1 "v_1")) data)
+        (set 'result (push '(k_2 "v_2") (assoc 1 data) -1))
+        (pop-assoc '(1 k_2) data)
+        (= result (push '(k_2 "v_2") (assoc 1 data) -1))
+	)
+)
+
+(define (test-post-url )
+  (= "ERR: HTTP bad formed URL" (post-url "" "abc" "def")))
+
+(define (test-pow )
+  (and
+    (= 1024 (pow 2 10))
+    (= 100 (pow 10))
+))
+
+(define (test-pretty-print)
+  (= (pretty-print) '(80 " " "%1.16g"))
+)
+
+(define (test-primitive? )
+  (primitive? primitive?))
+
+(define (test-print ) 
+  (device (open "testprint" "w"))
+  (print "hello")
+  (close (device))
+  (and (= "hello" (read-file "testprint"))
+     (delete-file "testprint")))
+
+(define (test-println ) 
+  (device (open "testprintln" "w"))
+  (print "hello")
+  (close (device))
+  (and 
+     (= "hello" (slice (read-file "testprintln") 0 5))
+     (delete-file "testprintln")))
+
+(define (test-prob-f)
+  (and
+    (< (abs (sub (prob-f 6.59 3 4) 0.05)) 0.001)
+    (< (abs (sub (prob-f 2.79 12 11) 0.05)) 0.001)
+    (< (abs (sub (prob-f 16.69 3 4) 0.01)) 0.0001)
+    (< (abs (sub (prob-f 4.40 12 11) 0.01)) 0.0001)
+))
+
+(define (test-prob-chi2)
+  (and
+    (< (abs (sub (prob-chi2 4.605 2) 0.1)) 0.001)
+    (< (abs (sub (prob-chi2 51.805 40) 0.1)) 0.001)
+    (< (abs (sub (prob-chi2 9.210 2) 0.01)) 0.0001)
+    (< (abs (sub (prob-chi2 63.691 40) 0.01)) 0.0001)
+))
+
+(define (test-prob-t)
+  (and
+    (< (abs (sub (prob-t 1.886 2) 0.1)) 0.001)
+    (< (abs (sub (prob-t 1.303 40) 0.1)) 0.001)
+    (< (abs (sub (prob-t 6.965 2) 0.01)) 0.0001)
+    (< (abs (sub (prob-t 2.423 40) 0.01)) 0.0001)
+))
+
+(define (test-prob-z)
+    (and
+        (< (sub (prob-z -0.1) 0.4601721627) 0.00001)
+        (< (sub (prob-z 0.1) 0.5398278373) 0.00001)
+        (< (sub (prob-z -1) 0.1586552539) 0.00001)
+        (< (sub (prob-z 1) 0.8413447461) 0.00001)
+        (< (sub (prob-z -2) 0.02275013195) 0.00001)
+        (< (sub (prob-z 2) 0.9772498681) 0.00001)
+        (< (sub (prob-z -3) 0.001349898032) 0.00001)
+        (< (sub (prob-z 3) 0.998650102) 0.00001)
+))
+
+
+(define (test-process ) 
+   (write-file "process test" {(write-file "test process" "hello") (exit)})
+   (if (find ostype '("Windows" "OS/2"))
+	(process {newlisp '"process test"'}) ; Win32 and Win64
+    (process "./newlisp 'process test'")) ; Unix
+   (until (file? "test process") (sleep 500))
+   (sleep 200)
+   (and
+     (= "hello" (read-file "test process"))
+     (delete-file "process test")
+     (delete-file "test process")))
+
+(define (test-prompt-event) true) /* test interactively */
+
+(define (test-protected?)
+	(and
+		(protected? 'println)
+		(constant 'cval 123)
+		(protected? 'cval)
+		(protected? 'QA))
+)
+
+(define (test-push , l)
+  (dotimes (x 10) 
+   (push x l x))
+  (and 
+       (= l '(0 1 2 3 4 5 6 7 8 9))
+       (set 'l '(a b (c d () e)))
+       (push 'x l '(2 2 0))
+       (= (ref 'x l) '(2 2 0))
+       (set 'lst '(1 2 3 (4 5)()))
+       (push 'x lst -1 -1)
+       (= lst '(1 2 3 (4 5) (x)))
+       (push 'y lst -1 0)
+       (= lst '(1 2 3 (4 5) (y x)))
+       (push 'z lst -1 1)
+       (= lst '(1 2 3 (4 5) (y z x)))
+       (push 'p lst 4)
+       (= lst '(1 2 3 (4 5) p (y z x)))
+       (push 'q lst -2)
+       (= lst '(1 2 3 (4 5) p q (y z x)))
+       (push 'a lst 3 -3)
+       (= lst '(1 2 3 (a 4 5) p q (y z x)))
+       (= (pop lst 3 -3) 'a)
+       (= (pop lst -2) 'q)
+       (= (pop lst 4) 'p)
+       (= (pop lst -1 1) 'z)
+       (= (pop lst -1 0) 'y)
+       (= (pop lst -1 -1) 'x)
+       (= lst '(1 2 3 (4 5)()))
+       (set 'lst '((1)))
+       (push 2 lst -1 -1)
+       (= lst '((1 2)))
+       (test-push-pop)
+       (test-push-optimization-bug)
+       ; test string push
+       (set 's "newLISP")
+       (= (push "#" s) "#newLISP")
+       (= (push "#" s 1) "##newLISP")
+       (= (push "#" s 3) "##n#ewLISP")
+       (= (push "#" s -1) "##n#ewLISP#")
+       (= (push "#" s -3) "##n#ewLIS#P#")
+       (= (push "xy" s) "xy##n#ewLIS#P#")
+       (= (push "xy" s -1) "xy##n#ewLIS#P#xy")
+       (= s "xy##n#ewLIS#P#xy")
+       (set 's "")
+       (= (push "" s) "")
+       (set 's "newLISP")
+       (= (push "" s -1) "newLISP")
+       (= (push "" s) "newLISP")
+       (= s "newLISP")
+       (push "-" s 7)
+	   (= s "newLISP-")
+	   (push "-" s -9)
+	   (= s "-newLISP-")
+       (set 's "newLISP")
+       (= (push "-" s 8) "newLISP-")
+	   (= (push "-" s -10) "-newLISP-")
+
+		; default functor
+		(set 'D:D '(a b (c d () e)))
+		(push 'x D '(2 2 0))
+		(= (ref 'x D) '(2 2 0))
+		(set 'D:D "newLISP")
+		(= (push "#" D:D) "#newLISP")
+		(= D:D "#newLISP")
+		
+))
+
+(define (test-push-pop)
+	; string
+	(set 's "abcdefg")
+	(= (pop (push "h" s -1)) "a")
+	(= s "bcdefgh")
+)
+
+(define (test-push-optimization-bug) ; fixed in 8.7.1
+    (set 'l nil)
+    (and (push 'x l -1)
+         (set 'lst l)
+         (push 'y lst -1)
+         (= lst '(x y))))
+
+(define (test-put-url ) 
+  (= "ERR: HTTP bad formed URL" (put-url "" "abc")))
+
+(define (test-pv )
+  (< (sub (pv 0.1 10 1000 100000 0 0) -44696.89605) 1e-05))
+
+(define (test-quote )
+  (= (quote x) 'x))
+
+(define (test-quote? )
+  (quote? ''quote?))
+
+(define (test-rand , sum)
+  (set 'sum 0)
+  (dotimes (x 1000) 
+   (inc sum (rand 2)))
+  (and (< sum 600) (> sum 400) (list? (rand 10 100))))
+
+(define (test-random )
+  (and (float? (random)) (= (length (random 0 1 10)) 10)))
+
+(define (test-randomize)
+  (and
+    (!= '(a b c d e f g) (randomize '(a b c d e f g)))
+    (= (difference '(a b c d e f g) (randomize '(a b c d e f g))) '())
+  )
+)
+
+(define (test-read-expr , code)
+    (and
+        (set 'code "; a statement\n(define (double x) (+ x x))\n")
+        (= (read-expr code (context)) '(define (double x) (+ x x)))
+        (= $count 41))
+)
+
+(define (test-read-buffer )
+  (and
+    (set 'file (open "qa-dot" "read"))
+    (read-buffer file buff (nth 0 (file-info "qa-dot")))
+    (close file)
+    (set 'file (open "junk" "write"))
+    (write-buffer file buff (nth 0 (file-info "qa-dot")))
+    (close file)))
+
+(define test-read test-read-buffer)
+
+(define (test-read-char )
+  (and 
+    (file-copy "qa-dot" "junk")
+    (delete-file "junk")))
+
+(define (test-read-file )
+  (read-file "qa-dot")
+  (starts-with (read-file "file://qa-dot") "#!/usr/bin/env newlisp")
+)
+
+(define (test-read-key) true)
+
+(define (test-read-line )
+  (line-count "qa-dot"))
+
+
+(define (test-read-utf8)
+  (and
+	(write-file "utf8text.txt" MAIN:utf8str)
+	(setq fle (open "utf8text.txt" "read"))
+	(= (read-utf8 fle) (char (MAIN:utf8str 0)))
+	(close fle)
+	(delete-file "utf8text.txt")
+))	
+
+
+(define (test-reader-event) true)
+
+(define (test-real-path) 
+  (and
+	(string? (real-path))
+    (string? (real-path "."))
+    (not (real-path "foofoo"))
+    (not (real-path "foofoo" true))
+    (if (!= ostype "Windows") 
+        (let ( old-path (env "PATH"))
+            (and
+                (env "PATH" (append (real-path) ":" (env "PATH")))
+                ; on Unix newLISP's which() is used to find executable path
+                (= (real-path "newlisp" true) (append (real-path) "/newlisp"))
+                (env "PATH" old-path))
+        )
+        true
+    )
+ ))
+
+; tested with qa-specific-tests/qa-message
+(define (test-receive) true) 
+
+(define (test-ref)
+  (and 
+    (set 'pList '(a b (c d () e)))
+    (push 'x pList 2 2 0)
+    (= (ref 'x pList) '(2 2 0))
+    (= (ref '(x) pList) '(2 2))
+    (set 'v (ref '(x) pList))
+    (= (pList v) '(x))
+    ;(= (ref 'foo pList) '()) changed in 10.2.18
+    (= (ref 'foo pList) nil)
+    ; comparison functor
+    (= (ref 'e '(a b (c d (e) f)) =) '(2 2 0))
+    (= (ref 'e '(a b (c d (e) f)) >) '(0))
+    (= (ref 'e '(a b (c d (e) f)) <) '(2))
+    (= (ref 'e '(a b (c d (e) f)) (fn (x y) (or (= x y) (= y 'd)))) '(2 1))
+    (define (is-it-or-d x y) (or (= x y) (= y 'd)))
+    (= (ref 'e '(a b (c d (e) f)) is-it-or-d) '(2 1))
+    ; comparison with match and unify
+    (= (ref '(a ?) '((l 3) (a 12) (k 5) (a 10) (z 22)) match) '(1))
+    (= (ref '(X X) '( ((a b) (c d)) ((e e) (f g)) ) unify) '(1 0))
+    (= (ref '(X g) '( ((a b) (c d)) ((e e) (f g)) ) unify) '(1 1))
+	; default functor
+	(set 'D:D '((l 3) (a 12) (k 5) (a 10) (z 22)) )
+	(= (ref '(a ?) D match) '(1))
+))
+
+(define (test-ref-all) 
+  (and
+    (set 'L '(a b c (d a f (a h a)) (k a (m n a) (x))))
+    (= (ref-all 'a L) '((0) (3 1) (3 3 0) (3 3 2) (4 1) (4 2 2)))
+    (= (L '(3 1)) 'a)
+    (= (map 'L (ref-all 'a L)) '(a a a a a a))
+    ; with comparison functor
+    (= (ref-all 'a '(1 2 3 4 5 6)) '())
+    (set 'L '(a b c (d f (h l a)) (k a (m n) (x))))
+    (= (ref-all 'c L =) '((2)))
+    (= (ref-all 'c L >) '((0) (1) (3 2 2) (4 1)))
+    (= (ref-all 'a L (fn (x y) (or (= x y) (= y 'k)))) ' ((0) (3 2 2) (4 0) (4 1)))
+    (define (is-long? x y) (> (length y) 2))
+    (= (ref-all nil L is-long?) '((3) (3 2) (4)))
+    (define (is-it-or-d x y) (or (= x y) (= y 'd)))
+    (= (ref-all 'e '(a b (c d (e) f)) is-it-or-d) '((2 1) (2 2 0)))
+    (= (ref-all 'b '(a b (c d (e) f)) is-it-or-d) '((1) (2 1)))
+    (= (ref-all nil '(((()))) (fn (x y) (> (length y) 0))) '((0) (0 0)))
+    ; test comparison with match and unify
+    (= (ref-all '(a ?) '((l 3) (a 12) (k 5) (a 10) (z 22)) match) '((1) (3)))
+    (= (ref-all '(X X) '( ((a b) (c d)) ((e e) (f g)) ((z) (z))) unify) '((1 0) (2)))
+    (= (ref-all '(X g) '( ((x y z) g) ((a b) (c d)) ((e e) (f g))) unify) '((0) (2 1)))
+))
+
+
+(define (test-regex )
+  (and
+   (= (regex "http://(.*):(.*)" "http://nuevatec.com:80")
+      '("http://nuevatec.com:80" 0 22 "nuevatec.com" 7 12 "80" 20 2))
+   (= $0 "http://nuevatec.com:80")
+   (= $1 "nuevatec.com")
+   (= $2 "80")
+   (= (regex "b+" "AAAABBBAAAA" 1) '("BBB" 4 3))
+   (= (regex "b+" "AABBBAAABBA" 1 4) '("B" 4 1))
+   (= (regex "b+" "AABBBAAABBA" 1 5) '("BB" 8 2))
+))
+
+(define (test-regex-comp)
+	(and
+		(set 'pattern (regex-comp "http://(.*):(.*)"))
+		(find pattern "http://nuevatec.com:80" 0x10000)
+		(= $0 "http://nuevatec.com:80")
+		(= $1 "nuevatec.com")
+		(= $2 "80")
+	))
+ 
+(define (test-remove-dir )
+  (and (make-dir "junk") (remove-dir "junk")))
+
+(define (test-rename-file )
+  (copy-file "qa-dot" "junk")
+  (rename-file "junk" "junk2"))
+
+;; this can run only once than must be reloaded
+;; because some replace's are in place with a constant
+(define (test-replace ) 
+ (and
+  (not (catch (replace "a" "akakak") 'result))
+  (not (catch (replace "a") 'result))
+  (not (catch (replace) 'result))
+  (catch (replace "a" '("x" "a" "y")) 'result)
+  (= (replace "a" "ababab" "b") "bbbbbb")
+  (= $count 3) 
+  (= (replace 'a '(a a b a b a a a b a) 'b) '(b b b b b b b b b b))
+  (= (replace 'a '(a a b a b a a a b a)) '(b b b))
+  (= (replace 'a '(a)) '())
+;; with regular expressions option
+  (= (replace "" "abc" "x" 0) "xaxbxcx")
+  (= (replace "$" "abc" "x" 0) "abcx")
+  (= (replace "^" "abc" "x" 0) "xabc")
+  (= (replace "\\b" "abc" "x" 0) "xabcx")
+  (= (replace "(?<=[0-9])(?=(?:[0-9]{3})+(?![0-9]))" "1234567" "," 0) "1,234,567")
+  (= (replace "a" "ababab" (upper-case $it) 0) "AbAbAb")
+  (= $count 3) 
+  (set 'str2 "abaBab")
+  (= (replace "b|B" str2 "z" 0) "azazaz")
+  (= $count 3)
+  (replace-once "aaa")
+  (= (replace "%([0-9A-F][0-9A-F])" "%41123%42456%43" (char (int (append "0x" $1))) 1) "A123B456C")
+  ; replace with comparison functor
+  (set 'L '(1 4 22 5 6 89 2 3 24))
+  (= (replace 10 L 10 <) '(1 4 10 5 6 10 2 3 10)) 
+  (set 'L '(1 4 22 5 6 89 2 3 24))
+  (= (replace 10 L 10 (fn (x y) (< x y))) '(1 4 10 5 6 10 2 3 10))
+  ;
+  (set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+  (= (replace '(mary *)  AL (list 'mary (apply + (rest $it))) match)
+    '((john 5 6 4) (mary 14) (bob 4 2 7 9) (jane 3)))
+  (set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+  (= (replace '(*) AL (list ($it 0) (apply + (rest $it))) match)
+    '((john 15) (mary 14) (bob 22) (jane 3)))
+  (set 'AL '((john 5 6 4) ("mary" 3 4 7) (bob 4 2 7 9) ("jane" 3)))
+  (= (replace nil AL (cons (sym ($it 0)) (rest $it)) (fn (x y) (string? (y 0))))
+    '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+
+  ; default functor
+  (set 'D:D '(a a b a b a a a b a) )
+  (= (replace 'a D 'b) '(b b b b b b b b b b))
+  (set 'D:D "abc")
+  (= (replace "" D "x" 0) "xaxbxcx")
+
+  ; regression for key cell part of list
+  (setq a '(b c d))
+  (= (replace (a 0) a (term (a 0))) '("b" c d))
+
+))
+ 
+(define (replace-once str)
+  (= (replace "a" str (upper-case $it) 0x8000) "Aaa") ;; custom option replace once
+)
+
+(define (test-reset )
+  true)
+
+(define (test-rest , l)
+  (set 'l '(a b c d e f g))
+  (and  (= (cons (first l) (rest l)) l)
+    (= (rest "newlisp") "ewlisp")
+    ;; implicit nrest
+    (= (1 l) '(b c d e f g))
+    (= (10 l) '())
+    (= (0 l) l)
+    (= (-3 '(a b c d e f g)) '(e f g))
+        (= (-3 "abcdefg") "efg")
+    (= (1 '(A)) '())
+    (= (1 "A") "")
+    (= (array 2 2 (sequence 3 6)) (rest (array 3 2 (sequence 1 6))))
+    ;; default functor
+    (set 'D:D '(a b c d e f g))
+	(= (rest D) '(b c d e f g))
+	(set 'D:D (array 7 '(a b c d e f g)))
+    (= (rest D) (array 6 '(b c d e f g)))	
+))
+
+(define (test-reverse )
+  (and
+    (= (reverse '(1 2 3)) '(3 2 1))
+    (= (reverse "newLISP") "PSILwen")
+	(set 'D:D '(1 2 3))
+	(= (reverse D) '(3 2 1))
+	(set 'D:D "newLISP")
+	(= (reverse D) "PSILwen")
+    (set 'a (array 2 3 '(1 2 3 4 5 6)))
+    (reverse a)
+    (= a (array 2 3 '(4 5 6 1 2 3)))
+))
+
+(define (test-rotate )
+  (and
+    (= '(8 9 0 1 2 3 4 5 6 7) (rotate '(0 1 2 3 4 5 6 7 8 9) 2))
+    (= '() (rotate '()))
+	(= (rotate '(1) -1) '(1))
+	(= (rotate "") "")
+	(= (rotate "x" -1) "x")
+	(set 'str "abcdefg")
+	(= (rotate str) "gabcdef")
+	(= (rotate str 3) "defgabc")
+	(= (rotate str -4) "abcdefg")
+    (set 'D:D '(0 1 2 3 4 5 6 7 8 9))
+    (= '(8 9 0 1 2 3 4 5 6 7) (rotate D 2))
+))
+
+(define (test-round)
+	(and
+		(= (round 1.25)  (round 1.25 0) 1)
+		(= (round 3.89) (round 3.89 0) 4)
+		(= (round 123.49 2) 100)
+		(= (round 123.49 1) 120)
+		(= (round 123.49 0) 123)
+		(= (round 123.49 -1) 123.5)
+		(= (round 123.49 -2) 123.49)
+		(= (round 123.49 -3) 123.49)
+		(!= (round 123.49 -2) 123.49000000000001)
+		(= (round 123.49 3)  0)
+        (= (round 0.05 -1) 0.1)
+		(= (round 0.5) 1)
+        (= (round 5 1) 10)    
+))
+
+(define (test-save )
+  (and (save "all") (save "save.lsp" 'test-save) (delete-file "all") 
+   (delete-file "save.lsp")))
+
+(define (test-search , file)
+  (and
+    (set 'file (open "qa-dot" "read"))
+    (search file "define")
+    (close file)))
+
+(define (test-seed )
+  (seed 123)
+  (set 'a (rand 10))
+  (seed 123)
+  (set 'b (rand 10))
+  (= a b)
+  ; built-in PRNG with state recall
+  (seed 123 true)
+  (rand 100 100)
+  (set 'state (seed)) ; save state
+  (set 'r1 (rand 100 100))
+  (rand 100 100) 
+  (normal 10 3 100)
+  (seed state true 0) ; recall state
+  (= r1 (rand 100 100))
+)
+
+(define (test-seek , file chr)
+  (set 'file (open "junk" "write"))
+  (dotimes (x 100) 
+   (write-char file x))
+  (close file)
+  (set 'file (open "junk" "read"))
+  (seek file 65)
+  (set 'chr (read-char file))
+  (close file)
+  (delete-file "junk")
+  (= chr 65))
+
+(define (test-select )
+  (set 'l '(0 1 2 3 4 5 6 7 8 9))
+  (and
+    (test-select-collect)
+    (= (select l '(0 9 9 0 1 8 8 1)) '(0 9 9 0 1 8 8 1))
+    (= (select "2001-09-20" '(5 6 8 9 0 1 2 3)) "09202001")
+	; default functor
+	(set 'D:D '(0 1 2 3 4 5 6 7 8 9))
+    (= (select D '(0 9 9 0 1 8 8 1)) '(0 9 9 0 1 8 8 1))
+))
+
+
+(new Class 'MAIN:Circle)
+(define (test-self)
+	(define (Circle:move dx dy) (inc (self 1) dx) (inc (self 2) dy))
+	(set 'myc (list (Circle 1 2 3) (Circle 4 5 6)))
+	(:move (myc 0) 10 20)
+	(:move (myc 1) 10 20)
+	(= myc '((Circle 11 22 3) (Circle 14 25 6)))
+)
+
+;; for testing semaphores accross processes/threads see test-share
+(define (test-semaphore)
+  (and
+    (set 'sid (semaphore))
+ 	(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+		(= (semaphore sid) 0) true) ;; no semaphore status on Win32
+    (semaphore sid 1)
+ 	(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "AIX" "Tru64Unix" "Cygwin"))  
+		(= (semaphore sid) 1) true) ;; no semaphore status on Win32
+    (semaphore sid 0)))
+
+; tested with qa-specific-tests/qa-message
+(define (test-send) true) 
+
+(define (test-sequence )
+  (= (sequence 1 10 3) '(1 4 7 10)))
+
+(define (test-series )
+  (and
+    (= (series 2 2 5) '(2 4 8 16 32))
+    (= (series 2 2 0) '())
+    (= (series 1 2 -10) '())
+    (= (series 1 1 5) '(1 1 1 1 1))
+	(= (series "a" (fn (c) (char (inc (char c)))) 5) '("a" "b" "c" "d" "e"))
+	(= (series 1 (fn (x) (* 2 x)) 5) '(1 2 4 8 16))
+))
+
+(define (test-set , x y z)
+  (set 'x (set 'y (set 'z 123)))
+  (= x 123))
+
+(define (test-setf)
+ (and
+    (setf l '(a b c d e f g))
+    (setf (nth 3 l) 999)
+    (= l '(a b c 999 e f g))
+    (set 's "abcdefg")
+    (setf (s 3) (upper-case $it))
+    (= s "abcDefg")
+    (set 's "a-b-c-d-e-f-g")
+    (setf (first (replace "-" s "")) (upper-case $it))
+    (= s "Abcdefg")    
+    (setf (s 2) "CCC")
+    (= s "AbCCCdefg")
+    (= (setf ((copy '(a b c)) 1) 'B) 'B)
+))
+
+
+(define (test-setq , x y z)
+  (setq x 1 y 2 z 3)
+  (and (= x 1) (= y 2) (= z 3)))
+
+
+(define (test-set-ref)
+	(and
+		(set 'L '(z a b (z) (d (c c (c)) e f c))) 
+		(= (set-ref 'c L 'z) '(z a b (z) (d (z c (c)) e f c)))
+		(set 'L '((a 1) (b 2) (a 3) (b 4)))	
+		(= (set-ref '(a *) L '(z 99) match) '((z 99) (b 2) (a 3) (b 4)))
+		(= (set-ref '(a *) L '(z 99) match) '((z 99) (b 2) (z 99) (b 4)))
+		(set 'Ct:Ct '(a b c d e f g))
+		(= (set-ref  'c Ct 'z) '(a b z d e f g))
+		; default functor
+		(set 'D:D '(z a b (z) (d (c c (c)) e f c))) 
+		(= (set-ref 'c D 'z) '(z a b (z) (d (z c (c)) e f c)))
+	)
+)
+
+
+(define (test-set-ref-all)
+    (and
+		(set 'L '(z a b (c) (d (c c (c)) e f c))) 
+		(= (set-ref-all 'c L 'z) '(z a b (z) (d (z z (z)) e f z)))
+		(set 'L '((a 1) (b 2) (a 3) (b 4)))
+		(= (set-ref-all '(a *) L '(z 99) match) '((z 99) (b 2) (z 99) (b 4)))
+    )
+)
+
+(define (test-share)
+    (and 
+      (if (find ostype '("Windows" "OS/2"))
+          (windows-test-share)
+          (unix-test-share))
+      (set 'mvar (share))
+      (not (share mvar nil)) 
+      (= (share mvar) nil)   ; nil 
+      (share mvar true)
+      (= (share mvar) true)  ; true
+      (share mvar 123)
+      (= (share mvar) 123)   ; integer
+      (share mvar 123.456)
+      (= (share mvar) 123.456)  ; float
+      (share mvar "hello")
+      (= (share mvar) "hello")  ; string
+      (share mvar '(a b c d e f))
+      (= (share mvar) '(a b c d e f)) ; list
+      ; check sizes > pagesize
+	  (share mvar (dup "X" 10000))
+      (= 10000 (length (share mvar)))
+      ; force deletion of temporary file
+      (not (share mvar nil))
+      (unless (= ostype "Windows") (share nil mvar))
+))
+
+
+(define (windows-test-share)
+    (write-file "sharetest.lsp"
+[text]
+(map set '(sid mm) (map int (slice (main-args) 2)))
+(if (= (share mm) "hello") (share mm "HELLO"))
+(semaphore sid 1) ; signale parent to read
+(exit)
+[/text]
+    )
+  (and
+    (set 'sid (semaphore))
+    (set 'mm (share))
+    (share mm "hello")
+    (if (find ostype '("Windows" "OS/2"))
+      (process (string "newlisp sharetest.lsp " sid " " mm))
+      (process (string "./newlisp sharetest.lsp " sid " " mm)))
+    (semaphore sid -1) ; wait for child process
+    (sleep 1000)
+    (semaphore sid 0) ;; delete semaphore
+    (= (share mm) "HELLO")
+    (or (delete-file "sharetest.lsp") true)))
+
+
+(define (unix-test-share)
+  (and
+    (set 'mm (share))
+    (share mm "hello")
+
+    (wait-pid (fork (begin
+            (if (= (share mm) "hello")
+                (share mm "HELLO"))
+                (exit ))))
+		
+    (= (share mm) "HELLO")
+    (share nil mm) ; unmap share
+))
+
+(define (test-sgn)
+ (and
+   (= 0 (sgn 0))
+   (= 1 (sgn 123))
+   (= -1 (sgn -3.5))))
+
+
+; test manually
+(define (test-signal) true)
+
+(define (test-silent )
+  (primitive? silent))
+
+(define (test-sin )
+  (= 1 (sin (asin (sin (asin 1))))))
+
+(define (test-sinh)
+	(< (abs (sub (tanh 1) (div (sinh 1) (cosh 1))))  0.0000000001)
+)
+
+(define (test-sleep )
+  (set 'start (time-of-day))
+  (sleep 10)
+  (set 'start (time-of-day))
+  (sleep 1000)
+  (set 'duration (- (time-of-day) start))
+  (and (> duration 500) (< duration 1500)))
+
+(define (test-slice )
+(and 
+   (set 'str "0123456789")
+   (= (slice str 0 1) "0") 
+   (= (slice str 0 3) "012") 
+   (= (slice str 8 2) "89") 
+   (= (slice str 8 10) "89") 
+   (= (slice str 20 10) "")
+   (= (slice str 2 -2) "234567")
+   (= (slice str 2 -5) "234")
+   (= (slice str 2 -7) "2")
+   (= (slice str 2 -8) "")
+   (= (slice str 2 -9) "")
+   (= (slice '(a b c d e f g) 3 1) '(d))
+   (= (slice '(a b c d e f g) 3 0) '())
+   (= (slice '(a b c d e f g) 0 0) '())
+   (= (slice '(a b c d e f g) 10 10) '())
+   (= (slice '(a b c d e f g) 3 2) '(d e))
+   (= (slice '(a b c d e f g) 5) '(f g))
+   (= (slice '(a b c d e f g) -5 2) '(c d))
+   (= (slice '(a b c d e f g) -1 -2) '())
+   (= (slice '(a b c d e f g) 1 -2) '(b c d e))
+   (= (slice '(a b c d e f g) 4 -2) '(e))
+   (= (slice '(a b c d e f g) 4 -3) '())
+   (= (slice '(a b c d e f g) 4 -4) '())
+   (= (slice '(a b c d e f g) -6 -3) '(b c d))
+;; implicit slice
+   (= (1 3 '(a b c d e f g)) '(b c d))
+   (= (-4 2 '(a b c d e f g)) '(d e))
+   (= (1 3 "abcdefg") "bcd")
+   (= (-4 2 "abcdefg") "de")
+   (= (1 -3 "abcdefg") "bcd")
+   (= (1 -5 "abcdefg") "b")
+   (=  (1 -7 "abcdefg") "")
+   (setq x 1 y 2)
+   (= (x y '(a b c d e f g)) '(b c))
+   (= (x y "abcdefg") "bc")
+   (= (1 -2 '(a b c d e f g)) '(b c d e))
+   (= (4 -2 '(a b c d e f g)) '(e))
+   (= (4 -3 '(a b c d e f g)) '())
+   (= (4 -4 '(a b c d e f g)) '())
+   (= (-6 -3 '(a b c d e f g)) '(b c d))
+
+   ; default functor
+   (set 'D:D "0123456789")
+   (= (slice D 0 1) "0") 
+   (= (slice D 0 3) "012") 
+   (set 'D:D '(a b c d e f g))
+   (= (slice D 3 1) '(d))
+   (= (1 3 D) '(b c d))
+))
+
+(define (test-sort )
+  (and
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5)))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5)))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5) <))
+    (= '(9 8 7 6 5 4 3 2 1) (sort '(9 1 8 2 7 3 6 4 5) >))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5) (fn (x y) (< x y))))
+    (= '(9 8 7 6 5 4 3 2 1) (sort '(9 1 8 2 7 3 6 4 5) (fn (x y) (> x y))))
+    (= '() (sort '()))
+	(= (sort '(1 nil)) '(nil 1))
+	(= (sort '(a nil true 1 1.2)) (sort (list 'a nil true 1 1.2)) '(nil true 1 1.2 a))
+    ;; at runtime generated sort function v10.4.6
+    (define (f<g= f g)
+        (expand (fn (a b) (f (g a) (g b))) 'f 'g))
+    (set 'lst '((c 4) (b 5) (a 2)))
+    (= (sort lst (f<g= < last)) '((a 2) (c 4) (b 5)))
+  )
+)
+
+(define (test-source) 
+  (= (replace "\r|\n" (source 'test-sin) "" 0) 
+     "(define (test-sin )  (= 1 (sin (asin (sin (asin 1))))))"))
+
+(define (test-sqrt )
+  (and (= 10 (sqrt 100)) (= 1.2 (sqrt 1.44))))
+
+(define (test-ssq)
+	(= 385 (ssq (sequence 1 10)) (ssq (array 10 (sequence 1 10))))
+)
+
+(define (test-starts-with )
+  (and 
+	(starts-with "newlisp" "new") 
+	(starts-with "newlisp" "NEW" 1)
+	(set 'D:D "newlisp")
+	(starts-with D "new") 
+	(starts-with D "NEW" 1)
+))
+
+(define (test-stats)
+    (< (apply add (map sub (stats '(1 2 3 4 5)) '(5 3 1.2 1.58113883 2.5 0 -1.912))) 0.000000001)
+)
+
+(define (test-string )
+  (and (string? (string 12345)) (= (string 12345) "12345") (string? 
+    (string 1.234)) 
+   (= (string 'test-string) "test-string") 
+   (string? (string test-string)) 
+   (= (string "a" "b" "c") (append "a" "b" "c") "abc") 
+   (= (string "a" 123 "b") "a123b")))
+
+(define (test-string? )
+  (and (string? "1234") (not (string? 1234))))
+
+(define (test-struct) ; more tests in qa-libffi
+    (struct 'complex "double" "double")
+    (= (unpack complex (pack complex 1.23 4.56)) '(1.23 4.56)))
+
+(define (test-sub )
+  (= 0 (sub 0.99999999 0.99999999))
+  (= -123 (sub 123)))
+
+(define (test-swap )
+  (and 
+	; new (swap <place1> <place2>) in 10.0.3
+	(set 'lst '(1 2 3 4))
+	(= (swap (first lst) (last lst)) 1)
+	(= lst '(4 2 3 1))
+	(= (swap (lst 0) (lst -1)) 4)
+	(= lst '(1 2 3 4))
+	(set 'A (array 2 3 (sequence 1 6)))
+	(= (swap (A 0 0) (A -1 -1)) 1)
+	(= A (array 2 3 (flat '((6 2 3) (4 5 1)))))
+	(set 'lst '(a b c d))
+	(set 'x 'z)
+	(= (swap (lst 0) x) 'a)
+	(= lst '(z b c d))
+	(= x 'a)
+  )
+)
+
+(define (test-sym)
+  (and (= (sym "test-sym") 'test-sym) 
+       (= (sym "test-sym" 'QA) 'test-sym)))
+
+(define (test-symbol? )
+	(and
+  		(symbol? (sym "test-symbol"))
+		(symbol? (sym "a b"))
+))
+
+(define (test-symbols )
+  (and (list? (symbols)) (> (length (symbols)) 0)))
+
+(define (test-sys-error) true)
+;	(integer? (sys-error 0) ))
+
+(define (test-sys-info )
+   (and (list? (sys-info)) (= (length (sys-info)) 10)))
+
+(define (test-tan )
+  (> 1 (tan (atan (tan (atan 1))))))
+
+(define (test-tanh)
+	(< (abs (sub (sinh 1) (div (sub (exp 1) (exp -1)) 2))) 0.0000000001)
+)
+
+(define (test-term )
+  (= "term" (term 'term)))
+
+(define test-name test-term)
+
+(define (test-throw )
+  (and (catch (throw (+ 3 4)) 'msg) (= msg 7)))
+
+(define (test-time )
+	(float? (time))
+)
+
+(define (test-time-of-day )
+  (float? (time-of-day)))
+
+(define (test-trace )
+  (trace nil)
+  (= nil (trace)))
+
+(define (test-trace-highlight )
+  (trace-highlight "#" "#"))
+
+(define (test-transpose )
+ (and
+  (= '((1) (2) (3)) (transpose '((1 2 3))))
+  (= '((a b) (c d) (e f)) (transpose '((a c e) (b d f))))
+  (= '((a d f) (b e g) (c nil nil)) (transpose '((a b c) (d e) (f g))))
+  (= '((a c f) (b d g)) (transpose '((a b) (c d e) (f g))))
+;; transpose arrays
+  (set 'A (array 2 3 (sequence 1 6)))
+  (= (array-list (transpose A)) '((1 4) (2 5) (3 6))) 
+))
+
+(define (test-trim )
+  (and 
+    (= (trim "  \n \t  h e l l o \r   ") "h e l l o") 
+    (= (trim "----hello----" "-") "hello")
+    (= (trim "----hello====" "-" "=") "hello")
+    (= (trim "000012345" "0" "") "12345")))
+
+(define (test-true?)
+ (= (map true? '(x nil  1 nil "hi" ())) '(true nil true nil true nil)))
+
+(define (test-unicode)
+  (= (utf8 (unicode "newLISP")) "newLISP"))
+
+(define (test-unify) 
+	(and
+		(= (unify 'X 123) '((X 123)))
+        (= (unify '(Int Flt Str Sym Lst) '(123 4.56 "Hello" s '(a b c)))
+                  '((Int 123) (Flt 4.56) (Str "Hello") (Sym s) (Lst '(a b c))))
+		(= (unify 'A 'A) '())
+		(= (unify '(A B "hello") '("hi" A Z)) '((A "hi") (B "hi") (Z "hello")))
+		(= (unify '(A B) '(B abc)) '((A abc) (B abc)))
+		(= (unify '(B A) '(abc B)) '((B abc) (A abc)))
+		(= (unify '(A A C D) '(B C 1 C)) '((B 1) (A 1) (C 1) (D 1)))
+		(= (unify '(D C A A) '(C 1 C B)) '((D 1) (C 1) (B 1) (A 1)))
+		(= (unify '(f A) '(f (a b c))) '((A (a b c))))
+		(= (unify '(A f) '((a b c) f)) '((A (a b c))))
+		(= (unify '(f (g A)) '(f B)) '((B (g A))))
+		(= (unify '(p X Y a) '(p Y X X)) '((Y a) (X a)))
+		(= (unify '(p X Y) '(p Y X)) '((Y X)))
+		(= (unify '(q (p X Y) (p Y X)) '(q Z Z)) '((Y X) (Z (p X X))))
+		(= (unify '(f (g A) A) '(f B xyz)) '((B (g xyz)) (A xyz)))
+		(= (unify '(A (g abc)) '(B A)) '((B (g abc)) (A (g abc))))
+		;; with additional environment list
+		(= (unify '(A (B) X) '(A (A) Z) '((A 1) (Z 4)))
+		   '((A 1) (Z 4) (B 1) (X 4)))
+))
+
+
+(define (test-union)
+    (= (union '(1 3 1 4 4 3) '(2 1 5 6 4)) '(1 3 4 2 5 6)))
+
+(define (test-unique )
+  (= (unique '(2 3 4 4 6 7 8 7)) '(2 3 4 6 7 8)))
+
+
+(define (test-unless )
+	(and 
+		(= (unless nil (set 'x 1) (set 'y 2) (set 'z 3)) 3)
+		(= x 1) (= y 2) (= z 3)
+		(= (unless 123) 123)
+		(= (unless true) true)
+		(= (unless nil) nil)
+))
+
+(define (test-unpack )
+  (= (pack "c c c" 65 66 67) "ABC")
+  (= (unpack "c c c" "ABC") '(65 66 67)))
+
+(define (test-until , x)
+  (set 'x 0)
+  (= 10 (until (= x 10) (inc x)) x))
+
+(define (test-do-until , x)
+  (set 'x 0)
+  (and 
+   (= 10 (do-until (= x 10) (inc x)) x)
+   (= 11 (do-until (> x 0) (inc x)) x)
+))
+
+(define (test-upper-case )
+	(= (upper-case "abcdefghijklmnopqrstuvwxyz") "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+
+(define (test-utf8)
+  (and
+    (= (utf8 (unicode "newLISP")) "newLISP")
+    (MAIN:utf8qa)))
+
+(define (test-utf8len)
+	(= 23 (utf8len MAIN:utf8str)))
+
+(define (test-uuid)
+    (= 36 (length (uuid))))
+
+(define (test-wait-pid)
+  (set 'pid (fork (begin (sleep 200)(exit))))
+  (wait-pid pid))
+
+(define (test-when)
+	(and 
+		(= (when true (set 'x 1) (set 'y 2) (set 'z 3)) 3)
+		(= x 1) (= y 2) (= z 3)
+		(= (when 123) 123)
+		(= (when nil) nil)
+		(= (when true) true)
+))
+
+(define (test-while , x)
+  (and
+    (set 'x 0)
+    (= 1000 (while (< x 1000) (inc x)) x)
+))
+
+(define (test-do-while, x)
+  (and
+    (set 'x 0)
+    (= 100 (do-while (< x 100) (inc x)) x)
+    (= 101 (do-while (< x 100) (inc x)) x)
+))
+
+(define (test-write-buffer )
+  (set 'str "")
+  (dotimes (x 5) (write-buffer str "hello"))
+  (set 'Bf:Bf "")
+  (set 'S:S "hello")
+  (dotimes (x 5) (write-buffer Bf S))
+  (and 
+    (= str "hellohellohellohellohello")
+    (= Bf:Bf str)
+    (test-read-buffer)
+	(set 'str "")
+	(write-buffer str S 3)
+	(= str "hel")
+))
+
+(define test-write test-write-buffer)
+
+(define (test-write-char )
+  (file-copy "qa-dot" "junk")
+  (delete-file "junk"))
+
+(define (test-write-file )
+ (and
+  (write-file "junk" "newlisp")
+  (write-file "file://junk2" "hello")
+  (= (read-file "junk") "newlisp")
+  (= (read-file "file://junk2") "hello")
+  (delete-file "file://junk2")
+))
+
+(define (test-write-line ) 
+  (and
+    (set 'fle (open "testwrite" "w"))
+    (write-line fle "hello")
+    (close fle)
+    (set 'fle (open "testwrite" "r"))
+    (= (read-line fle) "hello")
+    (close fle)
+    (delete-file "testwrite")  
+    (set 'Bf:Bf "")
+	(set 'S:S "hello world")
+	(write-line Bf S)
+	(if (find ostype '("Windows"))
+		(= Bf:Bf "hello world\r\n")
+		(= Bf:Bf "hello world\n"))
+))
+
+
+(define (test-xfer-event)
+  (not (xfer-event)))
+
+(define (test-xml-error )
+  (= (xml-error) nil))
+
+(define (test-xml-parse )
+  (= (xml-parse "<hello att='value'></hello>") '(("ELEMENT" "hello" 
+     (("att" "value")) 
+     ()))))
+
+(define (test-xml-type-tags )
+  (length (xml-type-tags) 4))
+
+(define (test-zero?)
+  (= (map zero? '(1 0 1.2 0.0)) '(nil true nil true)))
+
+(define (test-| )
+  (= (| -1431655766 1431655765) -1))
+
+(define (test-~ )
+  (and
+    (= (~ 0) -1)
+    (if 
+        (find ostype '("Windows" "OS/2"))
+        (= (format "%I64x" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f")
+
+        (= ostype "True64Unix")
+        (= (format "%lx" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f")
+
+        (= (format "%llx" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f"))
+))
+
+
+;;;;;;;;;;;;;;;; test Cilk interface, run qa-cilk for more tests ;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define (test-abort)
+	(and 
+		(spawn 'x (+ 1 2))
+		(abort)
+))
+
+; more testing can be found in qa-specific-test/qa-cilk
+(define (test-spawn)
+	(and 
+        (set 'pw (spawn 'w (list 'a 'b 'c 'd 'e 'f))) ; list
+		(set 'px (spawn 'x (+ 1 2 3 4))) ; integer
+		(set 'py (spawn 'y (add 1.23 4.56))) ; float
+        (set 'pz (spawn 'z (upper-case "hello world"))) ;string
+		(if (!= ostype "Windows")
+			(begin
+				(find pw (sync))
+				(find px (sync))
+        		(find py (sync))
+        		(find pz (sync)))
+			true)
+        (true? (sync 1000))
+		(empty? (sync))
+        (= w '(a b c d e f))
+		(= x 10)
+		(< (abs (sub y 5.79)) 0.0000000001)
+        (= z "HELLO WORLD")
+))
+
+(define (test-sync) true)
+(define (test-schedule) true)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; MAIN ENTRY POINT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(if (or (not (or (file? "newlisp") (file? "newlisp.exe"))) (not (file? "qa-dot")))
+	(begin
+		(println "both newlisp(.exe) and qa-dot should be in the current directory.")
+		(exit)))
+
+(cleanup)
+
+(unless MAIN:testing-cell-leaks
+    (println)
+    (println "Testing built-in functions ..."))
+
+(qa)
+(cleanup)
+
+(context 'MAIN)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(unless MAIN:testing-cell-leaks
+    (println "Testing contexts as objects and scoping rules ...")
+    (println))
+
+;; check creating local symbols
+;; in case they already exist in MAIN
+(set 'var 123)
+(set 'CTX:var 456)
+(if (or (!= CTX:var 456) (!= var 123))
+	(println " >>>> problem creating local symbols"))
+
+(set 'ctx CTX)
+
+(global 'myprint)
+(set 'myprint print)
+
+
+;; following would fail without dynamic symbols for non-existing
+;; contexts because 'accnt' is not a context at this moment
+(define (report accnt)
+    (list accnt:name accnt:balance))
+
+;; late in ACCOUNT the definition of 'deposit' should
+;; should not fail, locals should always be created for
+;; the current context
+(constant 'amount 999)
+(constant 'stat 999)
+
+;; the symbol defined should always be forced into the current
+;; context, even if alread exists in MAIN, if not following
+;; definition of 'deposit' would fail
+(set 'deposit 999) 
+(set 'clear 999)
+(constant 'withdraw 999) 
+
+(define balance 1000.00)
+(constant 'phone "123-456-789")
+
+
+(context 'ACCOUNT)
+    (set 'ACCOUNT:term "")      ; force creation of local symbol 'term with
+    (define balance 0.0)        ; same name as built in primitive
+    (set 'phone "")        
+    (constant 'const "foo")  ; a protected variable
+
+    (define (deposit amount)
+        (inc balance amount))
+
+    (define (withdraw amount)
+        (dec balance amount))
+    
+    ; make sure contexts are inherited
+    ; but not variables containing contexts
+    (if (not (context? CTX)) 
+	(QA:failed " >>>> problem inheriting context symbols"))
+
+    ; make sure context variables get not inherited
+    (if (= ctx CTX) (QA:failed " >>>> should not inherit context var"))
+    
+    (set 'ctx 123)
+
+    ; make sure redefined primitives get inherited
+    (if (not (primitive? myprint)) 
+    	(QA:failed " >>>> problem inheriting redefined primitives"))
+
+(set 'myprint nil)
+   
+(context 'MAIN)
+
+;; make sure again that context defs did not overwrite MAIN symbols
+(if (or (!= deposit 999) (!= clear 999) (!= withdraw 999) (!= stat 999) (!= ctx CTX)
+        (not (primitive? term)) (!= balance 1000.0) (!= phone "123-456-789"))
+	(QA:failed " >>>> context definitions are overwriting MAIN"))
+
+(new ACCOUNT 'John true)     ; this creates a new context copy of 
+                             ; ACCOUNT called 'John' if exists overwrite symbols
+
+(set 'John:name "John Doe")
+(set 'John:phone "555-123-456")
+
+(unless (protected? 'John:const)
+    (QA:failed ">>>> symbol protection has not been copied"))
+
+(John:deposit 100.00)
+(John:withdraw 60)
+
+(new ACCOUNT 'Anne true)
+
+(set 'Anne:name "Anne Somebody")
+(set 'Anne:phone "555-456-123")
+
+(Anne:deposit 120.00)
+(Anne:withdraw 50)
+(if (or (!= John:balance 40) (!= Anne:balance 70))
+	(QA:failed " >>>> problem with methods in contexts"))
+
+(if (or (!= (report John) (list John:name John:balance))
+        (!= (report Anne) (list Anne:name Anne:balance)))
+    (QA:failed " >>>> problem using context variables"))
+
+(if (!= (map report (map eval '(John Anne))) 
+       '(("John Doe" 40) ("Anne Somebody" 70)) )
+    (QA:failed " >>>> problem mapping functions using context vars"))
+
+
+;; dynamic context var as symbol to be defined
+;;
+(define (defit)
+	(define (ctx:foo x) (+ x x)))
+
+(set 'ctx ACCOUNT)
+(defit)
+
+(if (!= (ctx:foo 10) 20) 
+  (QA:failed " >>>> problem with dyna symbols in defined symbol"))
+
+;; check setq, define (as set) and inc, dec on dynamic context vars
+;;
+(define (foo-set ct value) (set 'ct:var value))
+(define (foo-setq ct value) (setq ct:var value))
+(define (foo-define ct value) (define ct:var value))
+(define (foo-inc ct value) (inc ct:var))
+(define (foo-dec ct value) (dec ct:var))
+
+(set 'CTX:var 0) ;; make sure var is existent
+(foo-set CTX 1)
+(if (!= 1 CTX:var) 
+  (QA:failed " >>>> problem with set on context vars"))
+
+(foo-setq CTX 3)
+(if (!= 3 CTX:var) 
+  (QA:failed " >>>> problem with setq on context vars"))
+
+(foo-define CTX 4)
+(if (!= 4 CTX:var) 
+  (QA:failed " >>>> problem with define on context vars"))
+
+(foo-inc CTX)
+(if (!= 5 CTX:var) 
+  (QA:failed " >>>> problem with inc on context vars"))
+
+(foo-dec CTX)
+(if (!= 4 CTX:var) 
+  (QA:failed " >>>> problem with dec on context vars"))
+
+;; dynamic context vars inside a context (since version 7.5.1)
+
+(context 'TST)
+
+(define (init ctx value)
+	(set 'ctx:foo value))
+
+;; since version 8.7.8 when calling a function in a context the current runtime
+;; context changes
+(define (test-context-change)
+	(= (context) TST))
+
+(context MAIN)
+
+;; foo does not exist in CTX
+
+(TST:init CTX 999)
+
+(if (!= 999 CTX:foo) 
+  (QA:failed " >>>> problem with dyna vars in contexts"))
+
+;; now foo does exist
+(TST:init CTX 222)
+
+(if (!= 222 CTX:foo)
+  (QA:failed " >>>> problem with dyna vars in contexts"))
+
+
+(define (cdf:cdf a b) (+ a b))
+
+(if (!= (cdf 3 4) 7) 
+  (QA:failed " >>>> problem with context default vars"))
+
+;; check for existence of dynamic context symbol
+
+(define (check-sym-existence ctx)
+  (if (symbol? 'ctx:foovar) ;; check only, will not create 
+    (QA:failed " >>>> problem with symbol? for dyna vars")))
+
+(check-sym-existence CTX)
+
+;; do not overwrite existing symbols
+
+(set 'Actx:x 123)
+(set 'Actx:y 456)
+(set 'Bctx:x 999)
+
+(new Actx Bctx)
+
+(if (not (= Bctx:x 999))
+  (QA:failed " >>>> problem with new in overwriting symbols"))
+
+
+;; delete contexts
+ (if (not (and
+        (delete 'ACCOUNT)
+        (delete 'Anne)
+        (delete 'John)
+      ) )
+    (QA:failed " >>>> problem deleting contexts"))
+
+
+;; define static default functions
+
+(define foobar:foobar)
+
+(define (def-static s contents)
+   (def-new 'contents (sym (term s) s)))
+
+(if (not 
+  (and
+    (def-static 'foobar (fn (x) (+ x x)))
+    (= foobar:foobar (lambda (foobar:x) (+ foobar:x foobar:x)))
+    (= (foobar 10) 20)))
+  (QA:failed " >>>> problem with static default function definition"))
+
+;; calling into context changes context
+(if (not TST:test-context-change)
+  (QA:failed " >>>> problem changing runtime context with symbol"))
+
+;; but calling with raw lambda doesn't
+(if ((eval TST:test-context-change))
+  (QA:failed " >>>> problem maintaining runtime context with lambda"))
+
+;; apply evaluates functor
+(if (not (apply 'TST:test-context-change))
+  (QA:failed " >>>> problem changing runtime context with apply symbol"))
+
+;; apply evaluates functor
+(if (apply TST:test-context-change)
+  (QA:failed " >>>> problem maintaining runtime context with apply lambda"))
+
+;; map evaluates functor
+(if (!= (map 'TST:test-context-change '(a b c)) '(true true true))
+  (QA:failed " >>>> problem changing runtime context with map symbol"))
+
+;; map evaluates functor
+(if (!= (map TST:test-context-change '(a b c)) '(nil nil nil))
+  (QA:failed " >>>> problem maintaining runtime context with map lambda"))
+
+;; hash-like access functions for namespaces
+(if (not (and
+	(nil? (define Foo:Foo)) ; create namespace and default functor
+	(= (Foo "bar" 123) 123)
+	(= (Foo "bar") 123)
+	(= (Foo "bar" (+ 100 23)) 123)
+	(= (Foo (append "b" "ar")) 123)
+	(= (Foo '(("var" 123) ("bar" 456) ("baz" 789))) 'Foo)
+	(= (Foo) '(("bar" 456) ("baz" 789) ("var" 123)))
+	(= (Foo "var" (* 2 (Foo "var"))) 246)
+    ; accept integers as keys since 10.5.6 (get converted to strings)
+    (= (Foo 123 "hello") "hello" (Foo 123))
+    (nil? (Foo 123 nil))
+	)) (QA:failed " >>>> problem with hash functions for namespaces") true)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(unless testing-cell-leaks (println "total time: " (- (time-of-day) start-of-qa) "\n"))
+(if QA:failed-messages
+  (begin
+    (println ">>>>> TESTING: " (main-args 0) " FINISHED WITH ERRORS:")
+    (println)
+    (dolist (func (reverse QA:failed-messages))
+        (println func)))
+  (unless testing-cell-leaks
+    (println ">>>>> ALL FUNCTIONS FINISHED SUCCESSFUL: " (main-args 0))
+    (println))
+)
+
+(delete-file "sharetest.lsp")
+(delete-file "udptest.lsp")
+(sys-info)
+(unless do-not-exit (exit))
+
+;; eof
+
+
diff --git a/qa-specific-tests/HOWTOTEST.txt b/qa-specific-tests/HOWTOTEST.txt
new file mode 100644
index 0000000..c44b250
--- /dev/null
+++ b/qa-specific-tests/HOWTOTEST.txt
@@ -0,0 +1,40 @@
+There is a shorter and a longer test suite. And both can run with more or less reporting. After making the newlisp executable do from the main distribution directory:
+
+For a short suite and less reporting:
+make test
+
+For a short suite with full reporting:
+make check
+
+For a long suite with less reporting:
+make testall
+
+For a long suite with full reporting:
+make checkall
+
+On a modern machine just do a 'make testall'. I normally do:
+
+make clean; make; make testall
+
+all in a row separated by semicolons. On Windows, I work in a MSYS Bash shell.
+
+When you write a qa-xxx, write your diagnostics, whatever else, to the console. At the end do a: 
+
+(println ">>>>> <your description here> SUCCESSFUL")
+
+or a:
+
+(println ">>>>> PROBLEM <your description here>")
+
+'make test' and 'make testall' basically run check and checkall but only report lines with at least 3 angle brackets ">>>".
+
+You can run a single qa- file, as an example:
+
+./newlisp qa-specific-tests/qa-net6
+
+Most qa-xxx files are in the qa-specific-tests/ directory, but there are two 'qa-xxxx' files in the main directory: 'qa-dot' and 'qa-comma'. Both do a quick test of all functions in the system. qa-dot does for locales with a decimal "." dot and qa-comma does for locales with a decimal "," comma.
+
+I also use qa-dot and qa-comma to check for cell or memory leakage. Comment out the last 'exit' statement in the script and report (sys-info). From the newlisp command line do several (load "qa-dot") to check for cell leakage. After no more than two invocations the cell count should remain constant. Once in a while I use 'valgrind' to check for general memory leaks.
+
+For main releases, I also check some files from the example/ directory and run the old modified Debian benchmark suite and applications offered at newlisp.org (the wiki and the ide).
+
diff --git a/qa-specific-tests/README.txt b/qa-specific-tests/README.txt
new file mode 100644
index 0000000..cc4a92a
--- /dev/null
+++ b/qa-specific-tests/README.txt
@@ -0,0 +1,4 @@
+For some of these tests newlisp must already be installed (be in the executable path).
+
+Run tests manually one by one.
+
diff --git a/qa-specific-tests/ffitest.dylib b/qa-specific-tests/ffitest.dylib
new file mode 100755
index 0000000..3017a91
Binary files /dev/null and b/qa-specific-tests/ffitest.dylib differ
diff --git a/qa-specific-tests/index.cgi b/qa-specific-tests/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/qa-specific-tests/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/qa-specific-tests/pipe-child.lsp b/qa-specific-tests/pipe-child.lsp
new file mode 100644
index 0000000..9339580
--- /dev/null
+++ b/qa-specific-tests/pipe-child.lsp
@@ -0,0 +1,4 @@
+
+(set 'msg (read-line (int (nth 2 (main-args)))))
+(write-line (int (nth 3 (main-args))) (upper-case msg))
+(exit)
diff --git a/qa-specific-tests/qa-bayes b/qa-specific-tests/qa-bayes
new file mode 100755
index 0000000..87e6fe8
--- /dev/null
+++ b/qa-specific-tests/qa-bayes
@@ -0,0 +1,69 @@
+#!/usr/bin/newlisp
+
+(println)
+(println "R.A. Fisher's Chi2:")
+
+;; from Project Gutenberg: http://www.gutenberg.org/catalog/
+;; The Adventures of Sherlock Holmes - Sir Arthur Conan Doyle
+;; A Comedy of Masks - Ernest Dowson and Arthur Moore
+
+(set 'docs '(
+        ; A Comedy of Masks - Ernest Dowson and Arthur Moore, 547KB
+        "http://www.gutenberg.org/files/16703/16703.txt"
+        ; The Adventures of Sherlock Holmes - Conan Doyle, 576KB
+        "http://www.gutenberg.org/cache/epub/1661/pg1661.txt"
+        ; The tale of Beowulf - anonymous, 219KB
+        "http://www.gutenberg.org/files/20431/20431-8.txt"
+        ))
+
+;if files are available locally
+;(bayes-train '() (parse (lower-case (read-file "Comedy.txt")) "[^a-z]+" 0) 'DoyleDowson)
+;(bayes-train (parse (lower-case (read-file "Sherlock.txt")) "[^a-z]+" 0) '() 'DoyleDowson)
+
+; training with the Doyle novel
+(println "Loading from Gutenberg project ...")
+(set 'AdventuresOfSherlockHolmes (read-file (docs 1)))
+(println "training: The Adventures of Sherlock Holmes (Doyle)")
+(bayes-train (parse (lower-case AdventuresOfSherlockHolmes) "[^a-z]+" 0) '() 'DoyleDowson)
+
+; training with the Dowson novel
+(println "... Loading from Gutenberg project ...")
+(set 'ComedyOfMasks (read-file (docs 0)))
+(println "training: Comedy of Masks (Dowson)")
+(bayes-train '() (parse (lower-case ComedyOfMasks) "[^a-z]+" 0) 'DoyleDowson)
+
+(setf result (bayes-query (parse "he was putting the last touches to a picture") 'DoyleDowson))
+(println "result: " result " " '(0.0359554723158327 0.964044527684167))
+(set 'diff (apply add (map abs (map sub result '(0.0359554723158327 0.964044527684167)))))
+(println (format "diff: %10.5f " diff) 
+    (if (< diff 0.001) ">>>>> bayes SUCCESSFUL" ">>>>> ERROR in bayes"))
+
+(setf result (bayes-query (parse "immense faculties and extraordinary powers of observation") 'DoyleDowson))
+(println "result: " result " " ' (0.983569359827141 0.0164306401728594) )
+(set 'diff (apply add (map abs (map sub result ' (0.983569359827141 0.0164306401728594) ))))
+(println (format "diff: %10.5f " diff) 
+    (if (< diff 0.001) ">>>>> bayes SUCCESSFUL" ">>>>> ERROR in bayes"))
+
+(println)
+
+(println "Chain Bayes:")
+
+(set 'Data:test-positive '(8 18))
+(set 'Data:test-negative '(2 72))
+(set 'Data:total '(10 90))
+
+(pretty-print 80 " " "%1.15f")
+(setf result (bayes-query '(test-positive) Data true) )
+(println "result: " result "  difference: " (map sub result '(0.3076923077 0.6923076923)))
+
+(setf result (bayes-query '(test-positive test-positive) Data true) )
+(println "result: " result " difference: " (map sub result '(0.64 0.36)))
+
+(setf result (bayes-query '(test-positive test-positive test-positive) Data true) )
+(println "result: " result " difference: " (map sub result '(0.8767123288 0.1232876712)))
+
+(pretty-print 80 " " "%1.15g")
+(exit)
+
+; eof
+
diff --git a/qa-specific-tests/qa-bench b/qa-specific-tests/qa-bench
new file mode 100755
index 0000000..20c4cf8
--- /dev/null
+++ b/qa-specific-tests/qa-bench
@@ -0,0 +1,2763 @@
+#!/usr/bin/newlisp
+
+;
+; qa-bench - benchmarks most non-I/O functions
+;
+
+; USAGE
+; =====
+; from the newlisp-x.x.x/ directory:
+;
+; Run all benchmakrs and output one number comparing to the
+; calibaration platform:
+;       ./newlisp /qa-specific-tests/qa-bench
+;
+; Calibrate for a specific platform:
+;       ./newlisp /qa-specific-tests/qa-bench calibrate
+; ... this generates a file primes.lsp in the current directory
+; the contents replaces the (set 'QA:primes ...) statement in qa-bench
+;
+; Report inividual results for each primitive tested:
+;       ./newlisp /qa-specific-tests/qa-bench report
+; ... on the calibration platform is will output apprxomately 10 ms
+; for each function.
+
+(unless xml-parse
+    (println ">>>>> qa-bench needs needs XML support compiled")
+    (exit)
+)
+
+(set-locale "C")
+
+
+(context 'Lex)  ; predeclare/create context for bayes-train
+(context MAIN)
+
+; setup some stuff used later
+(global 'global-myvar)
+(set 'global-myvar 123)
+(set '$0 "abcdefg")
+       
+(delete (sym "double")) ;; avoid error when running Emscripten intro before
+
+(define (double:double x) (+ x x))
+
+(define (test-default-functor)
+    (and
+        (= (map double '(1 2 3 4 5)) '(2 4 6 8 10))
+        (= (map 'double '(1 2 3 4 5)) '(2 4 6 8 10))
+        (set 'dflt:dflt '(a b c d e f g))
+        (= (map dflt '(1 2 6)) '(b c g))
+        (set 'i 0 'j -1 'k 6)
+        (= (dflt i) 'a)
+        (= (dflt k) 'g)
+        (= (dflt j) 'g)
+        (set 'ctx dflt)
+        (= (default ctx) dflt:dflt)
+        (= (default dflt) dflt:dflt)
+        (sort (default ctx) >)
+        (= (default dflt) '(g f e d c b a))
+))
+        
+(context 'QA)
+
+(set 'failed-messages '())
+
+(define (failed msg)
+  (push msg failed-messages))
+
+(define (myappend x y)
+  (cond 
+   ((= '() x) y) 
+   (true (cons (first x) (myappend (rest x) y)))))
+
+
+(set 'primitives '(
+ != $ % & * + - / < << <= = > >= >> NaN? ^ abs acos acosh 
+ add address amb and append apply args array array-list array? asin asinh 
+ assoc atan atan2 atanh atom? base64-dec base64-enc bayes-query bayes-train begin 
+ beta betai bind binomial bits case catch ceil char chop clean collect
+ cond cons constant context context? copy cos cosh 
+ count cpymem crc32 crit-chi2 crit-z curry date date-value dec 
+ def-new default define define-macro delete det 
+ difference div do-until do-while doargs dolist dostring dotimes 
+ dotree dump dup empty? encrypt ends-with env erf error-event eval eval-string 
+ exists exp expand explode factor fft filter find find-all 
+ first flat float float? floor flt for for-all format fv gammai gammaln gcd 
+ get-char get-float get-int get-long get-string global global? if if-not 
+ ifft inc index int integer? intersect invert irr join lambda? last 
+ last-error legal? length let letex letn list list? local log lookup lower-case 
+ macro? main-args map mat match max member min mod mul multiply 
+ new nil? normal not now nper npv nth null? number? or pack parse 
+ pmt pop pop-assoc pow pretty-print primitive? prob-chi2 
+ prob-z protected? push pv quote quote? rand random 
+ randomize read-expr ref ref-all regex regex-comp replace rest 
+ reverse rotate round seed select sequence series set 
+ set-locale set-ref set-ref-all setf setq sgn sin sinh 
+ slice sort source sqrt starts-with string string? sub swap sym symbol? symbols 
+ sys-error sys-info tan tanh term throw throw-error time time-of-day title-case 
+ transpose trim true? unify unique unless unpack 
+ until upper-case uuid when while write-buffer 
+ write-line xml-parse xml-type-tags zero? | ~))
+
+; number of times to run a test-xxxx function 
+; on 2.3 GHz Intel Core i5 Mac Mini OX X 10.91
+; and pass 1000 milliseconds
+
+(set 'QA:primes '(
+  (!= 6053) 
+  ($ 25056) 
+  (% 8760) 
+  (& 30217) 
+  (* 25346) 
+  (+ 14084) 
+  (- 30257) 
+  (/ 18797) 
+  (< 3022) 
+  (<< 29441) 
+  (<= 25578) 
+  (= 2915) 
+  (> 3056) 
+  (>= 25067) 
+  (>> 29320) 
+  (NaN? 6689) 
+  (^ 30002) 
+  (abs 19338) 
+  (acos 17728) 
+  (acosh 25334) 
+  (add 1100) 
+  (address 5829) 
+  (amb 17687) 
+  (and 22068) 
+  (append 811) 
+  (apply 2373) 
+  (args 9592) 
+  (array 1374) 
+  (array-list 2018) 
+  (array? 2300) 
+  (asin 7543) 
+  (asinh 8852) 
+  (assoc 1978) 
+  (atan 13084) 
+  (atan2 19131) 
+  (atanh 20106) 
+  (atom? 14913) 
+  (base64-dec 3030) 
+  (base64-enc 1819) 
+  (bayes-query 14947) 
+  (bayes-train 1449) 
+  (begin 
+   17015) 
+  (beta 13924) 
+  (betai 10034) 
+  (bind 6360) 
+  (binomial 14103) 
+  (bits 2701) 
+  (case 6907) 
+  (catch 3158) 
+  (ceil 31699) 
+  (char 1809) 
+  (chop 2193) 
+  (clean 3283) 
+  (collect 6354) 
+  (cond 
+   4163) 
+  (cons 4743) 
+  (constant 21374) 
+  (context 21963) 
+  (context? 30700) 
+  (copy 9901) 
+  (cos 17548) 
+  (cosh 14825) 
+  (count 1438) 
+  (cpymem 8578) 
+  (crc32 2773) 
+  (crit-chi2 314) 
+  (crit-z 5138) 
+  (curry 1177) 
+  (date 1381) 
+  (date-value 24580) 
+  (dec 7534) 
+  (def-new 6353) 
+  (default 1033) 
+  (define 3065) 
+  (define-macro 3104) 
+  (delete 489) 
+  (det 5633) 
+  (difference 1106) 
+  (div 13711) 
+  (do-until 4763) 
+  (do-while 826) 
+  (doargs 10649) 
+  (dolist 1378) 
+  (dostring 5872) 
+  (dotimes 2430) 
+  (dotree 144) 
+  (dump 11292) 
+  (dup 2348) 
+  (empty? 4194) 
+  (encrypt 7443) 
+  (ends-with 1106) 
+  (env 879) 
+  (erf 20568) 
+  (error-event 33105) 
+  (eval 8899) 
+  (eval-string 3297) 
+  (exists 1098) 
+  (exp 12468) 
+  (expand 1145) 
+  (explode 936) 
+  (factor 496) 
+  (fft 9530) 
+  (filter 1697) 
+  (find 493) 
+  (find-all 605) 
+  (first 2454) 
+  (flat 4612) 
+  (float 23358) 
+  (float? 46891) 
+  (floor 31571) 
+  (flt 32769) 
+  (for 5018) 
+  (for-all 2082) 
+  (format 120) 
+  (fv 18876) 
+  (gammai 15399) 
+  (gammaln 15592) 
+  (gcd 8168) 
+  (get-char 7645) 
+  (get-float 12718) 
+  (get-int 828) 
+  (get-long 11219) 
+  (get-string 12508) 
+  (global 39818) 
+  (global? 28470) 
+  (if 5084) 
+  (if-not 42924) 
+  (ifft 9383) 
+  (inc 4939) 
+  (index 3909) 
+  (int 6485) 
+  (integer? 19445) 
+  (intersect 2360) 
+  (invert 617) 
+  (irr 1621) 
+  (join 1595) 
+  (lambda? 46801) 
+  (last 2378) 
+  (last-error 15288) 
+  (legal? 4744) 
+  (length 1428) 
+  (let 5611) 
+  (letex 2014) 
+  (letn 7377) 
+  (list 10421) 
+  (list? 23320) 
+  (local 9311) 
+  (log 12525) 
+  (lookup 6393) 
+  (lower-case 6685) 
+  (macro? 31504) 
+  (main-args 3196) 
+  (map 3612) 
+  (mat 332) 
+  (match 969) 
+  (max 15813) 
+  (member 1416) 
+  (min 15580) 
+  (mod 12903) 
+  (mul 29844) 
+  (multiply 1147) 
+  (new 244) 
+  (nil? 3141) 
+  (normal 1191) 
+  (not 5147) 
+  (now 9680) 
+  (nper 19422) 
+  (npv 14747) 
+  (nth 749) 
+  (null? 4556) 
+  (number? 11851) 
+  (or 9823) 
+  (pack 394) 
+  (parse 1144) 
+  (pmt 18571) 
+  (pop 548) 
+  (pop-assoc 1586) 
+  (pow 17674) 
+  (pretty-print 11440) 
+  (primitive? 46760) 
+  (prob-chi2 13204) 
+  (prob-z 21896) 
+  (protected? 17128) 
+  (push 435) 
+  (pv 18318) 
+  (quote 31454) 
+  (quote? 41652) 
+  (rand 89) 
+  (random 12582) 
+  (randomize 3009) 
+  (read-expr 4715) 
+  (ref 345) 
+  (ref-all 147) 
+  (regex 1389) 
+  (regex-comp 3934) 
+  (replace 150) 
+  (rest 1057) 
+  (reverse 5031) 
+  (rotate 2282) 
+  (round 1909) 
+  (seed 2370) 
+  (select 1721) 
+  (sequence 19540) 
+  (series 7188) 
+  (set 15401) 
+  (set-locale 17081) 
+  (set-ref 1511) 
+  (set-ref-all 2380) 
+  (setf 1072) 
+  (setq 12671) 
+  (sgn 14249) 
+  (sin 16651) 
+  (sinh 12632) 
+  (slice 507) 
+  (sort 319) 
+  (source 704) 
+  (sqrt 19000) 
+  (starts-with 4339) 
+  (string 256) 
+  (string? 21249) 
+  (sub 20015) 
+  (swap 1931) 
+  (sym 9642) 
+  (symbol? 10533) 
+  (symbols 777) 
+  (sys-error 28675) 
+  (sys-info 13809) 
+  (tan 15491) 
+  (tanh 11477) 
+  (term 17560) 
+  (throw 4726) 
+  (throw-error 2408) 
+  (time 28520) 
+  (time-of-day 13445) 
+  (title-case 4709) 
+  (transpose 1809) 
+  (trim 2012) 
+  (true? 8442) 
+  (unify 335) 
+  (unique 6150) 
+  (unless 7231) 
+  (unpack 6633) 
+  (until 5849) 
+  (upper-case 7117) 
+  (uuid 7149) 
+  (when 7225) 
+  (while 840) 
+  (write-buffer 2736) 
+  (write-line 5587) 
+  (xml-parse 4259) 
+  (xml-type-tags 12922) 
+  (zero? 13161) 
+  (| 30349) 
+  (~ 2971)))
+
+;; run each test function once and collect errors
+(define (qa)
+    (dolist (sm primes)
+        (set 'func (eval (sym (append "test-" (string (first sm))))))
+        (unless (apply func) (push (sm 0) errors))
+    )
+)
+
+;; run all test-xxx functions the number of times it would take to pass
+;; 10 ms on the calibration platform
+(define (bench (total-time 0))
+    (dolist (sm primes)
+        (when (and 
+              (set 'func (eval (sym (append "test-" (string (first sm))))))
+              (set 'result (time (apply func) (mul (last sm) multiplier))))
+            (inc total-time result))
+        (when report-flag 
+            (println (format "%-14s %5.1f ms" (string (first sm)) result)))
+    )   
+    total-time
+)
+
+
+;; calibrate - find out how many times to run a test-xxxx function to pass
+;; ms milliseconds time (default is one second)
+
+(define (calibrate (ms 1000))
+    (set 'primes '())
+    (dolist (sm primitives)
+        (set 'func (eval (sym (append "test-" (string sm)))) )
+        (set 'N 0)
+        (set 'start-time (time-of-day))
+        (while (< (- (time-of-day) start-time) ms)
+            (dotimes (n 100) (apply func))
+            (inc N 1))
+        (push (list sm N) primes -1)
+        (println sm " -> " N)
+    )
+    (save "primes.lsp" 'primes)
+)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; test-functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (test-$) (= ($ 0) $0))
+
+(define (test-!= )
+  (and (not (!= -9223372036854775808 (& -9223372036854775808 -1))) (!= "abc" "ABC") 
+   (!= "a" "ยฟ") 
+   (!= 1.000000001 1) 
+   (!= "ยฟ" "a")))
+
+(define (test-% )
+  (and
+    (= (% 10 3) 1)
+    (= (% 5) 5))
+    (= (% 4.3 2) 0)
+    (= (% 4.3 2.2) 0)
+    (= (% 3.9 2) 1)
+)
+
+(define (test-& )
+  (= -9223372036854775808 (& -9223372036854775808 -1)))
+
+(define (test-* )
+  (= (* (* 123456789 123456789)) 15241578750190521))
+
+(define (test-+ )
+  (= (+ 999999999999999999 1) 1000000000000000000)
+  (= (+ 9223372036854775807 -9223372036854775808) -1)
+  (= (+ -9223372036854775808 -1) 9223372036854775807)) ; wraps around
+
+(define (test-- )
+  (= (- 100000000 1) 99999999))
+
+(define (test-/ )
+  (= (/ 15241578750190521 123456789) 123456789)
+  (= (/ -10 5) -2))
+
+(define (test-< )
+  (and 
+   (< -9223372036854775808 9223372036854775807)
+   (< "abcdefg" "abcdefgh")
+   (< 1 1.000000001) 
+   (< 1 "a") 
+   (< "a" 'a)
+   (< '(a b) '(b c) '(c d))
+   (not (< '(a b) '(b d) '(b c)))
+   (< '(((a b))) '(((b c))))
+   (< '(a (b c)) '(a (b d)) '(a (b (d))))
+   (< -1)
+   (< -1.23)
+   (not (< "1"))
+   (not (< '()))
+))
+
+(define (test-<< )
+  (= (<< 1 63) -9223372036854775808))
+
+(define (test-<= )
+  (and (<= -9223372036854775808 -9223372036854775808) (<= 1 1.00000001)))
+
+(define (test-= )
+  (and 
+    (= 1.23456789 1.23456789) 
+    (= 123456789 123456789) 
+    (= '(1 2 3 (4 5) (a b ("CDEFG" "HIJK") 'u 'v 'w)) 
+    '(1 2 3 (4 5) (a b ("CDEFG" "HIJK") 'u 'v 'w))) 
+    (= "ยฟยฟยฟยฟยฟยฟยฟยฟยฟยฟยฟ" "ยฟยฟยฟยฟยฟยฟยฟยฟยฟยฟยฟ")
+    (= '())
+    (= 0)
+    (= "")
+    (not (= 1))
+    (not (= "abc"))
+    (not (= '(1 2 3)))
+))
+
+(define (test-> )
+  (and (> 9223372036854775807 -9223372036854775808) (> "abcdefgh" "abcdefg") (> 1.000000001 
+    1) 
+   (> "a" 1) 
+   (> "z" "aaaaa")
+   (> "aaa" "a")
+   (> 'a "a") 
+   (> '(a) 'a)
+   (> 1)
+   (> 1.23)
+   (> "abc")
+   (> '(1 2 3))
+   (not (> ""))
+   (not (> '()))   
+))
+
+(define (test->= )
+  (and (>= 1 0) (>= 1.00000001 1)))
+
+(define (test->> )
+  (= (>> 1073741824 30) 1))
+
+(define (test-NaN? )
+  (and (NaN? (sqrt -1))
+       (set 'NaN (sqrt -1)) 
+       (= 1 (+ 1 NaN)) 
+       (= 0 (* 2 NaN)) 
+       (NaN? (add 1 (sqrt -1))) 
+       (NaN? (abs (sqrt -1)))
+       (NaN? (div 0 0))
+))
+
+(define (test-^ )
+  (= (^ 1431655765 -1431655766) -1))
+
+(define (test-abs )
+  (and (= (abs -1) 1) (= (abs -9.9) 9.9)))
+
+(define (test-acos )
+  (= 0 (acos (cos (acos (cos 0))))))
+
+(define (test-acosh)
+    (= (cosh (acosh 1)) 1))
+
+(define (test-add , l)
+  (dotimes (x 100) 
+   (push x l))
+  (= 4950 (apply add l)))
+
+(define (test-address s)
+  (and
+    (set 's "foo")
+    (= (address s) (last (dump s)))
+    (set 'D:D "foo")
+    (= (address D) (last (dump D:D)))
+))
+
+(define (test-amb)
+    (set 'x (amb 1 2))
+    (or (= x 1) (= x 2)))
+
+(define (test-and )
+  (and (and true true true) (not (and true true nil))))
+
+(define (test-append )
+  (and
+    (= '(1 2 3 4) (append '(1 2) '(3 4)))
+    (= '(1 2 3 4 5) (append '(1 2) '(3) '(4 5)))
+    (= '(1 2 3 4) (append '(1 2) '(3 4) '()))
+    (= '(1 2 3 4 5) (append '(1 2) '(3 4) '() '(5)))
+    (= '(1 2 3 4 5) (append '() '(1 2) '(3 4) '() '(5)))
+    (= '() (append '()) (append '() '()) (append))
+    (= "abcdefg" (append "" "a" "bcd" "" "ef" "g" ""))
+    (= "" (append ""))
+    (set 'A (array 3 2 (sequence 1 6)))
+    (set 'B (array 2 2 (sequence 7 10)))
+    (= (array 5 2 (sequence 1 10)) (append A B))
+    (lambda? (append '(lambda)))
+    ; default functor
+    (set 'D:D '(a b c))
+    (= '(a b c a b c a b c) (append D D D))
+))
+
+
+(define (test-apply )
+  (and (= (apply + '(1 2)) 3) 
+       (= (apply append '("a" "b" "c")) "abc")
+       (= (apply (fn (x y) (+ x y)) '(3 4)) 7)
+       (= (apply list '(a b c d e f) 2) '(((((a b) c) d) e) f))
+))
+
+
+(define-macro (do-args p)
+  (= (args) '(2 "3 4" 5 (x y)))
+  (= (args 3 -1) 'y))   
+
+(define (test-args )
+  (do-args 1 2 "3 4" 5 (x y)))
+
+(define (test-array) 
+  (and
+    (= (array-list (array 3 2 (sequence 1 6))) '((1 2) (3 4) (5 6)))
+    (set 'A (array 3 2 (sequence 1 6)))
+    (= (array-list (nth 0 A)) '(1 2))
+    (= (nth '(0 0) A) 1)
+    (= (nth '(2 1) A) 6)
+    (= (nth '(-1 -1) A) 6)
+    (= (nth 0 A) (array 2 '(1 2)))
+    (= (array-list (nth 0 A)) '(1 2))
+    (< (nth 0 A) (nth 1 A))
+    (> (nth 2 A) (nth 1 A))
+    (setf (A 1 0) 1)
+    (= (nth '(1 0) A) 1)
+    (setf (A 1 1) 1)
+    (= (array-list A) '((1 2) (1 1) (5 6)))
+    (< (nth 1 A) (nth 0 A))
+))
+
+
+(define (test-array-list)
+    (and 
+        (set 'a (array 3 4 (sequence 1 12)))
+        (array? a) 
+        (list? (array-list a))
+        ; default functor
+        (set 'D:D (array 3 4 (sequence 1 12)))
+        (array? D:D)
+        (list? (array-list D))
+        (= (array-list D) '((1 2 3 4) (5 6 7 8) (9 10 11 12)))
+))
+
+(define (test-array?) (test-array-list))
+
+(define (test-asin )
+  (= (round (asin (sin (asin (sin 1)))) -9) 1))
+
+(define (test-asinh)
+  (= (round (sinh (asinh 1)) -12) 1))
+
+(define (test-assoc)
+ (and
+    (set 'L '((a 1) (b (c (d 2) (e 3) (e 4))) ("a" 5) ((a) 6))) 
+    (= (assoc 'a L) '(a 1)) 
+    (= (assoc 'b L) '(b (c (d 2) (e 3) (e 4))))
+    (= (assoc "a" L) '("a" 5))
+    (= (assoc '((a)) L) '((a) 6))
+
+    (= (assoc '(b c) L) '(c (d 2) (e 3) (e 4)))
+    (= (assoc '(b c d) L) '(d 2))
+    (= (assoc '(b c e) L) '(e 3))
+    ; default functor
+    (set 'D:D '((a 1) (b (c (d 2) (e 3) (e 4))) ("a" 5) ((a) 6)))   
+    (= (assoc 'a D) '(a 1))
+))
+
+
+(define (test-atan )
+    (< (sub 1 (atan (tan (atan (tan 1))))) 1e-15))
+
+; old test broke after Mac OS X update to 10.5.2
+;  (= 1 (atan (tan (atan (tan 1)))))
+
+(define (test-atanh)
+    (< (sub (tanh (atanh 0.5)) 0.5) 0.0000000001))
+
+(define (test-atan2 )
+  (= (div (acos 0) (atan 1 1)) 2))
+
+(define (test-atom? )
+  (and (atom? 1) (atom? 1.23) (atom? "hello") (atom? 'x) (atom? nil) (atom? true)))
+
+(define (test-base64-enc)
+  (and
+    (= "" (base64-dec (base64-enc "")))
+    (= "1" (base64-dec (base64-enc "1")))
+    (= "12" (base64-dec (base64-enc "12")))
+    (= "123" (base64-dec (base64-enc "123")))
+    (= "1234" (base64-dec (base64-enc "1234")))
+))
+
+(define (test-base64-dec)
+  (test-base64-enc))
+
+;; context Lex was previously created
+
+(define (test-bayes-train)
+  (and
+    (test-bayes-query)
+    (= (bayes-train '(F F F B B) '(F B B B B) 'Lex) '(5 5))
+    (> 0.001 (apply add (map sub (bayes-query '(F) Lex) '(0.75 0.25))))
+    (> 0.001 (apply add (map sub (bayes-query '(F) Lex true) '(0.75 0.25))))
+    (> 0.001 (apply add (map sub (bayes-query '(F F) Lex) '(0.8251777681 0.1748222319))))
+    (> 0.001 (apply add (map sub (bayes-query '(F F) Lex true) '(0.9 0.1))))
+  )
+)
+
+(define (test-bayes-query) 
+    (set 'Lex:F '(0 0))
+    (set 'Lex:B '(0 0))
+    (set 'Lex:total '(0 0))
+    true)
+
+(define (test-begin )
+  (begin 
+   (set 'x 0) 
+   (inc x) 
+   (inc x) 
+   (= x 2)))
+
+(define (test-beta )
+  (< (abs (sub (beta 1 2) 0.5)) 1e-05))
+
+(define (test-betai )
+  (< (abs (sub (betai 0.5 5 10) 0.910217)) 1e-05))
+
+(define (test-bind)
+    (bind '((a 1) (b "hello") (c (3 4))))
+    (and
+        (= a 1)
+        (= b "hello")
+        (= c '(3 4))
+        (= 7 (bind '((a (+ 3 4))) true))
+    )
+)
+
+(define (test-binomial )
+  (< (sub (binomial 2 1 0.5) 0.5) 1e-09))
+
+(define (test-bits)
+  (and
+    (= (int (bits 0x7fffffffffffffff) 0 2) 0x7fffffffffffffff)
+    (= (int (bits 0x8000000000000000) 0 2) 0x8000000000000000)
+    (= 64 (length (bits 0x8000000000000000)))
+    (= (bits 0) "0")
+    (= (bits 1234) "10011010010")
+    (= (bits 1234 true) '(nil true nil nil true nil true true nil nil true))
+))
+
+(define (check-case x)
+  (case x 
+   (1 "one") 
+   (2 "two") 
+   (3 "three")))
+
+(define (test-case )
+  (and (= (check-case 1) "one") (= (check-case 2) "two") (= (check-case 
+     9) nil)))
+
+(define (test-catch)
+    (and (not (catch (invalid-func) 'result))
+         (starts-with result "ERR: invalid function in function catch")
+))
+
+(define (test-ceil )
+  (= 2 (ceil 1.5)))
+
+(define (test-change-dir )
+  (make-dir "adir")
+  (change-dir "adir")
+  (change-dir "..")
+  (remove-dir "adir"))
+
+(define (test-char )
+  (and 
+    (= (format "%c" (char "a" 0)) "a") 
+    (= (char "A") 65) (= (char 65) "A")
+    (= (map char (sequence 65 67)) '("A" "B" "C"))
+    (= (char 0) "\000")
+    (set 'D:D "ABCDEFG")
+    (= (char D 0) 65)
+    (= (char D -1) 71)
+))
+
+(define (test-chop )
+  (and 
+    (= (chop "newlisp") "newlis")
+    (= (chop "newlisp" 4) "new")
+    (= (chop "abc" 5) "")
+    (= (chop "abc" -5) "")
+    (= (chop '(a b (c d) e)) '(a b (c d)))
+    (= (chop '(a b (c d) e) 2) '(a b))
+    (set 'D:D "newlisp")
+    (= (chop D) "newlis")
+    (= (chop D 4) "new")
+))
+
+(define (test-clean ) 
+  (and
+    (= (clean integer? '(1 1.1 2 2.2 3 3.3)) '(1.1 2.2 3.3))
+    (= (clean true? '(a nil b nil c nil)) '(nil nil nil))))
+
+(define (test-collect)
+    (= (let (x 0) (collect (if (<= (inc x) 5) x))) '(1 2 3 4 5))
+)
+
+(define (test-crc32)
+    (= (crc32 "abcdefghijklmnopqrstuvwxyz") 1277644989))
+
+(define (test-select-collect )
+  (and
+    (set 'l '(0 1 2 3 4 5 6 7 8 9))
+    (= (select l '()) '())
+    (= (select l 0 9 9 0 1 8 8 1) '(0 9 9 0 1 8 8 1)) 
+    (= (select "2001-09-20" 5 6 8 9 0 1 2 3) "09202001") 
+    (set 'a 0 'b 1 'c 2)
+    (= (select '(w x y z) a b c) '(w x y))
+    (= (select '(w x y z) (inc a) (inc b) (inc c)) '(x y z))
+))
+
+(define (check-cond x)
+  (cond 
+   ((= x 1) 1) 
+   ((= x 2) 2) 
+   ((= x 3) 3)))
+
+(define (test-cond )
+  (and 
+      (= (check-cond 1) 1)
+      (= (check-cond 2) 2)
+      (not (check-cond 99)) 
+      (= (cond ((+ 3 4))) 7)
+      (= (cond (nil 1) ('())) '())
+      (= (cond (nil 1) (nil)) nil)
+      (= (cond (nil 1) (true nil)) nil)
+      (= (cond ('())) '())
+      (= (cond (nil 1) ('() 2)) '())
+))
+
+(define (test-cons )
+  (= (myappend '(1 2 3) '(4 5 6)) '(1 2 3 4 5 6))
+)
+
+(define (test-constant )
+  (constant 'cs 123)
+  (= cs 123)
+  (protected? 'cs))
+
+
+(define (test-context )
+  (and (context 'TEST) (context 'QA)))
+
+(define (test-context? )
+  (and (context? MAIN) (context? QA)))
+
+(define (test-copy)
+ (and
+    (set 'aList '(a b c))
+    (= (replace 'b (copy aList)) '(a c))
+    (= aList '(a b c))
+))
+
+(define (test-cos )
+  (= 1 (cos (acos (cos (acos 1))))))
+
+(define (test-cosh)
+    (= (cosh 1) (div (add (exp 1) (exp -1)) 2)))
+
+(define (test-count )
+  (and (= (count '(1 2) '(2 1 2 1)) '(2 2)) 
+       (= (count '(a b) '(a a b c a b b)) '(3 3))
+       (= (count '(a b c) '()) '(0 0 0))
+       (set 'L '(a b c d e f))
+       (= (count L L) '(1 1 1 1 1 1))
+  )
+)
+
+(define (test-cpymem)  
+  (set 'from "12345")
+  (set 'to "     ")
+  (cpymem (address from) (address to) 5)
+  (= from to))
+
+(define (test-crit-chi2)
+  (and
+    (< (abs (sub (crit-chi2 (prob-chi2 4.605 2) 2) 4.605)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 51.805 40) 40) 51.805)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 9.210 2) 2) 9.210)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 63.691 40) 40) 63.691)) 0.001)
+))
+
+(define (test-crit-z )
+  (< (abs (sub (crit-z 0.999) 3.090232)) 1e-05))
+
+(define (test-curry)
+  (and
+    (= (set 'f (curry + 10)) (lambda ($x) (+ 10 $x)))
+    (= (filter (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+       '((a 10) (a 3) (a 9)))
+    (= (clean (curry match '(a *)) '((a 10) (b 5) (a 3) (c 8) (a 9)))
+       '((b 5) (c 8)))
+    (= (map (curry list 'x) (sequence 1 5))
+       '((x 1) (x 2) (x 3) (x 4) (x 5)))
+))
+
+(define (test-date )
+  (= (date) (date (date-value)) (date (apply date-value (now)))))
+
+(define (test-date-value )
+  (= 0 (date-value 1970 1 1 0 0 0)))
+
+(define (test-dec , x)
+    (test-inc))
+
+(define (test-define , foo)
+  (and 
+    (lambda? (define (foo (x 1) (y 2)) (list x y)))
+    (= (foo) '(1 2))
+    (= (foo 3) '(3 2))
+    (= (foo 3 4) '(3 4))
+    (define (foo (x 10) (y (div x 2))) (list x y))
+    (= (foo) '(10 5))
+    (= (foo 20) '(20 10))
+    (= (foo 3 4) '(3 4))
+))
+
+(define (test-def-new)
+  (and
+    (set 'fooctx:x 123)
+    (new fooctx)
+    (= fooctx:x 123)
+    (set 'barctx:bar 999)
+    (def-new 'barctx:bar)
+    (= bar 999)
+    (def-new 'barctx:bar 'foobar)
+    (= foobar 999)
+    (def-new 'barctx:bar 'foofoo:foo)
+    (= foofoo:foo 999)
+))
+
+
+(define (test-define-macro , foo)
+  (and 
+    (macro? (define-macro (foo (x 1) (y 2)) (list x y)))
+    (= (foo) '(1 2))
+    (= (foo 3) '(3 2))
+    (= (foo 3 4) '(3 4))
+    (define-macro (foo (x 10) (y (div x 2))) (list x y))
+    (= (foo) '(10 5))
+    (= (foo 20) '(20 10))
+    (= (foo 3 4) '(3 4))
+))
+
+(define (test-default)
+    (MAIN:test-default-functor))
+
+(define (test-delete )
+  (delete (sym "xxx")))
+
+(define (test-delete-url )
+  (= "ERR: bad formed URL" (delete-url "")))
+
+(define (test-det) 
+  (set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+  (<  (sub (det A) -1) 2e-10))
+
+(define (test-difference )
+  (and
+    (= (difference '(2 5 6 0 3 0 2 5) '(1 2 3 3 2 1)) '(5 6 0))
+    (= (difference '(1 5 2 3 2 2 4 5 3 4 5 1) '(3 4) true) '(1 5 2 2 2 5 5 1))
+    (= (difference '(nil nil nil) '()) '(nil))
+    (= (difference '(nil nil nil) '() true) '(nil nil nil))
+    (set 'L '(a b c d e f))
+    (= (difference L L) '())
+  )
+)
+
+(define (test-div )
+  (and (= 0.1 (div 100000000 1000000000)) 
+       (= (div 1 3) 0.3333333333333333)
+       (= (div 3) 0.3333333333333333)
+))
+
+(define (testdoargs)
+    (local (lst)
+        (doargs (i) (push i lst))
+        lst))
+
+(define (test-doargs)
+    (= (testdoargs 3 2 1) '(1 2 3)))
+
+(define (test-dolist , rList)
+  (and 
+   (dolist (x '(1 2 3 4 5 6 7 8 9)) 
+    (push x rList)) 
+   (= rList '(9 8 7 6 5 4 3 2 1)) 
+   (dolist (x rList) 
+    (pop rList))
+    (dolist (x '(1 2 3 4 5 6 7 8 9) (> x 5))
+      (push x rList))
+   (= rList '(5 4 3 2 1))
+   (= (local (l) (dolist (e '(1 2 3)) (push $idx l)) l) '(2 1 0))
+   (= (dolist (x '(a b c d e f g)) x) 'g)
+   ;; default functor
+   (set 'D:D (sequence 1 10))
+   (set 'cnt 0)
+   (dolist (i D) (inc cnt i))
+   (= cnt (apply add D))
+))
+
+(define (test-dostring)
+    (local (r) 
+        (dostring (i "newlisp" (= i 108)) (push  i r)) 
+        (= r '(119 101 110))
+        (= (dostring (c "newlisp") c) 112)
+    )
+)
+
+(define (test-dotimes , aList)
+  (dotimes (x 2) 
+   (dotimes (y 2) 
+    (dotimes (z 2) 
+     (push z aList))))
+  (and
+     (= '(1 0 1 0 1 0 1 0) aList)
+     (not (dotimes (x 0) x))
+     (= (dotimes (x 1) x) 0)
+
+     ; dotimes returns nil when ever executed since 8.9.7
+     (not (= (dotimes (x -1) x) 0))
+     (not (= (dotimes (x -1.8) x) 0))
+
+     (= (dotimes (x 1.8) x) 0)
+     (set 'cnt 0)
+     (dotimes (x 10 (> x 5)) (inc cnt))
+     (= cnt 6)
+
+))
+     
+(define (test-dotree )
+  (set 'aList '())
+  (and
+    (= (last (symbols MAIN)) (dotree (p MAIN) p))
+    (dotree (x 'MAIN) 
+        (push x aList))
+    (= (length (symbols 'MAIN)) (length aList))
+))
+
+(define (test-dump )
+  ( = "hello" (get-string (last (dump "hello")))))
+
+(define (test-dump-symbol )
+  (= (length (dump nil) 4)))
+
+(define (test-dup)
+  (and
+    (= (dup "" 0) "")
+    (= (dup "" 10) "")
+    (= (dup "A" 10) "AAAAAAAAAA")
+    (= (dup "AB" 5) "ABABABABAB")
+    (= (dup 'x 5) '(x x x x x))
+    (= (dup "l" -1) "")
+    (= (dup '(1) -1) '())
+    (= (dup 1 0) '())
+    (= (dup 1 5) '(1 1 1 1 1))))
+
+(define (test-empty? , aList)
+  (set 'aList '(1 2 3 4 5 6 7 8 9 0))
+  (while aList 
+   (pop aList))
+  (and 
+    (empty? aList) 
+    (empty? "")
+    (set 'D:D (sequence 1 10))
+    (while D:D (pop D))
+    (empty? D)
+))
+
+(define (test-encrypt )
+  (= (encrypt (encrypt "newlisp" "123") "123") "newlisp"))
+
+(define (test-ends-with )
+  (and 
+    (ends-with "newlisp" "lisp") 
+    (ends-with "newlisp" "LISP" 1) 
+    (ends-with "abc.def.ghi" "def|ghi" 1)
+    (ends-with "12345" "4|5" 1)
+    (ends-with (explode "newlisp") "p")
+    (set 'D:D "newlisp")
+    (ends-with D "lisp") 
+    (ends-with D "LISP" 1) 
+))
+
+(define (test-env)
+  (and 
+    (list? (env))
+    (env "key" "value") 
+    (= (env "key") "value")
+    (env "key" "") ; remove key
+    (if (= ostype "Solaris")
+        (= (env "key" ""))
+        (not (env "key")))
+))
+
+(define (test-erf)
+   (<  (abs (sub 0.5204998778 (erf 0.5))) 0.000001))
+
+(define (test-estack) (list? (estack)))
+
+(define (test-throw)
+    (= "Hello World"
+        (catch (begin (+ 1 2 3 4 5) (throw "Hello World"))))
+)
+
+(define (test-throw-error)
+    (and (not (catch (catch (throw-error "Hello")) 'result))
+         (starts-with result "ERR: user error : Hello")
+))
+
+(define (test-title-case)
+    (= (title-case "heLLo") "HeLLo")
+    (= (title-case "heLLo" true) "Hello"))
+
+(define (test-error-event )
+  (= 'nil (error-event)))
+
+(define (test-estack) (list? (estack)))
+
+(define (test-eval , x y)
+  (set 'x 123)
+  (set 'y 'x)
+  (set 'z 'y)
+  (and (= 123 (eval y)) (= 123 (eval 'x)) (= 123 (eval (eval z)))))
+
+(define (test-eval-string )
+  (eval-string "(set 'x 123)")
+  (eval-string "(set 'y x)")
+  (= 123 (eval-string "y"))
+  (set 'Foo:xyz 99999)
+  (= 99999 (eval-string "xyz" 'Foo))
+)
+
+(define (sub-read-exec ) 
+   (write-file "exectest" {(println "hello") (exit)})
+   (and
+    (set 'result (if (find ostype '("Windows" "OS/2"))
+        (exec "newlisp exectest") 
+        (exec "./newlisp exectest")))
+    (= "hello" (last  result)) 
+    (delete-file "exectest")))
+
+(define (sub-write-exec )
+  (and 
+    (write-file "testexec" {(write-file "exectest" (read-line))})
+    (if (find ostype '("Windows" "OS/2"))
+     (exec "newlisp testexec" "HELLO") (exec "./newlisp testexec" "HELLO"))
+    (= "HELLO" (read-file "exectest"))
+    (delete-file "testexec")
+    (delete-file "exectest")))
+
+
+(define (test-exists)
+  (and
+    (= (exists string? '(2 3 4 6 "hello" 7)) "hello")
+    (not (exists string? '(3 4 2 -7 3 0)) )
+    (= (exists zero? '(3 4 2 -7 3 0)) 0)
+    (= (exists < '(3 4 2 -7 3 0)) -7)
+    (= (exists (fn (x) (> x 3)) '(3 4 2 -7 3 0)) 4)
+    (not (exists (fn (x) (= x 10)) '(3 4 2 -7 3 0)))
+))
+
+(define (test-exp )
+  (= 1 (exp (log (exp (log (exp (log 1))))))))
+
+(define (test-expand) 
+  (and
+    (set 'x 2)
+    (= (expand 'x 'x) 2)
+    (= (expand '(a x b) 'x) '(a 2 b))
+    (= (expand '(x b) 'x) '(2 b))
+    (= (expand '(a x) 'x) '(a 2))
+    (= (expand '(a (x) b) 'x) '(a (2) b))
+    (= (expand '(a ((x)) b) 'x) '(a ((2)) b))
+    (set 'a 1 'b 2 'c 3)
+    (= (expand '(a b c) 'b 'a 'c ) '(1 2 3))
+    ;; prolog mode with uppercase vars
+    (set 'X 2)
+    (= (expand '(a ((X)) b)) '(a ((2)) b))
+    ;; env list as parameter
+    (set 'a "a" 'B "B" 'c "c" 'd "d")
+    (= (expand '(a (B (c) (d a B))) '((a 1) (B 2) (c 3) (d 4)))
+       '(1 (2 (3) (4 1 2))))
+    (= a "a") (= B "B") (= c "c") (= d "d")
+    ;; default functor
+    (set 'Le:Le '(a (B (c) (d a B))) )
+    (set 'p '((a 1) (B 2) (c 3) (d 4)))
+    (= (expand Le p) '(1 (2 (3) (4 1 2))))
+))
+
+(define (test-explode )
+    (and    
+        (= (explode "kakak" -1) '())
+        (= (explode "ABC" 4) '("ABC"))
+        (= (explode '(a b c d e f) -1) '())
+        (= (explode "new") '("n" "e" "w"))
+        (= (explode "newlisp" 3) '("new" "lis" "p"))
+        (= (explode "newlisp" 3 true) '("new" "lis"))
+        (= (explode "newlisp" 7 true) '("newlisp"))
+        (= (explode "newlisp" 8 true) '())
+        (= (explode '(a b c d e)) '((a) (b) (c) (d) (e)))
+        (= (explode '(a b c d e) 2) '((a b) (c d) (e)))
+        (= (explode '(n e w l i s p)) '((n) (e) (w) (l) (i) (s) (p)))
+        (= (explode '(n e w l i s p) 3) '((n e w) (l i s) (p)))
+        (= (explode '(n e w l i s p) 7 true) '((n e w l i s p)))
+        (= (explode '(n e w l i s p) 8 true) '())
+        (set 'D:D '(a b c d e f g))
+        (= (explode D 2) '((a b) (c d) (e f) (g)))
+))
+
+(define (test-factor)
+    (= (factor 123456789) '(3 3 3607 3803)))
+
+(define (test-fft )
+  (= '((1 2) (3 4)) (ifft (fft '((1 2) (3 4))))))
+
+(define (test-filter )
+  (and
+    (= (filter integer? '(1 1.1 2 2.2 3 3.3)) '(1 2 3))
+    (= (filter true? '(a nil b nil c nil)) '(a b c))
+    ; default functor
+    (set 'D:D '(2 4 2 7 5 3 8))
+    (= (filter (curry < 5) D) '(7 8))
+))
+
+(define (test-find )
+  (and 
+    (= 3 (find '(3 4) '(0 1 2 (3 4) 5 6 7 8)))
+    (= nil (find 9 '(1 2 3))) 
+    (= 2 (find "W" "newlisp" 1))
+    (= $0 "w")
+    (= (find "newlisp" '("Perl" "Python" "newLISP") 1) 2)
+    ; use a comparison functor
+    (= (find '(1 2) '((1 4) 5 6 (1 2) (8 9))) 3)
+    (= (find 3 '(8 4 3  7 2 6) >)  4)
+    (= (find 5 '((l 3) (k 5) (a 10) (z 22)) (fn (x y) (= x (last y)))) 1)
+    (= (find '(a ?) '((l 3) (k 5) (a 10) (z 22)) match) 2)
+    (= (find '(X X) '((a b) (c d) (e e) (f g)) unify) 2)
+    (define (has-it-as-last x y) (= x (last y)))
+    (= (find 22 '((l 3) (k 5) (a 10) (z 22)) has-it-as-last) 3)
+    (= (find "newlisp" '("Perl" "Python" "newLISP") (fn (x y) (regex x y 1))) 2)
+    ; default functor
+    (set 'D:D '(0 1 2 (3 4) 5 6 7 8))
+    (= 3 (find '(3 4) D))
+    (set 'D:D "newlisp")
+    (= 2 (find "W" D 1))
+))
+
+
+(define (test-find-all)
+  (and
+    (= (find-all {\d+} "asdf2kjh44hgfhgf890") '("2" "44" "890"))
+    (= (find-all {(new)(lisp)} "newLISPisNEWLISP" (append $2 $1) 1) '("LISPnew" "LISPNEW"))
+    (set 'D:D "asdf2kjh44hgfhgf890")
+    (= (find-all {\d+} D) '("2" "44" "890"))
+    (set 'D:D "newLISPisNEWLISP")
+    (= (find-all {(new)(lisp)} D (append $2 $1) 1) '("LISPnew" "LISPNEW"))
+))
+
+(define (test-first )
+  (= 1 (first '(1 2 3 4)))
+  (= "n" (first "ewLISP"))
+  (= (array 2 '(1 2)) (first (array 3 2 (sequence 1 6))))
+  ;; default functor
+  (set 'D:D '(a b c d e f g))
+  (= (first D) 'a)
+  (set 'D:D (array 7 '(a b c d e f g)))
+  (= (first D) 'a)
+)
+
+(define (test-flat )
+  (set 'lst '(a (b (c d))))
+  (= (map (fn (x) (ref x lst)) (flat lst)) '((0) (1 0) (1 1 0) (1 1 1))))
+
+(define (test-float )
+  (float? (float "1.234")))
+
+(define (test-flt)
+    (= (flt 1.23) 1067282596))
+
+(define (test-float? )
+  (float? 1.234))
+
+(define (test-floor )
+  (= 1 (floor 1.5)))
+
+(define (test-for , x lst1 lst2)
+  (set 'lst1 '())
+  (set 'lst2 '())
+  (for (x 10 0 3) 
+   (push x lst1))
+  (for (x 10 0 3 (< x 7))
+   (push x lst2))
+  (and
+   (= lst1 '(1 4 7 10))
+   (= lst2 '(7 10)) )
+)
+
+(define (test-for-all)
+  (and
+    (for-all number? '(2 3 4 6 7)) 
+    (not (for-all number? '(2 3 4 6 "hello" 7)) )
+    (for-all (fn (x) (= x 10)) '(10 10 10 10 10))
+))
+
+(define (test-format )
+  (and
+   (= (format "%d" 1.23) "1") 
+   (= (format "%5.2f" 10) "10.00") 
+   (= (format "%c %s %d %g" 65 "hello" 123 1.23) "A hello 123 1.23")
+   (= (format "%5.2s" "hello") "   he")
+   ; args passed in a list
+   (= (format "%d" '(1.23)) "1")  
+   (= (format "%5.2f" '(10)) "10.00")  
+   (= (format "%c %s %d %g" '(65 "hello" 123 1.23)) "A hello 123 1.23")
+   (= (format "%5.2s" '("hello")) "   he")
+   (set 'data '((1 "a001" "g") (2 "a101" "c") (3 "c220" "g")))
+   (set 'result (map (fn (x) (format "%3.2f %5s %2s" (nth 0 x) (nth 1 x) (nth 2 x))) data))
+   (set 'result (map (fn (x) (format "%3.2f %5s %2s" (x 0) (x 1) (x 2))) data))
+   (= result '("1.00  a001  g" "2.00  a101  c" "3.00  c220  g"))
+   (= (test-format-r '(("foo" "bar") ("foo" "baz"))) 
+      "[ [ 'foo', 'bar' ], [ 'foo', 'baz' ] ]")
+   ; test 64-bit formatting
+   (if (find ostype '("Windows")) ;; Windows
+      (begin
+        (and
+         (= (format "%I64d" 0x7fffffffffffffff) "9223372036854775807")
+         (= (format "%I64x" 0x7fffffffffffffff) "7fffffffffffffff")
+         (= (format "%I64u" 0x7fffffffffffffff) "9223372036854775807")
+         (= (format "%I64d" 0x8000000000000000) "-9223372036854775808")
+         (= (format "%I64x" 0x8000000000000000) "8000000000000000")
+         (= (format "%I64u" 0x8000000000000000) "9223372036854775808")
+         (= (format "%I64d" 0xFFFFFFFFFFFFFFFF) "-1")
+         (= (format "%I64x" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+         (= (format "%I64u" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+      )
+      (begin ;; UNIX like OS 
+        (if (= ostype "Tru64Unix") ;TRU64
+          (begin
+            (and
+              (= (format "%d" 0x7fffffff) "2147483647")
+              (= (format "%d" 0xffffffff) "-1")
+              (= (format "%u" 0xffffffff) "4294967295")
+              (= (format "%i" 0x7fffffff) "2147483647")
+
+              ; truncate
+              (= (format "%d" 0x7fffffffffffffff) "-1")
+              (= (format "%u" 0x7fffffffffffffff) "4294967295")
+              (= (format "%x" 0x7fffffffffffffff) "ffffffff") 
+              (= (format "%X" 0x7fffffffffffffff) "FFFFFFFF") 
+
+              (= (format "%ld" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lu" 0xffffffffffffffff) "18446744073709551615")
+              (= (format "%li" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lx" 0x7fffffffffffffff) "7fffffffffffffff")
+              (= (format "%ld" 0x8000000000000000) "-9223372036854775808")
+              (= (format "%lx" 0x8000000000000000) "8000000000000000")
+              (= (format "%lu" 0x8000000000000000) "9223372036854775808")
+              (= (format "%ld" 0xFFFFFFFFFFFFFFFF) "-1")
+              (= (format "%lx" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+              (= (format "%lu" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+          )
+          (begin
+            (and
+              (= (format "%d" 0x7fffffff) "2147483647")
+              (= (format "%d" 0xffffffff) "-1")
+              (= (format "%u" 0xffffffff) "4294967295")
+
+              ; truncate
+              (= (format "%d" 0x7fffffffffffffff) "-1")
+              (= (format "%u" 0x7fffffffffffffff) "4294967295")
+              (= (format "%x" 0x7fffffffffffffff) "ffffffff") 
+              (= (format "%X" 0x7fffffffffffffff) "FFFFFFFF") 
+
+              (= (format "%lld" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%llx" 0x7fffffffffffffff) "7fffffffffffffff")
+              (= (format "%llu" 0x7fffffffffffffff) "9223372036854775807")
+              (= (format "%lld" 0x8000000000000000) "-9223372036854775808")
+              (= (format "%llx" 0x8000000000000000) "8000000000000000")
+              (= (format "%llu" 0x8000000000000000) "9223372036854775808")
+              (= (format "%lld" 0xFFFFFFFFFFFFFFFF) "-1")
+              (= (format "%llx" 0xFFFFFFFFFFFFFFFF) "ffffffffffffffff")
+              (= (format "%llu" 0xFFFFFFFFFFFFFFFF) "18446744073709551615"))
+          )
+      )
+))))
+
+(define (test-format-r obj , s) 
+  (cond 
+   ((string? obj)   (format "'%s'" obj)) 
+   ((list? obj) (format "[ %s ]" (join (map test-format-r obj) ", ")))
+)) 
+
+(define (test-fv )
+  (< (sub (fv 0.1 10 1000 0 0) -15937.4246) 1e-05))
+
+(define (test-gammai )
+  (< (abs (sub (gammai 4 5) 0.734974)) 1e-05))
+
+(define (test-gammaln )
+  (< (abs (sub 120 (exp (gammaln 6)))) 1e-05))
+
+(define (test-gcd)
+ (and
+  (= (gcd 0) 0)
+  (= (gcd 1) 1)
+  (= (gcd 12 36) 12)
+  (= (gcd 12 36 6) 6)
+  (= (gcd 12 36 6 3) 3)
+))
+
+(define (test-get-char )
+ (and
+  (= 65 (get-char (address "A")) (get-char "ABC"))
+  (set 'D:D "ABC")
+  (= 65 (get-char D))
+))
+
+(define (test-get-float )
+  (= 1.234 (get-float (pack "lf" 1.234))))
+
+(define (test-get-int )
+  (and
+    (= 123456789 (get-int (pack "ld" 123456789)))
+    (set 'adr (pack "ldld" 0xaabbccdd 0xccddeeff))
+    (= (format "%x" (get-int adr)) "aabbccdd")
+    (= (format "%x" (get-int (address adr))) "aabbccdd")
+    (= (format "%x" (get-int (+ (address adr) 0))) "aabbccdd")
+    (= (format "%x" (get-int (+ (address adr) 4))) "ccddeeff")
+
+    (set 'adr (pack "> ldld" 0xaabbccdd 0xccddeeff))
+    (= adr "\170\187\204\221\204\221\238\255")
+    (set 'adr (pack "< ldld" 0xaabbccdd 0xccddeeff))
+    (= adr "\221\204\187\170\255\238\221\204")
+    (set 'buff (pack "lulululululululu" 1 2 3 4))
+    (apply and (map (fn (i) (= (+ i 1) (get-int (+ (* i 4) (address buff))))) '(0 1 2 3))) 
+))
+
+
+(define (test-get-long)
+    (set 'adr (pack "Ld" -1))
+    (= -1 (get-long adr)))
+
+(define (test-get-string )
+  (= "hello" (get-string (address "hello"))))
+
+(define (test-global)
+    (= global-myvar 123))
+
+(define (test-global?)
+    (and
+        (global? 'global-myvar)
+        (global? 'println)
+))
+
+(define (test-if )
+  (and 
+   (if true true) 
+   (if nil nil true) 
+   (if 'nil nil true) 
+   (if '() nil true)
+   (= (if '()) '())
+   (= (if nil 1 '() 2) '())
+   (= (if nil '() '()) '())
+   (= (if true '() '()) '())
+   (= (if nil 1 nil 2 nil 3 true 4 3) 4)
+   (= (if nil 1 nil 2 nil 3 nil 4 3) 3)
+   ))
+
+(define (test-if-not )
+  (if-not nil 
+   true nil))
+
+(define (test-ifft )
+  (= '((1 2) (3 4)) (ifft (fft '((1 2) (3 4))))))
+
+(define (test-inc , x)
+  (and
+    (= (inc x) 1)
+    (= (inc x) 2)
+    (set 'l '(1 2 3 4))
+    (= (inc (l 1)) 3)
+    (= (dec (nth 0 l) 2) -1)
+    (= (dec (last l) 0.1) 3.9)
+    (= (inc (+ 3 4)) 8)
+    (= l '(-1 3 3 3.9))
+))
+
+(define (test-index )
+  (= '(1 3) (index (lambda (x) (> x 3)) '(1 5 2 6 2 0))))
+
+(define (test-integer )
+  (and 
+    (integer? (int "12345"))
+    (= (int " 12345") 12345)
+    (= (int "9223372036854775807")  9223372036854775807)
+    (= (int "-9223372036854775808") -9223372036854775808)
+    (= (int 0.0) 0)
+    (= (int 1e30)  9223372036854775807)
+    (= (int -1e30) -9223372036854775808)
+    (= (int 0x8000000000000000) (int "0x8000000000000000"))
+    (set 'D:D 12345)
+    (= (int D) 12345)
+))
+
+(define (test-int) (test-integer))
+
+(define (test-integer? )
+  (and
+    (integer? 12345)
+    (integer? 9223372036854775807)
+    (integer? -9223372036854775808)
+    (integer? 0x7FFFFFFFFFFFFFFF)
+    (integer? 0xFFFFFFFFFFFFFFFF)
+))
+
+(define (test-intersect )
+  (and
+    (= (intersect '(3 0 2 4 1) '(1 4 2 5)) '(2 4 1))
+    (set 'L '(a b c d e f))
+    (= (intersect L L) L)
+  )
+)
+
+(define (test-invert )
+  (set 'A '((-1 1 1) (1 4 -5) (1 -2 0)))
+  (set 'I (multiply A (invert A)))
+  (set 'J (multiply (array 3 3 (flat A)) (invert (array 3 3 (flat A)))))
+  (and (< (sub 1 (nth 0 (nth 0 I))) 1e-06)
+       (< (sub 1 (nth 1 (nth 1 I))) 1e-06) 
+       (< (sub 1 (nth 2 (nth 2 I))) 1e-06)
+       (= I (array-list J)) 
+       (not (invert '((0 1 0) (1 0 1) (0 0 0))) )
+))
+
+(define (test-irr )
+  (< (abs (sub (irr '(-1000 500 400 300 200 100)) 0.20272)) 0.0001))
+
+(define (test-join )
+  (and 
+    (= "this is a sentence" (join '("this" "is" "a" "sentence") " ")) 
+    (= "this_is_a_sentence" (join '("this_" "is_" "a_" "sentence")))
+    (= "" (join '()))
+    (= (join '("A" "B" "C") "-") "A-B-C")
+    (= (join '("A" "B" "C") "-" true) "A-B-C-")
+))
+
+(define (test-lambda? )
+  (lambda? qa))
+
+(define (test-last )
+  (= 'f (last '(a b c d e f)))
+  (= "p" (last "newlisp"))
+  (= (array 2 '(5 6)) (last (array 3 2 (sequence 1 6))))
+  ;; default functor
+  (set 'D:D '(a b c d e f g))
+  (= (last D) 'g)
+  (set 'D:D (array 7 '(a b c d e f g)))
+  (= (last D) 'g)
+)
+
+(define (test-last-error)
+    (= (last-error 1) '(1 "not enough memory"))
+)
+
+(define (test-legal?)
+  (and
+    (legal? "abc")
+    (not (legal? "a b c"))
+    (set 'greek (pack "cccccccccccccccccc" 206 160 206 181 206 187 206 181 206 185 206
+                172 206 180 206 181 207 137))
+    (legal? greek)
+))
+
+
+(define (test-length )
+  (> (length (symbols)) 100)
+  (- 7 (length "newlisp")))
+
+(define (test-let )
+  (set 'a 123)
+  (set 'b 456)
+  (set 'p 111)
+  (set 'q 222)
+  (and
+     (let ((a 1) (b 2)) 
+       (= (+ a b) 3))
+     (= a 123) 
+     (= b 456)
+     (let (p 3 q 4)
+       (= (+ q p) 7))
+     (= p 111)
+     (= q 222)
+))
+
+(define (test-letex)
+  (and
+    (= (letex (x '* y 3 z 4) (x y z)) 12)
+    (= (letex (x 1 y 2 z 3) (quote (x y z))) '(1 2 3))
+    (= (letex (x 1 y 2 z 3) '(x y z)) '(1 2 3))
+    (= (letex (x 1 y 2 z 3) '('x (quote y) z)) '('1 (quote 2) 3))
+    (= (letex (x 1) 'x) 1)
+    (set 'x 123 'y 456)
+    (= (letex (x 'y) 'x) 'y)
+    (= (letex (x 'y) x) 456)
+    (= (letex (x '(+ 3 4)) 'x) '(+ 3 4))
+    (= (letex (x '(+ 3 4)) x) 7)
+    ))
+
+(define (test-letn)
+  (set 'x 0 'y 0 'z 0)
+  (and
+      (= (letn ((x 1) (y (+ x 1)) (z (+ y 1))) (list x y z)) '(1 2 3))
+      (= 0 x y z))
+)
+
+(define (test-list )
+  (and (list? (list 1 2 3 4 5)) (= '(1) (list 1)) (= '(1 nil) (list 
+     1 'nil))))
+
+(define (test-list? )
+  (and (list? '(1 2 3 4 5)) (list? '())))
+
+(define (test-local)
+    (set 'a 10 'b 20)
+    (and 
+        (= (local (a b) (set 'a 1 'b 2) (+ a b)) 3)
+        (= a 10)
+        (= b 20)))
+
+(define (test-set-locale) 
+  (list? (set-locale)))
+
+(define (test-log )
+  (and
+    (= 1 (log (exp 1)))
+    (= 1 (log (exp 1) (exp 1)))
+  )
+)
+
+(define (test-lookup )
+  (and 
+    (= 3 (lookup 1 '((2 3 4) (1 2 3)))) 
+    (= 2 (lookup 1 '((2 3 4) (1 2 3)) 1))
+    ; default functor
+    (set 'D:D '((a 1 2 3) (b 4 5 6) (c 7 8 9)))
+    (= 6 (lookup 'b D -1))
+))
+
+(define (test-lower-case )
+   (= "abcdefghijklmnopqrstuvwxyz" (lower-case "ABCDEFGHIJKLMNOPQRSTUVWXYZ")))
+
+(define (test-macro? )
+  (macro? 
+   (define-macro (foo-macro))))
+
+(define (test-main-args )
+  (and 
+     (list? (main-args))
+     (list? $main-args)
+     (= $main-args (main-args))
+     (= ($main-args 0) ((main-args) 0) (main-args 0))
+     (= ($main-args -1) ((main-args) -1))
+     (= ($main-args -1) (main-args -1))
+))
+
+(define (test-make-dir )
+  (and (make-dir "foodir") (remove-dir "foodir")))
+
+(define (test-map )
+  (and (= '(11 22 33) (map + '(10 20 30) '(1 2 3))) 
+       (= '(2 4 6) (map (lambda (x) (+ x x)) '(1 2 3)))
+       (set 'D:D '(1 2 3 4 5))
+       (= (map pow D) '(1 4 9 16 25))
+))
+
+(define (test-mat)
+    (set 'A '((1 2 3) (4 5 6))) 
+    (set 'B A)
+    (and
+        (= (mat + A B) '((2 4 6) (8 10 12)))
+        (= (mat - A B) '((0 0 0) (0 0 0)))
+        (= (mat * A B) '((1 4 9) (16 25 36)))
+        (= (mat / A B) '((1 1 1) (1 1 1)))
+        (= (mat + A 2) '((3 4 5) (6 7 8)))
+        (= (mat - A 2) '((-1 0 1) (2 3 4)))
+        (= (mat * A 2) '((2 4 6) (8 10 12)))
+        (= (mat / A 2) '((0.5 1 1.5) (2 2.5 3)))
+
+        (= (mat + A 5) '((6 7 8) (9 10 11)))
+        (= (mat - A 2) '((-1 0 1) (2 3 4)))
+        (= (mat * A 3) '((3 6 9) (12 15 18)))
+        (= (mat / A 10) '((.1 .2 .3) (.4 .5 .6)))
+
+        (set 'op +)
+        (= (mat op A B) '((2 4 6) (8 10 12)))
+        (set 'op '+)
+        (= (mat op A B) '((2 4 6) (8 10 12)))
+        ; default functor
+        (set 'DA:DA A)
+        (set 'DB:DB B)
+        (= (mat + DA DB) '((2 4 6) (8 10 12)))
+    ))
+
+(define (test-match)
+  (and 
+    (= (match '(a (b ?) d e *) '(a (b c) d e f g) true)   '(a (b c) d e (f g)) )
+    (= (match '(a (b ?) d e *) '(a (b c) d e f g) )  '(c (f g)) )
+
+    (= (match '(a * b x) '(a b c d b x e f b x) true) '(a (b c d b x e f) b x) )
+    (= (match '(a * b x) '(a b c d b x e f b x) ) '((b c d b x e f)) )
+
+
+    (= (match '(? (?) x * ? (? e)) '(a (b) x y c (d e)) true) '(a (b) x (y) c (d e)) )
+    (= (match '(? (?) x * ? (? e)) '(a (b) x y c (d e))) '(a b (y) c d) )
+
+    (= (match '(a * b) '(a x b) true) '(a (x) b) )
+    (= (match '(a * b) '(a x b)) '((x)) )
+
+
+    (= (match '(a * b) '(a b) true) '(a () b) )
+    (= (match '(a * b) '(a b)) '(()) )
+
+    (= (match '( (? ?) * ) '( (x y) ) true) '((x y) ()) )
+    (= (match '( (? ?) * ) '( (x y) )) '(x y ()) )
+    (match '(+) '(a))
+    (match '(+) '(a b))
+    (not (match '(+) '()))
+    ; default functors
+    (set 'P:P '(a (b ?) d e *) )
+    (set 'M:M '(a (b c) d e f g))
+    (true? (match P M))
+  ))
+
+
+(define (test-max )
+  (and (= 10 (max 3 6 10 8)) (= 1.2 (max 0.7 0.6 1.2))))
+
+(define (test-member )
+ (and   
+  (= '(3 4) (member 3 '(1 2 3 4)))
+  (= (member "LISP" "newLISP") "LISP")
+  (= (member "LI" "newLISP") "LISP")
+  (= (member "" "newLISP") "newLISP")
+  (not (member "xyz" "newLISP"))
+  (not (member "new" "this is NEWLISP" 0))
+  (= (member "new" "this is NEWLISP" 1) "NEWLISP")
+  ; default functor
+  (set 'D:D '(1 2 3 4))
+  (= '(3 4) (member 3 D))
+  (set 'D:D "newLISP")
+  (= "LISP" (member "LI" D))
+ )  
+)
+
+(define (test-min )
+  (and (= 3 (min 3 6 10 8)) (= 0.6 (min 0.7 0.6 1.2))))
+
+(define (test-mod )
+  (and (< (sub (mod 10.5 3.3) 0.6) 0.0001) (< (sub (mod 10 3) 1) 0.0001)))
+
+(define (test-mul )
+  (= 1e-09 (mul 0.0001 1e-05)))
+
+(define (test-multiply )
+  (let ((A '((1 2 3) (4 5 6))) (B '((1 2) (1 2) (1 2)))) 
+    (and 
+       (= '((6 12) (15 30)) (multiply A B))
+       (= (array 2 2 (flat '((6 12) (15 30))))
+          (multiply (array 2 3 (flat A)) (array 3 2 (flat  B))))
+    )
+))
+
+(define (test-term )
+  (= "term" (term 'term)))
+
+(define (test-new) 
+  (new QA 'MAIN:QA2))
+
+(define (test-nil?) 
+  (and
+    ;test symbol-nil = logic-nil in order compare of count
+    (= (count '(nil true) (map (curry < 3) '(1 2 4 5))) '(2 2))
+    (= nil (not (nil? nil)))
+    (= '(nil true) (map nil? '(a nil)))))
+
+(define (test-null?)
+    (= (map null? '(1 0 2 0.0 "hello" "" (a b c) () nil true (lambda) (fn) (lambda ())))
+    '(nil true nil true nil true nil true true nil true true nil)))
+
+(define (test-normal )
+  (and (float? (normal)) (float? (normal 10 3)) (list? (normal 10 
+     3 100))))
+
+(define (test-not )
+  (and (not (not (not '()))) (not (not (not (not (not nil))))) (not 
+    (not (not (not true)))) 
+   (= '(true true true) (map not '(nil nil nil))) 
+   (= '(nil nil nil) (map not '(true true true)))))
+
+(define (test-now )
+  (= (length (now)) 11))
+
+(define (test-nper )
+  (< (sub (nper 0.1 1000 100000 0 0) -25.15885793) 1e-08))
+
+(define (test-npv )
+  (< (sub (npv 0.1 '(-10000 3000 4200 6800)) 1188.443412) 1e-06))
+
+(define (test-nth , l)
+    (and 
+        (set 'l '(0 1 2))
+        (= 0 (nth 0 l))
+        (= 1 (nth 1 l))
+        (= 2 (nth 2 l))
+        (= 2 (nth -1 l))
+        (= (nth 0 "lisp") "l")
+        (= (nth 1 "lisp") "i")
+        (= (nth 3 "lisp") "p")
+        (= (nth -4 "lisp") "l")
+        (= (nth 0 "") "")
+        
+        (set 'l '(a b (c d) (e f)))
+        (= 'a (l 0))
+        (= '(c d) (l 2))
+        (= 'c (l 2 0))
+        (= 'f (l -1 -1))
+        (= 'c (l '(2 0)))
+        (= 'f (l '(-1 -1)))
+
+        (set 'myarray (array 3 2 (sequence 1 6)))
+        (= (array 2 '(3 4)) (myarray 1))
+        (= 6 (myarray -1 -1))
+
+        (= (array 2 '(3 4)) (myarray '(1)))
+        (= 6 (myarray '(-1 -1)))
+
+        (= "L" ("newLISP" 3))
+
+        (constant 'constL '((1 2 3) (a b c)))
+        (set 'aref '(1 2))
+        (= (constL 1 2) 'c)
+        (= (nth '(1 2) constL) 'c)
+        (= (nth (list (- 2 1) (+ 1 1)) constL) 'c)
+        (= (nth aref constL) 'c)
+
+        ; default functor
+        (set 'D:D '(a b (c d) (e f)))
+        (= 'a (D 0))
+        (= '(c d) (D 2))
+        (= 'c (D 2 0))
+        (= 'f (D -1 -1))
+        (= 'c (D '(2 0)))
+        (= 'f (D '(-1 -1))) 
+        (= 'a (nth 0 D))
+        (= '(c d) (nth 2 D))
+  ))
+
+(define (test-number?)
+    (and
+        (number? 1)
+        (number? 1.23)
+        (not (number? 'x))
+        (not (number? "abc"))
+        (not (number? '(a b c)))
+    )
+)
+
+
+(define (test-or )
+  (and (or (or (= 1 2) nil nil) (or nil nil nil true)) (not (or nil 
+     (= "a" "b") nil))))
+
+(define (test-pack )
+ (and
+  (= (pack "c c c" 65 66 67) "ABC")
+  (= (unpack "c c c" "ABC") '(65 66 67))
+  (set 's (pack "c d u" 10 12345 56789))
+  (= (unpack "c d u" s) '(10 12345 56789))
+  (set 's (pack "s10 f" "result" 1.23))
+  (= (first (unpack "s10 f" s)) "result\000\000\000\000")
+  (< (- (last (unpack "s10 f" s)) 1.23) 0.00001)
+  (set 's (pack "s3 lf" "result" 1.23))
+  (= (first (unpack "s3 f" s)) "res")
+
+  (= (pack "ccc" 65 66 67) "ABC")
+  (= (unpack "ccc" "ABC") '(65 66 67))
+  (set 's (pack "cdu" 10 12345 56789))
+  (= (unpack "cdu" s) '(10 12345 56789))
+  (set 's (pack "s10f" "result" 1.23))
+  (= (first (unpack "s10f" s)) "result\000\000\000\000")
+  (< (- (last (unpack "s10f" s)) 1.23) 0.00001)
+  (set 's (pack "s3lf" "result" 1.23))
+  (= (first (unpack "s3f" s)) "res")
+
+  (= "\001\000" (pack "<d" 1))
+  (= "\000\001" (pack ">d" 1))
+  (= "\001\000\000\000" (pack "<ld" 1))
+  (= "\000\000\000\001" (pack ">ld" 1))
+  (= '(12345678) (unpack "ld" (pack "ld" 12345678)))
+  (= '(12345678) (unpack "<ld" (pack "<ld" 12345678)))
+  (= '(12345678) (unpack ">ld" (pack ">ld" 12345678)))
+  (= (unpack "bbbbbbbb" (pack "<lf" 1.234)) '(88 57 180 200 118 190 243 63))
+  (= (unpack "bbbbbbbb" (pack ">lf" 1.234)) '(63 243 190 118 200 180 57 88))
+  (= (format "%20.2f" (first (unpack "lf" (pack "lf" 1234567890123456)))) " 1234567890123456.00")
+))
+
+(define (test-parse )
+  (and 
+    (= 3 (length (parse "hello hi there"))) 
+    (= (parse "abcbdbe" "b") '("a" "c" "d" "e")) 
+    (= (parse "," ",") '("" ""))  
+    (= (parse "hello regular   expression 1, 2, 3" {,\s*|\s+} 0)
+       '("hello" "regular" "expression" "1" "2" "3"))))
+
+
+(define (test-date-parse)
+    (and
+        (= (date-parse "2007.1.3" "%Y.%m.%d") 1167782400)
+        (= (date-parse "January 10, 07" "%B %d, %y") 1168387200)
+))
+
+
+(define (test-pmt ) 
+  (< (sub (pmt 0.1 10 100000 0 0) -16274.53949) 1e-05))
+
+(define (test-pop , r l)
+  (set 'r '())
+  (set 'l '(1 2 3 4 5 6 7 8 9 0))
+  (dotimes (x 10) 
+   (push (pop l) r))
+  (and (= r '(0 9 8 7 6 5 4 3 2 1))
+       (set 'l '(a b (c d (x) e)))
+       (= 'x (pop l '(2 2 0)))
+       (set 'lst '(1 2 3 (4 5)()))
+       (push 'x lst -1 -1)
+       (= lst '(1 2 3 (4 5) (x)))
+       (push 'y lst -1 0)
+       (= lst '(1 2 3 (4 5) (y x)))
+       (push 'z lst -1 1)
+       (= lst '(1 2 3 (4 5) (y z x)))
+       (push 'p lst 4)
+       (= lst '(1 2 3 (4 5) p (y z x)))
+       (push 'q lst -2)
+       (= lst '(1 2 3 (4 5) p q (y z x)))
+       (push 'a lst 3 -3)
+       (= lst '(1 2 3 (a 4 5) p q (y z x)))
+       (= (pop lst 3 -3) 'a)
+       (= (pop lst -2) 'q)
+       (= (pop lst 4) 'p)
+       (= (pop lst -1 1) 'z)
+       (= (pop lst -1 0) 'y)
+       (= (pop lst -1 -1) 'x)
+       (= lst '(1 2 3 (4 5)()))
+       ; test pop string
+       (set 's "newLISP")
+       (= (pop s) "n")
+       (= s "ewLISP")
+       (= (pop s 2) "L")
+       (= s "ewISP")
+       (= (pop s -1) "P")
+       (= s "ewIS")
+       (= (pop s -2 2) "IS")
+       (= s "ew")
+       (= (pop s -2 10) "ew")
+       (= s "")
+       (set 's "123456789")
+       (= (pop s 5) "6")
+       (= (pop s 5 -1) "")
+       (= s "12345789")
+       (set 's "123456789")
+       (= (pop s 5 5) "6789")
+       (set 's "x")
+       (= (pop s) "x")
+       (= s "")
+       (= (pop s) "")
+       (= (pop s) "")   
+       (= s "")
+        ; default functor
+        (set 'D:D '(a b (c d (x) e)))
+        (= 'x (pop D '(2 2 0)))
+))
+
+(define (test-pop-assoc)
+    (and
+        (set 'L '((a (b 1) (c (d 2)))))
+        (= (pop-assoc 'a L) '(a (b 1) (c (d 2))))
+        (= L '())
+        (set 'L '((a (b 1) (c (d 2)))))
+        ( = (pop-assoc '(a b) L) '(b 1))
+        (= L '((a (c (d 2)))))
+        (set 'L '((a (b 1) (c (d 2)))))
+        (= (pop-assoc '(a c) L) '(c (d 2)))
+        (= L '((a (b 1))))
+        (set 'L '((a (b 1) (c (d 2)))))
+        (= (pop-assoc (list 'a 'c 'd) L) '(d 2))
+        (= L '((a (b 1) (c))))
+        (= (pop-assoc '(a c) L) '(c))
+        (= L '((a (b 1))))
+        (= (pop-assoc '(a b) L) '(b 1))
+        (= L '((a)))
+        (= (pop-assoc 'a L) '(a))
+        (= L '())
+        ; default functor
+        (set 'D:D '((a (b 1) (c (d 2)))))
+        (= (pop-assoc 'a D) '(a (b 1) (c (d 2))))
+        (= D:D '())
+    )
+)
+
+(define (test-post-url )
+  (= "ERR: bad formed URL" (post-url "" "abc" "def")))
+
+(define (test-pow )
+  (and
+    (= 1024 (pow 2 10))
+    (= 100 (pow 10))
+))
+
+(define (test-pretty-print)
+  (= (pretty-print) '(80 " " "%1.16g")))
+
+(define (test-primitive? )
+  (primitive? primitive?))
+
+(define (test-prob-chi2 )
+  (< (abs (sub (prob-chi2 10 10) 0.440493)) 1e-05))
+
+(define (test-prob-z )
+  (< (abs (sub (prob-z 0) 0.5)) 1e-05))
+
+(define (test-protected?)
+    (and
+        (protected? 'println)
+        (constant 'cval 123)
+        (protected? 'cval)
+        (protected? 'QA))
+)
+
+(define (test-push , l)
+  (dotimes (x 10) 
+   (push x l x))
+  (and 
+       (= l '(0 1 2 3 4 5 6 7 8 9))
+       (set 'l '(a b (c d () e)))
+       (push 'x l '(2 2 0))
+       (= (ref 'x l) '(2 2 0))
+       (set 'lst '(1 2 3 (4 5)()))
+       (push 'x lst -1 -1)
+       (= lst '(1 2 3 (4 5) (x)))
+       (push 'y lst -1 0)
+       (= lst '(1 2 3 (4 5) (y x)))
+       (push 'z lst -1 1)
+       (= lst '(1 2 3 (4 5) (y z x)))
+       (push 'p lst 4)
+       (= lst '(1 2 3 (4 5) p (y z x)))
+       (push 'q lst -2)
+       (= lst '(1 2 3 (4 5) p q (y z x)))
+       (push 'a lst 3 -3)
+       (= lst '(1 2 3 (a 4 5) p q (y z x)))
+       (= (pop lst 3 -3) 'a)
+       (= (pop lst -2) 'q)
+       (= (pop lst 4) 'p)
+       (= (pop lst -1 1) 'z)
+       (= (pop lst -1 0) 'y)
+       (= (pop lst -1 -1) 'x)
+       (= lst '(1 2 3 (4 5)()))
+       (set 'lst '((1)))
+       (push 2 lst -1 -1)
+       (= lst '((1 2)))
+       (test-push-pop)
+       (test-push-optimization-bug)
+       ; test string push
+       (set 's "newLISP")
+       (= (push "#" s) "#newLISP")
+       (= (push "#" s 1) "##newLISP")
+       (= (push "#" s 3) "##n#ewLISP")
+       (= (push "#" s -1) "##n#ewLISP#")
+       (= (push "#" s -3) "##n#ewLIS#P#")
+       (= (push "xy" s) "xy##n#ewLIS#P#")
+       (= (push "xy" s -1) "xy##n#ewLIS#P#xy")
+       (= s "xy##n#ewLIS#P#xy")
+       (set 's "")
+       (= (push "" s) "")
+       (set 's "newLISP")
+       (= (push "" s -1) "newLISP")
+       (= (push "" s) "newLISP")
+       (= s "newLISP")
+       (push "-" s 7)
+       (= s "newLISP-")
+       (push "-" s -9)
+       (= s "-newLISP-")
+       (set 's "newLISP")
+       (= (push "-" s 8) "newLISP-")
+       (= (push "-" s -10) "-newLISP-")
+
+        ; default functor
+        (set 'D:D '(a b (c d () e)))
+        (push 'x D '(2 2 0))
+        (= (ref 'x D) '(2 2 0))
+        (set 'D:D "newLISP")
+        (= (push "#" D:D) "#newLISP")
+        (= D:D "#newLISP")
+        
+))
+
+(define (test-push-pop)
+    ; string
+    (set 's "abcdefg")
+    (= (pop (push "h" s -1)) "a")
+    (= s "bcdefgh")
+)
+
+(define (test-push-optimization-bug) ; fixed in 8.7.1
+    (set 'l nil)
+    (and (push 'x l -1)
+         (set 'lst l)
+         (push 'y lst -1)
+         (= lst '(x y))))
+
+(define (test-put-url ) 
+  (= "ERR: bad formed URL" (put-url "" "abc")))
+
+(define (test-pv )
+  (< (sub (pv 0.1 10 1000 100000 0 0) -44696.89605) 1e-05))
+
+(define (test-quote )
+  (= (quote x) 'x))
+
+(define (test-quote? )
+  (quote? ''quote?))
+
+(define (test-rand , sum)
+  (set 'sum 0)
+  (dotimes (x 1000) 
+   (inc sum (rand 2)))
+  (and (< sum 600) (> sum 400) (list? (rand 10 100))))
+
+(define (test-random )
+  (and (float? (random)) (= (length (random 0 1 10)) 10)))
+
+(define (test-randomize)
+  (and
+    (!= '(a b c d e f g) (randomize '(a b c d e f g)))
+    (= (difference '(a b c d e f g) (randomize '(a b c d e f g))) '())
+  )
+)
+
+(define (test-read-expr , clist) true
+    (set 'code "; a statement\n(define (double x) (+ x x))\n")
+    (= (read-expr code (context)) '(define (double x) (+ x x)))
+)
+
+(define (test-ref)
+  (and
+    (set 'pList '(a b (c d () e)))
+    (push 'x pList 2 2 0)
+    (= (ref 'x pList) '(2 2 0))
+    (= (ref '(x) pList) '(2 2))
+    (set 'v (ref '(x) pList))
+    (= (pList v) '(x))
+    ;(= (ref 'foo pList) '()) changed in 10.2.18
+    (= (ref 'foo pList) nil)
+    ; comparison functor
+    (= (ref 'e '(a b (c d (e) f)) =) '(2 2 0))
+    (= (ref 'e '(a b (c d (e) f)) >) '(0))
+    (= (ref 'e '(a b (c d (e) f)) <) '(2))
+    (= (ref 'e '(a b (c d (e) f)) (fn (x y) (or (= x y) (= y 'd)))) '(2 1))
+    (define (is-it-or-d x y) (or (= x y) (= y 'd)))
+    (= (ref 'e '(a b (c d (e) f)) is-it-or-d) '(2 1))
+    ; comparison with match and unify
+    (= (ref '(a ?) '((l 3) (a 12) (k 5) (a 10) (z 22)) match) '(1))
+    (= (ref '(X X) '( ((a b) (c d)) ((e e) (f g)) ) unify) '(1 0))
+    (= (ref '(X g) '( ((a b) (c d)) ((e e) (f g)) ) unify) '(1 1))
+    ; default functor
+    (set 'D:D '((l 3) (a 12) (k 5) (a 10) (z 22)) )
+    (= (ref '(a ?) D match) '(1))
+))
+
+(define (test-ref-all) 
+  (and
+    (set 'L '(a b c (d a f (a h a)) (k a (m n a) (x))))
+    (= (ref-all 'a L) '((0) (3 1) (3 3 0) (3 3 2) (4 1) (4 2 2)))
+    (= (L '(3 1)) 'a)
+    (= (map 'L (ref-all 'a L)) '(a a a a a a))
+    ; with comparison functor
+    (= (ref-all 'a '(1 2 3 4 5 6)) '())
+    (set 'L '(a b c (d f (h l a)) (k a (m n) (x))))
+    (= (ref-all 'c L =) '((2)))
+    (= (ref-all 'c L >) '((0) (1) (3 2 2) (4 1)))
+    (= (ref-all 'a L (fn (x y) (or (= x y) (= y 'k)))) ' ((0) (3 2 2) (4 0) (4 1)))
+    (define (is-long? x y) (> (length y) 2))
+    (= (ref-all nil L is-long?) '((3) (3 2) (4)))
+    (define (is-it-or-d x y) (or (= x y) (= y 'd)))
+    (= (ref-all 'e '(a b (c d (e) f)) is-it-or-d) '((2 1) (2 2 0)))
+    (= (ref-all 'b '(a b (c d (e) f)) is-it-or-d) '((1) (2 1)))
+    (= (ref-all nil '(((()))) (fn (x y) (> (length y) 0))) '((0) (0 0)))
+    ; test comparison with match and unify
+    (= (ref-all '(a ?) '((l 3) (a 12) (k 5) (a 10) (z 22)) match) '((1) (3)))
+    (= (ref-all '(X X) '( ((a b) (c d)) ((e e) (f g)) ((z) (z))) unify) '((1 0) (2)))
+    (= (ref-all '(X g) '( ((x y z) g) ((a b) (c d)) ((e e) (f g))) unify) '((0) (2 1)))
+))
+
+
+(define (test-regex )
+  (and
+   (= (regex "http://(.*):(.*)" "http://nuevatec.com:80")
+      '("http://nuevatec.com:80" 0 22 "nuevatec.com" 7 12 "80" 20 2))
+   (= $0 "http://nuevatec.com:80")
+   (= $1 "nuevatec.com")
+   (= $2 "80")
+   (= (regex "b+" "AAAABBBAAAA" 1) '("BBB" 4 3))))
+
+(define (test-regex-comp)
+    (and
+        (set 'pattern (regex-comp "http://(.*):(.*)"))
+        (find pattern "http://nuevatec.com:80" 0x10000)
+        (= $0 "http://nuevatec.com:80")
+        (= $1 "nuevatec.com")
+        (= $2 "80")
+    ))
+ 
+ 
+(define (replace-once str)
+  (= (replace "a" str (upper-case $it) 0x8000) "Aaa") ;; custom option replace once
+)
+
+(define (test-replace)
+    (and
+        (set 'str "ababab")
+        (= (replace "a" str "b") "bbbbbb")
+        (set 'lst '(a a b a b a a a b a))
+        (= (replace 'a lst 'b) '(b b b b b b b b b b))
+        (set 'lst '(a))
+        (= (replace 'a lst) '())
+        (set 'str "abc")
+        (= (replace "" str "x" 0) "xaxbxcx")
+        (set 'str "abc")
+        (= (replace "$" str "x" 0) "abcx")
+        (set 'str "abc")
+        (= (replace "^" str "x" 0) "xabc")
+        (set 'str "abc")
+        (= (replace "\\b" str "x" 0) "xabcx")
+        (set 'str "1234567")
+        (= (replace "(?<=[0-9])(?=(?:[0-9]{3})+(?![0-9]))" str "," 0) "1,234,567")
+        (set 'str "ababab")
+        (= (replace "a" str (upper-case $it) 0) "AbAbAb")
+        (= $count 3)
+        (set 'L '(1 4 22 5 6 89 2 3 24))
+        (= (replace 10 L 10 <) '(1 4 10 5 6 10 2 3 10))
+        (set 'L '(1 4 22 5 6 89 2 3 24))
+        (= (replace 10 L 10 (fn (x y) (< x y))) '(1 4 10 5 6 10 2 3 10))
+        (set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+        (= (replace '(mary *)  AL (list 'mary (apply + (rest $it))) match)
+           '((john 5 6 4) (mary 14) (bob 4 2 7 9) (jane 3)))
+        (set 'AL '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+        (= (replace '(*) AL (list ($it 0) (apply + (rest $it))) match)
+        '((john 15) (mary 14) (bob 22) (jane 3)))
+        (set 'AL '((john 5 6 4) ("mary" 3 4 7) (bob 4 2 7 9) ("jane" 3)))
+        (= (replace nil AL (cons (sym ($it 0)) (rest $it)) (fn (x y) (string? (y 0))))
+        '((john 5 6 4) (mary 3 4 7) (bob 4 2 7 9) (jane 3)))
+        ; default functor
+        (set 'D:D '(a a b a b a a a b a) )
+        (= (replace 'a D 'b) '(b b b b b b b b b b))
+        (set 'D:D "abc")
+        (= (replace "" D "x" 0) "xaxbxcx")
+        ; regression for key cell part of list
+        (setq a '(b c d))
+        (= (replace (a 0) a (term (a 0))) '("b" c d))
+        (replace-once "aaa")
+))
+
+(define (test-reset )
+  true)
+
+(define (test-rest , l)
+  (set 'l '(a b c d e f g))
+  (and  (= (cons (first l) (rest l)) l)
+    (= (rest "newlisp") "ewlisp")
+    ;; implicit nrest
+    (= (1 l) '(b c d e f g))
+    (= (10 l) '())
+    (= (0 l) l)
+    (= (-3 '(a b c d e f g)) '(e f g))
+        (= (-3 "abcdefg") "efg")
+    (= (1 '(A)) '())
+    (= (1 "A") "")
+    (= (array 2 2 (sequence 3 6)) (rest (array 3 2 (sequence 1 6))))
+    ;; default functor
+    (set 'D:D '(a b c d e f g))
+    (= (rest D) '(b c d e f g))
+    (set 'D:D (array 7 '(a b c d e f g)))
+    (= (rest D) (array 6 '(b c d e f g)))   
+))
+
+(define (test-reverse )
+  (and
+    (= (reverse '(1 2 3)) '(3 2 1))
+    (= (reverse "newLISP") "PSILwen")
+    (set 'D:D '(1 2 3))
+    (= (reverse D) '(3 2 1))
+    (set 'D:D "newLISP")
+    (= (reverse D) "PSILwen")
+))
+
+(define (test-rotate )
+  (and
+    (= '(8 9 0 1 2 3 4 5 6 7) (rotate '(0 1 2 3 4 5 6 7 8 9) 2))
+    (= '() (rotate '()))
+    (= (rotate '(1) -1) '(1))
+    (= (rotate "") "")
+    (= (rotate "x" -1) "x")
+    (set 'str "abcdefg")
+    (= (rotate str) "gabcdef")
+    (= (rotate str 3) "defgabc")
+    (= (rotate str -4) "abcdefg")
+    (set 'D:D '(0 1 2 3 4 5 6 7 8 9))
+    (= '(8 9 0 1 2 3 4 5 6 7) (rotate D 2))
+))
+
+(define (test-round)
+    (and
+        (= (round 1.25)  (round 1.25 0) 1)
+        (= (round 3.89) (round 3.89 0) 4)
+        (= (round 123.49 2) 100)
+        (= (round 123.49 1) 120)
+        (= (round 123.49 0) 123)
+        (= (round 123.49 -1) 123.5)
+        (= (round 123.49 -2) 123.49)
+        (= (round 123.49 -3) 123.49)
+        (= (round 123.49 3)  0)
+        (= (round 0.05 -1) 0.1)
+        (= (round 0.5) 1)
+        (= (round 5 1) 10)
+))
+
+(define (test-seed )
+  (seed 123)
+  (set 'a (rand 10))
+  (seed 123)
+  (set 'b (rand 10))
+  (= a b))
+
+(define (test-select )
+  (set 'l '(0 1 2 3 4 5 6 7 8 9))
+  (and
+    (test-select-collect)
+    (= (select l '(0 9 9 0 1 8 8 1)) '(0 9 9 0 1 8 8 1))
+    (= (select "2001-09-20" '(5 6 8 9 0 1 2 3)) "09202001")
+    ; default functor
+    (set 'D:D '(0 1 2 3 4 5 6 7 8 9))
+    (= (select D '(0 9 9 0 1 8 8 1)) '(0 9 9 0 1 8 8 1))
+))
+
+(define (test-sequence )
+  (= (sequence 1 10 3) '(1 4 7 10)))
+
+(define (test-series )
+  (and
+    (= (series 2 2 5) '(2 4 8 16 32))
+    (= (series 2 2 0) '())
+    (= (series 1 2 -10) '())
+    (= (series 1 1 5) '(1 1 1 1 1))
+))
+
+(define (test-set , x y z)
+  (set 'x (set 'y (set 'z 123)))
+  (= x 123))
+
+(define (test-setf)
+ (and
+    (setf l '(a b c d e f g))
+    (setf (nth 3 l) 999)
+    (= l '(a b c 999 e f g))
+    (set 's "abcdefg")
+    (setf (s 3) (upper-case $it))
+    (= s "abcDefg")
+    (set 's "a-b-c-d-e-f-g")
+    (setf (first (replace "-" s "")) (upper-case $it))
+    (= s "Abcdefg")    
+))
+
+
+(define (test-setq , x y z)
+  (setq x 1 y 2 z 3)
+  (and (= x 1) (= y 2) (= z 3)))
+
+
+(define (test-set-ref)
+    (and
+        (set 'L '(z a b (z) (d (c c (c)) e f c))) 
+        (= (set-ref 'c L 'z) '(z a b (z) (d (z c (c)) e f c)))
+        (set 'L '((a 1) (b 2) (a 3) (b 4))) 
+        (= (set-ref '(a *) L '(z 99) match) '((z 99) (b 2) (a 3) (b 4)))
+        (= (set-ref '(a *) L '(z 99) match) '((z 99) (b 2) (z 99) (b 4)))
+        (set 'Ct:Ct '(a b c d e f g))
+        (= (set-ref  'c Ct 'z) '(a b z d e f g))
+        ; default functor
+        (set 'D:D '(z a b (z) (d (c c (c)) e f c))) 
+        (= (set-ref 'c D 'z) '(z a b (z) (d (z c (c)) e f c)))
+    )
+)
+
+
+(define (test-set-ref-all)
+    (and
+        (set 'L '(z a b (c) (d (c c (c)) e f c))) 
+        (= (set-ref-all 'c L 'z) '(z a b (z) (d (z z (z)) e f z)))
+        (set 'L '((a 1) (b 2) (a 3) (b 4)))
+        (= (set-ref-all '(a *) L '(z 99) match) '((z 99) (b 2) (z 99) (b 4)))
+    )
+)
+
+(define (test-sgn)
+ (and
+   (= 0 (sgn 0))
+   (= 1 (sgn 123))
+   (= -1 (sgn -3.5))))
+
+(define (test-sin )
+  (= 1 (sin (asin (sin (asin 1))))))
+
+(define (test-sinh)
+    (< (abs (sub (tanh 1) (div (sinh 1) (cosh 1))))  0.0000000001)
+)
+
+(define (test-slice )
+(and 
+   (set 'str "0123456789")
+   (= (slice str 0 1) "0") 
+   (= (slice str 0 3) "012") 
+   (= (slice str 8 2) "89") 
+   (= (slice str 8 10) "89") 
+   (= (slice str 20 10) "")
+   (= (slice str 2 -2) "234567")
+   (= (slice str 2 -5) "234")
+   (= (slice str 2 -7) "2")
+   (= (slice str 2 -8) "")
+   (= (slice str 2 -9) "")
+   (= (slice '(a b c d e f g) 3 1) '(d))
+   (= (slice '(a b c d e f g) 3 0) '())
+   (= (slice '(a b c d e f g) 0 0) '())
+   (= (slice '(a b c d e f g) 10 10) '())
+   (= (slice '(a b c d e f g) 3 2) '(d e))
+   (= (slice '(a b c d e f g) 5) '(f g))
+   (= (slice '(a b c d e f g) -5 2) '(c d))
+   (= (slice '(a b c d e f g) -1 -2) '())
+   (= (slice '(a b c d e f g) 1 -2) '(b c d e))
+   (= (slice '(a b c d e f g) 4 -2) '(e))
+   (= (slice '(a b c d e f g) 4 -3) '())
+   (= (slice '(a b c d e f g) 4 -4) '())
+   (= (slice '(a b c d e f g) -6 -3) '(b c d))
+;; implicit slice
+   (= (1 3 '(a b c d e f g)) '(b c d))
+   (= (-4 2 '(a b c d e f g)) '(d e))
+   (= (1 3 "abcdefg") "bcd")
+   (= (-4 2 "abcdefg") "de")
+   (= (1 -3 "abcdefg") "bcd")
+   (= (1 -5 "abcdefg") "b")
+   (=  (1 -7 "abcdefg") "")
+   (setq x 1 y 2)
+   (= (x y '(a b c d e f g)) '(b c))
+   (= (x y "abcdefg") "bc")
+   (= (1 -2 '(a b c d e f g)) '(b c d e))
+   (= (4 -2 '(a b c d e f g)) '(e))
+   (= (4 -3 '(a b c d e f g)) '())
+   (= (4 -4 '(a b c d e f g)) '())
+   (= (-6 -3 '(a b c d e f g)) '(b c d))
+
+   ; default functor
+   (set 'D:D "0123456789")
+   (= (slice D 0 1) "0") 
+   (= (slice D 0 3) "012") 
+   (set 'D:D '(a b c d e f g))
+   (= (slice D 3 1) '(d))
+   (= (1 3 D) '(b c d))
+))
+
+(define (test-sort )
+  (and
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5)))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5) <))
+    (= '(1 2 3 4 5 6 7 8 9) (sort '(9 1 8 2 7 3 6 4 5) (fn (x y) (< x y))))
+  )
+)
+
+(define (test-source) 
+  (= (replace "\r|\n" (source 'test-sin) "" 0) 
+     "(define (test-sin )  (= 1 (sin (asin (sin (asin 1))))))"))
+
+(define (test-sqrt )
+  (and (= 10 (sqrt 100)) (= 1.2 (sqrt 1.44))))
+
+(define (test-starts-with )
+  (and 
+    (starts-with "newlisp" "new") 
+    (starts-with "newlisp" "NEW" 1)
+    (set 'D:D "newlisp")
+    (starts-with D "new") 
+    (starts-with D "NEW" 1)
+))
+
+(define (test-string )
+  (and (string? (string 12345)) (= (string 12345) "12345") (string? 
+    (string 1.234)) 
+   (= (string 'test-string) "test-string") 
+   (string? (string test-string)) 
+   (= (string "a" "b" "c") (append "a" "b" "c") "abc") 
+   (= (string "a" 123 "b") "a123b")))
+
+(define (test-string? )
+  (and (string? "1234") (not (string? 1234))))
+
+(define (test-sub )
+  (= 0 (sub 0.99999999 0.99999999))
+  (= -123 (sub 123)))
+
+(define (test-swap )
+  (and 
+    ; new (swap <place1> <place2>) in 10.0.3
+    (set 'lst '(1 2 3 4))
+    (= (swap (first lst) (last lst)) 1)
+    (= lst '(4 2 3 1))
+    (= (swap (lst 0) (lst -1)) 4)
+    (= lst '(1 2 3 4))
+    (set 'A (array 2 3 (sequence 1 6)))
+    (= (swap (A 0 0) (A -1 -1)) 1)
+    (= A (array 2 3 (flat '((6 2 3) (4 5 1)))))
+    (set 'lst '(a b c d))
+    (set 'x 'z)
+    (= (swap (lst 0) x) 'a)
+    (= lst '(z b c d))
+    (= x 'a)
+  )
+)
+
+(define (test-sym)
+  (and (= (sym "test-sym") 'test-sym) 
+       (= (sym "test-sym" 'QA) 'test-sym)))
+
+(define (test-symbol? )
+    (and
+        (symbol? (sym "test-symbol"))
+        (symbol? (sym "a b"))
+))
+
+(define (test-symbols )
+  (and (list? (symbols)) (> (length (symbols)) 0)))
+
+(define (test-sys-error) (sys-error 1))
+
+(define (test-sys-info )
+   (and (list? (sys-info)) (= (length (sys-info)) 10)))
+
+(define (test-tan )
+  (> 1 (tan (atan (tan (atan 1))))))
+
+(define (test-tanh)
+    (< (abs (sub (sinh 1) (div (sub (exp 1) (exp -1)) 2))) 0.0000000001)
+)
+
+
+(define (test-time )
+  (float? (time)))
+
+(define (test-time-of-day )
+  (float? (time-of-day)))
+
+(define (test-trace )
+  (trace nil)
+  (= nil (trace)))
+
+(define (test-trace-highlight )
+  (trace-highlight "#" "#"))
+
+(define (test-transpose )
+ (and
+  (= '((1) (2) (3)) (transpose '((1 2 3))))
+  (= '((a b) (c d) (e f)) (transpose '((a c e) (b d f))))
+  (= '((a d f) (b e g) (c nil nil)) (transpose '((a b c) (d e) (f g))))
+  (= '((a c f) (b d g)) (transpose '((a b) (c d e) (f g))))
+;; transpose arrays
+  (set 'A (array 2 3 (sequence 1 6)))
+  (= (array-list (transpose A)) '((1 4) (2 5) (3 6))) 
+))
+
+(define (test-trim )
+  (and 
+    (= (trim "    hello    ") "hello") 
+    (= (trim "----hello----" "-") "hello")
+    (= (trim "----hello====" "-" "=") "hello")
+    (= (trim "000012345" "0" "") "12345")))
+
+(define (test-true?)
+ (= (map true? '(x nil  1 nil "hi" ())) '(true nil true nil true nil)))
+
+(define (test-unique )
+  (= (unique '(2 3 4 4 6 7 8 7)) '(2 3 4 6 7 8)))
+
+(define (test-unify) 
+    (and
+        (= (unify 'X 123) '((X 123)))
+        (= (unify '(Int Flt Str Sym Lst) '(123 4.56 "Hello" s '(a b c)))
+                  '((Int 123) (Flt 4.56) (Str "Hello") (Sym s) (Lst '(a b c))))
+        (= (unify 'A 'A) '())
+        (= (unify '(A B "hello") '("hi" A Z)) '((A "hi") (B "hi") (Z "hello")))
+        (= (unify '(A B) '(B abc)) '((A abc) (B abc)))
+        (= (unify '(B A) '(abc B)) '((B abc) (A abc)))
+        (= (unify '(A A C D) '(B C 1 C)) '((B 1) (A 1) (C 1) (D 1)))
+        (= (unify '(D C A A) '(C 1 C B)) '((D 1) (C 1) (B 1) (A 1)))
+        (= (unify '(f A) '(f (a b c))) '((A (a b c))))
+        (= (unify '(A f) '((a b c) f)) '((A (a b c))))
+        (= (unify '(f (g A)) '(f B)) '((B (g A))))
+        (= (unify '(p X Y a) '(p Y X X)) '((Y a) (X a)))
+        (= (unify '(p X Y) '(p Y X)) '((Y X)))
+        (= (unify '(q (p X Y) (p Y X)) '(q Z Z)) '((Y X) (Z (p X X))))
+        (= (unify '(f (g A) A) '(f B xyz)) '((B (g xyz)) (A xyz)))
+        (= (unify '(A (g abc)) '(B A)) '((B (g abc)) (A (g abc))))
+        ;; with additional environment list
+        (= (unify '(A (B) X) '(A (A) Z) '((A 1) (Z 4)))
+           '((A 1) (Z 4) (B 1) (X 4)))
+))
+
+(define (test-unless )
+    (and 
+        (= (unless nil (set 'x 1) (set 'y 2) (set 'z 3)) 3)
+        (= x 1) (= y 2) (= z 3)
+        (= (unless 123) 123)
+        (= (unless true) true)
+        (= (unless nil) nil)
+))
+
+(define (test-unpack )
+  (= (pack "c c c" 65 66 67) "ABC")
+  (= (unpack "c c c" "ABC") '(65 66 67)))
+
+(define (test-until , x)
+  (set 'x 0)
+  (= 10 (until (= x 10) (inc x)) x))
+
+(define (test-do-until , x)
+  (set 'x 0)
+  (and 
+   (= 10 (do-until (= x 10) (inc x)) x)
+   (= 11 (do-until (> x 0) (inc x)) x)
+))
+
+(define (test-upper-case )
+    (= (upper-case "abcdefghijklmnopqrstuvwxyz") "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+
+(define (test-uuid)
+    (= 36 (length (uuid))))
+
+(define (test-when)
+    (and 
+        (= (when true (set 'x 1) (set 'y 2) (set 'z 3)) 3)
+        (= x 1) (= y 2) (= z 3)
+        (= (when 123) 123)
+        (= (when nil) nil)
+        (= (when true) true)
+))
+
+(define (test-while , x)
+  (and
+    (set 'x 0)
+    (= 100 (while (< x 100) (inc x)) x)
+))
+
+(define (test-do-while, x)
+  (and
+    (set 'x 0)
+    (= 100 (do-while (< x 100) (inc x)) x)
+    (= 101 (do-while (< x 100) (inc x)) x)
+))
+
+(define (test-write-buffer )
+  (set 'str "")
+  (dotimes (x 5) (write-buffer str "hello"))
+  (set 'Bf:Bf "")
+  (set 'S:S "hello")
+  (dotimes (x 5) (write-buffer Bf S))
+  (and 
+    (= str "hellohellohellohellohello")
+    (= Bf:Bf str)
+))
+
+(define (test-write-line ) 
+  (and
+    (set 'Bf:Bf "")
+    (set 'S:S "hello world")
+    (write-line Bf S)
+    (if (find ostype '("Windows" "OS/2"))
+        (= Bf:Bf "hello world\r\n")
+        (= Bf:Bf "hello world\n"))
+))
+
+
+(define (test-xfer-event)
+  (not (xfer-event)))
+
+(define (test-xml-parse )
+  (= (xml-parse "<hello att='value'></hello>") '(("ELEMENT" "hello" 
+     (("att" "value")) 
+     ()))))
+
+(define (test-xml-type-tags )
+  (length (xml-type-tags) 4))
+
+(define (test-zero?)
+  (= (map zero? '(1 0 1.2 0.0)) '(nil true nil true)))
+
+(define (test-| )
+  (= (| -1431655766 1431655765) -1))
+
+(define (test-~ )
+  (and
+    (= (~ 0) -1)
+    (if 
+        (find ostype '("Windows" "OS/2"))
+        (= (format "%I64x" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f")
+
+        (= ostype "True64Unix")
+        (= (format "%lx" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f")
+
+        (= (format "%llx" (~ 0xa0a0a0a0a0a0a0a0)) "5f5f5f5f5f5f5f5f"))
+))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; MAIN ENTRY POINT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; this is only run to get a calibrated 'primes' table
+; after running this replace the primes table in this code
+(when (find "calibrate" (main-args))
+    (calibrate) 
+    (exit)
+)
+
+
+
+;display-html only occurs in Emsripten compiled newLISP
+(set 'Emscripten display-html)
+
+;; for Emscripten take out throw and throw-error, they suppress output on console
+(when Emscripten
+    (when (set 'pos (find '(throw ?) QA:primes match) )
+        (pop QA:primes pos) )
+    (when (set 'pos (find '(throw-error ?) QA:primes match) )
+        (pop QA:primes pos) )
+)
+
+;; test everything
+(println)
+(set 'report-flag nil)
+(set 'errors '())
+(set 'result (time (qa)))
+(if errors
+    (dolist (f errors) (println "->" f))
+    (println (length primes) " non I/O functions performed SUCCESSFUL in " result  " ms")
+)
+
+
+;; benchmark
+(println)
+(println ">>>>> Benchmarking all non I/O primitives ... (may take a while)")
+(set 'report-flag (or Emscripten (find "report" (main-args))))
+(if Emscripten
+    (set 'multiplier 0.2 'adjust  1.22)
+    (set 'multiplier 1 'adjust  1.03)
+)
+
+(set 'total-time (bench))
+
+(println ">>>>> total time: " total-time)
+(inc total-time (mul 0.5 (length primes)))
+(println (format 
+">>>>> Performance ratio:%5.2f (1.0 on MacOSX 10.9, 2.3GHz Intel Core i5, newLISP v10.6.0-64-bit)"
+    (round (div (div total-time adjust) (mul 10 (length primes)) multiplier) -2)))
+
+(context 'MAIN)
+(sys-info)
+; don't exit when  running Emscrypten
+(if (zero? (& (sys-info -1) 0x800)) (exit))
+;; eof
+
+
+
diff --git a/qa-specific-tests/qa-bigint b/qa-specific-tests/qa-bigint
new file mode 100644
index 0000000..59f6d32
--- /dev/null
+++ b/qa-specific-tests/qa-bigint
@@ -0,0 +1,186 @@
+; test big integer operators
+
+(unless bigint
+    (println "big integers not enabled in this version")
+    (exit))
+
+(println ">>>>> testing big ints arithmetik ... ")
+
+(set-locale "C")
+
+;; check embedded bigint 0's
+
+(set 'nums '(
+; aligned
+ 12345678901000000000L
+ 123456789010000000001234567890L
+ 123456789010000000000000000001234567890L
+ 123456789010000000000000000000L
+ 123000000000000000000000000000L
+ 123000000000000000001L
+; not aligned
+ 123456789010000000000L
+ 1234567890100000000001234567890L
+ 1234567890100000000000000000000L
+ 1230000000000000000000000000000L
+ 1230000000000000000001L
+ 1234578901000000000L
+ 12345789010000000001234567890L
+ 12345789010000000000000000000L
+ 123000000000000000000000000L
+ 123000000000000001L
+))
+
+(dolist (num nums)
+    (unless (= (/ num 1) num)
+        (println num)
+        (println ">>>>> ERROR in big integer zeros")
+        (exit))
+)
+
+; some special cases
+(unless (and
+    (= (/ 1234567890123456789012345678901234567890 12345678901234567890) 100000000000000000001L)
+    (= (/ 1234567890L 12345L) 100005L)
+    (= (/ 1234567891L 1234567890L) 1L)
+    (= (/ 1234567890L 1234567890L) 1L)
+    (= (/ 888888888888888888888888888888888888888888888888888888888888888888888888
+          888888888888888888888888888888888888888888888888888888888888889) 999999999L)
+    (= (/ 888888888888888888888888888888888888888888888888888888888888888888888888
+          888888888888888888888888888888888888888888888888888888888888888) 1000000000L)
+    (= (/ 888888888888888888888888888888888888888888888888888888888888888888888888
+          888888888888888888888888888888888888888888888888888888888888887) 1000000000L)
+    (= (/ 11111111111111111L 11111111111111111L) 1L) ; problems with gcc optimizations on Linux
+    (= (/ 22222222222222222L 22222222222222222L) 1L) 
+    (= (/ 44444444444444444L 44444444444444444L) 1L) 
+    (= (/ 88888888888888888L 88888888888888888L) 1L) 
+    (= (/ 99999999999999999L 99999999999999999L) 1L)  )
+        (println ">>>>> ERROR in special cases")
+            (exit)
+)
+
+(seed 5212011)
+
+(if (> (length (main-args)) 2)
+    (set 'N (int (main-args -1)))
+    (set 'N 100000))
+
+(if eval-string-js (set 'N 1000)) ; for JavaScript compiled newLISP
+
+(dotimes (i N)
+    (set 'f (pow (random 10 100) (+ 15 (rand 50))))
+    (set 'f1 (float (bigint f)))
+    (unless eval-string-js 
+        (when (= i (* (/ i 1000) 1000)) (print ".")))
+    ;(println "=>" (sub (abs (div f f1)) 1.0))
+    (unless (<= (abs (sub (abs (div f f1)) 1.0)) 0.000000001)
+       (println f "   " f1 " " (abs (sub (abs (div f f1)) 1)))
+       (println ">>>>> ERROR in big integer/float conversion")
+       (exit))
+)
+(println)
+(define (get-bignum n , num)
+    (set 'num (amb "-" ""))
+    (if (zero? n) (++ n))
+    (dotimes (i n)
+        (extend num (string (+ (rand 1000) 1))))
+    (extend num (dup (string (rand 10)) (rand 10)))
+    (extend num "L")
+    (bigint num))
+        
+(dotimes (i N)
+    (setq x (get-bignum (rand 30)))
+    (setq y (get-bignum (rand 30)))
+    ;(println "x=" x " y=" y)
+    (unless eval-string-js 
+        (when (= i (* (/ i 1000) 1000)) (print ".")))
+    (unless (= (zero? x) (= x 0))
+        (println ">>>>> ERROR in zero? for x = " x)
+        (exit))
+
+    (unless (and
+        (= (/ x x) 1L)
+        (= (/ y y) 1L)
+        )
+            (println ">>>>> ERROR in x/x y/y " x " " y)
+            (exit))
+    
+    (setq x+y (+ x y))
+    (setq x-y (- x y))
+
+    (setq x*y (* x y))
+    (setq x/y (/ x y))
+
+    (set 'xx x)
+    (unless (= (++ xx y) x+y)
+        (println ">>>>> ERROR in ++ with " x " " y)
+        (exit))
+
+    (set 'xx x)
+    (unless (= (-- xx y) x-y)
+        (println ">>>>> ERROR in -- with " x " " y)
+        (exit))
+
+    (unless (and (= (- x+y y) x) (= (- x+y x) y) (= (+ x-y y) x) ) 
+            (println ">>>>> ERROR in +, - with " x " " y)
+            (exit))
+
+    (unless (and (= (/ x*y x) y) (= (/ x*y y) x)) 
+        (println ">>>>> ERROR in * / with:\n" x "\n" y "\nat: " i)
+        (println "x*y / x ->" (/ x*y x) )
+        (println "x*y / y ->" (/ x*y y) )
+        (exit))
+
+    (unless (= (% x y) (- x (* x/y y)))
+            (println ">>>>> ERROR in %, * , / operation with " x " " y)
+            (exit))
+
+    (when (> (abs x/y) 0)
+        ;(println x " " y " remainder " (- (abs x) (* (abs x/y) (abs y))))
+        (unless (< (- (abs x) (* (abs x/y) (abs y))) (abs y))
+            (println ">>>>> ERROR in abs, -, *, - with " x " " y)
+            (exit))
+    )
+
+)
+(println)
+
+; gcd for bigint
+; from http://bit-player.org/2013/the-keys-to-the-keydom
+; and: http://en.wikipedia.org/wiki/Euclidean_algorithm
+
+(set 'x  123784517654557044204572030015647643260197571566202790882488143432336664289530131607571273603815008562006802500078945576463726847087638846268210782306492856139635102768022084368721012277184508607370805021154629821395702654988748083875440199841915223400907734192655713097895866822706517949507993107455319103401)
+
+(set 'y  139752806258570179719657334941265463008205415047073349942370461270597321020717639292879992151626413610247750429267916230424010955054750502833517070395986289724237112410816000558148623785411568845517146303421384063525091824898318226175234193815950597041627518140906384889218054867887058429444934835873139133193) 
+
+(define (gcd-big a b)
+	(if (= b 0) a (gcd-big b (% a b))))
+
+(define (gcd-big a b , t)
+	(until (= b 0)
+		(set 't b)
+		(set 'b (% a b))
+		(set 'a t)
+	)) 
+
+(set 'f 10704679319376067064256301459487150226969621912489596482628509800922080318199635726117009340189103336170841315900354200725312700639146605265442630619090531)
+
+(unless (= (gcd x y) f)
+    (println ">>>>> ERROR in big integer gcd") 
+    (exit))
+
+(unless (= (length 1234567890123456789012345) 25)
+    (println ">>>>> ERROR in big integer length") 
+    (exit))
+
+(dotimes (i 1000)
+    (unless (= (gcd i (- 1000 i)) (gcd (bigint i) (- 1000 i)))
+        (println ">>>>> ERROR in gcd to bigint gcd comparison")))
+
+;;(println ">>> big int gcd benchmark " (time (gcd x y) 1000) " micro secs")
+
+(println ">>>>> abs bigint float gcd length zero? + - * / % ++ -- big ints tested SUCCESSFUL")
+
+(exit)
+
+;; eof    
diff --git a/qa-specific-tests/qa-bigint-bench b/qa-specific-tests/qa-bigint-bench
new file mode 100755
index 0000000..27fa0d1
--- /dev/null
+++ b/qa-specific-tests/qa-bigint-bench
@@ -0,0 +1,65 @@
+#!/usr/bin/env newlisp
+
+(set 'x1 12345678901234567890L)
+(set 'y1 1234567890L)
+(set 'x2 1234567890123456789012345678901234567890L)
+(set 'y2 12345678901234567890L)
+(set 'x3 123456789012345678901234567890123456789012345678901234567890L)
+(set 'y3 123456789012345678901234567890L)
+(set 'x4 12345678901234567890123456789012345678901234567890123456789012345678901234567890L)
+(set 'y4 1234567890123456789012345678901234567890L)
+(set 'x5 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890L)
+(set 'y5 12345678901234567890123456789012345678901234567890L)
+
+(set 'x6 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890L)
+(set 'x7 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890L)
+(set 'x8 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890L)
+(set 'x9 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890L)
+
+(set 'start-time (time-of-day))
+
+(println " 20+10 " (time (+ x1 y1) 1000000))
+(println " 40+20 " (time (+ x2 y2) 1000000))
+(println " 60+30 " (time (+ x3 y3) 1000000))
+(println " 80+40 " (time (+ x4 y4) 1000000))
+(println "100+50 " (time (+ x5 y5) 1000000))
+(println)
+(println " 20-10 " (time (- x1 y1) 1000000))
+(println " 40-20 " (time (- x2 y2) 1000000))
+(println " 60-30 " (time (- x3 y3) 1000000))
+(println " 80-40 " (time (- x4 y4) 1000000))
+(println "100-50 " (time (- x5 y5) 1000000))
+(println)
+(println " 20*10 " (time (* x1 y1) 1000000))
+(println " 40*20 " (time (* x2 y2) 1000000))
+(println " 60*30 " (time (* x3 y3) 1000000))
+(println " 80*40 " (time (* x4 y4) 1000000))
+(println "100*50 " (time (* x5 y5) 1000000))
+(println)
+(println " 20/10 " (time (/ x1 y1) 1000000))
+(println " 40/20 " (time (/ x2 y2) 1000000))
+(println " 60/30 " (time (/ x3 y3) 1000000))
+(println " 80/40 " (time (/ x4 y4) 1000000))
+(println "100/50 " (time (/ x5 y5) 1000000))
+(println)
+(println "100+100 " (time (+ x5 x5) 1000000))
+(println "100-100 " (time (- x5 x5) 1000000))
+(println "100*100 " (time (* x5 x5) 1000000))
+(println "100/100 " (time (/ x5 x5) 1000000))
+(println)
+
+(println " 20*20  " (time (* x1 x1) 1000000))
+(println " 40*40  " (time (* x2 x2) 1000000))
+(println " 60*60  " (time (* x3 x3) 1000000))
+(println " 80*80  " (time (* x4 x4) 1000000))
+(println "100*100 " (time (* x5 x5) 1000000))
+(println "120*120 " (time (* x6 x6) 1000000))
+(println "140*140 " (time (* x7 x7) 1000000))
+(println "160*160 " (time (* x8 x8) 1000000))
+(println "200*200 " (time (* x9 x9) 1000000))
+
+(println "\ntotal time: " (- (time-of-day) start-time) "ms")
+(exit)
+
+
+
diff --git a/qa-specific-tests/qa-blockmemory b/qa-specific-tests/qa-blockmemory
new file mode 100755
index 0000000..a789398
--- /dev/null
+++ b/qa-specific-tests/qa-blockmemory
@@ -0,0 +1,41 @@
+#!/usr/bin/newlisp
+
+
+(println)
+(println "Testing cell block allocation and deallocation:")
+
+b1 b2 b3 b4 initial
+
+(seed (time-of-day))
+(define (run)
+	(set 'initial (sys-info 0))
+	(println "initial cell count:" initial)
+	(set 'b1 (sequence 1 (+ 10000 (rand 10000))))
+	(println "cell count after b1:" (sys-info 0))
+	(set 'b2 (sequence 1 (+ 10000 (rand 10000))))
+	(println "cell count after b2:" (sys-info 0))
+	(set 'b3 (sequence 1 (+ 10000 (rand 10000))))
+	(println "cell count after b3:" (sys-info 0))
+	(set 'b4 (sequence 1 (+ 10000 (rand 10000))))
+	(println "cell count after b4:" (sys-info 0))
+
+	(set 'b2 nil)
+	(println "return b2, cell count:" (sys-info 0) ", block count:" (reset nil))
+	(set 'b4 nil)
+	(println "return b4, cell count:" (sys-info 0) ", block count:" (reset nil))
+	(set 'b1 nil)
+	(println "return b1, cell count:" (sys-info 0) ", block count:" (reset nil))
+	(set 'b3 nil)
+	(println "return b3, cell count:" (sys-info 0) ", block count:" (reset nil))
+
+    (= initial (sys-info 0))
+)
+
+(if (run)
+	(println ">>>>> Memory allocation/deallocation SUCCESSFUL")
+	(println ">>>>> PROBLEM in memory allocation/deallocaton"))
+	
+(exit)
+
+
+
diff --git a/qa-specific-tests/qa-broadcast b/qa-specific-tests/qa-broadcast
new file mode 100644
index 0000000..471c69e
--- /dev/null
+++ b/qa-specific-tests/qa-broadcast
@@ -0,0 +1,3 @@
+newlisp -e '(net-receive (net-listen 3000 "" "udp") buff 10) (if (= buff "hello") "broadcast Ok" "broadcast Problem")' &
+newlisp -e '(net-send (net-connect "10.0.0.255" 3000 "broadcast") "hello")'
+
diff --git a/qa-specific-tests/qa-cellleak b/qa-specific-tests/qa-cellleak
new file mode 100644
index 0000000..bf1ecdf
--- /dev/null
+++ b/qa-specific-tests/qa-cellleak
@@ -0,0 +1,47 @@
+; check for cell leaks
+; to discover the source of the cell leak
+; limit the script changing the line:
+;   (if (and (primitive? (eval sm)) (< sm 'zzzz))
+; in procedure (qa) defined around line 160
+
+
+(write-line 2 "Testing for cell leaks, wait ...")
+
+(println [text]
+If this test reports cell leaks, but also shows errors during 
+the execution of the qa-dot script then run again. If qa-dot runs
+fine on its own but shows error during repeated execution in this 
+script, it is because of syncronization errors when freeing 
+file resources. This seems to ccur only on Windows. In this case 
+try running again or test on a less busy, faster system.
+[/text])
+
+(set 'do-not-exit true) ; avoids exit
+(set 'testing-cell-leaks true) ; avoids output to the console
+
+(println "loading and running qa-dot 1")
+(silent (load "qa-dot"))
+
+(set 'before (sys-info 0)) ; do not delete
+(set 'after (sys-info 0))  ; adjusting cellcount
+
+(println "loading and running qa-dot 2")
+(silent (load "qa-dot"))
+
+(println (sys-info))
+(set 'before (sys-info 0))
+
+(println "loading and running qa-dot 3")
+(silent (load "qa-dot"))
+
+(println (sys-info))
+(set 'after (sys-info 0))
+
+(if (= (abs (- before after)) 0)
+    (write-line 2 ">>>>> cell leaks test passed SUCCESSFUL")
+    (write-line 2 ">>>>> ERROR: cell leak discovered"))
+
+(exit)
+
+
+
diff --git a/qa-specific-tests/qa-cilk b/qa-specific-tests/qa-cilk
new file mode 100755
index 0000000..6fe50f9
--- /dev/null
+++ b/qa-specific-tests/qa-cilk
@@ -0,0 +1,88 @@
+#!/usr/bin/newlisp
+
+; note that run fibonacci with Cilk is not a good idea
+; in the real world, but it tests well the integrity
+; of the interface when applying Cilk calls recursively
+; because each call to (fibo x) branches into two other
+; calls and each caller maintains it's own list
+; of spawned processes, which it has to finish with sync
+
+; n    fibo(n) processes
+; 4     5      9
+; 5     8      15
+; 6    13      25
+; 7    21      41
+; 8    34      67
+; 9    55      109
+;10    89      177
+
+
+(when (find ostype '("Windows"))
+	(exit))
+
+(println)
+(println "Testing Cilk API")
+
+(define (fibo n)
+  (local (f1 f2)
+    (if(< n 2) 1
+		(begin 
+			(spawn 'f1 (fibo (- n 1)))
+			(spawn 'f2 (fibo (- n 2)))
+			(println "wait/sync up to 20 secs")
+			(sync 20000)
+			(+ f1 f2)))))
+
+(if (not fork) ; does not have fork
+  (if (= (fibo 7) 21) 
+	(println ">>>>> CILK API TESTED SUCCESSFUL ---")
+	(println ">>>>> PROBLEM with Cilk API")
+))
+
+(if (not fork) (exit))
+
+; spawn 10 processes than abort them all one by one
+(time (spawn 'x (sleep 100)) 10)
+
+(set 'result0 (map abort (sync)))
+
+; create 10 processes then abort all at once
+(time (spawn 'x (sleep 100)) 10)
+(println "(abort) -> " (set 'result1 (abort)))
+(println "(sync)  -> " (set 'result2  (sync)))
+
+; create 10 processes then wait for them to finish
+(time (spawn 'x (sleep 100)) 10)
+(println "(sync) -> " (sync))
+(println "N of processes -> " (set 'result3 (length (sync))))
+(println "waiting  to sync -> " (set 'result4 (sync 5000)))
+
+(println "fibo(5) -> (needs 15 processes) => " (set 'result5 (fibo 5)))
+
+; check inlet function
+(define (inlet pid) 
+	(println "inlet pid: " pid " " (lookup pid plist) ":" (eval (lookup pid plist)))
+	(push (list (lookup pid plist) (eval (lookup pid plist))) result6 -1)
+)
+
+(push (list (spawn 'p1 (sleep 400)) 'p1) plist)
+(push (list (spawn 'p2 (sleep 500)) 'p2) plist)
+
+(println (sync 5000 inlet))
+(println)
+
+(if (and
+         (apply and result0) 
+         (= 10 (length result0))
+         (true? result1) 
+         (empty? result2) 
+         (= 10 result3) 
+         (true? result4)
+         (= result5 8)
+         (= result6 '((p1 400) (p2 500))))
+	(println ">>>>> The Cilk API tested SUCCESSFUL")
+	(println ">>>>> PROBLEM with Cilk API")
+)
+(println)
+(exit)
+
diff --git a/qa-specific-tests/qa-cpymem b/qa-specific-tests/qa-cpymem
new file mode 100755
index 0000000..4440a1b
--- /dev/null
+++ b/qa-specific-tests/qa-cpymem
@@ -0,0 +1,25 @@
+#!/usr/bin/newlisp
+
+; this may not run on newer CPUs and definitely only runs in Intel i386
+; runs fine on Mac OSX 10.6 Intel dual core 2 MacMini (2007)
+; does not run on Mac OSX 10.7 Lion dual core 2 MacMini (2007)
+; runs fine on Windows XP 2 Intel dual core 2 and core i5 (2011)
+; will not run on Mac OSX 10.9
+
+(set 'foo-code (append
+     (pack "bbbbbbbbbb" 0x55 0x8B 0xEC 0x8B 0x45 0x08 0x03 0x45 0x0C 0x5D)
+     (if (= ostype "Windows") (pack "bbb" 0xC2 0x08 0x00) (pack "b" 0xC3))))
+(set 'foo print)
+;(cpymem (pack "ld" (if (= ostype "Windows") 265 264)) (first (dump foo)) 4) ; pre v10.3.10
+;(cpymem (pack "ld" (if (= ostype "Windows") 2312 1288)) (first (dump foo)) 4) 
+(cpymem (pack "ld" (if (= ostype "Windows") 0x2200 0x2100)) (first (dump foo)) 4) 
+(cpymem (pack "ld" (address foo-code)) (+ (first (dump foo)) 12) 4)
+(set 'foo-name "foo")
+(cpymem (pack "ld" foo-name) (+ (first (dump foo)) 8) 4)
+(if (=  (foo 3 4) 7)
+    (println ">>>>> cpymem testing code implanting SUCCESSFUL")
+    (println ">>>>> ERR problem testing code implanting with cpymem")
+)
+
+(exit)
+
diff --git a/qa-specific-tests/qa-dictionary b/qa-specific-tests/qa-dictionary
new file mode 100755
index 0000000..e5fd020
--- /dev/null
+++ b/qa-specific-tests/qa-dictionary
@@ -0,0 +1,78 @@
+#!/usr/bin/newlisp
+
+; qa-dictionary
+; check dictionary creation
+
+;(macro (double X) (+ x x))
+;(macro (triple X) (+ x x x))
+;(macro (bar X) (+ x x x))
+
+
+(println)
+(println "Testing and benchmarking namespaces")
+
+(set 'N 10000)
+
+(if (main-args 2)
+	(set 'N (int (main-args 2))))
+
+; define name-space, force creation, stay in MAIN
+(context 'Lex) (context MAIN)
+
+(define (qa-dictionary)
+    (set 'data (randomize (sequence 1 N)))
+    (set 'ass (map list (map string data) data))
+	(println "N of associations: " N)
+	(println "number of cells before creating Lex: " (sys-info 0))
+    (println "time to aquire from association list: " (set 'ta (time (Lex ass))) " ms")
+	(println "time to aquire one entry: " 
+		(format "%5.3f" (mul 1000 (div ta N))) (append " " (char  956) "s"))
+
+	(print "time reading and verifying entries ... : ")
+	(set 'start (time-of-day))
+	(set 'sum 0)
+	(dolist (a ass)
+		(if (!= (Lex (a 0)) (a 1)) 
+			(begin
+				(println "Error: " (Lex (a 0)) " != " (a 1))
+				(set 'read-error true))))
+	(set 'ta (- (time-of-day) start))
+	(println ta " ms")
+	(println "time to read and verify one entry: "
+			(format "%5.3f" (mul 1000 (div ta N))) (append " " (char  956) "s"))
+
+	(set 'start (time-of-day))
+	(set 'sum 0)
+	(dolist (a ass)
+		(Lex (a 0)) )
+	(set 'ta (- (time-of-day) start))
+	(println "time to only read one entry: "
+			(format "%5.3f" (mul 1000 (div ta N))) (append " " (char  956) "s"))
+
+	(println "number of cells after creating Lex: " (sys-info 0))
+	(println "N of symbols in Lex: " (set 'ns (length (Lex))))
+	(println "time to save to file: " (time (save "Lex.lsp" 'Lex)) " ms")
+	(println "time to delete namespace: " (set 'td (time (delete 'Lex))) " ms")
+	(println "time to delete one symbol: "
+		(format "%5.3f" (mul 1000 (div td ns))) (append " " (char  956) "s"))
+	(println "number of cells after deleting Lex: " (sys-info 0))
+	(println "time to load namespace: " (time (load "Lex.lsp")) " ms")
+	(println "number of cells after loading Lex: " (sys-info 0))
+	(println "time to save Lex2: " (time (save "Lex2.lsp" 'Lex)) " ms")
+	(println)
+	(if (and (not read-error) (= (read-file "Lex.lsp") (read-file "Lex2.lsp")))
+		(println ">>>>> Dictionary API tested SUCCESSFUL")
+		(println ">>>>> PROBLEM in dictionary API"))
+)
+
+(qa-dictionary)
+(delete-file "Lex.lsp")
+(delete-file "Lex2.lsp")
+(delete 'Lex)
+(set 'data nil)
+(set 'ass nil)
+(if (main-args 2) 
+    (println (sys-info))
+    (exit))
+
+
diff --git a/qa-specific-tests/qa-editor-highlighting.lsp b/qa-specific-tests/qa-editor-highlighting.lsp
new file mode 100644
index 0000000..b8bc4f1
--- /dev/null
+++ b/qa-specific-tests/qa-editor-highlighting.lsp
@@ -0,0 +1,35 @@
+# test code # also starts comments like ;
+# newLISP uses "," {,} and [text],[/text] as delimiters
+(dotimes (i 10) (println "Hello World"))
+; this is also a comment
+(dotimes (i 10) (println "Hello World")) # comment
+
+; numbers
++12345 -1.234 0xABCdef 0345 1e2 1.23E-5 0b10101
+
+; colon is operator but can be attached
+; separation
+(set 'Foo:foo 123)
+
+; no escaping necessary but balance inside {,}
+{kjhj"khj{lkhl}jkhljkh} 
+
+; [,] are just normal chars but show match
+[kjhjklhlj]khljhljkh] ; looks like any symbol
+
+(dotimes (i 10) (println "Hello World")) ; comment
+
+[text]
+this is a
+[/text
+{"{{}
+\"multi line
+text
+[/text] ; *everything* can go in text tags
+
+(dotimes (i 10) (println "Hello World"))
+
+{jljkh"[text][/text] {}jhkkjhkjh}
+
+; the end ;
+
diff --git a/qa-specific-tests/qa-exception b/qa-specific-tests/qa-exception
new file mode 100755
index 0000000..d848667
--- /dev/null
+++ b/qa-specific-tests/qa-exception
@@ -0,0 +1,50 @@
+#!/usr/bin/newlisp
+
+; check exception handling with 'catch' and 'throw'
+
+(println)
+(println "Testing 'catch' and 'throw'")
+
+(set 'start (time-of-day))
+
+(set 'HI 0 'LO 0)
+
+(define (some_function num)
+	(catch (hi_function num) 'result)
+	(when (not (integer? result))
+		(println "we never get here")))
+
+(define (hi_function num)
+	(catch (lo_function num) 'result)
+	(if (= result 'HI_exception)
+		(++ HI)
+		(throw result)))
+		
+(define (lo_function num)
+	(catch (blowup num) 'result)
+	(if (= result 'LO_exception) 
+		(++ LO)
+		(throw result)))
+
+(define (blowup num)
+	(if (= (& num 1) 1)
+		(throw 'HI_exception)
+		(throw 'LO_exception)))
+
+(define (main n)
+	(dotimes (i n)
+		(some_function i))
+	(println "Exceptions: HI=" HI ", LO=" LO))
+	
+
+(main 10000)
+(println (format " %6.3f ms per exception" (div (sub (time-of-day) start) 10000) ))
+
+(if (= (+ HI LO) 10000)
+	(println ">>>>> Exception testing SUCCESSFUL")
+	(println ">>>>> PROBLEM in testing exceptions")
+)
+
+(exit)
+
+
diff --git a/qa-specific-tests/qa-factorfibo b/qa-specific-tests/qa-factorfibo
new file mode 100755
index 0000000..f3ea13a
--- /dev/null
+++ b/qa-specific-tests/qa-factorfibo
@@ -0,0 +1,107 @@
+#!/usr/bin/newlisp
+
+; Fibonacci series
+
+(define (fibo n) 
+    (let (x 0L y 1L) ; 1 2 3 5 8 13 21
+        (for (_ 0 n) (++ x (swap y x))) ) 
+)
+
+; Collect all prime numbers up to N
+; using sieve algorithm
+
+(define (primes N)
+    (let (p (array N (sequence 0 N)))  
+        (for (i 2 (- N 1))
+            (when (p i) (let (j i)
+                (while (< (* i j) N)
+                    (setf (p (* i j)) nil)
+                    (++ j)))))
+        ; take all but 0 and 1
+        (2 (filter true? (array-list p)))
+    )
+)
+
+
+; Factorization into primes for big integers
+; for integers up to 64-bit use the built-in
+; factor function.
+
+(define (big-factor n , d k fact-list)
+    (set 'n (bigint n)) 
+    (set 'd 2L 'k 0)
+    (while (zero? (% n d))
+        (set 'n (/ n d))
+        (++ k) )
+    (dotimes (i k) (push d fact-list -1))
+    (set 'd 3L 'k 0)
+    (while (<= (* d d) n)
+        (while (zero? (% n d))
+            (set 'n (/ n d))
+            (++ k) )
+        (dotimes (i k) (push d fact-list -1))
+        (set 'k 0)
+        (++ d 2L))
+    (when (> n 1) (push n fact-list -1))
+    fact-list
+)
+
+
+; Use precollected primes wne factoring.
+; Speed gains vary greatly from a few percent
+; to 10 times as fast. The higher the prime factors
+; the less is the speed advantage.
+
+; Collect all primes up to a million
+
+(define (collect-primes)
+    (println "collecting all primes up to a million ...")
+    (set 'mprimes (map bigint (primes 1000000)))
+    (set 'mprimes (array (length mprimes) mprimes))
+    (println (length mprimes) " primes found")
+)
+
+; Primes are only collected once for the first
+; invocation of the function.
+
+(define (bfactor n , d k i np fact-list)
+    (set 'n (bigint n)) 
+    (unless mprimes (collect-primes))
+    (set 'd 2L 'k 0)
+    (while (zero? (% n d))
+        (set 'n (/ n d))
+        (++ k) )
+    (dotimes (i k) (push d fact-list -1))
+    (set 'd (mprimes 1) 'k 0 'i 0 'np (- (length mprimes) 1))
+    (while (<= (* d d) n)
+        (while (zero? (% n d))
+            (set 'n (/ n d))
+            (++ k) )
+        (dotimes (i k) (push d fact-list -1))
+        (set 'k 0)
+	(if (< i np)
+            (set 'd (mprimes (++ i))) 	
+            (++ d 2L))
+    )
+    (when (> n 1) (push n fact-list -1))
+    fact-list
+)
+
+
+; Calculate fibonacci numbers from 1 to N and factorize them.
+
+(set 'N (int (main-args -1) 100))
+(for (i 1 N)
+    (set 'f (fibo i))
+    (set 'duration (time (set 'facts (bfactor f))))
+    (println "fibo " i " " f " -> " (if (= 1 (length facts)) "PRIME" facts) " " duration "ms") 
+    (unless (= f (apply * facts 2))
+        (println ">>>>> ERROR factoring fibo " i " " f " -> " facts)
+        (exit))	
+    (inc total-duration duration)
+)
+
+(println "Total duration: " (div total-duration 1000) " seconds")
+
+(exit)
+;; eof
diff --git a/qa-specific-tests/qa-float b/qa-specific-tests/qa-float
new file mode 100755
index 0000000..ca38fac
--- /dev/null
+++ b/qa-specific-tests/qa-float
@@ -0,0 +1,131 @@
+#!/usr/bin/newlisp
+
+; Test IEE compliance of some FP operations and handling of 'inf' and 'NaN' 
+; numbers. In all versions of newLISP (32Bit and 64Bit) floating point numbers
+; are represented as IEE 754 64-bit: Double (binary64) numbers.
+
+; Thanks to Nelson H.F. Beebe <beebe@math.utah.edu> for some of the tests
+; in this file
+
+(println)
+(println "Testing floating point performance")
+
+(set-locale "C")
+
+(set 'aNan (sqrt -1))
+(set 'aInf (div 1.0 0))
+(set 'aNegInf (div -1 0))
+
+; operation on NaN result in NaN
+
+(set 'tests '(
+	"operation on NaN result in NaN"
+	(NaN? (mul 1.0 aNan))
+	(NaN? (div 1.0 aNan))
+	(NaN? (add 1.0 aNan))
+	(NaN? (sub 1.0 aNan))
+	(NaN? (sin aNan))
+	(NaN? (cos aNan))
+	(NaN? (tan aNan))
+	(NaN? (atan aNan))
+	"comparison with NaN is always nil"
+	(not (< 1.0 aNan))
+	(not (> 1.0 aNan))
+	(not (>= 1.0 aNan))
+	(not (<= 1.0 aNan))
+	(not (= aNan aNan))
+	"NaN is not equal to itself"
+	(not (= aNan aNan)) 
+	"integer operations assume NaN as 0"
+	(= (- 1 aNan) 1)
+	(= (+ 1 aNan) 1)
+	(= (* 1 aNan) 0)
+	(not (catch (/ 1 aNan) 'error))
+	(= (>> aNan) 0)
+	(= (<< aNan) 0)
+	"integer operations assume inf as max-int"
+	(= (* 1 aInf) 9223372036854775807)
+	(= (- aInf 1) 9223372036854775806)
+	(= (+ aInf 1) -9223372036854775808) ; wrap around
+	"FP division by inf results in 0"
+	(= (/ 1 aInf) 0)
+	(= (div 1 aInf) 0)
+	"inf specials"
+	(= aInf aInf)
+	(NaN? (sub aInf aInf))
+	"retain sign of -0.0"
+	(= (set 'tiny (div -1 aInf)) -0.0)
+	(= (sqrt tiny) -0.0)
+    (= (div -1 (div 1.0 0)) -0.0)
+	"inf is signed too"
+	(= aNegInf (div -1 0))
+	(!= aNegInf (div 1 0))
+    (= (int aNegInf) -9223372036854775808)
+	"mod with 0 divisor is NaN"
+	(NaN? (mod 10 0))
+	"% with 0 divisor throws error"
+	(not (catch (% 10 0) 'error))
+	)
+)
+
+
+(dolist (t tests)
+	(if (string? t) 
+		(println (format "\n%-47s\n%s" t (dup "-" 47)))
+		(let (result (eval t))
+			(println (format "%40s => %s" (string t) (string result)))
+			(push result result-list))
+	)
+)
+
+(println)
+
+(set 'result '())
+(set 'u 1.0)
+(while (> u 0.0) (set 'u (mul u 0.5)) (push u result))	
+(println "support of subnormals: " (0 2 result) " => (0 4.940656458e-324)")
+
+
+(set 'epsilon 1.0)
+(while (!= 1.0 (add 1.0 epsilon)) 
+    (set 'epsilon (mul epsilon 0.5))
+)
+(println "machine epsilon: " epsilon  " => 1.110223025e-16")
+
+(println)
+(if 
+    (and 
+         ;(= 2.2250738585072007e-308 2.2250738585072011e-308) ; true on OSX nil on FreeBSD and Win232
+         ;(= 2.2250738585072011e-308 2.2250738585072012e-308) ; true on FreeBSD and Win32 nil on OSX
+
+         ;(= (bits (first (unpack "Lu" (pack "lf" 2.2250738585072007e-308)))) ; true on FreeBSD and Win32 nil OSX
+         ;"1111111111111111111111111111111111111111111111111110")
+         ;(= (bits (first (unpack "Lu" (pack "lf" 2.2250738585072007e-308)))) ; true on OSX nil on FreeBSD and Win32
+         ;"1111111111111111111111111111111111111111111111111111")
+
+         ;(= (bits (first (unpack "Lu" (pack "lf" 2.2250738585072011e-308)))) ; true on OSX and Win32 nil on FreeBSD
+         ;"1111111111111111111111111111111111111111111111111111") ; 52 bits
+         ;(= (bits (first (unpack "Lu" (pack "lf" 2.2250738585072011e-308)))) ; true on FreeBS nil on OSX and Win32
+         ;"10000000000000000000000000000000000000000000000000000") ; 53 bits
+
+
+         ; work on FreeBSD and OSX but not on Win32 XP
+;         (= (bits 2.2250738585072007e-308) "0")
+;         (= (bits (first (unpack "Lu" (pack "lf" 2.2250738585072012e-308))))
+;         "10000000000000000000000000000000000000000000000000000")  ; 53 bits
+
+         ; works on FreeBSD, OSX and Win32
+         (= (bits (first (unpack "Lu" (pack "lf" (sqrt -1)))))
+         "1111111111111000000000000000000000000000000000000000000000000000") ; 64 bits
+    )
+    (println "bit patterns OK")
+    (println "problems in bit patterns")
+)
+
+(println)
+(if-not (apply and result-list)
+	(println ">>>>> PROBLEM in floating point tests")
+	(println ">>>>> Floating point tests SUCCESSFUL")
+)
+
+(exit)
diff --git a/qa-specific-tests/qa-foop b/qa-specific-tests/qa-foop
new file mode 100755
index 0000000..3d581a4
--- /dev/null
+++ b/qa-specific-tests/qa-foop
@@ -0,0 +1,94 @@
+#!/usr/bin/newlisp
+
+(println)
+(println "Testing FOOP")
+
+; changed for v10.2 (v10.1.8 and after)
+; oroginally by Cormullion and Michael (Froum)
+
+(define (complex:complex (r 0) (i 0)) 
+	(list complex r i)) 
+
+(define (complex:rad) 
+   (let (re (self 1) im (self 2)) 
+     (sqrt (add (mul re re) (mul im im)))))
+
+(define (complex:theta) 
+	(atan (div (self 1) (self 2)))) 
+
+(define (complex:add b) 
+	(complex (add (self 1) (b 1)) (add (self 2) (b 2)))) 
+
+(define (complex:mul b) 
+   (let (a.re (self 1) a.im (self 2)
+         b.re (b 1) b.im (b 2)) 
+     (complex 
+      (sub (mul a.re b.re) (mul a.im b.im)) 
+      (add (mul a.re b.im) (mul a.im b.re)) )))
+ 
+(define (complex:square) 
+	(:mul (self) (self)))
+
+
+(define (draw) 
+  (for (y -1 1.1 0.07) 
+      (for (x -2 1 0.03) 
+         (set 'z (complex x y) 'c 126 'a z ) 
+         (while (and (< (abs (:rad (set 'z (:add (:mul z z) a)))) 2) (> (dec c) 32)) ) 
+         (print (char c)) 
+      ) 
+  (println))) 
+
+(println (time (draw) ) "ms")
+
+;;;;;;;;;;;;;;;;;;; check FOOP self in nested FOOP functions ;;;;;;;;;;;;
+
+
+(new Class 'A)
+(new Class 'B)
+
+(setq a (A 0 (B 0)))
+
+(define (B:m str) 
+	(inc (self 1)) )
+
+(define (A:m str) 
+	(inc (self 1)))
+
+(define (A:qa1) 
+	(:m (self) (:m (self 2) " hello")) 
+	(self))
+
+(define (A:qa2) 
+	(:m (self 2) (:m (self) " hello")) 
+	(self))
+
+(if (and
+		(= (:qa1 a) '(A 1 (B 1)))
+		(= (:qa2 a) '(A 2 (B 2))))
+	(println ">>>>> FOOP nested 'self' tested SUCCCESSFUL")
+	(println ">>>>> PROBLEM in nested 'self'")
+)
+
+; make sure a FOOP object contained in a protected symbol,
+; cannot be modified
+
+(new Class 'Circle)
+
+(define (Circle:move dx)
+	(inc (self 1) dx) )
+
+;(set 'myc (Circle 1 2))
+;(:move myc 10)
+
+(constant 'myc (list (Circle 1 2) (Circle 4 5)))
+
+(if (catch (:move (myc 0) 10 ) 'result)
+	(println ">>>>> ERROR in FOOP symbol protection")
+	(if (starts-with result "ERR: symbol is protected : MAIN:container of (self)")
+		(println ">>>>> FOOP symbol protection SUCCESSFUL")
+		(println ">>>>> ERROR in FOOP symbol protection")))
+
+(exit)
+
+;; eof
diff --git a/qa-specific-tests/qa-inplace b/qa-specific-tests/qa-inplace
new file mode 100755
index 0000000..e3c621b
--- /dev/null
+++ b/qa-specific-tests/qa-inplace
@@ -0,0 +1,152 @@
+#!/usr/bin/newlisp
+
+; qa-inplace - test in-place modificatin since v.10.1.12 
+; This file tests a usually not used ability of
+; destructive functions to modify not only the
+; contents of symbols and places in list structures
+; but also the programming text in-place of a function.
+; newLISP has supported this for some destructive
+; functions for a long time, but it has never been
+; publicized or promoted.
+
+; Many will in-place modification as bad programming
+; style, but I think that it has interesting and little
+; explored possibilties. 
+
+; Changes for in-place also have made code smaller and 
+; faster of the functions involved.
+
+
+(define (inplace-++---)
+	(++ 0)
+	(-- 0))
+
+(define (inplace-inc-dec)
+	(inc 0)
+	(dec 0))
+
+(define (inplace-extend)
+	(extend "abc" "def")
+	(extend '(1 2 3) '(4 5 6)))
+
+(define (inplace-pop-assoc) 
+	(pop-assoc 'b '((a 1) (b 2))))
+
+(define (inplace-push-pop)
+	(push "a" "bc")
+	(push 'a '(b c))
+	(pop "abc")
+	(pop '(a b c)))
+
+(define (inplace-replace)
+	(replace "de" "abcdefg" "XX"))
+
+(define (inplace-rotate)
+	(rotate '(a b c)))
+
+; also check nth, first, last
+; 10.2.18 assoc, lookup and  set-ref, ref, rotate on result
+(define (inplace-setf-setq)
+	(setf 0 1)
+	(setf ('(a b) 0) 'A)
+	(setf (first '(a b c)) 'A)
+	(setf (last '(a b c)) 'C)
+	(setf (first "abc") "A")
+	(setf (last "abc") "C")
+	(setf (nth 1 '(a b c)) 'B))
+	
+(define (inplace-sort)
+	(sort '(q t r w e)))
+
+(define (inplace-swap)
+	(swap "abc" 123))
+
+(define (qa-inplace)
+	(and
+		(inplace-++---)
+		(= inplace-++--- (lambda () (++ 1) (-- -1)))
+
+		(inplace-inc-dec)
+		(= inplace-inc-dec (lambda () (inc 1) (dec -1)))
+
+		(inplace-extend)
+		(= inplace-extend 
+			(lambda () (extend "abcdef" "def") (extend '(1 2 3 4 5 6) '( 4 5 6))))
+
+		(inplace-pop-assoc)
+		(= inplace-pop-assoc (lambda () (pop-assoc 'b '((a 1)))))		
+
+		(inplace-push-pop)
+		(= inplace-push-pop
+			(lambda () (push "a" "abc") (push 'a '(a b c)) (pop "bc") (pop '(b c))))
+	
+		(inplace-replace)
+		(= inplace-replace (lambda () (replace "de" "abcXXfg" "XX")))
+
+		(inplace-rotate)
+		(= inplace-rotate (lambda () (rotate '(c a b))))
+
+		(inplace-setf-setq)
+		(= inplace-setf-setq (lambda () (setf 1 1) (setf ('(A b) 0) 'A)
+				(setf (first '(A b c)) 'A) (setf (last '(a b C)) 'C)
+				(setf (first "Abc") "A") (setf (last "abC") "C")
+				(setf (nth 1 '(a B c)) 'B)))
+
+		(inplace-sort)
+		(= inplace-sort (lambda () (sort '(e q r t w))))
+
+		(inplace-swap)
+		(= inplace-swap (lambda () (swap 123 "abc")))
+	)
+)
+
+; check if destructive functions return reference to 
+; in-place data for modification with other desctructive
+; functions, e.g. setf.
+
+(define (qa-inplace-2)
+  (and 
+	(define (foo) (setf (first (push 1 '(2 3 4))) 11))
+	(foo) (= (eval (nth '(1 1 1 2) foo)) '(11 2 3 4))
+
+	(define (foo) (setf (first (push "a" "bc")) "A"))
+	(foo) (= (eval (nth '(1 1 1 2) foo)) "Abc")
+
+	(define (foo) (setf (first (sort '(3 6 4 9))) 11))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) '(11 4 6 9))
+
+	(define (foo) (setf (first (reverse '(4 3 2))) 11))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) '(11 3 4))
+
+	(define (foo) (setf (first (reverse "abc")) "C"))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) '"Cba")
+
+	(define (foo) (setf (first (rotate '(4 3 2 1))) 11))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) '(11 4 3 2))
+
+	(define (foo) (setf (first (rotate "abc")) "C"))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) "Cab")
+
+	(define (foo) (setf (first (extend "abc" "def")) "A"))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) "Abcdef")
+
+	(define (foo) (setf (first (extend '(a b c) '(d e f))) 'A))
+	(foo) (= (eval (nth '(1 1 1 1) foo)) '(A b c d e f))
+
+	(define (foo) (setf (first (replace "c" "abc" "C")) "A"))
+	(foo) (= (eval (nth '(1 1 1 2) foo)) "AbC")
+
+	(define (foo) (setf (first (replace 'c '(a b c) 'C)) 'A))
+	(foo) (= (eval (nth '(1 1 1 2) foo)) '(A b C))
+  )	
+)
+
+(if (and (qa-inplace) (qa-inplace-2))
+	(println ">>>>> In-place modification passed SUCCESSFUL")
+	(println ">>>>> PROBLEM in-place modification passed")
+)
+
+(exit)
+
+; eof
+	
diff --git a/qa-specific-tests/qa-json b/qa-specific-tests/qa-json
new file mode 100755
index 0000000..608f3a6
--- /dev/null
+++ b/qa-specific-tests/qa-json
@@ -0,0 +1,146 @@
+#!/usr/bin/newlisp
+
+; test JSON translation
+
+(set 'js-1 [text]
+{
+    "name": "John Smith",
+    "age": 32,
+    "employed": true,
+    "address": {
+        "street": "701 First Ave.",
+        "city": "Sunnyvale, CA 95125",
+        "country": "United States"
+    },
+    "children": [
+        {
+            "name": "Richard",
+            "age": 7
+        },
+        {
+            "name": "Susan",
+            "age": 4
+        },
+        {
+            "name": "James",
+            "age": 3
+        }
+    ]
+}
+[/text])
+
+; this from a (public blog post) has empty objects:
+;    curl https://api.balancedpayments.com/v1/credits \
+;        -d amount=10000 \
+;        -d description="Math lesson" \
+;        -d bank_account[name]="Johann Bernoulli" \
+;        -d bank_account[account_number]=9900000001 \
+;        -d bank_account[routing_number]=121000358 \
+;        -d bank_account[type]=checking \
+;        -u 7b7a51ccb10c11e19c0a026ba7e239a9:
+
+(set 'js-2 [text]
+{
+  "status": "pending", 
+  "description": "Math lesson", 
+  "created_at": "2013-01-08T18:28:56.979172Z", 
+  "uri": "/v1/credits/CR23hlY1ElsZOFuKiruxPL3W", 
+  "amount": 10000, 
+  "meta": {}, 
+  "id": "CR23hlY1ElsZOFuKiruxPL3W", 
+  "bank_account": {
+    "routing_number": "121000358", 
+    "bank_name": "BANK OF AMERICA, N.A.", 
+    "name": "Johann Bernoulli", 
+    "meta": {}, 
+    "account_number": "xxxxxx0001", 
+    "fingerprint": "1eH719hwbYRpEILVKyboPs_pn", 
+    "type": "checking"
+  }
+}
+[/text])
+
+; like js-2, but no white space between tokens, just one long line
+(set 'js-3 [text]
+{"status": "pending","description":"Math lesson","created_at":"2013-01-08T18:28:56.979172Z","uri":"/v1/credits/CR23hlY1ElsZOFuKiruxPL3W","amount":10000,"meta":{},"id":"CR23hlY1ElsZOFuKiruxPL3W","bank_account":{"routing_number":"121000358","bank_name": "BANK OF AMERICA, N.A.","name":"Johann Bernoulli","meta":{},"account_number":"xxxxxx0001","fingerprint": "1eH719hwbYRpEILVKyboPs_pn","type":"checking"}}
+[/text])
+
+(if (and 
+        (= (json-parse js-1)
+          '(("name" "John Smith") 
+            ("age" 32) 
+            ("employed" true) 
+            ("address" (
+                ("street" "701 First Ave.") 
+                ("city" "Sunnyvale, CA 95125") 
+                ("country" "United States"))) 
+            ("children" (
+                (("name" "Richard") ("age" 7)) 
+                (("name" "Susan") ("age" 4)) 
+                (("name" "James") ("age" 3))))))
+        ; empty objects {}
+        (= (json-parse js-2) (json-parse js-3)
+            '(("status" "pending") 
+              ("description" "Math lesson") 
+              ("created_at" "2013-01-08T18:28:56.979172Z") 
+              ("uri" "/v1/credits/CR23hlY1ElsZOFuKiruxPL3W") 
+              ("amount" 10000) 
+            ("meta" ()) 
+            ("id" "CR23hlY1ElsZOFuKiruxPL3W") 
+            ("bank_account" ( 
+                ("routing_number" "121000358") 
+                ("bank_name" "BANK OF AMERICA, N.A.") 
+                ("name" "Johann Bernoulli") 
+                ("meta" ()) 
+                ("account_number" "xxxxxx0001") 
+                ("fingerprint" "1eH719hwbYRpEILVKyboPs_pn") 
+                ("type" "checking")))))
+        ; from test-json-error qa-dot
+        (and
+          (not (json-parse {{"key" : "value" , "hello"  "world"}}))
+          (= (json-error) '("missing : colon" 28))
+        )
+        ; test-json-parse from qa-dot with arrays
+        (and
+          (= (json-parse { {"key" : "value" , "hello" : "world", "array" : [1, 2, 3, 4, 5]} })
+          '(("key" "value") ("hello" "world") ("array" (1 2 3 4 5))))
+          (= (json-parse { [1,2,3,4,5,6,{ "nested" : 777}, 8, 9] } )
+            '(1 2 3 4 5 6 (("nested" 777)) 8 9) )
+        )
+        ; empty array and empty object
+        (and (= (json-parse {[]}) '()) (= (json-parse {{}}) '()))
+        ; only for utf8 enabled versions
+        (if utf8 (= (json-parse { {"greek letters" : "\u03b1\u03b2\u03b3\u03b4"} })
+                    '(("greek letters" "ฮฑฮฒฮณฮด")))
+                 true
+        )
+        ; escaped quotes fixed in 10.5.2
+        (= (json-parse [text]{"foo": ["bar", "\"baz\""]}[/text]) '(("foo" ("bar" "\"baz\""))))
+        ; escaped back slashes in 10.5.3
+        (= (json-parse [text]{"a backslash":"\\"}[/text]) '(("a backslash" "\\")))
+        ; trailing , (comma) in arrays for ECMA-404 compliance
+        (= (json-parse {[1,2,3,]}) '(1 2 3))
+    )
+    (println ">>>>> JSON translation tested SUCESSFUL")
+    (println ">>>>> PROBLEM in JSON translation")
+)
+
+(println)
+(exit)
+
+;; Other Tests
+
+; one long JSON line without spacesi (~ 700 bytes):
+; (json-parse (first (exec "curl -Ls http://webutils.flourishworks.com/dns")))
+; The JSON string returned by curl is different every time, but works.
+
+; longer JSON text (~ 3600 bytes), fill in any other ip-number
+; (json-parse (get-url "http://apps.db.ripe.net/whois/lookup/ripe/inetnum/208.94.116.204.json"))
+
+; large 10 Mbyte JSON file:
+; (write-file "auctions.json"  
+;     (get-url "http://eu.battle.net/auction-data/258993a3c6b974ef3e6f22ea6f822720/auctions.json"))
+; (time (set 'S (json-parse (read-file "auctions.json")))) ;=> 240.057 ms
+; (length (flat S)) ;=> 1212355 tokens
+
+
diff --git a/qa-specific-tests/qa-lfs b/qa-specific-tests/qa-lfs
new file mode 100755
index 0000000..8e7b34c
--- /dev/null
+++ b/qa-specific-tests/qa-lfs
@@ -0,0 +1,41 @@
+#!/usr/bin/newlisp
+
+;; Test for LFS (Large Files Support)
+;; create a file with more than 2^32 bytes
+;; and read back some records for verification
+;; Needs approximately 5 Gigabyte of diskspace
+;; writing a file of 5,000,000 records of 1k each.
+
+(println)
+(println "This test for LFS (Large Files Support) takes a long time to run.")
+(println "It writes 5 Million records to a 5 Gigabyte filei, then reads back.")
+(println)
+(print "You really want to run this test y/n ? ")
+(if (not (starts-with (read-line) "y" 1))
+	(exit))
+
+(set 'file (open "largefile" "write"))
+
+(dotimes (i 5000000)
+	(set 'rec (append (format "%08d" i) (dup "#" 992)))
+	(write-buffer file rec 1000)
+	(if (= 0 (% i 10000)) (print (format "%10d KB of 5000000 KB written \r" i)))
+)
+(close file)
+
+(println)
+
+(set 'file (open "largefile" "read"))
+
+(for (i 0 4999999 10000)
+	(set 'test (append (format "%08d" i) (dup "#" 992)))
+    (seek file (mul i 1000))
+	(read-buffer file rec 1000)
+	(if (= test rec) 
+		(print (format "%8d record -> Ok\r" i) (0 8 rec))
+		(println i " record -> Error reading " (0 8 rec)))
+)	
+
+(printlni ">>>>> tested Large file system support")
+(exit)
+
diff --git a/qa-specific-tests/qa-libc-libffi b/qa-specific-tests/qa-libc-libffi
new file mode 100755
index 0000000..4e97ed6
--- /dev/null
+++ b/qa-specific-tests/qa-libc-libffi
@@ -0,0 +1,117 @@
+#!/usr/bin/newlisp
+
+; Test libffi routines - all of the tests are performed using only the
+; OS platforms libc system library. For tests compiling a C libray
+; with source code in util/ffitest.c see qa-libffi
+
+; some simple libc functions
+
+; when doing "make testall" only text lines starting with ">>>" are printed
+
+(set-locale "C")
+
+(when (zero? (& 1024 (sys-info -1)))
+    (println ">>>>> qa-libc-libffi: tests only run on extended FFI enabled versions compiled with ffilib")
+    (exit))
+
+(set 'is64bit (not (zero? (& 256 (sys-info -1))))) ; used later
+
+(define (get-libc-name)
+    (letn (libc-name (first (exec "gcc -print-file-name=libc.so"))
+           libc-filetype (first (exec (string "file -b " libc-name))))
+       (if (find "ASCII" libc-filetype)
+           (first (regex "[^ \t]+/libc\\.so\\.*[0-9]*" (read-file libc-name)))
+           libc-name))
+)
+
+(define LIBC
+  (case ostype
+    ("Windows" "msvcrt.dll")
+    ("Cygwin" "msvcrt.dll")
+    ("OSX" "libc.dylib")
+    ("BSD" (get-libc-name) )
+    ("Linux" (get-libc-name) )
+    ))
+
+(println "\nTesting imports from " LIBC "\n")
+
+(unless (catch (import LIBC "sprintf" "int" "char*" "char*" "int" "double") 'result)
+    (println ">>>>> ERR cannot find library in qa-libc-libffi")
+    (exit))
+
+(set 'buff (dup "\000" 64))
+(sprintf buff "int 42 => %i, double Pi => %6.4f" 42 (mul 2 (acos 0))) 
+(set 'buff (get-string buff)) ;; trim buff of trailing zeroes
+(println "->" buff "<-")
+(unless (= buff "int 42 => 42, double Pi => 3.1416")
+    (println ">>>>> ERR problem importing sprinf() in qa-libc-libffi"))
+
+(import LIBC "atof" "double" "char*")
+(println {(atof "3.141") => } (atof "3.141"))
+(unless (= (atof "3.141") 3.141)
+    (println ">>>>> ERR problem importing atof() in qa-libc-libffi"))
+
+(import LIBC "atoi" "int" "char*")
+(println {(atoi "3434") => } (atoi "3434"))
+(unless (= (atoi "3434") 3434)
+    (println ">>>>> ERR problem importing atoi() in qa-libc-libffi"))
+
+(import LIBC "strcpy" "char*" "char*" "char*")
+(set 'from "Hello World")
+(set 'to (dup "\000" (length from)))
+(strcpy to from)
+(println "(strcpy from to) => " to)
+(unless (= to from)
+    (println ">>>>> ERR problem importing strcpy() in qa-libc-libffi"))
+
+(when (!= ostype "Linux")
+    (import LIBC "fabs" "double" "double")
+    (println {(fabs -8.230) => } (fabs 8.230))
+    (println {(fabs 3.14159) => } (fabs 3.14159))
+    (unless (and (= (fabs -8.230) 8.230) (= (fabs 3.14159) 3.14159))
+        (println ">>>>> ERR problem importing fabs() in qa-libc-libffi"))
+)
+
+; test struct pack unpack
+
+(import LIBC "asctime" "char*" "void*")
+(import LIBC "localtime" "void*" "void*")
+
+(if (find ostype '("Windows"))
+	(struct 'tm "int" "int" "int" "int" "int" "int" "int" "int" "int")
+	(struct 'tm "int" "int" "int" "int" "int" "int" "int" "int" "int" "long" "char*")
+)
+
+(if (find ostype '("Windows" "Cygwin"))
+    (set 'tmlist '(1 2 3 4 5 6 7 8 9))
+    (set 'tmlist '(1 2 3 4 5 6 7 8 9 10 "hello world")))
+
+(if (= tmlist (unpack tm (pack tm tmlist)))
+    (println "unpack pack => true")
+    (println ">>>>> ERR problem in struct pack/unpack in qa-libc-libffi"))
+
+(set 'ptr (localtime (address (date-value))))
+(println "unpack localtime structure => " (unpack tm ptr))
+(println "struct testing, today => " (asctime (localtime (address (date-value)))))
+
+; test callback
+
+(import LIBC "qsort" "void" "void*" "int" "int" "void*")
+(set 'len 1000)
+(set 'rlist (rand 10 len))
+(set 'carray (pack (dup "ld " len) rlist))
+(define (cmp a b) (- (get-int a) (get-int b)))
+(qsort (address carray) len 4 (callback 'cmp "int" "void*" "void*"))
+(println "qsort " len " elements => " (apply <= (unpack (dup "ld " len) carray)))
+(unless (apply <= (unpack (dup "ld " len) carray))
+    (println ">>>>> ERR problem in import qsort() with callback in qa-libc-libffi"))
+
+
+(unless (= ostype "Linux")
+    (import LIBC "atexit" "void" "void*")
+    (define (quit) (println "-> Quit ! => true"))
+    (print "atexit callback => ")
+    (atexit (callback 'quit "void" "void"))
+)
+
+(exit)
diff --git a/qa-specific-tests/qa-libffi b/qa-specific-tests/qa-libffi
new file mode 100755
index 0000000..76d2d47
--- /dev/null
+++ b/qa-specific-tests/qa-libffi
@@ -0,0 +1,136 @@
+#!/usr/bin/newlisp
+
+# run this from the main distribution directory:
+#   ./newlisp qa-specific-tests/qa-libffi
+
+# for testing simple and extended ffi on a more complex, real-world library:
+#    use examples/opengl-demo.lsp for simple ffi testing
+#    use examples/opengl-demo-ffi.lsp for extended ffi testing
+
+(when (zero? (& 1024 (sys-info -1)))
+    (println ">>>>> qa-libffi: tests only run on extended FFI enabled versions compiled with libffi")
+    (exit))
+
+(set-locale "C")
+
+(define (compile-recover CC-CALL) ; thanks to Rick Hansen
+  ;; Exec the compiler invocation CC-CALL (which is a string) and, on
+  ;; failure, check certain error conditions, amend the invocation and try
+  ;; again. This routine only handles re-compiling with -fPIC, for now.
+  (let (cc-call-output (exec (string CC-CALL " 2>&1")))
+    (if (not (empty? cc-call-output))
+        ;; You can expand the following IF to handle more recovery cases.
+        (if (find "recompile with -fPIC" (join cc-call-output " "))
+            (compile-recover (string CC-CALL " -fPIC"))
+            ;; Default case: if you've exhausted your recovery cases, then
+            ;; just throw out the compiler's error message to the console.
+            (! CC-CALL)))))
+
+    (if (ends-with (real-path) "qa-specific-tests")
+        (if (zero? (& 0x100 (sys-info -1)))
+            (compile-recover "gcc -m32 ../util/ffitest.c -shared -o ffitest.dylib")
+            (compile-recover "gcc -m64 ../util/ffitest.c -shared -o ffitest.dylib"))
+        (if (zero? (& 0x100 (sys-info -1)))
+            (compile-recover "gcc -m32 util/ffitest.c -shared -o ffitest.dylib")
+            (compile-recover "gcc -m64 util/ffitest.c -shared -o ffitest.dylib"))
+    )
+
+(if (and
+    (import "./ffitest.dylib" "ret_float" "float" "float")
+    (println "float => " (< (abs (sub (ret_float 123456.7890) 123456.7890)) 0.0001))
+;    (println "float => " (sub (ret_float 123456.7890) 123456.7890)) 
+
+    (import "./ffitest.dylib" "ret_double" "double" "double")
+    (println "double => "(= (ret_double 123456.7890) 123456.7890))
+
+    (import "./ffitest.dylib" "add_double" "double" "double" "double")
+    (println "add double => "(= (add_double 123456.7890 123456.7890) 246913.578))
+
+    (import "./ffitest.dylib" "ret_uint8" "byte" "byte")
+    (println "byte => " (= (ret_uint8 -1) 255))
+
+    (import "./ffitest.dylib" "ret_uint16" "unsigned short int" "unsigned short int")
+    (println "unsigned short int => "(= (ret_uint16 -1) 65535))
+
+    (import "./ffitest.dylib" "ret_uint32" "unsigned int" "unsigned int")
+    (println "unsigned int => "(= (ret_uint32 -1) 4294967295))
+
+    (import "./ffitest.dylib" "ret_sint8" "char" "char")
+    (println "char => " (= (ret_sint8 255) -1))
+
+    (import "./ffitest.dylib" "ret_sint16" "short int" "short int")
+    (println "short int => " (= (ret_sint16 65535) -1))
+
+    (import "./ffitest.dylib" "ret_sint32" "int" "int")
+    (println "int => " (= (ret_sint32 4294967295) -1))
+
+    (import "./ffitest.dylib" "ret_pointer" "char*" "char*")
+    (println "char* => " (= (ret_pointer "hello world") "HELLO WORLD"))
+
+    (import "./ffitest.dylib" "string_copy" "char*" "char*" "char*")        
+    (set 'from "hello")
+    (set 'to (dup "\000" (length from)))
+    ; char* will only accept string since 10.4.2
+    ; for address number use void*
+    (set 'ret (string_copy from to)) ; copy from to
+    (println "copy char* => " to " => " (= "hello" to) )
+    (println "return => " ret)
+    )
+  (println ">>>>> libffi API testing SUCCESSFUL")
+  (println ">>>>> ERR testing libffi API"))
+
+;; test simple import and callback API
+(import "./ffitest.dylib" "register_callback_simple" "cdecl")
+(import "./ffitest.dylib" "trigger_callback_simple" "cdecl")
+(define (callme-simple ptr int-num) 
+    (print (get-string ptr)  int-num)
+    (if (= int-num 1234567890)
+        (println " (simple callback API) SUCCESSFUL")
+        (println "ERR in simple callback API")
+    )) 
+
+(register_callback_simple (callback 0 'callme-simple))
+
+(trigger_callback_simple)
+
+;; test extended callback API
+(import "./ffitest.dylib" "register_callback" "void" "void*")
+(import "./ffitest.dylib" "trigger_callback" "void")
+
+(define (callme ptr int-num double-num) 
+    (print (get-string ptr)  int-num " " double-num)
+    (if (and (= int-num 1234567890) (= double-num 12345.67890))
+        (println " (extended callback API) SUCCESSFUL")
+        (println "ERR in extended callback API")
+    ))
+
+(set 'is64bit (not (zero? (& 256 (sys-info -1)))))
+
+(register_callback (callback 'callme "void" "char*" "int" "double" ))
+
+(trigger_callback)
+
+(if (and
+		(= (struct 'clock "char" "int" "short int") 'clock)
+		(= (struct 'foo "char" "int" "short int") 'foo)
+		(= (unpack foo (pack clock 1 2 3)) '(1 2 3))
+		(import "./ffitest.dylib" "addClock" "clock" "clock")
+		(= (addClock (pack clock 1 2 3)) '(2 3 4)) )
+	(println ">>>>> struct tested SUCCESSFUL")
+	(println ">>>>> ERR in struct function")
+)
+
+
+(if (and
+        (= (struct 'sfoo "char" "int" "short int" "char*") 'sfoo)
+        (import "./ffitest.dylib" "useFoo" "void*" "int")
+        (= (unpack sfoo (pack sfoo 1 2 3 "hello world")) '(1 2 3 "hello world"))
+        (= (unpack sfoo (useFoo 10)) '(11 12 13 "hello world")) )
+    (println ">>>>> struct ptr tested SUCCESSFUL")
+    (println ">>>>> ERR in struct ptr testing"))
+
+
+(delete-file "ffitest.dylib")
+
+(exit)
+
diff --git a/qa-specific-tests/qa-local-domain b/qa-specific-tests/qa-local-domain
new file mode 100755
index 0000000..cd4ae4b
--- /dev/null
+++ b/qa-specific-tests/qa-local-domain
@@ -0,0 +1,50 @@
+#!/usr/bin/newlisp
+
+; test local domain UNIX sockets
+; v 1.1 change net-receive for 10.0
+
+(println)
+(println "Testing UNIX local domain sockets")
+
+(when (find ostype '("Windows" "OS/2"))
+  (println "not tested on " ostype)
+  (exit))
+
+(define (listener path)
+	(set 'lsock (net-listen path))
+	(set 'csock (net-accept lsock))
+	(net-receive csock buff 1024)
+	(net-send csock (upper-case buff))
+	(net-close csock)
+	(exit)
+)
+
+(set 'pid (fork (listener "/tmp/mysock")))
+(println "pid:" pid)
+
+(while (not (set 'conn (net-connect "/tmp/mysock")))
+	(sleep 100))
+
+(if (not conn)
+	(begin
+		(println "Could not connect")
+		(exit)))
+
+(println "net-peer: " (net-peer conn))
+(println "net-local: " (net-local conn))
+(net-send conn "hello world")
+
+(while (not (net-select conn "read" 1000))
+	(println "waiting with net-select ..."))
+
+(println "net-peek: " (net-peek conn))
+
+(net-receive conn buff 1024)
+(if (= "HELLO WORLD" buff)
+	(println ">>>>> UNIX local domain sockets SUCCESSFUL")
+	(prrintn ">>>>> PROBLEM with UNIX loxal domain sockets"))
+
+(wait-pid pid)
+
+(exit)
+
diff --git a/qa-specific-tests/qa-longnum b/qa-specific-tests/qa-longnum
new file mode 100755
index 0000000..ba79fe6
--- /dev/null
+++ b/qa-specific-tests/qa-longnum
@@ -0,0 +1,34 @@
+#!/usr/bin/newlisp
+
+(unless bigint
+    (println "this version is not enabled for big integers")
+    (exit))
+
+(set 'num 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890)
+
+(println "1000 digit number num --->")
+(println num)
+(println)
+
+(set 'cien 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890)
+
+(set 'result (* num num))
+
+(println "(* num num) --->")
+(println result)
+(println)
+
+(println "sum of " (length result) " digits in result --->" 
+            (apply + (map int (explode (chop (string result))))))
+(println)
+
+(unless (= num (/ result num))
+    (println "(/ result num) ---> " (/ result num))
+    (println ">>>>> ERROR in parsing big integers")
+    (exit)
+)
+
+(println ">>>>> parsing big integers SUCCESSFUL")
+
+(exit)
+
diff --git a/qa-specific-tests/qa-lookup6 b/qa-specific-tests/qa-lookup6
new file mode 100755
index 0000000..06e72ea
--- /dev/null
+++ b/qa-specific-tests/qa-lookup6
@@ -0,0 +1,26 @@
+#!/usr/bin/env newlisp
+
+(net-ipv 6)
+;(println "net-ping -> " (or (net-ping "officemacmini.local" 1000) (net-error)))
+;(println "net-ping -> " (or (net-ping "lutzmacmini.local" 1000) (net-error)))
+
+;;;;
+
+(net-ipv 6)
+
+(set 'domains '(
+	"altavista.ipv6.digital.com"
+	"ipv6.research.microsoft.com"
+	"www.ipv6forum.com"
+	"ipv6.google.com"
+	"www.google.com"
+	"www.cisco.com"
+))
+
+(dolist (dm domains)
+	(set 'ip (net-lookup dm))
+	(println dm " -> " ip " -> " (or (net-lookup (string ip)) (last (net-error))) )
+)
+
+(exit)
+
diff --git a/qa-specific-tests/qa-message b/qa-specific-tests/qa-message
new file mode 100755
index 0000000..95018dc
--- /dev/null
+++ b/qa-specific-tests/qa-message
@@ -0,0 +1,135 @@
+#!/usr/bin/newlisp
+
+(println)
+(println "testing message API")
+
+; qa-message, check send and receive functions
+; child processes
+
+(when (find ostype '("Windows"))
+	(println "qa-message runs only run on Unix - exit")
+	(exit)
+)
+
+(sleep 1000)
+
+; --------------------------------- status update
+(set 'N 100)
+(set 'k 10)
+
+(println k " child processes transmit " 100 " random status numbers")
+
+(define (child-process N)
+    (set 'ppid (sys-info -4)) ; get parent pid
+    (set 'cpid (sys-info -3)) ; get this pid
+    (dotimes (i N)
+        (until (send ppid (random) ))
+    )
+)
+
+; parent starts k  child processes, listens and displays
+
+(dotimes (i k) (spawn 'result (child-process N) true))
+
+(set 'start (time-of-day));
+(set 'cnt 0)
+(while (< cnt (* k N))
+    (dolist (cpid (receive)) ; iterate thru child pids
+        (receive cpid msg) (inc cnt)
+    )
+)
+
+(abort) ; cancel child-processes
+
+(set 'ms (div (- (time-of-day) start) (* k N )))
+(println ">>>>> Time per simple message: " (mul ms 1000) " micro seconds")
+
+; --------------------------------- roundtrip test
+(set 'N 10)
+(set 'k 10)
+
+(println)
+(println N " round trips to " k " child processes")
+(println "send out and receive it back uppercased with child pid appended")
+
+(define (child-process , pid pppid msg)
+		(setq ppid (sys-info -4)) ; parent pid
+		(setq pid (sys-info -3))  ; this child pid
+		(while true
+			(until (receive ppid msg) )
+			(until (send ppid (upper-case (string msg "-" pid)))) )
+)
+
+(dotimes (i k)
+	(spawn 'r (child-process) true))
+
+(set 'start (time-of-day))
+(dotimes (i N)
+	(dolist (ch (sync))
+		(until (send ch "pid") ) ; send out message
+		(until (receive ch msg))  ; get response
+		(unless (= msg (string "PID-" ch)) ; check
+			(setq error-msg (append " >>>> ERROR in round trip test: " msg )))
+    )
+)
+
+(set 'ms (div (- (time-of-day) start) (* k N )))
+(println ">>>>> Time per round trip : " (mul ms 1000) " micros seconds")
+
+(abort) (sleep 100)
+
+; --------------------------------- proxy test
+(set 'N 100)
+(println)
+; proxy messageing A -> parent -> B
+
+; sender child process of the message
+(set 'A (spawn 'result 
+	(begin
+		(dotimes (i N)
+			(set 'ppid (sys-info -4))
+            /* the following statement in msg will be evaluated in the proxy */
+			(set 'msg '(until (send B (string "greetings from " A))))
+			(until (send ppid msg)))
+		(until (send ppid '(begin
+			(println "parent exiting ...\n")
+			(set 'finished true))))
+    ) true))
+
+; receiver child process of the message
+(set 'B (spawn 'result 
+	(begin
+		(set 'ppid (sys-info -4))
+		(while true
+			(until (receive ppid msg))
+			(unless (= msg (string "greetings from " A))
+                (println ">>> ERROR in proxy message: " msg))
+        )
+        (println)
+    ) true))
+
+; parent functioning as a proxy evaluating messages	or any other code
+(println "A:" A "-> parent-proxy:" (sys-info -3) " -> B:" B "\n")
+
+(sleep 200)
+
+(set 'start (time-of-day))
+; listen to messages from A
+(until finished (if (receive A msg) (eval msg)))
+
+(set 'ms (div (- (time-of-day) start) N))
+(println ">>>>> Time per proxy trip: " (mul ms 1000) " micro seconds")
+(println)
+
+(sleep 300)
+(abort)
+(sleep 300)
+
+(if error-msg 
+	(println ">>>>> PROBLEM " error-msg)
+	(println ">>>>> Message API tested SUCCESSFUL"))
+
+(exit)
+
+;; eof
+
diff --git a/qa-specific-tests/qa-msgbig b/qa-specific-tests/qa-msgbig
new file mode 100755
index 0000000..03775e2
--- /dev/null
+++ b/qa-specific-tests/qa-msgbig
@@ -0,0 +1,43 @@
+#!/usr/bin/newlisp
+
+; now updated for reworked message API in v.10.3.5:
+; must specify 'true' in 'spawn' when using 'send/'receive'
+
+; --------------------------------- roundtrip test
+(println "\n10 round trips to 10 child processes with 80,000 bytes in each package")
+
+(define (child-process , pid pppid msg)
+		(setq ppid (sys-info -4)) ; parent pid
+		(setq pid (sys-info -3))  ; this child pid
+		(while true
+			(until (receive ppid msg) )
+			(until (send ppid msg ) ))
+)
+
+(dotimes (i 10)
+	(spawn 'r (child-process)i true))
+
+(println "\nPIDs of spawned childs:\n" (sync)) (println)
+
+(set 'start (time-of-day))
+(dotimes (i 2)
+	(dolist (ch (sync))
+        /* cannot be binary */
+        (set 'pkg (base64-enc (dup (pack "lf" (random 0 1)) 20000)))
+		(until (send ch pkg) ) ; send out message
+		(until (receive ch msg))  ; get response
+		(unless (= msg pkg) ; check
+			(setq error-msg (string " >>>> ERROR in round trip test: " ch)))
+		(print  ch " ") )
+	(println)
+)
+
+(println "time per round trip: " (div (- (time-of-day) start) 100) " ms")
+
+(if error-msg 
+	(println ">>>>> PROBLEM " error-msg)
+	(println ">>>>> Message API with big content tested SUCCESSFUL"))
+
+(abort) (sleep 100) (println)
+(exit)
+
diff --git a/qa-specific-tests/qa-net b/qa-specific-tests/qa-net
new file mode 100755
index 0000000..97f914b
--- /dev/null
+++ b/qa-specific-tests/qa-net
@@ -0,0 +1,176 @@
+#!/usr/bin/newlisp
+
+; qa-net - test network routines for server mode IPv4
+;
+; tests: net-eval
+; tests http mode of: load, save, read-file, write-file, delete-file
+; 
+; assumes newlisp executable in the current directory:
+;     newlisp-x.x.x/
+;
+; usage to test on local host:
+;
+;        ./newlisp qa-net  
+;
+; usage to test on a remote host
+; 
+;        ./newlisp qa-net http://mysite.com:10001//home/test
+; or 
+;        ./newlisp qa-net http://localhost:4711//Users/Lutz/newlisp-8.9.8
+;
+; running this test on Win32/64
+;
+;        newlisp qa-net
+;
+; On Win32/64 this test may have timing issues, try running again.
+; 
+;
+
+(delete-file "qa-junk.txt")
+(when (file? "qa-junk.txt")
+	(println ">>>>> Please remove file qa-junk.txt manually")
+	(exit))
+
+(println)
+(println "Testing network API and server mode IPv4")
+
+(when (not (or (file? "newlisp") (file? "newlisp.exe")))
+	(println ">>>>> Need a newlisp executable in the current directory for qa-net")
+	(exit)
+)
+
+(set 'start (time-of-day))
+
+(println "Testing IPv4 networking functions")
+(set 'targetURL (or 
+	(main-args 2)
+	(append "http://localhost:10001/" (real-path) "/qa-junk.txt")))
+
+(replace "\\" targetURL "/") ; for Win32/64
+
+(when (not (ends-with targetURL "/qa-junk.txt"))
+	(set 'targetURL (append targetURL "/qa-junk.txt")))
+
+(set 'host ((regex "http://(.*?):" targetURL) 3))
+(set 'port (int ((regex "http://.*?:(\\d+)/" targetURL) 3)))
+(set 'file-path ((regex "http://.*:\\d+/(.*)" targetURL) 3))
+
+
+(println)
+(println "target URL: " targetURL)
+
+(println "host: " host)
+(println "port: " port)
+(println "path: " file-path)
+
+; check if server is online or start it, if not
+; start one on localhost if no URL was specified
+; on the command line
+(set 'connection (net-connect host port 1000))
+(if (not connection)
+	(begin
+		(println "Starting server on localhost")
+		(if (find ostype '("Windows" "OS/2"))
+			(set 'pid (process (string "newlisp -c -d " port)))
+			(set 'pid (process (string "./newlisp -c -d " port)))))
+	(begin
+		(println "Server already running ...")
+		(net-close connection)))
+	
+
+(println "waiting for server ...")
+(sleep 1000)
+
+(if (net-connect host (+ port 1) 500)
+	(println " >>>> net-connect -> ERROR")
+	(println "net-connect to wrong port ->OK"))
+
+(if (find "HTTP/1.0 404" (get-url (string "http://" host ":" port "/xyz.xyz")))
+	(set 'result0 (println "get-url ->OK"))
+	(println " >>>> get-url problem ->ERROR"))
+
+; test short syntax normal mode
+(if (=  (net-eval host port {(+ 3 4)} 1000) 7) 
+	(set 'result1 (println "net-eval normal mode ->OK"))
+	(println " >>>> net-eval poblem with normal mode ->ERROR"))
+
+; test error reporting
+(if (= (net-eval host port "(abc)") "\nERR: invalid function : (abc)\n")
+	(set 'result2 (println "net-eval error reporting ->OK"))
+	(println " >>>> net-eval problem with error reporting ->ERROR"))
+
+; test saving to URL
+(set 'key (uuid))
+(set 'verify key)
+(if (catch (save targetURL 'key) 'res)
+	(set 'result3 (println "save to URL ->OK"))
+	(println " >>>> save to URL ->ERROR"))
+
+(when (find ostype '("Windows" "Cygwin"))
+	(print "waiting on Windows for file to be unlocked .")
+	(until (= (length (source 'key)) (first (file-info file-path)))
+		(sleep 1000) 
+		(print "."))
+	(println))
+
+; test loading from URL
+(if (and
+       (println "loading target URL: " targetURL)
+       (catch (= (load targetURL) verify) 'result) 
+       (= key verify))
+       (set 'result4 (println "load from URL ->OK"))
+	(begin
+    	(println " >>>> load from URL ->ERROR OK on some Windows")
+		(println result))
+)
+
+; test writing file to remote
+
+; generate random binary data
+(set 'content "")
+(dotimes (i 100000)
+	(write-buffer content (pack "c" (rand 255))))
+
+; write content to remote URL
+(if	(find "transferred" (print (write-file targetURL content)) )
+	(set 'result5 (println "write-file to remote URL ->OK"))
+	(println "write-file to remote URL ->ERROR"))
+
+(when (find ostype '("Windows" "Cygwin"))
+	(print "waiting on Windows for file to be unlocked .")
+	(until (= 100000 (first (file-info file-path)))
+		(sleep 1000) 
+		(print "."))
+	(println))
+
+; read content from remote URL
+(if (catch (= contents (read-file targetURL)) 'result)
+    (set 'result6 (println "read-file from remote URL ->OK"))
+    (begin
+        (println " >>>> read-file from  remote URL ->ERROR OK on some Windows")
+		(println result))
+)
+
+; delete file at remote URL
+(if (not (find  ostype '("Windows"))) ; does not work on Windows when on the same machine
+	(if (delete-file targetURL)
+		(set 'result7 (println "delete-file from remote URL ->OK"))
+		(println " >>>> delete-file from remote URL ->Error"))
+	(set 'result7 true)
+)
+
+(when pid
+	(println "destroy -> " pid " ->" (destroy pid)))
+
+(println "\nduration -> " (- (time-of-day) start) " ms\n")
+
+(if (and result0 result1 result2 result3 result4 result5 result6 result7 )
+	(println ">>>>> Network eval and network file functions IPv4 SUCCESSFUL")
+	(println ">>>>> PROBLEM in network eval and network file IPv4 functions")
+)
+(println)
+(delete-file "qa-junk.txt")
+(when (file? "qa-junk.txt")
+	(println ">>>>> Please remove file qa-junk.txt manually"))
+
+(exit)
diff --git a/qa-specific-tests/qa-net6 b/qa-specific-tests/qa-net6
new file mode 100755
index 0000000..92007e8
--- /dev/null
+++ b/qa-specific-tests/qa-net6
@@ -0,0 +1,177 @@
+#!/usr/bin/newlisp
+
+; qa-net6 - test network routines for server mode in IPv6 mode
+; currently only UNIX like OSs.
+;
+; tests: net-eval
+; tests http mode of: load, save, read-file, write-file, delete-file
+; 
+; assumes newlisp executable in the current directory:
+;     newlisp-x.x.x/
+;
+; usage to test on local host:
+;
+;        ./newlisp qa-net  
+;
+; usage to test on a remote host
+; 
+;        ./newlisp qa-net http://mysite.com:10001//home/test
+; or 
+;        ./newlisp qa-net http://localhost:4711//Users/Lutz/newlisp-8.9.8
+;
+
+; remove the file qa-junk.txt manually before running
+(when (find ostype '("OS/2" "SunOS"))
+	(println "disabled for " ostype " - must exit -")
+	(exit))
+
+
+(net-ipv 6)
+; check if IPv6 works
+(if (set 'sock (net-listen 10001))
+	(net-close sock)
+	(begin
+		(print " >>>> " (last(net-error)))
+		(println ". Cannot test IPv6 on this platform.")
+		(exit)
+	))
+
+(println)
+(println "Testing network API and server mode IPv6")
+
+(when (not (or (file? "newlisp") (file? "newlisp.exe")))
+	(println ">>>>> Need a newlisp executable in the current directory for qa-net")
+	(exit)
+)
+
+(set 'start (time-of-day))
+
+(println "Testing IPv6 networking functions")
+(set 'targetURL (or 
+		(main-args 2)
+		(append "http://[::1]:10001/" (real-path) "/qa-junk.txt")))
+
+(replace "\\" targetURL "/") ; for Win32/64
+
+(if (not (ends-with targetURL "/qa-junk.txt"))
+	(set 'targetURL (append targetURL "/qa-junk.txt")))
+
+(set 'host (1 ((regex {http://(.*?)\]:} targetURL) 3)))
+(set 'port (int ((regex {http://.*?\]:(\d+)/} targetURL) 3)))
+(set 'file-path ((regex {http://.*\]:\d+/(.*)} targetURL) 3))
+
+(println)
+(println "target URL: " targetURL)
+
+(println "host: " host)
+(println "port: " port)
+(println "path: " file-path)
+
+; check if server is online or start it, if not
+; start one on localhost if no URL was specified
+; on the command line
+(set 'connection (net-connect host port 1000))
+(if (not connection)
+	(begin
+		(println "Starting server on localhost")
+		(if (find ostype '("Windows" "OS/2"))
+			(set 'pid (process (string "newlisp -6 -c -d " port)))
+			(set 'pid (process (string "./newlisp -6 -c -d " port)))))
+	(begin
+		(println "Server already running ...")
+		(net-close connection)))
+	
+
+(println "waiting for server ...")
+(sleep 1000)
+
+(if (net-connect host (+ port 1) 500)
+	(println " >>>> net-connect -> ERROR")
+	(println "net-connect to wrong port ->OK"))
+
+
+(if (find "HTTP/1.0 404" (get-url "http://[::1]:10001/xyz.xyz"))
+	(set 'result0 (println "get-url ->OK"))
+	(println " >>>> get-url problem ->ERROR"))
+
+; test short syntax normal mode
+(if (=  (net-eval host port {(+ 3 4)} 1000) 7) 
+	(set 'result1 (println "net-eval normal mode ->OK"))
+	(println " >>>> net-eval poblem with normal mode ->ERROR"))
+
+; test error reporting
+(if (= (net-eval host port "(abc)") "\nERR: invalid function : (abc)\n")
+	(set 'result2 (println "net-eval error reporting ->OK"))
+	(println " >>>> net-eval problem with error reporting ->ERROR"))
+
+; test saving to URL
+(set 'key (uuid))
+(set 'verify key)
+(if (catch (save targetURL 'key) 'res)
+	(set 'result3 (println "save to URL ->OK"))
+	(println " >>>> save to URL ->ERROR"))
+
+(when (find ostype '("Windows" "Cygwin"))
+	(print "waiting on Windows for file to be unlocked .")
+	(until (= (length (source 'key)) (first (file-info file-path)))
+		(sleep 1000) 
+		(print "."))
+	(println))
+
+; test loading from URL
+(if (and
+       (println "loading target URL: " targetURL)
+       (catch (= (load targetURL) verify) 'result) 
+       (= key verify))
+       (set 'result4 (println "load from URL ->OK"))
+	(begin
+    	(println " >>>> load from URL ->ERROR OK on some Windows")
+		(println result))
+)
+
+; test writing file to remote
+
+; generate random binary data
+(set 'content "")
+(dotimes (i 100000)
+	(write-buffer content (pack "c" (rand 255))))
+
+; write content to remote URL
+(if	(find "transferred" (print (write-file targetURL content)) )
+	(set 'result5 (println "write-file to remote URL ->OK"))
+	(println "write-file to remote URL ->ERROR"))
+
+(when (find ostype '("Windows" "Cygwin"))
+	(print "waiting on Windows for file to be unlocked .")
+	(until (= 100000 (first (file-info file-path)))
+		(sleep 1000) 
+		(print "."))
+	(println))
+
+; read content from remote URL
+(if (catch (= contents (read-file targetURL)) 'result)
+    (set 'result6 (println "read-file from remote URL ->OK"))
+    (begin
+        (println " >>>> read-file from  remote URL ->ERROR OK on some Windows")
+		(println result))
+)
+
+; delete file at remote URL
+(if (not (find ostype '("Windows"))) ; does not work on Windows when on the same machine
+	(if (delete-file targetURL)
+		(set 'result7 (println "delete-file from remote URL ->OK"))
+		(println " >>>> delete-file from remote URL ->Error"))
+	(set 'result7 true)
+)
+
+(if pid
+	(println "destroy -> " pid " ->" (destroy pid)))
+
+(println "\nduration -> " (- (time-of-day) start) " ms\n")
+
+(if (and result0 result1 result2 result3 result4 result5 result6 result7)
+	(println ">>>>> Network eval and network file functions IPv6 SUCCESSFUL")
+	(println ">>>>> PROBLEM in network eval and network file IPv6 functions")
+)
+(println)
+(exit)
diff --git a/qa-specific-tests/qa-nullstring b/qa-specific-tests/qa-nullstring
new file mode 100755
index 0000000..6a7e344
--- /dev/null
+++ b/qa-specific-tests/qa-nullstring
@@ -0,0 +1,26 @@
+#!/usr/bin/env newlisp
+
+; unpack, get-string and ffliob returns with char* == NULL
+; should give an error message "ERR: cannot convert NULL to string"
+; else they most likely will segfault
+
+(struct '_struct_string "char*" "long")
+(setf s (pack _struct_string 0 0))
+
+(if (not (catch (unpack _struct_string s) 'ret))
+        (println ">>>>> SUCCESS unpacking NULL ptr")
+        (println ">>>>> ERROR unpacking NULL ptr")
+)
+
+(if (and 
+        (not (catch (get-string 0) 'ret))
+        (not (catch (get-string 0 10) 'ret))
+        (not (catch (get-string 0 10 "end") 'ret))
+    )
+    (println ">>>>> SUCCESS get-string on NULL ptr")
+    (println ">>>>> ERROR get-string on NULL ptr")
+)
+
+(exit)
+
+
diff --git a/qa-specific-tests/qa-packet b/qa-specific-tests/qa-packet
new file mode 100755
index 0000000..8bb495c
--- /dev/null
+++ b/qa-specific-tests/qa-packet
@@ -0,0 +1,130 @@
+#!/usr/bin/newlisp
+
+(println "run with superuser permissions only")
+
+
+; set source and destination IP addresses for all test packages
+
+(map set '(sip1 sip2 sip3 sip4) '(10 0 2 15))
+(map set '(dip1 dip2 dip3 dip4) '(10 0 2 2))
+
+(define (send-packet packet)
+	(let (bytes-sent (net-packet packet))
+		(unless bytes-sent
+			(println " >>>> net-error:" (net-error)) 
+			(println " >>>> sys-error:" (sys-error)))
+		bytes-sent)
+)
+
+
+; ==============================================================================
+
+; example for sendig a TCP packet using net-packet and raw sockets
+; checksums ip_sum and th_sum are only calculated if given as zero
+; change at least the destination IP to a valid IP.
+; tcp header options and data can be added at the end; this would
+; increase the total packet length ip_len and would increase th_off,
+; if tcp header options are present. TCP header options must be
+; padded at the end for 32bit alignment. After TCP header options
+; data can be added.
+
+; only headers no data
+(set 'tcp-packet
+        ; IP header                      ; TCP header
+  (pack "b b bb bb bb b b bb bbbb bbbb   bb bb bbbb bbbb b b bb bb bb " 
+; IP header in BSD form
+0x45       ; ip_hl, ip_v IPV 4 and header length in quads
+0x00       ; ip_tos, type of service
+0x00 0x28  ; ip_len, total length=40 in network order
+0x22 0x79  ; ip_id, identification (random)
+0x00 0x00  ; ip_off, fragment offset field
+0x3c       ; ip_ttl, time to live TTL
+0x06       ; ip_p, protocl 6 for TCP
+0x00 0x00  ; ip_sum, checksum set automatically by net-packet if zero
+sip1 sip2 sip3 sip4 ; source IP
+dip1 dip2 dip3 dip4 ; destination IP
+; TCP header in BSD form
+0x14 0x03  ; th_sport, source port 5123 in big-endian
+0x30 0x39  ; th_dport, destination port 12345 in big-endian
+0x08 0xd7 0x35 0xef ; th_seq, sequence number in big-endian (random)
+0x1d 0x41 0x5f 0x04 ; th_ack, achnowledgement in big-emdian number (random)
+0x50       ; th_off, data offset 5 * 4 = 20 and th_x2, 0 unused
+0x03       ; th_flags on of: TH_FIN,TH_SYN,TH_RST,TH_PUSH,TH_ACK,TH_URG
+0x02 0x00  ; th_win window
+0x00 0x00  ; th_sum, checksum set automatically by net-packet if zero 
+0x00 0x00  ; th_urp
+) ; end pack
+) ; end tcp-packet
+
+(if (= 0x28 (send-packet tcp-packet))
+	(println ">>>>> packet with headers only OK")
+	(println ">>>>> ERROR sending packet with headers only"))
+
+; ==============================================================================
+
+; (get-url "http://192.168.1.92") -> connect to port 80
+; no data but TCP header options
+ 
+(set 'tcp-packet (pack (dup "b" 64) (list
+    0x45 0x00 0x00 0x40 0x73 0xa6 0x40 0x00 0x40 0x06 0x00 0x00 sip1 sip2 sip3 sip4
+    dip1 dip1 dip3 dip4 0xcd 0x15 0x00 0x50 0x46 0x0a 0x32 0xe9 0x00 0x00 0x00 0x00
+    0xb0 0x02 0xff 0xff 0x00 0x00 0x00 0x00 0x02 0x04 0x05 0xb4 0x01 0x03 0x03 0x03
+    0x01 0x01 0x08 0x0a 0x11 0xd3 0xaf 0x10 0x00 0x00 0x00 0x00 0x04 0x02 0x00 0x00))
+)
+
+(if (= 0x40 (send-packet tcp-packet))
+	(println ">>>>> packet with headers, header options and no data OK")
+	(println ">>>>> ERROR sending packet with headers only"))
+
+; ==============================================================================
+
+; (get-url "http://192.168.1.92") -> send "GET / HTTP/1.1" request
+; header options and data
+
+; 16 bytes of data
+(set 'tcp-packet (pack (dup "b" 68) (list
+    0x45 0x00 0x00 0x44 0x30 0x20 0x40 0x00 0x40 0x06 0x00 0x00 sip1 sip2 sip3 sip4 
+    dip1 dip2 dip3 dip4 0xc3 0xe3 0x00 0x50 0x7f 0x0e 0xbb 0x5d 0x85 0x9d 0x90 0xd3 
+    0x80 0x18 0xff 0xff 0x00 0x00 0x00 0x00 0x01 0x01 0x08 0x0a 0x00 0x15 0xac 0x3e
+    0x53 0xfe 0xe8 0xb0 0x47 0x45 0x54 0x20 0x2f 0x20 0x48 0x54 0x54 0x50 0x2f 0x31
+    0x2e 0x31 0x0d 0x0a)))
+
+(if (= 0x44 (send-packet tcp-packet))
+	(println ">>>>> packet with headers, header options and data OK")
+	(println ">>>>> ERROR sending packet with headers only"))
+
+; ==============================================================================
+
+; on this packet checksums are already set, to find out if ip_len and ip_off
+; swapping is handled correctly (assuming 10.0.2.15 -> 10.0.2.2 configuration
+; under VirtualBox)
+
+; (net-send-udp "10.0.2.2" 12345 "Hello World")
+(set 'udp-packet (pack (dup "b" 39) (list
+    0x45 0x00 0x00 0x27 0x00 0x00 0x40 0x00 0x40 0x11 0x22 0xb6 sip1 sip2 sip3 sip4 
+    dip1 dip2 dip3 dip4 0xe4 0x05 0x30 0x39 0x00 0x13 0x81 0xaa 0x48 0x65 0x6c 0x6c
+    0x6f 0x20 0x57 0x6f 0x72 0x6c 0x64)))
+
+(if (= 0x27 (send-packet udp-packet))
+	(println ">>>>> UDP packet with data OK")
+	(println ">>>>> ERROR sending UDP packet with data"))
+
+; ==============================================================================
+
+; (net-ping "192.168.1.92")
+
+(set 'icmp-packet (pack (dup "b" 84) (list
+    0x45 0x00 0x00 0x54 0x81 0xcf 0x00 0x00 0x40 0x01 0x00 0x00 sip1 sip2 sip3 sip4 
+    dip1 dip2 dip3 dip4 0x08 0x00 0x00 0x00 0xfd 0x30 0x00 0x00 0x00 0x00 0x00 0x00
+    0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+    0xb9 0x6d 0xd8 0x4b 0xdd 0x69 0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+    0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+    0x00 0x00 0x00 0x00)))
+
+(if (= 0x54 (send-packet icmp-packet))
+	(println ">>>>> ICMP packet with data OK")
+	(println ">>>>> ERROR sending ICMP packet with data"))
+
+(exit)
+
+;; eof
diff --git a/qa-specific-tests/qa-pipe b/qa-specific-tests/qa-pipe
new file mode 100755
index 0000000..0a229ca
--- /dev/null
+++ b/qa-specific-tests/qa-pipe
@@ -0,0 +1,43 @@
+#!/usr/bin/newlisp
+
+
+(define (test-pipe)
+	(write-file "pipe-child.lsp" 
+[text]
+(set 'msg (read-line (int (nth 2 (main-args)))))
+(write-line (int (nth 3 (main-args))) (upper-case msg))
+(exit)
+[/text]
+	)
+  (and
+	(set 'channel (pipe))
+	(set 'in (first channel))
+	(set 'out (last channel))
+	(if (find ostype '("Windows" "OS/2"))
+		(process (string "newlisp pipe-child.lsp " in " " out))
+		(process (string "./newlisp pipe-child.lsp " in " " out)))
+	(sleep 1000)
+	(write-line out (dup "hello there " 1000))
+	(sleep 1000)
+	(= (read-line in) (dup "HELLO THERE " 1000))
+	(delete-file "pipe-child.lsp")
+  )
+)
+
+;(if (find ostype '("Linux" "BSD" "OSX" "Solaris" "SunOS" "Aix" "True64Unix" "Cygwin"))
+;  (define (test-pipe)
+;	(set 'channel (pipe))
+;	(set 'in (first channel))
+;	(set 'out (last channel))
+;	(fork (write-line out (upper-case (read-line in))))
+;	(write-line out "hello there")
+;	(sleep 2000)
+;	(= (read-line in) "HELLO THERE")
+;	)
+;)
+
+(println "test-pipe => " (test-pipe))
+
+(exit)
+
+
diff --git a/qa-specific-tests/qa-pipefork b/qa-specific-tests/qa-pipefork
new file mode 100755
index 0000000..d1dcfa2
--- /dev/null
+++ b/qa-specific-tests/qa-pipefork
@@ -0,0 +1,36 @@
+#!/usr/bin/newlisp
+#
+# two forked processes communicating via pipes
+
+(when (find ostype '("Windows"))
+    (println "fork not available on Windows")
+	(exit))
+
+
+(println)
+(println "Testing/benchmarking  pipes with forked processes")
+
+(set 'start (time-of-day))
+(set 'N 1000)
+
+(define (count-down-proc x channel)
+  (while (!= x 0)
+      (write-line channel (string x))
+      (dec x)))
+
+(define (observer-proc channel)
+  (do-until (= i "1")
+    (print "read " (setq i (read-line channel)) "\r")
+))
+
+(map set '(in out) (pipe))
+(set 'observer (fork (observer-proc in)))
+(set 'counter (fork (count-down-proc N out)))
+
+; avoid zombies
+(wait-pid observer)
+(wait-pid counter)
+
+(println ">>>>> " (div (- (time-of-day) start)  N) 
+" ms per write->read pipe/fork (0.0356 ms Mac OSX, 1.83 GHz Core 2 Duo)")
+(exit)
diff --git a/qa-specific-tests/qa-ref b/qa-specific-tests/qa-ref
new file mode 100755
index 0000000..bbe666a
--- /dev/null
+++ b/qa-specific-tests/qa-ref
@@ -0,0 +1,219 @@
+#!/usr/bin/newlisp
+
+;; qa reference returns from functions
+
+(println)
+(println "testing reference passing to/from built-in functions")
+
+(define (qa-ref)
+	(and
+		; replace -> nth
+		(set 'L '(a b (c d e f g)))
+		(= (replace 'f (nth (+ 1 1) L) 'z) '(c d e z g))
+		(= L '(a b (c d e z g)))
+		
+		; protection
+		(constant 'C '(a b c d e (f g)))
+		(not (catch (replace 'f (nth (- 1 2) C) 'z) 'result))
+
+		; copied return from append
+		(set 's1 "ABC" 's2 "DEF")
+		(= (replace "D" (append s1 s2) "Z") "ABCZEF")
+		(= s1 "ABC")
+		(= s2 "DEF")
+
+		; replace -> rotate string
+		(set 's "ABCDEFG")
+		(= (replace "D" (rotate s) "Z") "GABCZEF")
+		(= s "GABCZEF")
+
+		; replace -> rotate list
+		(set 'r '(A B D E F G))
+		(= (replace 'D (rotate r) 'Z) '(G A B Z E F))
+		(= r '(G A B Z E F))
+
+		; pop -> sort list
+		(set 's '(K U Q A J P T))
+		(= (pop (sort s)) 'A)
+		(= s '(J K P Q T U))
+
+		; push -> reverse list
+		(set 'l '(A B C D E F))
+		(= (push 'D (reverse l)) '(D F E D C B A))
+		(= l '(D F E D C B A))
+
+		; setq -> assoc list
+		(set 'l '((a 1) (b 2)))
+		(= (setq (assoc 'b l) '(b 3)) '(b 3))
+		(= l '((a 1) (b 3)))
+	
+		; push -> setq -> assoc list
+		(= (push 'b (setq (assoc 'b l) '(b 4))) '(b b 4))
+		(= l '((a 1) (b b 4)))
+
+		; setq -> first, setq -> last list
+		(set 'l '(a b c d e f))
+		(= (setq (first l) 99) 99)
+		(= l '(99 b c d e f))
+		(= (setq (last l) 990) 990)
+		(= l '(99 b c d e 990))
+
+		; push -> setq
+		(= (push 'z (setq x '(a b c d e f)) -1) '(a b c d e f z))
+		(= x '(a b c d e f z))
+		
+		; pop -> set-ref list
+		(set 'l '("AA" ("BB" "CC")))
+		(= (pop (set-ref "BB" l "aa")) "AA")
+		(= l '(("aa" "CC")))
+		
+		; setq -> nth -> set-ref-all list
+		(set 'l '("AA" ("BB" ("CC" "BB"))))
+		(= (setq (nth 0 (set-ref-all "BB" l "aa")) "xx") "xx")
+		(= l '("xx" ("aa" ("CC" "aa"))))
+		
+		; if returns reference
+		(set 'l '((a b) c))
+		(= (pop (if true (l 0) '(x y z))) 'a)
+		(= l '((b) c))
+		
+		; if-not returns reference
+		(set 'l '((a b) c))
+		(= (pop (if-not nil (l 0) '(x y z))) 'a)
+		(= l '((b) c))
+		                       
+		; when returns reference
+		(set 'l '((a b) c))
+		(= (pop (when true (l 0))) 'a)
+		(= l '((b) c))
+		
+		; unless returns reference
+		(set 'l '((a b) c))
+		(= (pop (unless nil (l 0))) 'a)
+		(= l '((b) c))
+
+		; pop -> lookup
+		(set 'L '((a 1) (b 1 (2 3) 4) (c 3)))
+		(= (push 99 (lookup 'b L -2)) '(99 2 3))
+		(= L '((a 1) (b 1 (99 2 3) 4) (c 3)))
+		
+		; pop and push a as a queue
+		(set 'Q '(a b c d e))
+		(= (pop (push 'f Q -1)) 'a)
+		(= (pop (push 'g Q -1)) 'b)
+		(= Q '(c d e f g))
+		
+		; pop on list elements
+		(set 'L '(a "abc"))
+		(push 1 (eval (L 0)))
+		(push "z" (L 1))
+		(= a '(1))
+		(= L '(a "zabc"))
+				
+		; an evaluated symbol returns reference
+		(set 'l '(a b c d e f g))
+		(= (pop (if true l)) 'a)
+		(= (pop (if true l)) 'b)
+		(= (pop (if true l)) 'c)
+		(= l '(d e f g))
+
+		; begin, and, or
+		(set 'L '(a b c d e f g))
+		(replace 'b (begin (and (or L))) 'B)
+		(= L '(a B c d e f g))
+
+		; case cond
+		(set 'L '(a b c d e f g))
+		(pop (case 1 (1 L)))
+		(= L '(b c d e f g))
+		(pop (cond (nil 123) (true L)))
+		(= L '(c d e f g))
+
+		; nested implicit indexes
+		(set 'L '(a b (c d) e f g))
+		(= (setf ((L 2) 0) 99) 99)
+		(= L '(a b (99 d) e f g))
+		
+		; setf with $it
+		(setf x 1)
+		(= (setf x (+ $it 1)) 2)
+		
+		; hash with $it
+		(not (define foo:foo))
+		(foo "var" 123)
+		(= (foo "var" (* $it 2)) 246)
+
+		; nested eval implicit indexing
+		(set 'x '(0))
+		(set 'y 'x)
+		(setf ((eval y) 0) (+ $it 1))
+		(setf ((eval y) 0) (+ $it 1))
+		(= x '(2))
+	
+		; nested eval i assoc
+		(set 'L '((a 1) (b 2)))
+		(set 'K 'L)
+		(setf (assoc 'b (eval K)) '(b 3))
+		(= L '((a 1) (b 3)))
+		; check protection
+		(constant 'L)
+		(not (catch (setf (assoc 'b (eval K)) '(b 3)) 'err))		
+		
+		; apply should keep ref
+		(= (push 'z (apply set '(a ()))) '(z))
+		(= a '(z))
+
+		; setf on strings
+		(set 's "abcdefg")
+		(= (setf (s 3) "D") "D")
+		(= s "abcDefg")
+		(= (setf ((replace "a" s "A") 1) "B") "B")
+		(= s "ABcDefg")
+
+		; setf on strings with anaphoric $it
+		(set 's "abcdefg")
+		(set 'idx 0)
+		(= (setf (s (+ idx 1)) (upper-case $it)) "B")
+		(= s "aBcdefg")
+
+		; other nested expression and $it
+		(set 's "a-b-c-d-e-f-g")
+        (= (setf (first (replace "-" s "")) (upper-case $it)) "A")
+        (= s "Abcdefg")
+
+		; don't mistake context in setf/setq symbol for default symbol
+		; and take as equal a context symbol and a context
+		(context 'CTX) 
+		(context 'MAIN) 
+		(setq new-ctx (new CTX 'First))
+		(= new-ctx 'First First)
+		(setq new-ctx (new CTX 'Second))
+		(= new-ctx 'Second Second)
+
+		; loops
+		(not (set 'lst '()))
+		(setf (last (for (i 0 5) (push i lst))) 100)
+		(= lst '(5 4 3 2 1 100))
+		(setq str "")
+		(setf (first (dotimes (i 5) (push "X" str))) "Y")
+		(= str "YXXXX")
+		(not (set 'lst '()))
+		(= (dostring (c str) (push c lst)) '(88 88 88 88 89))	
+		)
+
+		; impicit indexing
+		(set 'lst '(a b c d e f g))
+		(setf (lst 1) (lst 2))
+		(= lst '(a c c d e f g))
+)
+
+(println)
+
+(if (qa-ref)
+	(println ">>>>> Reference testing SUCCESSFUL")
+	(println ">>>>> PROBLEM in reference testing")
+)
+
+
+(exit)
+
diff --git a/qa-specific-tests/qa-setsig b/qa-specific-tests/qa-setsig
new file mode 100755
index 0000000..b33fffa
--- /dev/null
+++ b/qa-specific-tests/qa-setsig
@@ -0,0 +1,63 @@
+#!/usr/bin/newlisp
+#
+# check out customized signal handlers
+#
+# USAGE: qa-setsig <low-bound> <high-bound>
+#
+# example: qa-setsig 1 8
+#
+# checks all signals between 1 and 8
+#
+# run without arguments for testing 1-8, 10-16
+#
+# USAGE: qa-setsig
+#
+
+(println)
+(println "Testing signals")
+
+(when (find ostype '("Windows"))
+	(println "Cannot run qa-signal on this platform because uses 'fork'")
+	(exit))
+
+(set 'low (int (main-args 2)))
+(set 'high (int (main-args 3)))
+(set 'pid (sys-info -3))
+
+(if low
+	(println "low=" low " hight=" high " pid=" pid))
+
+(define (alarm sig)
+	(if (= sig high) (set 'done true)) 
+	(print "sig-" sig " ")
+	(push sig result-list -1)
+)
+
+(if (and low high) 
+	(set 'sig-list (sequence low high))
+	(set 'sig-list (append (sequence 1 8) (sequence 10 16))))
+
+(set 'high (last sig-list))
+
+(dolist (s sig-list) (signal s alarm))
+
+(fork (begin
+		(dolist (s sig-list)
+			(sleep 200)
+			(destroy pid (int s)))
+		(sleep 200)
+;		(destroy pid 9)
+))
+
+(println)
+(while (not done)  (print ".") (sleep 100))
+(println)
+(println "sent: " sig-list)
+(println "received: " result-list)
+(println)
+(if (= result-list sig-list)
+	(println ">>>>> Signal testing SUCCESSFUL")
+	(println ">>>>> PROBLEM in signal TESTING"))
+
+(println)
+(exit)
diff --git a/qa-specific-tests/qa-siguser b/qa-specific-tests/qa-siguser
new file mode 100755
index 0000000..adcc042
--- /dev/null
+++ b/qa-specific-tests/qa-siguser
@@ -0,0 +1,35 @@
+#!/usr/bin/newlisp
+
+;; numbers and names may be different on
+;; your platform look int:
+;; /usr/include/sys/signal.h or
+;; /usr/include/signal.h
+
+(define SIGUSR1 30)
+(define SIGUSR2 31)
+
+(define (myhandler s)
+	(println "signal " s " was fired")
+)
+
+; setup the handler
+(signal SIGUSR1 myhandler)
+(signal SIGUSR2 myhandler)
+
+(set 'mypid (sys-info -3))
+
+(dotimes (i 6)
+	(sleep 500)
+	(exec (string "kill -" SIGUSR1 " " mypid))
+	(exec (string "kill -" SIGUSR2 " " mypid))
+)
+
+(exit)
+
+
+
+
+
+
+
+
diff --git a/qa-specific-tests/qa-statdist b/qa-specific-tests/qa-statdist
new file mode 100755
index 0000000..795f098
--- /dev/null
+++ b/qa-specific-tests/qa-statdist
@@ -0,0 +1,88 @@
+#!/usr/bin/newlisp
+
+(define (test-prob-t)
+  (and
+    (< (abs (sub (prob-t 1.886 2) 0.1)) 0.001)
+    (< (abs (sub (prob-t 1.303 40) 0.1)) 0.001)
+    (< (abs (sub (prob-t 6.965 2) 0.01)) 0.0001)
+    (< (abs (sub (prob-t 2.423 40) 0.01)) 0.0001)
+))
+
+(define (test-crit-t)
+  (and
+    (< (abs (sub (crit-t (prob-t 1.886 2) 2) 1.886)) 0.001)
+    (< (abs (sub (crit-t (prob-t 1.303 40) 40) 1.303)) 0.001)
+    (< (abs (sub (crit-t (prob-t 6.965 2) 2) 6.965)) 0.001)
+    (< (abs (sub (crit-t (prob-t 2.423 40) 40) 2.423)) 0.001)
+))
+
+(define (test-prob-f)
+  (and
+    (< (abs (sub (prob-f 6.59 3 4) 0.05)) 0.001)
+    (< (abs (sub (prob-f 2.79 12 11) 0.05)) 0.001)
+    (< (abs (sub (prob-f 16.69 3 4) 0.01)) 0.0001)
+    (< (abs (sub (prob-f 4.40 12 11) 0.01)) 0.0001)
+))
+    
+
+(define (test-crit-f)
+  (and
+    (< (abs (sub (crit-f (prob-f 6.59 3 4) 3 4) 6.59)) 0.001)
+    (< (abs (sub (crit-f (prob-f 2.79 12 11) 12 11) 2.79)) 0.001)
+    (< (abs (sub (crit-f (prob-f 16.59 3 4) 3 4) 16.59)) 0.001)
+    (< (abs (sub (crit-f (prob-f 4.40 12 11) 12 11) 4.40)) 0.001)
+))
+
+
+(define (test-prob-chi2)
+  (and
+    (< (abs (sub (prob-chi2 4.605 2) 0.1)) 0.001)
+    (< (abs (sub (prob-chi2 51.805 40) 0.1)) 0.001)
+    (< (abs (sub (prob-chi2 9.210 2) 0.01)) 0.0001)
+    (< (abs (sub (prob-chi2 63.691 40) 0.01)) 0.0001)
+))
+    
+(define (test-crit-chi2)
+  (and
+    (< (abs (sub (crit-chi2 (prob-chi2 4.605 2) 2) 4.605)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 51.805 40) 40) 51.805)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 9.210 2) 2) 9.210)) 0.001)
+    (< (abs (sub (crit-chi2 (prob-chi2 63.691 40) 40) 63.691)) 0.001)
+))
+
+(define (test-crit-z)
+(for (z -6 6 0.3)
+  (let (flag true)
+    (if (> (abs (sub (crit-z (prob-z z)) z)) 0.0001)
+        (set 'flag nil))
+  flag)
+))
+        
+(define (test-prob-z)
+    (and
+        (< (sub (prob-z -0.1) 0.4601721627) 0.00001)
+        (< (sub (prob-z 0.1) 0.5398278373) 0.00001)
+        (< (sub (prob-z -1) 0.1586552539) 0.00001)
+        (< (sub (prob-z 1) 0.8413447461) 0.00001)
+        (< (sub (prob-z -2) 0.02275013195) 0.00001)
+        (< (sub (prob-z 2) 0.9772498681) 0.00001)
+        (< (sub (prob-z -3) 0.001349898032) 0.00001)
+        (< (sub (prob-z 3) 0.998650102) 0.00001)
+))
+
+(if (not (and
+        (test-prob-f)
+        (test-crit-f)
+        (test-prob-chi2)
+        (test-crit-chi2)
+        (test-prob-t)
+        (test-crit-t)
+        (test-prob-z)
+        (test-crit-z)))
+
+	(println ">>>>> PROBLEM in statistical distributions tests")
+	(println ">>>>> Statisitical distribution tests SUCCESSFUL")
+)
+
+(exit)
+
diff --git a/qa-specific-tests/qa-udp b/qa-specific-tests/qa-udp
new file mode 100755
index 0000000..37a84c3
--- /dev/null
+++ b/qa-specific-tests/qa-udp
@@ -0,0 +1,65 @@
+#!/usr/bin/newlisp
+
+(println)
+(println "Testing UDP communicatiobs with spawned processes")
+
+; benchmark net work functions with spawned processes
+
+; non-blocking simole UDP communications
+
+(set 'N
+	(case ostype
+		("Linux" 1000)
+		("Cygwin" 1000)
+		("BSD" 1000)
+		("OSX" 10000)
+		("Tru64Unix" 1000)
+		("Solaris" 1000)
+		("SunOS" 1000)
+		(true (println ">>>>> UDP Not supported on this OS - will exit") 
+			(exit))
+	)
+)
+
+(set 'cpid (spawn 'r 
+	(begin
+		(sleep 300)
+		(for (i 1 N)
+			(sleep 0.2) ; increase if losing to much
+			(net-send-udp "localhost" 12345 (string i))
+		)
+	(exit)
+	)
+))
+
+(println (sync))
+
+(set 'start (time-of-day))
+(set 'counter 0)
+(set 'timeout '2000000)
+(until finished
+	(set 'buff (net-receive-udp 12345 100 timeout))
+	(if buff
+		(begin
+			(inc counter) 
+			(print "-> " (first buff) "\r")
+			(if (= (int (first buff)) N) (set 'finished true)))
+		(begin
+			(println "finished ->" (net-error))
+			(if (= (first (net-error)) 17)
+				(inc start (/ timeout 1000))) ; account for timeout
+			(set 'finished true))
+	)
+)
+
+(set 'duration (- (time-of-day) start))
+(println "received " counter  " (" (mul (div counter N) 100) 
+        "%) of " N " messages in " duration " ms")
+(println (div duration counter) " ms per message")
+
+(abort)
+
+(println ">>>>> Benchmarked UDP API")
+
+(exit)
+
diff --git a/qa-specific-tests/qa-utf16path b/qa-specific-tests/qa-utf16path
new file mode 100755
index 0000000..f27220f
--- /dev/null
+++ b/qa-specific-tests/qa-utf16path
@@ -0,0 +1,135 @@
+#!/usr/bin/newlisp
+
+;; qa-utf16path - check WIN_32 file and directory routines on 
+;; UTF-16 encoded paths
+
+;; run with N = 10000 to check for memory leaks
+;; ./qa-utf16path 10000
+;; newlisp qa-utf16path 10000
+
+
+(println)
+(println "Testing UTF-16 path names")
+
+(if (main-args 2)
+	(setq N (int (main-args 2)))
+	(setq N 10))
+
+(when (= 0 (& (sys-info -1) 128))
+		(println ">>>>> qa-utf16path: This test is only used on UTF8 enabled versions.")
+		(exit)
+)
+
+(set 'Yuki "\230\162\182\230\181\166\231\148\177\232\168\152")
+(set 'InvalidUTF8 "\xC0\xC1")
+
+(set 'UnicodeStr Yuki)
+
+(set 'h 1) ; pre allocate mem so changes should be minimal
+(set 'sRand 
+	(join (map char (map (curry + 32)
+		(rand 
+			(- 127 32)
+			(+ 10 90);(rand 100))
+		)
+	)
+)))
+(set 'buff sRand)
+
+
+(define-macro (assert any)
+	(local (result)
+		(when (not (set 'result (eval any)))
+			(println (string " >>>> Expression failed! " any))
+			(setq fail true)
+			(if (> N 10) (exit))
+		)
+		result
+	)
+)
+
+
+(println "Step 1:")
+
+(println (time 
+	(begin 
+		(assert (make-dir UnicodeStr))
+		(assert (remove-dir UnicodeStr))
+	)
+	N	
+))
+
+(println "Step 2:")
+
+(assert (make-dir UnicodeStr))
+(println (time (assert (directory? UnicodeStr)) N))
+(println (time (assert (file? UnicodeStr)) N))
+(println (time (begin
+	(assert (directory))
+	(assert (directory "." UnicodeStr))
+	(assert (= 1 (length (directory "." UnicodeStr))))
+	(assert (real-path UnicodeStr))
+	(assert (change-dir UnicodeStr))
+	(assert (real-path))
+	(assert (directory))
+	(assert (change-dir ".."))
+) N))
+(assert (remove-dir UnicodeStr))
+
+(println "Step 3:")
+		
+(println (time
+	(begin
+		(assert (write-file UnicodeStr sRand))
+		(assert (= (read-file UnicodeStr) sRand))
+		(assert (append-file UnicodeStr (reverse sRand)))
+		(assert (delete-file UnicodeStr))
+	)
+N ))
+
+(println "Step 4:")
+
+(assert (write-file UnicodeStr sRand))
+
+(println (time (assert (not (directory? UnicodeStr))) N))
+(println (time (assert (file? UnicodeStr)) N))
+
+(println (time (assert (file-info UnicodeStr)) N))
+
+(println "Step 5:")
+
+(println (time (begin
+	(assert (set 'h (open UnicodeStr "w")))
+	(assert (write-buffer h sRand))
+	(assert (close h))
+	(assert (set 'h (open UnicodeStr "a")))
+	(assert (write-buffer h (reverse sRand)))
+	(assert (close h))
+	(assert (set 'h (open UnicodeStr "r")))
+	(assert (read-buffer h buff 1024))
+	(assert (close h))
+	(assert (rename-file UnicodeStr "foo"))
+	(assert (rename-file "foo" UnicodeStr))
+	(assert (rename-file UnicodeStr UnicodeStr))
+	(when (find ostype '("Windows" "Cygwin"))
+		(assert (not (rename-file UnicodeStr InvalidUTF8)))
+		(assert (not (rename-file InvalidUTF8 InvalidUTF8)))
+		(assert (not (rename-file InvalidUTF8 UnicodeStr)))
+	)
+) N))
+
+(assert (delete-file UnicodeStr))
+
+(println "Step 6:")
+
+(println (time (save UnicodeStr) N))
+
+(assert (delete-file UnicodeStr))
+
+(if-not fail
+	(println ">>>>> UTF-16 path-file-names testing SUCCESSFUL")
+	(println ">>>>> PROBLEM with UTF-16 path-file-names processing")
+)
+
+(exit)
+
diff --git a/qa-specific-tests/qa-utf8 b/qa-specific-tests/qa-utf8
new file mode 100755
index 0000000..7af020b
--- /dev/null
+++ b/qa-specific-tests/qa-utf8
@@ -0,0 +1,145 @@
+#!/usr/bin/newlisp
+#
+# a selection of languages from from 
+# http://www.columbia.edu/kermit/utf8.html
+#
+# see also: http://www.unicode.org/charts/
+#
+
+(println)
+(println "Testing UTF-8 font display capabilities")
+
+(context 'L)
+(set 'Albanian "Un\195\171 mund t\195\171 ha qelq dhe nuk m\195\171 gjen gj\195\171.")
+
+(set 'Arabic "\216\163\217\134\216\167 \217\130\216\167\216\175\216\177 \216\185\217\132\217\137 \216\163\217\131\217\132 \216\167\217\132\216\178\216\172\216\167\216\172 \217\136 \217\135\216\176\216\167 \217\132\216\167 \217\138\216\164\217\132\217\133\217\134\217\138. ")
+
+(set 'Armenian "\212\191\214\128\213\182\213\161\213\180 \213\161\213\186\213\161\213\175\213\171 \213\184\214\130\213\191\213\165\213\172 \214\135 \213\171\213\182\213\174\213\171 \213\161\213\182\213\176\213\161\213\182\213\163\213\171\213\189\213\191 \213\185\213\168\213\182\213\165\214\128\214\137")
+
+(set 'Braille " \226\160\138\226\160\128\226\160\137\226\160\129\226\160\157\226\160\128\226\160\145\226\160\129\226\160\158\226\160\128\226\160\155\226\160\135\226\160\129\226\160\142\226\160\142\226\160\128\226\160\129\226\160\157\226\160\153\226\160\128\226\160\138\226\160\158\226\160\128\226\160\153\226\160\149\226\160\145\226\160\142\226\160\157\226\160\158\226\160\128\226\160\147\226\160\165\226\160\151\226\160\158\226\160\128\226\160\141\226\160\145")
+
+(set 'Bulgarian "\208\156\208\190\208\179\208\176 \208\180\208\176 \209\143\208\188 \209\129\209\130\209\138\208\186\208\187\208\190, \209\130\208\190 \208\189\208\181 \208\188\208\184 \208\178\209\128\208\181\208\180\208\184.")
+
+(set 'Chamorro "Si\195\177a yo' chumocho krestat, ti ha na'lalamen yo'.")
+
+(set 'Chinese1 "\230\136\145\232\131\189\229\144\158\228\184\139\231\142\187\231\146\131\232\128\140\228\184\141\228\188\164\232\186\171\228\189\147\227\128\130")
+
+(set 'Chinese2 "\230\136\145\232\131\189\229\144\158\228\184\139\231\142\187\231\146\131\232\128\140\228\184\141\229\130\183\232\186\171\233\171\148\227\128\130")
+
+(set 'Croatian "Ja mogu jesti staklo i ne boli me.")
+
+(set 'Czech "Mohu j\195\173st sklo, neubl\195\173\197\190\195\173 mi.")
+
+(set 'Danish "Jeg kan spise glas, det g\195\184r ikke ondt p\195\165 mig.")
+
+(set 'Dutch "Ik kan glas eten, het doet m\196\179 geen kwaad.")
+
+(set 'English "I can eat glass and it doesn't hurt me.")
+
+(set 'EnglishIPA "[a\201\170 k\195\166n i\203\144t gl\201\145\203\144s \195\166nd \201\170t d\201\144z n\201\146t h\201\156\203\144t mi\203\144")
+
+(set 'Esperanto "Mi povas man\196\157i vitron, \196\157i ne dama\196\157as min. ")
+
+(set 'Estonian "Ma v\195\181in klaasi s\195\188\195\188a, see ei tee mulle midagi.")
+
+(set 'Farsi " .\217\133\217\134 \217\133\219\140 \216\170\217\136\216\167\217\134\217\133 \216\168\216\175\217\136\217\134\217\144 \216\167\216\173\216\179\216\167\216\179 \216\175\216\177\216\175 \216\180\217\138\216\180\217\135 \216\168\216\174\217\136\216\177\217\133")
+
+(set 'French "Je peux manger du verre, \195\167a ne me fait pas de mal.")
+
+(set 'German "Ich kann Glas essen, ohne mir weh zu tun.")
+
+(set 'Greek "\225\189\149\206\177\206\187\206\191\206\189 \207\149\206\177\206\179\206\181\225\191\150\206\189 \206\180\225\189\187\206\189\206\177\206\188\206\177\206\185\206\135 \207\132\206\191\225\191\166\207\132\206\191 \206\191\225\189\148 \206\188\206\181 \206\178\206\187\225\189\177\207\128\207\132\206\181\206\185.")
+
+(set 'Hausa "\216\165\217\144\217\134\216\167 \216\165\217\144\217\137\217\142 \216\170\217\142\217\136\217\134\217\142\216\177 \216\186\217\144\217\132\217\142\216\167\216\180\217\144 \217\131\217\143\217\133\217\142 \216\165\217\144\217\134 \216\186\217\142\217\133\217\142\216\167 \217\132\217\142\216\167\217\129\217\144\217\137\217\142\216\167")
+
+(set 'Hebrew "\215\144\215\160\215\153 \215\153\215\155\215\149\215\156 \215\156\215\144\215\155\215\149\215\156 \215\150\215\155\215\149\215\155\215\153\215\170 \215\149\215\150\215\148 \215\156\215\144 \215\158\215\150\215\153\215\167 \215\156\215\153.")
+
+(set 'Hindi "\224\164\174\224\165\136\224\164\130 \224\164\149\224\164\190\224\164\129\224\164\154 \224\164\150\224\164\190 \224\164\184\224\164\149\224\164\164\224\164\190 \224\164\185\224\165\130\224\164\129, \224\164\174\224\165\129\224\164\157\224\165\135 \224\164\137\224\164\184 \224\164\184\224\165\135 \224\164\149\224\165\139\224\164\136 \224\164\170\224\165\128\224\164\161\224\164\190 \224\164\168\224\164\185\224\165\128\224\164\130 \224\164\185\224\165\139\224\164\164\224\165\128.")
+
+(set 'Irish "Is f\195\169idir liom gloinne a ithe. N\195\173 dh\195\169anann s\195\173 dochar ar bith dom.")
+
+(set 'Italian "Posso mangiare il vetro e non mi fa male.")
+
+(set 'Japanese "\231\167\129\227\129\175\227\130\172\227\131\169\227\130\185\227\130\146\233\163\159\227\129\185\227\130\137\227\130\140\227\129\190\227\129\153\227\128\130\227\129\157\227\130\140\227\129\175\231\167\129\227\130\146\229\130\183\227\129\164\227\129\145\227\129\190\227\129\155\227\130\147\227\128\130")
+
+(set 'Korean "\235\130\152\235\138\148 \236\156\160\235\166\172\235\165\188 \235\168\185\236\157\132 \236\136\152 \236\158\136\236\150\180\236\154\148. \234\183\184\235\158\152\235\143\132 \236\149\132\237\148\132\236\167\128 \236\149\138\236\149\132\236\154\148")
+
+(set 'Latvian "Es varu \196\147st stiklu, tas man nekait\196\147.")
+
+(set 'Lithuanian "A\197\161 galiu valgyti stikl\196\133 ir jis man\196\153s ne\197\190eid\197\190ia ")
+
+(set 'Macedonian "\208\156\208\190\208\182\208\176\208\188 \208\180\208\176 \209\152\208\176\208\180\208\176\208\188 \209\129\209\130\208\176\208\186\208\187\208\190, \208\176 \208\189\208\181 \208\188\208\181 \209\136\209\130\208\181\209\130\208\176.")
+
+(set 'Malay "Saya boleh makan kaca dan ia tidak mencederakan saya.")
+
+(set 'Marathi "\224\164\174\224\165\128 \224\164\149\224\164\190\224\164\154 \224\164\150\224\164\190\224\164\138 \224\164\182\224\164\149\224\164\164\224\165\139, \224\164\174\224\164\178\224\164\190 \224\164\164\224\165\135 \224\164\166\224\165\129\224\164\150\224\164\164 \224\164\168\224\164\190\224\164\185\224\165\128.")
+
+(set 'Mongolian1 "\208\145\208\184 \209\136\208\184\208\187 \208\184\208\180\209\141\208\185 \209\135\208\176\208\180\208\189\208\176, \208\189\208\176\208\180\208\176\208\180 \209\133\208\190\209\128\209\130\208\190\208\185 \208\177\208\184\209\136")
+
+(set 'Mongolian2 "\225\160\170\225\160\162 \225\160\176\225\160\162\225\160\175\225\160\162 \225\160\162\225\160\179\225\160\161\225\160\182\225\160\166 \225\160\180\225\160\162\225\160\179\225\160\160\225\160\168\225\160\160 \225\160\130 \225\160\168\225\160\160\225\160\179\225\160\164\225\160\183 \225\160\172\225\160\163\225\160\164\225\160\183\225\160\160\225\160\179\225\160\160\225\160\162 \225\160\170\225\160\162\225\160\176\225\160\162 ")
+
+(set 'Norvegian "Jeg kan spise glass uten \195\165 skade meg. ")
+
+(set 'Pashto "\216\178\217\135 \216\180\217\138\216\180\217\135 \216\174\217\136\218\147\217\132\219\144 \216\180\217\133\216\140 \217\135\216\186\217\135 \217\133\216\167 \217\134\217\135 \216\174\217\136\218\150\217\136\217\138")
+
+(set 'Polish "Mog\196\153 je\197\155\196\135 szk\197\130o i mi nie szkodzi.")
+
+(set 'Portugese "Posso comer vidro, n\195\163o me faz mal.")
+
+(set 'Russian "\208\175 \208\188\208\190\208\179\209\131 \208\181\209\129\209\130\209\140 \209\129\209\130\208\181\208\186\208\187\208\190, \208\190\208\189\208\190 \208\188\208\189\208\181 \208\189\208\181 \208\178\209\128\208\181\208\180\208\184\209\130.")
+
+(set 'Sanskrit "\224\164\149\224\164\190\224\164\154\224\164\130 \224\164\182\224\164\149\224\165\141\224\164\168\224\165\139\224\164\174\224\165\141\224\164\175\224\164\164\224\165\141\224\164\164\224\165\129\224\164\174\224\165\141 \224\165\164 \224\164\168\224\165\139\224\164\170\224\164\185\224\164\191\224\164\168\224\164\184\224\165\141\224\164\164\224\164\191 \224\164\174\224\164\190\224\164\174\224\165\141 \224\165\165")
+
+(set 'Serbian "\208\156\208\190\208\179\209\131 \209\152\208\181\209\129\209\130\208\184 \209\129\209\130\208\176\208\186\208\187\208\190 \208\176 \208\180\208\176 \208\188\208\184 \208\189\208\181 \209\136\208\186\208\190\208\180\208\184.")
+
+(set 'Slovak "M\195\180\197\190em jes\197\165 sklo. Nezran\195\173 ma.")
+
+(set 'Slovenian "Lahko jem steklo, ne da bi mi \197\161kodovalo.")
+
+(set 'Spanish "Puedo comer vidrio, no me hace da\195\177o.")
+
+(set 'SwahiliKI "Naweza kula bilauri na sikunyui.")
+
+(set 'Swedish "Jag kan \195\164ta glas utan att skada mig.")
+
+(set 'Tagalog "Kaya kong kumain nang bubog at hindi ako masaktan.")
+
+(set 'Tamil "\224\174\168\224\174\190\224\174\169\224\175\141 \224\174\149\224\174\163\224\175\141\224\174\163\224\174\190\224\174\159\224\174\191 \224\174\154\224\174\190\224\174\170\224\175\141\224\174\170\224\174\191\224\174\159\224\175\129\224\174\181\224\175\135\224\174\169\224\175\141, \224\174\133\224\174\164\224\174\169\224\174\190\224\174\178\224\175\141 \224\174\142\224\174\169\224\174\149\224\175\141\224\174\149\224\175\129 \224\174\146\224\174\176\224\175\129 \224\174\149\224\175\135\224\174\159\224\175\129\224\174\174\224\175\141 \224\174\181\224\174\176\224\174\190\224\174\164\224\175\129.")
+
+(set 'Thai "\224\184\137\224\184\177\224\184\153\224\184\129\224\184\180\224\184\153\224\184\129\224\184\163\224\184\176\224\184\136\224\184\129\224\185\132\224\184\148\224\185\137 \224\185\129\224\184\149\224\185\136\224\184\161\224\184\177\224\184\153\224\185\132\224\184\161\224\185\136\224\184\151\224\184\179\224\185\131\224\184\171\224\185\137\224\184\137\224\184\177\224\184\153\224\185\128\224\184\136\224\185\135\224\184\154")
+
+(set 'Tibetan "\224\189\164\224\189\186\224\189\163\224\188\139\224\189\166\224\190\146\224\189\188\224\188\139\224\189\159\224\188\139\224\189\147\224\189\166\224\188\139\224\189\132\224\188\139\224\189\147\224\188\139\224\189\130\224\189\178\224\188\139\224\189\152\224\188\139\224\189\162\224\189\186\224\189\145\224\188\141")
+
+(set 'Turkish "\216\172\216\167\217\133 \217\138\217\138\217\135 \216\168\217\132\217\136\216\177\217\133 \216\168\218\173\216\167 \216\182\216\177\216\177\217\137 \216\183\217\136\217\130\217\136\217\134\217\133\216\178")
+
+(set 'Ukranian "\208\175 \208\188\208\190\208\182\209\131 \209\151\209\129\209\130\208\184 \209\136\208\186\208\187\208\190, \208\185 \208\178\208\190\208\189\208\190 \208\188\208\181\208\189\209\150 \208\189\208\181 \208\191\208\190\209\136\208\186\208\190\208\180\208\184\209\130\209\140.")
+
+(set 'Urdu "\217\133\219\140\218\186 \218\169\216\167\217\134\218\134 \218\169\218\190\216\167 \216\179\218\169\216\170\216\167 \219\129\217\136\218\186 \216\167\217\136\216\177 \217\133\216\172\218\190\219\146 \216\170\218\169\217\132\219\140\217\129 \217\134\219\129\219\140\218\186 \219\129\217\136\216\170\219\140 \219\148")
+
+(set 'Vietnamese "\228\186\155 \240\163\142\143 \228\184\150 \229\146\185 \230\176\180 \230\153\182 \240\166\147\161 \231\169\186 \240\163\142\143 \229\174\179 \229\146\166 ")
+
+(set 'Yiddish "\215\144\215\153\215\154 \215\167\215\162\215\159 \215\162\215\161\215\159 \215\146\215\156\215\144\214\184\215\150 \215\144\215\149\215\159 \215\162\215\161 \215\152\215\149\215\152 \215\158\215\153\215\168 \215\160\215\153\215\169\215\152 \215\176\215\178. ")
+
+(set 'Yoruba "Mo l\195\168 je\204\169 d\195\173g\195\173, k\195\178 n\195\173 pa m\195\173 l\195\161ra.")
+
+(context MAIN)
+
+(dotree (l L)
+	(println (term l) ":" (eval l)))
+
+;(println "\239\163\191")
+(println (char 63743))
+
+(println ">>>>> Tested UTF-8 font and display performance")
+(exit)
+;; eof
+
+; utf8 test data
+
+; should show Chinese characters if editor or terminal is UTF-8 capable
+; (set 'utf8str "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚")
+
+;(set 'utf8chars '(25105 33021 21534 19979 29627 29827 32780 19981 20260 36523 20307 12290))
+;(set 'utf8str (join (map char utf8chars)))
+;(= (map char (explode utf8str)) utf8chars)
+
diff --git a/qa-specific-tests/qa-utf8-char-regex b/qa-specific-tests/qa-utf8-char-regex
new file mode 100755
index 0000000..791ecc1
--- /dev/null
+++ b/qa-specific-tests/qa-utf8-char-regex
@@ -0,0 +1,36 @@
+#!/usr/bin/newlisp
+
+(define (utf8-char-tests) 
+  (and
+    (= (char "ํ‚˜") 0xd098)
+    (= "ํ‚˜" (char 0xd098))
+    (= (char "ํ€ฟ") 0xd03f)
+    (= "ํ€ฟ" (char 0xd03f))
+    (= (char "ฮฉ") 937)
+    (= "ฮฉ" (char 937))
+    (= (char "ฮฆ") 934)
+    (= "ฮฆ" (char 934))
+))
+
+(define (utf8-regex-tests)
+  (and
+    (= (regex "ํ‚˜" "ํ‚˜") '("ํ‚˜" 0 3))
+    (= (regex "ํ€ฟ" "ํ€ฟ") '("ํ€ฟ" 0 3))
+    (= (regex "ฮฉ" "ฮฆabcฮฉdef") '("ฮฉ" 5 2))
+    (= (regex "ฮฆ" "ฮฉabcฮฆdef") '("ฮฆ" 5 2))
+))
+
+(if (utf8-char-tests)
+    (println ">>>>> utf8-char-tests SUCESSFUL")
+    (println ">>>>> ERROR in utf8-char-tests")
+    )
+
+
+(if (utf8-regex-tests)
+    (println ">>>>> utf8-regex-tests SUCESSFUL")
+    (println ">>>>> ERROR in utf8-regex-tests")
+    )
+
+
+(exit)
+
diff --git a/qa-specific-tests/qa-utf8-compile b/qa-specific-tests/qa-utf8-compile
new file mode 100755
index 0000000..fd1fb19
--- /dev/null
+++ b/qa-specific-tests/qa-utf8-compile
@@ -0,0 +1,8 @@
+#!/usr/bin/newlisp
+
+(if (catch (regex-comp "ใปใ’ใปใ’" 0x800) 'result)
+	(println ">>>>> UTF-8 compile SUCESSFULL")
+	(println ">>>>> PROBLEM in UTF-8 compile:\n" result))
+
+(exit)
+
diff --git a/qa-specific-tests/qa-utf8-ext b/qa-specific-tests/qa-utf8-ext
new file mode 100644
index 0000000..b699fbc
--- /dev/null
+++ b/qa-specific-tests/qa-utf8-ext
@@ -0,0 +1,36 @@
+๏ปฟ#!/usr/bin/newlisp
+
+(println "raw:      " (set 'utf8str "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚"))
+(set 'utf8str-ext " \n ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚ \t ")
+(print "dostring: ") (dostring (c utf8str) (print(char c)))
+(println)
+(print "unicode: ") (dostring (c utf8str) (print c " "))
+(println)
+
+(println "length raw, utf8: " (length utf8str) ", " 
+          (if utf8len (utf8len utf8str) " no utf8 version"))
+(println)
+(println "(= (trim utf8str) utf8str)) => " (= (trim utf8str) utf8str))
+(println "(= (trim utf8str-ext) utf8str)) => " (= (trim utf8str-ext) utf8str)) 
+(println)
+
+(println "unpack raw, trimmed, trimmed with 2nd parameter")
+(println (unpack (dup "b" 36) utf8str))
+(println (unpack (dup "b" 36) (trim utf8str)))
+(println (unpack (dup "b" 36) (trim utf8str " ")))
+
+(println "explode raw, trimmed, trimmed with 2nd parameter")
+(println (explode utf8str))
+(println (explode (trim utf8str)))
+(println (explode (trim utf8str " " " ")))
+
+(println "(map char (explode ...)) raw, trimmed, trimmed with 2nd parameter")
+(println (map char (explode utf8str)))
+(println (map char (explode (trim utf8str))))
+(println (map char (explode (trim utf8str " " " "))))
+
+;(bits 21534) ; 3rd correct
+;(bits 24542) ; 3rd on Java GS
+
+(exit)
+
diff --git a/qa-specific-tests/qa-utf8-special b/qa-specific-tests/qa-utf8-special
new file mode 100755
index 0000000..bbc98df
--- /dev/null
+++ b/qa-specific-tests/qa-utf8-special
@@ -0,0 +1,31 @@
+#!/usr/bin/env newlisp
+
+; regex compile of UTF-8 patterns
+
+(if (catch (regex-comp "ใปใ’ใปใ’" 0x800) 'result)
+    (println "UTF-8 compile sucessfull")
+    (println "problem in UTF-8 compile"))
+
+; UTF-8 - transforming from and to nmbers, upper-case'ing and lower-case'ing
+
+; should show Chinese characters if editor or terminal is UTF-8 capable
+(println "characters entered by keyboard:")
+
+(println (set 'utf8str "ๆˆ‘่ƒฝๅžไธ‹็Žป็’ƒ่€Œไธไผค่บซไฝ“ใ€‚"))
+
+(println "should look the same as made from unicode numbers:")
+
+(set 'utf8chars '(25105 33021 21534 19979 29627 29827 32780 19981 20260 36523 20307 12290))
+(println (set 'utf8str (join (map char utf8chars))))
+
+(print "and be transformd back to the same numbers: ")
+(println (= (map char (explode utf8str)) utf8chars))
+
+(println "checking upper-case'ing on russian letters")
+(println "ะฐะฑะฒะณะดะตั‘ะถะทะธะนะบะปะผะฝะพะฟั€ัั‚ัƒั„ั…ั†ั‡ัˆั‰ัŠั‹ัŒััŽั")
+(println (upper-case "ะฐะฑะฒะณะดะตั‘ะถะทะธะนะบะปะผะฝะพะฟั€ัั‚ัƒั„ั…ั†ั‡ัˆั‰ัŠั‹ัŒััŽั") " should be uppercase of previous")
+(println (lower-case (upper-case "ะฐะฑะฒะณะดะตั‘ะถะทะธะนะบะปะผะฝะพะฟั€ัั‚ัƒั„ั…ั†ั‡ัˆั‰ัŠั‹ัŒััŽั")) " and back to lowercase")
+
+(exit)
+
+
diff --git a/qa-specific-tests/qa-win-dll b/qa-specific-tests/qa-win-dll
new file mode 100755
index 0000000..ce748f7
--- /dev/null
+++ b/qa-specific-tests/qa-win-dll
@@ -0,0 +1,51 @@
+#!/usr/bin/newlisp
+
+;; test newlisp DLL
+
+(println)
+(println "Testing Windows DLL calls")
+
+(unless (find ostype '("Windows"))
+	(println "not tested on " ostype)
+	(exit)
+)
+
+(unless (file-info "newlisp.dll")
+	(println ">>>>> No newlisp.dll found")
+	(exit)
+)
+
+(error-event (fn () 
+    (println ">>>>> ERROR " (first (last-error)) " " (last (last-error)))
+    (exit)
+))
+
+(define (dll-eval expr)
+	(unless newlispEvalStr
+		(import "newlisp.dll" "newlispEvalStr"))
+	(let (result (get-string (newlispEvalStr (string expr))) )
+		(if (starts-with result "\nERR:")
+			"ERROR in DLL call"
+			(read-expr result))
+	)
+)
+
+
+(if (and
+		(println (= (dll-eval '(+ 3 4)) 7))
+		(println (= (dll-eval '(sequence 1 10)) (sequence 1 10)))
+		(println (= (dll-eval '(set 'x 12345)) 12345))
+		(println (= (dll-eval 'x) 12345))
+		(println (= (dll-eval '(foo bar)) "ERROR in DLL call")) )
+
+	(println ">>>>> Windows DLL CALLS SUCCESSFUL")
+	(println ">>>>> PROBLEM IN Windows DLL CALLS")
+)
+
+(println)
+
+(exit)
+
+
+
+
diff --git a/qa-specific-tests/qa-xml b/qa-specific-tests/qa-xml
new file mode 100755
index 0000000..9b1e761
--- /dev/null
+++ b/qa-specific-tests/qa-xml
@@ -0,0 +1,175 @@
+#!/usr/bin/newlisp
+
+# qa-xml - test newLISP xml-parse, xml-type-tags functions
+
+(unless xml-parse
+    (println ">>>>> compiles without XML support")
+    (exit)
+)
+
+(println)
+(println "Testing XML functions")
+
+(set 'example-xml
+[text]
+
+<DATABASE name="example.xml">
+<!--This is a database of fruits-->
+    <FRUIT>
+        <NAME>apple</NAME>
+        <COLOR>red</COLOR>
+        <PRICE>0.80</PRICE>
+    </FRUIT>
+
+    <FRUIT>
+        <NAME>orange</NAME>
+        <COLOR>orange</COLOR>
+        <PRICE>1.00</PRICE>
+    </FRUIT>
+
+    <FRUIT>
+       <NAME>banana</NAME>
+       <COLOR>yellow</COLOR>
+       <PRICE>0.60</PRICE>
+    </FRUIT>
+</DATABASE>
+[/text])
+
+
+(set 'result1 '(
+  ("ELEMENT" "DATABASE" (("name" "example.xml")) (("TEXT" "\n") (
+     "COMMENT" "This is a database of fruits") 
+    ("TEXT" "\n    ") 
+    ("ELEMENT" "FRUIT" () (("TEXT" "\n        ") ("ELEMENT" "NAME" 
+       () 
+       (("TEXT" "apple"))) 
+      ("TEXT" "\n        ") 
+      ("ELEMENT" "COLOR" () (("TEXT" "red"))) 
+      ("TEXT" "\n        ") 
+      ("ELEMENT" "PRICE" () (("TEXT" "0.80"))) 
+      ("TEXT" "\n    "))) 
+    ("TEXT" "\n\n    ") 
+    ("ELEMENT" "FRUIT" () (("TEXT" "\n        ") ("ELEMENT" "NAME" 
+       () 
+       (("TEXT" "orange"))) 
+      ("TEXT" "\n        ") 
+      ("ELEMENT" "COLOR" () (("TEXT" "orange"))) 
+      ("TEXT" "\n        ") 
+      ("ELEMENT" "PRICE" () (("TEXT" "1.00"))) 
+      ("TEXT" "\n    "))) 
+    ("TEXT" "\n\n    ") 
+    ("ELEMENT" "FRUIT" () (("TEXT" "\n       ") ("ELEMENT" "NAME" 
+       () 
+       (("TEXT" "banana"))) 
+      ("TEXT" "\n       ") 
+      ("ELEMENT" "COLOR" () (("TEXT" "yellow"))) 
+      ("TEXT" "\n       ") 
+      ("ELEMENT" "PRICE" () (("TEXT" "0.60"))) 
+      ("TEXT" "\n    "))) 
+    ("TEXT" "\n")))))
+
+
+(set 'result2 '(
+  ("ELEMENT" "DATABASE" (("name" "example.xml")) (("ELEMENT" "FRUIT" 
+     (("ELEMENT" "NAME" (("TEXT" "apple"))) ("ELEMENT" "COLOR" ((
+         "TEXT" "red"))) 
+      ("ELEMENT" "PRICE" (("TEXT" "0.80"))))) 
+    ("ELEMENT" "FRUIT" (("ELEMENT" "NAME" (("TEXT" "orange"))) ("ELEMENT" 
+       "COLOR" 
+       (("TEXT" "orange"))) 
+      ("ELEMENT" "PRICE" (("TEXT" "1.00"))))) 
+    ("ELEMENT" "FRUIT" (("ELEMENT" "NAME" (("TEXT" "banana"))) ("ELEMENT" 
+       "COLOR" 
+       (("TEXT" "yellow"))) 
+      ("ELEMENT" "PRICE" (("TEXT" "0.60")))))))))
+
+
+(set 'result3 '(
+  (DATABASE ((name "example.xml")) (!-- "This is a database of fruits") 
+   (FRUIT (NAME "apple") (COLOR "red") (PRICE "0.80")) 
+   (FRUIT (NAME "orange") (COLOR "orange") (PRICE "1.00")) 
+   (FRUIT (NAME "banana") (COLOR "yellow") (PRICE "0.60")))))
+
+(set 'result4 
+	'((CTX:DATABASE (@ (CTX:name "example.xml")) 
+		(CTX:FRUIT (CTX:NAME "apple") (CTX:COLOR "red") (CTX:PRICE "0.80"))
+		(CTX:FRUIT (CTX:NAME "orange") (CTX:COLOR "orange") (CTX:PRICE "1.00"))
+		(CTX:FRUIT (CTX:NAME "banana") (CTX:COLOR "yellow") (CTX:PRICE "0.60"))))
+)
+
+;(define CTX:msg)
+
+(println "testing: xml-parse and xml-type-tags")
+(define (test-xml-parse)
+  (and
+	(= (xml-type-tags "TEXT" "CDATA" "COMMENT" "ELEMENT")
+		'("TEXT" "CDATA" "COMMENT" "ELEMENT"))
+	(print (= result1 (xml-parse example-xml)) " ")
+	(print (= result2 (xml-parse example-xml (+ 1 2 4))) " ")
+ 	(xml-type-tags nil 'cdata '!-- nil) 
+	(print (= result3 (xml-parse example-xml (+ 1 2 8))) " ")
+	(print (= result4 (xml-parse example-xml (+ 1 2 4 8 16) 'CTX)) " ")
+	(xml-type-tags nil nil nil nil)
+	(print (= (xml-parse "<msg>Hello World</msg>" (+ 1 2 4 8 16) 'CTX)
+    		'((CTX:msg "Hello World"))) )
+    (= (xml-parse "<foo:var>Hello</foo:var>" 31) '((foo.var "Hello")))
+	(begin (println) (println) true)
+))
+
+(if (test-xml-parse)
+	(println ">>>>> XML API tested SUCCESSFUL")
+    (println ">>>>> PROBLEM in XML API"))
+(println)
+
+;; test callback feature
+(define (xml-callback s-expr start size)
+	(if (or (= (s-expr 0) 'NAME) (= (s-expr 0) 'COLOR) (= (s-expr 0) 'PRICE))
+		(begin
+			(print "parsed expresson:" s-expr)
+			(println ", source:" (start size example-xml))
+			(push (list s-expr start size) xml-callback-result -1)
+		)
+	)
+)
+
+
+(set 'xml-callback-result-test
+'(((NAME "apple") 88 18) ((COLOR "red") 115 18) ((PRICE "0.80") 142 19) 
+  ((NAME "orange") 196 19) ((COLOR "orange") 224 21) ((PRICE "1.00") 254 19) 
+  ((NAME "banana") 307 19) ((COLOR "yellow") 334 21) ((PRICE "0.60") 363 19)
+))
+  
+
+(println "Testing xml-parse with callback feature")
+(xml-type-tags nil 'cdata '!-- nil) 
+(set 'xml-callback-result '())
+(xml-parse example-xml (+ 1 2 8) MAIN xml-callback)
+(println)
+;(println "===>"  xml-callback-result)
+;(println "===>"  xml-callback-result-test)
+(println)
+(if (=  xml-callback-result xml-callback-result-test)
+	(println ">>>>> XML callback tested SUCCESSFUL")
+	(println ">>>>> PROBLEM in XML callback")
+)
+
+
+; produces this output:
+[text]
+parsed expresson:(NAME "apple"), source:<NAME>apple</NAME>
+parsed expresson:(COLOR "red"), source:<COLOR>red</COLOR>
+parsed expresson:(PRICE "0.80"), source:<PRICE>0.80</PRICE>
+parsed expresson:(NAME "orange"), source:<NAME>orange</NAME>
+parsed expresson:(COLOR "orange"), source:<COLOR>orange</COLOR>
+parsed expresson:(PRICE "1.00"), source:<PRICE>1.00</PRICE>
+parsed expresson:(NAME "banana"), source:<NAME>banana</NAME>
+parsed expresson:(COLOR "yellow"), source:<COLOR>yellow</COLOR>
+parsed expresson:(PRICE "0.60"), source:<PRICE>0.60</PRICE>
+[/text]
+
+(println)
+(exit)
+
+;; eof
+	
+
diff --git a/unix-lib.c b/unix-lib.c
new file mode 100644
index 0000000..02cdda8
--- /dev/null
+++ b/unix-lib.c
@@ -0,0 +1,185 @@
+/* unix-lib.c - make the newlisp shared newlisp library
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+
+extern int bigEndian;
+extern char preLoad[];
+extern CELL * sysEvalString(char * str, SYMBOL * context, CELL * proc, int mode);
+extern void setupAllSignals(void);
+extern int evalSilent;
+extern int opsys;
+extern SYMBOL * mainArgsSymbol;
+extern char linkOffset[];
+extern FILE * IOchannel;
+extern int newlispLibConsoleFlag;
+
+int libInitialized = 0;
+
+#ifdef MAC_OSX
+#ifdef EMSCRIPTEN
+#define LIBNAME "newlisp-js-lib.js"
+#else
+#define LIBNAME "newlisp.dylib"
+#endif
+#else
+#define LIBNAME "newlisp.so"
+#endif
+
+void initializeMain(void)
+{
+#ifndef EMSCRIPTEN
+char name[MAX_LINE];
+char * initFile;
+#endif
+
+opsys += 64;
+
+#ifdef SUPPORT_UTF8
+opsys += 128;
+#endif
+
+#ifdef NEWLISP64
+opsys += 256;
+#endif
+
+#ifdef FFI
+opsys += 1024;
+initFFI();
+#endif
+
+#ifdef EMSCRIPTEN
+opsys += 2048;
+#endif
+
+bigEndian = (*((char *)&bigEndian) == 0);
+
+
+initLocale();
+initStacks();
+initialize();
+mainArgsSymbol->contents = (UINT)makeCell(CELL_EXPRESSION, (UINT)stuffString(LIBNAME));
+/* setupAllSignals(); taken out for LIBRARY in 10.5.7 */
+sysEvalString(preLoad, mainContext, nilCell, EVAL_STRING);
+
+
+IOchannel = stdin;
+#ifndef EMSCRIPTEN
+initDefaultInAddr(); 
+
+initFile = getenv("NEWLISPLIB_INIT");
+if(initFile)
+    {
+    strncpy(name, initFile, MAX_LINE);
+    name[MAX_LINE - 1] = 0;
+    loadFile(name, 0, 0, mainContext);
+    }
+#endif
+
+libInitialized = 1;
+reset();
+}
+
+extern STREAM errorStream;
+STREAM libStrStream = {NULL, NULL, 0, 0, 0};
+
+/* ---- imported and called from a client using newlisp.so ---- */
+
+char * newlispEvalStr(char * cmd)
+{
+if(!libInitialized) initializeMain();
+
+if(setjmp(errorJump)) 
+    {
+    /* setupAllSignals(); taken out for LIBRARY in 10.5.7 */
+
+    reset();
+    initStacks();
+
+    if(errorReg) 
+        {
+        executeSymbol(errorEvent, NULL, NULL);
+        return(libStrStream.buffer);
+        }
+    else
+        return(errorStream.buffer);
+    }
+
+openStrStream(&libStrStream, MAX_STRING, 1);
+executeCommandLine(cmd, (UINT)&libStrStream, NULL);
+
+if(evalSilent) evalSilent = 0;
+
+return(libStrStream.buffer);
+}
+
+/* don't let stdout be included in return string */
+int newlispLibConsole(int flag)
+{
+newlispLibConsoleFlag = flag;
+return(flag);
+}
+
+#ifdef EMSCRIPTEN
+/* for callbacks 'eval-string-js' is used see p_evalStringJS in newlisp.c */
+#else
+/* callbacks from newlisp library into caller 
+
+currently only tested with newLISP as caller:
+
+(import "newlisp.dylib" "newlispEvalStr")
+(import "newlisp.dylib" "newlispCallback")
+(define (callme p1 p2 p3) (println "p1 => " p1 " p2 => " p2 " p3 => " p3) "hello world")
+(newlispCallback "callme" (callback 0 'callme) "cdecl")
+(get-string (newlispEvalStr {(get-string (callme 123 456 789))})) ; for string return
+;(get-string (newlispEvalStr {(callme 123 456 789)})) ; for number return
+
+*/
+
+long newlispCallback(char * funcName, long funcAddr, char * callType)
+{
+CELL * pCell;
+SYMBOL * symbol;
+
+if(!libInitialized) initializeMain();
+
+if(callType != NULL && strcmp(callType, "stdcall") ==  0)
+    pCell = getCell(CELL_IMPORT_DLL);
+else
+    pCell = getCell(CELL_IMPORT_CDECL);
+
+symbol = translateCreateSymbol(funcName, pCell->type, currentContext, TRUE);
+
+if(isProtected(symbol->flags))
+    {
+    errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol));
+    return(-1);
+    }
+
+deleteList((CELL *)symbol->contents);
+symbol->contents = (UINT)pCell;
+pCell->contents = (UINT)funcAddr;
+
+pCell->aux = (UINT)symbol->name;
+
+return(funcAddr);
+}
+#endif
+/* eof */
diff --git a/util/Android-utf8.mk b/util/Android-utf8.mk
new file mode 100644
index 0000000..c467b41
--- /dev/null
+++ b/util/Android-utf8.mk
@@ -0,0 +1,15 @@
+# newLISP makefile for Android NDK
+# SysV IPC with 'semaphore', readline and utf8 support have been disabled
+# the ANDROID compile flag controls code changes in some of the source files
+# -DSUPPORT_UTF8 can be added if required, then also add nl-utf8.c
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := newlisp
+LOCAL_CFLAGS := -Wall -Wno-long-long -Wno-strict-aliasing -O2 -c -DLINUX -DANDROID -DSUPPORT_UTF8
+LOCAL_LDLIBS := -lm -ldl
+LOCAL_SRC_FILES := newlisp.c nl-symbol.c nl-math.c nl-list.c nl-liststr.c nl-string.c \
+nl-sock.c nl-import.c nl-xml-json.c nl-web.c nl-matrix.c nl-debug.c pcre.c nl-filesys.c nl-utf8.c
+include $(BUILD_EXECUTABLE)
+
diff --git a/util/Android.mk b/util/Android.mk
new file mode 100644
index 0000000..b064954
--- /dev/null
+++ b/util/Android.mk
@@ -0,0 +1,15 @@
+# newLISP makefile for Android NDK
+# SysV IPC with 'semaphore', readline and utf8 support have been disabled
+# the ANDROID compile flag controls code changes in some of the source files
+# -DSUPPORT_UTF8 can be added if required, then also add nl-utf8.c
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := newlisp
+LOCAL_CFLAGS := -Wall -Wno-long-long -Wno-strict-aliasing -O2 -c -DLINUX -DANDROID
+LOCAL_LDLIBS := -lm -ldl
+LOCAL_SRC_FILES := newlisp.c nl-symbol.c nl-math.c nl-list.c nl-liststr.c nl-string.c \
+nl-sock.c nl-import.c nl-xml-json.c nl-web.c nl-matrix.c nl-debug.c pcre.c nl-filesys.c
+include $(BUILD_EXECUTABLE)
+
diff --git a/util/Application.mk b/util/Application.mk
new file mode 100644
index 0000000..351a47d
--- /dev/null
+++ b/util/Application.mk
@@ -0,0 +1,5 @@
+APP_MODULES := newlisp
+APP_PLATFORM := android-8
+APP_OPTIM   := release
+APP_ABI := armeabi
+
diff --git a/util/README.txt b/util/README.txt
new file mode 100644
index 0000000..5e5bd52
--- /dev/null
+++ b/util/README.txt
@@ -0,0 +1,20 @@
+Android-utf8.mk ................... make file for Android UTF8
+Android.mk ........................ make file for Android
+Application.mk .................... part of Android package
+README.txt ........................ this file
+description-pak ................... used when making Debian packages
+ffitest.c ......................... used by qa-libffi
+makefile_amal_darwin_utf8_ffi ..... all in one file for darwin
+makefile_amal_linux_utf8 .......... all in one file Linux
+newLISP-OSX-README.rtf ............ part of the OSX installer image
+newlisp.jsf ....................... syntax highlighting for the JOE editor
+newlisp.vim ....................... syntax highlighting for the VIM editor
+newlispdoc ........................ doc generator
+newlispdoc.css .................... style sheet for doc generatoor
+nls ............................... combination newLISP and OS shell
+org.newlisp.newlisp.plist ......... launchd file for OSX
+package.jsn ....................... used for some package maker
+standard.lsp ...................... used with newlispdoc to generate an index entry
+syntax.cgi ........................ generate a syntax hightlighted HTML file from newLISP source
+types.c ........................... check out C-type sizes and behavior on an OS platform
+uninstall.command ................. part of the OSX installer image
diff --git a/util/description-pak b/util/description-pak
new file mode 100644
index 0000000..5e917c0
--- /dev/null
+++ b/util/description-pak
@@ -0,0 +1 @@
+newLISP is a Lisp-like, general purpose scripting language.
diff --git a/util/ffitest.c b/util/ffitest.c
new file mode 100644
index 0000000..d56d389
--- /dev/null
+++ b/util/ffitest.c
@@ -0,0 +1,230 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+/*
+ testffi.c
+ test FFI correct passing of parameter and return types
+
+ this file is used in qa-specific-tests/qa-libffi
+
+ compile using either:
+     gcc -m32 ffitest.c -shared -o ffitest.dylib
+ or
+     gcc -m64 ffitest.c -shared -o ffitest.dylib
+
+
+ all intx tupes must correctly handle sign-extension
+ and unsigning
+ e.g.: (ret_uint8 -1) => 255
+       (ret_int8 255) => -1
+
+    user API type  ffi type
+    -------------  --------
+    "byte"         &ffi_type_uint8
+    "char"         &ffi_type_sint8
+    "short int"    &ffi_type_sint16
+    "unsigned short int"    &ffi_type_uint16
+    "unsigned int" &ffi_type_uint32
+    "int"          &ffi_type_sint32
+#ifdef NEWLISP64
+    "long"          &ffi_type_sint64
+#else
+    "long"          &ffi_type_sint32
+#endif
+    "long long"    &ffi_type_sint64
+    "float"        &ffi_type_float
+    "double"       &ffi_type_double
+    "char*"        &ffi_type_pointer  input string or address, return string 
+    "void*"        &ffi_type_pointer  input string or address, return address
+#endif
+*/
+
+char ret_sint8(char number)
+    {
+    return(number);
+    }
+
+char ret_uint8(unsigned char number)
+    {
+    return(number);
+    }
+
+short int ret_sint16(int number)
+    {
+    return(number);
+    }
+
+short int ret_uint16(unsigned int number)
+    {
+    return(number);
+    }
+
+int ret_sint32(int number)
+    {
+    return(number);
+    }
+
+int ret_sint32_void(void)
+    {
+    return(-1);
+    }
+
+unsigned int ret_uint32(unsigned int number)
+    {
+    return(number);
+    }
+
+long long ret_sint64(long long number)
+    {
+    return(number);
+    }
+
+float ret_float(float number)
+    {
+    return(number);
+    }
+
+double ret_double(double number)
+    {
+    return(number);
+    }
+
+double add_double(double number1, double number2)
+    {
+    return(number1 + number2);
+    }
+
+char * ret_pointer(char * ptr)
+    {
+    char * upper;
+    upper = ptr;
+    while(*ptr) { *ptr = toupper(*ptr); ptr++; }
+    return(upper);
+    }
+
+char * string_copy(char * from, char * to)
+    {
+    strcpy(to, from);
+    return(to);
+    }
+
+/* test ffi closure API */
+
+void (*function)(char * str, int inum, double fnum);
+
+void register_callback(void * ptr)
+    {
+    function = ptr;
+    }
+
+void trigger_callback()
+    {
+    double dnum = 12345.67890;
+
+    (*function)(">>>>> callback API ", 1234567890, dnum);
+    }
+
+/* test simple ffi */
+
+void (*function_simple)(char * str, int inum);
+
+void register_callback_simple(void * ptr)
+    {
+    function_simple = ptr;
+    }
+
+void trigger_callback_simple() /* only handles strings and integers */
+    {
+    long inum = 1234567890;
+
+    (*function_simple)(">>>>> callback API ", inum);
+    }
+
+/* test struct API */
+
+typedef struct clock
+    {
+    char hour;
+    int min;
+    short int sec;
+    } clock;
+
+clock addClock(clock in)
+    {
+    in.hour += 1;
+    in.min += 1;
+    in.sec += 1;
+    return in;
+    }
+
+typedef struct foo
+	{
+	char first;
+	int second;
+	short int third;
+	char * word;
+	} foo;
+
+foo * useFoo(int value)
+	{
+	foo * bar = malloc(sizeof(foo));
+	bar->first = 1 + value;	
+	bar->second = 2 + value;	
+	bar->third = 3 + value;	
+	bar->word = "hello world";
+	return bar;
+	}
+
+
+/* miscellanous tests */
+
+typedef struct 
+{
+double dat[2];
+} gsl_complex;
+
+/* structure return
+(struct 'complex "double" "double")
+(import LIB "gsl_complex_rect" "complex" "double" "double")
+(gsl_complex_rect 3.0 4.0) ;=> (3 4)
+*/
+
+gsl_complex complex_test(gsl_complex gs)
+{
+return(gs);
+}
+
+
+/* mixed floats intd for simple ffi and 32bit
+(import "ffitest.dylib" "mixed_int_float")
+(get-string (mixed_int_float 123 (flt 123.456) 456 (flt 789.123)))
+;=> "123 123.456001 456 789.122986\n"
+*/
+
+char * mixed_int_float(int x, float a, int y, float b)
+{
+static char buff[100];
+
+sprintf(buff, "%d %f %d %f\n", x, a, y, b);
+
+return(buff);
+}
+
+/* arrays */
+
+int array_test(int n, int m, double * ptr[])
+{
+int i , j;
+
+for(i = 0; i < n; i++)
+    for(j = 0; j < m; j++)
+        printf("%lf ", ptr[i][j]);
+
+return(0);
+}
+
+
+
+/* eof */
diff --git a/util/index.cgi b/util/index.cgi
new file mode 100755
index 0000000..85bfa37
--- /dev/null
+++ b/util/index.cgi
@@ -0,0 +1,14 @@
+#!/usr/bin/env newlisp
+
+(print  "Content-type: text/html\r\n\r\n")
+(println "<h2>" (real-path) "</h2>")
+
+(println {<table>})
+(dolist (file (sort (directory)))
+    (set 'slash (if (directory? file) "/" ""))
+    (println {<tr><td><tt><a href="http:} file slash {">} file  slash {</a>&nbsp;&nbsp;</tt></td><td><tt>}
+        (date (last (file-info file)) 0 "%Y-%m-%d %H:%M:%S") {</tt></td>} 
+        {<td><pre>} (format "%12.3f KB" (div (file-info file 0) 1000)) {</pre></td></tr>}))
+(println {</table>})
+(exit)
+
diff --git a/util/makefile_amal_darwin_utf8_ffi b/util/makefile_amal_darwin_utf8_ffi
new file mode 100644
index 0000000..bfc237e
--- /dev/null
+++ b/util/makefile_amal_darwin_utf8_ffi
@@ -0,0 +1,30 @@
+# amalgamation makefile for newLISP v. 10.x.x on Mac OSX with readline support
+# Concats all newLISP source files into one big file. At least on gcc v.4.0.1
+# on Mac OS X there is no speed advantage through better optimization of the
+# compiler. But other platforms compilers may show different results.
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+
+OBJS = newlisp-amal.o pcre.o
+
+CFLAGS = -Wall -m32 -O1 -I/usr/include -c -DREADLINE -DMAC_OSX -DSUPPORT_UTF8 -DFFI
+
+CC = gcc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -lffi -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+newlisp-amal.c:
+	cat newlisp.c nl-symbol.c nl-math.c nl-list.c nl-liststr.c nl-string.c nl-filesys.c \
+    nl-sock.c nl-import.c nl-xml-json.c nl-web.c nl-matrix.c nl-debug.c nl-utf8.c > newlisp-amal.c
+
+
+$(OBJS): newlisp.h primes.h protos.h makefile_amal_darwin_utf8_ffi
+
+
diff --git a/util/makefile_amal_linux_utf8 b/util/makefile_amal_linux_utf8
new file mode 100644
index 0000000..8adf546
--- /dev/null
+++ b/util/makefile_amal_linux_utf8
@@ -0,0 +1,30 @@
+# amalgamation makefile for newLISP v. 10.x.x on Linux with readline support
+# Concats all newLISP source files into one big file. At least on gcc v.4.3.2
+# on Linux there is no speed advantage through better optimization of the
+# compiler. But other platforms compilers may show different results.
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+
+OBJS = newlisp-amal.o pcre.o
+
+CFLAGS = -m32 -Wall -pedantic -Wno-strict-aliasing -Wno-long-long -c -O2 -DREADLINE -DSUPPORT_UTF8 -DLINUX
+
+CC = cc -L/usr/lib
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -ldl -lreadline -lncurses -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+newlisp-amal.c:
+	cat newlisp.c nl-symbol.c nl-math.c nl-list.c nl-liststr.c nl-string.c nl-filesys.c \
+    nl-sock.c nl-import.c nl-xml-json.c nl-web.c nl-matrix.c nl-debug.c nl-utf8.c > newlisp-amal.c
+
+
+$(OBJS): newlisp.h primes.h protos.h makefile_amal_linux_utf8
+
+
diff --git a/util/makefile_darwin b/util/makefile_darwin
new file mode 100644
index 0000000..022e3ed
--- /dev/null
+++ b/util/makefile_darwin
@@ -0,0 +1,22 @@
+# makefile for newLISP v. 10.x.x on Mac OSX with readline
+#
+# needs readline library and headerfiles installed (X tools)
+#
+
+OBJS = newlisp.o nl-symbol.o nl-math.o nl-list.o nl-liststr.o nl-string.o nl-filesys.o \
+	nl-sock.o nl-import.o nl-xml-json.o nl-web.o nl-matrix.o nl-debug.o pcre.o nl-utf8.o
+
+CFLAGS = -m32 -Wall -O1 -c -DREADLINE -DMAC_OSX
+
+CC = cc
+
+default: $(OBJS)
+	$(CC) $(OBJS) -m32 -lm -lreadline -o newlisp
+	strip newlisp
+
+.c.o:
+	$(CC) $(CFLAGS) $<
+
+$(OBJS): primes.h protos.h makefile_darwin
+
+
diff --git a/util/newLISP-OSX-README.rtf b/util/newLISP-OSX-README.rtf
new file mode 100644
index 0000000..4cf61f4
--- /dev/null
+++ b/util/newLISP-OSX-README.rtf
@@ -0,0 +1,42 @@
+{\rtf1\ansi\ansicpg1252\cocoartf1038\cocoasubrtf360
+{\fonttbl\f0\fswiss\fcharset0 Helvetica;\f1\fmodern\fcharset0 Courier;}
+{\colortbl;\red255\green255\blue255;}
+\margl1440\margr1440\vieww11600\viewh12260\viewkind0
+\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\ql\qnatural\pardirnatural
+
+\f0\fs32 \cf0 newLISP 
+\fs30 INSTALLATION and UNINSTALL
+\fs24 \
+ \
+- Mac OS X Snow Leopard 10.6 is required as a minimum for this release on Intel CPU systems. On PPC based systems Leopard 1.5 is required.\
+\
+- To run the newLISP-GS front-end installed in the Applications folder, Java JRE (Runtime Environment) 1.6 is required as a minimum. Starting with Mac OS X Lion 10.7 Java must be installed by the user, if the Java based IDE is used. \
+See {\field{\*\fldinst{HYPERLINK "http://support.apple.com/kb/DL1421"}}{\fldrslt http://support.apple.com/kb/DL1421}}\
+\
+
+\fs30 INSTALLATION
+\fs24 \
+\
+To install, just click on the newLISP package icon and follow the instruction of the OSX installer application.\
+\
+An applications icon for the newLISP-GS editor will be put in the Applications folder.\
+\
+The newLISP binary and newlisp-edit are installed as /usr/bin/newlisp and /usr/bin/newlisp-edit. HTML documentation, demos, modules and utilities are in the /usr/share/newlisp directory. Man pages are are installed in /usr/share/man/man1 and retrievable from a terminal window command line with 'man newlisp' and 'man newlispdoc'.\
+\
+For a minimum installation only /usr/bin/newlisp is required, all other files are optional.\
+\
+
+\fs30 UNINSTALL
+\fs24 \
+\
+To uninstall click on the uninstall.command script. This will start a shell script and ask for the current user password. The process finishes displaying:\
+\
+
+\f1 newLISP and newLISP-GS uninstalled\
+logout\
+[Process completed]
+\f0 \
+\
+At this point the shell window can be closed.\
+\
+}
diff --git a/util/newlisp.jsf b/util/newlisp.jsf
new file mode 100644
index 0000000..f9be817
--- /dev/null
+++ b/util/newlisp.jsf
@@ -0,0 +1,526 @@
+# JOE syntax highlight file for newLISP v.10.5.4
+
+# These colors are for the text console.
+# You will definitely need different colors for a terminal under X.
+# The range of colors is found in your c.jsf file.
+# Deprecated commands will blink annoyingly :-)
+#
+# on Linux UBUNTU 8.04 this file goes into /etc/joe/syntax/lisp.jsf
+# or into $HOME/.joe/syntax/lisp.jsf on all Unix
+
+# L Wix [xman-et-myrealbox-dot-com]
+# Thanks to Norman (newdep)
+# 10 Nov 2004
+# 27 Jan 2005, L.M. updated to v.8.4.1
+# 28 Jan 2005, L.M. made comments (did not work om Joe 3.1)
+#                   made [text] .. [/text] tags work
+# 25 June 2008, L.M updated for version 9.4.0
+# 22 Sept 2008, L.M updated for version 9.9.x -> 10.0 added setf
+# 29 Sept 2008, L.M updated for version 9.9.x -> 10.0 added copy
+# 21 Oct 2008, L.M. exclude MAIN from highlighting
+# 18 Nov 2008, L.M. eliminated old functions for 10.0
+# 27 Nov 2008, L.M. added obsolete functions
+# 4 May 2009, L.M. added xfer-event
+# 12 June 2009, L.M. added send and receive
+# 20 October 2009, L.M. added reader-event
+# 10 November 2009, L.M. removed experimental estack
+# 6 December 2009, LM added new 'self'
+# 9 February 2010, LM added new 'extend', 'term', '++', '--' eliminated 'name'
+# 29 April 2010, LM added new 'net-packet'
+# 26 May 2010, LM added new 'net-ipv'
+# 22 August 2010, LM date-parse replace parse-date, new date-list
+# 23 March 2011, Norman updated list with prim and depr functions
+# 28 March 2011, Norman updated list with prim and depr functions
+# 28 March 2011, L.M. added write-buffer (like write) to depr functions
+# 23 December 2011, L.M. added struct
+# 2 April 2012, L.M. added union, even?, odd?, crit-f, crit-t, prob-f, prob-t
+# 26 April 2012, L.M. added corr, stats, t-test
+# 20 January 2013, L.M. added json-parse, json-error
+# 20 May 2013, L.M. added bigint, bigint? 
+# 18 JUne 2013, L.M. added kmeans-query, kmeans-train
+# version 1.18
+
+=Idle		
+=Comment 	bold green
+=String 	bold yellow
+=Text		bold black
+=Escape 	bold green
+=Paren		red
+=Quote		bold cyan
+=Prim		bold cyan
+=Tag		bold cyan
+=Depr    	bold black
+
+:idle Idle
+	*		idle
+	";"		comment		recolor=-1
+	"#"		comment		recolor=-1
+	"\""	string		recolor=-1
+	"{"		brace_string	recolor=-1
+	"()"	paren		recolor=-1
+	"'"		quote		recolor=-1
+	"["		tag_o1		recolor=-1
+	"!=%&*+/<>^|~a-zA-Z_\-"	ident		buffer
+
+:comment Comment
+	*		comment
+	"\n"		idle
+
+:string String
+	*		string
+	"\""		idle
+	"\\"		string_escape	recolor=-1
+
+:string_escape Escape
+	*		string
+	"\n"		string		recolor=-2
+
+:brace_string String
+	*		brace_string
+	"}"		idle
+
+:paren Paren
+	*		idle		noeat
+
+:quote Quote
+	*		idle		noeat
+	
+:ident Idle
+	*		idle		noeat strings
+"!"	prim
+"!="	prim
+"$"	prim
+"%"	prim
+"&"	prim
+"*"	prim
+"+"	prim
+"++"	prim
+"-"	prim
+"--"	prim
+"/"	prim
+":"	prim
+"<"	prim
+"<<"	prim
+"<="	prim
+"="	prim
+">"	prim
+">="	prim
+">>"	prim
+"?"	prim
+"@"	prim
+"NaN?"	prim
+"^"	prim
+"abort"	prim
+"abs"	prim
+"acos"	prim
+"acosh"	prim
+"add"	prim
+"address"	prim
+"amb"	prim
+"and"	prim
+"append"	prim
+"append-file"	prim
+"apply"	prim
+"args"	prim
+"array"	prim
+"array-list"	prim
+"array?"	prim
+"asin"	prim
+"asinh"	prim
+"assoc"	prim
+"atan"	prim
+"atan2"	prim
+"atanh"	prim
+"atom?"	prim
+"base64-dec"	prim
+"base64-enc"	prim
+"bayes-query"	prim
+"bayes-train"	prim
+"begin"	prim
+"beta"	prim
+"betai"	prim
+"bigint"	prim
+"bigint?"	prim
+"bind"	prim
+"binomial"	prim
+"bits"	prim
+"callback"	prim
+"case"	prim
+"catch"	prim
+"ceil"	prim
+"change-dir"	prim
+"char"	prim
+"chop"	prim
+"clean"	prim
+"close"	prim
+"collect"	prim
+"command-event"	prim
+"cond"	prim
+"cons"	prim
+"constant"	prim
+"context"	prim
+"context?"	prim
+"copy"	prim
+"copy-file"	prim
+"corr"  prim
+"cos"	prim
+"cosh"	prim
+"count"	prim
+"cpymem"	prim
+"crc32"	prim
+"crit-chi2"	prim
+"crit-f"	prim
+"crit-t"	prim
+"crit-z"	prim
+"current-line"	prim
+"curry"	prim
+"date"	prim
+"date-parse"	prim
+"date-list"	prim
+"date-value"	prim
+"debug"	prim
+"dec"	prim
+"def-new"	prim
+"default"	prim
+"define"	prim
+"define-macro"	prim
+"delete"	prim
+"delete-file"	prim
+"delete-url"	prim
+"destroy"	prim
+"det"	prim
+"device"	prim
+"difference"	prim
+"directory"	prim
+"directory?"	prim
+"div"	prim
+"do-until"	prim
+"do-while"	prim
+"doargs"	prim
+"dolist"	prim
+"dostring"	prim
+"dotimes"	prim
+"dotree"	prim
+"dump"	prim
+"dup"	prim
+"empty?"	prim
+"encrypt"	prim
+"ends-with"	prim
+"env"	prim
+"erf"	prim
+"error-event"	prim
+"eval"	prim
+"eval-string"	prim
+"even?" prim
+"exec"	prim
+"exists"	prim
+"exit"	prim
+"exp"	prim
+"expand"	prim
+"explode"	prim
+"extend"	prim
+"factor"	prim
+"fft"	prim
+"file-info"	prim
+"file?"	prim
+"filter"	prim
+"find"	prim
+"find-all"	prim
+"first"	prim
+"flat"	prim
+"float"	prim
+"float?"	prim
+"floor"	prim
+"flt"	prim
+"for"	prim
+"for-all"	prim
+"fork"	prim
+"format"	prim
+"fv"	prim
+"gammai"	prim
+"gammaln"	prim
+"gcd"	prim
+"get-char"	prim
+"get-float"	prim
+"get-int"	prim
+"get-long"	prim
+"get-string"	prim
+"get-url"	prim
+"global"	prim
+"global?"	prim
+"if"	prim
+"if-not"	prim
+"ifft"	prim
+"import"	prim
+"inc"	prim
+"index"	prim
+"inf?"	prim
+"int"	prim
+"integer"	prim
+"integer?"	prim
+"intersect"	prim
+"invert"	prim
+"irr"	prim
+"join"	prim
+"json-error"    prim
+"json-parse"    prim
+"kmeans-query"  prim
+"kmeans-train"  prim
+"lambda?"	prim
+"last"	prim
+"last-error"	prim
+"legal?"	prim
+"length"	prim
+"let"	prim
+"letex"	prim
+"letn"	prim
+"list"	prim
+"list?"	prim
+"load"	prim
+"local"	prim
+"log"	prim
+"lookup"	prim
+"lower-case"	prim
+"macro?"	prim
+"main-args"	prim
+"make-dir"	prim
+"map"	prim
+"mat"	prim
+"match"	prim
+"max"	prim
+"member"	prim
+"min"	prim
+"mod"	prim
+"mul"	prim
+"multiply"	prim
+"net-accept"	prim
+"net-close"	prim
+"net-connect"	prim
+"net-error"	prim
+"net-eval"	prim
+"net-interface" prim
+"net-ipv" prim
+"net-listen"	prim
+"net-local"	prim
+"net-lookup"	prim
+"net-packet"	prim
+"net-peek"	prim
+"net-peer"	prim
+"net-ping"	prim
+"net-receive"	prim
+"net-receive-from"	prim
+"net-receive-udp"	prim
+"net-select"	prim
+"net-send"	prim
+"net-send-to"	prim
+"net-send-udp"	prim
+"net-service"	prim
+"net-sessions"	prim
+"new"	prim
+"nil"	prim
+"nil?"	prim
+"normal"	prim
+"not"	prim
+"now"	prim
+"nper"	prim
+"npv"	prim
+"nth"	prim
+"null?"	prim
+"number?"	prim
+"odd?"  prim
+"open"	prim
+"or"	prim
+"ostype"	prim
+"pack"	prim
+"parse"	prim
+"path"	prim
+"peek"	prim
+"pipe"	prim
+"pmt"	prim
+"pop"	prim
+"pop-assoc"	prim
+"post-url"	prim
+"pow"	prim
+"pretty-print"	prim
+"prefix"	prim
+"primitive?"	prim
+"print"	prim
+"println"	prim
+"prob-chi2"	prim
+"prob-f"	prim
+"prob-t"	prim
+"prob-z"	prim
+"process"	prim
+"prompt-event"	prim
+"protected?"	prim
+"push"	prim
+"put-url"	prim
+"pv"	prim
+"quote"	prim
+"quote?"	prim
+"rand"	prim
+"random"	prim
+"randomize"	prim
+"read"	prim
+
+"read-char"	prim
+"read-expr"	prim
+"read-file"	prim
+"read-key"	prim
+"read-line"	prim
+"read-utf8"	prim
+"reader-event"	prim
+"real-path"	prim
+"receive"	prim
+"ref"	prim
+"ref-all"	prim
+"regex"	prim
+"regex-comp"	prim
+"remove-dir"	prim
+"rename-file"	prim
+"replace"	prim
+"replace-assoc"	prim
+"reset"	prim
+"rest"	prim
+"reverse"	prim
+"rotate"	prim
+"round"	prim
+"save"	prim
+"search"	prim
+"seed"	prim
+"seek"	prim
+"select"	prim
+"self"	prim
+"semaphore"	prim
+"send"	prim
+"sequence"	prim
+"series"	prim
+"set"	prim
+"set-locale"	prim
+"set-ref"	prim
+"set-ref-all"	prim
+"setf"	prim
+"setq"	prim
+"sgn"	prim
+"share"	prim
+"signal"	prim
+"silent"	prim
+"sin"	prim
+"sinh"	prim
+"sleep"	prim
+"slice"	prim
+"sort"	prim
+"source"	prim
+"spawn"	prim
+"sqrt"	prim
+"starts-with"	prim
+"stats" prim
+"string"	prim
+"string?"	prim
+"struct"	prim
+"sub"	prim
+"swap"	prim
+"sym"	prim
+"symbol?"	prim
+"symbols"	prim
+"sync"	prim
+"sys"	prim
+"sys-error"	prim
+"sys-info"	prim
+"t-test"    prim
+"tan"	prim
+"tanh"	prim
+"term"	prim
+"throw"	prim
+"throw-error"	prim
+"time"	prim
+"time-of-day"	prim
+"timer"	prim
+"title-case"	prim
+"trace"	prim
+"trace-highlight"	prim
+"xfer-event"	prim
+"transpose"	prim
+"trim"	prim
+"true"	prim
+"true?"	prim
+"unicode"	prim
+"unify"	prim
+"unique"	prim
+"union"	prim
+"unless"	prim
+"unpack"	prim
+"until"	prim
+"upper-case"	prim
+"utf8"	prim
+"utf8len"	prim
+"uuid"	prim
+"wait-pid"	prim
+"when"	prim
+"while"	prim
+"write"	prim
+"write-char"	prim
+"write-file"	prim
+"write-line"	prim
+"xml-error"	prim
+"xml-parse"	prim
+"xml-type-tags"	prim
+"zero?"	prim
+"|"	prim
+"~"	prim
+"set-nth"	depr
+"nth-set"	depr
+"set-assoc"	depr
+"assoc-set"	depr
+"replace-assoc" depr
+"integer"	depr
+"ref-set"	depr
+"parse-date"	depr
+"name"		depr
+"read-buffer"	depr
+"write-buffer"	depr
+
+done		
+	"\-\"a-zA-Z_0-9!#@$%^&*+={}|/\\:';,.<>/?~`" ident
+
+
+:prim Prim
+	*		idle		noeat
+
+:tag_o1 Tag
+	*		idle		noeat
+	"t"		tag_o2
+	
+:tag_o2 Tag
+	*		idle		noeat
+	"e"		tag_o3
+	
+:tag_o3 Tag
+	*		idle		noeat
+	"x"		tag_o4
+	
+:tag_o4 Tag
+	*		idle		noeat
+	"t"		tag_o5
+	
+:tag_o5 Tag
+	*		idle		noeat
+	"]"		long_text
+	
+:long_text	Text
+	*		long_text
+	"["		close_tag	buffer recolor=-1
+	
+:close_tag Tag
+	*		long_text	noeat strings
+	"[/text]"	tag_closed
+done
+	"[]/etx"	close_tag
+	
+:tag_closed Tag
+	*		idle		noeat
+	
+:depr Depr
+	*  idle     noeat
+
+
diff --git a/util/newlisp.vim b/util/newlisp.vim
new file mode 100644
index 0000000..8ca4030
--- /dev/null
+++ b/util/newlisp.vim
@@ -0,0 +1,244 @@
+" Vim syntax file
+" Language:     newLISP
+" Maintainer:   Cyril Slobin <cyril@slobin.ru>
+" URL:          http://www.vim.org/scripts/script.php?script_id=2067
+" Another URL:  http://slobin.ru/vim/syntax/newlisp.vim
+" Started at:   2007 Nov 07 (The Great Revolution 90th anniversary)
+" Last change:  2013 Jun 02
+" Last change:  2013 Jun 18 L.M. added kmeans-query, kmeans-train
+" Last change:  2014 Dec 31 L.M. added collect
+" newLISP site: http://www.newlisp.org/
+
+" $Id: newlisp.vim,v 1.37 2013/06/02 22:30:55 slobin Exp $
+
+" *** Some syntax quirks of newLISP and how this file treats them: ***
+
+" * In the following text, the word "character" refers to the ASCII
+"   characters, and the word "symbol" to the lisp symbols (= atoms).
+"
+" * All built-in symbols are in the same class (Statement). Functions,
+"   definitions, macros and control structures aren't distinguished.
+"
+" * The quoting character ' (apostrophe) is allowed anywhere, even
+"   before closing parenthesis.
+"
+" * The comma character , makes a symbol by itself and need not be
+"   separated from adjacent symbols.
+"
+" * Brackets [ ] and braces { } are allowed in symbols, even unmatched
+"   ones. They albeit will break the Vim parentheses matching logic.
+"
+" * Special syntax for : character (colon) and FOOP is underway.
+"   Meantime it is just highlighted and not checked otherwise.
+"
+" * newLISP sometimes allows numbers, symbols or strings to follow one
+"   another without a separator (like 1.2.3e4e5, which is valid and
+"   equal to three tokens 1.2 .3e4 e5). Such a beast is rather a typo
+"   than  someones intent, so it is highlighted as error.
+"
+" * If a backlash character \ in a quoted string is not followed by
+"   a valid escape sequence, the interpreter doesn't alarm you, it just
+"   silently removes this character from the string. E.g. the string
+"   "a\b" is equal to the string "ab". Again, this is rather a typo than
+"   someones intent, so it is highlighted as error.
+"
+" * New in this version: based on newLISP 10.5.0 release; new syntax for
+"   big integer numbers; maintainer's e-mail and web site changed.
+
+if exists("b:current_syntax")
+  finish
+endif
+
+syntax case match
+
+setlocal iskeyword=33,36-38,42,43,45-47,48-57,60-64,@,91-94,_,123-126
+
+syn region newlispComment oneline start="[;#]" end="$" contains=newlispTodo,@Spell
+syn keyword newlispTodo FIXME TODO XXX contained
+
+syn region newlispDocComment start="^;;\(\s\|$\)" end="^\(;;\(\s\|$\)\)\@!" contains=newlispTodo,newlispDocCommentExample,newlispDocCommentUserKeyword,newlispDocCommentKeyword,newlispDocCommentItalic,newlispDocCommentMonospace,newlispDocCommentHTMLTag,newlispDocCommentHTMLEntity,@Spell
+syn region newlispDocCommentExample matchgroup=newlispDocCommentKeyword start="^;;\s@example$"ms=s+3 matchgroup=NONE end="^\(;;\(\s\|$\)\)\@!" contained
+syn match newlispDocCommentUserKeyword "^;;\s@[a-zA-Z_-]*\s"ms=s+3,me=e-1 contained
+syn match newlispDocCommentKeyword "^;;\s@\(module\|index\|description\|location\|version\|author\|syntax\|param\|return\)\s"ms=s+3,me=e-1 contained
+syn match newlispDocCommentKeyword "@link\s"me=e-1 contained
+syn match newlispDocCommentItalic "<[^<>]\+>"hs=s+1,he=e-1 contained
+syn match newlispDocCommentMonospace "'[^']\+'"hs=s+1,he=e-1 contained
+syn match newlispDocCommentHTMLTag "<\/\=\(h1\|h2\|h3\|h4\|i\|em\|b\|tt\|p\|pre\|center\|li\|ul\|blockquote\)>" contained
+syn match newlispDocCommentHTMLTag "<\(br\|hr\)\/\=>" contained
+syn match newlispDocCommentHTMLEntity "&\w\+;" contained
+
+syn cluster newlispListContent contains=TOP,newlispRightParenError
+syn region newlispList matchgroup=newlispParenthesis start="(" end=")" contains=@newlispListContent,newlispListError
+syn region newlispListError matchgroup=newlispLeftParenError start="^(" matchgroup=newlispParenthesis end=")" contains=@newlispListContent,newlispListError contained
+syn match newlispRightParenError ")"
+
+syn match newlispSymbol "\(\[\|[+-]\=\d\)\@!\k\+" nextgroup=newlispNoSeparatorError
+syn region newlispSymbolString start="\[" end="\]" nextgroup=newlispNoSeparatorError
+
+syn match newlispQuote "'" nextgroup=newlispQuote,newlispQuotedSymbol skipwhite
+syn match newlispQuotedSymbol "\(\[\|[+-]\=\d\)\@!\k\+" contained nextgroup=newlispNoSeparatorError
+
+syn match newlispNumberDec "[+-]\=[1-9]\d*L\=" nextgroup=newlispNoSeparatorError
+syn match newlispNumberOct "[+-]\=0\o*" nextgroup=newlispNoSeparatorError
+syn match newlispNumberHex "[+-]\=0[Xx]\x\+" nextgroup=newlispNoSeparatorError
+
+syn match newlispFloat "[+-]\=\d\+[Ee][+-]\=\d\+" nextgroup=newlispNoSeparatorError
+syn match newlispFloat "[+-]\=\.\d\+\([Ee][+-]\=\d\+\)\=" nextgroup=newlispNoSeparatorError
+syn match newlispFloat "[+-]\=\d\+\.\d*\([Ee][+-]\=\d\+\)\=" nextgroup=newlispNoSeparatorError
+
+syn region newlispStringQuoted matchgroup=newlispStringDelimiter start=+"+ skip=+\\"+ end=+"+ contains=newlispStringEscapeError,newlispStringEscape nextgroup=newlispNoSeparatorError
+syn match newlispStringEscapeError +\\.+ contained
+syn match newlispStringEscape +\\["\\nrt]+ contained
+syn match newlispStringEscape +\\\d\d\d+ contained
+syn match newlispStringEscape +\\x\x\x+ contained
+
+syn region newlispStringBraced matchgroup=newlispStringDelimiter start="{" end="}" contains=newlispStringNested nextgroup=newlispNoSeparatorError
+syn region newlispStringNested matchgroup=newlispStringDelimiter start="{" end="}" contains=newlispStringNested contained
+
+syn region newlispStringTexted matchgroup=newlispStringDelimiter start="\[text\]" end="\[\/text\]" nextgroup=newlispNoSeparatorError
+
+syn match newlispNoSeparatorError "\(\"\|\k\)\+" contained
+
+" This keywords list is based on newLISP v.10.5.0 build primes.h file
+" XXX Don't forget to remove colon ":" and escape vertical bar "|"
+
+syn keyword newlispFunction ! != $ % & * + ++ - -- / < << <= = > >= >> NaN? ^ abort abs acos acosh
+syn keyword newlispFunction add address amb and append append-file apply args array array-list
+syn keyword newlispFunction array? asin asinh assoc atan atan2 atanh atom? base64-dec base64-enc
+syn keyword newlispFunction bayes-query bayes-train begin beta betai bigint bigint? bind binomial
+syn keyword newlispFunction bits callback case catch ceil change-dir char chop clean close collect
+syn keyword newlispFunction command-event cond cons constant context context? copy
+syn keyword newlispFunction copy-file corr cos cosh count cpymem crc32 crit-chi2 crit-f crit-t
+syn keyword newlispFunction crit-z current-line curry date date-list date-parse date-value debug dec
+syn keyword newlispFunction def-new default define define-macro delete delete-file delete-url
+syn keyword newlispFunction destroy det device difference directory directory? div do-until do-while
+syn keyword newlispFunction doargs dolist dostring dotimes dotree dump dump-symbol dup empty?
+syn keyword newlispFunction encrypt ends-with env erf error-event eval eval-string even? exec exists
+syn keyword newlispFunction exit exp expand explode extend factor fft file-info file? filter find
+syn keyword newlispFunction find-all first flat float float? floor flt for for-all fork format fv
+syn keyword newlispFunction gammai gammaln gcd get-char get-float get-int get-long get-string
+syn keyword newlispFunction get-url global global? if if-not ifft import inc index inf? int integer
+syn keyword newlispFunction integer? intersect invert irr join json-error json-parse 
+syn keyword newlispFunction kmeans-query kmeans-train lambda? last
+syn keyword newlispFunction last-error legal? length let letex letn list list? load local log lookup
+syn keyword newlispFunction lower-case macro? main-args make-dir map mat match max member min mod
+syn keyword newlispFunction mul multiply net-accept net-close net-connect net-error net-eval
+syn keyword newlispFunction net-interface net-ipv net-listen net-local net-lookup net-packet
+syn keyword newlispFunction net-peek net-peer net-ping net-receive net-receive-from net-receive-udp
+syn keyword newlispFunction net-select net-send net-send-to net-send-udp net-service net-sessions
+syn keyword newlispFunction new nil? normal not now nper npv nth null? number? odd? open or pack
+syn keyword newlispFunction parse parse-date peek pipe pmt pop pop-assoc post-url pow prefix
+syn keyword newlispFunction pretty-print primitive? print println prob-chi2 prob-f prob-t prob-z
+syn keyword newlispFunction process prompt-event protected? push put-url pv quote quote? rand random
+syn keyword newlispFunction randomize read read-buffer read-char read-expr read-file read-key
+syn keyword newlispFunction read-line read-utf8 reader-event real-path receive ref ref-all regex
+syn keyword newlispFunction regex-comp remove-dir rename-file replace reset rest reverse rotate
+syn keyword newlispFunction round save search seed seek select self semaphore send sequence series
+syn keyword newlispFunction set set-locale set-ref set-ref-all setf setq sgn share signal silent sin
+syn keyword newlispFunction sinh sleep slice sort source spawn sqrt starts-with stats string string?
+syn keyword newlispFunction struct sub swap sym symbol? symbols sync sys-error sys-info t-test tan
+syn keyword newlispFunction tanh term throw throw-error time time-of-day timer title-case trace
+syn keyword newlispFunction trace-highlight transpose trim true? unicode unify union unique unless
+syn keyword newlispFunction unpack until upper-case utf8 utf8len uuid wait-pid when while write
+syn keyword newlispFunction write-buffer write-char write-file write-line xfer-event xml-error
+syn keyword newlispFunction xml-parse xml-type-tags zero? \| ~
+
+syn keyword newlispVariable $0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 $15
+syn keyword newlispVariable ostype $args $count $error-event $idx $it $main-args $x
+syn keyword newlispKeyword fn lambda
+syn keyword newlispPreloaded Class Tree module
+
+" functions that became obsolete starting with newLISP 9.3 or 9.4
+syn keyword newlispObsolete replace-assoc
+syn keyword newlispObsolete set-assoc assoc-set set-nth nth-set ref-set
+syn keyword newlispObsolete name
+syn keyword newlispObsolete error-number error-text
+
+" functions that still exist but are deprecated
+syn keyword newlispDeprecated integer parse-date if-not
+
+" functions that are not compiled in by default
+syn keyword newlispDebugging dump-symbol 
+
+syn match newlispColon ":"
+syn match newlispComma ","
+
+syn keyword newlispBoolean nil true
+
+hi def link newlispNumberDec newlispNumber
+hi def link newlispNumberOct newlispNumber
+hi def link newlispNumberHex newlispNumber
+
+hi def link newlispStringQuoted newlispString
+hi def link newlispStringBraced newlispString
+hi def link newlispStringNested newlispString
+hi def link newlispStringTexted newlispString
+
+hi def link newlispLeftParenError newlispError
+hi def link newlispRightParenError newlispError
+hi def link newlispNoSeparatorError newlispError
+hi def link newlispStringEscapeError newlispError
+
+hi def link newlispComment Comment
+hi def link newlispTodo Todo
+hi def link newlispDocComment Comment
+hi def link newlispDocCommentExample Comment
+hi def link newlispDocCommentUserKeyword Identifier
+hi def link newlispDocCommentKeyword Type
+hi def link newlispDocCommentItalic CommentItalic
+hi def link newlispDocCommentMonospace CommentUnderlined
+hi def link newlispDocCommentHTMLTag Statement
+hi def link newlispDocCommentHTMLEntity Special
+hi def link newlispList Normal
+hi def link newlispParenthesis Delimiter
+hi def link newlispSymbol Identifier
+hi def link newlispSymbolString Type
+hi def link newlispQuote Type
+hi def link newlispQuotedSymbol Type
+hi def link newlispNumber Number
+hi def link newlispFloat Float
+hi def link newlispStringDelimiter String
+hi def link newlispString String
+hi def link newlispStringEscape Special
+hi def link newlispFunction Statement
+hi def link newlispVariable Statement
+hi def link newlispKeyword Statement
+hi def link newlispPreloaded Statement
+hi def link newlispObsolete Todo
+hi def link newlispDeprecated Todo
+hi def link newlispDebugging Todo
+hi def link newlispColon Type
+hi def link newlispComma Type
+hi def link newlispBoolean Boolean
+hi def link newlispError Error
+
+" CommentItalic and CommentUnderlined groups have the same colors as
+" plain Comment, but italic and underlined respectively. Therefore we
+" need to recalculate those attributes on each colorscheme change.
+"
+" But we can't implement this for old Vim versions and semi-compatible
+" highlighting tools, so defaults are supplied as a fallback.
+
+hi link CommentItalic Identifier
+hi link CommentUnderlined Underlined
+
+function! s:color_of(where, what)
+  let val = synIDattr(hlID("Comment"), a:what, a:where)
+  return val == "" || val == -1 ? "" : printf(" %s%s=%s", a:where, a:what, val)
+endfunction
+
+function! s:set_colors()
+  let colors =  s:color_of("cterm", "fg") . s:color_of("cterm", "bg") . s:color_of("gui", "fg") . s:color_of("gui", "bg")
+  exec "hi CommentItalic term=italic cterm=italic gui=italic" . colors
+  exec "hi CommentUnderlined term=underline cterm=underline gui=underline" . colors
+endfunction
+
+if version >= 700 && !exists("g:newlisp_compat")
+  au ColorScheme <buffer> call s:set_colors()
+  call s:set_colors()
+endif
+
+let b:current_syntax = "newlisp"
+
+" vim: textwidth=72
+
diff --git a/util/newlispdoc b/util/newlispdoc
new file mode 100755
index 0000000..0419168
--- /dev/null
+++ b/util/newlispdoc
@@ -0,0 +1,506 @@
+#!/usr/bin/env newlisp
+
+;; @module newlispdoc
+;; @description Generates documentation and hightligted source from newLISP source files.
+;; @version 1.3 - handle remote files specified in URLs in a url-file
+;; @version 1.4 - title on page changed to index or module name and new index module option
+;; @version 1.5 - removed font restrictions on h1,h2,h3,h4 and added hr as a legal tag
+;; @version 1.6 - don't allow 3 semicolons at the beginning of a comment line
+;; @version 1.7 - 1.6 did not sense lines with semicolon only as parapgraph separators
+;; @version 1.8 - fixed problem of "true" appearing before multiple syntax statements
+;; @version 1.9 - write-line is now version sensitive for 10.0
+;; @version 2.0 - adds handling of < ?...>  XML tag
+;; @version 2.1 - generate more compliant HTML 4.01 for doc and syntax highlighting
+;;                but special arithmetik op characters in functionnames still cause
+;;                non-compliant HTML (this occurs only in modules/gmp.lsp)
+;; @version 2.2 - fix issue with paragraph spacing and module text font from 2.1
+;; @version 2.3 - handle scientific notation with e
+;; @version 2.4 - improved keyword regex for syntax highlighting
+;; @version 2.5 - scientific notation with E
+;; @version 2.6 - allow custom tags e.g: @MyTag the descriptive text (may contain @link)
+;; @version 2.7 - link rag did not work at beginnning of line
+;; @version 2.8 - support for newLISPdoc tag color
+;; @version 2.9 - correctly highlight & and ^ keywords
+;; @version 3.0 - when -d is specified, add download link
+;; @version 3.1 - changed <tt>write-buffer</tt> to shorter <tt>write</tt>, <tt>name</tt> to <tt>term</tt>
+;; @version 3.2 - formatting when view source, new stylesheet newlispdoc.css
+;; @version 3.3 - allow descriving variables using the @syntax tag. They will be colored red as well.
+;; @version 3.4 - make sure all @xxxxxx custom tags are title cased
+;; @version 3.5 - added META tag for UTF-8 encoding for html output
+;; @version 3.6 - allow trailing spaces on lines in index files
+;; @version 3.7 - forgotten * in @example pattern
+;;
+;; @author Lutz Mueller, 2006-2012
+;; @location http://newlisp.org
+;;
+;; <h3>Usage:</h3>
+;; The <tt>-s</tt> and <tt>-s</tt> switches can be used to generate highlighted source files,
+;; links and and download links
+;; <pre>
+;;    newlispdoc afile.lsp bfile.lsp
+;;    newlispdoc -s afile.lsp bfile.lsp
+;;    newlispdoc -s *.lsp
+;;    newlispdoc -s -d *.lsp
+;; <br>
+;;    ; or on Win32
+;;    newlisp newlispdoc afile.lsp bfile.lsp
+;;    newlisp newlispdoc -s afile.lsp bfile.lsp
+;;    newlisp newlispdoc -s *.lsp
+;;    newlisp newlispdoc -s -d *.lsp
+;; </pre>
+;; newlispdoc can take a file of URLs and generate documentation and syntax
+;; highlighted source from remote files:
+;; <pre>
+;;    newlispdoc -url file-with-urls.txt 10000
+;;    newlispdoc -s -url file-with-urls.txt 10000
+;; <br>
+;;    ; or on Win32
+;;    newlisp newlispdoc -url file-with-urls.txt 10000
+;;    newlisp newlispdoc -s -url file-with-urls.txt 10000
+;; </pre>
+;; file-with-urls.txt contains one URL per line in the file. A URLstarts either 
+;; with http:// or file:// - This allows mixing  remote and local files. An optional 
+;; timeout of 10 seconds is specified after the url file name. If no timeout is specified
+;; newlispdoc assumes 5 seconds.
+;;
+;; Execute from within the same directory of the source files when
+;; no url file is given.
+;;
+;; For each file a file with the same name and extension '.html' is generated
+;; and written to the current directory. A file 'index.htm' is written as
+;; an index for all other files generated. If the '-s' switch is specified,
+;; a file with the extension '.src.html' is generated for each file.
+;;
+;; Please read @link http://newlisp.org/newLISPdoc.html newLISPdoc.html to learn
+;; about tagging of newLISP source code for newlispdoc.
+;;
+
+; make compatible with older versions of newLISP
+(when (< (sys-info -2) 10111)
+    (constant (global 'write) write-buffer)
+    (constant (global 'term) name))
+
+; get list of files from command line
+(set 'files (2 (main-args)))
+
+(when (empty? files)
+    (println "USAGE: newlispdoc [-s] [-d] <file-names>")
+    (println "USAGE: newlispdoc [-s] [-d] -url <file-with-urls>")
+    (exit -1))
+
+
+(set 'prolog1
+[text]<!DOCTYPE HTML PUBLIC "HTML 4.01 Transitional">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>%s</title>
+[/text])
+
+(set 'stylesheet
+[text]
+<link rel="stylesheet" type="text/css" href="newlispdoc.css" />
+</head>
+[/text])
+
+(set 'prolog2
+[text]
+<body style="margin: 20px;" text="#111111" bgcolor="#FFFFFF" 
+            link="#376590" vlink="#551A8B" alink="#ffAA28">
+<blockquote>
+<center><h1>%s</h1></center>
+[/text])
+
+(set 'prolog3 {<p><a href="index.html">Module index</a></p>})
+
+(set 'epilog [text]
+<br/><br/><center>- &part; -</center><br/>
+<center><font face='Arial' size='-2' color='#444444'>
+generated with <a href="http://newlisp.org">newLISP</a>&nbsp;
+and <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a>
+</font></center>
+</blockquote>
+</body>
+</html>
+[/text])
+
+; ---------- routines for generating syntax-highlighted file <file-name>.src.html ------------------
+
+(define keyword-color "#0000AA")      ; newLISP keywords
+(define tag-color "#308080")          ; newLISPdoc tags
+(define string-color "#008800")       ; single line quoted and braced strings
+(define long-string-color "#008800")  ; multiline for [text], [/text] tags
+(define paren-color "#AA0000")        ; parenthesis
+(define comment-color "#555555")      ; comments
+(define number-color "#665500")       ; numbers
+
+(define function-name-color "#000088")    ; not implemented yet for func in (define (func x y z) ...)
+
+(set 'keywords (map term (filter (fn (x) (primitive? (eval x))) (sort (symbols) > ))))
+(push "nil" keywords)
+(push "true" keywords)
+(set 'keyword-regex (join keywords "|"))
+(replace "&" keyword-regex "&amp&")
+(replace "?" keyword-regex "\\?")
+(replace "^" keyword-regex "\\^")
+(replace "$" keyword-regex "\\$")
+(replace "!" keyword-regex "\\!")
+(replace "+" keyword-regex "\\+")
+(replace "*" keyword-regex "\\*")
+(replace "||" keyword-regex "|\\|")
+(set 'keyword-regex (append {(\G|\s+|\(|\))(} keyword-regex {)(\s+|\(|\))}))
+
+(define (clean-comment str)
+    (replace {<font color='#......'>} str "" 0)
+    (replace {</font>} str "")
+    (replace {[text]} str "&#091&text]")
+    (replace {[/text]} str "&#091&/text]")
+)
+
+(define (format-quoted-string str)
+    (replace {<font color='#......'>} str "" 0)
+    (replace {</font>} str "")
+    (replace ";" str "&#059&")
+    (replace "{" str "&#123&")
+    (replace "}" str "&#125&")
+    (replace {\} str "&#092&")
+    (replace {[text]} str "&#091&text]")
+    (replace {[/text]} str "&#091&/text]")
+    (format {<font color='%s'>%s</font>} string-color str)
+)
+
+(define (format-braced-string str)
+    (replace {<font color='#......'>} str "" 0)
+    (replace {</font>} str "")
+    (replace ";" str "&#059&")
+    (replace {"} str "&#034&")
+    (replace {[text]} str "&#091&text]")
+    (replace {[/text]} str "&#091&/text]")
+    (format {<font color='%s'>%s</font>} string-color str)
+)
+
+(define (format-tagged-string str)
+    (replace {<font color='#......'>} str "" 0)
+    (replace {</font>} str "")
+    (replace ";" str "&#059&")
+    (format {<font color='%s'>%s</font>} string-color str)
+)
+
+(define (write-syntax-highlight title src-file outputfile)
+    ; replace special HTML characters
+    (replace "\r\n" src-file "\n")
+    (replace "&" src-file "&amp&")
+    (replace "<(\\w)" src-file (append "&lt&" $1) 0)
+    (replace "(\\w)>" src-file (append $1 "&gt&") 0)
+    (replace "/>" src-file "/&gt&" 0)
+    (replace "</" src-file "&lt&/" 0)
+    (replace "<!" src-file "&lt&!" 0)
+    (replace "<\\?" src-file "&lt&?" 0)
+    ; replace escaped quotes
+    (replace  "\092\034"  src-file "&#092&&#034&")
+
+    ; color keywords
+    (replace keyword-regex src-file 
+        (format {%s<font color='%s'>%s</font>%s} $1 keyword-color $2 $3) 0)
+
+    ; color numbers
+    (replace 
+    ;   <-- lead --><---- hex ---->|<- oct ->|<------- decimal ----- and ----- scientific -->
+        {(\s+|\(|\))(0x[0-9a-fA-F]+|[+-]?0\d+|([+-]?(0|[1-9]\d*)(\.\d*)?|\.\d+)([eE][+-]?\d+)?)} src-file 
+            (format {%s<font color='%s'>%s</font>} $1 number-color $2) 0)
+
+    ; color parens
+    (replace "(" src-file (format {<font color='%s'>(</font>} paren-color))
+    (replace ")" src-file (format {<font color='%s'>)</font>} paren-color))
+
+    ; color braced strings
+    (replace "{.*?}" src-file (format-braced-string $0) 0) ; no multiline string
+    ; color quoted strings
+    (replace {".*?"} src-file (format-quoted-string $0) 0) ; no multiline strings
+
+    ; color ;  comments
+    (replace ";.*" src-file (clean-comment $0) 0)
+    (replace ";.*" src-file (format {<font color='%s'>%s</font>} comment-color $0) 0)
+    (replace "(;;.*)(@.*)(\\s.*\n)" src-file 
+            (append $1 (format {<font color='%s'>%s</font>} tag-color $2) $3) 512)
+
+    ; color # comments
+    (set 'buff "")
+    (dolist (lne (parse src-file "\n"))
+        (replace "^\\s*#.*" lne  (clean-comment $0) 0)
+        (replace "^\\s*#.*" lne (format {<font color='%s'>%s</font>} comment-color $0) 0)
+        (if (< (sys-info -2) 9909) 
+            (write-line lne buff) 
+            (write-line buff lne)))
+
+    (set 'src-file buff)
+
+    ; color tagged strings
+    (replace {\[text\].*?\[/text\]} src-file 
+        (format-tagged-string $0) 4) ; handles multiline strings
+
+    ; xlate back special characters
+    (replace "&amp&" src-file "&amp;")   ; ampersand
+    (replace "&lt&" src-file "&lt;")     ; less
+    (replace "&gt&" src-file "&gt;")     ; greater
+    (replace {&#034&} src-file "&#034;") ; quotes
+    (replace {&#059&} src-file "&#059;") ; semicolon
+    (replace {&#123&} src-file "&#123;") ; left curly brace
+    (replace {&#125&} src-file "&#125;") ; right curly brace
+    (replace {&#091&} src-file "&#091;") ; left bracket
+    (replace {&#092&} src-file "&#092;") ; back slash
+
+    ; add pre and post tags
+    (write-file (string outputfile ".src.html") 
+        (append
+            {<!DOCTYPE HTML PUBLIC "4.01 Transitional">}
+            {<META http-equiv="Content-Type" content="text/html; charset=utf-8" />}
+            "<html><title>" title "</title><body><pre>\n" src-file "\n</pre>" 
+            {<center><font face='Arial' size='-3' color='#666666'>}
+            {syntax highlighting with <a href="http://newlisp.org">newLISP</a>&nbsp;}
+            {and <a href="http://newlisp.org/newLISPdoc.html">newLISPdoc</a>}
+            {</font></center></body></html>}))
+)
+
+;---------------------------------- End syntax highlighting routines ------------------------
+
+; get command line switch -s for generating syntax highlighted source
+(let (pos (find "-s" files))
+    (when pos
+        (pop files pos)
+        (set 'source-link true)))
+
+; get command line switch -d for generating a download link
+(let (pos (find "-d" files))
+    (when pos
+        (pop files pos)
+        (set 'download-link true)))
+
+; get command line switch -url for retrieving files via http from remote location
+(let (pos (find "-url" files))
+    (when pos
+        (pop files pos)
+        (set 'url-file (files pos))
+        (set 'time-out (int (last files) 5000))))
+
+; if url-file is specified make a list of all urls
+(when url-file
+    (set 'files (parse (read-file url-file) "\\s+" 0)))
+
+(when (= (last files) "") (pop files -1))
+
+(set 'indexpage "") ; buffer for modules index page
+(write indexpage (format prolog1 "Index"))
+(write indexpage stylesheet)
+(write indexpage (format prolog2 "Index"))
+
+; reformat
+
+(define (protect-html text)
+    (replace "<h1>" text "[h1]")
+    (replace "<h2>" text "[h2]")
+    (replace "<h3>" text "[h3]")
+    (replace "<h4>" text "[h4]")
+    (replace "</h1>" text "[/h1]")
+    (replace "</h2>" text "[/h2]")
+    (replace "</h3>" text "[/h3]")
+    (replace "</h4>" text "[/h4]")
+    (replace "<i>" text "[i]")
+    (replace "</i>" text "[/i]")
+    (replace "<em>" text "[em]")
+    (replace "</em>" text "[/em]")
+    (replace "<b>" text "[b]")
+    (replace "</b>" text "[/b]")
+    (replace "<tt>" text "[tt]")
+    (replace "</tt>" text "[/tt]")
+    (replace "<p>" text "[p]")
+    (replace "</p>" text "[/p]")
+    (replace "<br>" text "[br]")
+    (replace "<br/>" text "[br/]")
+    (replace "<pre>" text "[pre]")
+    (replace "</pre>" text "[/pre]")
+    (replace "<center>" text "[center]")
+    (replace "</center>" text "[/center]")
+    (replace "<li>" text "[li]")
+    (replace "</li>" text "[/li]")
+    (replace "</ul>" text "[/ul]")
+    (replace "<ul>" text "[ul]")
+    (replace "</blockquote>" text "[/blockquote]")
+    (replace "<blockquote>" text "[blockquote]")
+    (replace "<hr>" text "[hr]") 
+    (replace "<hr/>" text "[hr/]") 
+)
+
+(define (unprotect-html text)
+    (replace "[h1]" text "<h1>")
+    (replace "[h2]" text "<h2>")
+    (replace "[h3]" text "<h3>")
+    (replace "[h4]" text "<h4>")
+    (replace "[/h1]" text "</h1>")
+    (replace "[/h2]" text "</h2>")
+    (replace "[/h3]" text "</h3>")
+    (replace "[/h4]" text "</h4>")
+    (replace "[i]" text "<i>")
+    (replace "[/i]" text "</i>")
+    (replace "[em]" text "<em>")
+    (replace "[/em]" text "</em>")
+    (replace "[b]" text "<b>")
+    (replace "[/b]" text "</b>")
+    (replace "[tt]" text "<tt>")
+    (replace "[/tt]" text "</tt>")
+    (replace "[p]" text "<p>")
+    (replace "[/p]" text "</p>")
+    (replace "[br]" text "<br>")
+    (replace "[br/]" text "<br/>")
+    (replace "[pre]" text "<pre>")
+    (replace "[/pre]" text "</pre>")
+    (replace "[center]" text "<center>")
+    (replace "[/center]" text "</center>")
+    (replace "[li]" text "<li>")
+    (replace "[/li]" text "</li>")
+    (replace "[ul]" text "<ul>")
+    (replace "[/ul]" text "</ul>")
+    (replace "[blockquote]" text "<blockquote>")
+    (replace "[/blockquote]" text "</blockquote>")
+    (replace "[hr]" text "<hr>") 
+    (replace "[hr/]" text "<hr/>") 
+)
+
+; format the example tags
+(define (format-example text)
+    (replace "<" text "&lt;")
+    (replace ">" text "&gt;")
+    (string "<b>Example:</b><blockquote><pre>" (replace ";;" text "") "</pre></blockquote>\n")
+)
+
+; write the module tag link on the index page
+; put source link on doc page if -s flag
+(define (format-module text desc filename , module)
+    (set 'module (string "<br/>\n<h2>Module:&nbsp;" text "</h2>"))
+    (write indexpage (string {<a href="} filename {.html">} module "</a>\n" ))
+    (write indexpage (string "<p>" desc "</p>\n"))
+
+    (let (link "")
+        (if source-link (setq link (string {<a href="} filename {.src.html">source</a>&nbsp;})))
+        (if download-link (write link (string {<a href="} filename {">download</a>})))
+        (string link module)
+    )
+)
+
+; write the function name links on the index page under the module
+(define (format-func-link func-name file-name)
+        (let (names (if (find ":" func-name) (parse func-name ":") (list "" func-name)))
+            (write indexpage (string {<a href="} file-name 
+                    {.html#} (names 0) "_" (names 1) {">} (names 1) {</a>&nbsp; &nbsp; }))
+            (string (names 0) "_" (names 1))
+        )
+)
+
+; format the syntax line
+(define (format-syntax text file-name, tag)
+    (replace "<([^<]*?)>" text (string "<em>" $1 "</em>") 0)
+    (replace {^ *\((.*?) (.*?\))} text (string "(<font color=#CC0000>" $1 "</font> " $2) 0)
+    (replace {^ *\(([^ ]*?)\)} text (string "(<font color=#CC0000>" $1 "</font>)") 0)
+    (replace {^ *([^ ()]*?)$} text (string "<font color=#CC0000>" $1 "</font>") 0)
+    (string
+        (if (!= old-syntax $1)
+            (begin
+                (set 'old-syntax $1)
+                (set 'tag (format-func-link $1 file-name))
+                (set 'tag (string {<a name="} tag {"></a>}))
+                (string "<br/><br/><center>&sect;</center><br/>\n" tag
+                        "<h3><font color=#CC0000>" old-syntax "</font></h3>\n"))
+            "")
+        "<b>syntax: " (trim text) "</b><br/>\n")
+)
+
+(define (format-parameter param text)
+    (string "<b>parameter: </b>" (format-text (trim param)) " - " (format-text text) "<br/>\n")
+)
+
+(define (format-return text)
+    (string "<p><b>return: </b>" (format-text text) "</p>\n") 
+)
+
+(define (format-text text)
+    (replace "<([^<]*?)>" text (string "<em>" $1 "</em>") 0)
+    (replace "'([^\\s].*?[^\\s])'" text (string "<tt>" $1 "</tt>") 0)
+)
+
+;---------------------------------- End newlisdoc formatting subroutines ----------------
+; MAIN function
+
+(dolist (fle files)
+    (println fle)
+    (set 'html "")
+
+    (set 'original (read-file fle time-out))
+
+    (if (not original)
+        (begin
+            (println "Could not read " fle)
+            (exit 1)))
+
+    (if (starts-with original "ERR:")
+        (println "Could not read " fle " " original))
+
+    (set 'outfile (last (parse fle "\\\\|/" 0)))
+
+    (set 'page (parse (replace "\r\n" original "\n") "\n"))
+
+    (set 'page (filter (fn (ln) (or (starts-with ln ";;(?!;)" 0) (= (length (trim ln)) 0))) page))
+    (set 'page (join page "\n"))
+
+    ; link to another index page
+    (when (find ";; *@index ([^ ]*?) ([^ ]*?)\\s*\n" page 0)
+        (write indexpage 
+            (string {<br /><br /><h2><a href="} $2 {">Index:&nbsp;} $1 "</a></h2>\n"))
+        (when (find ";; *@description (.*?)\n" page 0)
+            (write indexpage (string $1 "<br/>\n")))
+    )
+        
+
+    (if (find ";; *@module " page 0)
+        (begin
+            (replace {;;(.*) @link ([^ ]*?) ([^ ]*?)\s} page (string $1 { <a href="} $2 {">} $3 {</a> }) 0)
+            (replace ";; *@example *\n(.*?)\n\\s*\n" page (format-example $1) 4)
+            (set 'page (protect-html page))
+            (set 'desc "")
+            (replace ";; *@description (.*?)\n" page (begin (set 'desc $1) (string "<p>" desc "</p>\n") ) 0)
+            (replace ";; *@module (.*?)\n" page (format-module $1 desc outfile)  0)
+            (set 'module-title $1)
+            (replace ";; *@author (.*?)\n" page (string "<b>Author: </b>" $1 "<br/>\n")  0)
+            (replace ";; *@version (.*?)\n" page (string "<b>Version: </b>" $1 "<br/>\n")  0)
+            (replace ";; *@location (.*?)\n" page 
+                (string {<b>Location: </b><a href="} $1 {">} $1 "</a><br/>\n")  0)
+            (replace ";; *@syntax (.*?)\n" page (format-syntax $1 outfile) 0)
+            (replace ";; *@param (.*?) (.*?)\n" page (format-parameter $1 $2) 0)
+            (replace ";; *@return (.*?)\n" page (format-return $1)  0)
+            ;; custom tags, upper-case first letter
+            (replace ";; *@([a-zA-Z_-]*?) (.*?)\n" page (string "<b>" (title-case $1) ": </b>" $2 "<br/>\n") 0)
+            (replace ";;\\s*\n" page "<br/><br/>\n" 0)
+            (replace ";;(.*\n)" page (format-text $1) 0)
+            (set 'page (unprotect-html page))
+            (write html (format prolog1 outfile))
+            (write html stylesheet)
+            (write html (format prolog2 outfile))
+            (write html prolog3)
+            (write html page)
+            (write html epilog)
+
+            (write-file (string outfile ".html") html)
+
+            ; write syntax highlighted source   
+            (if source-link
+                (write-syntax-highlight module-title original outfile))
+
+        )
+    )
+)
+    
+; write the modules index page
+(write indexpage epilog)
+(write-file "index.html" indexpage)
+
+(exit)
+
diff --git a/util/newlispdoc.css b/util/newlispdoc.css
new file mode 100644
index 0000000..73aed29
--- /dev/null
+++ b/util/newlispdoc.css
@@ -0,0 +1,47 @@
+<!-- this file should reside in the same directory, where HTML
+     files generated with newlispdoc reside -->
+
+span.arw {
+	color:#666666;
+	font-size: 100%;
+	}
+	
+body 	{
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+	line-height: 100%;
+	max-width: 1000px;
+ 	}
+
+p 	{
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+	line-height: 100%;
+ 	}
+
+h3, h4 {
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+   	font-size: 100%;
+	}
+
+h1, h2 {
+	padding-top: 10px;
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+   	font-size: 100%;
+	}
+
+b 	{
+	font-family: Verdana, Lucida Sans, Helvetica,  sans-serif;
+   	font-size: 90%;
+	color: grey;
+	font-weight: 600;
+	}
+
+pre {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+   	font-size: 85%;
+	}
+
+tt {
+	font-family: Andale Mono, "Bitstream Vera Sans Mono", Monaco, "Courier New";
+	font-size: 95%;
+	}
+
diff --git a/util/nls b/util/nls
new file mode 100755
index 0000000..20e0310
--- /dev/null
+++ b/util/nls
@@ -0,0 +1,96 @@
+#!/usr/bin/newlisp
+
+; - nls - newLISP shell combines interactive OS and LISP shell
+;
+; v.1.0 - adapted to new manual HTML formatting 2009-08-04
+; v.1.1 - better regex string for syntax filtering 2011-11-01
+;         now formats dolist, dotimes ... etc. correctly
+; v.1.2 - fix for Windows probelm passing cr-lf in command-event
+; c.1.3 - cut off cr-lf only on versions < 10.4.1
+;
+; Directory and file commands to not work yet on names containing spaces!
+; Does not work with <,>,<<,>>
+;
+;
+; Use the prompt as if a Bash shell. Commands not starting with an opening
+; parenthesis or space are interpreted as UNIX shell cmomands, commands
+; starting with parenthesis or space are interpreted as interacive newLISP
+; commands.
+
+(define (help func-name)
+  (when (= func-name "help") (set 'func-name ""))
+  (if (find func-name "|+*-") (push "\\" func-name))
+  (set 'helpfile (read-file (if (= ostype "Win32")
+    (string (env "NEWLISPDIR") "/newlisp_manual.html") 
+    "/usr/share/doc/newlisp/newlisp_manual.html")))
+  (set 'html-text (join 
+    (find-all (format {(syntax: \(%s.*?)(<br/>|</h4>)} func-name ) helpfile $1) "\n"))
+  (replace "<.*?>" html-text "" 0)
+  (replace "&lt;" html-text "<")
+  (replace "&gt;" html-text ">")
+  (replace "&amp;" html-text "&")
+  (println html-text)
+  "")
+
+; set the prompt to the current path
+(prompt-event (fn (ctx) (string ctx ":" (real-path) "> ")))
+
+; handle some special commands, newLISP expressions and shell commands
+(command-event (fn (s) 
+  (if (and (< (sys-info -2) 10401) (= ostype "Win32"))
+        (set 's (chop s 2)))
+  (if 
+    ; get syntax help
+    (starts-with s "\\?|help" 0)
+    (help (last (parse s " ")))
+
+    ; restart newLISP
+    (starts-with s "reset")
+    (reset true) ; restart
+
+    ; avoid X-windows beeing started on OS X
+    (starts-with s "x")
+    ""
+
+    ; all directory changes must be done inside newLISP
+    ; previous directory cd -
+    (starts-with s "cd -")
+    (begin
+        (set 'new-dir prev-dir)
+        (set 'prev-dir (real-path))
+        (string " " (true? (change-dir new-dir))))
+	
+    ; pushd
+    (starts-with s "pushd")
+    (begin
+        (set 'prev-dir (real-path))
+        (push prev-dir dir-stack)
+        (string " " (true? (change-dir (last (parse s " "))))))
+
+    ; popd
+    (starts-with s "popd")
+    (begin
+        (set 'prev-dir (real-path))
+        (string " " (true? (change-dir (pop dir-stack)))))
+
+    ; go to home directory
+    (= s "cd")
+    (begin
+        (set 'prev-dir (real-path))
+        (string " " (true? (change-dir (env "HOME")))))
+
+    ; change directory cd
+    (starts-with s "cd") 
+    (begin
+        (set 'prev-dir (real-path))
+        (string " " (true? (change-dir (last (parse s " "))))))
+
+    ; else handle as a shell command, start newLISP expressions
+    ; with either a space or a parenthesis
+    (starts-with s "[\\.a-zA-Z]" 0)
+    (append "!" s)
+
+    true s)))
+
+;; eof
+
diff --git a/util/org.newlisp.newlisp.plist b/util/org.newlisp.newlisp.plist
new file mode 100644
index 0000000..042cd31
--- /dev/null
+++ b/util/org.newlisp.newlisp.plist
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN"
+		"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!-- This file is used on Mac OS X for the launchd and launchctl
+utiities. The file should go into the $HOME/Library/LaunchAgents/
+directory or in the system wide Library/LaunchAgents/ directory 
+customize the -d (port) and -w (working directory) options to 
+your own liking -->
+<plist version="1.0">
+<dict>
+	<key>Label</key>
+	<string>org.newlisp.newlisp</string>
+	<key>ProgramArguments</key>
+	<array>
+		<string>/usr/bin/newlisp</string>
+		<string>-c</string>
+		<string>-d4711</string>
+		<string>-w/Users/lutzmueller/Sites</string>
+	</array>
+	<key>RunAtLoad</key>
+	<true/>
+</dict>
+</plist>
diff --git a/util/package.jsn b/util/package.jsn
new file mode 100644
index 0000000..35995b0
--- /dev/null
+++ b/util/package.jsn
@@ -0,0 +1,9 @@
+{
+  "name": "newLISP",
+  "version": "10.6.3",
+  "repo": "newlisp.org",
+  "description": "Lisp-like scripting language",
+  "keywords": ["statistics", "AI", "networking", "multicore", "distributed processing"],
+  "license": "GPL3",
+  "install": "make; make install"
+}
diff --git a/util/sql.c b/util/sql.c
new file mode 100644
index 0000000..66949c1
--- /dev/null
+++ b/util/sql.c
@@ -0,0 +1,75 @@
+/* 
+  sql.c - find offsets of important data fields in MySQL data structures 
+
+  version 1.1, (c) Lutz Mueller 2004, released under the GNU GPL License
+  version 1.2 added 2 more include files for 4.0
+
+  compile using: gcc sql.c -o sql
+
+  then do: ./sql
+  to obtain a list of offsets in MySQL data structures for different
+  versions and compile flavors of MySQL
+
+  this program is only needed when designing new MySQL support functions
+  in newLISP and the MySQL data structures have to be accessed directly
+
+  the values produced by this program are used in the files mysql.lsp,
+  mysql5.lsp and mysql51.lsp
+
+  See also /usr/share/newlisp/mysql.lsp
+
+*/
+
+
+#define LINUX
+/* #define MACOSX */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#ifdef MACOSX
+#include "/usr/local/mysql/include/mysql.h"
+#include "/usr/local/mysql/include/mysql_com.h"
+#include "/usr/local/mysql/include/mysql_version.h"
+#include "/usr/local/mysql/include/my_alloc.h"
+#endif
+
+#ifdef LINUX
+#include "/usr/include/mysql/mysql.h"
+#include "/usr/include/mysql/mysql_com.h"
+#include "/usr/include/mysql/mysql_version.h"
+#include "/usr/include/mysql/my_alloc.h"
+#endif
+
+MYSQL  * mysql;
+MYSQL_RES  * mysql_res;
+
+
+int main(int argc, char ** argv)
+{
+printf("sizeof(MYSQL)       %d\n", sizeof(MYSQL));
+printf("sizeof(MYSQL_RES)   %d\n", sizeof(MYSQL_RES));
+printf("sizeof(MYSQL_ROW)   %d\n", sizeof(MYSQL_ROW));
+printf("sizeof(MYSQL_FIELD) %d\n", sizeof(MYSQL_FIELD));
+printf("sizeof(NET) %d\n", sizeof(NET));
+printf("sizeof(my_ulonglong) %d\n", sizeof(my_ulonglong));
+printf("sizeof(my_bool) %d\n\n", sizeof(my_bool));
+
+mysql = 0;
+mysql_res = 0;
+
+printf("offset mysql->affected_rows: %d\n", &mysql->affected_rows);
+printf("offset mysql->insert_id: %d\n", &mysql->insert_id);
+printf("offset mysql->net.last_error: %d\n", &mysql->net.last_error);
+
+printf("offset mysql_res->row_count: %d\n", &mysql_res->row_count);
+printf("offset mysql_res->field_count: %d\n", &mysql_res->field_count);
+printf("offset mysql_res->eof: %d\n", &mysql_res->eof);
+
+
+return 0;
+}
+
+/* eof */
+
diff --git a/util/standard.lsp b/util/standard.lsp
new file mode 100644
index 0000000..bfe2906
--- /dev/null
+++ b/util/standard.lsp
@@ -0,0 +1,5 @@
+# this file is used together with newlispdoc to create an index entry
+# to a remote modules collection
+;; @index Standard http://newlisp.org/code/modules
+;; @description Standard modules shipped with the distribution
+
diff --git a/util/syntax.cgi b/util/syntax.cgi
new file mode 100755
index 0000000..c41ac4b
--- /dev/null
+++ b/util/syntax.cgi
@@ -0,0 +1,235 @@
+#!/usr/bin/env newlisp
+
+# - syntax.cgi - this utility formats a newLISP source file as an HTML 
+# file with syntax highlighting
+#
+# comment following line out when not using as CGI utilty
+# for CGI files to convert which are local must end with .txt
+
+# v.1.7 - switch for using as commandline or cgi utility
+# v.1.9 - fixed highlighting problem with escaped quotes
+# v.2.0 - fixed \r\n translation
+# v.2.1 - more compatible CGI
+# v.2.3 - changed syntax for write-line
+# v.2.4 - added handling of < ? ... > XML tag
+# v.2.5 - generate more compliant HTML 4.01 transitional
+# v.2.6 - handle number scientific format with e
+# v.2.7 - improved keyword regex
+# v.2.8 - scientific format with E
+# v.2.9 - support for newLISPdoc tag color
+# v.3.0 - correctly highlight & and ^ keywords
+# v.3.1 - change additional 'nil' arg in 'starts-with' to 1
+# v.3.2 - replace 'name' with 'term' and make compatible with older versions
+# v.3.3 - added utf-8 meta tag in header
+# v.3.4 - fontsize 150% for iPad or iPhone
+#
+# formats newLISP source files with syntax highlighting in HTML
+#
+# use on the command line or as cgi file together with a webserver
+# 
+# EXAMPLE command line (set 'cgi-use nil):
+#
+#    ./syntaxi.cgi mysource.lsp > mysource.lsp.html
+#
+# formats mysorce.lsp and redirects output to a new file mysource.lsp.html
+#
+# EXAMPLE webserver CGI (tested on Apache) local files must end in txt for security
+#
+#    http://www.mysite.com/syntax.cgi?mysource.lsp.txt
+#
+# returns mysorce.lsp HTML formatted to the requesting client (browser)
+#
+# EXAMPLE webserver CGI with other site URL
+#
+#    http://www.mysite.com/syntax.cgi?http://othersite/afile.lsp
+#
+# displays afile.lsp formateed from other site
+#
+# the following situations are not handled correctly:
+#    - nested curly braces for strings like {abd{def}ghi}
+#    - multiline quoted strings, use [text] [/text] instead
+#    - multiline braced strings, use [text] [/text] instead
+#    - comments starting with # but not starting at beginning of line
+#      use ; as comment starter when comment appears after code
+
+
+(define cgi-use true)
+
+; make compatible with versions prior to 10.1.11
+(when (< (sys-info -2) 10111)
+    (constant (global 'term) name))
+
+(when cgi-use 
+	(print "Content-Type: text/html\r\n\r\n")
+	(set 'iPad (find "iPad" (env "HTTP_USER_AGENT") 1))
+	(set 'iPhone (find "iPhone" (env "HTTP_USER_AGENT") 1))
+)
+		
+
+(define keyword-color "#0000AA")      ; newLISP keywords
+(define tag-color "#308080")          ; newLISPdoc tags
+(define string-color "#008800")       ; single line quoted and braced strings
+(define long-string-color "#008800")  ; multiline for [text], [/text] tags
+(define paren-color "#AA0000")        ; parenthesis
+(define comment-color "#555555")      ; comments
+(define number-color "#665500")       ; numbers
+
+(define function-name-color "#000088")    ; not implemented yet for func in (define (func x y z) ...)
+
+(set 'keywords (map term (filter (fn (x) (primitive? (eval x))) (sort (symbols) > ))))
+(push "nil" keywords)
+(push "true" keywords)
+(set 'keyword-regex (join keywords "|"))
+(replace "&" keyword-regex "&amp&")
+(replace "?" keyword-regex "\\?")
+(replace "^" keyword-regex "\\^")
+(replace "$" keyword-regex "\\$")
+(replace "!" keyword-regex "\\!")
+(replace "+" keyword-regex "\\+")
+(replace "*" keyword-regex "\\*")
+(replace "||" keyword-regex "|\\|")
+(set 'keyword-regex (append {(\G|\s+|\(|\))(} keyword-regex {)(\s+|\(|\))}))
+
+(set 'file (if cgi-use 
+	(or (read-line) (env "QUERY_STRING"))
+	(main-args 2)))
+
+(set 'title file)
+
+(when cgi-use
+    (when (and (not (starts-with file "http://" 1)) (not (ends-with file ".txt")))
+        (println "<h3>File not allowed for viewing: " file "</h3>")
+        (exit))
+)
+
+
+(if (starts-with file "http://" 1)
+	(set 'file (get-url file 10000))
+	(set 'file (read-file file )))
+
+(unless file
+    (println "<h3>Cannot find file</h3>")
+    (exit))
+
+(define (clean-comment str)
+	(replace {<font color='#......'>} str "" 0)
+	(replace {</font>} str "")
+	(replace {[text]} str "&#091&text]")
+	(replace {[/text]} str "&#091&/text]")
+)
+
+(define (format-quoted-string str)
+	(replace {<font color='#......'>} str "" 0)
+	(replace {</font>} str "")
+	(replace ";" str "&#059&")
+	(replace "{" str "&#123&")
+	(replace "}" str "&#125&")
+	(replace {\} str "&#092&")
+	(replace {[text]} str "&#091&text]")
+	(replace {[/text]} str "&#091&/text]")
+	(format {<font color='%s'>%s</font>} string-color str)
+)
+
+(define (format-braced-string str)
+	(replace {<font color='#......'>} str "" 0)
+	(replace {</font>} str "")
+	(replace ";" str "&#059&")
+	(replace {"} str "&#034&")
+	(replace {[text]} str "&#091&text]")
+	(replace {[/text]} str "&#091&/text]")
+	(format {<font color='%s'>%s</font>} string-color str)
+)
+
+(define (format-tagged-string str)
+	(replace {<font color='#......'>} str "" 0)
+	(replace {</font>} str "")
+	(replace ";" str "&#059&")
+	(format {<font color='%s'>%s</font>} string-color str)
+)
+
+; replace special HTML characters
+(replace "\r\n" file "\n")
+(replace "&" file "&amp&")
+(replace "<(\\w)" file (append "&lt&" $1) 0)
+(replace "(\\w)>" file (append $1 "&gt&") 0)
+(replace "/>" file "/&gt&" 0)
+(replace "</" file "&lt&/" 0)
+(replace "<!" file "&lt&!" 0)
+(replace "<\\?" file "&lt&?" 0)
+; replace escaped quotes
+(replace  "\092\034"  file "&#092&&#034&")
+
+; color keywords
+(replace keyword-regex file (format {%s<font color='%s'>%s</font>%s} $1 keyword-color $2 $3) 0)
+;(replace keyword-regex file (println "->" $0 "<-<br>") 0)
+;(exit)
+
+; color numbers
+(replace  
+;   <-- lead --><---- hex ---->|<- oct ->|<------- decimal ----- and ----- scientific -->
+	{(\s+|\(|\))(0x[0-9a-fA-F]+|[+-]?0\d+|([+-]?(0|[1-9]\d*)(\.\d*)?|\.\d+)([eE][+-]?\d+)?)} file 
+         (format {%s<font color='%s'>%s</font>} $1 number-color $2) 0)
+
+
+; color parens
+(replace "(" file (format {<font color='%s'>(</font>} paren-color))
+(replace ")" file (format {<font color='%s'>)</font>} paren-color))
+
+; color braced strings
+(replace "{.*?}" file (format-braced-string $0) 0) ; no multiline string
+; color quoted strings
+(replace {".*?"} file (format-quoted-string $0) 0) ; no multiline strings
+
+; color ;  comments
+(replace ";.*" file (clean-comment $0) 0)
+(replace ";.*" file (format {<font color='%s'>%s</font>} comment-color $0) 0)
+(replace "(;;.*)(@.*)(\\s.*\n)" file (append $1 (format {<font color='%s'>%s</font>} tag-color $2) $3) 512)
+
+; color # comments
+(set 'buff "")
+(dolist (lne (parse file "\n"))
+	(replace "^\\s*#.*" lne  (clean-comment $0) 0)
+	(replace "^\\s*#.*" lne (format {<font color='%s'>%s</font>} comment-color $0) 0)
+	(if (< (sys-info -2) 9909) 
+		(write-line lne buff)
+		(write-line buff lne)))
+(set 'file buff)
+
+; color tagged strings
+(replace {\[text\].*?\[/text\]} file (format-tagged-string $0) 4) ; handles multiline strings
+
+; xlate back special characters
+(replace "&amp&" file "&amp;")   ; ampersand
+(replace "&lt&" file "&lt;")     ; less
+(replace "&gt&" file "&gt;")     ; greater
+(replace {&#034&} file "&#034;") ; quotes
+(replace {&#059&} file "&#059;") ; semicolon
+(replace {&#123&} file "&#123;") ; left curly brace
+(replace {&#125&} file "&#125;") ; right curly brace
+(replace {&#091&} file "&#091;") ; left bracket
+(replace {&#092&} file "&#092;") ; back slash
+
+; add pre and post tags
+(println (append 
+	{<!DOCTYPE HTML PUBLIC "4.01 Transitional">}
+	"<html><head><title>" title "</title>\n"
+	{<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />}
+	{<style type="text/css">}
+	(if (or iPad iPhone)
+		{pre {font-size: 150%}}
+		{pre {font-size: 100%}} )
+	"</style></head><body>\n<pre>\n" 
+	file "\n</pre>" 
+))
+
+(println {<center><font face='Arial' size='-2' color='#444444'>}
+         {syntax highlighting with <a href="http://newlisp.org">newLISP</a>&nbsp;}
+         {and <a href="http://newlisp.org/syntax.cgi?code/syntax-cgi.txt">syntax.cgi</a>}
+         {</font></center>})
+
+(println {</body></html>})
+
+(exit)
+
+;; eof
+
diff --git a/util/types b/util/types
new file mode 100644
index 0000000..4893162
Binary files /dev/null and b/util/types differ
diff --git a/util/types.c b/util/types.c
new file mode 100644
index 0000000..97756c5
--- /dev/null
+++ b/util/types.c
@@ -0,0 +1,265 @@
+/* types.c -- find out size of data types */
+
+/* 
+
+output on Mac OS X PPCi, memory model ILP32
+
+type        bytes
+-----------------
+char          1
+char *        4
+void *        4
+short int     2
+int           4
+long          4
+long int      4
+long long int 8
+float         4
+double        8
+wchar_t       4
+size_t        4
+off_t         4
+time_t        4
+intptr_t      4
+
+output on Windows MinGW 32-bit
+
+type        bytes
+-----------------
+char          1
+char *        4
+void *        4
+short int     2
+int           4
+long          4
+long int      4
+long long int 8
+float         4
+double        8
+long double   12
+wchar_t       2
+size_t        4
+off_t         4
+time_t        4
+intptr_t      4
+
+output on AMD64 and Intel dual Core 2, memory model LP64
+
+type        bytes
+-----------------
+char          1
+char *        8
+void *        8
+short int     2
+int           4 
+long          8
+long int      8
+long long int 8
+float         4
+double        8
+long double  16
+wchar_t       4
+size_t        8
+off_t         8
+time_t        8
+intptr_t      8
+
+LLP64 Windows when compiling with tdm gcc 64-bit
+
+type        bytes
+-----------------
+char          1
+char *        8
+void *        8
+short int     2
+int           4
+long          4
+long int      4
+long long int 8
+float         4
+double        8
+long double   16
+wchar_t       2
+size_t        8
+off_t         4
+time_t        8
+intptr_t      8
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <fcntl.h>
+#include <locale.h>
+#include <inttypes.h>
+
+#ifndef time_t
+#include <time.h>
+#endif
+
+typedef struct {
+    char one;
+    short int two;
+    int four;
+    } alignment1;
+
+typedef struct {
+    char one;
+    int four;
+    short int two;
+    } alignment2;
+
+typedef struct {
+    char one;
+    short int two;
+    long three;
+    int four;
+    } alignment3;
+
+typedef struct {
+    char one;
+    long three;
+    short int two;
+    int four;
+    } alignment4;
+
+#define str2cmp(s1,s2) ( ( (*(unsigned char *)(s1) << 8) |  *((unsigned char *)(s1) + 1) ) - \
+						 ( (*(unsigned char *)(s2) << 8) |  *((unsigned char *)(s2) + 1) )  )		 
+void printMemoryModel(void);
+
+int main(int argc, char * argv[])
+{
+int endian = 1;
+long long int x, y, z;
+
+alignment1 checkstruct1;
+alignment2 checkstruct2;
+alignment3 checkstruct3;
+alignment4 checkstruct4;
+
+printf("\n");
+printf("type        bytes\n");
+printf("-----------------\n");
+printf("char          %lu\n", sizeof(char));
+printf("char *        %lu\n", sizeof(char *));
+printf("void *        %lu\n", sizeof(void *));
+printf("short int     %lu\n", sizeof(short int));
+printf("int           %lu\n", sizeof(int));
+printf("long          %lu\n", sizeof(long));
+printf("long int      %lu\n", sizeof(long int));
+printf("long long int %lu\n", sizeof(long long int));
+printf("float         %lu\n", sizeof(float));
+printf("double        %lu\n", sizeof(double));
+printf("long double   %lu\n", sizeof(long double));
+printf("wchar_t       %lu\n", sizeof(wchar_t));
+printf("size_t        %lu\n", sizeof(size_t));
+printf("off_t         %lu\n", sizeof(off_t));
+printf("time_t        %lu\n", sizeof(time_t));
+#if defined(_INTTYPES_H_)
+printf("intptr_t      %lu\n", sizeof(intptr_t));
+#endif
+
+printf("\nAlignment:\n");
+printf("size of struct {char, short int, int} is: %ld\n", sizeof(checkstruct1));
+printf("size of struct {char, int, short int} is: %ld\n", sizeof(checkstruct2));
+printf("size of struct {char, short int, long, int} is: %ld\n", sizeof(checkstruct3));
+printf("size of struct {char, long, short int, int} is: %ld\n", sizeof(checkstruct4));
+printf("\n");
+
+printf("format input                  output\n");
+printf("--------------------------------------------------\n");
+printf("%%d     0x7fffffff             %d\n", 0x7fffffff);
+printf("%%d     0x80000000             %d\n", 0x80000000);
+printf("%%d     0xffffffff             %d\n", 0xffffffff);
+printf("%%u     0x7fffffff             %u\n", 0x7fffffff);
+printf("%%u     0x80000000             %u\n", 0x80000000);
+printf("%%u     0xffffffff             %u\n", 0xffffffff);
+#ifndef TRUE64
+/* will handle either 32bit or 64bit depending on platform
+printf("%%ld   0x7fffffffffffffffL    %ld\n", 0x7FFFFFFFL);
+printf("%%ld   0x8000000000000000L    %ld\n", 0x80000000L);
+printf("%%ld   0xffffffffffffffffL    %ld\n", 0xFFFFFFFFL);
+printf("%%lu   0x7fffffffffffffffL    %lu\n", 0x7FFFFFFFL);
+printf("%%lu   0x8000000000000000L    %lu\n", 0x80000000L);
+printf("%%lu   0xffffffffffffffffL    %ld\n", 0xFFFFFFFFL);
+*/
+#endif
+printf("%%llx   0x7FFFFFFFFFFFFFFFLL   %llx\n", 0x7FFFFFFFFFFFFFFFLL);
+printf("%%llx   0x8000000000000000LL   %llx\n", 0x8000000000000000LL);
+printf("%%llx   0xFFFFFFFFFFFFFFFFLL   %llx\n", 0xFFFFFFFFFFFFFFFFLL);
+printf("%%llX   0x7fffffffffffffffLL   %llX\n", 0x7fffffffffffffffLL);
+printf("%%llX   0x8000000000000000LL   %llX\n", 0x8000000000000000LL);
+printf("%%llX   0xffffffffffffffffLL   %llX\n", 0xffffffffffffffffLL);
+#ifndef TRU64
+printf("%%lld   0x7fffffffffffffffLL   %lld\n", 0x7fffffffffffffffLL);
+printf("%%lld   0x8000000000000000LL   %lld\n", 0x8000000000000000LL);
+printf("%%lld   0xffffffffffffffffLL   %lld\n", 0xffffffffffffffffLL);
+printf("%%llu   0x7fffffffffffffffLL   %lld\n", 0x7fffffffffffffffLL);
+printf("%%llu   0x8000000000000000LL   %llu\n", 0x8000000000000000LL);
+printf("%%llu   0xffffffffffffffffLL   %llu\n", 0xffffffffffffffffLL);
+#else
+printf("%%ld   0x7fffffffffffffffLL    %ld\n", 0x7FFFFFFFFFFFFFFFLL);
+printf("%%ld   0x8000000000000000LL    %ld\n", 0x8000000000000000LL);
+printf("%%ld   0xffffffffffffffffLL    %ld\n", 0xFFFFFFFFFFFFFFFFLL);
+printf("%%lu   0x7fffffffffffffffLL    %lu\n", 0x7FFFFFFFFFFFFFFFLL);
+printf("%%lu   0x8000000000000000LL    %lu\n", 0x8000000000000000LL);
+printf("%%lu   0xffffffffffffffffLL    %ld\n", 0xFFFFFFFFFFFFFFFFLL);
+#endif
+
+printf("\n");
+
+if(*(char *)&endian == 1)
+	printf("CPU is little endian\n");
+else
+	printf("CPU is big endian\n");
+	
+#ifdef __LITTLE_ENDIAN__
+printf("The constant __LITTLE_ENDIAN__ is defined by the compiler\n");
+#endif
+
+#ifdef __BIG_ENDIAN__
+printf("The constant __BIG_ENDIAN__ is defined by the compiler\n");
+#endif
+
+printMemoryModel();
+printf("\n");
+
+/*
+x = 9223372036854775807LL; 
+y = 1000LL;
+z = x * y;
+printf("\n9223372036854775807 * 1000 = %ld <- should be -1000\n", z);
+
+x = 11;
+y = -4;
+z = x % y;
+
+printf("11 %% -4 = %ld <- should be 3\n", z);
+
+setlocale(LC_NUMERIC, "");
+printf("$%'.2Lf\n", 123456789.00L);
+printf("$%'.2Lf\n", 1234.56L);
+printf("$%'.2Lf\n", 123.45L);
+*/
+
+
+exit(0);
+}
+
+void printMemoryModel(void)
+{
+short sc = sizeof(char) * 8;
+short ss = sizeof(short) * 8;
+short si = sizeof(int) * 8;
+short sl = sizeof(long) * 8;
+short sp = sizeof(void*) * 8;
+
+printf("\nMemory model is ");
+if (si == 32 && sl == 64 && sp == 64) { printf("LP64\n"); return;}
+if (si == 64 && sl == 64 && sp == 64) { printf("ILP64\n"); return;}
+if (si == 32 && sl == 32 && sp == 64) { printf("LLP64\n"); return;}
+if (si == 32 && sl == 32 && sp == 32) { printf("ILP32\n"); return;}
+if (si == 16 && sl == 32 && sp == 32) { printf("LP32\n"); return;}
+printf("UNKNOWN\n"); 
+}
diff --git a/util/uninstall.command b/util/uninstall.command
new file mode 100755
index 0000000..985a657
--- /dev/null
+++ b/util/uninstall.command
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+# this file is part of the OSX install image
+
+sudo rm /usr/local/bin/newlisp
+sudo rm /usr/local/bin/newlisp-edit
+sudo rm /usr/local/bin/newlispdoc
+sudo rm /usr/local/share/man/man1/newlispdoc.1
+sudo rm /usr/local/share/man/man1/newlisp.1
+sudo rm -rf /usr/local/share/newlisp/
+sudo rm -rf /usr/local/share/doc/newlisp/
+sudo rm -rf /Applications/newLISP-GS.app
+sudo rm -rf /Library/Receipts/newLISPpackage.pkg
+
+echo 'newLISP and newLISP-GS uninstalled, quit Terminal'
diff --git a/win-dll.c b/win-dll.c
new file mode 100644
index 0000000..9399fa6
--- /dev/null
+++ b/win-dll.c
@@ -0,0 +1,223 @@
+/* win-dll.c - make the newlisp.exe usable as a DLL 
+
+    Copyright (C) 2011 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+#include <winsock2.h>
+
+#define EXPORT __declspec(dllexport) __stdcall
+
+extern int bigEndian;
+extern char preLoad[];
+extern CELL * sysEvalString(char * str, SYMBOL * context, CELL * proc, int mode);
+extern char linkOffset[];
+extern int evalSilent;
+extern int opsys;
+extern SYMBOL * mainArgsSymbol;
+extern FILE * IOchannel;
+extern int newlispLibConsoleFlag;
+
+
+int dllInitialized = 0;
+WSADATA WSAData;
+
+char libName[MAX_LINE] = "newlisp.dll";
+
+void initializeMain(void)
+{
+char name[MAX_LINE];
+char * initFile;
+
+
+WSAStartup(MAKEWORD(2,2), &WSAData);
+
+_setmode(_fileno(stdin), _O_BINARY);
+_setmode(_fileno(stdout), _O_BINARY);
+_setmode(_fileno(stderr), _O_BINARY);
+
+opsys += 64;
+
+#ifdef SUPPORT_UTF8
+opsys += 128;
+#endif
+
+#ifdef NEWLISP64
+opsys += 256;
+#endif
+
+#ifdef FFI
+opsys += 1024;
+initFFI();
+#endif
+
+bigEndian = (*((char *)&bigEndian) == 0);
+initLocale();
+initStacks();
+initialize();
+IOchannel = stdin;
+
+mainArgsSymbol->contents = (UINT)makeCell(CELL_EXPRESSION, (UINT)stuffString(libName));
+sysEvalString(preLoad, mainContext, nilCell, EVAL_STRING);
+
+initFile = getenv("NEWLISPLIB_INIT");
+
+if(initFile)
+	{
+	strncpy(name, initFile, MAX_LINE);
+    name[MAX_LINE - 1] = 0;
+	loadFile(name, 0, 0, mainContext);
+	}
+
+if(strncmp(linkOffset + 4, "@@@@", 4)) /* contains linked source */
+	{
+	GetModuleFileName(GetModuleHandle(libName), name, MAX_LINE);
+	loadFile(name, *(UINT*)linkOffset, 1, mainContext);
+	}
+
+dllInitialized = 1;
+reset();
+}
+
+/* ------------ initialize DLL (gets called by Windows) ----------------- */
+
+extern STREAM errorStream;
+
+STREAM libStrStream = {NULL, NULL, 0, 0, 0};
+
+int CALLBACK LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine)
+{
+return 1;
+}
+
+
+/* called automatically from nl-import when DLL is loaded from newLISP */
+
+int EXPORT dllName(LPSTR name)
+{
+strncpy(libName, name, MAX_LINE);
+return(1);
+}
+
+/* import and call this to create a console for stdio - debugging I/O  */
+
+int EXPORT debugConsole() {
+
+   IOchannel = stdin;
+
+   if(!AllocConsole())
+		return(0);
+
+   if(freopen("CONOUT$","w+t",stdout) == NULL) return(0);
+   if(freopen("CONIN$","r+t",stdin) == NULL) return(0);  
+
+return(1);
+}
+
+/* ---- imported and called from a client using newlisp.dll ---- */
+
+LPSTR EXPORT newlispEvalStr(LPSTR cmd)
+{
+if(!dllInitialized) initializeMain();
+
+if(setjmp(errorJump)) 
+	{
+	reset();
+	initStacks();
+	if(errorReg) 
+		{
+		executeSymbol(errorEvent, NULL, NULL);
+		return((LPSTR)libStrStream.buffer);
+		}
+	else
+	    return((LPSTR)errorStream.buffer);
+	}
+
+openStrStream(&libStrStream, MAX_STRING, 1);
+executeCommandLine(cmd, (UINT)&libStrStream, NULL);
+
+if(evalSilent) evalSilent = 0;
+
+return((LPSTR)libStrStream.buffer);
+}
+
+
+LPSTR EXPORT dllEvalStr(LPSTR cmd)
+{
+return(newlispEvalStr(cmd));
+}
+
+/* don't let stdout be included in return string */
+int EXPORT newlispLibConsole(int flag)
+{
+newlispLibConsoleFlag = flag;
+return(flag);
+}
+
+
+/* callbacks from newlisp library into caller 
+
+currently only tested with newLISP as caller:
+
+(import "newlisp.dylib" "newlispEvalStr")
+(import "newlisp.dylib" "newlispCallback")
+(define (callme p1 p2 p3) (println "p1 => " p1 " p2 => " p2 " p3 => " p3) "hello world")
+(newlispCallback "callme" (callback 0 'callme) "cdecl")
+(get-string (newlispEvalStr {(get-string (callme 123 456 789))})) ; for string return
+;(get-string (newlispEvalStr {(callme 123 456 789)})) ; for number return
+
+*/
+
+intptr_t EXPORT newlispCallback(char * funcName, intptr_t funcAddr, char * callType)
+{
+CELL * pCell;
+SYMBOL * symbol;
+
+if(!dllInitialized) initializeMain();
+
+if(callType != NULL && strcmp(callType, "cdecl") ==  0)
+	pCell = getCell(CELL_IMPORT_CDECL);
+else
+	pCell = getCell(CELL_IMPORT_DLL);
+
+symbol = translateCreateSymbol(funcName, pCell->type, currentContext, TRUE);
+
+if(isProtected(symbol->flags))
+    {
+	errorProcExt2(ERR_SYMBOL_PROTECTED, stuffSymbol(symbol));
+    return(-1);
+    }
+
+deleteList((CELL *)symbol->contents);
+symbol->contents = (UINT)pCell;
+pCell->contents = (UINT)funcAddr;
+
+pCell->aux = (UINT)symbol->name;
+
+return(funcAddr);
+}
+
+
+/* ------------ called from Windows when unloading DLL ------------------ */
+
+int EXPORT WEP (int bSystemExit)
+{
+return(1);
+}
+
+/* eof */
diff --git a/win-dll.def b/win-dll.def
new file mode 100644
index 0000000..801c4a0
--- /dev/null
+++ b/win-dll.def
@@ -0,0 +1,8 @@
+EXPORTS
+    WEP@4 @1
+    debugConsole@0 @2
+    dllEvalStr@4 @3
+    dllName@4 @4
+    newlispCallback@12 @5
+    newlispEvalStr@4 @6
+    newlispLibConsole@4 @7
diff --git a/win-ffi.h b/win-ffi.h
new file mode 100644
index 0000000..00f9b1b
--- /dev/null
+++ b/win-ffi.h
@@ -0,0 +1,558 @@
+/* -----------------------------------------------------------------*-C-*-
+   libffi 3.0.10 - Copyright (c) 2012 Anthony Green
+                    - Copyright (c) 1996-2003, 2007, 2008 Red Hat, Inc.
+
+   Permission is hereby granted, free of charge, to any person
+   obtaining a copy of this software and associated documentation
+   files (the ``Software''), to deal in the Software without
+   restriction, including without limitation the rights to use, copy,
+   modify, merge, publish, distribute, sublicense, and/or sell copies
+   of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+
+   ----------------------------------------------------------------------- */
+
+/* -------------------------------------------------------------------
+   The basic API is described in the README file.
+
+   The raw API is designed to bypass some of the argument packing
+   and unpacking on architectures for which it can be avoided.
+
+   The closure API allows interpreted functions to be packaged up
+   inside a C function pointer, so that they can be called as C functions,
+   with no understanding on the client side that they are interpreted.
+   It can also be used in other cases in which it is necessary to package
+   up a user specified parameter and a function pointer as a single
+   function pointer.
+
+   The closure API must be implemented in order to get its functionality,
+   e.g. for use by gij.  Routines are provided to emulate the raw API
+   if the underlying platform doesn't allow faster implementation.
+
+   More details on the raw and cloure API can be found in:
+
+   http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
+
+   and
+
+   http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
+   -------------------------------------------------------------------- */
+
+#ifndef LIBFFI_H
+#define LIBFFI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Specify which architecture libffi is configured for. */
+#ifdef WIN_32 /* in makefile */
+#ifndef X86_WIN32
+#define X86_WIN32
+#endif
+#endif
+
+#ifdef WIN_64 /* in makefile */
+#ifndef X86_WIN64
+#define X86_WIN64
+#endif
+#endif
+
+/* ---- System configuration information --------------------------------- */
+
+/* ============================== begin ffitarget.h ====================== */
+
+/* -----------------------------------------------------------------*-C-*-
+   ffitarget.h - Copyright (c) 1996-2003, 2010  Red Hat, Inc.
+   Copyright (C) 2008  Free Software Foundation, Inc.
+
+   Target configuration macros for x86 and x86-64.
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   ``Software''), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be included
+   in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+
+   ----------------------------------------------------------------------- */
+
+#ifndef LIBFFI_TARGET_H
+#define LIBFFI_TARGET_H
+
+/* ---- System specific configurations ----------------------------------- */
+
+/* For code common to all platforms on x86 and x86_64. */
+#define X86_ANY
+
+#if defined (X86_64) && defined (__i386__)
+#undef X86_64
+#define X86
+#endif
+
+#ifdef X86_WIN64
+#define FFI_SIZEOF_ARG 8
+#define USE_BUILTIN_FFS 0 /* not yet implemented in mingw-64 */
+#endif
+
+/* ---- Generic type definitions ----------------------------------------- */
+
+#ifndef LIBFFI_ASM
+#ifdef X86_WIN64
+#ifdef _MSC_VER
+typedef unsigned __int64       ffi_arg;
+typedef __int64                ffi_sarg;
+#else
+typedef unsigned long long     ffi_arg;
+typedef long long              ffi_sarg;
+#endif
+#else
+typedef unsigned long          ffi_arg;
+typedef signed long            ffi_sarg;
+#endif
+
+typedef enum ffi_abi {
+  FFI_FIRST_ABI = 0,
+
+  /* ---- Intel x86 Win32 ---------- */
+#ifdef X86_WIN32
+  FFI_SYSV,
+  FFI_STDCALL,
+  FFI_LAST_ABI,
+  /* TODO: Add fastcall support for the sake of completeness */
+  FFI_DEFAULT_ABI = FFI_SYSV
+
+#elif defined(X86_WIN64)
+  FFI_WIN64,
+  FFI_LAST_ABI,
+  FFI_DEFAULT_ABI = FFI_WIN64
+
+#else
+  /* ---- Intel x86 and AMD x86-64 - */
+  FFI_SYSV,
+  FFI_UNIX64,   /* Unix variants all use the same ABI for x86-64  */
+  FFI_LAST_ABI,
+#if defined(__i386__) || defined(__i386)
+  FFI_DEFAULT_ABI = FFI_SYSV
+#else
+  FFI_DEFAULT_ABI = FFI_UNIX64
+#endif
+#endif
+} ffi_abi;
+#endif
+
+/* ---- Definitions for closures ----------------------------------------- */
+
+#define FFI_CLOSURES 1
+#define FFI_TYPE_SMALL_STRUCT_1B (FFI_TYPE_LAST + 1)
+#define FFI_TYPE_SMALL_STRUCT_2B (FFI_TYPE_LAST + 2)
+#define FFI_TYPE_SMALL_STRUCT_4B (FFI_TYPE_LAST + 3)
+
+#if defined (X86_64) || (defined (__x86_64__) && defined (X86_DARWIN))
+#define FFI_TRAMPOLINE_SIZE 24
+#define FFI_NATIVE_RAW_API 0
+#else
+#ifdef X86_WIN32
+#define FFI_TRAMPOLINE_SIZE 13
+#else
+#ifdef X86_WIN64
+#define FFI_TRAMPOLINE_SIZE 29
+#define FFI_NATIVE_RAW_API 0
+#define FFI_NO_RAW_API 1
+#else
+#define FFI_TRAMPOLINE_SIZE 10
+#endif
+#endif
+#ifndef X86_WIN64
+#define FFI_NATIVE_RAW_API 1	/* x86 has native raw api support */
+#endif
+#endif
+
+#endif
+
+/* ============================== eof ffitarget.h ======================== */
+
+#ifndef LIBFFI_ASM
+
+#ifdef _MSC_VER
+#define __attribute__(X)
+#endif
+
+#include <stddef.h>
+#include <limits.h>
+
+/* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
+   But we can find it either under the correct ANSI name, or under GNU
+   C's internal name.  */
+
+#define FFI_64_BIT_MAX 9223372036854775807
+
+#ifdef LONG_LONG_MAX
+# define FFI_LONG_LONG_MAX LONG_LONG_MAX
+#else
+# ifdef LLONG_MAX
+#  define FFI_LONG_LONG_MAX LLONG_MAX
+#  ifdef _AIX52 /* or newer has C99 LLONG_MAX */
+#   undef FFI_64_BIT_MAX
+#   define FFI_64_BIT_MAX 9223372036854775807LL
+#  endif /* _AIX52 or newer */
+# else
+#  ifdef __GNUC__
+#   define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
+#  endif
+#  ifdef _AIX /* AIX 5.1 and earlier have LONGLONG_MAX */
+#   ifndef __PPC64__
+#    if defined (__IBMC__) || defined (__IBMCPP__)
+#     define FFI_LONG_LONG_MAX LONGLONG_MAX
+#    endif
+#   endif /* __PPC64__ */
+#   undef  FFI_64_BIT_MAX
+#   define FFI_64_BIT_MAX 9223372036854775807LL
+#  endif
+# endif
+#endif
+
+/* The closure code assumes that this works on pointers, i.e. a size_t	*/
+/* can hold a pointer.							*/
+
+typedef struct _ffi_type
+{
+  size_t size;
+  unsigned short alignment;
+  unsigned short type;
+  struct _ffi_type **elements;
+} ffi_type;
+
+#ifndef LIBFFI_HIDE_BASIC_TYPES
+#if SCHAR_MAX == 127
+# define ffi_type_uchar                ffi_type_uint8
+# define ffi_type_schar                ffi_type_sint8
+#else
+ #error "char size not supported"
+#endif
+
+#if SHRT_MAX == 32767
+# define ffi_type_ushort       ffi_type_uint16
+# define ffi_type_sshort       ffi_type_sint16
+#elif SHRT_MAX == 2147483647
+# define ffi_type_ushort       ffi_type_uint32
+# define ffi_type_sshort       ffi_type_sint32
+#else
+ #error "short size not supported"
+#endif
+
+#if INT_MAX == 32767
+# define ffi_type_uint         ffi_type_uint16
+# define ffi_type_sint         ffi_type_sint16
+#elif INT_MAX == 2147483647
+# define ffi_type_uint         ffi_type_uint32
+# define ffi_type_sint         ffi_type_sint32
+#elif INT_MAX == 9223372036854775807
+# define ffi_type_uint         ffi_type_uint64
+# define ffi_type_sint         ffi_type_sint64
+#else
+ #error "int size not supported"
+#endif
+
+#if LONG_MAX == 2147483647
+# if FFI_LONG_LONG_MAX != FFI_64_BIT_MAX
+ #error "no 64-bit data type supported"
+# endif
+#elif LONG_MAX != FFI_64_BIT_MAX
+ #error "long size not supported"
+#endif
+
+#if LONG_MAX == 2147483647
+# define ffi_type_ulong        ffi_type_uint32
+# define ffi_type_slong        ffi_type_sint32
+#elif LONG_MAX == FFI_64_BIT_MAX
+# define ffi_type_ulong        ffi_type_uint64
+# define ffi_type_slong        ffi_type_sint64
+#else
+ #error "long size not supported"
+#endif
+
+/* These are defined in types.c */
+extern ffi_type ffi_type_void;
+extern ffi_type ffi_type_uint8;
+extern ffi_type ffi_type_sint8;
+extern ffi_type ffi_type_uint16;
+extern ffi_type ffi_type_sint16;
+extern ffi_type ffi_type_uint32;
+extern ffi_type ffi_type_sint32;
+extern ffi_type ffi_type_uint64;
+extern ffi_type ffi_type_sint64;
+extern ffi_type ffi_type_float;
+extern ffi_type ffi_type_double;
+extern ffi_type ffi_type_pointer;
+
+#if 1
+extern ffi_type ffi_type_longdouble;
+#else
+#define ffi_type_longdouble ffi_type_double
+#endif
+#endif /* LIBFFI_HIDE_BASIC_TYPES */
+
+typedef enum {
+  FFI_OK = 0,
+  FFI_BAD_TYPEDEF,
+  FFI_BAD_ABI
+} ffi_status;
+
+typedef unsigned FFI_TYPE;
+
+typedef struct {
+  ffi_abi abi;
+  unsigned nargs;
+  ffi_type **arg_types;
+  ffi_type *rtype;
+  unsigned bytes;
+  unsigned flags;
+#ifdef FFI_EXTRA_CIF_FIELDS
+  FFI_EXTRA_CIF_FIELDS;
+#endif
+} ffi_cif;
+
+/* ---- Definitions for the raw API -------------------------------------- */
+
+#ifndef FFI_SIZEOF_ARG
+# if LONG_MAX == 2147483647
+#  define FFI_SIZEOF_ARG        4
+# elif LONG_MAX == FFI_64_BIT_MAX
+#  define FFI_SIZEOF_ARG        8
+# endif
+#endif
+
+#ifndef FFI_SIZEOF_JAVA_RAW
+#  define FFI_SIZEOF_JAVA_RAW FFI_SIZEOF_ARG
+#endif
+
+typedef union {
+  ffi_sarg  sint;
+  ffi_arg   uint;
+  float	    flt;
+  char      data[FFI_SIZEOF_ARG];
+  void*     ptr;
+} ffi_raw;
+
+#if FFI_SIZEOF_JAVA_RAW == 4 && FFI_SIZEOF_ARG == 8
+/* This is a special case for mips64/n32 ABI (and perhaps others) where
+   sizeof(void *) is 4 and FFI_SIZEOF_ARG is 8.  */
+typedef union {
+  signed int	sint;
+  unsigned int	uint;
+  float		flt;
+  char		data[FFI_SIZEOF_JAVA_RAW];
+  void*		ptr;
+} ffi_java_raw;
+#else
+typedef ffi_raw ffi_java_raw;
+#endif
+
+
+void ffi_raw_call (ffi_cif *cif,
+		   void (*fn)(void),
+		   void *rvalue,
+		   ffi_raw *avalue);
+
+void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
+void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
+size_t ffi_raw_size (ffi_cif *cif);
+
+/* This is analogous to the raw API, except it uses Java parameter	*/
+/* packing, even on 64-bit machines.  I.e. on 64-bit machines		*/
+/* longs and doubles are followed by an empty 64-bit word.		*/
+
+void ffi_java_raw_call (ffi_cif *cif,
+			void (*fn)(void),
+			void *rvalue,
+			ffi_java_raw *avalue);
+
+void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_java_raw *raw);
+void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_java_raw *raw, void **args);
+size_t ffi_java_raw_size (ffi_cif *cif);
+
+/* ---- Definitions for closures ----------------------------------------- */
+
+#if FFI_CLOSURES
+
+#ifdef _MSC_VER
+__declspec(align(8))
+#endif
+typedef struct {
+  char tramp[FFI_TRAMPOLINE_SIZE];
+  ffi_cif   *cif;
+  void     (*fun)(ffi_cif*,void*,void**,void*);
+  void      *user_data;
+#ifdef __GNUC__
+} ffi_closure __attribute__((aligned (8)));
+#else
+} ffi_closure;
+# ifdef __sgi
+#  pragma pack 0
+# endif
+#endif
+
+void *ffi_closure_alloc (size_t size, void **code);
+void ffi_closure_free (void *);
+
+ffi_status
+ffi_prep_closure (ffi_closure*,
+		  ffi_cif *,
+		  void (*fun)(ffi_cif*,void*,void**,void*),
+		  void *user_data);
+
+ffi_status
+ffi_prep_closure_loc (ffi_closure*,
+		      ffi_cif *,
+		      void (*fun)(ffi_cif*,void*,void**,void*),
+		      void *user_data,
+		      void*codeloc);
+
+#ifdef __sgi
+# pragma pack 8
+#endif
+typedef struct {
+  char tramp[FFI_TRAMPOLINE_SIZE];
+
+  ffi_cif   *cif;
+
+#if !FFI_NATIVE_RAW_API
+
+  /* if this is enabled, then a raw closure has the same layout 
+     as a regular closure.  We use this to install an intermediate 
+     handler to do the transaltion, void** -> ffi_raw*. */
+
+  void     (*translate_args)(ffi_cif*,void*,void**,void*);
+  void      *this_closure;
+
+#endif
+
+  void     (*fun)(ffi_cif*,void*,ffi_raw*,void*);
+  void      *user_data;
+
+} ffi_raw_closure;
+
+typedef struct {
+  char tramp[FFI_TRAMPOLINE_SIZE];
+
+  ffi_cif   *cif;
+
+#if !FFI_NATIVE_RAW_API
+
+  /* if this is enabled, then a raw closure has the same layout 
+     as a regular closure.  We use this to install an intermediate 
+     handler to do the transaltion, void** -> ffi_raw*. */
+
+  void     (*translate_args)(ffi_cif*,void*,void**,void*);
+  void      *this_closure;
+
+#endif
+
+  void     (*fun)(ffi_cif*,void*,ffi_java_raw*,void*);
+  void      *user_data;
+
+} ffi_java_raw_closure;
+
+ffi_status
+ffi_prep_raw_closure (ffi_raw_closure*,
+		      ffi_cif *cif,
+		      void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
+		      void *user_data);
+
+ffi_status
+ffi_prep_raw_closure_loc (ffi_raw_closure*,
+			  ffi_cif *cif,
+			  void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
+			  void *user_data,
+			  void *codeloc);
+
+ffi_status
+ffi_prep_java_raw_closure (ffi_java_raw_closure*,
+		           ffi_cif *cif,
+		           void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
+		           void *user_data);
+
+ffi_status
+ffi_prep_java_raw_closure_loc (ffi_java_raw_closure*,
+			       ffi_cif *cif,
+			       void (*fun)(ffi_cif*,void*,ffi_java_raw*,void*),
+			       void *user_data,
+			       void *codeloc);
+
+#endif /* FFI_CLOSURES */
+
+/* ---- Public interface definition -------------------------------------- */
+
+ffi_status ffi_prep_cif(ffi_cif *cif,
+			ffi_abi abi,
+			unsigned int nargs,
+			ffi_type *rtype,
+			ffi_type **atypes);
+
+void ffi_call(ffi_cif *cif,
+	      void (*fn)(void),
+	      void *rvalue,
+	      void **avalue);
+
+/* Useful for eliminating compiler warnings */
+#define FFI_FN(f) ((void (*)(void))f)
+
+/* ---- Definitions shared with assembly code ---------------------------- */
+
+#endif
+
+/* If these change, update src/mips/ffitarget.h. */
+#define FFI_TYPE_VOID       0    
+#define FFI_TYPE_INT        1
+#define FFI_TYPE_FLOAT      2    
+#define FFI_TYPE_DOUBLE     3
+#if 1
+#define FFI_TYPE_LONGDOUBLE 4
+#else
+#define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
+#endif
+#define FFI_TYPE_UINT8      5   
+#define FFI_TYPE_SINT8      6
+#define FFI_TYPE_UINT16     7 
+#define FFI_TYPE_SINT16     8
+#define FFI_TYPE_UINT32     9
+#define FFI_TYPE_SINT32     10
+#define FFI_TYPE_UINT64     11
+#define FFI_TYPE_SINT64     12
+#define FFI_TYPE_STRUCT     13
+#define FFI_TYPE_POINTER    14
+
+/* This should always refer to the last type code (for sanity checks) */
+#define FFI_TYPE_LAST       FFI_TYPE_POINTER
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/win-path.c b/win-path.c
new file mode 100644
index 0000000..25eb69d
--- /dev/null
+++ b/win-path.c
@@ -0,0 +1,385 @@
+/*  win-path.c 
+
+    directory and file functions working on UTF-16 file and path names
+
+    Copyright (C) 2007,2008,2010 Michael Sabin
+
+    This software is provided 'as-is', without any express or implied
+    warranty.  In no event will the authors be held liable for any damages
+    arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it
+    freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+       claim that you wrote the original software. If you use this software
+       in a product, an acknowledgment in the product documentation would be
+       appreciated but is not required.
+    2. Altered source versions must be plainly marked as such, and must not be
+       misrepresented as being the original software.
+    3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include <wchar.h>
+#include <windows.h>
+#include "newlisp.h"
+#include "protos.h"
+
+/*
+utf8_to_utf16
+Uses the Windows API to convert a UTF-8 string to a UTF-16 string.
+Returns a pointer to a WCHAR string, or NULL if there was an error
+(like if an invalid utf8 string was provided).
+Note that the returned string must be free()ed.
+*/
+WCHAR * utf8_to_utf16(const char *utf8str)
+{
+    int size = -1;
+    WCHAR *utf16str = NULL;
+
+    size = MultiByteToWideChar(
+        CP_UTF8,
+        0,          /* no flags=ignore errors if possible */
+        utf8str,
+        -1,         /* read until NULL character */
+        NULL,       
+        0           /* just calculate size */
+    );
+    
+    if (size == 0) return (NULL);
+    
+    utf16str = (WCHAR*)callocMemory((size+1) * sizeof(WCHAR));
+    
+    size = MultiByteToWideChar(
+        CP_UTF8,
+        0,
+        utf8str,
+        -1,
+        utf16str,
+        size
+    );  
+    
+    if (size == 0) 
+    {
+        free(utf16str);
+        return(NULL);
+    }
+    else
+        return(utf16str);
+}
+
+
+/*
+utf16_to_utf8ptr
+Used in win_realpath,
+but otherwise wrapped by utf16_to_utf8.
+*/
+int utf16_to_utf8ptr(const WCHAR *utf16str, char * utf8str, int size)
+{
+    
+    if (size < 1) return(-1);
+    
+    size = WideCharToMultiByte(
+        CP_UTF8,
+        0,
+        utf16str,
+        -1,
+        utf8str,
+        size,
+        NULL,
+        NULL
+    );
+    
+    if (size == 0) 
+        return(-1);
+    else
+        return(0);
+}
+
+/*
+utf16_to_utf8
+Uses the Windows API to convert a UTF-16 string to a UTF-8 string.
+Returns a pointer to a char string, or NULL if there was an error
+(like if an invalid utf16 string was provided).
+Note that the returned string must be free()ed.
+*/
+char * utf16_to_utf8(const WCHAR *utf16str)
+{
+    int size = -1;
+    char *utf8str = NULL;
+    
+    size = WideCharToMultiByte(
+        CP_UTF8,
+        0,
+        utf16str,
+        -1,
+        0,
+        0,
+        NULL,
+        NULL
+    );
+    
+    if (size == 0) return (NULL);   
+    
+    utf8str = (char*)callocMemory((size+1) * sizeof(char));
+    
+    if (utf16_to_utf8ptr(utf16str, utf8str, size) == -1)
+    {
+        free(utf8str);
+        return(NULL);
+    }
+    else
+        return(utf8str);
+}
+
+/* wrapper to return a cell */
+
+#if SUPPORT_UTF8
+CELL * utf8_from_mbcs(void * str)
+{
+WCHAR * utf16str;
+char * utf8str;
+
+utf16str = ansi_mbcs_to_utf16(str); 
+utf8str = utf16_to_utf8(utf16str);
+free(utf16str); 
+
+if(utf8str != NULL)
+	return(makeStringCell(utf8str, strlen(utf8str)));
+else
+	return(nilCell);
+}
+#endif
+
+/*
+mbcs_to_utf16
+Uses the Windows API to convert a FileSystem/CommandArgs OEM CodePage string to a UTF-16 string.
+Returns a pointer to a WCHAR string, or NULL if there was an error
+*/
+WCHAR * ansi_mbcs_to_utf16(const char *mbcsStr)
+{
+    int size = -1;
+    WCHAR *utf16str = NULL;
+
+    size = MultiByteToWideChar(
+        CP_OEMCP,
+        0,          /* no flags=ignore errors if possible */
+        mbcsStr,
+        -1,         /* read until NULL character */
+        NULL,       
+        0           /* just calculate size */
+    );
+    
+    if (size == 0) return (NULL);
+    
+    utf16str = (WCHAR*)callocMemory((size+1) * sizeof(WCHAR));
+    
+    size = MultiByteToWideChar(
+        CP_OEMCP,
+        0,
+        mbcsStr,
+        -1,
+        utf16str,
+        size
+    );  
+    
+    if (size == 0) 
+    {
+        free(utf16str);
+        return(NULL);
+    }
+    else
+        return(utf16str);
+}
+
+/*
+win_realpath
+Identical interface as realpath
+for both ANSI and UTF-16 path names on Windows.
+Has the following functional differences
+* If GetFullPathNameW, first converts the UTF-8 file name to UTF-16 (WCHAR)
+* Uses GetFullPathNameA or GetFullPathNameW to receive the char/WCHAR path
+* If GetFullPathNameW, converts the UTF-16 WCHAR path back to UTF-8
+*/
+char *win_realpath(const char *filepath, char *realpath)
+{
+
+#ifdef USE_WIN_UTF16PATH
+    
+    WCHAR * utf16filepath;
+    WCHAR utf16realpath[MAX_PATH + 2];
+    int err;
+    
+    utf16filepath = utf8_to_utf16(filepath);
+    err = GetFullPathNameW(utf16filepath, MAX_PATH, utf16realpath, NULL);
+    free(utf16filepath);
+    
+    if (err == 0)
+        return(NULL);
+    
+    if (utf16_to_utf8ptr(utf16realpath, realpath, MAX_PATH) == -1)
+        return(NULL);
+    
+#else
+
+    if(GetFullPathNameA(filepath, MAX_PATH, realpath, NULL) == 0)
+        return(NULL);
+    
+#endif
+
+return(isFile(realpath, 0) ? 0 : realpath);
+}
+
+/*
+win_getModulePath - added by LM for version 10.4.7
+used in newlisp.c:loadStartup(..) and newlisp.c:linkUnlink(...)
+gets the full path for a loaded module (executable).
+EXEName must be allocated by caller with PATH_MAX typically
+*/
+
+char * win_getExePath(char * EXEName)
+{
+#ifdef SUPPORT_UTF8
+ WCHAR wEXEName[PATH_MAX] ;
+ GetModuleFileNameW(NULL, wEXEName, PATH_MAX);
+ utf16_to_utf8ptr(wEXEName, EXEName, PATH_MAX);
+#else
+ GetModuleFileName(NULL, EXEName, PATH_MAX);
+#endif
+
+return(EXEName);
+}
+
+/* ---------------------------------------------------------------------------- 
+Wrappers for wide-character functions.
+Same interface as the standard functions, but accepts UTF-8 strings.
+Adds the following functionality:
+* first converts the UTF-8 string to UTF-16
+* if there a conversion error, return fail
+* calls the wide-character function
+Note that errno is not set on UTF conversion failures.
+---------------------------------------------------------------------------- */
+
+int rename_utf16(const char* oldname8, const char* newname8)
+{
+    int i = -1;
+    WCHAR * oldname16;
+    WCHAR * newname16;
+    
+    oldname16 = utf8_to_utf16(oldname8);
+    if (oldname16)
+    {
+        newname16 = utf8_to_utf16(newname8);
+        if (newname16)
+        {
+            i = _wrename(oldname16, newname16);
+            free(oldname16);
+        }
+        free(newname16);
+    }
+    return i;
+}
+
+int stat_utf16(const char* filename8, struct stat* buf)
+{
+    int i = -1;
+    struct _stat st;
+    WCHAR * filename16 = utf8_to_utf16(filename8);
+    if (filename16)
+    {
+        i = _wstat(filename16, &st);
+        free(filename16);
+    }
+
+    if (i == 0) {
+    /* FIXME: incompatible type 'struct _stat' and 'struct stat' in MinGW64 ? */
+    buf->st_dev   = st.st_dev;
+    buf->st_ino   = st.st_ino;
+    buf->st_mode  = st.st_mode;
+    buf->st_nlink = st.st_nlink;
+    buf->st_uid   = st.st_uid;
+    buf->st_gid   = st.st_gid;
+    buf->st_rdev  = st.st_rdev;
+    buf->st_size  = st.st_size;
+    buf->st_atime = st.st_atime;
+    buf->st_mtime = st.st_mtime;
+    buf->st_ctime = st.st_ctime;
+    }
+
+    return i;
+}
+
+int chdir_utf16(const char* filename8)
+{
+    int i = -1;
+    WCHAR * filename16 = utf8_to_utf16(filename8);
+    if (filename16)
+    {
+        i = _wchdir(filename16);
+        free(filename16);
+    }
+    return i;
+}
+
+int open_utf16(const char* filename8, int flags, int mode)
+{
+    int i = -1;
+    WCHAR * filename16 = utf8_to_utf16(filename8);
+    if (filename16)
+    {
+        i = _wopen(filename16, flags, mode);
+        free(filename16);
+    }
+    return i;
+}
+
+int mkdir_utf16(const char* filename8)
+{
+    int i = -1;
+    WCHAR * filename16 = utf8_to_utf16(filename8);
+    if (filename16)
+    {
+        i = _wmkdir(filename16);
+        free(filename16);
+    }
+    return i;
+}
+
+int rmdir_utf16(const char* filename8)
+{
+    int i = -1;
+    WCHAR * filename16 = utf8_to_utf16(filename8);
+    if (filename16)
+    {
+        i = _wrmdir(filename16);
+        free(filename16);
+    }
+    return i;
+}
+
+int unlink_utf16(const char* filename8)
+{
+    int i = -1;
+    WCHAR * filename16 = utf8_to_utf16(filename8);
+    if (filename16)
+    {
+        i = _wunlink(filename16);
+        free(filename16);
+    }
+    return i;
+}
+
+_WDIR * opendir_utf16(const char* dirname8)
+{
+    _WDIR * dir = NULL;
+    WCHAR * dirname16 = utf8_to_utf16(dirname8);
+    if (dirname16)
+    {
+        dir = _wopendir(dirname16);
+        free(dirname16);
+    }
+    return dir;
+}
+
+/* eof */
diff --git a/win-util.c b/win-util.c
new file mode 100644
index 0000000..d90c58e
--- /dev/null
+++ b/win-util.c
@@ -0,0 +1,296 @@
+/* 
+   win-util.c, utitity routines for native windows port of newLISP 
+
+    Copyright (C) 2016 Lutz Mueller
+
+    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 3 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, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "newlisp.h"
+#include "protos.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+#define WIN32_LEAN_AND_MEAN     /* exclude rarely-used windows headers */
+#include <windows.h>
+#include <io.h>
+#include <process.h>
+
+
+/* from newlisp.c */
+int init_argv(char * ptr, char *argv[]);
+void * callocMemory(size_t nbytes);
+
+WINBASEAPI DWORD WINAPI GetProcessId(HANDLE);
+
+/*
+typedef struct _PROCESS_INFORMATION {
+    HANDLE hProcess; 
+    HANDLE hThread; 
+    DWORD dwProcessId; 
+    DWORD dwThreadId; 
+} PROCESS_INFORMATION; 
+*/
+
+
+/* kill for MinGW
+   by Shigeru Kobayashi for v10.4.5
+   to be used by p_destroyProcess()
+   see also changes in plainProcess() and winPipedProcess() below
+*/
+
+int kill(pid_t pid, int sig)
+{
+int ret;
+HANDLE h;
+
+h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
+if (h == NULL) return -1;
+
+ret = TerminateProcess(h, 0) ? 0 : -1;
+CloseHandle(h);
+return ret;
+}
+
+/* ---------------------------- pipes -------------------------------------- */
+
+
+UINT plainProcess(char * command, size_t len)
+{
+char * cPtr;
+char * argv[16];
+HANDLE hProc;
+DWORD pid;
+
+cPtr = callocMemory(len + 1);
+memcpy(cPtr, command, len + 1);
+
+init_argv(cPtr, argv);
+
+hProc = (HANDLE)_spawnvp(P_NOWAIT, argv[0], (const char * const *)argv); 
+
+free(cPtr);
+if(hProc == INVALID_HANDLE_VALUE) return(0);
+
+pid = GetProcessId(hProc);
+CloseHandle(hProc);
+
+return(pid);
+}
+
+
+UINT winPipedProcess(char * cmd, int inpipe, int outpipe, int option)
+{
+STARTUPINFO si = { 0 };
+PROCESS_INFORMATION process;
+int result;
+HANDLE fin, fout; 
+UINT pid;
+
+if(inpipe == -1 && outpipe == -1)
+    {
+    memset(&si, 0, sizeof(si));
+    si.cb = sizeof(si);
+    si.wShowWindow = option; 
+    memset(&process, 0, sizeof(process));
+    }
+else
+    {
+    /* GetStartupInfo(&si);  */
+    si.cb = sizeof(si);
+    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+    si.wShowWindow = option; /* SW_SHOW, SW_HIDE  get additional user option in Win32 versions */
+
+    fin  = (HANDLE)_get_osfhandle(inpipe);
+    fout = (HANDLE)_get_osfhandle(outpipe);
+
+    si.hStdInput  = (inpipe)  ? fin  : GetStdHandle(STD_INPUT_HANDLE);
+    si.hStdOutput = (outpipe) ? fout : GetStdHandle(STD_OUTPUT_HANDLE);
+    si.hStdError  = (outpipe) ? fout : GetStdHandle(STD_OUTPUT_HANDLE);
+    }
+
+if((result = CreateProcess(NULL,cmd,NULL,NULL,TRUE,DETACHED_PROCESS,NULL,NULL,&si, &process)) == 0)
+    return(0); 
+
+pid = GetProcessId(process.hProcess);
+CloseHandle(process.hProcess);
+
+return(pid);
+}
+
+
+int winPipe(UINT * inpipe, UINT * outpipe)
+{
+SECURITY_ATTRIBUTES sa = { 0 };
+HANDLE pipe_r, pipe_w;
+
+sa.nLength = sizeof(sa);
+sa.bInheritHandle = TRUE;
+sa.lpSecurityDescriptor = NULL;
+
+if(!CreatePipe(&pipe_r, &pipe_w, &sa, 0))
+    return(0);
+
+*inpipe = _open_osfhandle((intptr_t) pipe_r, 0);
+*outpipe = _open_osfhandle((intptr_t) pipe_w, 0);
+
+
+return(1);
+}
+
+
+/* ---------------------------------- semaphores ---------------------------- */
+
+UINT winCreateSemaphore(void)
+{
+SECURITY_ATTRIBUTES security = { 0 };
+HANDLE hSemaphore;
+
+security.nLength = sizeof(security);
+security.bInheritHandle = TRUE;
+security.lpSecurityDescriptor = NULL; /* default of caller */
+
+hSemaphore = CreateSemaphore(&security, 0, 65536, NULL);
+
+return((UINT)hSemaphore);
+} 
+
+UINT winWaitSemaphore(UINT hSemaphore)
+{
+DWORD dwWaitResult; 
+
+dwWaitResult = WaitForSingleObject((HANDLE)hSemaphore, INFINITE);
+
+if(dwWaitResult == WAIT_FAILED)
+    return(FALSE);
+
+return(TRUE);
+}
+
+UINT winSignalSemaphore(UINT hSemaphore, int count)
+{
+return(ReleaseSemaphore((HANDLE)hSemaphore, count, NULL));
+}
+
+int winDeleteSemaphore(UINT hSemaphore) 
+{
+return (CloseHandle((HANDLE)hSemaphore));
+}
+
+/*
+See: http://www.codeguru.com/Cpp/W-P/win32/article.php/c1423/
+QuerySemaphore() call
+int winGetSemaphoreCount(UINT hSemaphore) {}
+*/
+
+/* ---------------------------- shared memory interface -------------------- */
+
+UINT winSharedMemory(int size)
+{
+SECURITY_ATTRIBUTES sa = { 0 };
+HANDLE hMemory;
+
+sa.nLength = sizeof(sa);
+sa.bInheritHandle = TRUE;
+sa.lpSecurityDescriptor = NULL; /* default of caller */
+
+hMemory = CreateFileMapping(INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE, 0, size, NULL);
+
+return((UINT)hMemory);
+}
+
+UINT * winMapView(UINT hMemory, int size)
+{
+return((UINT *)MapViewOfFile((HANDLE)hMemory, FILE_MAP_WRITE, 0, 0, size));
+}
+
+/* ---------------------------- timer -------------------------------------- */
+
+extern SYMBOL * timerEvent;
+extern int milliSecTime(void);
+extern CELL * getCreateSymbol(CELL * params, SYMBOL * * symbol, char * name);
+
+/* 
+UINT_PTR SetTimer(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc);
+BOOL KillTimer(HWND hWnd, UINT_PTR uIDEvent);
+*/
+
+void timerFunc(void * dummy);
+int timerDuration = 0;
+int rollover = 0;
+int start;
+
+CELL * p_timerEvent(CELL * params)
+{
+CELL * symCell;
+double seconds;
+int now;
+
+if(params != nilCell) 
+  {
+  params = getCreateSymbol(params, &timerEvent, "$timer");
+
+  if(params != nilCell)
+    {
+    getFloat(params, &seconds);
+    timerDuration = 1000 * seconds;
+    if(timerDuration > 0)
+        {
+        start = milliSecTime();
+        _beginthread(timerFunc, 0, 0);
+        seconds = timerDuration/1000.0;
+        }
+    }
+  else
+    {
+    /* return the elapsed time */
+    seconds = ((now = milliSecTime()) < start ? 
+            86400000 - start + now :
+            now - start)/1000.0;  
+    }
+  return(stuffFloat(seconds));    
+  }
+  
+symCell = getCell(CELL_SYMBOL);
+symCell->contents = (UINT)timerEvent;
+return(symCell);
+}
+
+
+void timerFunc(void * dummy)
+{
+if(timerDuration == 0) return;
+
+/* take care of midnight rollover */
+if((rollover = start + timerDuration - 86400000) > 0)
+    {
+    while(milliSecTime() > start) mySleep(10); /* wait for rollover */
+    while(milliSecTime() < rollover) mySleep(10);
+    }
+else
+    while( milliSecTime() < (start + timerDuration) ) mySleep(10);
+
+if(recursionCount)
+  traceFlag |= TRACE_TIMER;
+else /* if idle */
+  executeSymbol(timerEvent, NULL, NULL);
+}
+
+
+extern STREAM errorStream;
+
+
+/* eof */
diff --git a/win64-dll.def b/win64-dll.def
new file mode 100644
index 0000000..d275866
--- /dev/null
+++ b/win64-dll.def
@@ -0,0 +1,8 @@
+EXPORTS
+    WEP @1
+    debugConsole @2
+    dllEvalStr @3
+    dllName @4
+    newlispCallback @5
+    newlispEvalStr @6
+    newlispLibConsole @7