diff --git a/doc/efun/add_action b/doc/efun/add_action
index 8b0f778..19813d2 100644
--- a/doc/efun/add_action
+++ b/doc/efun/add_action
@@ -1,97 +1,72 @@
-add_action(E)
-FUNKTION:
-     void add_action(string fun, string cmd)
-     void add_action(string fun, string cmd, int flag)
+SYNOPSIS
+        #include <commands.h>
 
-ARGUMENTE:
-     fun
-	gerufene Methode
-     cmd
-	ausloesendes Verb
-     flag
-	Flag fuer unscharfe Interpretation
+        void add_action(string|closure fun, string cmd);
+        void add_action(string|closure fun, string cmd, int flag);
+        void add_action(string|closure fun);        /* veraltet */
 
-BESCHREIBUNG:
-     Generell: Das Verhalten dieser efun wird durch AddCmd aus
-               /std/thing/commands.c komfortabler widergespiegelt.
-               Darauf sollte man zurueckgreifen.
+BESCHREIBUNG
+        Setzt eine lokale Funktion fun, die aufgerufen wird, wenn der Spieler
+        das Kommandos <cmd< eintippt. Der Funktion werden die Argumente des
+        vom Spieler eingegebenen Kommandos als string uebergeben. Die
+        Funktion muss entweder 1 zurueck geben, wenn das Kommando erfolgreich
+        ausgefuehrt werden konnte, sonst 0.
 
-     Legt fuer "cmd" (ein Kommandoverb) eine im entsprechenden Objekt
-     zu rufende Methode fest.
+        Wenn das Kommando nicht erfolgreich ausgefuehrt werden konnte, sucht
+        der Parser weiter nach einer passenden Funktion, bis eine solche
+        1 zurueck liefert. Falls der Parser keine Funktion findet, wird an
+        den Spieler eine Fehlermeldung ausgegeben. ("Wie bitte?")
 
-     Diese Methode bekommt die Argumente als String uebergeben und
-     muss 0 (fuer einen Fehler) oder 1 (fuer Erfolg) zurueckgeben.
+        Wenn add_action() ohne das zweite Argument (string cmd) aufgerufen
+        wird, muss dieses mit add_verb() oder add_xverb() angegeben werden.
+        DIESE DEKLARATION IST JEDOCH VERALTET UND SOLLTE NICHT VERWENDET
+        WERDEN. Sie funktioniert auch nur, wenn USE_DEPRECATED gesetzt ist.
 
-     Der Parser durchsucht bei einer Spielereingabe die Liste der
-     eingetragenen Kommandos nach passenden Kommandos und ruft die
-     zugehoerigen Methoden in den Objekten bis eine der Methoden
-     1 zurueckgibt oder die Liste durchlaufen wurde. In dem Fall
-     kommt die Fehlermeldung (notify_fail()) zum Einsatz.
+        Die Funktion fun wird mit einem string als Argument aufgerufen, der
+        die Worte nach dem Verb in der Inputzeile enthaelt. Das Verb kann
+        mit der Efun query_verb() abgefragt werden. Das Verb ist immer das
+        erste Wort in der Inputzeile bis zum ersten Leerschlag.
 
-     Mit Werten != 0 fuer "flag" legt man eine unscharfe Auswertung
-     fest, im Beispiel: Die Methode "action_fun" bei einem
-      add_action("action_fun", "hops", 1);
-     wird sowohl beim Kommando "hops" als auch bei Kommandos wie
-     "hopse", "hopseblub", ... gerufen werden.
-     Dieses Flag sollte vorsichtig verwendet werden.
+        add_action() muss immer aus einer init() Routine heraus aufgerufen
+        werden. Das Objekt, welches das Kommando cmd definiert, muss sich in
+        der Umgebung des Spielers befinden; also entweder der Spieler selbst,
+        im Inventar des Spielers, der Raum, in dem sich der Spieler befindet
+        oder ein Objekt im gleichen Raum wie der Spieler. Wenn der Spieler
+        die Umgebung des Objekts verlaesst, werden alle von add_action()
+        definierten Kommandos automatisch entfernt.
 
-     Es gibt drei moegliche Verhaltensweise, die per "flag" eingeschaltet
-     werden koennen:
-     Wenn das Argument <flag> AA_SHORT (d.h. 1) ist, koennen Argumente von
-     cmd ohne einen Leerschlag an cmd angehaengt sein. An die Funktion fun
-     werden alle Zeichen nach dem ersten Leerschlag als Argument
-     uebergeben.
+        Die Kommandos lassen sich auch manuell entfernen. Die Efun dazu lautet
+        remove_actions().
 
-     Wenn <flag> AA_NOSPACE (d.h. 2) ist, koennen die Argumente wiederum
-     ohne Leerschlag ans Verb angehaengt sein. Im Unterschied zu AA_SHORT
-     werden alle Zeichen nach dem Verb als Argument an die Funktion
-     uebergeben. Die Zeichen, welche nicht durch einen Leerschlag vom
-     Verb getrennt sind, werden ZUSAETZLICH von query_verb() zurueck
-     gegeben.
+        Wenn das Argument <flag> AA_SHORT (d.h. 1) ist, koennen Argumente von
+        cmd ohne einen Leerschlag an cmd angehaengt sein. An die Funktion fun
+        werden alle Zeichen nach dem ersten Leerschlag als Argument
+        uebergeben.
 
-     Wenn <flag> AA_IMM_ARGS (3) ist, werden alle Zeichen nach dem Verb
-     als Argument uebergeben, nicht aber von query_verb() beruecksichtigt.
+        Wenn <flag> AA_NOSPACE (d.h. 2) ist, koennen die Argumente wiederum
+        ohne Leerschlag ans Verb angehaengt sein. Im Unterschied zu AA_SHORT
+        werden alle Zeichen nach dem Verb als Argument an die Funktion
+        uebergeben. Die Zeichen, welche nicht durch einen Leerschlag vom
+        Verb getrennt sind, werden ZUSAETZLICH von query_verb() zurueck
+        gegeben.
 
+        Wenn <flag> AA_IMM_ARGS (3) ist, werden alle Zeichen nach dem Verb
+        als Argument uebergeben, nicht aber von query_verb() beruecksichtigt.
 
-BEMERKUNGEN:
-     (1) add_action() sollte immer innerhalb von init() benutzt werden
-     (2) das definierende Objekt muss im inventory des Spielers oder
-         environment() des kommandogebenden Lebewesens sein
-     (3) im init() spaeter eingetragene Kommandos oder spaeter hinzu-
-         kommende Objekte werden bei der Kommandoauswertung VOR den
-         alten beruecksichtigt
-         (Daher bewegt sich das Xtool der Magier regelmaessing neu in
-          das Inventory, um immer "erstes" Objekt zu sein.)
+        Wenn -<flag> eine negative Zahl ist, muss das vom Spieler eingegebene
+        Kommando nur mit den ersten <flag> Zeichen von cmd uebereinstimmen.
 
-BEISPIELE:
-     // ein Kommando in einem Schirm
-     void init() {
-      ::init();
-      add_action("action_oeffne", "oeffne");
-     }
+        Als Name fuer die Funktion fun duerfen keine geschuetzten Namen wie
+        zum Beispiel create, init, reset, heart_beat etc. verwendet werden
+        (eine vollstaendige Liste findet man unter /doc/applied/).
 
-     int action_oeffne(string str) {
-      if(stringp(str) && id(str))	// Argument da und bin ich gemeint?
-       write("Du oeffnest den Schirm.\n");
-       say(break_string(this_player()->Name(WER)+" oeffnet einen Schirm.",78));
-       return 1;
-      }
-      notify_fail("Was willst Du oeffnen?\n");
-      return 0;
-     }
+BEISPIELE
+        add_action("geh_rein", "betrete");
 
-     // frueher beliebt um Spieler lahmzulegen, da es _alle_ Kommandos 
-     // triggert -> siehe heute jedoch dafuer eher P_DISABLE_COMMANDS
-     // Achtung: siehe Implikation von (3)
-     add_action("action_nothing", "",1 );
-     ...
-     int action_nothing(string str) {
-      write("Dir sind die Haende gebunden.\n");
-      return 1;
-     }
+        Wenn der Spieler "betrete" eintippt, wird die Funktion geh_rein()
+        aufgerufen.
 
-     Beispiele fuer die Verwendung des Argumentes "flag":
-      add_action("disfunc", "disconnect", AA_NOSPACE);
+        add_action("disfunc", "disconnect", AA_NOSPACE);
 
         Die Funktion disfunc() wird aufgerufen, wenn der Spieler "disconnect"
         oder eine Abkuerzung davon (zum Beispiel "di" oder "discon") eingibt.
@@ -99,14 +74,15 @@
         Um rauszufinden, was der Spieler tatsaechlich eingegeben hat, muss
         query_verb() aufgerufen werden.
 
-      add_action("fun", "cmd");
-      add_action("fun", "scmd", AA_SHORT);
-      add_action("fun", "ncmd", AA_NOSPACE);
-      add_action("fun", "icmd", AA_IMM_ARGS);
+        add_action("fun", "cmd");
+        add_action("fun", "scmd", AA_SHORT);
+        add_action("fun", "ncmd", AA_NOSPACE);
+        add_action("fun", "icmd", AA_IMM_ARGS);
 
         Die folgende Tabelle zeigt, was die oben aufgefuehrten Kommandos bzw.
         <flag> fuer Werte an query_verb() und als Argumente an die Funktion
         fun uebergeben:
+
         |-------------------|--------------|----------------------------|
         | Eingabe           | query_verb() | Argument der Funktion fun  |
         |-------------------|--------------|----------------------------|
@@ -132,18 +108,10 @@
         | "icmdbla fasel"   | "icmd"       | "bla fasel"                |
         |-------------------|--------------|----------------------------|
 
-
 GESCHICHTE
         Das Argument <flag> < 0 wird seit 3.2@127 unterstuetzt, aber erst ab
         LDMud 3.2.8 richtig implementiert. LDMud 3.2.9 fuehrte das AA_IMM_ARGS
         Flag ein. Ab LDMud 3.5 kann man Closures als Funktionen uebergeben.
 
-SIEHE AUCH:
-			remove_action(E), init(E), enable_commands(E)
-     Fehlermeldung:	notify_fail(E), _notify_fail(E)
-     Argumentstring:	query_verb(E), _unparsed_args(L)
-     obsolet:		add_verb(E), add_xverb(E)
-     alternativ:	AddAction(L), AddCmd(L)
-                        P_DISABLE_COMMANDS
-
-24. Maerz 2004 Gloinson@MG
+SIEHE AUCH
+        query_verb(E), query_command(E), add_verb(E), add_xverb(E), init(A)
diff --git a/doc/efun/all_inventory b/doc/efun/all_inventory
index ad6eea1..212c530 100644
--- a/doc/efun/all_inventory
+++ b/doc/efun/all_inventory
@@ -1,17 +1,12 @@
-all_inventory
-FUNKTION:
-     object *all_inventory()
-     object *all_inventory(object ob)
+SYNOPSIS
+        object * all_inventory()
+        object * all_inventory(object ob)
 
-BESCHREIBUNG:
-     Liefert ein Feld (Array) mit allen Objekten, die sich im Objekt ob
-     befinden (bzw. in this_object(), sofern kein Argument angegeben
-     wurde).
-     Gerade bei sehr vollen Objekten bietet sich eher first_inventory(),
-     next_inventory() an.
+BESCHREIBUNG
+        Liefert ein Feld (Array) mit allen Objekten, die sich im Objekt ob
+        befinden (bzw. in this_object(), sofern kein Argument angegeben
+        wurde).
 
-SIEHE AUCH:
-     first_inventory(E), next_inventory(E), deep_inventory(E),
-     all_environment(E), environment(E)
-
-22. Maerz 2004 Gloinson
+SIEHE AUCH
+        first_inventory(E), next_inventory(E), deep_inventory(E),
+        all_environment(E), environment(E)
diff --git a/doc/efun/call_out b/doc/efun/call_out
index dba28b3..0293b3e 100644
--- a/doc/efun/call_out
+++ b/doc/efun/call_out
@@ -2,53 +2,48 @@
         void call_out(string fun, int delay, mixed arg, ...)
         void call_out(closure cl, int delay, mixed arg, ...)
 
-DESCRIPTION
-        Set up a call to function fun in the current object, or to
-        closure cl. The call will take place in delay seconds, with the
-        remaining argument list provided. delay can be 0, but be careful!
+BESCHREIBUNG
+        Ruft zeitverzoegert die Funktion <fun> im aktuellen Objekt oder
+        die Closure <cl> auf. Der Aufruf erfolgt in <delay> Sekunden.
+        Die Funktion / Closure wird mit den <arg> Argumenten aufgerufen.
+        Die minimale Verzoegerung ist 0 (negative <delay> werden implizit als
+        0 behandelt). Allerdings ist die reale Verzoegerung etwas zwischen
+        <delay> und __ALARM_TIME__.
 
-        call_out() saves and restores the current user. It is now
-        possible to use say() or write() which rely on a current
-        user to be something useful.
+        call_out() merkt sich den aktuellen User und ruft die Funktion
+        entsprechend auf. call_out() kann nur Funktionen aufrufen, die
+        oeffentlich zugaenglich sind, das heisst "public" und "static"
+        deklarierte Funtionen. "private" und "protected" deklarierte
+        Funktionen koennen nicht aufgerufen werden.
 
-        call_out() can only call functions which are publicly accessible,
-        i.e. "public" and "static" functions. "private" and "protected"
-        functions can't be called.
+        Die Ausfuehrung von call_out()s erfordert einen einfachen (nicht
+        zu aufwendigen) Schutz gegen Rabbits: die Evalkosten aller
+        gleichzeitig anstehenden call_out()s werden auf einer pro-UID-Basis
+        summiert. Uebersteigt die Summe ein vorgegebenes Maximum, wird
+        ein Fehler 'too long evaluation' erzeugt, und es werden alle
+        call_out()s des betreffenden Benutzers, die zur gleichen Zeit
+        faellig werden, entfernt.
 
-        The execution of the call_out()s implies a simple (not
-        exhaustive) measure against rabbits: the evaluation costs of
-        those call_outs() executing at the same time are summed up on
-        a per-UID base. If the summed-up costs exceed the given maximum,
-        a 'too long evaluation' error will occur and any remaining
-        call_outs() of this user scheduled for the same time are
-        discarded.
+        Wenn zwei call_out()s zum gleichen Zeitpunkt ausgefuehrt werden
+        sollen, wird der zuerst gestartete zuerst ausgefuehrt.
 
-        Callouts are executed every 2s, therefore your delay may be bigger
-        than the you specified. In fact, a Callout with delay==0 is
-        executed within 2s from the function call to call_out(). 
-
-WARNING
-        Please never use call_out(...,0) in recursive Callouts and be at least
-        very careful in other cases. That Callout would be executed directly
-        after your current function and you really get 0 delay.
-
-EXAMPLE
+BEISPIELE
         call_out("RefreshMe", 10);
 
-        This will call the function RefreshMe() in 10 seconds without
-        any arguments. The function RefreshMe() can then call out
-        itself again which will result in a loop (not in a recursion)
-        which can be used to check or set up things in the object in
-        intervals. Be aware that callouts are stored in a linear
-        list, and so are somewhat expensive for the driver.
+        Dies ruft die Funktion RefreshMe() nach Ablauf von 10 Sekunden ohne
+        irgendwelche Argumente auf. Die Funktion RefresMe() kann dann
+        wiederum selbst call_out()s starten, auch auf sich selbst, was
+        eine Schleife erzeugt (keine Rekursion). Mit einer solchen Schleife
+        koennen Anweisungen in einem Objekt in regelmaessigen Zeitintervallen
+        ausgefuehrt werden. Es ist allerdings zu beachten, dass call_out()s
+        in einer linearen Liste gespeichert werden, und deshalb ziemlich
+        rechenaufwendig fuer den Treiber sind.
 
-        And YES: self-replicating call_out()s, where each call_out()
-        creates two or more other call_out()s in a loop (so called
-        'rabbits') slow the mud down very fast, and are even able
-        to crash it. No need to try it yourself.
+        Und JA: selbst-replizierende call_out()s, bei denen jeder call_out()
+        selbst zwei oder mehr call_out()s in einem Loop erzeugt (sogenannte
+        Rabbits) verlangsamen das Mud ungemein und koennen es sogar zum
+        Crash bringen. Kein Grund, es selbst auszuprobieren.
 
-SEE ALSO
+SIEHE AUCH
         remove_call_out(E), call_out_info(E), find_call_out(E),
         this_player(E), reset(A), heart_beat(A)
-
-05.11.06 Zesstra
diff --git a/doc/efun/count_bits b/doc/efun/count_bits
index 1b725d0..67e6dd4 100644
--- a/doc/efun/count_bits
+++ b/doc/efun/count_bits
@@ -1,20 +1,15 @@
 SYNOPSIS
-     int count_bits(string str);
+        int count_bits(string str)
 
 BESCHREIBUNG
-     Diese Funktion zaehlt die Anzahl gesetzer Bits im Bitstring <str> und
-     liefert die Anzahl als Resultat zurueck.
+        Diese Funktion zaehlt die Anzahl gesetzer Bits im Bitstring <str> und
+        liefert die Anzahl als Resultat zurueck.
 
-BEMERKUNGEN
-     Arbeitet eigentlich nur sinnvoll auf Bitstrings :)
-
-BEISPIEL
-     string s;
-     s = set_bit("", 3); s = set_bit(s, 15);
-     count_bits(s) --> liefert 2
+BEISPIELE
+        string s;
+        s = set_bit("", 3); s = set_bit(s, 15);
+        count_bits(s) --> liefert 2
 
 SIEHE AUCH
-     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), bitstrings (C)
-
-10.Apr.2007 Gloinson
+        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)
diff --git a/doc/efun/environment b/doc/efun/environment
index ea10b3d..38ca58e 100644
--- a/doc/efun/environment
+++ b/doc/efun/environment
@@ -1,69 +1,22 @@
 SYNOPSIS
-        object environment();
-        object environment(object obj);
-        object environment(string obj);
+        object environment()
+        object environment(object obj)
+        object environment(string obj)
 
-ARGUMENTE:
-     obj
-          Objekt oder Pfad-String eines Objektes dessen Umgebungsobjekt
-          gesucht ist
+BESCHREIBUNG
+        Gibt das umgebende Objekt von <obj> wider. Das Objekt <obj> kann
+        direkt angegeben werden oder ueber seinen Namen als String. Wenn
+        kein Argument angegeben wird, wird die Umgebung des aktuellen
+        Objekts zurueck gegeben.
 
-BESCHREIBUNG:
-     Es wird das Objekt bestimmt, in dem sich obj aufhaelt.
-     Wird obj nicht angegeben, so wird this_object() als Objekt angenommen.
+        Zerstoerte Objekte haben kein Environment.
 
-     Zerstoerte Objekte haben kein Environment.
+BEISPIELE
+        object room;
+        room = environment(this_player());
 
-BEMERKUNGEN:
-     - Blueprints, wie zum Beispiel Raeume haben oft kein environment(). Man
-       sollte daher ueberpruefen, ob ein environment() existiert, wenn man
-       darin oder darauf eine Funktion aufrufen will.
+        Dies liefert den Raum, in dem sich der Spieler im Moment aufhaelt.
 
-BEISPIELE:
-     // In der Variable "raum" steht der Raum, in dem sich der Spieler derzeit
-     // aufhaelt - das kann auch 0 sein!
-     raum = environment(this_player());
-
-     // Dieses Objekt hat noch kein environment, da es eben erst geclont
-     // wurde. Ergo steht in env eine 0.
-     obj = clone_object("/std/thing");
-     env = environment(obj);
-
-     // alle Methoden die auf Environment arbeiten, sollten das vorher
-     // pruefen - insbesondere tell_room()
-     if(this_player() && environment(this_player()) &&
-        objectp(o=present("schild",environment(this_player()))) {
-
-      write("Du klebst Deine Plakette auf "+o->name(WEN)+".\n");
-      tell_room(environment(this_player()), break_string(
-		this_player()->Name(WER)+" pappt einen Aufkleber auf "+
-		o->name(WEN)+".",78),
-		({this_player()}));
-     }
-
-     // wenn Dinge sehr offensichtlich in Leuten kaputtgehen wird es
-     // komplexer (man kann das natuerlich noch weiter schachteln oder
-     // ueber all_environment() versuchen zu loesen
-     if(environment()) {
-      object ee;
-      ee=environment(environment());
-      if(living(environment())) {
-       tell_object(environment(),Name(WER)+" zerfaellt.\n");
-       if(ee)
-        tell_room(ee,
-	 environment()->Name(WESSEN)+" "+name(RAW)+" zerfaellt.\n",
-	 ({environment()}));
-      } else if(ee && living(ee))
-       if(environment()->QueryProp(P_TRANSPARENT))
-        tell_object(ee, Name(WER)+" zerfaellt in Deine"+
-	 (environment()->QueryProp(P_PLURAL)?"n":
-	  (environment()->QueryProp(P_GENDER)==FEMALE?"r":"m"))+
-	 environment()->name(RAW)+".\n");
-      } else tell_room(environment(),Name(WER)+" zerfaellt.\n");
-     }
-
-SIEHE AUCH:
-        first_inventory(E), next_inventory(E), all_inventory(E)
+SIEHE AUCH
+        first_inventory(E), next_inventory(E), all_inventory(E),
         all_environment(E)
-
-20. Sep. 2002 Gloinson@MG
\ No newline at end of file
diff --git a/doc/efun/file_size b/doc/efun/file_size
index d49dd53..59a1ec3 100644
--- a/doc/efun/file_size
+++ b/doc/efun/file_size
@@ -1,35 +1,17 @@
-FUNKTION:
+SYNOPSIS
+        #include <files.h>
+
         int file_size(string file)
 
-BESCHREIBUNG:
-        Liefert die Groesse des Files in Bytes.
-
-RUECKGABEWERT:
+BESCHREIBUNG
         Liefert die Dateigroesse in Bytes.
 
-        Davon abweichend kann auch folgendes als Rueckgabewert vor-
-        kommen:
+        Existiert die angegebene Datei nicht oder ist fuer das aufrufende
+        Objekt bzw. den aufrufenden Benutzer nicht lesbar, so wird
+        FSIZE_NOFILE (-1) zurueckgeliefert.
 
-        FSIZE_NOFILE    Das File ist entweder nicht vorhanden oder das
-         (-1)           abfragende Objekt besitzt keine Leserechte dafuer.
-        FSIZE_DIR       Es handelt sich nicht um ein File sondern um
-         (-2)           ein Verzeichnis.
+        Verzeichnisse haben die Groesse FSIZE_DIR (-2).
 
-BEISPIELE:
-        Ein Spieler soll seinen Plan abfragen koennen:
-
-        #include <sys/files.h>
-        if(file_size("/p/service/loco/plans/"+
-                     getuid(this_player())+".plan") <= FSIZE_NOFILE)
-        {
-          write("Du hast keinen eigenen Plan festgelegt.\n");
-          return 1;
-        }
- 
-        this_player()->More(read_file("/p/service/loco/plans/"+
-                            getuid(this_player())+".plan");
-         
-SIEHE AUCH:
-        file_time(S), write_file(E), cat(E), get_dir(E), ls()
-
-03.08.2007, Zesstra
+SIEHE AUCH
+        write_file(E), write_bytes(E), read_file(E), read_bytes(E),
+        get_dir(E)
diff --git a/doc/efun/filter b/doc/efun/filter
index 449f144..f75b98d 100644
--- a/doc/efun/filter
+++ b/doc/efun/filter
@@ -1,168 +1,69 @@
-filter(E)
+SYNOPSIS
+        mixed * filter(mixed *arg, string fun, string|object ob
+                                             , mixed extra...)
+        mixed * filter(mixed *arg, closure cl, mixed extra...)
+        mixed * filter(mixed *arg, mapping map, mixed extra...)
 
-FUNKTION:
-    mixed * filter(mixed *arg, string fun, string|object ob
-                                         , mixed extra...)
-    mixed * filter(mixed *arg, closure cl, mixed extra...)
-    mixed * filter(mixed *arg, mapping map, mixed extra...)
+        string  filter(string arg, string fun, string|object ob
+                                          , mixed extra...)
+        string  filter(string arg, closure cl, mixed extra...)
+        string  filter(string arg, mapping map, mixed extra...)
 
-    string  filter(string arg, string fun, string|object ob
-                                      , mixed extra...)
-    string  filter(string arg, closure cl, mixed extra...)
-    string  filter(string arg, mapping map, mixed extra...)
+        mapping filter(mapping arg, string func, string|object ob
+                                               , mixed extra...)
+        mapping filter(mapping arg, closure cl, mixed extra...)
 
-    mapping filter(mapping arg, string func, string|object ob
-                                           , mixed extra...)
-    mapping filter(mapping arg, closure cl, mixed extra...)
+BESCHREIBUNG
+        Ruft fuer jedes Element des Arrays oder Mappings <arg> die Funktion
+        <ob>-><func>() bzw. die Closure <cl> auf und liefert jene Elemente,
+        fuer die die Funktion / Closure TRUE ergeben hat. Die <extra>
+        Argumente werden als zusaetzliche Parameter an die Funktion
+        uebergeben und duerfen keine Referenzen von Array- oder Mapping-
+        Elementen sein (wie &(i[1]) ).
 
+        Wird <ob> nicht angegeben oder ist es weder ein String noch ein
+        Objekt, wird standardmaessig this_object() verwendet.
 
-PARAMETER:
-    arr     - zu filterndes Array/Mapping/String
-    fun/cl  - zu rufende Methode/Closure
-    map     - filterndes Mapping
-    ob      - Objekt/Dateiname, an dem Methode gerufen werden soll
-    extra   - weitere Parameter fuer Methode/Closure
+        Ist <arg> ein Array oder struct, wird <fun> mit jedem Element des
+        Arrays/der struct als ersten Parameter aufgerufen, gefolgt von den
+        <extra> Argumenten. Wenn das Resultat der Funktion TRUE ergibt, wird
+        das Element in das Ergebnis der filter() Operation mit einbezogen.
 
-BESCHREIBUNG:        
-    Ruft fuer jedes Element des Arrays oder Mappings <arg> die Funktion
-    <ob>-><func>() bzw. die Closure <cl> auf und liefert jene Elemente,
-    fuer die die Funktion / Closure TRUE ergeben hat. Die <extra>
-    Argumente werden als zusaetzliche Parameter an die Funktion
-    uebergeben und duerfen keine Referenzen von Array- oder Mapping-
-    Elementen sein (wie &(i[1]) ).
+        Wird filter() mit einem Mapping <map> anstelle der Funktion <func>
+        aufgerufen, wird jedes Element im Array <arg>, das ein Key von <map>
+        ist, ins Ergebnis mit einbezogen.
 
-    Wird <ob> nicht angegeben oder ist es weder ein String noch ein
-    Objekt, wird standardmaessig this_object() verwendet.
+        Wenn <arg> ein Mapping ist, wird die Funktion <func> mit jedem Key
+        als erstem und (falls vorhanden) den Werten dieses Keys als zweitem
+        Parameter, gefolgt von den <extra> Argumenten, aufgerufen. Wenn die
+        Funktion TRUE ergibt, wird das betreffende Element des Mappings ins
+        Ergebnis aufgenommen.
 
-    Ist <arg> ein Array oder struct, wird <fun> mit jedem Element des
-    Arrays/der struct als ersten Parameter aufgerufen, gefolgt von den
-    <extra> Argumenten. Wenn das Resultat der Funktion TRUE ergibt, wird
-    das Element in das Ergebnis der filter() Operation mit einbezogen.
+        Abhaengig von der Groesse des Mappings <arg> erfolgt der Aufruf der
+        Funktion auf drei unterschiedliche Arten:
 
-    Wird filter() mit einem Mapping <map> anstelle der Funktion <func>
-    aufgerufen, wird jedes Element im Array <arg>, das ein Key von <map>
-    ist, ins Ergebnis mit einbezogen.
+            widthof(arg) == 0: ob->func(key, 0, extra...)
+                         == 1: ob->func(key, arg[key], extra...)
+                          > 1: ob->func( key
+                                       , ({ arg[key,0] ...arg[key,width-1] })
+                                       , extra...)
 
-    Wenn <arg> ein Mapping ist, wird die Funktion <func> mit jedem Key
-    als erstem und (falls vorhanden) den Werten dieses Keys als zweitem
-    Parameter, gefolgt von den <extra> Argumenten, aufgerufen. Wenn die
-    Funktion TRUE ergibt, wird das betreffende Element des Mappings ins
-    Ergebnis aufgenommen.
+        Der Vorteil dieser Vorgehensweise ist, dass beide Typen von
+        multidimensionalen Mappings (Mappings mit mehreren Werte pro Key und
+        Mappings aus Arrays) gleich verarbeitet werden koennen.
 
-    Abhaengig von der Groesse des Mappings <arg> erfolgt der Aufruf der
-    Funktion auf drei unterschiedliche Arten:
+        Ist <arg> ein String, werden der Filterfunktion die einzelnen Zeichen
+        des Strings uebergeben und nur jene Zeichen im zurueckgegebenen
+        String aufgenommen, fuer die die Filterfunkton != 0 zurueckgibt.
 
-        widthof(arg) == 0: ob->func(key, 0, extra...)
-                     == 1: ob->func(key, arg[key], extra...)
-                      > 1: ob->func( key
-                                   , ({ arg[key,0] ...arg[key,width-1] })
-                                   , extra...)
+ANMERKUNGEN
 
-    Der Vorteil dieser Vorgehensweise ist, dass beide Typen von
-    multidimensionalen Mappings (Mappings mit mehreren Werte pro Key und
-    Mappings aus Arrays) gleich verarbeitet werden koennen.
+        Fuer Arrays wirkt filter() wie filter_array(), fuer Mappings stellt
+        filter() eine Verallgemeinerung von filter_indices() dar.
 
-    Ist <arg> ein String, werden der Filterfunktion die einzelnen Zeichen
-    des Strings uebergeben und nur jene Zeichen im zurueckgegebenen
-    String aufgenommen, fuer die die Filterfunkton != 0 zurueckgibt.
+GESCHICHTE
+        Eingefuehrt in LDMud 3.2.6. Die Funktion loest filter_array() ab.
 
-
-AENDERUNGEN
-    Eingefuehrt in LDMud 3.2.6. Die Funktion loest filter_array() ab.
-
-RUeCKGABEWERT:
-    Gefiltertes Array mit allen die Filterbedingung erfuellenden Elementen.
-
-BEMERKUNGEN:
-    (1) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie
-    also selbst Arrays oder Mappings, so fuehrt eine spaetere Aenderung im
-    Rueckgabe-Arrays zur Aenderung im Ursprungsarray:
-
-    int *i, *j;
-    i=({({1,2,3}),({4,5,6})});
-    j=filter(i, #'sizeof);     // filtert leere Arrays heraus
-    j[0][0]=8;
-
-    fuehrt zu: i==j==({({8,2,3}),({4,5,6})});
-
-    (2) Das Kopieren in das Rueckgabemapping erfolgt fuer jedes Element nach
-    Ausfuehrung der Filtermethode. Aenderungen der Werte im Array in dieser
-    Methode (globale Variable/Uebergabe als Referenz an filter)
-    schlagen sich also im Rueckgabearray nieder.
-
-    (3) Fuer Arrays wirkt filter() wie filter_array(), fuer Mappings stellt
-    filter() eine Verallgemeinerung von filter_indices() dar.
-
-BEISPIEL:
-    ### Filtere alle Lebewesen in einem Raum in ein Array ###
-    filter(all_inventory(this_object()),#'living);
-
-    ### Filtere alle tauben Spieler im Raum in ein Array ###
-    static int filter_isdeaf(object who) {
-      return (interactive(who) && who->QueryProp(P_DEAF));
-    }
-
-    filter(all_inventory(this_object()), #'filter_isdeaf);
-
-
-    ### Filtern von Idlern (>=1 Sekunde idle) ###
-    // Folgend identische Resultate, aber andere Ansaetze:
-
-    #1: nutzt die Efun query_idle() als Lfun-Closure (ideal hier)
-        idle_usr = filter(users(), #'query_idle );
-
-    #2: mit Filtermethode
-        int check_if_idle(object user) {
-          return query_idle(user);
-        }
-
-        #2a: filtert mittels der Lfun im selben Objekt die Idler in das
-             Rueckgabearray
-             idle_usr = filter(users(), "check_if_idle");
-             idle_usr = filter(users(), "check_if_idle", this_object());
-
-        #2b: ruft die Lfun check_if_idle() als Lfun-Closure (Funktions-
-             pointer)
-             idle_usr = filter(users(), #'check_if_idle );
-
-    #3: Nutzt eine Inline-Closure
-        idle_usr = filter(users(), function int (object user) {
-                     return query_idle(user);
-                   } );
-
-    ### Filtern von Idlern (>=20 Sekunden idle) mit Extraparameter ###
-    // Folgend identische Resultate, aber andere Ansaetze:
-
-    #1: die Efun koennen wir nicht mehr direkt nutzen, weil sie
-        diesen Parameter nicht unterstuetzt
-       // idle_usr = filter(users(), #'query_idle );
-
-    #2: mit separater Filtermethode ... mit neuem Parameter
-        int check_if_idle(object user, int length) {
-          return query_idle(user)>length;
-        }
-
-        #2a: filtert mittels der Lfun im selben Objekt die Idler in das
-             Rueckgabearray ... mit drittem Parameter!
-             idle_usr = filter(users(), "check_if_idle", this_object(), 20);
-
-        #2b: ruft die Lfun check_if_idle() als Lfun-Closure (Funktions-
-             pointer)
-             idle_usr = filter(users(), #'check_if_idle, 20);
-
-    #3: Nutzt eine Inline-Closure
-        idle_usr = filter(users(), function int (object user, int length) {
-                     return (query_idle(user) > length); 
-                     }, 20);
-
-SIEHE AUCH:
-     Arrays:        map(E)
-     Objektarrays:  filter_objects(E), map_objects(E)
-     Mappings:      filter_indices(E), map_indices(E)
-                    walk_mapping(E), member(E)
-
-     Sonstiges:     sort_array(E), unique_array()
-                    transpose_array(E)
-
-----------------------------------------------------------------------------
-23.09.2019, Zesstra
+SIEHE AUCH
+        filter(E), filter_indices(E), map(E), walk_mapping(E), member(E),
+        m_contains(E)
diff --git a/doc/efun/filter_objects b/doc/efun/filter_objects
index 9fb6922..87c96f6 100644
--- a/doc/efun/filter_objects
+++ b/doc/efun/filter_objects
@@ -1,59 +1,11 @@
-filter_objects(E)
+SYNOPSIS
+        object * filter_objects(object *arr, string fun, mixed extra, ...)
 
-FUNKTION:
-     object *filter_objects(mixed *arr, string fun, [, mixed extra, ...])
+BESCHREIBUNG
+        Diese Efun ist aehnlich wie filter(), es wird aber
+        arr[n]->fun(extra,...) aufgerufen. Wenn der Aufruf einen Wert != 0
+        liefert, wird das Objekt arr[n] in das Resultat uebernommen.
+        0-Eintraege in <arr> werden ignoriert.
 
-PARAMETER:
-     arr	- zu filterndes Array von Objekten/Objektpfaden
-     fun	- an Objekten zu rufende Methode
-     extra	- weitere Parameter fuer Methode
-
-BESCHREIBUNG:
-     Filtert die Elemente aus 'arr' durch den Aufruf der Methode 'fun' an
-     jedem der Elemente von 'arr'. 0-Eintraege werden ignoriert.
-
-     Wenn der Aufruf
-	arr[n]->fun([extra1, extra2, ...])
-     als Rueckgabewert !=0 zurueckgibt dann wird das Element in das neue
-     Array aufgenommen, sonst nicht.
-
-RUeCKGABEWERT:
-     Gefiltertes Array mit Filterbedingung erfuellenden Objekten.
-
-BEMERKUNGEN:
-     Werden Pfade angegeben, so wird versucht ein Objekt zu laden, falls
-     dieses nicht existiert.
-
-BEISPIEL:
-     // gibt alle tauben Personen wieder
-     deaf=filter_objects(users(), "QueryProp", P_DEAF);
-
-     // gibt alle blinden Personen wieder
-     blind=filter_objects(users(), "QueryProp", P_BLIND);
-
-     // filtert alle Objekte auf eine bestimmte ID (-> present)
-     idmatch=filter_objects(arr, "id", "irgendwasID");
-
-     // gibt alle Autoloader wieder
-     al=filter_objects(all_inventory(this_player()),
-                      "QueryProp", P_AUTOLOADOBJ);
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
-     int i;
-     object *ret; mixed *input;
-
-     ret=allocate(0);
-     i=sizeof(input);
-     while(i--)
-       if(input[i]->fun([extra1, extra2, ...]))
-         ret+=({input[i]});
-
-SIEHE AUCH:
-     Arrays:		filter(E), map(E)
-     Objektarrays:	map_objects(E)
-     Mappings:		filter_indices(E), map_indices(E)
-
-     Sonstiges:		sort_array(E), unique_array()
-			alist, transpose_array(E)
-
-20.Jan 2005 Gloinson
+SIEHE AUCH
+        filter(E), map(E), map_objects(E)
diff --git a/doc/efun/find_call_out b/doc/efun/find_call_out
index 3517518..6716a04 100644
--- a/doc/efun/find_call_out
+++ b/doc/efun/find_call_out
@@ -1,37 +1,28 @@
-FUNKTION:
-        int find_call_out(string func)
-        int find_call_out(closure cl)
+SYNOPSIS
+        int find_call_out(string fun)
+        int find_call_out(closur cl)
 
-BESCHREIBUNG:
-        Findet den ersten call_out() auf die Funktion 'func' im aktuellen Objekt
-        (bzw. auf die Closure 'cl') der ausgefuehrt werden soll.
-        Zurueck gegeben wird die verbleibende Zeit bis zum Aufruf in Sekunden.
-        Wenn kein call_out() gefunden wird, wird -1 zurueck gegeben.
+BESCHREIBUNG
+        Findet den ersten call_out() auf die Funktion fun im aktuellen Objekt
+        (bzw. auf die Closure cl) der ausgefuehrt werden soll. Zurueck gegeben
+        wird die verbleibende Zeit bis zum Aufruf. Wenn kein call_out()
+        anhaengig ist, wird -1 zurueck gegeben.
 
-BEISPIELE:
-        // Findet sich kein call_out auf die Funktion 'func', so kann er
-        // gestartet werden. (Wichtig falls der call_out nicht mehrfach
-        // aufgerufen werden soll).
- 
-        if(find_call_out("func")==-1)
-          call_out("func",5);
+FEHLER
+        Die Suche nach call_out()s auf Closures funktioniert nur, wenn der
+        genaue Wert der Closure gesucht wird.
 
-        // Die Suche nach call_out()s auf Closures funktioniert nur, wenn der
-        // genaue Wert der Closure gesucht wird.
-
-        // Das funktioniert:
+        Das funktioniert:
             closure cl = symbol_function("main", obj);
             call_out(cl, 2);
             find_call_out(cl);
 
-        // Das funktioniert nicht:
+        Das funktioniert nicht:
             call_out(symbol_function("main", obj), 2);
             find_call_out(symbol_function("main", obj));
 
-        Ein Codebeispiel, um alle call_out()s auf eine Funktion zu entfernen,
-        findet sich in der Manpage zu remove_call_out().
+GESCHICHTE
+        Die Suche nach call_out()s auf Closures wurde in 3.2.1@45 eingefuehrt.
 
-SIEHE AUCH:
+SIEHE AUCH
         call_out(E), remove_call_out(E), call_out_info(E)
-
-25.08.2016, Arathorn
diff --git a/doc/efun/get_eval_cost b/doc/efun/get_eval_cost
index 50bc012..ac3ab9d 100644
--- a/doc/efun/get_eval_cost
+++ b/doc/efun/get_eval_cost
@@ -1,33 +1,16 @@
-FUNKTION:
-        int get_eval_cost(void)
+SYNOPSIS
+        int get_eval_cost()
 
-BESCHREIBUNG:
+BESCHREIBUNG
         Liefert die noch verbleibenden Eval Kosten, die das momentane
         Kommando noch verbrauchen darf.
-        Der Maximalwert betraegt zur Zeit 1.500.000 Ticks (Stand: 2007). 
 
-        Sollten die Kosten bei der Ausfuehrung irgendwo groesser werden,
-        wird ein Fehler der Art "too long eval" erzeugt. Diese Funktion
-        dient dazu, solche Fehler genau zu lokalisieren bzw. 
-        herauszufinden, an welchen Stellen im Code wieviel Rechenzeit 
-        verbraucht wird.
-        
-BEISPIELE
-        void foo()
-        {
-          int prev, used, i;
-          
-          prev=get_eval_cost(); // Merken, was bis hierhin verbraucht wurde 
-          for (i=0;i<=1000;i++) // Dann kommt der zu testende Code, zB eine
-          {                     // Schleife
-            ...
-          }
-          used=prev-get_eval_cost(); // Berechnung der Differenz
-          printf("Die Schleife verbrauchte %d Ticks.\n", used);
-        }
+        Das Resultat beginnt bei einer hohen, vom Treiber festgelegten Zahl
+        und nimmt fuer jede ausgefuehrte Anweisung ab.
 
-SIEHE AUCH:
-        caller_stack_depth(E), rusage(E), command(E), query_limits(E)
-        Konstante: __MAX_EVAL_COST__
+GESCHICHTE
+        Der Anfangswert, also die vom Treiber zur Verfuegung gestellten Evals,
+            sind seit 3.2.6 in LDMud als Makro verfuegbar.
 
-4.Aug 2007 Gloinson
+SIEHE AUCH
+        rusage(E), command(E), query_limits(E)
diff --git a/doc/efun/lambda b/doc/efun/lambda
index b156798..14a709f 100644
--- a/doc/efun/lambda
+++ b/doc/efun/lambda
@@ -1,5 +1,5 @@
 SYNOPSIS
-        closure lambda(mixed *arr, mixed);
+        closure lambda(mixed *arr, mixed)
 
 BESCHREIBUNG
         Erzeugt eine Lambda Closure, entsprechend den Lamda Closures in LISP.
@@ -10,19 +10,8 @@
         beschreibt, die der Closure bei ihrer Auswertung durch funcall()
         oder apply() uebergeben werden.
 
-        Von der Verwendung wird aus Lesbarkeits- und Wartungsgruenden dringend
-        abgeraten.
-
-BEISPIEL
-        // Lambdas werden gern eingesetzt, um komplexere Filter zu schreiben
-        // Allerdings kann jede Lambda dabei auch durch eine Inline-Closure
-        // oder eine LFun-Closure ersetzt werden.
-        filter(users(), 
-          lambda(({'x}),
-                 ({#'==,
-                   ({#'call_other,'x,"QueryProp",P_SECOND}),"gloinson"
-                })));
+GESCHICHTE
+        Eingefuehrt in 3.2@70.
 
 SIEHE AUCH
-        Verwandt: unbound_lambda(E), apply(E), funcall(E), bind_lambda(E)
-        Generell: closures-abstract(LPC), closures(LPC)
+        closures(LPC), unbound_lambda(E), apply(E), funcall(E), bind_lambda(E)
diff --git a/doc/efun/limited b/doc/efun/limited
index c967812..1155af1 100644
--- a/doc/efun/limited
+++ b/doc/efun/limited
@@ -1,30 +1,32 @@
 VORLAEUFIG, GESCHUETZT
 SYNOPSIS
-        #include <sys/rtlimits.h>
+        #include <rtlimits.h>
 
-        mixed limited(closure fun);
-        mixed limited(closure fun, int tag, int value, ...);
-        mixed limited(closure fun, int *limits [, mixed *args]);
+        mixed limited(closure fun)
+        mixed limited(closure fun, int tag, int value, ...)
+        mixed limited(closure fun, int *limits)
+        mixed limited(closure fun, int *limits, mixed *args)
 
 BESCHREIBUNG
         limited() ruft die Funktion <fun> mit den bezeichneten Argumenten
-        <args> auf und fuehrt sie mit den gegebenen Laufzeitlimiten aus.
+        <args> auf und fuehrt sie mit den gegebenen Laufzeitlimitierungen aus.
 
         Beim Ende der Funktion <fun> werden die momentan aktiven
-        Laufzeitlimiten wiederhergestellt. limited() liefert den
+        Laufzeitlimitierungen wiederhergestellt. limited() liefert den
         Rueckgabewert der Closure <fun> zurueck.
 
-        Die Laufzeitlimiten koennen in zwei Formen angegeben werden: als
-        Array (wie es von query_limits() geliefert wird) oder als Liste von
-        Werten mit Tags. Wird limited() ohne Angabe von Limits aufgerufen,
-        gelten die Laufzeitlimiten als 'unlimitiert'.
+        Die Laufzeitlimitierungen koennen in zwei Formen angegeben werden: 
+        *  als Array (wie es von query_limits() geliefert wird) oder 
+        *  als Liste von Werten mit Tags.
+        Wird limited() ohne Angabe von Limits aufgerufen, gelten die
+        Laufzeitlimiten als 'unlimitiert'.
 
-        Die Limiteneinstellung kennt drei spezielle Werte aus <rtlimits.h>:
+        Die Limitierung kennt drei spezielle Werte aus <rtlimits.h>:
             LIMIT_UNLIMITED:    es gibt kein Limit
             LIMIT_KEEP:         das zuletzt gesetzte Limit wird beibehalten
-            LIMIT_DEFAULT:      die 'globalen' Limiten werden verwendet
+            LIMIT_DEFAULT:      die 'globalen' Limitierungen werden verwendet
 
-        Fuer LIMIT_COST, die Spezialwerte haben diese Bedeutung:
+        Fuer LIMIT_COST haben folgende Spezialwerte eine Bedeutung:
             LIMIT_UNLIMITED: die Ausfuehrung kosten lediglich einen Tick
             LIMIT_KEEP:      LIMIT_COST wird auf 0 gesetzt
             LIMIT_DEFAULT:   LIMIT_COST wird auf -100 gesetzt
@@ -32,33 +34,23 @@
         limited() erzeugt eine Schutzverletzung ("limited", current_object,
         fun, limits-array).
 
-BEMERKUNGEN:
-        Diese Funktion kann bei uns mudlibweit genutzt werden. Allerdings wird
-        nur die _Reduktion_ von LIMIT_EVAL zugelassen, alle anderen Limits
-        duerfen _nicht_ veraendert werden. Hierbei ist zu beachten, dass das
-        Limit fuer LIMIT_EVAL um min. 1000 Ticks unter den noch verfuegbaren
-        Ticks liegen muss (get_eval_cost()).
-        Fuer LIMIT_COST sind nur 0 und -100 zugelassen.
 
 BEISPIELE
         limited(#'function)
-        --> fuehrt die Funktion ohne Limiten aus.
+        --> fuehrt die Funktion ohne Limits aus.
 
         limited(#'function, ({ 200000 }), "foo")
-        --> fuehrt die Funktion mit einem Eval-Kosten Limit von 200000 Ticks
+        --> fuehrt die Funktion mit einem Eval-Kosten-Limit von 200000 Ticks
             aus. Die Funktion wird als 'function("foo")' aufgerufen.
 
         limited(lambda(0, ({#'function, "foo"})), LIMIT_EVAL, 200000)
-        --> fuehrt die Funktion mit einem Eval-Kosten Limit von 200000 Ticks
+        --> fuehrt die Funktion mit einem Eval-Kosten-Limit von 200000 Ticks
             aus. Die Funktion wird als 'function("foo")' aufgerufen.
 
-AENDERUNGEN
+GESCHICHTE
         Eingefuehrt in LDMud 3.2.7.
         LDMud 3.3.563 fuehrte LIMIT_COST ein.
+        LDMud 3.5.0 fuehrte LIMIT_MEMORY ein.
 
 SIEHE AUCH
         query_limits(E), set_limits(E)
-        get_eval_cost(E)
-
-16.05.2007, Zesstra
-
diff --git a/doc/efun/map_indices b/doc/efun/map_indices
deleted file mode 100644
index de3b15f..0000000
--- a/doc/efun/map_indices
+++ /dev/null
@@ -1,75 +0,0 @@
-map_indices(E)
-
-FUNKTION:
-     mapping map_indices(mapping m, string fun, object ob [, mixed extra])
-     mapping map_indices(mapping m, closure cl [, mixed extra])
-
-PARAMETER:
-     arr	- zu mappendes Array
-     fun/cl	- zu rufende Methode/Closure
-     ob		- Objekt/Dateiname, an dem Methode gerufen werden soll
-     extra	- weitere Parameter fuer Methode/Closure
-
-BESCHREIBUNG:
-     Mapped die Elemente (jeweils Schluessel) aus 'map' durch die Methode
-     'fun' oder die Closure 'cl' in ein neues Mapping.
-     Fuer jedes Element aus 'm' wird 'fun' oder 'cl' mit dem Schluessel als
-     erstem Parameter [und folgend den optionalen Extra-Parametern] gerufen.
-
-     Der Rueckgabewert der Methode/Closure wird in fuer den Schluessel als
-     Datenwert in das neue Mapping eingetragen.
-
-     ACHTUNG: Alle anderen Daten bei Mapping mit Breite>1 verfallen!
-
-     Verwendung von Methoden:
-	Wenn bei der Angabe von 'fun' kein Objekt 'ob' in Form eines Strings
-	oder Objekts angegeben wird, wird this_object() angenommen.
-
-     Verwendung von Closures:
-	Es koennen sowohl Lfun-Closures als auch Lambda-Closures verwendet
-	werden. Lfun-Closures koennen, wenn im selben Objekt vorhanden auch
-	'private' oder/und 'static' deklariert sein, muessen aber zu dem
-	Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
-
-RUeCKGABEWERT:
-     Mapping mit Schluessel:Rueckgabewerten der Methode/Closure.
-
-BEISPIELE:
-     // ersetze in einem Mapping die Datenwerte durch das Doppelte,
-     // nutze dabei die Datenwerte des Altmappings durch Uebergabe als
-     // extra-Parameter
-
-     // Anmerkung: Das geht mit walk_mapping() eleganter!
-
-     int do_double(string key, mapping m, int mult) {
-      return m[key]*mult;
-     }
-
-     mapping x, y;
-     x=(["a":2, "b":3]);
-     y=map_indices((["a":2, "b":3]), #'do_double, &x, 3);
-
-     y == (["a":6,"b":9])
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
-     int i;
-     mapping ret; mapping input;
-     mixed *index;
-
-     ret=m_allocate(0, 1);
-     index=m_indices(input);
-     i=sizeof(index);
-     while(i--)
-       ret[index[i]]=ob->fun(index[i] [, extra1, extra2, ...]))
-       // ret[index[i]]=funcall(cl, index[i] [, extra1, extra2, ...]);
-
-SIEHE AUCH:
-     Arrays:		filter(E), map(E)
-     Objektarrays:	filter_objects(E), map_objects(E)
-     Mappings:		filter_indices(E)
-
-     Sonstiges:		walk_mapping(E), m_contains(E)
-			member()
-			m_indices(E), m_values(E)
-
-29.10.2006 Zesstra
diff --git a/doc/efun/map_objects b/doc/efun/map_objects
index 4543a2e..a0961f9 100644
--- a/doc/efun/map_objects
+++ b/doc/efun/map_objects
@@ -1,51 +1,15 @@
-map_objects(E)
+SYNOPSIS
+        mixed * map_objects(object *arr, string fun, mixed extra, ...)
+        mixed * map_objects(string *arr, string fun, mixed extra, ...)
 
-FUNKTION:
-     object *map_objects(object *arr, string fun [, mixed extra])
+BESCHREIBUNG
+        map_objects() verhaelt sich aehnlich wie map(), ruft jedoch
+        arr[n]->fun(extra, ...) auf. Der Rueckgabewert ersetzt das Objekt bzw.
+        den Objektnamen in <arr>.
+        <arr> kann auch eine Mischung aus Objekten und Objektnamen enthalten.
+        Es ist eine beliebige Anzahl <extra> Argumente erlaubt, welche alle an
+        die Funktion <fun> uebergeben werden.
+        0-Eintraege in <arr> werden ignoriert.
 
-PARAMETER:
-     arr	- zu mappendes Array von Objekten/Objektpfaden
-     fun	- an Objekten zu rufende Methode
-     extra	- weitere Parameter fuer Methode
-
-BESCHREIBUNG:
-     Mapped die Elemente aus 'arr' durch den Aufruf der Methode 'fun' an
-     jedem der Elemente von 'arr' in ein neues Array.
-     0-Eintraege werden ignoriert.
-
-     Der Rueckgabewert von
-	arr[n]->fun([extra1, extra2, ...])
-     wird an der Indexposition des Elementes in das neue Array eingetragen.
-
-RUeCKGABEWERT:
-     Array mit Resultaten der Funktionsaufrufe am jeweiligen Objekt.
-
-BEMERKUNGEN:
-     Werden Pfade angegeben, so wird versucht ein Objekt zu laden, falls
-     dieses nicht existiert.
-
-BEISPIEL:
-     // ersetze alle Objekte durch ihre Namen
-     arr=map_objects(inputarr, "name");
-
-     // ersetze alle Objekte durch ihre Namen im Genitiv
-     arr=map_objects(inputarr, "name", WESSEN);
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
-     int i;
-     object *ret; mixed *input;
-
-     i=sizeof(input);
-     ret=allocate(i);
-     while(i--)
-       ret[i]=input[i]->fun([extra1, extra2, ...]);
-
-SIEHE AUCH:
-     Arrays:		filter(E), map(E)
-     Objektarrays:	filter_objects(E)
-     Mappings:		filter_indices(E), map_indices(E)
-
-     Sonstiges:		sort_array(E), unique_array()
-			alist, transpose_array(E)
-
-20.Jan 2005 Gloinson
+SIEHE AUCH
+        map(E), filter(E), filter_objects(E)
diff --git a/doc/efun/raise_error b/doc/efun/raise_error
index 40ac234..e063420 100644
--- a/doc/efun/raise_error
+++ b/doc/efun/raise_error
@@ -1,5 +1,5 @@
 SYNOPSIS
-        void raise_error(string arg);
+        void raise_error(string arg)
 
 BESCHREIBUNG
         Bricht die Ausfuehrung des laufenden Programms ab. Wenn das Programm
@@ -14,10 +14,5 @@
         einschliesslich der Erzeugung eines Stack Backtraces, ist diese
         Funktion sehr zeitintensiv.
 
-BEMERKUNGEN
-        Der String sollte umgebrochen oder wenigstens mit einem \n terminiert
-	werden, da die Ausgabe direkt an den interaktiven Magier erfolgen
-	kann bzw. auf dem Debug-Kanal das letzte Zeichen entfernt wird.
-
 SIEHE AUCH
         catch(E), throw(E)
diff --git a/doc/efun/random b/doc/efun/random
index a98542b..d3f876f 100644
--- a/doc/efun/random
+++ b/doc/efun/random
@@ -1,42 +1,16 @@
-FUNKTION:
+SYNOPSIS
         int random(int n)
 
-ARGUMENTE:
-        n: Zahlen-Bereich aus dem gewaehlt werden soll.
+BESCHREIBUNG
+        Liefert eine Zufallszahl im Bereich [0 .. n-1].
 
-BESCHREIBUNG:
-        Gibt eine zufaellige Zahl im Bereich von 0..(n-1) zurueck.
+        Dieser Zufallszahlgenerator liefert eine gleichmaessige Verteilung von
+        Zahlen ueber einen grossen Bereich, ohne Wiederholung von Sequenzen
+        waehrend einer langen Zeit. Der Nachteil dieser (wuenschenswerten)
+        Qualitaeten ist, dass wenn viele Zahlen in einem kleinen Bereich in
+        kurzer Zeit generiert werden, einige Zahlen sehr viel haeufiger
+        auftreten als andere.
 
-BEMERKUNGEN:
-        Der Nachteil der Zufaelligkeit (ueber grosse Zahlen) ist, dass wenn
-        viele Zahlen in einem kleinen Bereich in kurzer Zeit generiert
-        werden, einige Zahlen sehr viel haeufiger auftreten als andere.
-
-        Es sei nochmal darauf hingewiesen, dass der Bereich immer bei 0 
-        und NICHT bei 1 anfaengt. Ein random(10) geht also nicht von 
-        1..10 sondern von 0..9!
-
-BEISPIELE:
-        // Einfache Abfrage z.B. aus der HitFunc einer Waffe:
-
-        if(random(101) >= 70) return random(11);
-        else                  return 0;
-
-        // Spieler soll in einen zufaellig ausgewaehlten Raum gemovt
-        // werden: 
-
-        string *dest = ({ "raum1","raum2","raum3","raum4","raum5" });
-        this_player()->move(dest[random(sizeof(dest))],M_GO|M_NOCHECK);
-
-        // Es soll eine zufaellige Meldung ausgegeben werden:
-
-        tell_object(this_player(),
-         ({ "Es knackt.\n", "Dir ist kalt.\n", "Du schwitzt.\n",
-            "Du bekommst Angst.\n", "Hinter Dir knackt es im Gebuesch.\n",
-            "Ein kuehler Wind kommt auf.\n" })[random(6)]);
-
-        Wie man sieht, gibt es fuer random() viele schoene Einsatz-
-        moeglichkeiten. Wobei letzteres Beispiel ueber AddRoomMessage
-        (fuer Raeume) viel einfacher umzusetzen ist.
-
-7.Aug 2007 Gloinson
+        Die einzige Loesung hierzu ist eine spezielle simul_efun, die geeignete
+        Schritte unternimmt, um eine gleichmaessige Verteilung ueber kleine
+        Bereiche in kurzen Zeitraeumen zu erreichen.
diff --git a/doc/efun/regexplode b/doc/efun/regexplode
index 595e9df..ca67db8 100644
--- a/doc/efun/regexplode
+++ b/doc/efun/regexplode
@@ -1,8 +1,8 @@
 SYNOPSIS
         #include <regexp.h>
 
-        string *regexplode (string text, string pattern)
-        string *regexplode (string text, string pattern, int opt)
+        string * regexplode(string text, string pattern)
+        string * regexplode(string text, string pattern, int opt)
 
 DESCRIPTION
         This function is similar to explode but accepts a regular
@@ -19,9 +19,11 @@
         regexplode("abcdef", "cde", RE_OMIT_DELIM) -> ({ "ab", "f" })
 
 HISTORY
-        Introduced in 3.2@61
+        Introduced in 3.2@61.
         LDMud 3.3 added the optional <opt> argument and the RE_OMIT_DELIM
           flag.
+        Since 3.5.0 a error is raised if RE_PCRE is specified in <opt>, but
+        the driver lacks PCRE support.
 
 SEE ALSO
         explode(E), regexp(E), regmatch(E), regreplace(E),
diff --git a/doc/efun/replace_program b/doc/efun/replace_program
index 4812d4e..d2f41b4 100644
--- a/doc/efun/replace_program
+++ b/doc/efun/replace_program
@@ -1,6 +1,6 @@
 SYNOPSIS
-        void replace_program();
-        void replace_program(string program);
+        void replace_program()
+        void replace_program(string program)
 
 BESCHREIBUNG
         Ersetzt ein Programm mit dem geerbten Programm (inherit) <program>.
@@ -36,17 +36,12 @@
         verschwundene Lfuns des Objekts referenzieren. Das stellt allerdings
         kein Problem dar, solange diese Referenzen nicht ausgefuehrt werden.
 
-BEMERKUNGEN
-        Raeume benutzen replace_program automatisch. Es ist nicht sinnvoll
-        oder notwendig, replace_program selbst ohne Konsultaton mit einem
-        Erzmagier einzusetzen!
-
-BUGS
+FEHLER
         Wenn ein ersetzendes Programm virtuell geerbte Variablen enthaelt,
         muss dieses Programm als erstes geerbt werden. Ohne diese
         Einschraenkung ueberleben die falschen Variablen den
         Ersetzungsprozess.
 
-AENDERUNGEN
+GESCHICHTE
         LDMud 3.2.9 liess zu, dass das Argument <program> weggelassen wird,
         wenn nur ein Inherit existiert.
diff --git a/doc/efun/save_object b/doc/efun/save_object
index 681946b..2ec83b2 100644
--- a/doc/efun/save_object
+++ b/doc/efun/save_object
@@ -1,10 +1,10 @@
 SYNOPSIS
-        int save_object(string name [, int format]);
-        string save_object([int format]);
+        int    save_object(string name [, int format])
+        string save_object([int format])
 
 BESCHREIBUNG
-        Codiert die speicherbaren (s.u.) Variablen des aktuellen Objekts in
-        einen String.
+        Codiert die speicherbaren Variablen des aktuellen Objekts in einen
+        String.
 
         In der ersten Form wir der String in die Datei <name> geschrieben. Eine
         Endung ".c" in <name> wird entfernt, dafuer kann eine Endung ".o"
@@ -24,23 +24,17 @@
              0: das Originalformat nach Amylaar's LPMud und LDMud <=3.2.8
              1: LDMud >= 3.2.9: Non-Lambda Closures, Symbole und gequotete
                 Arrays koennen gespeichert werden
+             2: LDMUd >= 3.5.0: Gleitkommazahlen werden in einem neuen Format
+                geschrieben, welches kompakter ist die Gleitkommazahlen aus
+                3.5.x verlustfrei speichern kann.
+        
+        Es wird empfohlen, die Angabe des Formats wegzulassen oder in Version
+        2 (oder hoeher) zu speichern.
 
         Eine Variable wird als 'speicherbar' betrachtet, wenn sie nicht als
         'nosave' oder 'static' deklariert ist.
 
-        Bitte beachten, dass diese efun im MG durch eine Sefun ueberschrieben
-        wird und deren Manpage auch lesen!
-
-BEMERKUNGEN:
-        Damit ein Objekt in Verzeichnisse der Region/des Magiers schreiben
-        kann, muss es entsprechende Rechte, also eine gueltige EUID
-        besitzen. Im create() sollte daher ein:
-
-        seteuid(getuid(this_object()));
-
-        stehen.
-
-AENDERUNGEN
+GESCHICHTE
         Seit LDMud 3.2.8 liefert save_object() einen fixen Wert bei Erfolg.
         Das direkte Abspeichern in einen String wurde in LDMud 3.2.8
             eingefuehrt, wird aber in Zukunft eventuell in eine separate Efun
@@ -49,6 +43,7 @@
             Closures, Symbolen und gequoteten Arrays. Dazu wurde ein neues
             Format fuer die Speicherdatei eingefuehrt.
         LDMud 3.2.10 fuehrte das Argument <format> ein.
+        LDMud 3.5.0 fuehrte Formatversion 2 ein.
 
 SIEHE AUCH
-        restore_object(E), save_value(E), save_object (Sefun)
+        restore_object(E), save_value(E)
diff --git a/doc/efun/say b/doc/efun/say
index 6f0958f..61dc373 100644
--- a/doc/efun/say
+++ b/doc/efun/say
@@ -1,11 +1,11 @@
 SYNOPSIS
-        void say(string str);
-        void say(string str, object exclude);
-        void say(string str, object *excludes);
+        void say(string str)
+        void say(string str, object exclude)
+        void say(string str, object *excludes)
 
-        void say(mixed *|mapping|struct|object msg);
-        void say(mixed *|mapping|struct|object msg, object exclude);
-        void say(mixed *|mapping|struct|object msg, object *excludes);
+        void say(mixed *|mapping|struct|object msg)
+        void say(mixed *|mapping|struct|object msg, object exclude)
+        void say(mixed *|mapping|struct|object msg, object *excludes)
 
 BESCHREIBUNG
         Es bestehen zwei Hauptanwendungen fuer say():
@@ -14,21 +14,22 @@
         lebendigen Objekte im aktuellen Raum gesendet, ausser zum Objekt,
         das die Funktion aufgerufen hat.
 
-        Ist die Nachricht ein String, wird der Text an interaktive Objekte
-        direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
-        in diesen aufgerufen.
-        Falls ein Lewebesen die Funktion catch_tell() definiert (-> shadow),
-        so wird der Text hier ausgewertet und nicht an den User ausgegeben.
+        Wenn das erste Argument ein nicht-String <msg> ist, wird die Lfun
+        catch_msg() in allen lebendigen Objekt im Raum aufgerufen, ausser im
+        Objekt, das say() aufgerufen hat. Der Wert <msg> wird als erstes
+        Argument an catch_msg() uebergeben, das aufrufende Objekt als zweites
+        Argument.
 
-        Wenn das zweite Argument, die Nachricht, kein String ist, wird in
-        allen Lebewesen, die den Text erhalten, catch_msg() anstatt
-        catch_tell() aufgerufen.
+        MERKE: Wenn die Lfun catch_msg() den Wert <msg> veraendert, erhalten
+        alle nachfolgenden Objekte das veraenderte <msg>.
 
-        Mit dem Array <*exclude> kann man verhindern, dass die Nachricht an
-        die darin enthaltenen Objekte gesendet wird. Der Sender muss nicht
-        noch einmal aufgefuehrt werden.
-        Das ist sinnvoll, wenn zB eine Spielergruppe Ausloeser einer Meldung
-        ist und diese selbst nicht erhalten soll.
+        Wird der Efun say() ein zweites Argument angegeben, kann man andere
+        Objekte als nur das aufrufende Objekt ausschliessen. Wenn das zweite
+        Argument ein einzelnes Objekt <exclude> ist, werden das aufrufende
+        Objekt und <exclude> von der Meldung ausgeschlossen. Wenn das zweite
+        Argument ein Array <excludes> ist, werden alle Objekte aus dieser
+        Liste zusaetzlich zum aufrufenden Objekt als Empfaenger von say()
+        ausgeschlossen.
 
         Das aufrufende Objekt wird nach folgenden Regeln bestimmt:
           - Wenn say() aus einem lebendigen Objekt aufgerufen wird, gilt
@@ -37,62 +38,61 @@
             Handlung eines Benutzers aufgerufen wird (das heisst,
             this_player() ist gueltig), gilt this_player() als aufrufendes
             Objekt.
-          - In allen anderen Faellen (Aufruf aus reset zB) gilt das Objekt,
-            das say() aufgerufen hat, als aufrufendes Objekt.
-
-BEMERKUNGEN
-        - fuer laengere Meldungen sollte break_string() verwendet werden
-        - wird in einem catch_msg() der Wert von <msg> veraendert, erhalten
-          alle nachfolgenden Objekte das veraenderte <msg> (Referenz!)
-
-        - say(<str>) ist verhaltensgleich zu
-          tell_room(environment(), <str>, ({this_player()||this_object()}))
+          - In allen anderen Faellen gilt das Objekt, das say() aufgerufen
+            hat, als aufrufendes Objekt.
 
 BEISPIELE
-        // Folgende Aufrufe sind gleich, wenn sie durch ein Spielerkommando
-        // in einem nicht lebendigen Objekt aufgeloest werden:
+        Folgende Aufrufe sind gleich, wenn sie aus einem nicht lebendigen
+        Objekt aufgerufen werden:
 
             say("Hi!\n");
             say("Hi!\n", this_player());
 
-        // Das folgende Beispiel zeigt, wie say() zusammen mit catch_tell()
-        // funktioniert. Das zweite Objekt darf nicht lebendig sein, damit
-        // write() an den aktuellen Benutzer geht.
+        Das folgende Beispiel zeigt, wie say() zusammen mit catch_tell()
+        funktioniert. Das zweite Objekt darf nicht lebendig sein, sodass
+        write() an den aktuellen Benutzer geht.
 
         Objekt 1 (living):
-            void catch_tell(string str) {
+            void catch_tell(string str)
+            {
                 write("Empfangen: "+str+"\n");
             }
 
         Objekt 2 (nicht living):
-            void func() {
+            void func()
+            {
                 ...
                 say("HiHo!\n");
                 ...
             }
 
-        // Ein etwas komplexeres Beispiel zeigt das Zusammenspiel von say()
-        // und catch_msg(). Auch hier wird ein nicht-lebendiges Objekt
-        // verwendet, das die Nachricht ausgibt, sodass das 'wer' in
-        // catch_msg() auf den aktuellen Benutzer zeigt.
+        Ein etwas komplexeres Beispiel zeigt das Zusammenspiel von say()
+        und catch_msg(). Auch hier wird ein nicht-lebendiges Objekt
+        verwendet, das die Nachricht ausgibt, sodass das 'wer' in
+        catch_msg() auf den aktuellen Benutzer zeigt.
 
         Object 1 (living):
             void catch_msg(mixed *arr, object who) {
-                foreach(mixed element: arr)
-                    tell_object(who, sprintf("%O\n", element));
+                int i;
+                if (!arr) return;
+                for (i=0;i<sizeof(arr);i++)
+                    tell_object(who, (stringp(arr[i]) ? arr[i] : "-/-")+"\n");
             }
 
         Object 2 (nicht living):
             void func() {
                 ...
-                say( ({ "Hello", "there!" }) );
+                say(({ "Hello", "there!" }));
                 ...
             }
 
-SIEHE AUCH
-        Aehnlich:   tell_room(E), write(E), shout(E), tell_object(E),
-                    printf(E)
-        Verwandt:   catch_tell(E), catch_msg(A)
-        Sonstiges:  object_name(E)
+ANMERKUNGEN
+        Wenn die Lfun catch_msg() den Wert <msg> veraendert, erhalten alle
+        nachfolgenden Objekte das veraenderte <msg>.
 
-7.Aug 2007 Gloinson
\ No newline at end of file
+GESCHICHTE
+        LDMud 3.3.686 erlaubt die Verwendung eines mapping/struct/object als
+        zweites Argument.
+
+SIEHE AUCH
+        write(E), tell_object(E), tell_room(E)
diff --git a/doc/efun/set_next_reset b/doc/efun/set_next_reset
index 89e09c5..20961ea 100644
--- a/doc/efun/set_next_reset
+++ b/doc/efun/set_next_reset
@@ -1,55 +1,26 @@
-FUNKTION
-     int set_next_reset(int delay)
-
-ARGUMENTE
-     delay - minimale Zeit bis zum naechsten Reset des Objektes
+SYNOPSIS
+        int set_next_reset(int delay)
 
 BESCHREIBUNG
-     Mit dieser efun ist es moeglich Einfluss auf das Resetverhalten des
-     Objektes zu nehmen:
+        Weist den Gamedriver an, im Objekt nicht vor Ablauf von <delay>
+        Sekunden einen Reset durchzufuehren. Wird fuer <delay> ein negativer
+        Wert angegeben, wird nie ein Reset im Objekt durchgefuehrt (sinnvoll
+        fuer Blueprints). Wird fuer <delay> 0 angegeben, wird die
+        Reset-Zeit des Objekts nicht veraendert.
 
-     Das Objekt bekommt einen reset()-Aufruf fruehestens in <delay> Sekunden.
-     Bei Angabe eines Wertes <0 wird der reset() für das Objekt abgeschaltet,
-     was fuer Blueprints gelegentlich sinnvoll ist.
+        Die Funktion gibt die verbleibende Zeit bis zum naechsten Reset
+        zurueck, bevor <delay> gesetzt wurde. Der Wert kann auch negativ
+        sein, wenn der Reset ueberfaellig war.
 
-     Intern wird in gleichbleibenden Abstaenden (derzeit: in der Regel 2s,
-     kann sich aber auch verzoegern, wenn der Driver viel zu hat, z.B. auf 
-     4s) geprueft ob die Zeit zum zum naechsten reset() abgelaufen ist. 
-     Sollte dies der Fall sein, wird die Funktion reset() im Objekt 
-     aufgerufen.
-
-     Die Funktion gibt die verbleibende Zeit bis zum naechsten Reset
-     zurueck, bevor <delay> gesetzt wurde. Der Wert kann auch negativ
-     sein, wenn der Reset ueberfaellig war.
-
-     Achtung: die tatsaechliche Zeit, wann der Reset im Objekt durchgefuehrt
-     wird, haengt auch davon ab, ob das Objekt nach Ablauf von <delay>
-     verwendet wird.
+        Merke: die tatsaechliche Zeit, wann der Reset im Objekt
+        durchgefuehrt wird, haengt davon ab, ob das Objekt nach Ablauf
+        von <delay> verwendet wird.
 
 BEISPIELE
-     // ein Objekt mit verkuerzter reset()-Zeit
-     void create() {
-       ...
-       set_next_reset(15*60);	// ~ 15 Minuten
-       ...
-     }
+        set_next_reset(15*60);      Der naechste Reset erfolgt nach
+                                    fruehestens 15 Minuten.
+        set_next_reset(0);          Gibt die verbleibende Zeit zum naechsten
+                                    Reset zurueck.
 
-     void reset() {
-       set_next_reset(900);	// die muss im reset() immer wieder
-       ::reset();           // neu gesetzt werden
-     }
-
-     // ein Objekt, dessen Blueprint keinen reset() bekommen soll
-     void create() {
-       if(!clonep(this_object())) {
-         set_next_reset(-1);
-         return;
-       }
-       ::create();
-       ...
-     }
-
-SIEHE AUCH
-     call_out(E), object_info(E), reset(L), query_next_reset(E)
-
-7.Aug 2007 Gloinson
+GESCHICHTE
+        Eingefuehrt in LDMud 3.2.6, angepasst von Morgengrauen.
diff --git a/doc/efun/sort_array b/doc/efun/sort_array
index 80837b7..3316a0c 100644
--- a/doc/efun/sort_array
+++ b/doc/efun/sort_array
@@ -1,108 +1,74 @@
-sort_array(E)
-
-FUNKTION:
-     mixed *sort_array(mixed *arr, mixed func [, mixed ob])
-
-PARAMETER:
-     arr  - zu sortierendes Array
-     func - zu rufende Methode; kann als String (Funktionsname) oder 
-            Closure uebergeben werden
-     ob   - Objekt, an dem Methode gerufen werden soll; kann als String
-            (Filename) oder Objektpointer uebergeben werden
+SYNOPSIS
+        mixed * sort_array(mixed *arr, string wrong_order)
+        mixed * sort_array(mixed *arr, string wrong_order, object|string ob)
+        mixed * sort_array(mixed *arr, string wrong_order, object|string ob,
+                             mixed extra...)
+        mixed * sort_array(mixed *arr, closure cl)
+        mixed * sort_array(mixed *arr, closure cl, mixed extra...)
 
 BESCHREIBUNG
-     Erzeugt eine (flache) Kopie des Arrays 'arr' und sortiert diese mit der
-     Sortierfunktion 'func'. Die sortierte Kopie wird dann zurueckgegeben.
+        Sortiert das Array <arr> entweder nach der Ordnungsfunktion
+        <ob->wrong_order(a, b)> oder nach der Closure cl.
 
-     Die Elemente des zu sortierenden Arrays werden paarweise an die
-     Sortierfunktion als Argumente uebergeben.
-     Die Sortierfunktion sollte eine Zahl
-     - >0 zurueckgeben, wenn die Elemente in der falschen
-       Reihenfolge sind
-     - <=0 zurueckgeben, wenn die Elemente in der richtigen
-       Reihenfolge sind.
+        Normalerweise wird zuerst eine flache Kopie des Arrays <arr> erstellt
+        und die sortierte Kopie als Ergebnis zurueckgeliefert. Wird <arr>
+        jedoch als Referenz uebergeben, wird keine implizite Kopie erstellt
+        und das Originalarray sortiert.
 
-     Verwendung von Methoden:
-       Wenn bei der Angabe von 'func' kein Objekt 'ob' in Form eines Strings
-       oder Objekts angegeben wird, wird this_object() angenommen.
+        Wenn das Argument <arr> 0 ist, ist das Resultat der Funktion auch 0.
 
-     Verwendung von Closures:
-       Es koennen Lfun-, Lambda- und Inline-Closures verwendet werden. 
-       Lfun-Closures koennen, wenn im selben Objekt vorhanden, auch
-       'private' oder/und 'static' deklariert sein, muessen aber zu dem
-       Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
-       Von der Verwendung von Lambda-Closures wird ausdruecklich abgeraten.
+        <ob> ist das Objekt, in dem die Ordnungsfunktion <wrong_order()>
+        aufgerufen wird. <ob> kann das Objekt als solches enthalten, oder
+        einen String mit dem Objektnamen. Wird <ob> nicht angegeben, oder
+        enthaelt es weder einen String noch ein Objekt, wird stattdessen
+        this_object() verwendet.
 
-BEMERKUNGEN:
-     (1) sort_array() unterstuetzt keinen extra-Parameter
+        Die Elemente von <arr> werden paarweise an die Ordnungsfunktion
+        <wrong_order()> als Argumente uebergeben, gefolgt von den <extra>
+        Argumenten, falls vorhanden. Die Ordnungsfunktion <wrong_order> sollte
+        eine positve Zahl liefern, wenn die paarweisen Elemente in der
+        falschen Reihenfolge waren, 0 oder eine negative Zahl sonst.
 
-     (2) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie
-     also selbst Arrays oder Mappings, so fuehrt eine Aenderung im Rueckgabe-
-     Array zur Aenderung im Ursprungsarray:
+BEISPIELE
+        Um folgendes Array in aufsteigender Reihenfolge zu ordnen:
 
-     int *i, *j;
-     i=({({1}),({2,3}),({4,5,6})});
-     j=sort_array(i,        // sortiert der Groesse nach absteigend
-         function int ( mixed x, mixed y ) {
-           return sizeof(x) < sizeof(y); }
-         );
-     
-     Zu diesem Zeitpunkt ist  i == ({ ({1}),({2,3}),({4,5,6}) })
-                              j == ({ ({4,5,6}),({2,3}),({1}) })
-     
-     Fuehrt man jetzt die Zuweisung j[0][0]=8; aus
+            arr = ({ 3, 8, 1, 3 })
 
-     resultieren folgende Arrays: i == ({ ({1}),({2,3}),({8,5,6}) })
-                                  j == ({ ({8,5,6}),({2,3}),({1}) })
+        wird als Ordnungsfunktion ist_groesser() verwendet:
 
-BEISPIELE:
-     ### Sortieren von Zahlen in aufsteigender Reihenfolge ###
-     
-     int *arr = ({ 3, 8, 1, 3 })
+            int ist_groesser(int a, int b) {
+                return a > b;
+            }
 
-     // Folgend identische Resultate, aber andere Ansaetze:
+        Folgende Aufrufe von sort_array() sind alle aequivalent:
 
-     #1: nutzt die 'Efun' > als Lfun-Closure (ideal hier):
-         sort_array(arr, #'>);
+            arr = sort_array(arr, "ist_groesser", this_object())
+            arr = sort_array(arr, "ist_groesser")
+            arr = sort_array(arr, #'ist_groesser)
+            arr = sort_array(arr, #'>)  //dies ist die bevorzugte Variante :-)
+            arr = sort_array(arr, lambda(({'a, 'b}), ({#'>, 'a, 'b})))
 
-     #2: mit Sortierfunktion im selben Objekt:
-         int is_greater (int a, int b) {
-           return a > b;
-         }
-         
-         #2a: sortiert mittels der Lfun im selben Objekt die Elemente in das
-              Rueckgabearray
-              sort_array(arr, "is_greater", this_object())
-              sort_array(arr, "is_greater")
+        Soll direkt das Original <arr> statt einer impliziten Kopie sortiert
+        werden:
 
-         #2b: nutzt die Lfun is_greater() als Lfun-Closure (Funktionspointer)
-              sort_array(arr, #'is_greater)
+            sort_array(&arr, #'>)
 
-     #3: Nutzt eine Inline-Closure
-         sort_array(arr, function int (int a, int b) {
-           return a > b; } );
+        Etwas komplizierter ist es, folgendes Array aufsteigend nach dem
+        zweiten Argument jedes Teilarrays zu ordnen:
 
-     Resultat in allen Faellen: ({1,3,3,8})
+            arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... })
 
-     ### Sortieren von geschachtelten Arrays ###
+        Dafuer muss die Ordnungsfunktion folgende Form annehmen:
 
-     arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... })
+            int ist_groesser(mixed *a, mixed *b) {
+                return a[1] > b[1];
+            }
 
-     // Vorgehen identisch, allerdings muss die Sortierfunktion
-     // angepasst werden (siehe auch das Beispiel unter Verwendung von
-     // Inline-Closures oben unter "Bemerkungen"):
-     
-     int is_greater (mixed *a, mixed *b) {
-       return a[1] > b[1];
-     }
+GESCHICHTE
+        LDMud 3.2.8 fuehrte die Moeglichkeit ein, zusaetzliche Argumente
+            <extra> zu uebergeben.
+        LDMud 3.3.720 unterstuetzt die Uebergabe von <arr> als Referenz und
+            sortiert das Original statt einer impliziten flachen Kopie.
 
-SIEHE AUCH:
-     Arrays:        filter(E), map(E)
-     Objektarrays:  filter_objects(E), map_objects(E)
-     Mappings:      filter_indices(E), map_indices(E)
-
-     Sonstiges:     unique_array()
-                    alist, transpose_array(E)
-
-----------------------------------------------------------------------------
-Last modified: Mon Feb 18 23:09 2008 by Arathorn
+SIEHE AUCH
+        transpose_array(E), filter(E), map(E), alists(LPC)
diff --git a/doc/efun/tell_object b/doc/efun/tell_object
index e2cfd9c..6a78c8d 100644
--- a/doc/efun/tell_object
+++ b/doc/efun/tell_object
@@ -1,47 +1,48 @@
 SYNOPSIS
-        void tell_object(object|string obj, string str);
-        void tell_object(object|string obj, mixed *|mapping|struct|object msg);
+        void tell_object(object|string obj, string str)
+        void tell_object(object|string obj, mixed *|mapping|struct|object msg)
 
 BESCHREIBUNG
         Sendet einen Nachricht an das Objekt <obj> (das auch durch seinen
-        Objektnamen angegeben werden kann).
+        Namen angegeben werden kann).
 
         Ist die Nachricht ein String, wird der Text an interaktive Objekte
         direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
-        in diesen aufgerufen.
+        aufgerufen.
 
         Ist die Nachricht ein anderer Typ, wird die lfun catch_msg() im
         Empfaenger aufgerufen.
 
-BEMERKUNGEN
-        - wird in einem catch_msg() der Wert von <msg> veraendert, erhalten
-          alle nachfolgenden Objekte das veraenderte <msg> (Referenz!)
-
 BEISPIELE
-        // Dies gibt ein einfaches "Hi!" an den Spieler Thomas aus:
+        Dies gibt ein einfaches "Hi!" an den Spieler Thomas aus:
 
             object wer;
             wer = find_player("thomas");
             tell_object(wer, "Hi!\n");
 
-        // Ein Beispiel mit zwei Objekten, das zeigt, wie das Zusammenspiel
-        // von catch_tell() und tell_object() ablaueft. Objekt1 ist ein
-        // Lebewesen mit Namen "Dummymonster", Objekt2 verteilt die Meldung:
+        Ein Beispiel mit zwei Objekten, das zeigt, wie das Zusammenspiel von
+        catch_tell() und tell_object() ablaueft. Objekt1 ist ein Lebewesen
+        mit Namen "Dummymonster", Objekt2 verteilt die Meldung:
 
         Objekt1:
-            void catch_tell(string str) {
-                write("Erhaltener Text: "+str+"\n");
+            void catch_tell(string str)
+            {
+                wirte("Erhaltener Text: "+str+"\n");
             }
 
         Objekt2:
-            void fun() {
+            void fun()
+            {
                 object wer;
                 wer = find_living("dummymonster");
                 tell_object(wer, "Folge mir, Sterblicher!\n");
                 ...
             }
 
+GESCHICHTE
+        LDMud 3.2.11 fuehrte die Arrayform aus Symmetriegruenden ein.
+        LDMud 3.3.686 erlaubt die Verwendung eines mapping/struct/object als
+        zweites Argument.
+
 SIEHE AUCH
-        Aehnlich:   write(E), shout(E), say(E), tell_room(E), printf(E)
-        Verwandt:   catch_tell(E), catch_msg(A)
-        Sonstiges:  object_name(E)
\ No newline at end of file
+        write(E), say(E), catch_tell(A), catch_msg(A)
diff --git a/doc/efun/tell_room b/doc/efun/tell_room
index 77f302c..0f18ab5 100644
--- a/doc/efun/tell_room
+++ b/doc/efun/tell_room
@@ -1,67 +1,36 @@
-FUNKTION:
-        void tell_room(string|object obj, string str);
-        void tell_room(string|object obj, string str, object *exclude);
+SYNOPSIS
+        void tell_room(string|object obj, string str)
+        void tell_room(string|object obj, string str, object *exclude)
 
         void tell_room(string|object obj, mixed *|mapping|struct|object msg)
-        void tell_room(string|object obj, mixed *|mapping|struct|object  msg
-                                        , object *exclude);
+        void tell_room(string|object obj, mixed *|mapping|struct|object msg,
+                                                     object *exclude)
 
-BESCHREIBUNG:
+BESCHREIBUNG
         Gibt einen Text <str> an den Raum <obj> aus. <obj> kann auch der
-        Objektname des Raumes als String sein.
-        Wenn das Raumobjekt mit seinem Namen angegeben ist, sucht der Driver
-        das Objekt unter diesem Namen und laedt es, falls notwendig.
+        Name des Raumes als String sein. Wenn das Objekt, das die Meldung
+        erhaelt, nicht ein interaktives Objekt (also kein User) ist, wird
+        im Empfaenger die Funktion catch_tell() mit dem Text als Argument
+        aufgerufen. Falls ein Lebewesen die Funktion catch_tell() definiert,
+        wird der Text hier ausgewertet und nicht an den User ausgegeben.
+        Wenn das Empfaengerobjekt mit seinem Namen angegeben ist, sucht der
+        Driver das Objekt unter diesem Namen und laedt es, falls notwendig.
+        Wenn das Array <*exclude> angegeben ist, wird der Text an die
+        Objekte in <*exclude> nicht ausgegeben.
 
-        Ist die Nachricht ein String, wird der Text an interaktive Objekte
-        direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
-        in diesen aufgerufen.
-        Falls ein Lewebesen die Funktion catch_tell() definiert (-> shadow),
-        so wird der Text hier ausgewertet und nicht an den User ausgegeben.
+        Wenn das zweite Argument ein nicht-String ist, wird in allen
+        Lebewesen, die den Text erhalten, catch_msg() aufgerufen (statt
+        catch_tell()).
 
-        Wenn das zweite Argument, die Nachricht, kein String ist, wird in
-        allen Lebewesen, die den Text erhalten, catch_msg() anstatt
-        catch_tell() aufgerufen.
+BEISPIELE
+        An alle Lebewesen im Raum soll ein simples "Hi!" gesendet werden:
 
-        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.
+            tell_object(environment(this_player()), "Hi!\n");
 
-BEMERKUNGEN:
-        - der Eintrag von mehreren Anwesenden in *exclude ist moeglich
-        - wird in einem catch_msg() der Wert von <msg> veraendert, erhalten
-          alle nachfolgenden Objekte das veraenderte <msg> (Referenz!)
+        Folgendes Beispiel zeigt, wie tell_room() zusammen mit catch_tell()
+        funktioniert.
 
-        - say("str") ist verhaltensgleich zu
-          tell_room(environment(), "str", ({this_player()||this_object()}))
-
-BEISPIELE:
-        // Dies ist ein einfaches Beispiel fuer eine Meldung an alle An-
-        // wesenden im Raum.
-
-        tell_room(this_object(),"Ein leichter Wind kommt auf.\n");
-
-        // Diese Meldung wird im Raum /d/ebene/ark/raum.c ausgegeben, dieser
-        // Raum muss nicht derjenige sein, in dem das tell_room() ausgefuehrt
-        // wird.
-
-        tell_room("/d/ebene/ark/raum","Ein leichter Wind kommt auf.\n");
-
-
-        // Diese Meldung wird an alle Anwesenden im Raum AUSSER this_player()
-        // (der diese Meldung ausgeloest hat) ausgegeben. Der muss eine ge-
-        // sonderte Meldung ueber sein Stolpern per write() oder
-        // tell_object() bekommen.
-        tell_room(this_object(),
-                  break_string(this_player()->Name()+" stolpert.", 78),
-                  ({ this_player() }));
-        tell_object(this_player(), "Du stolperst.\n");
-
-        // Ein Beispiel mit zwei Objekten, das zeigt, wie das Zusammenspiel
-        // von catch_tell() und tell_room() ablaueft. Objekt1 ist ein
-        // Lebewesen mit Namen "Dummymonster", Objekt2 verteilt die Meldung:
-
-        Objekt1 (ein Lebewesen, steht im Env von this_player()):
+        Objekt1 (ein Lebewesen):
             void catch_tell(string str) {
                 write("Empfangen: "+str+"\n");
             }
@@ -71,9 +40,9 @@
                 tell_room(environment(this_player()), "Hallo Welt!\n");
             }
 
-SIEHE AUCH
-        Aehnlich:   tell_object(E), write(E), shout(E), say(E), printf(E)
-        Verwandt:   catch_tell(E), catch_msg(A)
-        Sonstiges:  object_name(E)
+GESCHICHTE
+        LDMud 3.3.686 erlaubt die Verwendung eines mapping/struct/object als
+        zweites Argument.
 
-7.Aug 2007 Gloinson
+SIEHE AUCH
+        write(E), say(E), tell_object(E), catch_tell(A), catch_msg(A)
diff --git a/doc/efun/walk_mapping b/doc/efun/walk_mapping
index 7396fcf..3dad60c 100644
--- a/doc/efun/walk_mapping
+++ b/doc/efun/walk_mapping
@@ -1,88 +1,24 @@
-walk_mapping(E)
+SYNOPSIS
+        void walk_mapping(mapping map, string fun, mixed extra, ...)
+        void walk_mapping(mapping map, string fun, string|object obj,
+                                                      mixed extra, ...)
+        void walk_mapping(mapping map, closures cl, mixed extra, ...)
 
-FUNKTION:
-        void walk_mapping(mapping m, string fun [, mixed extra, ...])
-        void walk_mapping(mapping m, string fun, string|object ob
-                                                , mixed extra,...)
-        void walk_mapping(mapping m, closure cl, mixed extra,...)
+BESCHREIBUNG
+        Ruft obj->fun(key, &value1, ... &valueN, extra, ...) fuer jeden Key
+        im Mapping <map> auf bzw. wendet die Closure <cl> auf jeden Key
+        im Mapping <map> an. Dies Keys werden als Wert uebergeben, die Values
+        als Referenz, entsprechend koennen sie in der Funktion veraendert
+        werden.
 
-PARAMETER:
-     m		- durchzugehendes Mapping
-     fun/cl	- zu rufende Methode/Closure
-     ob		- Objekt/Dateiname, an dem Methode gerufen werden soll
-     extra	- weitere Parameter fuer Methode/Closure
+        Es kann eine beliebige Anzahl zusaetzlicher Argumente <extra>
+        uebergeben werden.
 
-BESCHREIBUNG:
-     Ruft die Methode fuer jeden Eintrag im Mapping:
-      ob->func(key, value1, ..., valueN, extra,...)
-     beziehungsweise fuehrt die Closure fuer jeden dieser Eintraege aus:
-      funcall(cl, key, value1, ..., valueN, extra,...)
+        Wird <obj> weggelassen oder enthaelt es weder einen String noch ein
+        Objekt, wird standardmaessig this_object() verwendet.
 
-     Die Schluessel werden als Wert uebergeben und die dazugehoerigen Werte
-     per Referenz, diese koennen somit also in der Funktion/Closure geaendert
-     werden.
+GESCHICHTE
+        Eingefuehrt in LDMud 3.2@61.
 
-
-     Verwendung von Methoden:
-	Wenn bei der Angabe von 'fun' kein Objekt 'ob' in Form eines Strings
-	oder Objekts angegeben wird, wird this_object() angenommen.
-
-     Verwendung von Closures:
-	Es koennen sowohl Lfun-Closures als auch Lambda-Closures verwendet
-	werden. Lfun-Closures koennen, wenn im selben Objekt vorhanden auch
-	'private' oder/und 'static' deklariert sein, muessen aber zu dem
-	Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
-
-BEISPIELE:
-     // Liste mit Spielern durchgehen ...
-     mapping x=([ [/human:liafar]:  20,
-		  [/dwarf:mesirii]: 50,
-		  [/elf:zarniya]:   40,
-		  [/feline:turbo]:  30]);
-
-     // ... und Werte aendern:
-     void add_val(object key, int val, int add) {
-       if(key->InFight())
-         val+=add;
-       else
-         val-=add;
-     }
-
-     // verschiedene Aufrufarten, identisches Resultat:
-     walk_mapping(x, "add_val", 0, 10);
-     walk_mapping(x, "add_val", this_object(), 10
-     walk_mapping(x, "add_val", "/players/jof/addierobjektmitmethode", 10);
-
-     walk_mapping(x, #'add_val, 10);
-
-
-AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
-     // so richtig aequivalent wird es nur mit einer Closure hier
-     int i, width;
-     mapping input;
-     mixed *index, *param;
-
-     width=get_type_info(input)[1];
-     param=allocate(width);
-     index=m_indices(input);
-     i=sizeof(index);
-     while(i--) {
-       j=width;
-       while(j-- > 1)
-         param[j]=input[index[i],j];
-       j[0]=index[i];
-
-       apply(cl, param);
-       // fun(index[i], input[index[i],0], input[index[i],1], ...);
-      }
-
-SIEHE AUCH:
-     Arrays:		filter(E), map(E)
-     Objektarrays:	filter_objects(E), map_objects(E)
-     Mappings:		filter_indices(E), map_indices(E)
-
-     Sonstiges:		m_contains(E)
-			member()
-			m_indices(E), m_values(E)
-
-20.Jan 2005 Gloinson
+SIEHE AUCH
+        map(E), filter(E)
diff --git a/doc/obsolete/map_indices b/doc/obsolete/map_indices
new file mode 100644
index 0000000..7aacc04
--- /dev/null
+++ b/doc/obsolete/map_indices
@@ -0,0 +1,33 @@
+VERALTET
+SYNOPSIS
+        mapping map_indices(mapping m, string fun, string|object ob,
+                                                     mixed extra, ...)
+        mapping map_indices(mapping m, closure cl, mixed extra, ...)
+
+BESCHREIBUNG
+        Fuer jedes Element des Mappings wird ob->func() bzw. die Closure <cl>
+        aufgerufen. Dabei wird zuerst der Key des Mappings, dann das
+        Datenelement und schliesslich die <extra> Argumente uebergeben.
+        Die <extra> Argumente duerfen keine geschuetzten Referenzen wie z.B.
+        &(i[0]) enthaelten. Der Dateneintrag im Mapping wird durch den
+        Rueckgabewert der Funktion ersetzt. <ob> kann auch der Dateiname
+        eines Objektes sein.
+
+        Wird <ob> nicht angegeben oder weder ein String noch ein Objekt,
+        wird standardmaessig this_object() verwendet.
+
+        Verfuegt das Mapping ueber mehr als ein Datenelement pro Key, so
+        wird nur das erste Element beachtet, alle andern Datenelemente
+        werden ignoriert. Das Verhalten von map_indices() unterscheidet sich
+        also vom Verhalten von map_array().
+
+BEISPIELE
+        m = mkmapping(users());
+        m = map_indices(m, #'envrionment);
+
+GESCHICHTE
+        In LDMud 3.2.6 umbenannt von map_mapping() und durch map() ergaenzt.
+
+SIEHE AUCH
+        map(E), filter(E), filter_indices(E), walk_mapping(E), member(E),
+        m_contains(E)