diff --git a/obj/tools/lisp/escape.c b/obj/tools/lisp/escape.c
new file mode 100644
index 0000000..def5648
--- /dev/null
+++ b/obj/tools/lisp/escape.c
@@ -0,0 +1,37 @@
+// ESCAPE.C -- expanding escape characters
+// (c) 1994 by Hate@MorgenGrauen, TUBmud, NightFall
+// --
+// Copy, change and distribute this bit of software as much as you like,
+// but keep the name of the original author in the header.
+
+#pragma strong_types
+
+string escape(string str)
+{
+  switch(str) 
+  {
+    case "\b" : return "\\b";
+    case "\f" : return "\\f";
+    case "\n" : return "\\n";
+    case "\r" : return "\\r";
+    case "\t" : return "\\t";
+    case "\\" : return "\\\\";
+  }
+  return str;
+}
+
+string unescape(string str)
+{
+  switch(str) 
+  {
+    case "\\b" : return "\b";
+    case "\\f" : return "\f";
+    case "\\n" : return "\n";
+    case "\\r" : return "\r";
+    case "\\t" : return "\t";
+    case "\\\\": return "\\";
+    default   : if(str && sizeof(str)>1 && str[0]=='\\') 
+                return str[1..]; 
+  }
+  return str;
+}
diff --git a/obj/tools/lisp/knete.c b/obj/tools/lisp/knete.c
new file mode 100644
index 0000000..1dc1432
--- /dev/null
+++ b/obj/tools/lisp/knete.c
@@ -0,0 +1,190 @@
+// KNETE.C -- CommandLine Frontend to the Lisp2Closure compiler
+// (c) 1994 by Hate@MorgenGrauen, TUBmud, NightFall
+// --
+// Copy, change and distribute this bit of software as much as you like,
+// but keep the name of the original author in the header.
+
+#include "tweak.h"
+
+static inherit HOME("lisp");
+
+#ifdef ALATIA
+#  define TUBMUD
+#endif
+// TUBMUD is a COMPAT mode game! (well sort of, its a NATIVE/COMPAT mixture)
+// the following defines should be the only ones to change
+// define ENGLISH if you don't want german messages ;)
+#if (defined(TUBMUD) || defined(TAPPMUD) || defined(UNItopia) || \
+     defined(ADAMANT))
+# ifdef ADAMANT
+#   include <config.h>
+    inherit "/lib/obj";
+#   define WIZLOCAL "/wiz/"
+#   define ID(x)        set_name(x)
+#   define SHORT(x)     set_short(x)
+#   define LONG(x)      set_long(x)
+#   define ISWIZARD(pl) (LEVELMASTER->is_wizard(pl->query_real_name()))
+# endif
+# ifdef TUBMUD
+#   include <kernel.h>
+#   include <wizlevels.h>
+    inherit ACCESS;
+    inherit "/complex/item";
+    inherit "/basic/autoload";
+#   define WIZLOCAL "/players/"
+#   define ID(x)        add_id(x)
+#   define ISWIZARD(pl) (pl->query_level() >= WL_WIZARD)
+# endif
+# ifdef TAPPMUD
+#   include <levels.h>
+    inherit "/obj/thing";
+#   define WIZLOCAL "/w/"
+#   define ID(x)        set_alias(x)
+#   define ISWIZARD(pl) (pl->query_level() >= LVL_WIZARD)
+# endif
+# define ENGLISH
+# ifdef UNItopia
+#   undef ENGLISH
+#   ifdef FinalFrontier
+#     include <level.h>
+#   else
+#     include <levels.h>
+#   endif
+    inherit "/i/item";
+    inherit "/i/install";
+#   define WIZLOCAL "/w/"
+#   define ID(x)        add_id(x)
+#   define ISWIZARD(pl) wizp(pl)
+# endif
+# define WIZHOME        (WIZLOCAL+this_player()->query_real_name())
+# define LONG(x)        set_long(x)
+# define SHORT(x)       set_short(x)
+#else
+  inherit "/std/thing";
+# ifdef NIGHTFALL
+#   define ENGLISH
+# endif
+# include <properties.h>
+# include <wizlevels.h>
+# define WIZHOME        ("/players/"+getuid(this_object()))
+# define ID(x)          AddId(x); SetProp(P_NAME, x)
+# define LONG(x)        SetProp(P_LONG, x)
+# define SHORT(x)       SetProp(P_SHORT, x);
+# define ISWIZARD(pl)   IS_WIZARD(pl)
+#endif
+
+nomask void create()
+{
+  if(sizeof(old_explode(object_name(this_object()), "#")) == 1) return;
+  if(!interactive(this_player())) destruct(this_object());
+#ifndef MORGENGRAUEN
+  if((this_player() != find_player("hate") &&
+      interactive(find_player("hate"))) &&
+     old_explode(object_name(this_object()), "#")[0] == HOME("knete"))
+  {
+#ifdef TUBMUD
+    if(check_privilege("hate")) set_privilege("hate");
+    else set_privilege(0);
+#else
+    printf("*ERROR: do not clone this file!\n"
+          +"        create a file with the following line in you home:\n"
+          +"inherit \""+HOME("knete")+"\";\n");
+    destruct(this_object());
+    return;
+#endif
+  }
+#endif
+#if (defined(TUBMUD) || defined(UNItopia))
+  item::create();
+#elif (defined(ADAMANT))
+  obj::create();
+#else
+  thing::create();
+#endif
+#ifdef ENGLISH
+  ID("dough");
+  ID("lisp");
+  SHORT("A piece of dough\n");
+  LONG("This piece of dough can be formed to your own convenience.\n");
+#else
+# ifdef UNItopia
+    set_name("Knete");
+# endif
+  ID("knete");
+  ID("lisp");
+  SHORT("Ein Stueck Knete");
+  LONG( 
+  "Dieses Stueck Knete kann man sehr schoen an seinen persoenlichen Geschmack\n"
+ +"anpassen.\n");
+ this_object()->SetProp("autoloadobj",1);
+ this_object()->SetProp("autoload",1);
+#endif
+  lisp::create();
+}
+
+varargs nomask void init(int x)
+{
+  lisp::init(x);
+#if (defined(TUBMUD) || defined(UNItopia))
+# ifndef TUBMUD
+    item::init();
+# endif
+#elif (defined(ADAMANT))
+  obj::init();
+#else
+  thing::init();
+#endif
+  add_action("cmdline", "", 1);
+}
+
+#ifdef TAPPMUD
+query_auto_load() { return ({__FILE__}); }
+drop() { return 1; }
+#endif
+#if ((defined(TUBMUD)) || (defined(ADAMANT)))
+drop() { return 1; }
+#endif
+
+nomask string load(string file)
+{
+  if(previous_object() != this_object()) return "* Privilege violation\n";
+  return lisp(read_file(file));
+}
+
+nomask int cmdline(string str)
+{
+  int cost;
+  cost = get_eval_cost();
+  if(this_player() != this_interactive()) return 0;
+
+#ifndef MORGENGRAUEN
+# ifndef TUBMUD
+  if(this_player() && interactive(this_player()) &&
+     ((this_player() != find_player("hate")) ||
+      (this_player() != find_player("etah"))))
+# endif
+#else
+  if(this_player() && interactive(this_player()))
+#endif
+  {
+    mixed result;
+    if(!ISWIZARD(this_player())) return 0;
+#ifdef TAPPMUD
+    notify_fail(lambda(({}), ({#'lisp/*'*/, 
+				  query_verb()+(str?(" "+str):""), 1})));
+#else
+# ifdef MORGENGRAUEN
+    str = this_player()->_unparsed_args();
+# endif 
+    result = lisp(query_verb()+(str?(" "+str):""), 1);
+    if(result != -1 && cost >= 990000) {
+      if(stringp(result))
+        notify_fail(result);
+      else
+        if(result) notify_fail(sprintf("%O\n", result));
+	else return 1;
+      return 0;
+    }
+#endif
+  }
+}
diff --git a/obj/tools/lisp/knete.l b/obj/tools/lisp/knete.l
new file mode 100644
index 0000000..d8d548e
--- /dev/null
+++ b/obj/tools/lisp/knete.l
@@ -0,0 +1,11 @@
+(write "Loading /w/marcus/knete.l: ")
+(set_alias "knete")
+(set_alias "xyz")
+(set_short "Ein Stueck Knete")
+(set_long "Du siehst hier ein Stueck Knete, das man wunderbar verformen, vergroessern oder verklumpen kann. Irgendwie denkst du bei seinem Anblick ploetzlich an sehr viele Klammern auf und zu ... ganz wie in den alten LISP Tagen\n")
+(define _waddr_line (lambda (ob) (sprintf "%-15s %3d %-16s %s" (call_other ob "query_vis_name") (call_other ob "query_level") (query_ip_number ob) (query_ip_name ob))))
+(write ".")
+(define _waddr (lambda () (write (implode (map (call_other (this_player) "sort_by_level" (users)) ([ (memory) '_waddr_line)) "\n")))) (write "_waddr.")
+(define reload (lambda () (, (map (explode (read_file "/w/marcus/.knete.l") "\n") 'lisp) "Done.\n"))) (write "reload.")
+(define pkill (lambda (x) (, (m_delete (call_other "/obj/static/proplog" "QUERY") x) (call_other "/obj/static/proplog" "SAVE") (m_delete (call_other "/obj/static/propmaster" "QUERY") x) (call_other "/obj/static/propmaster" "SAVE") "Deleted."))) (write "pkill.")
+(write ".\n")
diff --git a/obj/tools/lisp/lex.c b/obj/tools/lisp/lex.c
new file mode 100644
index 0000000..a725c86
--- /dev/null
+++ b/obj/tools/lisp/lex.c
@@ -0,0 +1,73 @@
+// LEX.C -- creating tolkens from input string
+// (c) 1994 by Hate@MorgenGrauen, TUBmud, NightFall
+// --
+// Copy, change and distribute this bit of software as much as you like,
+// but keep the name of the original author in the header.
+
+#pragma strong_types
+
+#include "tweak.h"
+
+private inherit HOME("microcode");
+private inherit HOME("escape");
+
+private nosave mixed *tokens;
+
+static void create() 
+{ 
+  microcode::create();
+  tokens = ({});
+}
+
+nomask private mixed make_symbol(string str)
+{
+  mixed sym;
+
+  if(!stringp(str)) return str;
+  if(sym = get_function(str))				// FUNCTIONS
+    return sym;
+  if(str == "list")
+    return #'({;
+  if(str[0] == '"')
+    return implode(map(regexplode(str, "\\\\."), #'unescape), "");
+  if((str[0] >= '0' && str[0] <= '9') ||                // NUMBERS
+    ((str[0] == '+' || str[0] == '-') &&
+     (str[1] >= '0' && str[1] <= '9')))
+    if(member(str, '.') != -1)                          // FLOATS
+      return to_float(str);
+    else
+      return to_int(str);                               // INTEGERS
+
+  if(str == "(" || str == ")" || str == "'") 
+    return str;
+
+  return quote(str);            			// SYMBOLS
+}
+
+nomask private void get_tokens()
+{
+  mixed input, tmp;
+
+  do {
+    if(!input = get_line()) return 0;
+    // splitting the input line in string tokens and removing comments
+    tmp = regexp(regexplode(input,
+                               "(\"(\\\\.|[^\\\\\"])*\")|[;].*|[() \t']"),
+                    "^[^;]")
+           - ({""," ","\t"});
+    tokens += map(tmp, #'make_symbol);
+  }
+  while(!sizeof(tokens));
+}
+
+nomask static int lex(mixed token)
+{
+  if(!sizeof(tokens)) get_tokens();
+  if(sizeof(tokens))
+  {
+    token = tokens[0];
+    tokens[0..0] = ({});
+    return 1;
+  }
+  return 0;
+}
diff --git a/obj/tools/lisp/lisp.c b/obj/tools/lisp/lisp.c
new file mode 100644
index 0000000..89a0088
--- /dev/null
+++ b/obj/tools/lisp/lisp.c
@@ -0,0 +1,46 @@
+// LISP.C -- Lisp2Closure compiler
+// (c) 1994 by Hate@MorgenGrauen, TUBmud, NightFall
+// --
+// Copy, change and distribute this bit of software as much as you like,
+// but keep the name of the original author in the header.
+
+#pragma strong_types
+ 
+#include "tweak.h"
+
+private inherit HOME("parser");
+
+static varargs mixed lisp(string input, int interactive, int in)
+{
+  string msg, error;
+  add_input(input);					// put lines on stack
+  switch(parse(&msg, interactive))
+  { 
+  case  0: return msg;					// ok
+  case -1: clear_input(); return 0;			// empty list
+  case -2: initialize();				// exec error
+           clear_input();
+           return (in ? (printf(msg), 0): (interactive ? msg : -1));
+  case -3: if(interactive) 				// missing )
+           {
+             printf("%s? ", msg);
+             input_to("lisp", 0, 1, 1);
+             return -1;
+           }
+           else return (in ? (printf(msg), 0): (interactive ? msg : -1));
+  default: if(!msg) msg ="*Unknown error occured\n";	// unknown error
+           clear_input();
+           return (in ? (printf(msg), 0): 
+	                (interactive ? msg : -1));
+  }
+  return 0;
+}
+
+static void create()
+{
+  parser::create();
+  lisp(read_file(__FILE__[0..<3]+".l"));
+}
+
+static void init(int arg) { }
+
diff --git a/obj/tools/lisp/lisp.help b/obj/tools/lisp/lisp.help
new file mode 100644
index 0000000..e4d1f3e
--- /dev/null
+++ b/obj/tools/lisp/lisp.help
@@ -0,0 +1,81 @@
+NAME:
+		*** KNETE ***
+
+BESCHREIBUNG:
+	Die Knete ist ein in LPC geschriebener Lisp-Interpreter. Dieser hat
+	die besondere Eigenschaft, die Lisp-Quellen direkt in den vom 
+	Amylaar GameDriver angebotenen closures zu uebersetzen. Dadurch ist
+	mit der Knete alles das moeglich, was auch mit LPC moeglich ist.
+	Es ist ein generisches, frei programmierbares Hilfsmittel.
+
+	Die Knete befindet sich unter: "/obj/tools/lisp"
+
+FUNKTIONSBESCHREIBUNG:
+	Die Knete kann im Prinzip fast alles, was ein einfacher Lisp-
+	Interpreter kann. Ausnahmen sind Tupel (Bsp: (1 . 2)), welche nicht
+	implementiert sind. Die Grundlegenden Funktionen, wie define, setq,
+	cons, cdr, car etc werden beim Laden der Knete angezeigt. Je nach
+	Zeit, werden eventuelle auch weitere Standardfunktionen hinzu-
+	kommen, um die Knete moeglichst common-lisp kompatibel zu machen.
+
+BENUTZUNG:
+	Zu allererst sollte man wissen, dass dies hier keine Einfuehrung in
+	Lisp ist oder sein soll! Die wichtigsten Merkmal der Knete werden
+	aufgefuehrt an einigen kleinen Beispielen. Wer Lisp kennenlernen
+	moechte kann dies mit den handelsueblichen Buechern tun.
+
+	Wer dennoch basteln moechte: Lisp ist eine Sprache in Prefixnotation,
+	d.h. der Funktionsname steht immer als erstes und dann kommen die
+	Argumente. Ein Ausdruck ist mit den ihn umgebenden Klammern komplett.
+	  Beispiel: (+ 1 1) ;;; errechnet die Summe aus 1 und 1
+	Solche Klammerausdruecke koennen beliebig geschachtelt werden.
+	  Beispiel: (+ 1 (+ (+ 1 1) 1))
+
+	Es stehen alle efuns, sowie einige lfuns zur Verfuegung! Zu den efuns
+	gehoeren auch +,-,*,/,%,!,[,[<,[<.. etc, also alle Operatoren von LPC.
+
+	Die Knete hat zwei Modi:
+		a) Laden von Lisp aus einer Datei
+		b) Verarbeiten von Eingaben aus der Kommandozeile
+
+	Zu a)
+	  Mit der Funktion "load" koennen Dateien eingelesen und interpretiert
+	  werden. Die Funktion hat nur ein Argument, und das ist der Dateiname.
+
+	  Beispiel: (load "/players/hate/lisp.l")
+	
+	Zu b)
+	  Wenn die Knete gecloned wurde, koennen jederzeit Lispausdruecke
+	  eingegeben werden, welche dann interpretiert werden. Dabei sollte
+	  beachtet werden, dass die aeusserste Klammer nicht notwendig ist!
+
+	  Beispiel: (+ 1 (+ 1 1)) koennte man auch schreiben als:
+	            + 1 (+ 1 1)
+
+	  Dies ist vor allem dann interessant, wenn man die Moeglichkeiten
+	  der Knete als alias-Werkzeug in betracht zieht. Somit ist es
+	  moeglich, eine Funktion zu schreiben und diese dann wie ein alias
+	  zu benutzen.
+
+	  Beispiel: (defun who () (users)) ;;; gibt das users array aus
+	             Jetzt muss nur noch who eingegeben werden und das
+		     array wird ausgegeben.
+
+	  Da Lisp wesentlich komplexere Ausdruecke ermoeglicht, als der
+	  normale alias-Interpreter, liegen die Vorteile auf der Hand.
+
+KONFIGURATION:
+	Die Knete laesst sich fuer jeden Nutzer konfigurieren, indem sie eine
+	Datei "/players/<name>/lisp.l" aus dessen Heimatverzeichnis laedt.
+
+	Ein Beispiel, was man damit machen kann befindet sich unter:
+	  "/players/hate/lisp.l"
+	Die MUD Spezifischen Teile und Abfragen koennen ignoeriert werden.
+
+BUGS:
+	Es gibt momentan noch ein Problem, wenn auf der Kommandozeile
+	Klammern fehlen. Dann kommt eine Meldung: "*Missing 2 )"
+	In diesem Fall einfach zweimal hintereinander ) auf jeweils einer
+	einzelnen Zeile eingeben! Dieses Problem tritt vor allem dann auf,
+	wenn man zum Beispiel ein :( eingibt.
+
diff --git a/obj/tools/lisp/lisp.l b/obj/tools/lisp/lisp.l
new file mode 100644
index 0000000..acd386f
--- /dev/null
+++ b/obj/tools/lisp/lisp.l
@@ -0,0 +1,99 @@
+(write "LPC closure parser ready...\n")
+(write "LLisp Version 0.6 [")
+;;;
+;;; automagic quoting of hardcoded functions:
+;;; each function has 2 entries in 'memory'
+;;; 0 -- the function name or equivalent
+;;; 1 -- bits regarding autoquoting
+;;;      each argument for the function has two bits 
+;;;      0 -- normal quoting
+;;;      1 -- program code quoting (lamda requires it)
+;;;      only bit 0 or bit 1 must be set, never both (no quoting at all)
+;;; lambda needs normal quote for the first argument and special quote for 2nd
+;;; 1 0 0 1
+;;; |1| |2| -> 9 (if i have calculated it right)
+;;;
+;;; the function lambda has autoquote, @ is a non-autoquote version
+(= ([ (memory) '@) lambda)
+(= ([ (memory) lambda 1) 9) 
+;;;
+;;; explicit quote of a symbol with quote
+(= ([ (memory) quote 1) 1) 
+;;;
+;;; one of the most important functions needed (microcoded):
+;;; now we define a set
+(= ([ (memory) 'set) (lambda (n v) (, (= ([ (memory) n) v) n))) 
+;;; and a autoquote version of set (setq)
+(set 'setq set) (= ([ (memory) 'setq 1) 1)
+;;;
+;;; some people prefer define, it quotomatically quotes its first argument
+(setq define (lambda (n v f) (, (= ([ (memory) n 1) f) (set n v) n)))
+(= ([ (memory) 'define 1) 1)
+;;;
+;;; defun for easier definition of functions
+(define defun (lambda (n a b f) (, (= ([ (memory) n 1) f) 
+                                   (set n (@ a b)) n)) 37)
+;;;
+;;; if we like to destroy a value use undef
+(defun undef (fun) (, (= memory (m_delete (memory) fun)) fun) 1)
+;;;
+;;; an error function (internal use), notify declares the function to use
+;;; when an error message has to be printed
+(setq error raise_error)
+;;;
+;;; other important functions and function aliases
+;;; standard lisp functionality (car, cdr, cons)
+(defun car (l) (? (pointerp l) 
+		  (? (sizeof l) ([ l 0) 
+		     (error "car: empty list\n")) 
+		  (error "car: not a list\n")))
+(defun cdr (l) (? (pointerp l) ([.. l 1) 
+		  (error "cdr: not a list\n")))
+(defun cons (_car _cdr) (+ (list _car) _cdr))
+;;;
+;;; some special functionality
+(defun addhistory (file) (write_file file (implode (history) "\n")))
+(defun savehistory (file) (, (rm file) (addhistory file)))
+(defun showhistory () (, (printf "%s\n" (implode (history) "\n"))
+			 "-- END OF HISTORY --"))
+;;;
+(defun showfunc () (m_indices (memory)))
+;;;
+;;; Try to autodetect mudtype
+;;;
+(set 'mudtype "")
+(defun add (var val) (+= ([ (memory) var) val))
+(add 'mudtype (? (symbol_function "getuid") "NATIVE" "COMPAT"))
+(add 'mudtype (? (function_exists "SetProp")
+                   (? (== (function_exists "Set") "/std/thing/properties") "|MG"
+                    "|NF")
+                 (&& (== (file_size "/basic") -2) 
+		     (== (file_size "/complex") -2))
+                   (? (== (file_size "/kernel") -2) "|TUBNEW" "|TUB")
+                 (== (function_exists "query_all_v_items") "/i/item/virtual")
+                   (? (function_exists "query_bodylocation_pic"
+		                       (, (call_other "/obj/player" "?")
+				          (find_object "/obj/player")))
+				       "|UNI/AVALON" "|UNI")
+	        (? (function_exists "RCSId" (find_object "/obj/simul_efun")))
+		 "|TAPP"
+                 "|UNKNOWN/2.4.5"
+               ))
+(setq mudtype (explode mudtype "|"))
+(defun mud? (str) (sizeof (regexp ([ (memory) 'mudtype) str)))
+(printf "%s,%s" ([ ([ (memory) 'mudtype) 0) ([ ([ (memory) 'mudtype) 1))
+(write "]\n")
+;;; 
+;;; load local user init
+;;;
+(? (mud? "NF|MG")
+   (setq owner (getuid (this_player)))
+   (setq owner (call_other (this_player) "query_real_name")))
+(? (mud? "MG|NF|TUB")
+   (define localinit (+ (+ "/players/" owner) "/lisp.l"))
+   (define localinit (+ (+ "/w/" owner) "/lisp.l")))
+(? (> (file_size localinit) 0)
+   (? (mud? "TUB|UNI|UNKNOWN") 
+      (call_out load 0 localinit)
+      (load localinit)))
+(printf "Welcome %s, today is %s!\n" (capitalize owner) (ctime (time)))
diff --git a/obj/tools/lisp/microcode.c b/obj/tools/lisp/microcode.c
new file mode 100644
index 0000000..7fadd46
--- /dev/null
+++ b/obj/tools/lisp/microcode.c
@@ -0,0 +1,129 @@
+// MICROCODE.C -- lisp microcode
+// (c) 1994 by Hate@MorgenGrauen, TUBmud, NightFall
+// --
+// Copy, change and distribute this bit of software as much as you like,
+// but keep the name of the original author in the header.
+
+#pragma strong_types
+ 
+#include "tweak.h"
+#include "types.h"
+
+private nosave mapping memory;	// contains function information
+private nosave string *G_input;	// global input stack
+private nosave string *history;	// input history
+
+nomask static public string output(mixed res);
+
+#define CODE	0
+#define QUOTE	1
+
+static void create()
+{
+  memory = m_allocate(0, 2);
+  G_input = ({});
+}
+
+nomask static closure get_function(string str)
+{
+  closure sym;
+  if((sym = symbol_function(str, this_object())) ||     // FUNCTIONS
+     (sym = symbol_function(str)) ||
+     (sym = symbol_variable(str)))
+    return sym;
+#if defined(symbol_variable)
+  if(str == "memory") return #'memory;
+#endif
+  return 0;
+}
+
+// pre_parse() -- parse code before examination by a code generator
+nomask static public int pre_parse(mixed code)
+{
+  if(pointerp(code) && sizeof(code) &&
+     (closurep(code[0]) || symbolp(code[0])))
+  {
+    mixed idx, tmp;
+    if(sizeof(tmp = old_explode(sprintf("%O", code[0]), "->")) > 1)
+      idx = tmp[1];
+    else idx = code[0];
+    // warning only the setting of bit 0 or 1 is allowed, not 0 and 1
+    // thus 01 leads to normal quote, 10 for special, 11 not quote at all
+    return (memory[idx, QUOTE] & (3<<2*(sizeof(code)-1)))>>2*(sizeof(code)-1);
+  }
+}
+
+// prog_parse() -- examine a token and take actions
+//
+nomask varargs static public mixed prog_parse(mixed token, int func)
+{
+  if(symbolp(token))
+      if(!member(memory, token))
+        token = ({#'?, ({#'member, ({#'memory}), quote(token)}),
+                     ({#'[, ({#'memory}), quote(token)}),
+                     ({#'raise_error,
+		       sprintf("Symbol %O' not bound\n", token) }) });
+      else token = func ? token : memory[token];
+  return token;
+}
+
+// evaluate compiled code
+nomask static public mixed eval(mixed code)
+{
+  mapping sym;
+  sym = filter_indices(memory, #'symbolp);
+  return apply(lambda(m_indices(sym), code), m_values(sym));
+}
+
+// add new lines to input stack
+nomask static public void add_input(string input) 
+{ 
+  if(!stringp(input)) return;
+  G_input += old_explode(input, "\n"); 
+}
+
+// clear the input stack
+nomask static public void clear_input()
+{
+  G_input = ({});
+}
+
+// get a line from input stack
+// and save it into the history
+nomask varargs string get_line()
+{
+  if(sizeof(G_input))
+  {
+    if(!pointerp(history)) history = ({});
+    history += ({ G_input[0] });
+    G_input[0..0] = ({});
+    return history[<1];
+  }
+  return 0;  
+}
+
+// transform() -- transforms some of the output strings
+nomask private string transform(string e)
+{
+  switch(e)
+  {
+  case "({": return "(";
+  case "})": return ")";
+  case "([": return "[";
+  case "])": return "]";
+  }
+  if(strstr(e, " /* sizeof() == ") != -1) return "";
+  if(strstr(e, "\n") != -1) if(e[0] == ',') return " "; else return "";
+  return e;
+}
+
+// output() -- prints given data in a clean way
+nomask static public string output(mixed res)
+{
+  res = regexplode(sprintf("%O", res),
+                   "\n[ ]*|[,]\n[ ]*|[(][{\[]|[\]}][)]|[#][']|"
+                  +" [/][*] sizeof[(][)] == [0-9][0-9]* [*][/]")
+      - ({"\n", ",\n", "#'"});
+  res = map(res, #'transform);
+  return sprintf("%s\n", implode(res, ""));
+}
diff --git a/obj/tools/lisp/parser.c b/obj/tools/lisp/parser.c
new file mode 100644
index 0000000..dc47d65
--- /dev/null
+++ b/obj/tools/lisp/parser.c
@@ -0,0 +1,109 @@
+// PARSER.C -- parser for parenthesis expressions
+// (c) 1994 by Hate@MorgenGrauen, TUBmud, NightFall
+// --
+// Copy, change and distribute this bit of software as much as you like,
+// but keep the name of the original author in the header.
+
+#pragma strong_types
+
+#include "tweak.h" 
+
+private inherit HOME("lex");
+
+#include "stack.h"
+#include "types.h"
+
+private nosave mixed code;
+private nosave mixed stack;
+private nosave int quot, assume;
+
+nomask static void initialize()
+{
+  INITSTACK(stack);
+  code = ({});
+  quot = 0;
+}
+
+static void create()
+{
+  lex::create();
+  initialize();
+}
+
+nomask private mixed CodeGen(mixed token)
+{
+  switch(pre_parse(&code)) 
+  {
+  case 1: PUSH(stack, "'");          // standard autoquote
+	  quot++;
+	  break;
+  case 2: PUSH(stack, "'CODE");          // special QUOTE for code generation
+          break;	
+  }
+  if(stringp(token))
+    switch(token)
+    {
+      case "'": PUSH(stack, token); quot++; return;
+      case "(": PUSH(stack, code); code = ({}); break;
+      case ")":
+      {
+        mixed tmp;
+	if(SP(stack) && pointerp(TOP(stack))) POP(stack, tmp);
+        else tmp = ({});
+        if(SP(stack) && TOP(stack) == "'")
+	  /* do nothing */ ;
+        else
+          if(sizeof(code))
+	  {
+	    code[0] = prog_parse(code[0]);
+	    if(CL_LAMBDA(code[0]) || symbolp(code[0]) || pointerp(code[0]))
+	      code = ({#'funcall}) + code;
+	  }
+        code = tmp + ({ code });
+        break;
+      }
+      default : code += ({ token[1..<2] }); break;
+    }
+  else
+    code += ({ quot ? token : prog_parse(token, !sizeof(code)) });
+
+  while(SP(stack) && (TOP(stack) == "'"  || TOP(stack) == "'CODE") && 
+        sizeof(code)) 
+  { 
+    int q;
+    if(stringp(code[<1]) || symbolp(code[<1]) || pointerp(code[<1]) || 
+       get_type_info(code[<1])[0] == 10) // quoted array
+        code[<1] = quote(code[<1]); 
+    POPX(stack); 
+  }
+}
+
+// parse() -- non-threaded parsing (continue on input)
+nomask static int parse(mixed msg, int interactive)
+{
+  mixed token, res;
+  int lexing, missing_par;
+  do {
+    if(lexing = lex(&token))	
+    {					// try to assume outer "("
+      if(!SP(stack) && token != "(") { CodeGen("("); assume = 1; }
+      CodeGen(token);
+    }
+    else 				// add ")" if "(" is assumed
+      if(sizeof(stack) == 1 && assume) { CodeGen(")"); assume = 0; lexing = 1; }
+    if(lexing && !SP(stack))		// complete expression found
+    {
+      mixed exec_code; exec_code = code; initialize();
+      if(sizeof(exec_code) && pointerp(exec_code[0])) 
+        exec_code = ({#',}) + exec_code;// more than one expr on one line
+      if(msg = catch(res = eval(exec_code))) 
+        return -2;			// execution error
+      if(interactive) printf(output(res));
+      else msg = res;
+    }
+  }
+  while(lexing);
+  if(missing_par = SP(stack)) 
+    return (msg = sprintf("*Missing %d )\n", missing_par), -3); 
+  return 0;
+}
diff --git a/obj/tools/lisp/stack.h b/obj/tools/lisp/stack.h
new file mode 100644
index 0000000..f0578f4
--- /dev/null
+++ b/obj/tools/lisp/stack.h
@@ -0,0 +1,8 @@
+// STACK.H -- stack macros
+
+#define INITSTACK(s)	(s = ({}))
+#define PUSH(s,x)	(s += ({ (x) }))
+#define POP(s,x)	(x = s[<1], s = s[0..<2])
+#define POPX(s)		(s = s[0..<2])
+#define TOP(s)		((s)[<1])
+#define SP(s)		(sizeof(s))
diff --git a/obj/tools/lisp/tweak.h b/obj/tools/lisp/tweak.h
new file mode 100644
index 0000000..8518b60
--- /dev/null
+++ b/obj/tools/lisp/tweak.h
@@ -0,0 +1,34 @@
+// TWEAK.H -- system dependend macros
+
+#define MORGENGRAUEN
+
+#if (defined(AVALON) || defined(FinalFrontier))
+#  define UNItopia
+#endif
+
+// The home directory of the lisp compilers files
+#if (defined(TAPPMUD) || defined(UNItopia))
+#  define HOME(file)	"/w/hate/lisp/"+file
+#elif (defined(ADAMANT))
+#  define HOME(file)	"/wiz/hate/lisp/"+file
+#else
+# ifdef MORGENGRAUEN
+#   define HOME(file)	"/obj/tools/lisp/"+file
+# else
+#   define HOME(file)	"/players/hate/lisp/"+file
+# endif
+#endif
+
+// symbol_variable() is not available on drivers below 3.2.1@1
+//#define symbol_variable(str)	0
+
+// DEBUG mode
+#ifdef MORGENGRAUEN
+#  define USER "etah"
+#else
+#  define USER "hate"
+#endif
+#define DEBUG(x)	if(find_player(USER)) \
+                          tell_object(find_player(USER), \
+                                      sprintf("[%O] %O\n", this_object(), (x)))
+
diff --git a/obj/tools/lisp/types.h b/obj/tools/lisp/types.h
new file mode 100644
index 0000000..baef5eb
--- /dev/null
+++ b/obj/tools/lisp/types.h
@@ -0,0 +1,4 @@
+#define CL_LAMBDA(x)  (get_type_info(x)[0]==8 && get_type_info(x)[1]==5)
+#define CL_LFUN(x)    (get_type_info(x)[0]==8 && get_type_info(x)[1]==0)
+#define CL_EFUN(x)    (get_type_info(x)[0]==8 && get_type_info(x)[1]< 0)
+#define CL_VAR(x)     (get_type_info(x)[0]==8 && get_type_info(x)[1]==1)