diff --git a/doc/sphinx/man/sefun/CountUp b/doc/sphinx/man/sefun/CountUp
new file mode 100644
index 0000000..9e55d69
--- /dev/null
+++ b/doc/sphinx/man/sefun/CountUp
@@ -0,0 +1,40 @@
+
+CountUp()
+*********
+
+
+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/sphinx/man/sefun/_notify_fail b/doc/sphinx/man/sefun/_notify_fail
new file mode 100644
index 0000000..a9801ef
--- /dev/null
+++ b/doc/sphinx/man/sefun/_notify_fail
@@ -0,0 +1,35 @@
+
+_notify_fail()
+**************
+
+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/sphinx/man/sefun/break_string b/doc/sphinx/man/sefun/break_string
new file mode 100644
index 0000000..8e3017d
--- /dev/null
+++ b/doc/sphinx/man/sefun/break_string
@@ -0,0 +1,112 @@
+
+break_string()
+**************
+
+
+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/sphinx/man/sefun/broken_count_bits b/doc/sphinx/man/sefun/broken_count_bits
new file mode 100644
index 0000000..de01e96
--- /dev/null
+++ b/doc/sphinx/man/sefun/broken_count_bits
@@ -0,0 +1,48 @@
+
+broken_count_bits()
+*******************
+
+
+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/sphinx/man/sefun/cindent b/doc/sphinx/man/sefun/cindent
new file mode 100644
index 0000000..e0e16af
--- /dev/null
+++ b/doc/sphinx/man/sefun/cindent
@@ -0,0 +1,22 @@
+
+cindent()
+*********
+
+
+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/sphinx/man/sefun/debug_info b/doc/sphinx/man/sefun/debug_info
new file mode 100644
index 0000000..02e02b8
--- /dev/null
+++ b/doc/sphinx/man/sefun/debug_info
@@ -0,0 +1,508 @@
+
+debug_info()
+************
+
+
+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/sphinx/man/sefun/deep_present b/doc/sphinx/man/sefun/deep_present
new file mode 100644
index 0000000..c3f673a
--- /dev/null
+++ b/doc/sphinx/man/sefun/deep_present
@@ -0,0 +1,40 @@
+
+deep_present()
+**************
+
+
+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/sphinx/man/sefun/dtime b/doc/sphinx/man/sefun/dtime
new file mode 100644
index 0000000..dac7dd0
--- /dev/null
+++ b/doc/sphinx/man/sefun/dtime
@@ -0,0 +1,49 @@
+
+dtime()
+*******
+
+
+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/sphinx/man/sefun/dump_netdead b/doc/sphinx/man/sefun/dump_netdead
new file mode 100644
index 0000000..b5b480a
--- /dev/null
+++ b/doc/sphinx/man/sefun/dump_netdead
@@ -0,0 +1,29 @@
+
+dump_netdead()
+**************
+
+
+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/sphinx/man/sefun/enable_commands b/doc/sphinx/man/sefun/enable_commands
new file mode 100644
index 0000000..593fb31
--- /dev/null
+++ b/doc/sphinx/man/sefun/enable_commands
@@ -0,0 +1,42 @@
+
+enable_commands()
+*****************
+
+
+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/sphinx/man/sefun/file_time b/doc/sphinx/man/sefun/file_time
new file mode 100644
index 0000000..ddaefce
--- /dev/null
+++ b/doc/sphinx/man/sefun/file_time
@@ -0,0 +1,13 @@
+
+file_time()
+***********
+
+
+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/sphinx/man/sefun/find_living b/doc/sphinx/man/sefun/find_living
new file mode 100644
index 0000000..5930695
--- /dev/null
+++ b/doc/sphinx/man/sefun/find_living
@@ -0,0 +1,42 @@
+
+find_living()
+*************
+
+
+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/sphinx/man/sefun/find_livings b/doc/sphinx/man/sefun/find_livings
new file mode 100644
index 0000000..7f8f9b1
--- /dev/null
+++ b/doc/sphinx/man/sefun/find_livings
@@ -0,0 +1,49 @@
+
+find_livings()
+**************
+
+
+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/sphinx/man/sefun/find_netdead b/doc/sphinx/man/sefun/find_netdead
new file mode 100644
index 0000000..8686436
--- /dev/null
+++ b/doc/sphinx/man/sefun/find_netdead
@@ -0,0 +1,46 @@
+
+find_netdead()
+**************
+
+
+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/sphinx/man/sefun/find_player b/doc/sphinx/man/sefun/find_player
new file mode 100644
index 0000000..048b105
--- /dev/null
+++ b/doc/sphinx/man/sefun/find_player
@@ -0,0 +1,60 @@
+
+find_player()
+*************
+
+
+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/sphinx/man/sefun/getuuid b/doc/sphinx/man/sefun/getuuid
new file mode 100644
index 0000000..63ea31e
--- /dev/null
+++ b/doc/sphinx/man/sefun/getuuid
@@ -0,0 +1,29 @@
+
+getuuid()
+*********
+
+
+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/sphinx/man/sefun/iso2ascii b/doc/sphinx/man/sefun/iso2ascii
new file mode 100644
index 0000000..bd64d73
--- /dev/null
+++ b/doc/sphinx/man/sefun/iso2ascii
@@ -0,0 +1,32 @@
+
+iso2ascii()
+***********
+
+
+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/sphinx/man/sefun/log_file b/doc/sphinx/man/sefun/log_file
new file mode 100644
index 0000000..a3f3cab
--- /dev/null
+++ b/doc/sphinx/man/sefun/log_file
@@ -0,0 +1,59 @@
+
+log_file()
+**********
+
+
+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.
+   Sollte file schon mit einem /log/ beginnen, wird kein erneutes /log/ davor
+   eingefuegt.
+
+
+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... ;)
+   log_file( "/log/report/wargon.rep", "TYPO von bla in blubb:\ntest\n");
+   Gleiches Ergebnis. ;-)
+
+
+SIEHE AUCH
+==========
+
+   write_file(E)
+
+29.01.2017, Zesstra
diff --git a/doc/sphinx/man/sefun/lowerchar b/doc/sphinx/man/sefun/lowerchar
new file mode 100644
index 0000000..8e6cfdd
--- /dev/null
+++ b/doc/sphinx/man/sefun/lowerchar
@@ -0,0 +1,42 @@
+
+lowerchar()
+***********
+
+
+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/sphinx/man/sefun/lowerstring b/doc/sphinx/man/sefun/lowerstring
new file mode 100644
index 0000000..a483224
--- /dev/null
+++ b/doc/sphinx/man/sefun/lowerstring
@@ -0,0 +1,45 @@
+
+lowerstring()
+*************
+
+
+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/sphinx/man/sefun/m_copy_delete b/doc/sphinx/man/sefun/m_copy_delete
new file mode 100644
index 0000000..9aa90f2
--- /dev/null
+++ b/doc/sphinx/man/sefun/m_copy_delete
@@ -0,0 +1,68 @@
+
+m_copy_delete()
+***************
+
+
+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/sphinx/man/sefun/match_living b/doc/sphinx/man/sefun/match_living
new file mode 100644
index 0000000..5cb347b
--- /dev/null
+++ b/doc/sphinx/man/sefun/match_living
@@ -0,0 +1,52 @@
+
+match_living()
+**************
+
+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/sphinx/man/sefun/md5 b/doc/sphinx/man/sefun/md5
new file mode 100644
index 0000000..f48dcc8
--- /dev/null
+++ b/doc/sphinx/man/sefun/md5
@@ -0,0 +1,52 @@
+
+md5()
+*****
+
+
+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/sphinx/man/sefun/mkdirp b/doc/sphinx/man/sefun/mkdirp
new file mode 100644
index 0000000..2bb9d06
--- /dev/null
+++ b/doc/sphinx/man/sefun/mkdirp
@@ -0,0 +1,42 @@
+
+mkdirp()
+********
+
+
+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/sphinx/man/sefun/notify_fail b/doc/sphinx/man/sefun/notify_fail
new file mode 100644
index 0000000..85b700a
--- /dev/null
+++ b/doc/sphinx/man/sefun/notify_fail
@@ -0,0 +1,107 @@
+
+notify_fail()
+*************
+
+
+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/sphinx/man/sefun/object_info b/doc/sphinx/man/sefun/object_info
new file mode 100644
index 0000000..bee892e
--- /dev/null
+++ b/doc/sphinx/man/sefun/object_info
@@ -0,0 +1,148 @@
+
+object_info()
+*************
+
+
+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/sphinx/man/sefun/obsolete/exclude_alist b/doc/sphinx/man/sefun/obsolete/exclude_alist
new file mode 100644
index 0000000..5d1aace
--- /dev/null
+++ b/doc/sphinx/man/sefun/obsolete/exclude_alist
@@ -0,0 +1,11 @@
+
+exclude_alist()
+***************
+
+
+SYNOPSIS
+========
+
+   mixed *exclude_alist(int i, mixed *alist)
+
+Remove element i from alist.
diff --git a/doc/sphinx/man/sefun/obsolete/remove_alist b/doc/sphinx/man/sefun/obsolete/remove_alist
new file mode 100644
index 0000000..fceac4f
--- /dev/null
+++ b/doc/sphinx/man/sefun/obsolete/remove_alist
@@ -0,0 +1,7 @@
+
+remove_alist()
+**************
+
+mixed >>*<<remove_alist(mixed key, mixed >>*<<alist)
+
+Removes element associated by key key from alist.
diff --git a/doc/sphinx/man/sefun/old_explode b/doc/sphinx/man/sefun/old_explode
new file mode 100644
index 0000000..357e838
--- /dev/null
+++ b/doc/sphinx/man/sefun/old_explode
@@ -0,0 +1,53 @@
+
+old_explode()
+*************
+
+
+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/sphinx/man/sefun/process_call b/doc/sphinx/man/sefun/process_call
new file mode 100644
index 0000000..cd43faf
--- /dev/null
+++ b/doc/sphinx/man/sefun/process_call
@@ -0,0 +1,38 @@
+
+process_call()
+**************
+
+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/sphinx/man/sefun/process_string b/doc/sphinx/man/sefun/process_string
new file mode 100644
index 0000000..fbc7018
--- /dev/null
+++ b/doc/sphinx/man/sefun/process_string
@@ -0,0 +1,77 @@
+
+process_string()
+****************
+
+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/sphinx/man/sefun/query_editing b/doc/sphinx/man/sefun/query_editing
new file mode 100644
index 0000000..32358ed
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_editing
@@ -0,0 +1,29 @@
+
+query_editing()
+***************
+
+
+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/sphinx/man/sefun/query_idle b/doc/sphinx/man/sefun/query_idle
new file mode 100644
index 0000000..7deccee
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_idle
@@ -0,0 +1,21 @@
+
+query_idle()
+************
+
+
+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/sphinx/man/sefun/query_input_pending b/doc/sphinx/man/sefun/query_input_pending
new file mode 100644
index 0000000..c40c355
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_input_pending
@@ -0,0 +1,27 @@
+
+query_input_pending()
+*********************
+
+
+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/sphinx/man/sefun/query_ip_name b/doc/sphinx/man/sefun/query_ip_name
new file mode 100644
index 0000000..76de80f
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_ip_name
@@ -0,0 +1,28 @@
+
+query_ip_name()
+***************
+
+
+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/sphinx/man/sefun/query_ip_number b/doc/sphinx/man/sefun/query_ip_number
new file mode 100644
index 0000000..d09bc88
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_ip_number
@@ -0,0 +1,43 @@
+
+query_ip_number()
+*****************
+
+
+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/sphinx/man/sefun/query_limits b/doc/sphinx/man/sefun/query_limits
new file mode 100644
index 0000000..8af988f
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_limits
@@ -0,0 +1,82 @@
+
+query_limits()
+**************
+
+
+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/sphinx/man/sefun/query_mud_port b/doc/sphinx/man/sefun/query_mud_port
new file mode 100644
index 0000000..de4c1e2
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_mud_port
@@ -0,0 +1,39 @@
+
+query_mud_port()
+****************
+
+
+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/sphinx/man/sefun/query_next_reset b/doc/sphinx/man/sefun/query_next_reset
new file mode 100644
index 0000000..528ae56
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_next_reset
@@ -0,0 +1,47 @@
+
+query_next_reset()
+******************
+
+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/sphinx/man/sefun/query_once_interactive b/doc/sphinx/man/sefun/query_once_interactive
new file mode 100644
index 0000000..bfb8b55
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_once_interactive
@@ -0,0 +1,21 @@
+
+query_once_interactive()
+************************
+
+
+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/sphinx/man/sefun/query_shadowing b/doc/sphinx/man/sefun/query_shadowing
new file mode 100644
index 0000000..aadf109
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_shadowing
@@ -0,0 +1,38 @@
+
+query_shadowing()
+*****************
+
+
+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
diff --git a/doc/sphinx/man/sefun/query_snoop b/doc/sphinx/man/sefun/query_snoop
new file mode 100644
index 0000000..94e598a
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_snoop
@@ -0,0 +1,26 @@
+
+query_snoop()
+*************
+
+
+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/sphinx/man/sefun/query_wiz_grp b/doc/sphinx/man/sefun/query_wiz_grp
new file mode 100644
index 0000000..fe01fbd
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_wiz_grp
@@ -0,0 +1,34 @@
+
+query_wiz_grp()
+***************
+
+
+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/sphinx/man/sefun/query_wiz_level b/doc/sphinx/man/sefun/query_wiz_level
new file mode 100644
index 0000000..3645035
--- /dev/null
+++ b/doc/sphinx/man/sefun/query_wiz_level
@@ -0,0 +1,70 @@
+
+query_wiz_level()
+*****************
+
+
+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/sphinx/man/sefun/read_data b/doc/sphinx/man/sefun/read_data
new file mode 100644
index 0000000..1756890
--- /dev/null
+++ b/doc/sphinx/man/sefun/read_data
@@ -0,0 +1,34 @@
+
+read_data()
+***********
+
+
+SYNOPSIS
+========
+
+   string read_data(string file, int start, int anzahl)
+
+
+BESCHREIBUNG
+============
+
+   Diese Funktion macht genau das, was read_file() tut (also siehe dort),
+   allerdings stellt sie sicher, dass <file> immer mit einem /data/
+   beginnt (setzt es also notfalls davor).
+   Es wird also immer irgendwo unterhalb von /data/ gelesen.
+
+
+BEISPIEL
+========
+
+   # read_data("/d/ebene/zesstra/blupp");
+   -> liest das File /data/d/ebene/zesstra/blupp.
+   # read_data("/data/d/ebene/zesstra/blupp");
+   -> tut dasselbe.
+
+
+SIEHE AUCH
+==========
+
+   write_data()
+   read_file(E), write_file(E), read_bytes(E), write_file(E)
diff --git a/doc/sphinx/man/sefun/replace_personal b/doc/sphinx/man/sefun/replace_personal
new file mode 100644
index 0000000..3804be3
--- /dev/null
+++ b/doc/sphinx/man/sefun/replace_personal
@@ -0,0 +1,113 @@
+
+replace_personal()
+******************
+
+
+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)
+
+5. September 2015, Arathorn
diff --git a/doc/sphinx/man/sefun/restore_object b/doc/sphinx/man/sefun/restore_object
new file mode 100644
index 0000000..631252d
--- /dev/null
+++ b/doc/sphinx/man/sefun/restore_object
@@ -0,0 +1,31 @@
+
+restore_object()
+****************
+
+
+SYNOPSIS
+========
+
+   mixed restore_object(string name);
+
+
+BESCHREIBUNG
+============
+
+   Diese Simul-Efun unterscheidet sich in einigen Details von der
+   Driver-Efun restore_object() (s. auch dort! Wichtig!).
+
+   1. diese sefun restauriert auch die mit F_SAVE markierten Properties
+   eines Objektes, sofern das Savefile von sefun save_object erstellt
+   wurde (was die efun des Driver nicht tut!).
+   2. Sofern ein Pfad angegeben wird und dieser NICHT mit /data/ beginnt,
+   wird das Savefile als erstes immer unter /data/+name gesucht. Erst wenn es
+   dort nicht gefunden wird, wird unter name gesucht.
+
+
+SIEHE AUCH
+==========
+
+   save_object(E), restore_object(E), save_value(E)
+
+29.01.2017, Zesstra
diff --git a/doc/sphinx/man/sefun/save_object b/doc/sphinx/man/sefun/save_object
new file mode 100644
index 0000000..fc8175f
--- /dev/null
+++ b/doc/sphinx/man/sefun/save_object
@@ -0,0 +1,35 @@
+
+save_object()
+*************
+
+
+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. Sofern ein Pfad angegeben wird und dieser NICHT mit /data/ beginnt,
+   wird /data/ vorangestellt, d.h. das Savefile wird immer unter /data/
+   erstellt.
+   3. 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.
+   4. 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)
+
+29.01.2017, Zesstra
diff --git a/doc/sphinx/man/sefun/send_room b/doc/sphinx/man/sefun/send_room
new file mode 100644
index 0000000..7ddf43d
--- /dev/null
+++ b/doc/sphinx/man/sefun/send_room
@@ -0,0 +1,42 @@
+
+send_room()
+***********
+
+
+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/sphinx/man/sefun/set_heart_beat b/doc/sphinx/man/sefun/set_heart_beat
new file mode 100644
index 0000000..a304181
--- /dev/null
+++ b/doc/sphinx/man/sefun/set_heart_beat
@@ -0,0 +1,41 @@
+
+set_heart_beat()
+****************
+
+
+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/sphinx/man/sefun/set_light b/doc/sphinx/man/sefun/set_light
new file mode 100644
index 0000000..b9dfc9c
--- /dev/null
+++ b/doc/sphinx/man/sefun/set_light
@@ -0,0 +1,32 @@
+
+set_light()
+***********
+
+
+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/sphinx/man/sefun/set_living_name b/doc/sphinx/man/sefun/set_living_name
new file mode 100644
index 0000000..e588e6e
--- /dev/null
+++ b/doc/sphinx/man/sefun/set_living_name
@@ -0,0 +1,41 @@
+
+set_living_name()
+*****************
+
+
+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/sphinx/man/sefun/set_object_heart_beat b/doc/sphinx/man/sefun/set_object_heart_beat
new file mode 100644
index 0000000..caecca2
--- /dev/null
+++ b/doc/sphinx/man/sefun/set_object_heart_beat
@@ -0,0 +1,34 @@
+
+set_object_heart_beat()
+***********************
+
+
+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/sphinx/man/sefun/sha1 b/doc/sphinx/man/sefun/sha1
new file mode 100644
index 0000000..ef3b10e
--- /dev/null
+++ b/doc/sphinx/man/sefun/sha1
@@ -0,0 +1,44 @@
+
+sha1()
+******
+
+
+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/sphinx/man/sefun/shadow b/doc/sphinx/man/sefun/shadow
new file mode 100644
index 0000000..2b7032c
--- /dev/null
+++ b/doc/sphinx/man/sefun/shadow
@@ -0,0 +1,162 @@
+
+shadow()
+********
+
+
+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
diff --git a/doc/sphinx/man/sefun/shout b/doc/sphinx/man/sefun/shout
new file mode 100644
index 0000000..0d38abb
--- /dev/null
+++ b/doc/sphinx/man/sefun/shout
@@ -0,0 +1,93 @@
+
+shout()
+*******
+
+
+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/sphinx/man/sefun/time2string b/doc/sphinx/man/sefun/time2string
new file mode 100644
index 0000000..4acd1a2
--- /dev/null
+++ b/doc/sphinx/man/sefun/time2string
@@ -0,0 +1,75 @@
+
+time2string()
+*************
+
+
+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/sphinx/man/sefun/update_actions b/doc/sphinx/man/sefun/update_actions
new file mode 100644
index 0000000..b25c07c
--- /dev/null
+++ b/doc/sphinx/man/sefun/update_actions
@@ -0,0 +1,63 @@
+
+update_actions()
+****************
+
+
+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/sphinx/man/sefun/upperstring b/doc/sphinx/man/sefun/upperstring
new file mode 100644
index 0000000..416c90d
--- /dev/null
+++ b/doc/sphinx/man/sefun/upperstring
@@ -0,0 +1,39 @@
+
+upperstring()
+*************
+
+
+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/sphinx/man/sefun/uptime b/doc/sphinx/man/sefun/uptime
new file mode 100644
index 0000000..4c007a3
--- /dev/null
+++ b/doc/sphinx/man/sefun/uptime
@@ -0,0 +1,37 @@
+
+uptime()
+********
+
+
+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/sphinx/man/sefun/wizlist b/doc/sphinx/man/sefun/wizlist
new file mode 100644
index 0000000..f81b9b8
--- /dev/null
+++ b/doc/sphinx/man/sefun/wizlist
@@ -0,0 +1,84 @@
+
+wizlist()
+*********
+
+
+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/sphinx/man/sefun/wizlist_info b/doc/sphinx/man/sefun/wizlist_info
new file mode 100644
index 0000000..0c86434
--- /dev/null
+++ b/doc/sphinx/man/sefun/wizlist_info
@@ -0,0 +1,58 @@
+
+wizlist_info()
+**************
+
+
+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)
diff --git a/doc/sphinx/man/sefun/write_data b/doc/sphinx/man/sefun/write_data
new file mode 100644
index 0000000..b8f0d4f
--- /dev/null
+++ b/doc/sphinx/man/sefun/write_data
@@ -0,0 +1,39 @@
+
+write_data()
+************
+
+
+SYNOPSIS
+========
+
+   string write_data(string file, int start, int anzahl)
+
+
+BESCHREIBUNG
+============
+
+   Diese Funktion macht genau das, was write_file() tut (also siehe dort),
+   allerdings stellt sie sicher, dass <file> immer mit einem /data/
+   beginnt (setzt es also notfalls davor).
+   Es wird also immer irgendwo unterhalb von /data/ geschrieben.
+
+   Die Benutzung dieser sefun wird dringend empfohlen, falls Daten
+   ausserhalb von Spielerobjekten gepeichert werden, damit Daten und
+   Code getrennt abgelegt sind. Dies vereinfacht z.B. die
+   Datensicherung.
+
+
+BEISPIEL
+========
+
+   # write_file("/d/ebene/zesstra/blupp", "Testdaten.\n");
+   -> schreibt in das File /data/d/ebene/zesstra/blupp.
+   # write_file("/data/d/ebene/zesstra/blupp", "Testdaten.\n");
+   -> tut dasselbe.
+
+
+SIEHE AUCH
+==========
+
+   read_data()
+   read_file(E), write_file(E), read_bytes(E), write_file(E)