diff --git a/lib/erl/build/beamver b/lib/erl/build/beamver
new file mode 100644
index 0000000..fe448b9
--- /dev/null
+++ b/lib/erl/build/beamver
@@ -0,0 +1,59 @@
+#!/bin/sh
+
+# erlwareSys: otp/build/beamver,v 1.1 2002/02/14 11:45:20 hal Exp $
+
+# usage: beamver <beam_file>
+#
+# if there's a usable -vsn() attribute, print it and exit with status 0
+# otherwise, print nothing and exit with status 1
+
+# From the Erlang shell:
+#
+# 5> code:which(acca_inets).
+# "/home/martin/work/otp/releases/<app>/../../acca/ebin/<app>.beam"
+# 
+# 8> beam_lib:version(code:which(<app>)).
+# {ok,{<app>,['$Id: beamver,v 1.1.1.1 2003/06/13 21:43:21 mlogan Exp $ ']}}
+
+# TMPFILE looks like this:
+#
+# io:format("hello ~p~n",
+#   beam_lib:version("/home/hal/work/otp/acca/ebin/acca_inets.beam")]).
+
+TMPFILE=/tmp/beamver.$$
+
+# exit with failure if we can't read the file
+test -f "$1" || exit 1
+BEAMFILE=\"$1\"
+
+cat > $TMPFILE <<_EOF
+io:format("~p~n",
+  [beam_lib:version($BEAMFILE)]).
+_EOF
+
+# beam_result is {ok,{Module_name, Beam_version} or {error,beam_lib,{Reason}}
+beam_result=`erl -noshell \
+  -s file eval $TMPFILE \
+  -s erlang halt`
+
+rm -f $TMPFILE
+
+# sed regexes:
+#   remove brackets and anything outside them
+#   remove quotes and anything outside them
+#   remove apostrophes and anything outside them
+#   remove leading and trailing spaces
+
+case $beam_result in
+\{ok*)
+  echo $beam_result | sed -e 's/.*\[\(.*\)].*/\1/'  \
+                          -e 's/.*\"\(.*\)\".*/\1/' \
+                          -e "s/.*\'\(.*\)\'.*/\1/" \
+                          -e 's/ *$//' -e 's/^ *//'
+  exit 0
+  ;;
+*)
+  exit 1
+  ;;
+esac
+
diff --git a/lib/erl/build/buildtargets.mk b/lib/erl/build/buildtargets.mk
new file mode 100644
index 0000000..24d0bf8
--- /dev/null
+++ b/lib/erl/build/buildtargets.mk
@@ -0,0 +1,14 @@
+EBIN=../ebin
+EMULATOR=beam
+
+ERLC_WFLAGS = -W
+ERLC = erlc $(ERLC_WFLAGS) $(ERLC_FLAGS)
+ERL = erl -boot start_clean
+ESRC = .
+
+$(EBIN)/%.beam: $(ESRC)/%.erl
+	$(ERLC) $(ERL_FLAGS) $(ERL_COMPILE_FLAGS) -o$(EBIN) $<
+
+.erl.beam:
+	$(ERLC) $(ERL_FLAGS) $(ERL_COMPILE_FLAGS) -o$(dir $@) $<
+
diff --git a/lib/erl/build/colors.mk b/lib/erl/build/colors.mk
new file mode 100644
index 0000000..4d69c41
--- /dev/null
+++ b/lib/erl/build/colors.mk
@@ -0,0 +1,24 @@
+# Colors to assist visual inspection of make output.
+
+# Colors
+LGRAY=$$'\e[0;37m'
+DGRAY=$$'\e[1;30m'
+LGREEN=$$'\e[1;32m'
+LBLUE=$$'\e[1;34m'
+LCYAN=$$'\e[1;36m'
+LPURPLE=$$'\e[1;35m'
+LRED=$$'\e[1;31m'
+NO_COLOR=$$'\e[0m'
+DEFAULT=$$'\e[0m'
+BLACK=$$'\e[0;30m'
+BLUE=$$'\e[0;34m'
+GREEN=$$'\e[0;32m'
+CYAN=$$'\e[0;36m'
+RED=$$'\e[0;31m'
+PURPLE=$$'\e[0;35m'
+BROWN=$$'\e[0;33m'
+YELLOW=$$'\e[1;33m'
+WHITE=$$'\e[1;37m'
+
+BOLD=$$'\e[1;37m'
+OFF=$$'\e[0m'
diff --git a/lib/erl/build/docs.mk b/lib/erl/build/docs.mk
new file mode 100644
index 0000000..b0b7377
--- /dev/null
+++ b/lib/erl/build/docs.mk
@@ -0,0 +1,12 @@
+EDOC_PATH=../../../tools/utilities
+
+#single place to include docs from.
+docs:
+	@mkdir -p ../doc
+	@echo -n $${MY_BLUE:-$(BLUE)}; \
+	$(EDOC_PATH)/edoc $(APP_NAME); \
+	if [ $$? -eq 0 ]; then \
+		echo $${MY_LRED:-$(LRED)}"$$d Doc Failed"; \
+	fi; \
+	echo -n $(OFF)$(NO_COLOR)	
+
diff --git a/lib/erl/build/mime.types b/lib/erl/build/mime.types
new file mode 100644
index 0000000..d6e3c0d
--- /dev/null
+++ b/lib/erl/build/mime.types
@@ -0,0 +1,98 @@
+
+application/activemessage
+application/andrew-inset
+application/applefile
+application/atomicmail
+application/dca-rft
+application/dec-dx
+application/mac-binhex40	hqx
+application/mac-compactpro	cpt
+application/macwriteii
+application/msword		doc
+application/news-message-id
+application/news-transmission
+application/octet-stream	bin dms lha lzh exe class
+application/oda			oda
+application/pdf			pdf
+application/postscript		ai eps ps
+application/powerpoint		ppt
+application/remote-printing
+application/rtf			rtf
+application/slate
+application/wita
+application/wordperfect5.1
+application/x-bcpio		bcpio
+application/x-cdlink		vcd
+application/x-compress		Z
+application/x-cpio		cpio
+application/x-csh		csh
+application/x-director		dcr dir dxr
+application/x-dvi		dvi
+application/x-gtar		gtar
+application/x-gzip		gz
+application/x-hdf		hdf
+application/x-httpd-cgi		cgi
+application/x-koan		skp skd skt skm
+application/x-latex		latex
+application/x-mif		mif
+application/x-netcdf		nc cdf
+application/x-sh		sh
+application/x-shar		shar
+application/x-stuffit		sit
+application/x-sv4cpio		sv4cpio
+application/x-sv4crc		sv4crc
+application/x-tar		tar
+application/x-tcl		tcl
+application/x-tex		tex
+application/x-texinfo		texinfo texi
+application/x-troff		t tr roff
+application/x-troff-man		man
+application/x-troff-me		me
+application/x-troff-ms		ms
+application/x-ustar		ustar
+application/x-wais-source	src
+application/zip			zip
+audio/basic			au snd
+audio/mpeg			mpga mp2
+audio/x-aiff			aif aiff aifc
+audio/x-pn-realaudio		ram
+audio/x-pn-realaudio-plugin	rpm
+audio/x-realaudio		ra
+audio/x-wav			wav
+chemical/x-pdb			pdb xyz
+image/gif			gif
+image/ief			ief
+image/jpeg			jpeg jpg jpe
+image/png			png
+image/tiff			tiff tif
+image/x-cmu-raster		ras
+image/x-portable-anymap		pnm
+image/x-portable-bitmap		pbm
+image/x-portable-graymap	pgm
+image/x-portable-pixmap		ppm
+image/x-rgb			rgb
+image/x-xbitmap			xbm
+image/x-xpixmap			xpm
+image/x-xwindowdump		xwd
+message/external-body
+message/news
+message/partial
+message/rfc822
+multipart/alternative
+multipart/appledouble
+multipart/digest
+multipart/mixed
+multipart/parallel
+text/html			html htm
+text/x-server-parsed-html	shtml
+text/plain			txt
+text/richtext			rtx
+text/tab-separated-values	tsv
+text/x-setext			etx
+text/x-sgml			sgml sgm
+video/mpeg			mpeg mpg mpe
+video/quicktime			qt mov
+video/x-msvideo			avi
+video/x-sgi-movie		movie
+x-conference/x-cooltalk		ice
+x-world/x-vrml			wrl vrml
diff --git a/lib/erl/build/otp.mk b/lib/erl/build/otp.mk
new file mode 100644
index 0000000..4e93ea8
--- /dev/null
+++ b/lib/erl/build/otp.mk
@@ -0,0 +1,146 @@
+# +----------------------------------------------------------------------+
+# $Id: otp.mk,v 1.4 2004/07/01 14:57:10 tfee Exp $
+# +----------------------------------------------------------------------+
+
+# otp.mk
+# - to be included in all OTP Makefiles
+# installed to /usr/local/include/erlang/otp.mk
+
+# gmake looks in /usr/local/include - that's hard-coded
+# users of this file will use
+# include erlang/top.mk
+
+# most interface files will be installed to $ERL_RUN_TOP/app-vsn/include/*.hrl
+
+# group owner for library/include directories
+ERLANGDEV_GROUP=erlangdev
+
+# ERL_TOP is root of Erlang source tree
+# ERL_RUN_TOP is root of Erlang target tree (some Ericsson Makefiles use $ROOT)
+# ERLANG_OTP is target root for Erlang code 
+# - see sasl/systools reference manual page; grep "TEST"
+
+# OS_TYPE is FreeBSD, NetBSD, OpenBSD, Linux, SCO_SV, SunOS. 
+OS_TYPE=${shell uname}
+
+# MHOST is the host where this Makefile runs.
+MHOST=${shell hostname -s}
+ERL_COMPILE_FLAGS+=-W0
+
+# The location of the erlang runtime system.
+ifndef ERL_RUN_TOP
+ERL_RUN_TOP=/usr/local/lib/erlang
+endif
+
+
+# Edit to reflect local environment.
+# ifeq (${OS_TYPE},Linux)
+# ERL_RUN_TOP=/usr/local/lib/erlang
+#  Note* ERL_RUN_TOP can be determined by starting an 
+#        erlang shell and typing code:root_dir().
+# ERL_TOP=a symbolic link to the actual source top, which changes from version to version
+#  Note* ERL_TOP is the directory where the erlang 
+#        source files reside. Make sure to run ./configure there. 
+# TARGET=i686-pc-linux-gnu
+#  Note* Target can be found in $ERL_TOP/erts
+# endif
+
+# See above for directions.
+ifeq (${OS_TYPE},Linux)
+ERL_TOP=/opt/OTP_SRC
+TARGET=i686-pc-linux-gnu
+endif
+
+ERLANG_OTP=/usr/local/erlang/otp
+VAR_OTP=/var/otp
+
+
+# Aliases for common binaries
+# Note - CFLAGS is modified in erlang.conf
+
+
+################################
+# SunOS
+################################
+ifeq (${OS_TYPE},SunOS)
+
+    CC=gcc
+    CXX=g++
+    AR=/usr/ccs/bin/ar
+    ARFLAGS=-rv
+    CXXFLAGS+=${CFLAGS} -I/usr/include/g++
+    LD=/usr/ccs/bin/ld
+    RANLIB=/usr/ccs/bin/ranlib
+
+CFLAGS+=-Wall -pedantic -ansi -O 
+CORE=*.core
+endif
+
+
+################################
+# FreeBSD
+################################
+ifeq (${OS_TYPE},FreeBSD)
+
+  ifdef LINUXBIN
+    COMPAT_LINUX=/compat/linux
+    CC=${COMPAT_LINUX}/usr/bin/gcc
+    CXX=${COMPAT_LINUX}/usr/bin/g++
+    AR=${COMPAT_LINUX}/usr/bin/ar
+    ARFLAGS=-rv
+    CXXFLAGS+=-fhandle-exceptions ${CFLAGS} -I${COMPAT_LINUX}/usr/include/g++
+    LD=${COMPAT_LINUX}/usr/bin/ld
+    RANLIB=${COMPAT_LINUX}/usr/bin/ranlib
+	BRANDELF=brandelf -t Linux
+  else
+    CC=gcc
+    CXX=g++
+    AR=/usr/bin/ar
+    ARFLAGS=-rv
+    CXXFLAGS+=-fhandle-exceptions ${CFLAGS} -I/usr/include/g++
+    LD=/usr/bin/ld
+    RANLIB=/usr/bin/ranlib
+	BRANDELF=@true
+
+    ifdef USES_PTHREADS
+      CFLAGS+=-D_THREAD_SAFE
+      LDFLAGS+=-lc_r
+
+	  # -pthread flag for 3.0+
+	  ifneq (${shell uname -r | cut -d. -f1},2)
+		CFLAGS+=-pthread
+	  endif
+    endif
+  endif
+
+CFLAGS+=-Wall -pedantic -ansi -O -DFREEBSD
+CORE=*.core
+endif
+
+################################
+# OpenBSD
+################################
+ifeq (${OS_TYPE},OpenBSD)
+
+    CC=gcc
+    CXX=g++
+    AR=/usr/bin/ar
+    ARFLAGS=-rv
+    CXXFLAGS+=${CFLAGS} -I/usr/include/g++
+    LD=/usr/bin/ld
+    RANLIB=/usr/bin/ranlib
+
+    ifdef USES_PTHREADS
+      CFLAGS+=-D_THREAD_SAFE
+      LDFLAGS+=-lc_r
+
+	  # -pthread flag for 3.0+
+	  ifneq (${shell uname -r | cut -d. -f1},2)
+		CFLAGS+=-pthread
+	  endif
+    endif
+
+CFLAGS+=-Wall -pedantic -ansi -O -DOPENBSD
+CORE=*.core
+endif
+
diff --git a/lib/erl/build/otp_subdir.mk b/lib/erl/build/otp_subdir.mk
new file mode 100644
index 0000000..7333969
--- /dev/null
+++ b/lib/erl/build/otp_subdir.mk
@@ -0,0 +1,85 @@
+# Comment by tfee 2004-07-01
+# ==========================
+# This file is a mod of the stock OTP one.
+# The change allows make to stop when a compile error occurs.
+# This file needs to go into two places:
+#     /usr/local/include/erlang
+#     /opt/OTP_SRC/make
+#
+# where OTP_SRC is a symbolic link to a peer directory containing
+# the otp source, e.g. otp_src_R9C-2.
+#
+# After installing OTP, running sudo make install in otp/build
+# will push this file out to the two places listed above.
+#
+# The mod involves setting the shell variable $short_circuit, which we
+# introduce - ie it is not in the stock file. This variable is tested
+# to affect execution flow and is also returned to affect the flow in
+# the calling script (this one). The latter step is necessary because
+# of the recursion involved.
+# =====================================================================
+
+
+# ``The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved via the world wide web at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+# Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+# AB. All Rights Reserved.''
+# 
+#     $Id: otp_subdir.mk,v 1.5 2004/07/12 15:12:23 jeinhorn Exp $
+#
+#
+# Make include file for otp
+
+.PHONY: debug opt release docs release_docs tests release_tests \
+	clean depend
+
+#
+# Targets that don't affect documentation directories
+#
+debug opt release docs release_docs tests release_tests clean depend: prepare
+	@set -e ;							\
+	app_pwd=`pwd` ;							\
+	if test -f vsn.mk; then						\
+	    echo "=== Entering application" `basename $$app_pwd` ;	\
+	fi ;								\
+	case "$(MAKE)" in *clearmake*) tflag="-T";; *) tflag="";; esac;	\
+	short_circuit=0 ;						\
+	for d in $(SUB_DIRECTORIES); do					\
+	    if [[ $$short_circuit = 0 ]]; then				\
+		if test -f $$d/SKIP ; then				\
+		    echo "=== Skipping subdir $$d, reason:" ;		\
+		    cat $$d/SKIP ;					\
+		    echo "===" ;					\
+		else							\
+		    if test ! -d $$d ; then				\
+			echo "=== Skipping subdir $$d, it is missing" ;	\
+		    else						\
+			xflag="" ;					\
+			if test -f $$d/ignore_config_record.inf; then	\
+			    xflag=$$tflag ;				\
+			fi ;						\
+			(cd $$d && $(MAKE) $$xflag $@) ;		\
+			if [[ $$? != 0 ]]; then				\
+			    short_circuit=1 ;				\
+			fi ;						\
+		    fi ;						\
+		fi ;							\
+	    fi ;							\
+	done ;								\
+	if test -f vsn.mk; then						\
+	    echo "=== Leaving application" `basename $$app_pwd` ;	\
+	fi ;								\
+	exit $$short_circuit
+
+prepare:
+	echo
diff --git a/lib/erl/build/raw_test.mk b/lib/erl/build/raw_test.mk
new file mode 100644
index 0000000..dbacf18
--- /dev/null
+++ b/lib/erl/build/raw_test.mk
@@ -0,0 +1,29 @@
+# for testing erlang files directly. The set up for a
+# this type of test would be 
+# files to test reside in lib/<app_name>/src and the test files which are 
+# just plain erlang code reside in lib/<app_name>/test
+#
+# This color codes emitted while the tests run assume that you are using
+# a white-on-black display schema. If not, e.g. if you use a white
+# background, you will not be able to read the "WHITE" text.
+# You can override this by supplying your own "white" color,
+# which may in fact be black! You do this by defining an environment
+# variable named "MY_WHITE" and setting it to $'\e[0;30m' (which is
+# simply bash's way of specifying "Escape [ 0 ; 3 0 m").
+# Similarly, you can set your versions of the standard colors
+# found in colors.mk.
+
+test:
+	@TEST_MODULES=`ls *_test.erl`; \
+	trap "echo $(OFF)$(NO_COLOR); exit 1;" 1 2 3 6; \
+	for d in $$TEST_MODULES; do \
+		echo $${MY_GREEN:-$(GREEN)}"Testing File $$d" $${MY_WHITE:-$(WHITE)}; \
+		echo -n $${MY_BLUE:-$(BLUE)}; \
+		erl -name $(APP_NAME) $(TEST_LIBS) \
+		-s `basename $$d .erl` all -s init stop -noshell; \
+		if [ $$? -ne 0 ]; then \
+			echo $${MY_LRED:-$(LRED)}"$$d Test Failed"; \
+		fi; \
+		echo -n $(OFF)$(NO_COLOR); \
+        done  
+
