diff --git a/doc/sefun/CountUp b/doc/sefun/CountUp
new file mode 100644
index 0000000..5515780
--- /dev/null
+++ b/doc/sefun/CountUp
@@ -0,0 +1,25 @@
+FUNKTION:
+	public varargs string CountUp( string *s, string sep, string lastsep );
+
+ARGUMENTE:
+	*s
+	  Array von Strings mit Woertern.
+  sep
+    String, der zwischen den Woerten in der Aufzaehlung eingefuegt wird.
+    Standard: ", "
+  lastsep
+    String, der zwischen dem vorletzten und letzten Element eingefuegt wird.
+    Standard: " und "
+
+BESCHREIBUNG:
+	Die Woerter Wort_1 bis Wort_n aus dem Stringaray werden als
+	Aufzaehlung in der Form
+	  Wort_1<sep>Wort_2, ... Wort_n-1<lastsep>Wort_n
+	zusammengesetzt. Mit Standardwerten also:
+	  Wort_1, Wort_2, ... Wort_n-1 und Wort_n
+
+RUeCKGABEWERT:
+	String als Aufzaehlung der einzelnen Woerter.
+
+----------------------------------------------------------------------------
+15.03.2008, Zesstra
diff --git a/doc/sefun/_notify_fail b/doc/sefun/_notify_fail
new file mode 100644
index 0000000..84aa4de
--- /dev/null
+++ b/doc/sefun/_notify_fail
@@ -0,0 +1,18 @@
+simul_efun::_notify_fail(E)
+FUNKTION:
+     void _notify_fail(string str)
+
+ARGUMENTE:
+     str
+	umgebrochener Fehlermeldungsstring
+
+BESCHREIBUNG:
+     Identisches Verhalten zu notify_fail(E), bis darauf, dass bei bereits
+     gesetzter Fehlermeldung _keine_ neue Fehlermeldung gesetzt wird.
+
+SIEHE AUCH:
+     notify_fail(E), P_ACTUAL_NOTIFY_FAIL
+     add_action(E), AddCmd(L), AddAction(L),
+     query_verb(E)
+
+24 Maerz 2004 Gloinson
diff --git a/doc/sefun/break_string b/doc/sefun/break_string
new file mode 100644
index 0000000..52d4d7b
--- /dev/null
+++ b/doc/sefun/break_string
@@ -0,0 +1,90 @@
+FUNKTION:
+    string break_string(string str)
+    string break_string(string str, int width)
+    string break_string(string str, int width, string indent)
+    string break_string(string str, int width, int space)
+    string break_string(string str, int width, string indent, int flags)
+    string break_string(string str, int width, int space, int flags)
+
+ARGUMENTE:
+    str    - umzubrechender String
+    width  - optional: maximale Zeilenlaenge (default 78)
+    indent - optional: String, der vor jeder umgebrochenen Zeile erscheint
+    space  - optional: Anzahl der Leerzeichen vor jeder umgebrochenen Zeile
+    flags  - optional: hiermit laesst sich das Verhalten von break_string()
+             aendern; moegliche Flags siehe Punkt 'Beschreibung'
+
+BESCHREIBUNG:
+    In der ersten Form wird der String 'str' durch Einfuegen von "\n" so um-
+    gebrochen, dass bei einer anschliessenden Ausgabe keine Zeile laenger
+    als 'width' Zeichen ist. Eventuell schon in 'str' vorhandene "\n" werden
+    dabei vorher entfernt.
+
+    Gibt man zusaetzlich noch einen String 'indent' an, so wird dieser vor
+    jede der umgebrochenen Zeilen gesetzt.
+
+    Analog wird bei der Angabe der Zahl 'space' ein String mit 'space' Leer-
+    zeichen vor jede umgebrochene Zeile gesetzt.
+
+    Zusaetzlich gibt es folgende optionale Flags, die man beliebig kombinieren
+    kann:
+
+        BS_LEAVE_MY_LFS  -  schon im Text vorhandene "\n" werden beibehalten
+        BS_SINGLE_SPACE  -  doppelte Leerzeichen sowie Leerzeichen nach Zeilen-
+                            umbruechen werden entfernt
+        BS_BLOCK         -  der Text wird im Blocksatz formatiert
+        BS_NO_PARINDENT  -  bei Blocksatz mit vorgegebenen Zeilenumbruechen
+                            (BS_BLOCK|BS_LEAVE_MY_LFS) werden Zeilen nach "\n"
+                            normalerweise mit einem Leerzeichen begonnen.
+                            Um das Einfuegen des fuehrenden Leerzeichens zu
+                            unterdruecken, muss BS_NO_PARINDENT angegeben werden
+        BS_INDENT_ONCE   -  die erste Zeile des Textes wird mit vorangestelltem
+                            'indent' ausgegeben; alle folgenden Zeilen bekommen
+                            einen Leerstring vorangestellt
+        BS_PREPEND_INDENT - der Ident wird dem Text vorangestellt sofern der 
+                            Indent + Text laenger als eine Zeile ist. Der Text
+			    wird um ein Leerzeichen eingerueckt, was mittels
+                            BS_NO_PARINDENT verhindert werden kann.
+
+RUECKGABEWERT:
+    Der umgebrochene Text.
+
+    Laufzeit-Fehler, wenn der Indent laenger ist als die vorgegebene Breite.
+
+BEISPIELE:
+    write(break_string("Dies ist ein laengerer Text. Nur so als Beispiel.",27));
+
+        => Dies ist ein laengerer
+           Text. Nur so als Beispiel.
+
+    write(break_string("Mit indent sieht das so aus", 30, "Wargon sagt: "));
+
+        => Wargon sagt: Mit indent sieht
+           Wargon sagt: das so aus
+
+    write(break_string("Mit indent sieht das so aus", 30, "Wargon sagt: ",
+                        BS_INDENT_ONCE));
+
+        => Wargon sagt: Mit indent sieht
+                        das so aus
+
+    write(break_string("Mit Leerzeichen sieht das so aus", 30, 2));
+
+        =>   Mit Leerzeichen sieht das so
+             aus...
+
+    write(break_string("Ich will es\naber vorformatiert!",60,
+                        "Wargon sagt: ", BS_LEAVE_MY_LFS));
+
+        => Wargon sagt: Ich will es
+           Wargon sagt: aber vorformatiert!
+
+    write(break_string("Ich will es\naber vorformatiert!",30,
+                        "Wargon sagt: ", BS_PREPEND_INDENT));
+
+        => Wargon sagt:
+            Ich will es aber 
+            vorformatiert!
+
+SIEHE AUCH:
+    senderwiederholung
diff --git a/doc/sefun/broken_count_bits b/doc/sefun/broken_count_bits
new file mode 100644
index 0000000..09e56b8
--- /dev/null
+++ b/doc/sefun/broken_count_bits
@@ -0,0 +1,29 @@
+SYNOPSIS
+        int count_bits (string str)
+
+DESTRIPTION
+        Count the number of set bits in bitstring <str> and return the number
+        as result.
+
+NOTE
+	Bitstrings store 6 Bits per Character. Consequently, the functions for
+	manipulating bitstrings (see below) do generally not work on most
+	strings. An exception is this (s)efun. It accepts strings which are
+	not correct bitstrings (like getuid(PL)), BUT: It does NOT work
+	correctly on them! The results are NOT the correct number of bits!
+	Additionally, count_bits() in LDMud rejects such strings with an error
+	instead of returning false results, as all the other functions for
+	bitstrings do as well.
+
+EXAMPLES
+        string s;
+
+        s = set_bit("", 3); s = set_bit(s, 15);
+
+        count_bits(s) --> returns 2
+
+SEE ALSO
+        clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E),
+        or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
+
+19.12.2006, Zesstra
diff --git a/doc/sefun/cindent b/doc/sefun/cindent
new file mode 100644
index 0000000..72119b3
--- /dev/null
+++ b/doc/sefun/cindent
@@ -0,0 +1,9 @@
+SYNOPSIS:
+        int cindent(string file)
+
+DESCRIPTION:
+        Indent a file using an LPC-enhanced version of the GNU indent
+	program, which is modelled after the Berkeley indent(1).
+
+SEE ALSO:
+	ed(E)
diff --git a/doc/sefun/debug_info b/doc/sefun/debug_info
new file mode 100644
index 0000000..18747b0
--- /dev/null
+++ b/doc/sefun/debug_info
@@ -0,0 +1,490 @@
+DEPRECATED
+SYNOPSIS
+        #include <debug_info.h>
+
+        mixed debug_info(int flag)
+        mixed debug_info(int flag, mixed arg)
+        mixed debug_info(int flag, mixed arg2, mixed arg3)
+
+BESCHREIBUNG
+        Sammelt entsprechend den Angaben in <flag> gewisse intere Debuginfos
+        des Treibers. <flag> kann dabei folgende in debug_info.h definierte
+        Werte enthalten:
+
+        DINFO_OBJECT   (0): Angezeigt werden Informationen zum in <arg>
+            spezifizierten Objekt, zum Beispiel heart_beat,
+            enable_commands etc. Die Funktion liefert 0 zurueck.
+
+        DINFO_MEMORY   (1): Angezeigt werden Informationen zu
+            Speicherbelegung und -ausnutzung des in <arg> spezifizierten
+            Objekts, zum Beispiel Anzahl Strings, Variablen, geerbte Files,
+            Objektgroesse etc. Die Funktion liefert 0 zurueck.
+
+        DINFO_OBJLIST  (2): debug_info() liefert Objekte aus der globalen
+            Objektliste. Wenn <arg2> nicht angegeben wird, wird das erste
+            Element aus der Objektliste gelierfert, wenn <arg2> eine Zahl n
+            ist, das n-te Element. Ist <arg2> ein Objekt, werden die
+            nachfolgenden Objekte in der Objektliste zurueck geliefert.
+            Das optionale Argument <arg3> bezeichnet die Anzahl zurueck
+            gelieferter Objekte. Wenn <arg3> 0 ist, wird ein einzelnes
+            Objekt zurueck geliefert. Wenn <arg3> eine Zahl m enthaelt, wird
+            ein Array mit hoechstens m Elementen zurueck geliefert. Auf
+            diese Weise kann ein Array mit saemtlichen Objekten im Spiel
+            erzeugt werden, wenn fuer <arg3> __INT_MAX__ gesetzt wird (eine
+            entsprechende maximale Arraygroesse vorausgesetzt).
+
+        DINFO_MALLOC   (3): Entsprichend der Eingabe des 'malloc'-Kommandos.
+            Es muessen keine weiteren Argumente angegeben werden.
+
+        DINFO_STATUS   (4): Angezeigt wird die Statusinformation des Drivers.
+            Optional kann das Argument <arg> die Werte 0, "tables", "swap",
+            "malloc" oder andere vom Driver akzeptierte Argumente enthalten.
+            Das Resultat ist ein druckbarer String, der die Statusinformation
+            enthaelt, oder 0, wenn ein ungueltiges Argument angegeben wurde.
+
+        DINFO_DUMP     (5): Die durch <arg2> angeforderte Information wird
+            in ein File geschrieben, das man mit <arg3> angeben kann. Wird
+            <arg3> nicht angegeben, wird eine Standarddatei verwendet.
+            debug_info() ueberprueft mittels master->valid_write(), ob es
+            das File schreiben kann. Falls bereits eine entsprechende Datei
+            existiert, wird diese ueberschrieben. Die Funktion liefert 1
+            bei Erfolg, 0 sonst.
+
+            <arg2> == "objects": liefert Informationen ueber alle Objekte im
+                Spiel und schreibt diese standardmaessig in die Datei
+                /OBJ_DUMP, dem valid_write() wird 'objdump' uebergeben.
+                Die Datei enthaelt fuer jedes Objekt eine Zeile, in der
+                jeweils folgende Informationen aufgelistet sind:
+                  - Name des Objekts (object_name)
+                  - Groesse im Speicher, gemeinsamer genutzter Speicher nur
+                    einmal gezaehlt
+                  - Groesse im Speicher, wenn es keine gemeinsam genutzte
+                    Daten geben wuerde
+                  - Anzahl Referenzen
+                  - 'HB', wenn das Objekt einen heart_beat hat, sonst nichts.
+                  - der Name der Umgebung oder '--', wenn das Objekt keine
+                    Umgebung hat
+                  - in Klammern die Anzahl der durch das Objekt verursachten
+                    Verarbeitungsschritten (execution ticks)
+                  - der Swap-Status:
+                      > nichts, wenn das Objekt nicht geswapt wurde
+                      > 'PROG SWAPPED', wenn nur das Programm geswapt wurde
+                      > 'VAR SWAPPED', wenn nur die Variablen geswapt wurden
+                      > 'SWAPPED', wenn beide geswapt wurden
+                  - die Zeit, zu der das Objekt geladen wurde.
+
+            <arg2> == "destructed": liefert Informationen ueber alle
+                zerstoerten Objekte und schreibt diese standardmaessig in
+                die Datei /DEST_OBJ_DUMP, dem valid_write() wird 'objdump'
+                uebergeben. Die Datei enthaelt fuer jedes Objekt eine Zeile,
+                in der jeweils folgende Informationen aufgelistet sind:
+                  - Name des Objekts (object_name)
+                  - Anzahl der Referenzen
+                  - 'NEW', wenn das Objekt in diesem Verarbeitungszyklus
+                    zerstoert wurde, nichts wenn es bereits fruehre zerstoert
+                    worden war.
+
+            <arg2> == "opcodes": liefert Nutzungsinformationen ueber die
+                opcodes. Standardmaessig wird in die Datei /OPC_DUMP
+                geschrieben. valid_write() wird 'opcdump' uebergeben.
+
+            <arg2> == "memory": liefert eine Liste aller allokierten
+                Speicherbloecke.
+                Standardmaessig wird in die Datei /MEMORY_DUMP geschrieben;
+                valid_write() wird 'memdump' uebergeben.  Existiert die
+                Datei bereits, werden die neuen Daten angehaengt.
+                Wenn der Allokator einen Speicherabzug nicht unterstuetzt,
+                wird keine Datei geschrieben und immer 0 zurueckgegeben.
+                Diese Funktion ist am nuetzlichsten wenn der Allokator
+                mit MALLOC_TRACE und MALLOC_LPC_TRACE kompiliert
+                wurde.
+
+
+        DINFO_DATA    (6): Liefert Rohdaten ueber gewisse, durch <arg2>
+            spezifizierte Aspekte des Treibers. Das Resultat der Funktion ist
+            ein Array mit der Information oder 0, falls <arg2> keinen
+            gueltigen Wert enthalten hat.
+            Ist <arg3> eine Zahl, die kleiner ist als die Anzahl Elemente im
+            Resultat-Array, liefert die Funktion nur das entsprechende
+            Element zurueck.
+            Zulaessige Werte fuer <arg2> sind: DID_STATUS, DID_SWAP und
+            DID_MALLOC.
+
+            <arg2> == DID_STATUS (0): Liefert die "status" und "status table"
+                Information. Folgende Indizes sind definiert:
+                  - int DID_ST_BOOT_TIME
+                        die Zeit (time()), zu der das Mud gestartet wurde
+                  - int DID_ST_ACTIONS
+                  - int DID_ST_ACTIONS_SIZE
+                        die Anzahl und Groesse im Speicher der allozierten
+                        Actions.
+                  - int DID_ST_SHADOWS
+                  - int DID_ST_SHADOWS_SIZE
+                        Anzahl und Groesse im Speicher aller allozierten
+                        Shadows.
+                  - int DID_ST_OBJECTS
+                  - int DID_ST_OBJECTS_SIZE
+                        Anzahl und Groesse im Speicher aller Objekte.
+                  - int DID_ST_OBJECTS_SWAPPED
+                  - int DID_ST_OBJECTS_SWAP_SIZE
+                        Anzahl und Groesse im Speicher der geswapten
+                        Variablenbloecke der Objekte
+                  - int DID_ST_OBJECTS_LIST
+                        Anzahl Objekte in der Objektliste
+                  - int DID_ST_OBJECTS_NEWLY_DEST
+                        Anzahl der frisch zerstoerten Objekte (d.h. Objekte,
+                        die in diesem Verarbeitungszyklus zerstoert wurden)
+                  - int DID_ST_OBJECTS_DESTRUCTED
+                        Anzahl der zerstoerten, aber noch immer referenzierten
+                        Objekte, ohne die unter DID_ST_OBJECTS_NEWLY_DEST
+                        bereits gezaehlten.
+                  - int DID_ST_OBJECTS_PROCESSED
+                        Anzahl der gelisteten Objekte, die im letzten
+                        Verarbeitungszyklus verarbeitet wurden.
+                  - float DID_ST_OBJECTS_AVG_PROC
+                        Durchschnittlicher Anteil der pro Zyklus verarbeiteten
+                        Objekte, ausgedrueckt in Prozent (0 .. 1.0)
+                  - int DID_ST_OTABLE
+                        Anzahl eingetragener Objekte in der Objekttabelle
+                  - int DID_ST_OTABLE_SLOTS
+                        Anzahl von Hashplaetzen, die von jeder Objekttabelle
+                        bereitgestellt werden
+                  - int DID_ST_OTABLE_SIZE
+                        Durch die Objekttabelle belegter Speicher
+                  - int DID_ST_HBEAT_OBJS
+                        Anzahl Objekte mit einem heart_beat()
+                  - int DID_ST_HBEAT_CALLS
+                        Anzahl aktiver heart_beat() Zyklen bisher (d.h.
+                        Zyklen, in denen mindestens eine heart_beat() Funktion
+                        aufgerufen wurde)
+                  - int DID_ST_HBEAT_CALLS_TOTAL
+                        Gesamtzahl von heart_beat() Zyklen bisher.
+                  - int DID_ST_HBEAT_SLOTS
+                  - int DID_ST_HBEAT_SIZE
+                        Anzahl und Groesse aller allozierten Eintraege in der
+                        heart_beat() Tabelle.
+                  - int DID_ST_HBEAT_PROCESSED
+                        Anzahl heart_beat()s im letzten Zyklus
+                  - float DID_ST_HBEAT_AVG_PROC
+                        Durchschnittlicher Anteil der pro Zyklus aufgerufenen
+                        heart_beat()s, ausgedrueckt in Prozent (0 .. 1.0)
+                  - int DID_ST_CALLOUTS
+                        Anzahl und Groesse aller laufenden call_out()s
+                  - int DID_ST_ARRAYS
+                  - int DID_ST_ARRAYS_SIZE
+                        Anzahl und Groesse aller Arrays
+                  - int DID_ST_MAPPINGS
+                  - int DID_ST_MAPPINGS_SIZE
+                        Anzahl und Groesse aller Mappings
+                  - int DID_ST_PROGS
+                  - int DID_ST_PROGS_SIZE
+                        Anzahl und Groesse aller Programme
+                  - int DID_ST_PROGS_SWAPPED
+                  - int DID_ST_PROGS_SWAP_SIZE
+                        Anzahl und Groesse der geswapten Programme
+                  - int DID_ST_USER_RESERVE
+                  - int DID_ST_MASTER_RESERVE
+                  - int DID_ST_SYSTEM_RESERVE
+                        Momentane Groesse der drei Speicherreserven
+                  - int DID_ST_ADD_MESSAGE
+                  - int DID_ST_PACKETS
+                  - int DID_ST_PACKET_SIZE
+                        Anzahl Aufrufe von add_message(), Anzahl und Groesse
+                        der versendeten Pakete.
+                        Wenn der Driver nicht mit COMM_STAT kompiliert wurde,
+                        liefern alle drei Werte immer -1 zurueck.
+                  - int DID_ST_APPLY
+                  - int DID_ST_APPLY_HITS
+                        Anzahl Aufrufen von apply_low(), und wie viele davon
+                        Cache-Treffer waren. Wenn der Driver nicht mit
+                        APPLY_CACHE_STAT kompiliert wurde, liefern beide
+                        Werte immer -1.
+                  - int DID_ST_STRINGS
+                  - int DID_ST_STRING_SIZE
+                        Anzahl unterschiedlicher Strings in der Stringtabelle,
+                        sowie ihre Groesse
+                  - int DID_ST_STR_TABLE_SIZE
+                        Groesse der String Tabelle
+                  - int DID_ST_STR_REQ
+                  - int DID_ST_STR_REQ_SIZE
+                        Gesamte Anzahl von String Allokationen, und ihre
+                        Groesse
+                  - int DID_ST_STR_SEARCHES
+                  - int DID_ST_STR_SEARCH_LEN
+                        Anzahl Suchvorgaenge in der Stringtabelle und die
+                        Gesamtlaenge des Suchstrings
+                  - int DID_ST_STR_FOUND
+                        Anzahl erfolgreicher Suchvorgaenge
+                  - int DID_ST_STR_ENTRIES
+                        Anzahl Eintraege (Hash Ketten) in der String Tabelle
+                  - int DID_ST_STR_ADDED
+                        Anzahl zur String Tabelle bisher hinzugefuegter
+                        Strings
+                  - int DID_ST_STR_DELETED
+                        Anzahl aus der String Tabelle bisher geloeschter
+                        Strings
+                  - int DID_ST_STR_COLLISIONS
+                        Anzahl zu einer existierenden Hash Kette hinzugefuegte
+                        Strings
+                  - int DID_ST_RX_CACHED
+                        Anzahl gecacheter regulaerer Ausdruecke (regular
+                        expressions)
+                  - int DID_ST_RX_TABLE
+                  - int DID_ST_RX_TABLE_SIZE
+                        Anzahl Plaetze in der Regexp Cache Tabelle und
+                        Speicherbedarf der gecacheten Ausdruecke
+                  - int DID_ST_RX_REQUESTS
+                        Anzahl Anfragen fuer neue regexps
+                  - int DID_ST_RX_REQ_FOUND
+                        Anzahl gefundener regexps in der regexp Cache Tabelle
+                  - int DID_ST_RX_REQ_COLL
+                        Anzahl angefragter regexps, die mit einer bestehenden
+                        regexp kollidierten
+                  - int DID_ST_MB_FILE
+                        Die Groesse des 'File' Speicherpuffers
+                  - int DID_ST_MB_SWAP
+                        Die Groesse des 'Swap' Speicherpuffers
+
+            <arg2> == DID_SWAP (1): Liefert "status swap"-Information:
+                  - int DID_SW_PROGS
+                  - int DID_SW_PROG_SIZE
+                        Anzahl und Groesse der geswappten Programmbloecke
+                  - int DID_SW_PROG_UNSWAPPED
+                  - int DID_SW_PROG_U_SIZE
+                        Anzahl und Groesse der nicht geswappten Bloecke
+                  - int DID_SW_VARS
+                  - int DID_SW_VAR_SIZE
+                        Anzahl und Groesse der geswappten Variablenbloecke
+                  - int DID_SW_FREE
+                  - int DID_SW_FREE_SIZE
+                        Anzahl und Groesse der freien Bloecke in der
+                        Auslagerungsdatei
+                  - int DID_SW_FILE_SIZE
+                        Groesse der Auslagerungsdatei
+                  - int DID_SW_REUSED
+                        Gesamter wiederverwendeter Speicherplatz in der
+                        Auslagerungsdatei
+                  - int DID_SW_SEARCHES
+                  - int DID_SW_SEARCH_LEN
+                        Anzahl und Gesamtlaenge der Suchvorgaenge nach
+                        wiederverwendbaren Bloecken in der Auslagerungsdatei
+                  - int DID_SW_F_SEARCHES
+                  - int DID_SW_F_SEARCH_LEN
+                        Anzahl und Gesamtlaenge der Suchvorgaenge nach einem
+                        Block, der frei gemacht werden kann.
+                  - int DID_SW_COMPACT
+                        TRUE wenn der Swapper im Compact-Modus laeuft
+                  - int DID_SW_RECYCLE_FREE
+                        TRUE wenn der Swapper gerade einen freien Block
+                        wiederverwendet
+
+            <arg2> == DID_MEMORY (2): Liefert die "status malloc"-Information:
+                  - string DID_MEM_NAME
+                        Der Name des Allokators: "sysmalloc", "smalloc",
+                        "slaballoc"
+                  - int DID_MEM_SBRK
+                  - int DID_MEM_SBRK_SIZE
+                        Anzahl und Groesse der Speicherbloecke, die vom
+                        Betriebssystem angefordert wurden (smalloc, slaballoc)
+                  - int DID_MEM_LARGE
+                  - int DID_MEM_LARGE_SIZE
+                  - int DID_MEM_LFREE
+                  - int DID_MEM_LFREE_SIZE
+                        Anzahl und Groesse der grossen allozierten bzw.
+                        freien Bloecke (smalloc, slaballoc)
+                  - int DID_MEM_LWASTED
+                  - int DID_MEM_LWASTED_SIZE
+                        Anzahl und Groesse der unbrauchbaren grossen
+                        Speicherfragmente (smalloc, slaballoc)
+                  - int DID_MEM_CHUNK
+                  - int DID_MEM_CHUNK_SIZE
+                        Anzahl und Groesse kleiner Speicherbloecke (chunk
+                        blocks; smalloc, slaballoc)
+                  - int DID_MEM_SMALL
+                  - int DID_MEM_SMALL_SIZE
+                  - int DID_MEM_SFREE
+                  - int DID_MEM_SFREE_SIZE
+                        Anzahl und groesse der allozierten bzw. freien
+                        kleinen Speicherbloecke (smalloc, slaballoc)
+                  - int DID_MEM_SWASTED
+                  - int DID_MEM_SWASTED_SIZE
+                        Anzahl und Groesse der unbrauchbar kleinen
+                        Speicherfragmente (smalloc, slaballoc)
+                  - int DID_MEM_MINC_CALLS
+                  - int DID_MEM_MINC_SUCCESS
+                  - int DID_MEM_MINC_SIZE
+                        Anzahl Aufrufe von malloc_increment(), Anzahl der
+                        erfolgreichen Aufrufe und die Groesse des auf diese
+                        Art allozierten Speichers (smalloc, slaballoc)
+                  - int DID_MEM_PERM
+                  - int DID_MEM_PERM_SIZE
+                        Anzahl und Groesse permanenter (non-GCable)
+                        Allokationen (smalloc, slaballoc)
+                  - int DID_MEM_CLIB
+                  - int DID_MEM_CLIB_SIZE
+                        Anzahl und Groesse der Allokationen durch Clib
+                        Funktionen (nur smalloc, slaballoc mit SBRK_OK)
+                  - int DID_MEM_OVERHEAD
+                        Overhead fuer jede Allokation (smalloc, slaballoc)
+                  - int DID_MEM_ALLOCATED
+                        Der Speicher, der durch die Speicherverwaltung
+                        alloziert wurde, inklusive den Overhead fuer die
+                        Speicherverwaltung (smalloc, slaballoc)
+                  - int DID_MEM_USED
+                        Der Speicher, der durch den Driver belegt ist, ohne
+                        den durch die Speicherverwaltung belegten Speicher
+                        (smalloc, slaballoc)
+                  - int DID_MEM_TOTAL_UNUSED
+                        Der Speicher, der vom System zur Verfuegung gestellt,
+                        aber vom Treiber nicht benoetigt wird.
+                  - int DID_MEM_AVL_NODES          (smalloc, slaballoc)
+                        Anzahl der AVL-Knoten, die zur Verwaltung der
+                        freien grossen Speicherbloecke verwendet werden
+                        (nur smalloc). Dieser Wert kann in Zukunft
+                        wieder verschwinden.
+                  - mixed * DID_MEM_EXT_STATISTICS (smalloc, slaballoc)
+                        Detaillierte Statistiken des Allokators sofern
+                        diese aktiviert wurden; 0 anderenfalls.
+
+                        Dieser Wert kann in Zukunft wieder verschwinden.
+
+                        Das Array enthaelt NUM+2 Eintraege, wobei NUM
+                        Anzahl der verschiedenen 'kleinen'
+                        Blockgroessen ist. Eintrag [NUM] beschreibt
+                        die uebergrossen 'kleinen' Bloecke, Eintrag
+                        [NUM+1] beschreibt summarisch die 'grossen'
+                        Bloecke. Jeder Eintrag ist ein Array mit
+                        diesen Feldern:
+
+                        int DID_MEM_ES_MAX_ALLOC:
+                          Maximale Anzahl allokierter Bloecke dieser
+                          Groesse.
+
+                        int DID_MEM_ES_CUR_ALLOC:
+                          Derzeitige Anzahl allokierter Bloecke dieser
+                          Groesse.
+                          Current number of allocated blocks of this size.
+
+                        int DID_MEM_ES_MAX_FREE:
+                          Maximale Anzahl freier Bloecke dieser
+                          Groesse.
+
+                        int DID_MEM_ES_CUR_FREE:
+                          Derzeitige Anzahl freier Bloecke dieser
+                          Groesse.
+
+                        float DID_MEM_ES_AVG_XALLOC:
+                          Durchschnittliche Zahl von Allokationen pro
+                          Sekunde.
+
+                        float DID_MEM_ES_AVG_XFREE:
+                          Durchschnittliche Zahl von Deallokationen pro
+                          Sekunde.
+
+                      Die Durchschnittsstatistiken schliessen interne
+                      Umsortierungen der Blocklisten nicht ein.
+
+
+        DINFO_TRACE    (7): Liefert die 'trace' Information aus dem
+            Call Stack entsprechend der Spezifikation in <arg2>. Das Resultat
+            ist entweder ein Array (dessen Format nachstehend erlaeutert ist)
+            oder ein druckbarer String. Wird <arg2> weggelasen entspricht
+            dies DIT_CURRENT.
+
+            <arg2> == DIT_CURRENT (0): Momentaner Call Trace
+                   == DIT_ERROR   (1): Letzter Fehler Trace (caught oder
+                        uncaught)
+                   == DIT_UNCAUGHT_ERROR (2): Letzer Fehler Trace, der nicht
+                        gefangen werden konnte (uncaught)
+
+            Die Information wird in Form eines Array uebergeben.
+
+            Die Fehlertraces werden nur geaendert, wenn ein entsprechender
+            Fehler auftritt; ausserdem werden sie bei einem GC (Garbage
+            Collection) geloescht. Nach einem Fehler, der nicht gefangen
+            werden konnte (uncaught error), weisen beide Traces auf das
+            gleiche Array, sodass der ==-Operator gilt.
+
+            Wenn das Array mehr als ein Element enthaelt, ist das erste
+            Element 0 oder der Name des Objekts, dessen heart_beat() den
+            laufenden Zyklus begonnen hat; alle nachfolgenden Elemente
+            bezeichnen den Call Stack, beginnen mit der hoechsten
+            aufgerufenen Funktion.
+
+            Alle Eintraege im Array sind wiederum Arrays mit folgenden
+            Elementen:
+              - int[TRACE_TYPE]: Der Typ der aufrufenden Funktion
+                    TRACE_TYPE_SYMBOL (0): ein Funktionssymbol (sollte nicht
+                                           vorkommen)
+                    TRACE_TYPE_SEFUN  (1): eine simul-efun
+                    TRACE_TYPE_EFUN   (2): eine Efun Closure
+                    TRACE_TYPE_LAMBDA (3): eine lambda Closure
+                    TRACE_TYPE_LFUN   (4): eine normale Lfun
+              - int[TRACE_NAME]
+                    _TYPE_EFUN    : entweder der Name der Funktion oder der
+                                    Code einer Operator-Closure
+                    _TYPE_LAMBDA  : die numerische Lambda-ID
+                    _TYPE_LFUN    : der Name der Lfun
+              - string[TRACE_PROGRAM]:  Der Name des Programms mit dem Code
+              - string[TRACE_OBJECT]:   Der Name des Objekts, fuer das der
+                                        Code ausgefuehrt wurde
+              - int[TRACE_LOC]:
+                    _TYPE_LAMBDA  : Der Offset des Programms seit Beginn des
+                                    Closure-Codes
+                    _TYPE_LFUN    : Die Zeilennummer.
+
+            <arg2> == DIT_STR_CURRENT (3): Liefert Informationen ueber den
+                momentanen Call Trace als druckbarer String.
+
+            <arg2> == DIT_CURRENT_DEPTH (4): Liefert die Zahl der Frames auf
+                dem Control Stack (Rekursionstiefe).
+
+        DINFO_EVAL_NUMBER (8): gibt die Nummer der aktuellen Berechnung
+            zurueck. Diese Nummer wird fuer jeden vom driver initiierten
+            Aufruf von LPC-Code erhoeht, also bei Aufruf von:
+              - Kommandos (die per add_action hinzugefuegt wurden)
+              - heart_beat, reset, clean_up
+              - Aufrufe durch call_out oder input_to
+              - master applies, die auf externe Ereignisse zurueckgehen
+              - driver hooks genauso
+              - Rueckrufen von send_erq
+              - logon in interaktiven Objekten
+
+           Dieser Zaehler kann z.B. benutzt werden, um zu verhindern, dass
+           bestimmte Aktionen mehrfach innerhalb eines heart_beat()
+           ausgefuehrt werden. Eine andere Anwendungsmoeglichkeit sind
+           Zeitstempel zur Sortierung zur Sortierung von Ereignissen.
+
+           Es ist zu beachten, dass der Zaehler ueberlaufen kann, insbesondere
+           auf 32-bit-Systemen. Er kann demzufolge auch negativ werden.
+
+
+GESCHICHTE
+        Seit 3.2.7 liefert DINFO_STATUS die Information zurueck, anstatt sie
+            nur auszugeben.
+        DINFO_DUMP wurde in 3.2.7 eingefuehrt.
+        LDMud 3.2.8 fuegte die Datengroesse des Objekts zum Resultat von
+            DINFO_MEMORY hinzu, ausserdem die DINFO_DATA Abfrage und die
+            verschiedenen DID_MEM_WASTED Statistiken.
+        LDMud 3.2.9 fuegte DINFO_TRACE, das Indizierungs-Feature von
+            DINFO_DATA, den 'destructed'-DINFO_DUMP, die DID_MEM_CLIB*,
+            die DID_MEM_PERM*, ausserdem DID_ST_OBJECTS_NEWLY_DEST,
+            DID_ST_OBJECTS_DEST, DID_MEM_OVERHEAD, DID_MEM_ALLOCATED,
+            DID_MEM_USED, DID_MEM_TOTAL_UNUSED, DID_ST_HBEAT_CALLS_TOTAL
+            und die found / added / collision Stringstatistiken.
+        LDMud 3.2.10 fuegte die Erzeugungszeit zu DINFO_DUMP:"objects" hinzu,
+            entfernte DID_MEM_UNUSED aus DINFO_DATA:DID_MEMORY, fuegte
+            DINFO_DATA:DID_STATUS DID_ST_BOOT_TIME, DID_ST_MB_FILE und
+            DID_ST_MB_SWAP hinzu und entfernte DID_ST_CALLOUT_SLOTS daraus,
+            fuegte das dritte Argument zu DINFO_OBJLIST hinzu, und veraenderte
+            die Bedeutung von DID_ST_CALLOUT_SIZE und DID_ST_HBEAT_SIZE
+            bzw. _SLOTS.
+        LDMud 3.3.533 fuegte DID_MEM_AVL_NODES zu DINFO_DATA:DID_MEMORY
+            hinzu.
+        LDMud 3.3.603 fuegte DID_MEM_EXT_STATISTICS zu DINFO_DATA:DID_MEMORY
+            hinzu.
+        LDMud 3.3.718 fuegte DIT_CURRENT_DEPTH to DINFO_TRACE hinzu.
+        LDMud 3.3.719 fuegte DINFO_EVAL_NUMBER hinzu.
+
+SIEHE AUCH
+        trace(E), traceprefix(E), malloc(D), status(D), dumpallobj(D)
diff --git a/doc/sefun/deep_present b/doc/sefun/deep_present
new file mode 100644
index 0000000..78c0983
--- /dev/null
+++ b/doc/sefun/deep_present
@@ -0,0 +1,21 @@
+FUNKTION:
+        object deep_present(string what)
+        object deep_present(object what)
+        object deep_present(string what, object ob)
+        object deep_present(object what, object ob)
+
+ARGUMENTE:
+        what - Objekt oder ID des Objektes, nach dem gesucht werden soll
+        ob - Objekt, in dem gesucht werden soll
+
+BESCHREIBUNG:
+        deep_present() sucht in this_object() (oder in ob, falls angegeben)
+        nach dem Objekt what oder einem Objekt, das auf what anspricht.
+        Im Gegensatz zu present() wird aber das komplette Inventory berueck-
+        sichtigt (also zB. auch der Inhalt von Beuteln).
+
+RUECKGABEWERT:
+        das gefundene Objekt oder 0
+
+SIEHE AUCH:
+        present(E)
diff --git a/doc/sefun/dtime b/doc/sefun/dtime
new file mode 100644
index 0000000..6624642
--- /dev/null
+++ b/doc/sefun/dtime
@@ -0,0 +1,24 @@
+FUNKTION:
+	string dtime(int time)
+
+ARGUMENTE:
+	time - Umzuwandelndes Datum in Sekunden seit 1.1.1970, 0:0:0h
+
+BESCHREIBUNG:
+	Wandelt das Datum time in einen deutschsprachigen String der Form
+	"<wtag>, <tag>. <mon> <jahr>, <std>:<min>:<sek>" um.
+
+RUECKGABEWERT:
+	Der String mit dem umgewandelten Datum.
+
+BEMERKUNGEN:
+	Als time wird meistens das Ergebnis von time() benutzt.
+  strftime() stellt eine wesentlich flexiblere Moeglichkeit der Ausgabe von
+  Zeiten dar.
+
+BEISPIELE:
+	datum = dtime(time());
+        => datum = "Mon,  6. Mar 1994, 15:00:08"
+
+SIEHE AUCH:
+	ctime(E), strftime(E), time(E)
diff --git a/doc/sefun/dump_netdead b/doc/sefun/dump_netdead
new file mode 100644
index 0000000..c73b2c0
--- /dev/null
+++ b/doc/sefun/dump_netdead
@@ -0,0 +1,13 @@
+FUNKTION:
+        string *dump_netdead()
+
+BESCHREIBUNG:
+        Gibt ein Array mit den Namen aller zur Zeit netztoten Spieler
+        zurueck.
+
+RUECKGABEWERT:
+        Ein Stringarray mit den Namen der netztoten Spieler.
+        gibt.
+
+SIEHE AUCH:
+        find_netdead(E)
diff --git a/doc/sefun/enable_commands b/doc/sefun/enable_commands
new file mode 100644
index 0000000..6508b5f
--- /dev/null
+++ b/doc/sefun/enable_commands
@@ -0,0 +1,26 @@
+SYNOPSIS
+        void enable_commands();
+
+BESCHREIBUNG
+        Erlaubt dem Objekt, Kommandos zu verwenden, die normalerweise Usern
+        zugaenglich sind. Der Aufruf markiert das Objekt als "living". Dies
+        wird fuer Spieler und alle von /std/npc abgeleiteten Objekte
+        bereits von der Mudlib erledigt und sollte nicht nochmals gemacht
+        werden.
+
+        Diese Funktion darf nicht ausserhalb von create() (oder reset(0) im
+        Compat-Modus) aufgerufen werden, weil der Kommandogeber auf dieses
+        Objekt gesetzt wird.
+
+BEISPIEL
+        void create()
+        {
+            enable_commands();
+            ...
+        }
+
+        Dies markiert das Objekt als "living".
+
+SIEHE AUCH
+        command(E), living(E), disable_commands(E), native(C), hooks(C)
+        set_living_name(E)
diff --git a/doc/sefun/file_time b/doc/sefun/file_time
new file mode 100644
index 0000000..6c24baa
--- /dev/null
+++ b/doc/sefun/file_time
@@ -0,0 +1,5 @@
+FUNKTION:
+	int file_time(string filename);
+
+Liefert den Zeitpunkt der letzten Modifikation des Files in Sekunden seit
+dem 1.1.1970, 0:00. Kann per ctime() in ein lesbares Format gebracht werden.
diff --git a/doc/sefun/find_living b/doc/sefun/find_living
new file mode 100644
index 0000000..106dd63
--- /dev/null
+++ b/doc/sefun/find_living
@@ -0,0 +1,22 @@
+SYNOPSIS:
+        object find_living(string str)
+
+BESCHREIBUNG:
+        Findet das erste "lebende" Objekt, welches per set_living_name() den
+        Namen <str> setzte.
+        
+        Das Objekt muss ausserdem per enable_commands() als Lebewesen
+        markiert worden sein. Dies ist fuer alle von /std/npc erbenden NPCs
+        _automatisch_ der Fall und sollte daher nicht nochmal explizit gemacht
+        werden.
+
+BEISPIEL:
+        object ob;
+        ob = find_living("Public Enemy");
+
+SIEHE AUCH:
+        find_player(E), enable_commands(E), set_living_name(E)
+
+LETZTE AeNDERUNG:
+09.10.2011, Zesstra
+
diff --git a/doc/sefun/find_livings b/doc/sefun/find_livings
new file mode 100644
index 0000000..cc9228f
--- /dev/null
+++ b/doc/sefun/find_livings
@@ -0,0 +1,24 @@
+FUNKTION:
+        object *find_livings(string name)
+
+ARGUMENTE:
+        name - der living_name der gesuchten Lebewesen
+
+BESCHREIBUNG:
+        Diese Funktion liefert ein Array mit allen Lebewesen, die den gleichen
+        living_name haben.
+
+RUECKGABEWERT:
+        Array mit den Lebewesen oder 0, wenn es kein Lebewesen diesen Namens
+        gibt.
+
+BEISPIELE:
+        ob = find_livings("herkules");
+        => ob = ({ [/human:herkules], 
+                   [/d/inseln/wargon/luftschloss/mon/herkules] })
+
+SIEHE AUCH:
+        find_living(E), set_living_name(E), find_player(E), find_netdead(E)
+
+LETZTE AENDERUNG:
+19. Okt. 2015, Arathorn
diff --git a/doc/sefun/find_netdead b/doc/sefun/find_netdead
new file mode 100644
index 0000000..d44ee9e
--- /dev/null
+++ b/doc/sefun/find_netdead
@@ -0,0 +1,25 @@
+FUNKTION:
+        object find_netdead(string name)
+
+ARGUMENTE:
+        name - Name des gesuchten Spielers
+
+BESCHREIBUNG:
+        Falls der Spieler name netztot ist, liefert diese Funktion das Spieler-
+        objekt zurueck.
+
+        Akzeptiert auch die UUID statt einer UID. In diesem Fall erfolgt aber
+        nur eine Pruefung, ob die UID des gefundenen Spielers zur angegebenen
+        UUID passt (d.h. "jof_-1" wuerde dann ggf. auch das Spielerobjekt Jof
+        zurueckliefern, wenn das die UUID "Jof_1234" hat).
+
+
+RUECKGABEWERT:
+        Der netztote Spieler oder 0, falls es keinen Netztoten diesen Namens
+        gibt.
+
+SIEHE AUCH:
+        find_living(E), find_player(E)
+
+LETZT AeNDERUNG:
+06.01.2009, Zesstra
diff --git a/doc/sefun/find_player b/doc/sefun/find_player
new file mode 100644
index 0000000..57c85f3
--- /dev/null
+++ b/doc/sefun/find_player
@@ -0,0 +1,42 @@
+FUNKTION:
+        object find_player(string uid)
+
+BESCHREIBUNG:
+        Findet den Spieler mit dem Namen bzw. der User-ID <uid>.
+        
+        Akzeptiert auch die UUID statt einer UID. In diesem Fall erfolgt aber
+        nur eine Pruefung, ob die UID des gefundenen Spielers zur angegebenen
+        UUID passt (d.h. "jof_-1" wuerde dann ggf. auch das Spielerobjekt Jof
+        zurueckliefern, wenn das die UUID "Jof_1234" hat).
+
+        Rueckgabewert ist das Spielerobjekt (wenn Spieler anwesend),
+        ansonsten 0.
+
+BEISPIEL:
+
+        object ob;
+        ob = find_player("deepthought");
+
+        if(ob)
+          tell_object(ob,"Tach Du!\n");
+
+        oder auch 
+
+        if(ob = find_player("deepthought"))
+          tell_object(ob,"Tach Du!\n");
+
+ANMERKUNGEN:
+
+        Via find_player() werden auch unsichtbare Magier gefunden. In 
+        Objekten, die fuer Spieler gedacht sind, muss dies dann extra
+        per Abfrage auf if(ob->QueryProp(P_INVIS)) getestet werden.
+
+        Netztote Spieler und Monster werden nicht gefunden da find_player
+        den Namen aus set_living_name() verwendet, der in player.c ge-
+        setzt wird.
+        
+SIEHE AUCH:
+        find_living(E), set_living_name(E), find_object(E), find_netdead(E)
+
+----------------------------------------------------------------------------
+Letzte Aenderung: 06.01.2009, Zesstra 
diff --git a/doc/sefun/getuuid b/doc/sefun/getuuid
new file mode 100644
index 0000000..5b34343
--- /dev/null
+++ b/doc/sefun/getuuid
@@ -0,0 +1,17 @@
+SYNOPSIS:
+    string getuuid(object ob)
+
+DESCRIPTION:
+    Liefert eine eindeutige (get unique uid) UID fuer einen Spieler.
+    Wird zusammengesetzt aus der UID des Spielers und seinem
+    Erstlogin-Datum.
+
+    Nach einer Selbstloeschung und neuem Login erhaelt der Spieler eine
+    neue UUID, bei einer Restaurierung behaelt er seine alte UUID.
+
+    Wenn die Funktion ohne Parameter aufgerufen wird, wird per Default
+    this_object() genommen.
+    
+
+SEE ALSO:
+        getuid(E)
diff --git a/doc/sefun/iso2ascii b/doc/sefun/iso2ascii
new file mode 100644
index 0000000..fe7757a
--- /dev/null
+++ b/doc/sefun/iso2ascii
@@ -0,0 +1,17 @@
+FUNKTION:
+	public string iso2ascii( string str );
+
+ARGUMENTE:
+	str
+	  String, in welchem Zeichen ersetzt werden sollen.
+
+BESCHREIBUNG:
+	In dem String werden alle Nicht-ASCII-Zeichen durch ASCII-Zeichen
+	ersetzt, und zwar Umlaute in der bekannten Form und alle anderen
+	durch ein Fragezeichen.
+
+RUeCKGABEWERT:
+	String mit ASCII-Zeichen.
+
+----------------------------------------------------------------------------
+Last modified: Fri Jul  6 19:36:09 2001 by Patryn
diff --git a/doc/sefun/log_file b/doc/sefun/log_file
new file mode 100644
index 0000000..cf7e03b
--- /dev/null
+++ b/doc/sefun/log_file
@@ -0,0 +1,31 @@
+FUNKTION:
+	int log_file(string file, string text)
+  int log_file(string file, string text, int size_to_break)
+
+ARGUMENTE:
+	file - Name der Datei, in die geschrieben werden soll
+	text - Der Text, der geschrieben werden soll
+	size_to_break - Groesse, ab der ein neues File begonnen wird (optional)
+
+BESCHREIBUNG:
+	log_file schreibt den Text text in die Datei /log/file.
+
+RUECKGABEWERT:
+	1 bei Erfolg oder 0, falls ein Fehler beim Schreiben auftrat.
+
+BEMERKUNGEN:
+	Wenn die Groesse von file vor dem Schreiben 50000 Bytes ueberschreitet,
+	wird sie in file.old umbenannt. Eine schon vorhandene Datei file.old
+	wird dabei geloescht. Der Text wird nach dem Umbenennen geschrieben.
+	Wird 'size_to_break' angegeben und ist dies > 0, wird dieser Wert (in 
+	Bytes) statt der 50000 Bytes zum Rotieren des Logfiles benutzt.
+
+BEISPIELE:
+	log_file( "report/wargon.rep", "TYPO von bla in blubb:\ntest\n");
+	In /log/report/wargon.rep finde ich nun die neueste Typomeldung... ;)
+
+SIEHE AUCH:
+	write_file(E)
+
+09.06.2014, Zesstra
+
diff --git a/doc/sefun/lowerchar b/doc/sefun/lowerchar
new file mode 100644
index 0000000..0ec62bf
--- /dev/null
+++ b/doc/sefun/lowerchar
@@ -0,0 +1,20 @@
+FUNKTION:
+	int lowerchar(int char)
+
+ARGUMENTE:
+	char - Das umzuwandelnde Zeichen
+
+BESCHREIBUNG:
+	Wenn char ein Grossbuchstabe ist, so wird es in einen Kleinbuchstaben
+	umgewandelt. Andere Zeichen werden von dieser Funktion nicht beein-
+        flusst.
+
+RUECKGABEWERT:
+	Das umgewandelte Zeichen.
+
+BEISPIELE:
+	printf("%c\n", lowerchar('A')); => a
+	printf("%c\n", lowerchar('1')); => 1
+
+SIEHE AUCH:
+	lower_case(E), lowerstring(E), upperstring(E), capitalize(E)
diff --git a/doc/sefun/lowerstring b/doc/sefun/lowerstring
new file mode 100644
index 0000000..30748fc
--- /dev/null
+++ b/doc/sefun/lowerstring
@@ -0,0 +1,20 @@
+FUNKTION:
+	string lowerstring(string str)
+
+ARGUMENTE:
+	str - Der umzuwandelnde String.
+
+BESCHREIBUNG:
+	Alle Grossbuchstaben in str werden in Kleinbuchstaben umgewandelt.
+
+RUECKGABEWERT:
+	Der umgewandelte String.
+
+BEMERKUNGEN:
+	lowerstring ist mit lower_case identisch!
+
+BEISPIELE:
+	s = lowerstring("So, McLaud...\n"); => s = "so, mclaud...\n"
+
+SIEHE AUCH:
+	lower_case(E), lowerchar(E), upperstring(E), capitalize(E)
diff --git a/doc/sefun/m_copy_delete b/doc/sefun/m_copy_delete
new file mode 100644
index 0000000..cb1c97b
--- /dev/null
+++ b/doc/sefun/m_copy_delete
@@ -0,0 +1,43 @@
+FUNKTION:
+	mapping m_copy_delete(mapping map, mixed key)
+
+ARGUMENTE:
+	map - das Mapping, aus dem geloescht werden soll.
+	key - der zu loeschende Eintrag
+
+BESCHREIBUNG:
+	Aus dem Mapping map wird der Eintrag key geloescht (wenn er in map vor-
+	handen ist). map wird dabei nicht veraendert.
+
+RUECKGABEWERT:
+	Eine (flache !) Kopie von map ohne den Eintrag key, d.h. enthaltene
+	Mappings/Arrays werden nicht kopiert.
+
+BEMERKUNGEN:
+	Das urspruengliche Mapping wird bei dieser Operation nicht veraendert!
+	Wenn man nur einen Wert aus dem Mapping loeschen will und die Kopie nicht
+	braucht, bietet sich efun::m_delete(mapping,key) sehr an, da die Erstellung
+  einer Kopie sehr aufwendig sein kann.
+
+BEISPIELE:
+	mapping m1, m2;
+
+        m1 = ([ "a":1, "b":2, "c":3 ]);
+
+        m2 = m_copy_delete(m1, "b");
+           => m1 = ([ "a":1, "b":2, "c":3 ])
+	      m2 = ([ "a":1, "c":3 ])
+
+        m_copy_delete(m1, "a");
+           => (es hat sich nichts geaendert)
+
+        m1 = m_copy_delete(m1, "a");
+           => m1 = ([ "b":2, "c":3 ])
+
+        Im letzten Fall sollte aber besser efun::m_delete(m1, "a") benutzt 
+        werden, da ansonsten das Mapping unnoetig kopiert wird und Rechen-
+        leistung frisst. 
+
+SIEHE AUCH:
+  efun::m_delete(E), mappingp(E), mkmapping(E), m_indices,(E) m_values(E),
+  sizeof(E), widthof(E)
diff --git a/doc/sefun/match_living b/doc/sefun/match_living
new file mode 100644
index 0000000..44801a8
--- /dev/null
+++ b/doc/sefun/match_living
@@ -0,0 +1,30 @@
+match_living(sefun)
+FUNKTION:
+     varargs mixed match_living( string str, int players_only,
+				 string *exclude)
+
+ARGUMENTE:
+     string str		- Kuerzel, nach dem die living_names durchsucht
+			  werden soll
+     int players_only	- 1, um nur Spieler (Interactives) zu suchen
+     string *exlude	- welche Namen sollen ignoriert werden
+
+
+BESCHREIBUNG:
+     Sucht alle Lebewesen, deren Namen mit str beginnen.
+
+RUECKGABEWERT:
+     Ein String, falls es ein Lebewesen mit dem Namen str gibt (der Name
+     muss genau passen).
+     -1, wenn es mehrere Lebewesen gibt, deren Namen mit str beginnen.
+     -2, wenn es kein Lebewesen gibt, dessen Name mit str beginnt.
+
+BEISPIELE:
+     match_living("wargon"); => "wargon", wenn Wargon eingeloggt ist.
+     match_living("war");    => "wargon", wenn es kein anderes Lebewesen
+                                gibt, dessen Name mit "war" beginnt.
+
+SIEHE AUCH:
+     find_living(E), find_player(E), find_netdead(E)
+
+27. Mai 2004 Gloinson
diff --git a/doc/sefun/md5 b/doc/sefun/md5
new file mode 100644
index 0000000..1e65090
--- /dev/null
+++ b/doc/sefun/md5
@@ -0,0 +1,30 @@
+DEPRECATED
+SYNOPSIS
+        string md5 (string arg [ , int iterations ] )
+        string md5 (int *  arg [ , int iterations ] )
+
+BESCHREIBUNG
+        Berechnet den MD5-Hashwert von <arg>.
+        Das Argument kann ein String, oder ein Array von Zahlen sein (von
+        welchen nur das unterste Byte betrachted wird).
+
+        Das Ergebnis wird als 32-stelliger Hexadezimalwert geliefert.
+
+        Ist das <iterations> Argument eine Zahl groesser 0, berechnet der
+        Driver den Digest mit diese Anzahl an Wiederholungen. Fehlt die
+        Angabe, fuehrt der Driver die Digest-Berechnung einmal aus.
+
+BEISPIEL
+        string s;
+
+        s = md5("Hallo");
+        s = md5( ({ 'H', 'e', 'l', 'l', 'o' }) )
+        s = md5( ({ 'H', 'e', 'l', 'l', 'o' }), 2 )
+
+AENDERUNGEN
+        Eingefuehrt in LDMud 3.2.9
+        LDMud 3.2.12 fuehrte Zaehlenarrays als Argument ein, also auch
+          die Anzahl der Wiederholungen.
+
+SIEHE AUCH
+        crypt(E), md5_crypt(E), sha1(E), hash(E), hmac(E)
diff --git a/doc/sefun/mkdirp b/doc/sefun/mkdirp
new file mode 100644
index 0000000..a05d4e6
--- /dev/null
+++ b/doc/sefun/mkdirp
@@ -0,0 +1,21 @@
+FUNKTION:
+        int mkdirp(string dir)
+
+ARGUMENTE:
+        dir - Name des zu erstellenden Verzeichnisses (absolut)
+
+BESCHREIBUNG:
+        Erzeugt das Verzeichnis <dir>. Dies muss als abs. Pfad angegeben
+        werden.
+        Wenn noetig, wird die ganze Verzeichnishierarchie rekursiv erstellt.
+        
+RUECKGABEWERT:
+        0 - Verzeichnis konnte nicht erstellt werden
+        1 - Verzeichnis wurde erstellt oder existierte bereits
+
+SIEHE AUCH:
+        mkdir(E)
+
+LETZT AeNDERUNG:
+26.01.2013, Zesstra
+
diff --git a/doc/sefun/notify_fail b/doc/sefun/notify_fail
new file mode 100644
index 0000000..1970367
--- /dev/null
+++ b/doc/sefun/notify_fail
@@ -0,0 +1,85 @@
+FUNKTION:
+     #include <notify_fail.h>
+
+     varargs void notify_fail(string str, int prio)
+     varargs void notify_fail(closure cl, int prio)
+
+ARGUMENTE:
+     str   Meldung die an den Spieler anstatt des 'Wie bitte' ausgegeben
+           werden soll
+     cl    Closure, die bei Fehlschlag ausgefuehrt werden soll
+     prio  Prioritaet dieses Objekts bei diesem Setzen der Meldung
+
+BESCHREIBUNG:
+     Merkt sich den angegebenen str und gibt ihn im Falle einer inkorrekten
+     Eingabe des Spielers anstatt eines 'Wie bitte' aus.
+
+     Gedacht ist notify_fail, um dem Spieler eine bessere Hilfestellung
+     bei Kommandos / Eingaben zu geben, um ihn u.U. auf die richtige
+     Syntax hinzuweisen.
+
+     Wird notify_fail mehrfach (durch verschiedene Objekte o.ae.) auf-
+     gerufen, wird der letzte erfolgreiche Aufruf gewertet. Eine Meldung wird
+     dann tatsaechlich gesetzt, wenn die Prioritaet dieses Objekts gleich
+     gross oder groesser ist als die Prioritaet des Objekts, was das bisher
+     gueltige notify_fail() gesetzt hat. Folgende Prioritaeten sind
+     vordefiniert und werden automatisch ermittelt:
+     NF_NL_OWN    100         // eigenes Objekt (soul) ueberschreibt kaum was
+     NF_NL_THING  100000
+     NF_NL_ROOM   1000000     // Raeume ueberschreiben sonstigen Krams
+     NF_NL_LIVING 10000000    // Lebewesen ueberschreiben auch Raeume
+     2 weitere vordefinierte koennen von Magier angegeben werden:
+     NF_NL_NONE   -1          // wird von allem ueberschrieben
+     NF_NL_MAX    __INT_MAX__ // hoechste Prioritaet, ueberschreibt alles
+
+     Wird eine Closure als Argument gegeben, wird sie im Fehlerfall
+     (also erst wenn ein Kommando endgueltig fehlgeschlagen hat)
+     ausgefuehrt und hat die Fehlermeldung als Resultat
+     zurueckzugeben. Die Closure erhaelt als Argument den
+     originalen Befehlsgeber; in der Regel dies ist this_player(),
+     was aber vom MODIFY_CMD hook geaendert werden kann.
+
+     notify_fail() erkennt verschachtelte Kommandos (siehe Efun
+     command()), und ein notify_fail() in einem Unterkommando
+     hat keinen Einfluss auf das uebergeordnete Kommando.
+
+BEMERKUNGEN:
+     - solange man sich nicht absolut sicher ist, dass ein bestimmtes Objekt
+       mit dem Kommando gemeint ist (Identifikation ueber id()), sollte man
+       - notify_fail(str); return 0;
+       nutzen anstatt mit
+       - write(str) return 1;
+       die Kommandoauswertung abzubrechen (und anderen Objekten die Chance
+       zu nehmen das Kommando zu erfuellen)
+     - Kommandos werden uebrigens oft erst vom betretenen Raum, dann von den
+       Objekten abgearbeitet (je nachdem wann diese dazukamen)
+     - die Prioritaet wird momentan nicht gespeichert, sie ist nur beim Setzen
+       relevant. Will spaeter ein anderes Objekt eine Meldung setzen, wird
+       fuer das eigene Objekt die Standardprioritaet ermittelt, auch wenn man
+       eine andere hier uebergeben hat
+     - Die NF_NL_* sind in /sys/notify_fail.h defniert.
+
+BEISPIELE:
+     Ein Raum erwartet die korrekte Eingabe von 'iss suppe':
+
+     int iss_cmd(string str){
+       // zu Anfang der Funktion das notify_fail definieren
+       notify_fail("Moechtest Du vielleicht von der Suppe essen?\n");
+
+       // Spieler hat nur 'iss' ohne Parameter eingegeben oder einen anderen
+       // Parameter angegeben ... Abbruch!
+       // Falls kein weiteres Objekt das Kommando erfuellt oder das
+       // notify_fail() mit einer eigenen Meldung ueberschreibt, wird obige
+       // Meldung an den Spieler ausgegeben.
+
+       if(!str || str!="suppe") return 0;
+       // ab hier ist die Eingabe dann wirklich 'suppe' und die Funktion
+       // kann beliebig fortgefuehrt werden
+       ...
+       return   1;
+
+SIEHE AUCH:
+     add_action(E), AddCmd(L), AddAction(L),
+     query_verb(E), query_notify_fail(E)
+
+8.Aug 2007 Gloinson
diff --git a/doc/sefun/object_info b/doc/sefun/object_info
new file mode 100644
index 0000000..3945651
--- /dev/null
+++ b/doc/sefun/object_info
@@ -0,0 +1,129 @@
+DEPRECATED
+SYNOPSIS
+        #include <objectinfo.h>
+
+        mixed * object_info(object ob, int what)
+        mixed * object_info(object ob, int what, int index)
+
+DESCRIPTION
+        Returns some internal information about object <ob>, collected
+        in an array. Argument <what> determines which information is
+        returned.
+
+        The result is usually an array. However, if <index> is specified,
+        the result is the value from position <index> of the array which
+        would have been returned normally.
+
+        The possible values of <what>, and the indices of the returned
+        arrays are defined in the include file <objectinfo.h>, and may
+        change in future versions of the driver!
+
+
+        <what> == OINFO_BASIC:
+
+          This call returns basic information about <ob>:
+
+          int [OIB_HEART_BEAT]:       1 if <ob> has a heart_beat, 0 else.
+          int [OIB_IS_WIZARD]:        1 if <ob> has the wizard flag set,
+                                        0 else.
+            This entry is always 0 when set_is_wizard() is not available.
+          int [OIB_ENABLE_COMMANDS]:  1 if <ob> can give commands, 0 else.
+          int [OIB_CLONE]:            1 if <ob> is a clone, 0 else.
+          int [OIB_DESTRUCTED]:       1 if <ob> is destructed, 0 else.
+          int [OIB_SWAPPED]:          1 if <ob> is swapped, 0 else.
+          int [OIB_ONCE_INTERACTIVE]: 1 if <ob> was once interactive, 0 else.
+          int [OIB_RESET_STATE]:      1 if <ob> is (still) reset, 0 else.
+          int [OIB_WILL_CLEAN_UP]:    1 if <ob> will call clean_up(), 0 else.
+          int [OIB_LAMBDA_REFERENCED]: 1 if <ob> has lambdas, 0 else.
+          int [OIB_SHADOW]:           1 if <ob> has a shadow structure tied
+                                        to it, 0 if not.
+          int [OIB_REPLACED]:         1 if the program for <ob> was replaced,
+                                      0 else.
+          int [OIB_NEXT_RESET]:   time of the next reset
+          int [OIB_TIME_OF_REF]:  time of the last call to <ob>
+          int [OIB_NEXT_CLEANUP]: time of the next data cleanup
+          int [OIB_REF]:          number of references to <ob>
+          int [OIB_GIGATICKS] and [OIB_TICKS]: together, these numbers
+            give the accumulated evaluation cost spend in <ob>
+          int [OIB_SWAP_NUM]:     the swap number for <ob>s program,
+                                  or -1 if not swapped.
+          int [OIB_PROG_SWAPPED]: 1 if <ob>'s program is swapped, 0 else.
+          int [OIB_VAR_SWAPPED]:  1 if <ob>'s variables are swapped, 0 else.
+          int [OIB_NAME]:         <ob>'s object name.
+          int [OIB_LOAD_NAME]:    <ob>'s load name.
+          object [OIB_NEXT_ALL]:  next object in the object list.
+          object [OIB_PREV_ALL]:  previous object in the object list.
+
+
+        <what> == OINFO_POSITION:
+
+          This call returns information about <ob>'s position in the
+          global list of objects:
+
+          object [OIP_NEXT]: next object in the object list.
+          object [OIP_PREV]: previous object in the object list.
+          int    [OIP_POS]:  position of <ob> in list, counting from 0 up.
+
+          This call can be expensive in computing time.
+
+
+        <what> == OINFO_MEMORY:
+
+          This call returns information about the program <ob> uses:
+
+          int    [OIM_REF]:            number of references to the program.
+          string [OIM_NAME]:           name of program.
+          int    [OIM_PROG_SIZE]:      size of the program.
+          int    [OIM_NUM_FUNCTIONS]:  number of functions in the program.
+          int    [OIM_SIZE_FUNCTIONS]: size needed for the function structs.
+          int    [OIM_NUM_VARIABLES]:  number of variables in the program.
+          int    [OIM_SIZE_VARIABLES]: size needed for the variable structs.
+          int    [OIM_NUM_STRINGS]:    number of strings in the program.
+          int    [OIM_SIZE_STRINGS]:   size needed for the string pointers.
+          int    [OIM_SIZE_STRINGS_DATA]: size needed for the string data,
+                                       scaled down according to the extend of
+                                       data sharing.
+          int    [OIM_SIZE_STRINGS_TOTAL]: unmodified size needed for the
+                                       string data.
+          int    [OIM_NUM_INCLUDES]:   number of included files in the program.
+          int    [OIM_NUM_INHERITED]:  number of inherited programs.
+          int    [OIM_SIZE_INHERITED]: size needed for the inherit structs.
+          int    [OIM_TOTAL_SIZE]:     total size of the program.
+          int    [OIM_DATA_SIZE]:      total size of the values held in the
+                                       object's variables, scaled down
+                                       according to the extend of data
+                                       sharing.
+          int    [OIM_DATA_SIZE_TOTAL]: unmodified total size of the values
+                                       held in the object's variables
+          int    [OIM_NO_INHERIT]:     1 if the program can't be inherited.
+          int    [OIM_NO_CLONE]:       1 if the program/blueprint can't be
+                                       cloned.
+          int    [OIM_NO_SHADOW]:      1 if the program's functions can't be
+                                       shadowed.
+          int    [OIM_SHARE_VARIABLES]:  1 if clones of this program share
+                                       their initial variable values with
+                                       the blueprint.
+
+          This call swaps in the program if necessary.
+          Note that the OIM_SIZE_xxx entries only give the size spent on
+          the structures and pointers, not the size of the variable data,
+          function code, and strings themselves.
+
+HISTORY
+        Introduced in LDMud 3.2.6.
+        Changes in LDMud 3.2.7:
+          - new basic result OIB_REPLACED.
+          - basic result OIB_IS_WIZARD is always 0 if set_is_wizard()
+              is not available.
+          - basic result OIB_APPROVED is gone.
+        LDMud 3.2.8 added OIM_DATA_SIZE to the result of OINFO_MEMORY.
+        LDMud 3.2.9 added the index mechanism, OIM_NUM_INCLUDES,
+          OIM_NO_INHERIT, OIM_NO_SHADOW, OIM_NO_CLONE, OIM_SIZE_STRINGS_DATA,
+          OIM_SIZE_STRINGS_TOTAL, and OIM_DATA_SIZE_TOTAL to the result
+          of OINFO_MEMORY.
+        LDMud 3.3.378 added the OIM_SHARE_VARIABLES to the result
+          of OINFO_MEMORY.
+        LDMud 3.3.654 added the OIB_NEXT_CLEANUP to the result of OINFO_BASIC.
+
+SEE ALSO
+        debug_info(E)
diff --git a/doc/sefun/obsolete/exclude_alist b/doc/sefun/obsolete/exclude_alist
new file mode 100644
index 0000000..a967a14
--- /dev/null
+++ b/doc/sefun/obsolete/exclude_alist
@@ -0,0 +1,4 @@
+SYNOPSIS:
+	mixed *exclude_alist(int i, mixed *alist)
+
+Remove element i from alist.
diff --git a/doc/sefun/obsolete/remove_alist b/doc/sefun/obsolete/remove_alist
new file mode 100644
index 0000000..cf9bc61
--- /dev/null
+++ b/doc/sefun/obsolete/remove_alist
@@ -0,0 +1,3 @@
+mixed *remove_alist(mixed key, mixed *alist)
+
+Removes element associated by key key from alist.
diff --git a/doc/sefun/old_explode b/doc/sefun/old_explode
new file mode 100644
index 0000000..6b13d8e
--- /dev/null
+++ b/doc/sefun/old_explode
@@ -0,0 +1,28 @@
+FUNKTION:
+	string *old_explode(string str, string del)
+
+ARGUMENTE:
+	str - Der String, der aufgespaltet werden soll.
+	del - Der String, nach dem str aufgespalten werden soll.
+
+BESCHREIBUNG:
+	Durch Ausschneiden von del wird der String str in ein Array von Strings
+	zerlegt. Dieses Array wird anschliessend zuruckgegeben.
+
+RUECKGABEWERT:
+	Das Array mit den Bestandteilen der Zerlegung.
+
+BEMERKUNGEN:
+	Das Verhalten von old_explode() entspricht dem dem explode()-Verhalten,
+	das in /doc/efun/explode als "altes" Verhalten bezeichnet wird, d.h.
+	Leerstrings an Anfang und Ende des zerlegten Strings werden entfernt!
+
+BEISPIELE:
+	strs = explode( "nimm alles", " "); => strs = ({ "nimm", "alles" })
+	strs = explode( "abc", "abc" );     => strs = ({ })
+	strs = explode( "ein test", "" );   => strs = ({ "ein test" })
+	strs = explode( "a b", "a");        => strs = ({ " b" });
+
+SIEHE AUCH:
+	explode(E), new_explode(E), efun::explode(E), sscanf(E)
+        implode(E), regexplode(E)
diff --git a/doc/sefun/process_call b/doc/sefun/process_call
new file mode 100644
index 0000000..c00a039
--- /dev/null
+++ b/doc/sefun/process_call
@@ -0,0 +1,21 @@
+simul_efun::process_call(E)
+FUNKTION:
+     int process_call()
+
+BESCHREIBUNG:
+     Gibt zurueck, ob die Ausfuehrung zum derzeitigen Zeitpunkt durch
+     process_string() ausgerufen wurde.
+
+BEISPIELE:
+     process_string("@@current_long@@");
+     ...
+     string current_long() {
+      if(process_call())
+       return("Dieser String wurde durch ein process_string eingefuegt.");
+      else return("Du hast die Funktion direkt gerufen!");
+     }
+
+SIEHE AUCH:
+     notify_fail(E), process_string(E), replace_personal(E)
+
+28. Maerz 2004 Gloinson
diff --git a/doc/sefun/process_string b/doc/sefun/process_string
new file mode 100644
index 0000000..75c9290
--- /dev/null
+++ b/doc/sefun/process_string
@@ -0,0 +1,57 @@
+process_string(E)
+FUNKTION:
+     string process_string(string str)
+     string process_string(closure cl)
+
+BESCHREIBUNG:
+     Durchsucht den String str nach Vorkommnissen von Substrings, die "Wert
+     durch Funktionsaufruf zu ersetzen" andeuten. Die Form ist: @@, gefolgt
+     durch einen impliziten Funktionsaufruf.
+
+     Der zu ersetzenden Substring hat die Form:
+     @@function[:filename][|argument1|argument2]@@
+
+     Die entsprechende Funktion muss einen String zurueckgeben, oder der
+     process_string() uebergebene String str wird nicht modifiziert.
+
+     process_string() arbeitet nicht rekursiv, object_name und argument sind
+     optionale Werte.
+
+     Falls eine Closure angegeben wurde, wird diese lediglich gerufen
+     und nicht gefiltert.
+
+ANMERKUNGEN:
+     - Die Funktion, die gerufen werden soll, _muss_ mit einem Buchstaben
+		   anfangen, '_' ist nicht moeglich!
+     - folgendes Properties und Details werden bei der Abfrage ueber
+       process_string() gefiltert:
+       P_LONG, P_SHORT, P_READ_MSG, AddReadDetail()-Details und NPC-Chats
+       P_INT_LONG ueber int_long(), P_INT_SHORT ueber int_short()
+     - die Nutzung kann zu Sicherheitsproblemen fuehren, siehe auch
+       process_call()
+
+BEISPIEL:
+     // komplette Ersetzung ...
+     SetProp(P_LONG,"@@current_long@@");
+     ...
+     string current_long() {
+      if(x) return(break_string("Die Beschreibung."));
+      else return(break_string("Die andere Beschreibung."));
+     }
+
+     -> bei Abfrage: "Die Beschreibung." oder "Die andere Beschreibung."
+
+
+     // Teilersetzung
+     SetProp(P_SHORT, "Ein @@farbenfun|huebsch@@ Ding");
+     ...
+     string farbenfun(string str) {
+      return(str+" "+"gelbes");
+     }
+
+     -> bei Abfrage: "Ein huebsch gelbes Ding."
+
+SIEHE AUCH:
+     notify_fail(E), process_call(E), replace_personal(E)
+
+22. Nov. 2006 Arathorn
diff --git a/doc/sefun/query_editing b/doc/sefun/query_editing
new file mode 100644
index 0000000..010c98e
--- /dev/null
+++ b/doc/sefun/query_editing
@@ -0,0 +1,13 @@
+DEPRECATED
+SYNOPSIS
+        mixed query_editing(object ob);
+
+BESCHREIBUNG
+        Liefert 1, wenn <ob> interaktiv ist (das heisst, es gibt einen realen
+        Benutzer mit einer Socketverbindung zum Mud) und gerade mit ed() eine
+        Datei bearbeitet. Wenn ed() mit einem Funktionsnamen als zweites
+        Argument aufgerufen wird, wird das Objekt, aus dem ed() aufgerufen
+        wurde, geliefert, sonst 0.
+
+SIEHE AUCH
+        ed(E)
diff --git a/doc/sefun/query_idle b/doc/sefun/query_idle
new file mode 100644
index 0000000..7c0a0a5
--- /dev/null
+++ b/doc/sefun/query_idle
@@ -0,0 +1,8 @@
+SYNOPSIS
+        int query_idle(object ob);
+
+BESCHREIBUNG
+        Gibt an, seit wie vielen Sekunden ein Player Objekt <ob> idle ist.
+
+SIEHE AUCH
+        interactive(E)
diff --git a/doc/sefun/query_input_pending b/doc/sefun/query_input_pending
new file mode 100644
index 0000000..8033cec
--- /dev/null
+++ b/doc/sefun/query_input_pending
@@ -0,0 +1,11 @@
+DEPRECATED
+SYNOPSIS
+        object query_input_pending(object ob);
+
+BESCHREIBUNG
+        Wenn <ob> interaktiv und ein input_to() haengig ist, so liefert die
+        Efun das Objekt zurueck, welches den input_to() aufgerfuen hat. Ist
+        kein input_to() haengig, liefert die Funktion 0.
+
+SIEHE AUCH
+        input_to(E), find_input_to(E), input_to_info(E), remove_input_to(E)
diff --git a/doc/sefun/query_ip_name b/doc/sefun/query_ip_name
new file mode 100644
index 0000000..d16298f
--- /dev/null
+++ b/doc/sefun/query_ip_name
@@ -0,0 +1,12 @@
+GESCHUETZT
+SYNOPSIS
+        string query_ip_name(object ob);
+
+BESCHREIBUNG
+        Liefert den IP-Namen des Users <ob> oder des aktuellen Benutzers, wenn
+        <ob> nicht angegeben wurde. Der IP-Name wird durch den asynchronen
+        Prozess hname ermittelt. Wenn der IP-Name nicht ermittelt werden kann,
+        liefert query_ip_name() die IP-Nummer zurueck.
+
+SIEHE AUCH
+        query_ip_number(E)
diff --git a/doc/sefun/query_ip_number b/doc/sefun/query_ip_number
new file mode 100644
index 0000000..a462aba
--- /dev/null
+++ b/doc/sefun/query_ip_number
@@ -0,0 +1,24 @@
+GESCHUETZT
+SYNOPSIS
+        string query_ip_number(object ob);
+        string query_ip_number(mixed & ob);
+
+BESCHREIBUNG
+        Liefert die IP-Nummer des Benutzers <ob> oder des aktuellen Benutzers,
+        wenn <ob> nicht angegeben wurde.
+
+        Wenn <ob> als Referenz angegeben wird (dann muss es ein gueltiges
+        Objekt sein), wird dieses bei der Ausgabe auf die struct sockaddr_in
+        gesetzt. struct sockaddr_in ist ein Integer-Array, mit einem Integer
+        pro Adressbyte:
+
+            ob[0 .. 1] : sin_family
+            ob[2 .. 3] : sin_port
+            ob[4 .. 7] : sin_addr
+            ob[8 ..15] : nicht definiert.
+
+AENDERUNGEN
+        Die Rueckgabe von struct sockaddr_in wurde in 3.2.1@81 eingefuehrt.
+
+SIEHE AUCH
+        query_ip_name(E)
diff --git a/doc/sefun/query_limits b/doc/sefun/query_limits
new file mode 100644
index 0000000..954577a
--- /dev/null
+++ b/doc/sefun/query_limits
@@ -0,0 +1,56 @@
+DEPRECATED
+SYNOPSIS
+        #include <sys/rtlimits.h>
+
+        int *query_limits();
+        int *query_limits(int default);
+
+BESCHREIBUNG
+        Liefert ein Array mit den momentan gueltigen Laufzeit Limiten bzw.
+        die standardmaessigen Laufzeit Limiten, wenn <default> wahr ist.
+        Die Eintraege im gelieferten Array bedeuten:
+
+        int[LIMIT_EVAL]:        die maximalen Eval Kosten
+        int[LIMIT_ARRAY]:       die maximale Anzahl Array Eintraege
+        int[LIMIT_MAPPING]:     die maximale Anzahl Mapping Eintraege
+        int[LIMIT_BYTE]:        die maximale Anzahl Bytes, die mit read_bytes()
+                                /write_bytes() bearbeitet werden koennen
+        int[LIMIT_FILE]:        die maximale Anzahl Bytes, die mit read_file()
+                                /write_file() bearbeitet werden koennen
+        int[LIMIT_CALLOUTS]:    die maximale Anzahl gleichzeitiger call_out()s
+        int[LIMIT_COST]:        wie die aktuellen Kosten einzurechnen sind
+
+        Ausser fuer LIMIT_COST ein Limit von '0' (auch LIMIT_UNLIMITED)
+        bedeutet 'keine Limit'.
+
+        LIMIT_COST hat diese Bedeutungen:
+          
+          wert > 0: Maximal <wert> fuer als Kosten fuer die aktuelle Ausfuehrung
+                    verwendet, ungeachtet wie lange sie tatsaechlich dauert.
+               = 0: ist die derzeite LIMIT_EVAL groesser als die vorherige
+                    LIMIT_EVAL, kostet die aktuelle Ausfuehrung nur 10
+                    Ticks; andernfalls werden die gesamten Kosten angerechnet.
+                < 0: (-wert)% der aktuellen Ausfuehrungskosten werden
+                     angerechnet.
+
+BEMERKUNGEN:
+        "Aktuelle Kosten" bei LIMIT_COST hat im Falle der Benutzung von
+        limited() die Bedeutung von "im limited verbrauchte Kosten", steuert
+        also, wieviel der im Durchlaufen der Funktion im limited()
+        verbrauchten Ticks mit dem Ende von limited() angezogen wird.
+
+BEISPIELE
+        query_limits()
+        --> liefert die momentan gueltigen Laufzeit Limiten.
+        query_limits(1)
+        --> liefert die standardmaessigen Laufzeit Limiten.
+
+AENDERUNGEN
+        Eingefuehrt in LDMud 3.2.7.
+        LIMIT_CALLOUTS wurde in LDMud 3.2.9 eingefuehrt.
+
+SIEHE AUCH
+        limited(E), set_limits(E)
+
+16.05.2007, Zesstra
+
diff --git a/doc/sefun/query_mud_port b/doc/sefun/query_mud_port
new file mode 100644
index 0000000..2e5c6d2
--- /dev/null
+++ b/doc/sefun/query_mud_port
@@ -0,0 +1,23 @@
+DEPRECATED
+SYNOPSIS
+        int query_mud_port(void)
+        int query_mud_port(object user)
+        int query_mud_port(int num)
+
+DESCRIPTION
+        Returns the port number the parser uses for user connections.
+
+        If no argument is given, the port for this_player() is
+        returned. If this_player() is not existing or not interactive,
+        the first port number open for connections is returned.
+
+        If an user object is given, the port used for its connection
+        is returned.
+        If a positive number is given, the <num>th port number the
+        parser uses for connections is returned (given that there are
+        that many ports).
+        If -1 is given, the number of ports open for connections is
+        returned.
+
+SEE ALSO
+        query_udp_port(E)
diff --git a/doc/sefun/query_next_reset b/doc/sefun/query_next_reset
new file mode 100644
index 0000000..03bbd7e
--- /dev/null
+++ b/doc/sefun/query_next_reset
@@ -0,0 +1,27 @@
+simul_efun::query_next_reset(E)
+FUNKTION:
+     varargs int query_next_reset(object ob)
+
+ARGUMENTE:
+     ob - das interessierende Objekt; wenn nicht angegeben, wird 
+          this_object() verwendet
+
+BESCHREIBUNG:
+     Diese sefun gibt den Zeitpunkt des naechsten Resets des Objektes ob 
+     zurueck. Die Angabe erfolgt in Sekunden, die seit dem 01. Januar 1970 
+     00:00:00 GMT verstrichen sind, analog zu time().
+
+     In der Regel erfolgt der Reset im naechsten Backend-Zyklus nach dem 
+     Faelligkeitszeitpunkt,  d.h. momentan in den nachfolgenden 2s.
+     Allerdings kann dies auch mal nen Zyklus laenger dauern (4s), wenn der
+     Driver viel zu tun hat.
+
+BEMERKUNGEN:
+     Diese sefun ist object_info()-Abfragen vorzuziehen, da die Parameter und
+     Rueckgabewerte von object_info() bei verschiedenen Gamedriverversionen
+     variieren koennen.
+
+SIEHE AUCH:
+     call_out(E), object_info(E), reset(L), set_next_reset(E), time(E)
+
+28.07.2014 Arathorn
diff --git a/doc/sefun/query_once_interactive b/doc/sefun/query_once_interactive
new file mode 100644
index 0000000..c794223
--- /dev/null
+++ b/doc/sefun/query_once_interactive
@@ -0,0 +1,8 @@
+SYNOPSIS
+        int query_once_interactive(object obj);
+
+BESCHREIBUNG
+        Wahr, wenn <obj> interaktiv ist oder dies einmal war.
+
+SIEHE AUCH
+        remove_interactive(E)
diff --git a/doc/sefun/query_shadowing b/doc/sefun/query_shadowing
new file mode 100644
index 0000000..3ce5d6a
--- /dev/null
+++ b/doc/sefun/query_shadowing
@@ -0,0 +1,18 @@
+DEPRECATED
+query_shadowing(E)
+FUNKTION:
+     object query_shadowing(object obj)
+
+BESCHREIBUNG:
+     Die Funktion gibt das derzeit vom Objekt <obj> beschattete Objekt
+     victim oder 0 zurueck.
+
+BEISPIELE:
+     // B beschattet A
+     query_shadowing(find_object(B)) == A
+
+SIEHE AUCH:
+     Generell:	     shadow(E), unshadow(E)
+     Rechte:	     query_allow_shadow(M), query_prevent_shadow(L)
+
+23.02.2016, Zesstra
\ No newline at end of file
diff --git a/doc/sefun/query_snoop b/doc/sefun/query_snoop
new file mode 100644
index 0000000..4da8838
--- /dev/null
+++ b/doc/sefun/query_snoop
@@ -0,0 +1,10 @@
+DEPRECATED
+SYNOPSIS
+        object query_snoop(object victim)
+
+DESCRIPTION
+        Returns the user who currently snoops victim. The calling
+        object must be privileged by the master object.
+
+SEE ALSO
+        snoop(E)
diff --git a/doc/sefun/query_wiz_grp b/doc/sefun/query_wiz_grp
new file mode 100644
index 0000000..c45cfe1
--- /dev/null
+++ b/doc/sefun/query_wiz_grp
@@ -0,0 +1,15 @@
+FUNKTION:
+        query_wiz_grp(string wiz)
+        query_wiz_grp(object wiz)
+
+ARGUMENTE:
+        wiz - Spieler, dessen Magierlevelgruppe ermittelt werden soll
+
+BESCHREIBUNG:
+        Diese Funktion ermittelt die Magiergruppe, der der Spieler wiz angehoert.
+
+RUECKGABEWERT:
+        Die Magierlevelgruppe des Spielers.
+
+SIEHE AUCH:
+        /secure/wizlevels.h
diff --git a/doc/sefun/query_wiz_level b/doc/sefun/query_wiz_level
new file mode 100644
index 0000000..03e89cb
--- /dev/null
+++ b/doc/sefun/query_wiz_level
@@ -0,0 +1,43 @@
+FUNKTION:
+	int query_wiz_level(object ob)
+	int query_wiz_level(string ob)
+
+ARGUMENTE:
+	ob - Der Spieler/das Objekt, dessen Magierlevel ermittelt werden soll.
+       Es kann auch eine UID (z.B. "zesstra", "d.inseln.zesstra") als String
+       uebergeben werden.
+
+BESCHREIBUNG:
+	query_wiz_level() liefert den Magierlevel des Objekts ob zurueck.
+	Normale Spieler haben einen Magierlevel von 0, Seher normalerweise
+  einen von 1 (auf jeden Fall < 10).
+  Objekte bekommen folgende Level:
+  /d/           - 25
+  /p/           - 21
+  /obj/         - 0
+  /std/         - 0
+  /gilden/      - 30
+  /spellbooks/  - 30
+  /players/     - entsprechend Magier, 20 - 111
+  /secure/      - 100
+
+RUECKGABEWERT:
+	Der Magierlevel des Spielers/Objekts.
+
+BEMERKUNGEN:
+	Wird als Parameter ein String mit einem Spielernamen uebergeben, so 
+	kann auch der Magierlevel eines nicht eingeloggten Spielers heraus-
+	gefunden werden.
+
+BEISPIELE:
+	lv = query_wiz_level(find_player("jof"))
+	   => lv = 111, falls Jof eingeloggt ist.
+	lv = query_wiz_level("jof")
+           => lv = 111 in jedem Fall.
+
+SIEHE AUCH:
+	/secure/wizlevels.h
+
+LETZTE AeNDERUNG:
+15.10.2007, Zesstra
+
diff --git a/doc/sefun/replace_personal b/doc/sefun/replace_personal
new file mode 100644
index 0000000..2a18dc7
--- /dev/null
+++ b/doc/sefun/replace_personal
@@ -0,0 +1,84 @@
+FUNKTION:
+     varargs string replace_personal(string str, mixed *obs [, int caps]);
+
+DEFINIERT IN:
+     /secure/simul_efun.c
+
+ARGUMENTE:
+     str    - zu bearbeitender String
+     obs    - Liste von Objekt1, Objekt2, ..., Objekt9
+              (Objekte oder Strings)
+     caps   - 1 fuer Grossschreibung des Ersetzten nach Satzenden (.,?,!,")
+              0 sonst
+
+BESCHREIBUNG:
+     Ersetzt in Strings
+     @WERx, @WESSENx, @WEMx, @WENx durch
+        Objectx->name(<casus>, 1);
+     @WERUx, @WESSENUx, @WEMUx, @WENUx durch
+        Objectx->name(<casus>);
+     @WERQPx, @WESSENQPx, @WEMQPx, @WENQPx durch
+        Objectx->QueryPronoun(<casus>);
+     @WERQAx, @WESSENQAx, @WEMQAx, @WENQAx durch
+        Objectx->QueryArticle(<casus>, 1, 1);
+     @WERQPPGNx, @WESSENQPPGNx, @WEMQPPGNx, @WENQPPGNx durch
+        Objectx->QueryPossPronoun(<gender>, <casus>, <number>);
+     oder den entsprechenden String bei "Objektx".            
+
+BEMERKUNGEN:
+     x steht fuer die Position des Objekts/Strings in *obs, beginnend bei 1.
+     
+     Besonderheiten beim Possessivpronomen (@WERQPPGNx):
+     G muss durch das Geschlecht (M, F oder N) und N durch den Numerus (S 
+     oder P) ersetzt werden. 
+     Alle Angaben, auch der CASUS, beziehen sich dabei auf das Objekt, welches
+     besessen wird, nicht auf den Besitzer! Dieser ist bereits durch x 
+     bestimmt.
+     
+RUeCKGABEWERT:
+     durchersetzter String 
+     
+Beispiele:
+
+     replace_personal("@WER1", ({find_player("gloinson")}))
+     == "Gloinson"
+     
+     replace_personal("@WEMQP1", ({find_player("gloinson")}))
+     == "ihm"     
+     
+     // unbestimmter und bestimmter Artikel:
+     replace_personal("@WER1 zueckt @WENU2 und verhaut @WEN3.", 
+                      ({find_player("gloinson"),
+                        find_object("/obj/mpa"), 
+                        find_object("/obj/wanderer")}))
+     == "Gloinson zueckt eine Zeitung und verhaut den Wanderer."
+     
+     // Beim Possessivpronomen beziehen sich WEN, F und P (Akkusativ,
+     // Femininum, Plural) auf die Taschen, nicht auf Kessa:
+     replace_personal("@WER1 steckt @WESSEN2 Turnschuhe in @WENQPPFP1 "
+                      "Taschen.", 
+                      ({find_player("kessa"), 
+                        find_player("gloinson")}))
+     == "Kessa steckt Gloinsons Turnschuhe in ihre Taschen."
+
+     // Ein Beispiel mit laengerem *obs:
+     replace_personal("@WER1 zieht @WENQPPMP1 neuen Turnschuhe an. @WER2 ist "
+                      "so beeindruckt, dass @WERQP2 @WEMQP1 @WENU3 auf die "
+                      "@WEN4 haut und die Schuhe in @WEMQPPFS2 Tasche "
+                      "verschwinden laesst. @WERU5 schaut zu und kichert "
+                      "irre. Wenn das @WER6 gesehen haette!",
+                      ({find_player("gloinson"), 
+                        find_player("kessa"),
+                        find_object("/obj/mpa"),                        
+                        "Birne",
+                        find_object("/obj/wanderer"),
+                        find_netdead("jof")}),1)
+     == "Gloinson zieht seine neuen Turnschuhe an. Kessa ist so beeindruckt, "
+        "dass sie ihm eine Zeitung auf die Birne haut und die Schuhe in ihrer "
+        "Tasche verschwinden laesst. Ein Wanderer schaut zu und kichert "
+        "irre. Wenn das Jof gesehen haette!"
+
+SIEHE AUCH:
+     AddCmd(L)
+
+05. September 2015, Arathorn
diff --git a/doc/sefun/save_object b/doc/sefun/save_object
new file mode 100644
index 0000000..b1743b1
--- /dev/null
+++ b/doc/sefun/save_object
@@ -0,0 +1,19 @@
+SYNOPSIS
+        mixed save_object(string name);
+
+BESCHREIBUNG
+        Diese Simul-Efun unterscheidet sich in einigen Details von der
+        Driver-Efun save_object() (s. auch dort! Wichtig!).
+        1. diese sefun speichert auch die mit F_SAVE markierten Properties
+        eines Objektes ab (was die efun des Driver nicht tut!).
+        2. das Format, in dem gespeichert wird, kann bei der sefun nicht
+        ausgewaehlt werden (ist aber auch nicht noetig!), sondern ein
+        mudlib-weiter Standard wird benutzt.
+        3. will man nicht in einem File speichern, sondern das, was im File
+        stehen wurde, als String zurueckhaben, muss man 0 als 'name'
+        uebergeben.
+
+SIEHE AUCH
+        save_object(E), restore_object(E), save_value(E)
+03.08.2007, Zesstra
+
diff --git a/doc/sefun/send_room b/doc/sefun/send_room
new file mode 100644
index 0000000..24b05fa
--- /dev/null
+++ b/doc/sefun/send_room
@@ -0,0 +1,30 @@
+FUNKTION:
+varargs void send_room(object|string room, string msg, int msg_type,
+                       string msg_action, string msg_prefix,
+                       object *exclude, object origin)
+
+BESCHREIBUNG:
+        Sendet msg an alle Objekte in room durch Aufruf von ReceiveMsg() mit
+        den uebergebenen Argumenten.
+        Zur Bedeutung der Argumente siehe Manpage von ReceiveMsg().
+
+        Wenn das Raumobjekt mit seinem Namen angegeben ist, wird das Objekt
+        unter diesem Namen gesucht und und geladen, falls notwendig.
+
+        Mit dem Array <*exclude> kann man verhindern, dass die Nachricht an
+        die darin enthaltenen Objekte gesendet wird.
+        Das ist sinnvoll, wenn zB ein Spieler Ausloeser einer Meldung ist
+        und diese selbst nicht erhalten soll.
+
+        origin gibt an, welches Objekt die Meldung ausloest (muss nicht das
+        sendende Objekt selber) und wird vor allem fuer die Ignorierepruefung
+        verwendet. Default ist das sendende Objekt.
+
+        Letztendlich ist die sefun vergleichbar zu tell_room().
+
+SIEHE AUCH
+        ReceiveMsg(L)
+        tell_object(E), tell_room(E), say(E), write(E)
+
+13.03.2016, Zesstra
+
diff --git a/doc/sefun/set_heart_beat b/doc/sefun/set_heart_beat
new file mode 100644
index 0000000..837759e
--- /dev/null
+++ b/doc/sefun/set_heart_beat
@@ -0,0 +1,23 @@
+SYNOPSIS
+        int set_heart_beat(int flag);
+
+BESCHREIBUNG
+        Schaltet den Heartbeat ein (1) oder aus (0). Der Treiber wendet die
+        Lfun heart_beat() auf das aktuelle Objekt alle __HEARTBEAT_INTERVAL__
+        Sekunden an, wenn der Heartbeat eingeschaltet ist. Ein Shadow
+        auf der Lfun wird ignoriert.
+        
+        Der Heartbeat sollte immer ausgeschaltet werden, wenn er nicht
+        gebraucht wird. Das reduziert die Systemauslastung.
+
+        Liefert '1' bei Erfolg, '0' bei Fehler.
+
+        Das Abschalten eines bereits abgeschalteten Heartbeats (und umgekehrt
+        das Einschalten eines bereits eingeschalteten Heartbeats) zaehlt
+        als Fehler.
+
+BEMERKUNGEN
+        __HEARTBEAT_INTERVAL__ ist in MG = 2 Sekunden
+
+SIEHE AUCH
+        heart_beat(A), call_out(E)
diff --git a/doc/sefun/set_light b/doc/sefun/set_light
new file mode 100644
index 0000000..62390c4
--- /dev/null
+++ b/doc/sefun/set_light
@@ -0,0 +1,17 @@
+SYNOPSIS:
+        int set_light(int n)
+
+DESCRIPTION:
+        An object is by default dark. It can be set to not dark by
+        calling set_light(1). The environment will then also get this
+        light. The returned value is the total number of lights in
+        this room. So if you call set_light(0) it will return the
+        light level of the current object.
+        
+        Note that the value of the argument is added to the light of
+        the current object.
+
+BUGS:
+	This handling of light by the parser is inappropriate for most
+	purposes: If you put a burning candle into a safe, the safe
+	will start to emit light.
diff --git a/doc/sefun/set_living_name b/doc/sefun/set_living_name
new file mode 100644
index 0000000..360a3ce
--- /dev/null
+++ b/doc/sefun/set_living_name
@@ -0,0 +1,25 @@
+SYNOPSIS:
+        void set_living_name(string name)
+
+BESCHREIBUNG:
+        Setzt einen "Lebewesennamen" fuer das Objekt, indem Name und Objekt in
+        eine Tabelle eingetragen werden, welche von find_living() durchsucht 
+        wird. Nach Setzen des Namens kann das Objekt per find_living() 
+        gefunden werden.
+
+        Das Objekt muss ausserdem per enable_commands() als Lebewesen
+        markiert worden sein. Dies ist fuer alle von /std/npc erbenden NPCs
+        _automatisch_ der Fall und sollte daher nicht nochmal explizit gemacht
+        werden.
+
+        Alle von /std/npc erbenden NPCs setzen ebenfalls automatisch einen
+        LivingName, der lower_case(P_NAME) entspricht.
+
+        Ein Objekt kann nur einen Namen haben, mit dem es per find_living()
+        gesucht werden kann.
+
+SIEHE AUCH:
+        find_living(E), find_livings(E), find_player(E), enable_commands(E)
+
+LETZTE AeNDERNG:
+19.10.2015, Arathorn
diff --git a/doc/sefun/set_object_heart_beat b/doc/sefun/set_object_heart_beat
new file mode 100644
index 0000000..a7ba4ef
--- /dev/null
+++ b/doc/sefun/set_object_heart_beat
@@ -0,0 +1,15 @@
+FUNKTION:
+        int set_object_heart_beat(object ob, int on)
+
+ARGUMENTE:
+        ob - Objekt, dessen heart_beat veraendert werden soll
+        on - Soll der heart_beat ein- oder ausgeschaltet werden?
+
+BESCHREIBUNG:
+        Der heart_beat des Objektes wird ein- (on=1) oder aus- (on=0) geschaltet.
+
+RUECKGABEWERT:
+        1, wenn das Setzen geklappt hat, ansonsten 0.
+
+SIEHE AUCH:
+        set_heart_beat(E), heart_beat(L), call_out(E)
diff --git a/doc/sefun/sha1 b/doc/sefun/sha1
new file mode 100644
index 0000000..00bb6cc
--- /dev/null
+++ b/doc/sefun/sha1
@@ -0,0 +1,22 @@
+DEPRECATED
+SYNOPSIS
+        string sha1 (string arg)
+        string sha1 (int *  arg)
+
+BESCHREIBUNG
+        Berechnet den SHA1-Hashwert von <arg>.
+        Das Argument kann ein String, oder ein Array von Zahlen sein (von
+        welchen nur das unterste Byte betrachted wird).
+
+BEISPIEL
+        string s;
+
+        s = sha1("Hello");
+        s = sha1( ({ 'H', 'e', 'l', 'l', 'o' })
+
+HISTORY
+        Eingefuehrt in LDMud 3.3.523.
+        LDMud 3.3.712 fuehrte Zaehlenarrays als Argument ein.
+
+SIEHE AUCH
+        crypt(E), md5(E)
diff --git a/doc/sefun/shadow b/doc/sefun/shadow
new file mode 100644
index 0000000..9309dea
--- /dev/null
+++ b/doc/sefun/shadow
@@ -0,0 +1,143 @@
+FUNKTION:
+     object shadow(object ob, int flag)
+
+ARGUMENTE:
+     object ob		- das vom shadow betroffene Objekt
+     int flag		- 0 fuer eine Shadow-Existenzabfrage
+                      1 fuer Shadow durch previous_object()
+
+BESCHREIBUNG:
+     Wenn <flag> nicht 0 ist, wird das aktuelle Objekt dem Objekt obj
+     als Shadow uebergeworfen. Bei Erfolg wird das geshadowte Objekt
+     zurueckgegeben, sonst 0.
+     Wenn <flag> 0 ist, wird entweder 0 oder das geshadowte Objekt
+     zurueck gegeben.
+
+     Wenn ein Objekt A ein Objekt B beschattet, werden alle call_other() fuer
+     B auf A umgeleitet. Wenn die an B gerufene Funktion in A existiert, so
+     wird sie in A gerufen, bei Nichtexistenz in B.
+     A ist das einzige Objekt, welche die beschatteten Funktionen mit 
+     call_other() in B aufrufen kann, selbst B kann nicht per call_other() 
+     diese Funktion rufen.
+     Alle intern verwendeten Funktionen arbeiten jedoch weiterhin normal.
+
+     Das aufrufende Objekt muss vom Master-Objekt die Erlaubnis haben,
+     als Shadow zu wirken.
+
+     Es gibt folgende Kriterien fuer eine erfolgreiche Beschattung:
+     - das zu beschattende Objekt ob:
+       - ist weder ein access_rights-Objekt noch ein ROOT-Objekt
+       - gibt beim Aufruf von query_prevent_shadow(beschatter) eine 0
+         zurueck
+       - beschattet selbst niemanden
+       - hat kein '#pragma no_shadow' gesetzt
+     - der Beschatter:
+       - wird nicht selbst (direkt) beschattet
+       - beschattet noch niemanden (sonst folgt direkter Abbruch)
+       - hat kein environment()
+       - definiert/beschattet keine Methode, die im beschatteten Objekt ob 
+         als nomask definiert ist
+
+     Beschattet man ein Objekt A mit einem Objekt B und dann das Objekt A
+     zusaetzlich mit einem Objekt C, so wird eine Beschattungshierarchie
+     erstellt:
+
+     B macht shadow(A, 1)
+     B->A
+     C macht shadow(A, 1)
+     C->B->A
+
+BEISPIELE:
+     // wenn: B beschattet A, dann
+     shadow(find_object(A), 0) == B
+
+
+     // 3 Objekte beschatten in Hierarchie (liegt auch im Pfad)
+     --- aa.c ---
+     void fun() {
+         printf("%O [a] fun()\n", this_object());
+     }
+
+     void fun3() {
+         printf("%O [a] fun3()\n", this_object());
+     }
+
+     --- bb.c ---
+     int fun() {
+         printf("%O [b] fun()\n", this_object());
+         find_object("/doc/beispiele/shadow/aa")->fun();
+     }
+
+     void fun2() {
+         printf("%O [b] fun2()\n", this_object());
+         find_object("/doc/beispiele/shadow/aa")->fun3();
+         this_object()->fun3();
+     }
+
+     void do_shadow(object target) { shadow(target, 1); }
+
+     --- cc.c ---
+     int fun() {
+         printf("%O [c] fun()\n", this_object());
+         find_object("/doc/beispiele/shadow/aa")->fun();
+     }
+
+     void fun3() {
+         printf("%O [c] fun3()\n", this_object());
+     }
+
+     void do_shadow(object target) { shadow(target, 1); }
+
+     // darauf arbeitender Code
+
+     object a, b, c;
+
+     destruct("/doc/beispiele/shadow/aa");
+     a = load_object("/doc/beispiele/shadow/aa");
+     destruct("/doc/beispiele/shadow/bb");
+     b = load_object("/doc/beispiele/shadow/bb");
+     destruct("/doc/beispiele/shadow/cc");
+     c = load_object("/doc/beispiele/shadow/cc");
+
+     b->do_shadow(a);
+     c->do_shadow(a);
+     printf("--- a->fun() ---\n");
+     a->fun();
+     printf("--- b->fun() ---\n");
+     b->fun();
+     printf("--- c->fun() ---\n");
+     c->fun();
+     printf("--- b->fun2() ---\n");
+     b->fun2();
+
+     // ... und seine Ausgabe:
+
+     --- a->fun() ---
+     /doc/beispiele/shadow/cc [c] fun()
+     /doc/beispiele/shadow/bb [b] fun()
+     /doc/beispiele/shadow/aa [a] fun()
+     --- b->fun() ---
+     /doc/beispiele/shadow/cc [c] fun()
+     /doc/beispiele/shadow/bb [b] fun()
+     /doc/beispiele/shadow/aa [a] fun()
+     --- c->fun() ---
+     /doc/beispiele/shadow/cc [c] fun()
+     /doc/beispiele/shadow/bb [b] fun()
+     /doc/beispiele/shadow/aa [a] fun()
+     --- b->fun2() ---
+     /doc/beispiele/shadow/bb [b] fun2()
+     /doc/beispiele/shadow/aa [a] fun3()
+     /doc/beispiele/shadow/cc [c] fun3()
+
+     // Der erste Aufruf von b::fun2() in a findet sofort a::fun3()! Der
+     // Driver nimmt an, dass alle Shadows ab c bei Rufen von b nach a
+     // schon ihre Chance hatten.
+     // Der zweite Aufruf allerdings ist auf b und wird beim Durchgeben
+     // an a von c uebernommen.
+
+SIEHE AUCH:
+     Generell:	     shadow(E)
+     Rechte:	     query_allow_shadow(M), query_prevent_shadow(L)
+     Informationen:  query_shadowing(E)
+
+8.Aug 2007 Gloinson
\ No newline at end of file
diff --git a/doc/sefun/shout b/doc/sefun/shout
new file mode 100644
index 0000000..ead266f
--- /dev/null
+++ b/doc/sefun/shout
@@ -0,0 +1,69 @@
+FUNKTION:
+     varargs void shout( string text, mixed where )
+
+DEFINIERT IN:
+     /secure/simul_efun.c
+
+ARGUMENTE:
+     text
+          Der Text, der ausgegeben werden soll
+
+     where [optional]
+          Wo soll man den Text ueberall hoeren koennen?
+
+BESCHREIBUNG:
+     Der Text 'text' wird an alle Spieler in einem Gebiet ausgegeben.
+     Wird der Parameter 'where' weggelassen bzw. ist er null, so geht der
+     Text an alle Spieler im Mud. Das catch_tell() von NPCs wird nicht
+     ausgeloest.
+
+     Ist 'where' eine Zahl != 0, so wird der Text nur an Spieler ausgegeben,
+     die sich im selben Gebiet aufhalten wie this_player(). Dabei wird die
+     Zugehoerigkeit zum selben Gebiet an den ersten zwei Ebenen des Pfades
+     der Raeume festgemacht. Befindet sich this_player() z.B. in
+     "/d/ebene/irgendwo", so geht der Text an alle Spieler, deren Aufenthalts-
+     orte in "/d/ebene/*" liegen.
+
+     Fuer 'where' kann auch direkt ein Pfad angegeben werden. So wuerde ein
+     'shout( txt, "/players/" )' an alle Spieler gehen, die sich in
+     (eigentlich nicht erwuenschten) Raeumen in /players/* befinden.
+
+     Um mit einem Aufruf gleich mehrere Pfade abzudecken, kann auch ein Array
+     von Strings uebergeben werden. Alle Pfade werden als 'regular expression'
+     interpretiert. Dadurch ist es moeglich, die Zielraeume auf einfache Art
+     sehr genau einzuschraenken.
+
+     HINWEIS: Bitte ueberleg vor jedem shout() genau, ob es wirklich noetig
+     ist, dass _jeder_ etwas davon mitbekommt oder ob es nicht vielleicht
+     sinnvoller ist, das Zielgebiet etwas einzuschraenken. Im Zweifelsfall
+     sollte der zustaendige RM aufpassen, dass die Spieler nicht durch allzu
+     zahlreiche shouts belaestigt werden.
+
+RUeCKGABEWERT:
+     keiner
+
+BEISPIELE:
+     shout( "Du spuerst, wie ein Zittern durch das MorgenGrauen geht.\n" );
+        Der allseits bekannte Text wird an alle Spieler im MG ausgegeben.
+
+     shout( "Du hoerst eine gewaltige Explosion.\n", 1 );
+        Von der Explosion bekommen alle Spieler in derselben Gegend etwas mit,
+        aber nicht am anderen Ende des Muds.
+
+     shout( "Irgendwo ist ein Baum umgefallen.\n", "/d/vland/" );
+        ... gibt eine Meldung aus, die keinen wirklich interessiert. Aber es
+        trifft eh nur Leute in einem unwichtigen Teil des MorgenGrauen. ;-)
+
+     shout( "Aufwachen Du Idler!\n", "/players/.*/workroom" );
+        Mit Hilfe von regular expressions kann man recht einfach z.B. alle
+        Workrooms auf einmal adressieren.
+
+     shout( "Halloooooo, Echoooooo!\n", ({ "/d/gebirge/", "/d/ebene/" }) );
+        Wenn der Spieler hoch oben auf dem Berg laut genug ruft, hoert man
+        ihn auch noch weit in der Ebene.
+
+SIEHE AUCH:
+     write(), say(), tell_object(), tell_room(), regexp()
+
+----------------------------------------------------------------------------
+Last modified: Sun Nov 28 03:00:00 1999 by Tiamak
diff --git a/doc/sefun/time2string b/doc/sefun/time2string
new file mode 100644
index 0000000..4dae719
--- /dev/null
+++ b/doc/sefun/time2string
@@ -0,0 +1,53 @@
+FUNKTION:
+	string time2string( string format, int time )
+	
+ARGUMENTE:
+	format: String, der das Format der Zeitausgabe festlegt.
+	time: Eine Anzahl von Sekunden, die ausgegeben werden soll.
+
+ERGEBNIS:
+	Zeit in String-Form.
+
+BESCHREIBUNG:
+	Der Formatstring wird zurueckgegeben, wobei bestimmte Ersetzungs-
+	symbole durch passende Daten, die aus der Zeit berechnet werden,
+	ersetzt werden. Die Ersetzungssymbole funktionieren aehnlich
+	denen aus 'printf' bekannten Symbolen. Insbesondere kann eine
+	Feldbreite mit angegeben werden.
+
+	Folgende Ersetzungssymbole sind erlaubt:
+	%%	wird durch ein Prozent (%) ersetzt.
+	%n, %w, %d, %h, %m, %s
+		  werden durch die Anzahl der Monate, Wochen, Tage, Stunden, Minuten oder
+      Sekunden ersetzt. Die Funktion erkennt, welches die groesste benutzte
+		  Zeiteinheit ist und rechnet die keineren so um, dass sie zwischen 0 und
+      jeweiligen Maximum der Zeiteinheit liegen (59, 23 etc.) liegen.
+ 	%N	wird durch die Worte 'Woche' oder 'Wochen' ersetzt,
+      je nachdem welchen Wertd %n haette.
+ 	%W	wird durch die Worte 'Woche' oder 'Wochen' ersetzt,
+		  je nachdem welchen Wert %w haette.
+	%D	wird durch die Worte 'Tag' oder 'Tage' ersetzt,
+		  je nachdem welchen Wert %d haette.
+	%H,%M,%S
+		  werden durch die Worte 'Stunde(n)', 'Minute(n)' bzw. 'Sekunde(n)'
+      ersetzt.
+	%X	wird durch die groesste Zeiteinheit ersetzt, die nicht Null ist. Wenn
+      bei %X die Feldbreite 0 angegeben wird (also %0X), dann wird nicht der
+      ausgeschriebene Name, sonder eine Abkuerzung fuer die Zeiteinheit
+      ausgegeben. (Das sind dann 'd','h','m' oder 's'.)
+	%x	wird durch den numerischen Wert dieser Zeiteinheit
+		  ersetzt.
+			
+BEISPIELE:
+	time2string( "%m %M", 60 ) -> "1 Minute"
+	time2string( "%m %M", 120 ) -> "2 Minuten"
+	time2string( "%s %S", 125 ) -> "125 Sekunden"
+	time2string( "%m %M und %s %S" ) -> "2 Minuten und 5 Sekunden"
+	time2string( "%d:%02h:%02m:%02s", 10000 ) -> "0:02:46:40"
+	time2string( "%x %X", 3600 ) -> "1 Stunde"
+	time2string( "%x %0X", 3600 ) -> "1 h"
+	time2string( "%x %X", 360000 ) -> "4 Tage"
+	time2string( "%x %0X", 360000 ) -> "4 d"
+
+SIEHE AUCH:
+	sprintf(E)
diff --git a/doc/sefun/update_actions b/doc/sefun/update_actions
new file mode 100644
index 0000000..b28cf9f
--- /dev/null
+++ b/doc/sefun/update_actions
@@ -0,0 +1,38 @@
+FUNKTION:
+        void update_actions()
+
+ARGUMENTE:
+        keine
+
+BESCHREIBUNG:
+        Falls eine Aktion ein add_action() ausgeloest hat, werden mit dieser
+        Funktion die neuen Befehle bei allen Lebewesen im aufrufenden Objekt
+        bzw. in der Umgebung des aufrufenden Objektes aktiv.
+
+RUECKGABEWERT:
+        keiner
+
+BEMERKUNGEN:
+        Diese Funktion wird eigentlich nur benoetigt, wenn man mit add_action()
+        anstelle von AddCmd() arbeitet (zB. bei Objekten, die nicht
+        /std/thing/commands inheriten).
+
+BEISPIELE:
+        /* Normalerweise sollte man es SO gerade nicht machen. Stattdessen
+         * sollte die "kletter"-Funktion pruefen, ob die Luke geoeffnet ist, 
+         * und sich im Fehlerfall beschweren.
+         * So aber dient es als schoenes Beispiel fuer update_actions() ;)
+         */
+        int oeffne(string str)
+        {
+          if( str == "luke" ) {
+            write( "Du oeffnest die Luke. Du kannst jetzt nach unten klettern.\n");
+            add_action("kletter", "kletter", 1);
+            update_actions();
+            return 1;
+          }
+          return 0;
+        }
+
+SIEHE AUCH:
+  add_action(E), AddCmd(L), RemoveCmd(L)
diff --git a/doc/sefun/upperstring b/doc/sefun/upperstring
new file mode 100644
index 0000000..665ed16
--- /dev/null
+++ b/doc/sefun/upperstring
@@ -0,0 +1,17 @@
+FUNKTION:
+	string upperstring(string str)
+
+ARGUMENTE:
+	str - Der umzuwandelnde String.
+
+BESCHREIBUNG:
+	Alle Kleinbuchstaben in str werden in Grossbuchstaben umgewandelt.
+
+RUECKGABEWERT:
+	Der umgewandelte String.
+
+BEISPIELE:
+	s = upperstring( "Na, Sterblicher!\n") => s = "NA, STERBLICHER!\n"
+
+SIEHE AUCH:
+	lowerstring(E), lower_case(E), capitalize(E)
diff --git a/doc/sefun/uptime b/doc/sefun/uptime
new file mode 100644
index 0000000..ee7a536
--- /dev/null
+++ b/doc/sefun/uptime
@@ -0,0 +1,16 @@
+FUNKTION:
+        string uptime()
+
+ARGUMENTE:
+        keine
+
+BESCHREIBUNG:
+        Liefert die aktuelle Uptime des MorgenGrauens.
+
+RUECKGABEWERT:
+        Die Uptime als Zeitstring.
+
+BEISPIELE:
+        ut = uptime() => ut = "14 Tage, 9 Stunden, 3 Minuten und 7 Sekunden."
+
+SIEHE AUCH:
diff --git a/doc/sefun/wizlist b/doc/sefun/wizlist
new file mode 100644
index 0000000..a2ba7bd
--- /dev/null
+++ b/doc/sefun/wizlist
@@ -0,0 +1,66 @@
+SYNOPSIS:
+  varargs void wizlist(string name, int sortkey ) 	
+
+DESCRIPTION:
+  wizlist() liefert eine Liste mit verschiedenen Verbrauchsdaten 
+	zu Magiern. Es werden dabei normalerweise 21 Eintraege ausgegeben:
+  10 vor <name>, <name> selbst und 10 nach <name>.
+
+  Die Liste ist dabei folgendermassen aufgebaut:
+
+	1. WL_NAME
+	   Gesammelt werden die Daten pro UID. Hierbei zaehlt aber jede EUID, nicht
+     nur die von Magiern.
+     Das heisst, Objekte unter /d/polar/vanion/eispalast
+	   werden nicht unter "vanion" sondern unter "d.polar.vanion"
+	   abgerechnet.
+
+	2. WL_COMMANDS
+     Anzahl der diesem Objekt zugeordneten commands.
+
+	3. WL_COMMANDS * 100 / total_cmd 
+     Prozentualer Anteil an den gesamt verbrauchten commands.
+
+	4. WL_COST (links in der eckigen Klammer)
+     Anzahl der verbrauchten eval ticks. Dies ist zeitlich gewichtet, d.h.
+     nimmt im Lauf der Zeit ab, wenn nichts mehr dazu kommt.
+
+  5. WL_TOTAL_GIGACOST (rechts in der eckigen Klammer)
+     Anzahl der insgesamt verbrauchten eval ticks in Giga-Ticks.
+     Nicht zeitlich gewichtet.
+
+	6. WL_HEART_BEATS
+     Anzahl der ausgeloesten heart beats.
+  
+  7. WL_ARRAY_TOTAL
+
+  8. WL_MAPPING_TOTAL
+
+PARAMETERS: 
+  Wird name angegeben, wird erzwungen, dass die erwaehnte EUID mit
+  in der Liste dargestellt wird. Wird name nicht angegeben, wird es
+  automatisch auf this_player()->query_real_name() gesetzt.
+
+  Wird als name "TOP100" angegeben, wird die Top-100-Liste ausgegeben.
+
+  Wird als name "ALL" angegeben, wird die vollstaendige Liste aus-
+  gegeben.
+
+  Durch Angabe von sortkey kann die Liste nach einer der Spalten 
+  sortiert werden. Gueltige Werte sind die in /sys/wizlist.h ange-
+  gebenen Defines.
+	
+EXAMPLE: 
+  > xeval wizlist("vanion", WL_HEART_BEATS)
+      Erzwingt Vanions Eintrag in der Liste und sortiert die Liste anhand
+      der durch die EUIDs ausgefuehrten heart beats.
+
+  > xeval wizlist("ALL", WL_EVAL_COST)
+      Zeigt die komplette Liste nach eval ticks-Verbauch sortiert an.
+
+SEE ALSO:
+      wizlist_info(E)
+
+LAST UPDATED:
+  09.05.2015, Zesstra
+
diff --git a/doc/sefun/wizlist_info b/doc/sefun/wizlist_info
new file mode 100644
index 0000000..2a5c127
--- /dev/null
+++ b/doc/sefun/wizlist_info
@@ -0,0 +1,39 @@
+GESCHUETZT
+SYNOPSIS
+        #include <sys/wizlist.h>
+
+        *mixed wizlist_info();
+
+BESCHREIBUNG
+        Liefert ein Array mit Eintraegen aus der Wizlist (der internen
+        Magierliste). Die Benutzung muss durch das Masterobjekt erlaubt
+        werden.
+
+        Das Resultat ist ein Array mit einem Eintrag fuer jeden Magier (uid).
+        Jeder Eintrag enthaelt wiederum ein Array mit folgenden Elementen:
+
+            string  w[WL_NAME]          Name des Magiers
+            int w[WL_COMMANDS]          Gewichtete Anzahl Kommandi, die von
+                                        Objekten dieses Gottes ausgefuehrt
+                                        wurden
+            int w[WL_COSTE]             Gewichtete Summe der Eval-Kosten
+            int w[WL_GIGACOST]          Gewichtete Summe der Eval-Kosten
+            int W[WL_TOTAL_COST]        Totale Summe der Eval-Kosten
+            int w[WL_TOTAL_GIGACOST]    Totale Summe der Eval-Kosten
+            int w[WL_HEART_BEAT]        Gewichtete Anzahl der heat_beat()s
+            int w[WL_CALL_OUT]          Reserviert fuer call_out()s
+                                        (bisher nicht implementiert)
+            int w[WL_ARRAY_TOTAL]       Totale Groesse aller Arrays in
+                                        Elementen
+            mixed w[WL_EXTRA]           Die eigentliche Wizlist-Info
+
+        Die "gewichteten" Werte verfallen pro Stunde um 10%.
+
+AENDERUNGEN
+        LDMud 3.2.10 trennte das alte WL_EVAL_COST in WL_COST und WL_GIGACOST,
+        um laengeren Uptimes gerecht zu werden. Ausserdem wurde
+        WL_TOTAL_COST und WL_TOTAL_GIGACOST eingefuehrt.
+
+SIEHE AUCH
+        privilege_violation(M), set_extra_wizinfo_size(E),
+        get_extra_wizinfo(E), set_extra_wizinfo(E)