Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/doc/efun/.default b/doc/efun/.default
new file mode 100644
index 0000000..2560e19
--- /dev/null
+++ b/doc/efun/.default
@@ -0,0 +1,14 @@
+FUNKTION:
+
+ARGUMENTE:
+
+BESCHREIBUNG:
+
+RUECKGABEWERT:
+
+BEMERKUNGEN:
+
+BEISPIELE:
+
+SIEHE AUCH:
+
diff --git a/doc/efun/.synonym b/doc/efun/.synonym
new file mode 100644
index 0000000..f024a1b
--- /dev/null
+++ b/doc/efun/.synonym
@@ -0,0 +1,3 @@
+round ceil
+trunc ceil
+efun::m_delete efun__m_delete
diff --git "a/doc/efun/\133\135" "b/doc/efun/\133\135"
new file mode 100644
index 0000000..a59696a
--- /dev/null
+++ "b/doc/efun/\133\135"
@@ -0,0 +1,66 @@
+SYNOPSIS
+ mixed arr[index];
+ int str[index];
+
+ *mixed arr[from .. to];
+ string str[from .. to];
+
+BESCHREIBUNG
+ Liefert ein Element aus einem Array oder String (erste Form), oder
+ eine Teilmenge (zweite Form).
+
+ Die Indizes <index>, <from> und <to> sind durchnummeriert von 0 bis
+ strlen(<str>)-1 bzw. sizeof(<arr>)-1. Wenn ein <index> als '<wert'
+ geschrieben wird, wird der Wert vom Ende des Stings / Arrays her
+ gezaehlt. Dabei wird nummeriert von 1 bis strlen(<str>) bzw.
+ sizeof(<arr>). Wird <from> weggelassen, beginnt die Teilmenge mit
+ dem ersten Element. Wird <to> weggelassen, endet die Teilmenge mit
+ dem letzten Element.
+
+ In der ersten Form muss <index> innerhalb der Grenzen des Strings /
+ Arrays sein, sonst wird ein Laufzeitfehler (RTE) verursacht. In der
+ zweiten Form werden die Indizes an die Groesse des Strings / Arrays
+ angepasst. Wenn <from> groesser ist als <to> oder beide ausserhalb
+ der Groesse des Strings / Arrays liegen, wird ein leerer String ""
+ bzw. ein leeres Array ({}) zurueck geliefert.
+
+ Die Notation als Closure ist entsprechend:
+
+ [index] -> ({'#[, arr, index })
+ [<index] -> ({'#[<, arr, index })
+ [from..to] -> ({'#[..], arr, from, to })
+ [<from..to] -> ({'#[<..], arr, from, to })
+ [from..<to] -> ({'#[..<], arr, from, to })
+ [<from..<to] -> ({'#[<..<], arr, from, to })
+
+BEISPIELE
+ foo = ({ 1, 2, 3, 4 }); str = "test";
+
+ foo[1] -> 1 str[1] -> 'e' == 101
+ foo[1..2] -> ({ 2, 3 }) str[1..2] -> "es"
+ foo[2..1] -> ({ }) str[2..1] -> ""
+ foo[0..<2] -> ({ 1, 2 }) str[0..<2] -> "tes"
+
+ foo[..<2] -> ({ 1, 2 }) str[..<2] -> "tes"
+ foo[<3..] -> ({ 2, 3, 4 }) str[<3..] -> "est"
+
+ foo[1] = 5 -> foo == ({ 1, 5, 3, 4 })
+ foo[1..2] = ({ 5, 6, 7 }) -> foo == ({ 1, 5, 6, 7, 4 })
+ foo[1..2] = ({ }) -> foo == ({ 1, 4 })
+
+ str[1] = 'a' -> str == "tast"
+ str[1..2] = "bar" -> str == "tbart"
+ str[1..2] = "" -> str == "tt"
+
+AENDERUNGEN
+ slice_array() ist die alte Form der []-Operatoren fuer Arrays,
+ extract() ist die alte Form der []-Operatoren fuer Strings.
+ BEIDE VARIANTEN SIND VERALTET, WERDEN NICHT MEHR UNTERSTUETZT UND
+ SOLLTEN DESHALB NICHT MEHR VERWENDET WERDEN.
+
+ Die Syntax fuer 'rueckwaerts zaehlen vom letzten Element' hat sich von
+ Version 3.1.J zu 3.1.K geaendert von '-1' zu '<1'. Auch ist seit dann
+ foo[0..-1] ein leeres Array bzw. ein leerer String.
+
+SIEHE AUCH
+ member(E), sizeof(E), slice_array(E)
diff --git a/doc/efun/abs b/doc/efun/abs
new file mode 100644
index 0000000..586beea
--- /dev/null
+++ b/doc/efun/abs
@@ -0,0 +1,20 @@
+SYNOPSIS
+ int abs (int arg)
+ float abs (float arg)
+
+BESCHREIBUNG
+ Liefert den Betrag des Argumentes <arg>.
+
+BEISPIELE
+ Funktion Rueckgabewert
+ -------------------------------------------------------------------
+ abs(-18 ) 18
+ abs( 11 ) 11
+ abs( -1.974) 1.974
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6.
+
+SIEHE AUCH
+ sin(E), asin(E), cos(E), acos(E), tan(E), atan(E), log(E), exp(E),
+ sqrt(E), floor(E), ceil(E), pow(E), sgn(E)
diff --git a/doc/efun/acos b/doc/efun/acos
new file mode 100644
index 0000000..2487958
--- /dev/null
+++ b/doc/efun/acos
@@ -0,0 +1,8 @@
+SYNOPSIS
+ float acos(float)
+
+BESCHREIBUNG
+ Liefert der Arkuskosinus des Argumentes.
+
+SIEHE AUCH
+ sin(E), asin(E), cos(E), tan(E), atan(E), atan2(E)
diff --git a/doc/efun/add_action b/doc/efun/add_action
new file mode 100644
index 0000000..8b0f778
--- /dev/null
+++ b/doc/efun/add_action
@@ -0,0 +1,149 @@
+add_action(E)
+FUNKTION:
+ void add_action(string fun, string cmd)
+ void add_action(string fun, string cmd, int flag)
+
+ARGUMENTE:
+ fun
+ gerufene Methode
+ cmd
+ ausloesendes Verb
+ flag
+ Flag fuer unscharfe Interpretation
+
+BESCHREIBUNG:
+ Generell: Das Verhalten dieser efun wird durch AddCmd aus
+ /std/thing/commands.c komfortabler widergespiegelt.
+ Darauf sollte man zurueckgreifen.
+
+ Legt fuer "cmd" (ein Kommandoverb) eine im entsprechenden Objekt
+ zu rufende Methode fest.
+
+ Diese Methode bekommt die Argumente als String uebergeben und
+ muss 0 (fuer einen Fehler) oder 1 (fuer Erfolg) zurueckgeben.
+
+ 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.
+
+ 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.
+
+ 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.
+
+ 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.)
+
+BEISPIELE:
+ // ein Kommando in einem Schirm
+ void init() {
+ ::init();
+ add_action("action_oeffne", "oeffne");
+ }
+
+ 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;
+ }
+
+ // 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;
+ }
+
+ Beispiele fuer die Verwendung des Argumentes "flag":
+ 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.
+ Laengere Worte (zum Beispiel "disconnecting") werden NICHT erkannt.
+ 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);
+
+ 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 |
+ |-------------------|--------------|----------------------------|
+ | "cmd" | "cmd" | 0 |
+ | "cmd bla fasel" | "cmd" | "bla fasel" |
+ |-------------------|--------------|----------------------------|
+ | "scmd" | "scmd" | 0 |
+ | "scmd bla" | "scmd" | "bla" |
+ | "scmdbla" | "scmdbla" | 0 |
+ | "scmd bla fasel" | "scmd" | "bla fasel" |
+ | "scmdbla fasel" | "scmdbla" | "fasel" |
+ |-------------------|--------------|----------------------------|
+ | "ncmd" | "ncmd" | 0 |
+ | "ncmd bla" | "ncmd" | " bla" |
+ | "ncmdbla" | "ncmdbla" | "bla" |
+ | "ncmd bla fasel" | "ncmd" | " bla fasel" |
+ | "ncmdbla fasel" | "ncmdbla" | "bla fasel" |
+ |-------------------|--------------|----------------------------|
+ | "icmd" | "icmd" | 0 |
+ | "icmd bla" | "icmd" | " bla" |
+ | "icmdbla" | "icmd" | "bla" |
+ | "icmd bla fasel" | "icmd" | " bla fasel" |
+ | "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
diff --git a/doc/efun/all_environment b/doc/efun/all_environment
new file mode 100644
index 0000000..993f493
--- /dev/null
+++ b/doc/efun/all_environment
@@ -0,0 +1,33 @@
+SYNOPSIS
+ object *all_environment();
+ object *all_environment(object ob);
+
+ARGUMENTE:
+ ob - das Objekt, dessen environment()s gewuenscht werden
+
+BESCHREIBUNG
+ Gibt ein Array mit allen Umgebungen des Objekts <ob> zurueck.
+ Wenn <ob> nicht angegeben wird, wird standardmaessig this_object()
+ verwendet.
+
+ Wenn <o> keine Umgebung hat oder zerstoert wurde, wird 0 zurueck
+ gegeben.
+
+BEMERKUNGEN:
+ Das zurueckgegebene Array ist so angelegt, dass die innerste Umgebung
+ am Anfang des Arrays steht, und die aeusserste Umgebung am Ende.
+
+BEISPIEL
+ (Die gesuchte Fackel befindet sich in einem Behaelter, den Wargon bei
+ sich traegt. Wargon steht in seinem Workroom.)
+
+ ob = all_environment(find_object("/obj/fackel#32"));
+ => ob = ({[+wueste/durian/behaelter#31],[/magier:wargon],[~/workroom]})
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6. Ein Vorschlag von TubMud.
+
+SIEHE AUCH
+ environment(E), all_inventory(E)
+
+7.Feb 2007 Gloinson
\ No newline at end of file
diff --git a/doc/efun/all_inventory b/doc/efun/all_inventory
new file mode 100644
index 0000000..ad6eea1
--- /dev/null
+++ b/doc/efun/all_inventory
@@ -0,0 +1,17 @@
+all_inventory
+FUNKTION:
+ 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.
+
+SIEHE AUCH:
+ first_inventory(E), next_inventory(E), deep_inventory(E),
+ all_environment(E), environment(E)
+
+22. Maerz 2004 Gloinson
diff --git a/doc/efun/allocate b/doc/efun/allocate
new file mode 100644
index 0000000..c591c5e
--- /dev/null
+++ b/doc/efun/allocate
@@ -0,0 +1,38 @@
+SYNOPSIS
+ *mixed allocate(int size);
+ *mixed allocate(int size, mixed init_value);
+
+ *mixed allocate(*int sizes);
+ *mixed allocate(*int sizes, mixed init_value);
+
+BESCHREIBUNG
+ Alloziert ein Array von <size> Elementen. Die Anzahl Elemente muss
+ groesser sein als 0, darf aber das Systemmaximum (normalerweise 1000)
+ nicht uebersteigen. Wird <init_value> angegeben, wird allen Elementen
+ dieser als Anfangswert zugewiesen. Wenn <init_value> ein Mapping oder
+ ein Array ist, wird fuer jedes Element eine einfache Kopie erstellt.
+ Wird <init_value> nicht angegeben, sind alle Elemente 0.
+
+ In der zweiten Form (mit einem Feld von <sizes> anstelle nur einer
+ <size>) erzeugt allocate() ein mehrdimensionales Array, ein Array aus
+ Arrays.
+
+ Heute wird allocate() kaum mehr benoetigt, weil Arrays mit dem
+ +-Operator addiert werden koennen und mit dem ({})-Operator
+ initialisiert. Der einzige Nutzen der Funktion ist, grosse leere
+ oder initialisierte Arrays zu erzeugen.
+
+BEISPIEL
+ string *buffer;
+ buffer = allocate(50);
+ buffer = allocate(50, "");
+
+ buffer = allocate( ({ 2, 3 }) )
+ --> ({ ({ 0, 0, 0 }), ({ 0, 0, 0 }) })
+
+AENDERUNGEN
+ LDMud 3.2.9 fuehrte den Anfangswert <init_value> und die
+ Initialisierung von mehrdimensionalen Arrays ein.
+
+SIEHE AUCH
+ sizeof(E)
diff --git a/doc/efun/and_bits b/doc/efun/and_bits
new file mode 100644
index 0000000..f066d61
--- /dev/null
+++ b/doc/efun/and_bits
@@ -0,0 +1,23 @@
+SYNOPSIS
+ string and_bits(string str1, string str2);
+
+BESCHREIBUNG
+ <str1> und <str2> seien beides Bitstrings. Das Resultat von and_bits()
+ ist ein Bitstring mit dem binaeren Und von <str1> und <str2>, das
+ heisst ein String, in dem ein Bit nur gesetzt ist, wenn das
+ entsprechende Bit in beiden Strings <str1> und <str2> gesetzt ist.
+
+BEISPIEL
+ string s1, s2, s3;
+
+ s1 = set_bit("", 3); s1 = set_bit(s1, 15); -> s1 is "( ("
+ s2 = set_bit("", 3); s2 = set_bit(s2, 4); -> s2 is "8"
+
+ s3 = and_bits(s1, s2);
+
+ --> s3 ist jetzt "8", d.h. ein Bitstring, in dem nur das 3. Bit
+ gesetzt ist.
+
+SIEHE AUCH
+ clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E),
+ count_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/apply b/doc/efun/apply
new file mode 100644
index 0000000..aaa30a5
--- /dev/null
+++ b/doc/efun/apply
@@ -0,0 +1,35 @@
+SYNOPSIS
+ mixed apply(closure cl, mixed arg, ...);
+
+BESCHREIBUNG
+ Wertet die Closure <cl> aus. Wenn <cl> keine Closure ist, wird <cl>
+ unveraendert zurueck geliefert und alle Argumente <arg> werden
+ ignoriert.
+
+ Es gibt einen kleinen Unterschied zu funcall(), das ja im Wesentlichen
+ das gleiche tut (naemlich, eine Closure auswerten): wenn das letzte
+ Argument von apply() ein Array ist, wird jedes Element dieses Arrays
+ zu einem separaten zusaetzlichen Parameter der Closure umgewandelt.
+
+ Eine moegliche Anwendung waere:
+ mixed eval(object ob,string func,mixed *args)
+ {
+ return apply(#'call_other,ob,func,args);
+ }
+
+ Das fuehrt zu folgenden Aufrufen:
+ ob->func(args[0],args[1],...,args[sizeof(args)-1])
+
+ Waere stattdessen funcall() aufgerufen worden, so haette das ergeben:
+ ob->func(args)
+
+ Eine wichtige Anwendung von apply() ist das Auswerten des
+ Array-Arguments in "varargs" Funktionen.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2@70.
+ LDMud 3.2.8 fuehrte ein, dass das erste Argument zurueck gegeben wird,
+ wenn es sich nicht um eine Closure handelt.
+
+SIEHE AUCH
+ funcall(E), closures(LPC), varargs(LPC)
diff --git a/doc/efun/asin b/doc/efun/asin
new file mode 100644
index 0000000..44c6d4d
--- /dev/null
+++ b/doc/efun/asin
@@ -0,0 +1,8 @@
+SYNOPSIS
+ float asin(float)
+
+BESCHREIBUNG
+ Liefert der Arkussinus des Argumentes.
+
+SIEHE AUCH
+ sin(E), cos(E), acos(E), tan(E), atan(E), atan2(E)
diff --git a/doc/efun/atan b/doc/efun/atan
new file mode 100644
index 0000000..105b748
--- /dev/null
+++ b/doc/efun/atan
@@ -0,0 +1,11 @@
+SYNOPSIS
+ float atan(int|float)
+
+BESCHREIBUNG
+ Liefert den Arkustangens des Argumentes.
+
+AENDERUNGEN
+ LDMud 3.2.9: Ganzzahlen (Integers) als Argument hinzugefuegt.
+
+SIEHE AUCH
+ atan2(E), sin(E), cos(E), tan(E), asin(E), acos(E)
diff --git a/doc/efun/atan2 b/doc/efun/atan2
new file mode 100644
index 0000000..e4cd78a
--- /dev/null
+++ b/doc/efun/atan2
@@ -0,0 +1,16 @@
+SYNOPSIS
+ float atan2 (int|float y, int|float x)
+
+BESCHREIBUNG
+ Liefert den Winkel der Polarkoordinaten des Punktes (x, y) im
+ Bereich (-Pi, Pi].
+
+ Man beachte die Vertauschung der Koordinaten x und y in der
+ Parameter-Liste, die die Abfolge in der Steigungs-Winkel-Umrechnung
+ atan(y / x) widerspiegelt.
+
+AENDERUNGEN
+ LDMud 3.2.9: Ganzzahlen (Integers) als Argumente hinzugefuegt.
+
+SIEHE AUCH
+ sin(E), cos(E), tan(E), asin(E), acos(E), atan(E)
diff --git a/doc/efun/attach_erq_demon b/doc/efun/attach_erq_demon
new file mode 100644
index 0000000..032b13b
--- /dev/null
+++ b/doc/efun/attach_erq_demon
@@ -0,0 +1,37 @@
+SYNOPSIS
+ int attach_erq_demon(object ob, int do_close)
+ int attach_erq_demon(string obname, int do_close)
+
+DESCRIPTION
+ This privileged efun is to set/change the connection of the
+ driver to the external erq demon, thus in effect changing the
+ demons.
+
+ The connection of the given interactive 'ob'ject is taken away(!)
+ from it and stored as the erq-connection. The object itself is
+ then no longer needed, but may stay alive - it is just another
+ non-interactive object then.
+
+ In the second form, the string will be combined as suffix to
+ the filename ERQFILE<obname>, which is then the binary to be
+ forked off as new erq demon. The communication with this erq
+ will take place over unix domain sockets. ERQFILE defaults to
+ BINDIR/erq, where BINDIR is the configuration value for the
+ executable directory.
+
+ If there is alreay an erq demon connected to the driver, the
+ function will fail unless 'do_close' (default 0) is specified
+ as 1 (or any other odd integer): then the old connection will
+ be closed before attaching the new.
+ The efun returns 1 on success, else 0.
+
+EXAMPLE
+ To restart the (default) erq, write in
+ master.c::stale_erq(closure c):
+ attach_erq_demon("", 0);
+
+HISTORY
+ Introduced in 3.2.1@61.
+
+SEE ALSO
+ send_erq(E), erq(C)
diff --git a/doc/efun/baseof b/doc/efun/baseof
new file mode 100644
index 0000000..d64cc20
--- /dev/null
+++ b/doc/efun/baseof
@@ -0,0 +1,16 @@
+SYNOPSIS
+ int baseof (struct b, struct s)
+
+DESCRIPTION
+ Test if the type of struct <b> is a base of struct <s> (the
+ values of <b> and <s> are irrelevant). Results are:
+ 0: <b> is not a base of <s>, nor is <b> of equal type as <s>
+ (though <s> might be a base of <b>).
+ 1: <b> is a true base of <s>
+ 2: <b> and <s> are the same struct type
+
+HISTORY
+ Introducted in LDMud 3.3.344.
+
+SEE ALSO
+ structp(E), structs(LPC)
diff --git a/doc/efun/binary_message b/doc/efun/binary_message
new file mode 100644
index 0000000..08bc321
--- /dev/null
+++ b/doc/efun/binary_message
@@ -0,0 +1,36 @@
+GESCHUETZT
+SYNOPSIS
+ int binary_message(int *|string messages, int flags);
+
+BESCHREIBUNG
+ Liest den Output aus und sendet diesen direkt mit write() OHNE IAC
+ QUOTING. Die Nachricht kann Nullen enthalten, wenn sie als
+ int * angegeben sind. Die Nachricht wird an this_object() ausgegeben,
+ aber nur, wenn dieses interaktiv ist.
+
+ Der Rueckgabewert ist die Anzahl tatsaechlich gedruckter Zeichen. Eine
+ allfaellige "allowed charset" Einstellung wird uebergangen.
+
+ <flags> werden bitweise interpretiert und koennen ueber das binaere
+ Oder verbunden werden.
+
+ Bit 0 (Wert 1): wenn gesetzt, wird add_message() anstelle von
+ write() verwendet. So muss der Output nicht zuerst ausgelesen
+ werden, allerdings erfolgt die Ausgabe nicht sofort. Auch kann
+ dann die Anzahl effektiv uebertragener Zeichen nicht bestimmt
+ werden - der Rueckgabewert ist nicht definiert.
+
+ Bit 1 (Wert 2): Der Puffer wird ausgelesen, _nachdem_ die Nachricht
+ angefuegt wurde. Ist nur in Verbindung mit Bit 0 sinnvoll.
+
+ Die Idee hinter den Flags ist, dass das Senden von Kommandocodes
+ zum Beispiel fuer Farben an den vorhandenen Filtern fuer erlaubte
+ Zeichen vorbeigeschleust werden muss, jedoch nicht wichtig genug
+ ist, um die Verschwendung von Bandbreite mittels einer
+ synchronen Uebertragung zu rechtfertigen.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2.1@40.
+
+SIEHE AUCH
+ set_connection_charset(E)
diff --git a/doc/efun/bind_lambda b/doc/efun/bind_lambda
new file mode 100644
index 0000000..6075a33
--- /dev/null
+++ b/doc/efun/bind_lambda
@@ -0,0 +1,16 @@
+SYNOPSIS
+ closure bind_lambda(closure, object ob)
+
+DESCRIPTION
+ Binds an unbound lambda closure to an object and return it.
+ The efun can also be used to rebind an efun-, simul-efun
+ or operator closure to a different object.
+
+ If the optional argument ob is not this_object(), the privilege
+ violation ("bind_lambda", this_object(), ob) occurs.
+
+HISTORY
+ Introduced in 3.2@82.
+
+SEE ALSO
+ lambda(E), unbound_lambda(E), apply(E), funcall(E), closures(LPC)
diff --git a/doc/efun/blueprint b/doc/efun/blueprint
new file mode 100644
index 0000000..1c77497
--- /dev/null
+++ b/doc/efun/blueprint
@@ -0,0 +1,23 @@
+VORLAEUFIG
+SYNOPSIS
+ object blueprint()
+ object blueprint(string|object ob);
+
+BESCHREIBUNG
+ Die Efun liefert den Blueprint fuer das angegeben Objekt <ob> oder
+ fuer this_object(), wenn nicht angegeben.
+
+ Wenn der Blueprint zerstoert wurde, liefert die Funktion 0. Fuer
+ Objekte mit replace_program() liefert die Funktion den Blueprint des
+ ersetzenden Programs.
+
+BEISPIEL
+ blueprint("/obj/ding"); -> liefert /obj/ding
+ blueprint(find_object("/obj/ding")); -> liefert /obj/ding
+ blueprint(clone_object("/obj/ding")); -> liefert /obj/ding
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ clones(E), clone_object(E)
diff --git a/doc/efun/break_point b/doc/efun/break_point
new file mode 100644
index 0000000..584453e
--- /dev/null
+++ b/doc/efun/break_point
@@ -0,0 +1,11 @@
+OPTIONAL
+SYNOPSIS
+ void break_point()
+
+DESCRIPTION
+ This function is for system internal use and should never be called by
+ user objects. It is supposed to check the stack integrity and aborts
+ the driver when it detects corruption.
+
+SEE ALSO
+ shutdown(E), swap(E)
diff --git a/doc/efun/call_direct b/doc/efun/call_direct
new file mode 100644
index 0000000..94ab028
--- /dev/null
+++ b/doc/efun/call_direct
@@ -0,0 +1,75 @@
+SYNOPSIS
+ unknown call_direct (object ob, string fun, mixed arg, ...)
+ unknown call_direct (object *ob, string fun, mixed arg, ...)
+
+DESCRIPTION
+ Call a member function <fun> in another object <ob> with an
+ the argument(s) <arg...>. Result is the value returned from
+ the called function (or 0 for non-existing or void functions).
+
+ This efun is a twin to call_other(), with the difference
+ being that call_direct() never calls a default method.
+
+ Optionally the driver can be configured to accept an array of
+ objects as <ob>: the function is called with the same
+ arguments in all the given objects. The single results are
+ collected in an array and yield the final result. Array
+ elements can be objects or the names of existing objects;
+ destructed objects and 0s will yield a '0' as result, but
+ don't cause an error.
+
+ If the array-calling mode is available, the macro
+ __LPC_ARRAY_CALLS__ is defined.
+
+ The object(s) can be given directly or via a string (i.e. its
+ object_name). If it is given by a string and the object does not
+ exist yet, it will be loaded.
+
+ ob->fun(args) and "ob_name"->fun(args) is equivalent to
+ call_other(ob, "fun", args). Nowadays the ob_name string can
+ also be a variable.
+
+ ob->fun(args) and ob->"fun"(args) are equivalent to
+ call_other(ob, "fun", args). ob->(fun)(args) are equivalent
+ to call_other(ob, fun, args) where fun is a runtime expression
+ returning the function name.
+
+ If ob::fun does not define a publicly accessible function, the
+ call_other() will return 0, which is indistinguishable from
+ a function returning 0.
+
+ "publicly accessible" means "public" when calling other objects,
+ and "public" or "static" when calling this_object(). "private"
+ and "protected" function can never be called with call_other().
+
+ The return type of call_other() is 'any' be default. However,
+ if your LPC code uses #pragma strict_types, the return type is
+ 'unknown', and the result of call_other() must be casted to
+ the appropriate type before you can use it for anything.
+
+EXAMPLES
+ // All the following statements call the lfun QueryProp()
+ // in the current player with the argument P_SHORT.
+ string str, fun;
+
+ str = (string)call_direct(this_player(), "QueryProp", P_SHORT);
+ fun = "QueryProp";
+ str = (string)call_direct(this_player(), fun, P_SHORT);
+
+ You have to do explicit type casting because of the unknown
+ return type, if you have set #pragma strict_types.
+
+ // This statement calls the lfun short() in all interactive users
+ // and stores the collected results in a variable.
+ string * s;
+
+ s = (string *)call_direct(users(), "short");
+
+
+HISTORY
+ Introduced in LDMud 3.3.113 with the H_DEFAULT_METHOD hook.
+ LDMud 3.2.10 made the call on arrays of objects configurable.
+
+SEE ALSO
+ call_other(E), call_direct_resolved(E), create(A), pragma(LPC),
+ extern_call(E), function_exists(E), functions(LPC)
diff --git a/doc/efun/call_direct_resolved b/doc/efun/call_direct_resolved
new file mode 100644
index 0000000..e227934
--- /dev/null
+++ b/doc/efun/call_direct_resolved
@@ -0,0 +1,25 @@
+SYNOPSIS
+ int call_direct_resolved(mixed result, object ob, string func, ...)
+
+DESCRIPTION
+ Similar to call_direct(). If ob->func() is defined and publicly
+ accessible, any of the optional extra arguments are passed to
+ ob->func(...). The result of that function call is stored in
+ result, which must be passed by reference.
+
+ This efun is a twin to call_resolved(), with the difference
+ being that call_direct_resolved() never calls a default method.
+
+ The efun returns 1 if the function could be called.
+ If ob::fun does not define a publicly accessible function, the
+ efun will return 0.
+
+ ob can also be an object_name. If a string is passed for ob, and
+ no object with that name does exist, an error occurs.
+
+HISTORY
+ Introduced in LDMud 3.3.113 with the H_DEFAULT_METHOD hook.
+
+SEE ALSO
+ call_direct(E), call_resolved(E), function_exists(E),
+ find_object(E)
diff --git a/doc/efun/call_other b/doc/efun/call_other
new file mode 100644
index 0000000..b487f4d
--- /dev/null
+++ b/doc/efun/call_other
@@ -0,0 +1,94 @@
+SYNOPSIS
+ unknown call_other(object ob, string fun, mixed arg, ...);
+ unknown call_other(object *ob, string fun, mixed arg, ...);
+
+ ob->fun(mixed arg, ...);
+ ob->"fun"(mixed arg, ...);
+ ob->(fun)(mixed arg, ...);
+
+BESCHREIBUNG
+ Ruft die in einem anderen Objekt <ob> die Funktion <fun> mit den
+ Argumenten <arg...> auf und gibt den Wert zurueck, der von der
+ Funktion <fun> geliefert wird (oder 0 fuer nicht existierende oder
+ als void deklarierte Funktionen).
+
+ Optional kann der Driver so konfigueriert werden, dass auch ein Array
+ von Objekten *<ob> akzeptiert wird. Die Funktion <fun> wird dann fuer
+ jedes Objekt <ob> im Array mit den Argumenten <arg...> aufgerufen.
+ Die einzelnen Resultate werden in einem Array zusammen gefasst und
+ dieses Array dann als Endresultat von call_other() zurueck gegeben.
+ Die Elemente von *<ob> koennen Objekte oder Namen von Objekten sein.
+ Zerstoerte Objekte und 0 als Element geben eine 0 zurueck, fuehren
+ aber nicht zu einem Fehler.
+ call_other() auf Arrays von Objekten ist im MG aktiviert, welches
+ durch das Define __LPC_ARRAY_CALLS__ angezeigt wird.
+
+ Das Objekt (bzw. die Objekte) kann direkt oder ueber einen String
+ (d.h. den Objektnamen) angegeben werden. Wenn ein String angegeben
+ wird und das Objekt noch nicht existiert, wird es geladen.
+
+ ob->fun(args) und "ob_name"->fun(args) sind aequivalent zu
+ call_other(ob, "fun", args). Heutzutage kann "ob_name" auch eine
+ Variable sein. ob->(fun)(args) ist aequivalent zu
+ call_other(ob, fun, args), wobei <fun> ein Runtime Ausdruck ist,
+ der den Funktionsnamen liefert.
+
+ Wenn das Objekt <ob> keine oeffentliche Funktion mit dem Namen <fun>
+ enthaelt, gibt call_other() den Wert 0 zurueck. Dies ist nicht
+ unterscheidbar von einer Funktion <fun>, die 0 zurueck liefert.
+ Oeffentlich bedeutet "public", wenn andere Objekte aufgerufen
+ werden und "public" oder "static", wenn der Aufruf an this_object()
+ ergeht. Funktionen, die "private" oder "protected" definiert sind,
+ koennen niemals von call_other() aufgerufen werden.
+
+ Der Rueckgabewert von call_other() ist standardmaessig 'any'. Falls
+ aber #pragma strict_types gesetzt ist, ist der Rueckgabewert
+ 'unknown', und das Resultat des call_other() muss zuerst auf einen
+ zutreffenden Variablentyp gecastet werden, bevor man es fuer etwas
+ verwenden kann.
+
+BEISPIELE
+ Die nachfolgenden Beispiele rufen alle die Funktion "QueryProp" auf
+ mit dem Argument P_SHORT.
+
+ string str, fun;
+ str = (string)call_other(this_player(), "QueryProp", P_SHORT);
+ fun = "QueryProp";
+ str = (string)call_other(this_player(), fun, P_SHORT);
+
+ str = (string)this_player()->QueryProp(P_SHORT);
+ str = (string)this_player()->"QueryProp"(P_SHORT);
+ fun = "QueryProp";
+ str = (string)this_player()->(fun)(P_SHORT);
+
+ Solange #pragma strict_types gesetzt ist, muss man das Resultat von
+ call_other() explizit auf einen passenden Typ casten, weil
+ call_other() unknown liefert.
+
+ Das folgende Statement ruft die lfun short() in allen aktiven
+ Benutzern auf und speichert das gesammelte Resultat in einer
+ Variablen:
+
+ string * s;
+ s = (string *)users()->short();
+
+ Objekte laden (obsolet):
+ Compat: call_other("/users/luser/thing", "???", 0);
+
+ Das sieht etwas merkwuerdig aus, wurde aber oft verwendet, um einfach
+ ein Objekt zu laden. Dazu wurde die (nicht existierende) Funktion
+ "???" im Objekt aufgerufen. Gluecklicherweise gibt es heute zu
+ diesem Zweck die Efun load_object(), also bitte nicht mehr verwenden.
+
+AENDERUNGEN
+ In LDMud 3.2.8 wurden die folgenden Verbesserungen eingefuehrt:
+ - die Formen x->"y"() und x->(y)() werden erkannt;
+ - die Form x->y() kollidiert nicht mehr mit einer lokalen Variablen,
+ die auch "y" heisst.
+ - eine simul_efun call_other() erwischt auch Aufrufe der Form ->().
+ - call_other kann auch auf Arrays von Objekten angewandt werden.
+ LDMud 3.2.10 machte den Aufruf von Objektarrays konfigurierbar.
+
+SIEHE AUCH
+ function_exists(E), call_resolved(E), create(A), pragma(LPC),
+ extern_call(E), functions(LPC)
diff --git a/doc/efun/call_out b/doc/efun/call_out
new file mode 100644
index 0000000..dba28b3
--- /dev/null
+++ b/doc/efun/call_out
@@ -0,0 +1,54 @@
+SYNOPSIS
+ 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!
+
+ 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() can only call functions which are publicly accessible,
+ i.e. "public" and "static" functions. "private" and "protected"
+ functions can't be called.
+
+ 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.
+
+ 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
+ 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.
+
+ 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.
+
+SEE ALSO
+ 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/call_out_info b/doc/efun/call_out_info
new file mode 100644
index 0000000..61d5ff5
--- /dev/null
+++ b/doc/efun/call_out_info
@@ -0,0 +1,19 @@
+SYNOPSIS
+ mixed *call_out_info();
+
+BESCHREIBUNG
+ Liefert Informationen ueber alle anhaengigen call_out()s. Das Resultat
+ ist ein Array, bei dem jedes Element wiederum aus einem Array besteht,
+ das einen call_out() beschreibt. Jedes dieser Unter-Arrays enthaelt 3
+ oder mehr Elemente:
+
+ 1. Das Objekt, in dem die Funktion oder die Closure aufgerufen wird.
+ 2. Die Funktion oder Closure.
+ 3. Der verbleibende Delay bis zum Aufruf.
+ 4ff. Die (optionalen) Argumente.
+
+ call_out()s fuer zerstoerte Objekte werden nicht in der Liste
+ aufgefuehrt.
+
+SIEHE AUCH
+ call_out(E), remove_call_out(E), find_call_out(E)
diff --git a/doc/efun/call_resolved b/doc/efun/call_resolved
new file mode 100644
index 0000000..0103766
--- /dev/null
+++ b/doc/efun/call_resolved
@@ -0,0 +1,18 @@
+SYNOPSIS
+ int call_resolved(mixed result, object ob, string func, mixed arg,...);
+
+BESCHREIBUNG
+ Die Funktion ist aehnlich zu call_other(). Wenn obj->func() definiert
+ und oeffentlich ist, werden alle Argumente <arg> an obj->func()
+ uebergeben. Das Resultat dieses Funktionsaufrufes wird in <result>
+ gespeichert und muss deshalb als Referenz uebergeben werden.
+
+ Wenn <ob> zerstoert wurde oder keine oeffentlich zugaengliche Funktion
+ <func> definiert, liefert call_resolved() 0 fuer Fehler, 1 bei Erfolg.
+
+ <ob> kann auch ein object_name() sein. Wenn <ob> ein String ist und
+ das Objekt mit diesem Namen nicht gefunden oder geladen werden kann,
+ tritt ein Fehler auf.
+
+SIEHE AUCH
+ call_other(E), function_exists(E), find_object(E)
diff --git a/doc/efun/caller_stack b/doc/efun/caller_stack
new file mode 100644
index 0000000..d1b5777
--- /dev/null
+++ b/doc/efun/caller_stack
@@ -0,0 +1,33 @@
+SYNOPSIS
+ *object caller_stack();
+ *object caller_stack(int add_interactive);
+
+BESCHREIBUNG
+ Liefert ein Array der previous_object(), die einen call_other() auf
+ this_object() verursacht haben. Dabei entspricht previous_object(i)
+ caller_stack()[i].
+
+ Wenn die Funktion mit <add_interactive> (als wahr) aufgerufen wird,
+ wird this_interactive() dem Array hinzugefuegt, oder 0, wenn kein
+ this_interactive() existiert.
+
+BEISPIEL
+ Das interaktive Objekt A gibt ein Kommando ein, das im Objekt B eine
+ Funktion aufruft, die auf das Objekt C verweist, welches wiederum
+ eine Funktion im Objekt D aufruft.
+
+ Wenn D nun caller_stack() aufruft, ergibt dies: ({C,B}).
+ Fuer caller_stack(1) ergibt die Funktion: ({C,B,A}).
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6, vorgeschlagen von TubMud.
+
+ANMERKUNG
+ Aufrufe von "alien lfun closures" (vergleiche symbol_function())
+ erzeugen zwei Eintraege im Stack, wenn das gebundene Objekt sich vom
+ Objekt der Closure unterscheidet: der erste Eintrag steht fuer das
+ gebundene Objekt, der zweite fuer das Closure-Objekt.
+
+SIEHE AUCH
+ caller_stack_depth(E), previous_object(E), this_interactive(E),
+ call_other(E)
diff --git a/doc/efun/caller_stack_depth b/doc/efun/caller_stack_depth
new file mode 100644
index 0000000..230827e
--- /dev/null
+++ b/doc/efun/caller_stack_depth
@@ -0,0 +1,9 @@
+SYNOPSIS
+ int caller_stack_depth(void)
+
+DESCRIPTION
+ Returns the number of previous objects on the stack. This
+ can be used for security checks.
+
+SEE ALSO
+ caller_stack(E), previous_object(E), call_other(E), call_resolved(E)
diff --git a/doc/efun/capitalize b/doc/efun/capitalize
new file mode 100644
index 0000000..bbb82b7
--- /dev/null
+++ b/doc/efun/capitalize
@@ -0,0 +1,12 @@
+SYNOPSIS
+ string capitalize(string str)
+
+DESCRIPTION
+ Convert the first character in str to upper case, and return
+ the new string.
+
+EXAMPLES
+ capitalize("heya!") -> "Heya!"
+
+SEE ALSO
+ lower_case(E), upper_case(E)
diff --git a/doc/efun/cat b/doc/efun/cat
new file mode 100644
index 0000000..665fe4d
--- /dev/null
+++ b/doc/efun/cat
@@ -0,0 +1,29 @@
+SYNOPSIS
+ int cat(string path, int start, int num)
+
+DESCRIPTION
+ List the file found at path.
+
+ In most installations it is not legal to have '..' or spaces
+ in the path. This commands is normally connected to the "cat"
+ command that wizards have. It is also used by the "help"
+ command. The optional arguments start and num are start line
+ number and number of lines. If they are not given the whole
+ file is printed from the beginning.
+
+ The total number of lines will not exceed a system limit, which
+ normally is 50 lines.
+
+ cat() returns the number of lines read and printed if success,
+ 0 if no such file or no lines to read (if start or len is < 0,
+ or if the file has less than start lines).
+
+EXAMPLE
+ cat("/doc/efun/cat", 5, 9);
+
+ This will print out the file "/doc/efun/cat" begining at line
+ 5 and ending with line 13.
+
+SEE ALSO
+ get_dir(E), file_size(E), read_file(E), read_bytes(E),
+ valid_read(M)
diff --git a/doc/efun/catch b/doc/efun/catch
new file mode 100644
index 0000000..c436b7d
--- /dev/null
+++ b/doc/efun/catch
@@ -0,0 +1,64 @@
+SYNOPSIS
+ mixed catch(expr, expr, ...);
+ mixed catch(expr, expr, ...; modifiers);
+
+BESCHREIBUNG
+ Wertet die Ausdruecke <expr> aus. Wenn kein Fehler auftritt, wird 0
+ zurueck geliefert. Wenn ein Fehler auftritt, wird die Ausfuehrung an
+ diesem Punkt abgebrochen und ein String mit der Fehlermeldung wird
+ zurueck gegeben.
+
+ Systemeigene Fehlermeldungen beginnen mit einem "*", benutzerdefinierte
+ Fehlermeldungen aus throw() und raise_error() (sofern von 0
+ verschieden), werden unveraendert zurueck geliefert.
+
+ Wenn zum Zeitpunkt, zu dem catch() aufgerufen wird, weniger als
+ __CATCH_EVAL_COST__ Rechenticks uebrig sind, wird ein Laufzeitfehler
+ RTE innerhalb von catch() erzeugt (und somit wie jeder andere
+ Fehler abgefangen) und es werden keine Ausdruecke <expr> aus catch()
+ ausgewertet. Der Modifikator 'reserve' kann verwendet werden,
+ einen anderen Wert fuer die Reserve anzugeben.
+
+ Das Verhalten von catch() kann durch <modifiers> veraendert werden:
+
+ 'nolog': Normalerweise wird der Fehler im Fehlerlog
+ gespeichert, um die Fehlersuche zu erleichtern. Wird
+ 'nolog' gesetzt, wird dieser Log-Eintrag unterdrueckt.
+ 'publish': Normalerweise wird master::runtime_error() fuer einen
+ Fehler innerhalb eines catch() nicht aufgerufen. Mit
+ diesem <modifier> wird runtime_error() trotzdem
+ aufgerufen.
+ 'reserve <expr>': <expr> muss eine ganzen Zahl groesser 0
+ ergeben, welche dann als Rechenreserve anstelle
+ von __CATCH_EVAL_COST__ verwendet wird. Das Minimum
+ ist 2 * __MASTER_EVAL_COST__ .
+
+ catch() an sich ist nicht besonders laufzeit-intensiv: es braucht
+ nur etwas mehr Zeit als ein Intra-Objekt Funktionsaufruf.
+
+ throw() ist ebenfalls nicht sehr teuer, da lediglich einige
+ interne Strukturen aufgeraeumt werden muessen.
+
+ Echte Laufzeitfehlers (ob nun mit oder ohne catch()) auf
+ der anderen Seite ist sehr zeitintensiv.
+
+ catch ist nicht im eigentlichen Sinne eine Efun, sondern eine Compiler
+ Anweisung.
+
+BEISPIEL
+ object obj;
+ string err;
+ if(err = catch(obj = clone_object("/foo/bar/baz")))
+ write("Kann das Objekt nicht clonen. Grund: "+err+"\n");
+
+AENDERUNGEN
+ LDMud 3.2.9 fuehrte den 'nolog' catch() als experimentelles Feature
+ ein.
+ LDMud 3.2.10 implementierte 'nolog' als offizielle Form und fuehrte
+ zudem 'publish' ein.
+ LDMud 3.3.559 verlegte den Test auf verbleibende Rechenticks in die
+ vom catch() umschlossenen Ausfuehrung.
+ LDMud 3.3.560 fuegte den Modifikator 'reserve' ein.
+
+SIEHE AUCH
+ throw(E), raise_error(E), predefined(D), runtime_error(M)
diff --git a/doc/efun/ceil b/doc/efun/ceil
new file mode 100644
index 0000000..dc44244
--- /dev/null
+++ b/doc/efun/ceil
@@ -0,0 +1,19 @@
+SYNOPSIS
+ float ceil(int|float arg);
+
+BESCHREIBUNG
+ Rundet <arg> zur naechsten ganzen Zahl auf und liefert das Resultat
+ zurueck. Wenn <arg> ein Integer ist, wird das Resultat in float
+ konvertiert.
+
+BEISPIEL
+ ceil(4.5); ergibt: 5.0
+ ceil(-4.5); ergibt: -4.0
+ ceil(5); ergibt: 5.0
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+ LDMud 3.2.9 fuehrte neu Integer als moegliche Argumente ein.
+
+SIEHE AUCH
+ abs(E), floor(E)
diff --git a/doc/efun/clear_bit b/doc/efun/clear_bit
new file mode 100644
index 0000000..93f15ec
--- /dev/null
+++ b/doc/efun/clear_bit
@@ -0,0 +1,35 @@
+SYNOPSIS
+ string clear_bit(string str, int n);
+
+BESCHREIBUNG
+ Gibt einen neuen String zurueck, in dem das n-te Bit im String <str>
+ nicht gesetzt ist. Dabei wird <str> selbst nicht veraendert.
+
+ Jedes Zeichen enthaelt sechs Bits. So kann in jedem Zeichen eine Zahl
+ zwischen 0 und 63 (2^6=64) gespeichert werden. Das erste Zeichen ist
+ der Leerschlag " " mit Wert 0. Das erste Zeichen im String ist jenes
+ mit den niedrigsten Bits (0 bis 5).
+
+BEISPIELE
+ string s;
+ s = clear_bit("_", 5);
+
+ Weil "_" den hoechsten moeglichen Wert enthaelt (63), enthaelt die
+ Variable s nun das Zeichen "?", das dem Wert 31 entspricht (63-2^5=31).
+
+ string s;
+ s = clear_bit("?<",3);
+ s = clear_bit(s, 8);
+
+ s enthaelt nun den String "78". "?" entspricht dem Wert 31 und "<" dem
+ Wert 28. "?<" entspricht also dem Wert 31+28<<6=31+1792=1823, was in
+ Binaerschreibweise (hoechstes Bit rechts) 11111000111 ergibt. Werden
+ aus dieser Zahl die Bits 3 und 8 (die Nummerierung beginnt mit dem
+ 0. Bit) ergibt dann: 11101000011. Die ersten 6 Bits 010111 sind in
+ Dezimalschreibweise 23. Die zweiten 6 Bits (0)11000 ergeben 24 in
+ Dezimalschreibweise. Nun entspricht der Wert 23 dem Zeichen "7" und
+ der Wert 24 dem Zeichen "8". Der String s enthaelt also "78".
+
+SIEHE AUCH
+ set_bit(E), next_bit(E), last_bit(E), test_bit(E), count_bits(E),
+ and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/clone_object b/doc/efun/clone_object
new file mode 100644
index 0000000..f622bef
--- /dev/null
+++ b/doc/efun/clone_object
@@ -0,0 +1,23 @@
+SYNOPSIS:
+ object clone_object(string name)
+
+DESCRIPTION:
+ Clone a new object from definition name, and give it a new unique
+ name. Return the new object.
+
+ The original, called blue print, used for cloning, should not be
+ used in the game, only be used for cloning. The cloned objects
+ contain only the data but the blue print also the function code.
+ The blue print is the one without a unique number at the end of
+ the object's object_name(). The clone_object() function never
+ returns a blue print.
+
+ Note that the pathname must be complete, which means there are no
+ relative paths allowed.
+
+EXAMPLE:
+ object torch;
+ torch = clone_object("/obj/torch");
+
+SEE ALSO:
+ destruct(E), move_object(E), uids(C)
diff --git a/doc/efun/clonep b/doc/efun/clonep
new file mode 100644
index 0000000..afff71a
--- /dev/null
+++ b/doc/efun/clonep
@@ -0,0 +1,28 @@
+SYNOPSIS
+ int clonep ()
+ int clonep (object obj)
+ int clonep (string obj)
+ int clonep (mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das angegebene Objekt ein Klon ist, ansonsten 0.
+ Das Objekt kann dabei auch durch seinen Objekt-Namen angegeben werden.
+ Wird kein Argument uebergeben, so wird this_object() getestet.
+ Liefert 0, wenn das Argument von einem anderen Typ.
+ Ein Objekt, dessen Programm mittels replace_program() ersetzt wurde,
+ zaehlt nicht als Klon.
+
+BEISPIEL
+ object o;
+ o = clone_object("/obj/ding");
+ write(clonep(o)); --> schreibt "1"
+ write(clonep("/obj/ding")) --> schreibt "0"
+
+ (Im COMPAT_MODE "obj/ding" als Dateinahmen benutzen)
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6, geaendert in 3.2.7, so dass Objekte mit
+ ersetzten Programmen nicht mehr als Klone zaehlen.
+
+SIEHE AUCH
+ load_name(E), clone_object(E), clones(E)
diff --git a/doc/efun/clones b/doc/efun/clones
new file mode 100644
index 0000000..23e20d2
--- /dev/null
+++ b/doc/efun/clones
@@ -0,0 +1,38 @@
+SYNOPSIS
+ *object clones();
+ *object clones(int what);
+ *object clones(string|object obj [, int what]);
+
+BESCHREIBUNG
+ Diese Efun liefert ein Array mit allen Clones eines bestimmten
+ Blueprints. Dabei unterliegt das Array den normalen Systemlimiten.
+
+ Wenn <obj> angegeben ist, werden alle Clones des Blueprints von <obj>
+ (oder von <obj> selbst, falls <obj> ein Blueprint ist) ausgegeben,
+ sonst die Clone des aktuellen Objekts bzw. die Clone des Blueprints
+ des aktuellen Objekts. Wenn <obj> als String angegeben ist, muss es
+ der Name eines existierenden Objekts sein.
+
+ <what> waehlt aus, wie Clone von aelteren Versionen des Blueprints
+ zu behandeln sind:
+ == 0: liefert nur die Clone des aktuellen Blueprints (Standard)
+ == 1: liefert nur die Clone der alten Blueprint-Version
+ == 2: liefert alle Clones aller Blueprint-Versionen
+
+ Wenn der Treiber mit DYNAMIC_COSTS kompiliert wurde, sind die Kosten
+ fuer diese Funktion proportional zur Anzahl Objekte im Spiel.
+
+BEISPIEL
+ object o, p;
+ o = clone_object("/std/thing"); /* oder "std/thing" im COMPAT_MODE */
+ destruct(find_object("/std/thing"));
+ p = clone_object("/std/thing");
+
+ clones("/std/thing") --> ergibt ({ p })
+ clones("/std/thing", 0) --> ergibt ({ p })
+ clones("/std/thing", 1) --> ergibt ({ o })
+ clones("/std/thing", 2) --> ergibt ({ o, p })
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.8.
+ LDMud 3.2.9 fuehrte die dynamischen Kosten ein.
diff --git a/doc/efun/closurep b/doc/efun/closurep
new file mode 100644
index 0000000..25a2829
--- /dev/null
+++ b/doc/efun/closurep
@@ -0,0 +1,11 @@
+SYNOPSIS
+ int closurep(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument eine Closure ist, ansonsten 0.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2@70.
+
+SIEHE AUCH
+ intp(E), referencep(E), symbolp(E)
diff --git a/doc/efun/command b/doc/efun/command
new file mode 100644
index 0000000..09d6c0b
--- /dev/null
+++ b/doc/efun/command
@@ -0,0 +1,50 @@
+command()
+FUNKTION:
+ int command(string str)
+ int command(string str, object ob)
+
+BESCHREIBUNG:
+ Fuehrt str wie ein Kommando welches direkt vom Nutzer abgegeben wurde
+ aus. Alle Effekte des Kommandos wirken sich auf this_object() oder,
+ falls angegeben, auf das Objekt <obj> aus.
+
+ Der Rueckgabewert ist >=1 fuer Erfolg und 0 fuer Misserfolg.
+ Rueckgabewert ist im Erfolgsfall die Hoehe der EvalCost in Ticks.
+
+ Wenn command() auf ein anderes Objekt angewendet wird, koennen auf
+ diesem Wege keine "static" deklarierten Funktionen aufgerufen werden,
+ um etwas Schutz vor unerlaubten Aufrufen zu geben.
+
+ Kommandi werden gestapelt, das heisst, nach der Ausfuehrung von <str>
+ werden die alten Werte fuer this_player(), query_verb() etc. wieder
+ hergestellt (ein Kommando kann dazu fuehren, dass ein Kommando
+ ausgefuehrt wird).
+
+BEMERKUNGEN:
+ Die meisten in Lebewesen definierten Kommandofunktionen sind vor
+ aeusserem Aufrufen durch "static" oAe geschuetzt. Zum Ausfuehren dieser
+ Kommandos muss command_me(L) eingesetzt werden, um diesen Schutz zu
+ umgehen.
+
+BEISPIELE:
+ Siehe command_me(L) fuer einen Vergleich.
+
+ // #1 Ein NPC nimmt und zuendet eine herumliegende /std/lightsource an
+ object f = present("\nlichtquelle", environment());
+ if(f && command("nimm lichtquelle"))
+ if(command("zuende lichtquelle an"))
+ tell_room(environment(), Name(WER)+" freut sich.\n");
+ else
+ tell_room(environment(), Name(WER)+" schaut bedroeppelt.\n");
+
+ // #2 Ein NPC traegt seine Sachen
+ clone_object("/ruestung/sommerkleid")->move(this_object(), 2);
+ command("trage kleid")
+ // aequivalent und besser ist hier:
+ AddItem("/ruestung/sommerkleid", REFRESH_REMOVE|CLONE_WEAR);
+
+SIEHE AUCH
+ command_stack(E), notify_fail(E), enable_commands(E), get_eval_cost(E)
+ command_me(L)
+
+6 Sep 2012 Gloinson
diff --git a/doc/efun/command_stack b/doc/efun/command_stack
new file mode 100644
index 0000000..d3a4e46
--- /dev/null
+++ b/doc/efun/command_stack
@@ -0,0 +1,34 @@
+GESCHUETZT
+SYNOPSIS
+ #include <sys/commands.h>
+
+ *mixed command_stack();
+
+BESCHREIBUNG
+ Liefert ein Array, das den Kommando Stack beschreibt. Das Array
+ umfasst command_stack_depth() Eintraege, der erste davon beschreibt
+ das Top-Level Kommando, der letze Eintrag das aktuelle Kommando.
+
+ Jeder Eintrag ist wiederum ein Array mit folgenden Eintraegen:
+
+ string [CMD_VERB]: das Verb dieses Kommandos
+ string [CMD_TEXT]: der volle Text des Kommandos
+ object [CMD_ORIGIN]: der urspruengliche Kommandogeber
+ object [CMD_PLAYER]: der momentane Kommandogeber
+ mixed [CMD_FAIL]: der Inhalt von notify_fail() (oder 0)
+ mixed [CMD_FAILOBJ]: das Objekt, welches notify_fail() gesetzt
+ hat
+
+ CMD_ORIGIN und CMD_PLAYER sind fuer gewohenlich das gleiche Objekt.
+ Es gibt nur einen Unterschied, wenn der modify_command Hook den
+ Kommandogeber mit set_this_player() aendert.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+ LDMud 3.2.8 fuegte den CMD_FAILOBJ Eintrag hinzu.
+
+ANMERKUNG
+ Jeder der Eintraege im Array kann 0 sein.
+
+SIEHE AUCH
+ command(E), command_stack_depth(E), notify_fail(E)
diff --git a/doc/efun/command_stack_depth b/doc/efun/command_stack_depth
new file mode 100644
index 0000000..37205b5
--- /dev/null
+++ b/doc/efun/command_stack_depth
@@ -0,0 +1,13 @@
+GESCHUETZT
+SYNOPSIS
+ int command_stack_depth();
+
+BESCHREIBUNG
+ Liefert die Anzahl der verschachtelten Kommandi, also die Tiefe des
+ Command Stacks.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+
+SIEHE AUCH
+ command(E), command_stack(E)
diff --git a/doc/efun/configure_driver b/doc/efun/configure_driver
new file mode 100644
index 0000000..fa2407b
--- /dev/null
+++ b/doc/efun/configure_driver
@@ -0,0 +1,133 @@
+SYNOPSIS
+ #include <configuration.h>
+
+ void configure_driver(int what, mixed data)
+
+DESCRIPTION
+ This efun configures runtime adjustable bahviour of the driver.
+
+ Sets the option <what> to the value <data>.
+
+ This function always causes the privilege_violation
+ ("configure_driver", this_object(), what, data).
+
+ <what> == DC_MEMORY_LIMIT
+ Set new soft and hard memory limits for the driver.
+ <data> is expected to be an array with two elements, which have to
+ be integers giving the amount of memory in bytes.
+ ({<soft memory limit>, <hard memory limit>})
+
+ <what> == DC_ENABLE_HEART_BEATS
+ Globally enable the calling of Heartbeats, if <data> is 1,
+ globally disable them if <data> is 0.
+ If called during heartbeat processing, the change comes into effect
+ at the next backend cycle.
+
+ <what> == DC_LONG_EXEC_TIME
+ Set the time considered as (too) long for top-level executions. If
+ an execution exceeds this time, a stack trace will be written to
+ the debug log. The execution will continue at that point.
+ <data> is an integer and measured in microseconds.
+ A time of 0 disables the detection of long executions.
+
+ <what> == DC_DATA_CLEAN_TIME
+ Sets the average time between clean-ups of an objects data
+ structures. This is not to be confused with the standard cleanup
+ time which determines when H_CLEAN_UP is called. A long time for
+ data cleanup may lead to larger memory consumption and prevents
+ destructed objects being cleaned up. A too short time may lead to
+ high loads and lag on the machine. The actual time delay will be a
+ time between 0.9*DC_DATA_CLEAN_TIME and 1.1*DC_DATA_CLEAN_TIME.
+ Default at driver startup are 3600s.
+ <data> is an integer and measured in seconds.
+
+ <what> == DC_TLS_CERTIFICATE
+ Sets the current certificate used for new TLS sessions.
+ It can be one of the certificates in the key directory
+ (command line option --tls-keydirectory) or the main
+ certificate (given with --tls-certfile).
+ Default is the main certificate or else the first
+ certificate found in the directory. The chosen certificate at the
+ time of the tls_init_connection() call is used for that connection.
+ <data> is a string containing the SHA1 fingerprint
+ of the certificate with hexadecimal numbers,
+ it may contain colons or whitespaces (for example
+ "5A:FE:CA:57:1E:50:5E:1E:C7:ED:BA:11:AD:50:10:75:0F:7A:1E:50").
+ When loading certificates their fingerprints are printed
+ on stdout and into the logfile.
+
+ <what> == DC_TLS_DHE_PARAMETER
+ Sets new parameters for the Diffie-Hellman keyexchange for new TLS
+ sessions. The paramters must be given as a PEM encoded string
+ (e.g. the output of 'openssl dhparam -5 2048').
+ If <data> is 0, the built-in defaults will be restored.
+ If importing the new parameters fails (e.g. due to an incorrect
+ format), the driver tries to keep the old parameters
+
+ <what> == DC_TLS_CIPHERLIST
+ Sets a new list of ciphers (OpenSSL) or priorities (GnuTLS) to use.
+ For the correct format, please refer to the help of 'openssl
+ ciphers' or documentation of priority strings in GnuTLS.
+ With GnuTLS a syntax error in the list causes an error.
+ With OpenSSL an error is only raised of none of the given ciphers
+ could be selected.
+ By default, the preferred ciphers of the driver take precedence
+ This can be changed in the priority strings for GnuTLS, but
+ currently not for OpenSSL.
+
+ <what> == DC_EXTRA_WIZINFO_SIZE
+ Indicate that the wizlist should contain an array of the given size
+ with extra info for each wizard. A negative value indicates
+ a non-array value.
+
+ The value is only used to allocate a proper empty 'extra' value
+ for newly created wizlist entries.
+
+ <what> == DC_DEFAULT_RUNTIME_LIMITS
+ Sets the default runtime limits, that will be used for each thread.
+ They will be in effect as the initial limits with the next thread.
+ The limits must be given as an array with the following entries:
+
+ int[LIMIT_EVAL]: the max number of eval costs
+ int[LIMIT_ARRAY]: the max number of array entries
+ int[LIMIT_MAPPING_SIZE]: the max number of mapping values
+ int[LIMIT_MAPPING_KEYS]: the max number of mapping entries
+ int[LIMIT_BYTE]: the max number of bytes handled with
+ one read_bytes()/write_bytes() call.
+ int[LIMIT_FILE]: the max number of bytes handled with
+ one read_file()/write_file() call.
+ int[LIMIT_CALLOUTS]: the number of callouts at one time.
+ int[LIMIT_COST]: how to account the current cost.
+ int[LIMIT_MEMROY]: the max. number of bytes which can be
+ _additionally_ allocated/used
+ _per top-level execution thread_.
+
+ The limit settings recognize three special values:
+
+ LIMIT_UNLIMITED: the limit is deactivated
+ LIMIT_KEEP: the former setting is kept
+ LIMIT_DEFAULT: the 'global' default setting is used.
+
+ For LIMIT_COST, the special values have these meaning:
+ LIMIT_UNLIMITED: at maximum 1 tick is accounted
+ LIMIT_KEEP: LIMIT_COST is set to 0
+ LIMIT_DEFAULT: LIMIT_COST is set to -100
+
+ <what> == DC_SWAP_COMPACT_MODE
+ Sets free swap space shall be reused immediately to keep
+ the swap file as small as possible.
+ (Same as the --swap-compact command line switch.)
+
+HISTORY
+ Introduced in LDMud 3.3.719.
+ DC_ENABLE_HEART_BEATS was added in 3.5.0.
+ DC_LONG_EXEC_TIME was added in 3.5.0.
+ DC_DATA_CLEAN_TIME was added in 3.5.0.
+ DC_EXTRA_WIZINFO_SIZE was added in 3.5.0.
+ DC_TLS_CERTIFICATE was added in 3.5.0.
+ DC_TLS_DHE_PARAMETER was added in 3.5.0.
+ DC_TLS_CIPHERLIST was added in 3.5.0.
+ DC_SWAP_COMPACT_MODE was added in 3.5.0.
+
+SEE ALSO
+ configure_interactive(E)
diff --git a/doc/efun/configure_interactive b/doc/efun/configure_interactive
new file mode 100644
index 0000000..b7d145d
--- /dev/null
+++ b/doc/efun/configure_interactive
@@ -0,0 +1,139 @@
+SYNOPSIS
+ #include <configuration.h>
+
+ void configure_interactive(object ob, int what, mixed data)
+
+DESCRIPTION
+ Sets the option <what> to the value <data> on the interactive <ob>
+ or the default for all interactives if <ob> is 0.
+
+ If the first argument <ob> is not this_object(), the privilege
+ violation ("configure_interactive", this_object(), ob, what, data)
+ occurs.
+
+ As <what>, the following arguments are accepted:
+
+ <what> == IC_MAX_WRITE_BUFFER_SIZE
+ Sets the maximum amount of data to be held pending for writing
+ per player to <data> bytes. A value of -1 means unlimited,
+ 0 deactivates the write buffer.
+
+ <what> == IC_SOCKET_BUFFER_SIZE
+ Changes the socket buffer size to the given size in bytes.
+ Not every operating system might provide this option to
+ change the buffer size.
+
+ The buffer size is used for sending, when the remote side isn't
+ getting the data fast enough. When the socket buffer is full,
+ the driver will buffer in its internal write buffer (see
+ IC_MAX_WRITE_BUFFER_SIZE). When that gets full, too, then
+ messages are discarded.
+
+ <what> == IC_COMBINE_CHARSET_AS_STRING
+ Set the set of characters which can be combined into a single
+ string when already received en-bloc in charmode from the
+ interactive user <ob>. Non-combinable characters and single
+ received characters are returned as separate strings as usual.
+
+ The newline '\n' and the NUL character '\0' are always
+ non-combinable.
+
+ The given string should contain all combinable characters.
+ If given as the number 0, the default combine charset is
+ re-established.
+
+ <what> == IC_COMBINE_CHARSET_AS_ARRAY
+ Set the set of characters which can be combined into a single
+ string, just like IC_COMBINE_CHARSET_AS_STRING.
+
+ The given array shall contain an array of up to 32 integers
+ that are interpreted as 8-bit-values. Each character is encoded
+ as one bit (ASCII characters 0-7 in the first integer, and so on).
+ So a character <n> is treated as combinable if
+
+ array[n/8] & (1 << n%8)
+
+ If the array contains less elements, the missing elements will
+ be regarded as 0 (non-combinable characters).
+
+ <what> == IC_CONNECTION_CHARSET_AS_STRING
+ Set the set of characters which can be output to the interactive
+ user <ob>. All other characters are discarded. (This does not
+ apply to binary_message()).
+
+ The given string should contain all allowed characters.
+ If given as the number 0, the default charset is re-established.
+
+ <what> == IC_CONNECTION_CHARSET_AS_ARRAY
+ Set the set of characters which can be output to the interactive
+ user <ob>, just like IC_CONNECTION_CHARSET_AS_STRING.
+
+ The given array shall contain an array of up to 32 integers
+ that are interpreted as 8-bit-values. Each character is encoded
+ as one bit (ASCII characters 0-7 in the first integer, and so on).
+ So a character <n> is allowed to be output if
+
+ array[n/8] & (1 << n%8)
+
+ If the array contains less elements, the missing elements will
+ be regarded as 0 (not allowed, ie. to be discarded).
+
+ <what> == IC_QUOTE_IAC
+ Sets whether the character 255 (telnet IAC) shall be quoted
+ by prepending another IAC character, so it will not be interpreted
+ by the telnet protocol. Enable with 1, disable with 0. By default
+ it is enabled and does only apply if character 255 is allowed to
+ be output (ie. it is part of the connection charset).
+
+ <what> == IC_TELNET_ENABLED
+ Enables (1) or disables (0) the telnet machine for the interactive
+ user <ob>. When deactivated the driver won't handle telnet
+ negotiations (eg. H_TELNET_NEG won't be called), they will be
+ part of the user input. Also INPUT_NOECHO won't be effective
+ as the driver won't send any telnet negotiations itself.
+
+ <what> == IC_MCCP
+ Starts oder ends MCCP compression of the driver -> client traffic.
+ <data> must be the MCCP version (either TELOPT_COMPRESS or
+ TELOPT_COMPRESS2 from <telnet.h>). When the telnet machine
+ is disabled, any value other then zero will do, and the compression
+ starts without a telnet preamble.
+
+ Available only if the driver is compiled with MCCP enabled;
+ __MCCP__ is defined in that case.
+
+ <what> == IC_PROMPT
+ Sets the prompt for the interactive user <ob> to <data>. The
+ prompt can either be a string or a closure that will be called
+ each time the prompt is shown.
+
+ <what> == IC_MAX_COMMANDS
+ Sets the max number of commands the interactive user <ob> is
+ allowed to execute per second to <data>. A negative value means
+ 'unlimited' and is the setting for newly created connections.
+
+ A 'command' in this context means every received data packet
+ which causes a LPC call - actions and calls to input_to()
+ alike.
+
+ <what> == IC_MODIFY_COMMAND
+ Sets an object that will act as a modifier for each command.
+ All commands for the interactive user <ob> will be passed to
+ data->modify_command() before actually being executed.
+ <data> must be given as an object.
+
+ When an object is set, the H_MODIFY_COMMAND hook wont be
+ called anymore. 0 as argument will stop the command modification
+ and reinstall the use of that driver hook.
+
+ This mechanism is intended to expand aliases on quicktypers
+ or the like. The name of the lfun called can be changed
+ from modify_command() to something else using the
+ H_MODIFY_COMMAND_FNAME hook.
+
+
+HISTORY
+ Introduced in LDMud 3.3.719.
+
+SEE ALSO
+ configure_driver(E)
diff --git a/doc/efun/configure_object b/doc/efun/configure_object
new file mode 100644
index 0000000..9a54789
--- /dev/null
+++ b/doc/efun/configure_object
@@ -0,0 +1,41 @@
+SYNOPSIS
+ #include <configuration.h>
+
+ void configure_object(object ob, int what, mixed data)
+
+DESCRIPTION
+ Sets the option <what> to the value <data> on the object <ob>
+ or the default for all interactives if <ob> is 0.
+
+ If the first argument <ob> is not this_object(), the privilege
+ violation ("configure_object", this_object(), ob, what, data)
+ occurs.
+
+ As <what>, the following arguments are accepted:
+
+ <what> == OC_COMMANDS_ENABLED
+ Sets whether <ob> can use commands normally accessible to
+ users (1) or not (0). This also marks the object as "living".
+
+ <what> == OC_HEART_BEAT
+ Enables (1) or disables (0) the heart beat for <ob>. The
+ driver will apply the lfun heart_beat() to the <ob> every
+ __HEARTBEAT_INTERVAL__ seconds, if it is enabled.
+ A shadow over the heart_beat() lfun will be ignored.
+
+ If the heart beat is not needed for the moment, then do disable
+ it. This will reduce system overhead.
+
+ Note that heart_beat()s are called only if there are enabled
+ via configuer_driver(DC_ENABLE_HEART_BEATS), which is the
+ default.
+
+
+ The current values for these options can be queried using
+ object_info().
+
+HISTORY
+ Introduced in LDMud 3.5.0.
+
+SEE ALSO
+ object_info(E), configure_interactive(E), configure_driver(E)
diff --git a/doc/efun/convert_charset b/doc/efun/convert_charset
new file mode 100644
index 0000000..567ce65
--- /dev/null
+++ b/doc/efun/convert_charset
@@ -0,0 +1,94 @@
+SYNOPSIS
+ string convert_charset(string str, string from_cs, string to_cs)
+
+BESCHREIBUNG
+ Der String <str> wird von Zeichensatz <from_cs> in Zeichensatz
+ <to_cs> umgewandelt und das Ergebnis zurueckgegeben.
+
+ Die Zeichensaetze werden bei Namen angegeben (sowohl Klein-
+ als auch Grossschrift ist zulaessig).
+
+ Die Funktion ist nur verfuegbar auf Systemen mit installierter
+ libiconv.
+
+ Erlaubte Zeichensaetze sind:
+
+ Der derzeitige Systemzeichensatz:
+ "" (der Leerstring)
+
+ European
+ ASCII, ISO-8859-{1,2,3,4,5,7,9,10,13,14,15,16}, KOI8-R, KOI8-U,
+ KOI8-RU, CP{1250,1251,1252,1253,1254,1257}, CP{850,866},
+ Mac{Roman,CentralEurope,Iceland,Croatian,Romania},
+ Mac{Cyrillic,Ukraine,Greek,Turkish}, Macintosh
+
+ Semitic
+ ISO-8859-{6,8}, CP{1255,1256}, CP862, Mac{Hebrew,Arabic}
+
+ Japanese
+ EUC-JP, SHIFT_JIS, CP932, ISO-2022-JP, ISO-2022-JP-2,
+ ISO-2022-JP-1
+
+ Chinese
+ EUC-CN, HZ, GBK, GB18030, EUC-TW, BIG5, CP950, BIG5-HKSCS,
+ ISO-2022-CN, ISO-2022-CN-EXT
+
+ Korean
+ EUC-KR, CP949, ISO-2022-KR, JOHAB
+
+ Armenian
+ ARMSCII-8
+
+ Georgian
+ Georgian-Academy, Georgian-PS
+
+ Tajik
+ KOI8-T
+
+ Thai
+ TIS-620, CP874, MacThai
+
+ Laotian
+ MuleLao-1, CP1133
+
+ Vietnamese
+ VISCII, TCVN, CP1258
+
+ Platform specifics
+ HP-ROMAN8, NEXTSTEP
+
+ Full Unicode
+ UTF-8
+ UCS-2, UCS-2BE, UCS-2LE
+ UCS-4, UCS-4BE, UCS-4LE
+ UTF-16, UTF-16BE, UTF-16LE
+ UTF-32, UTF-32BE, UTF-32LE
+ UTF-7
+ C99, JAVA
+
+ Auf einigen System sind auch die folgenden Zeichensaetze verfuegbar:
+
+ European
+ CP{437,737,775,852,853,855,857,858,860,861,863,865,869,1125}
+
+ Semitic
+ CP864
+
+ Japanese
+ EUC-JISX0213, Shift_JISX0213, ISO-2022-JP-3
+
+ Turkmen
+ TDS565
+
+ Platform specifics
+ RISCOS-LATIN1
+
+
+BEISPIEL
+ convert_charset("Hi!", "ascii", "utf-8")
+
+GESCHICHTE
+ Introduced in LDMud 3.3.531 .
+
+SEE ALSO
+
diff --git a/doc/efun/copy b/doc/efun/copy
new file mode 100644
index 0000000..39f3752
--- /dev/null
+++ b/doc/efun/copy
@@ -0,0 +1,23 @@
+SYNOPSIS
+ mixed copy(mixed arg);
+
+BESCHREIBUNG
+ Erzeugt eine flache Kopie von <arg> und liefert diese zurueck. Fuer
+ Arrays und Mappings heisst das, dass neue Arrays bzw. Mappings erzeugt
+ werden, die Kopien der Elemente des Originals enthalten. Eingebettete
+ Arrays und Mappings werden jedoch als Referenz uebergeben!
+
+ Fuer andere Werte von <arg> bewirkt diese Funktion nichts.
+
+BEISPIEL
+ mixed *a, *b;
+ a = ({ 1, ({ 21, 22 }) });
+ b = copy(a);
+ a[0] = -1; a[1][0] = -21;
+ --> a ist nun ({ -1, ({ -21, 22 }) })
+ b ist nun ({ 1, ({ -21, 22 }) })
+
+SIEHE AUCH
+ deep_copy(E)
+
+10.Apr.2007 Gloinson
\ No newline at end of file
diff --git a/doc/efun/copy_bits b/doc/efun/copy_bits
new file mode 100644
index 0000000..ec68d51
--- /dev/null
+++ b/doc/efun/copy_bits
@@ -0,0 +1,41 @@
+SYNOPSIS
+ string copy_bits(string src, string dest [, int srcstart
+ [, int deststart [, int copylen]]]);
+
+BESCHREIBUNG
+ Kopiert den Bitbereich [<srcstart> .. <srcstart> + <copylen>] aus dem
+ Bitstring <src> in den Bitstring <dest> beginnend an der Position
+ <deststart>. Die alten Werte von <dest> werden dabei ueberschrieben.
+
+ Der resultierende String wird zurueck geliefert, die beiden
+ Originalstrings bleiben unbeeinflusst.
+
+ Wird <srcstart> nicht angegeben, wird <src> von Anfang an kopiert.
+ Ist <srcstart> negativ, wird vom letzten Bit her gezaehlt (d.h. -1
+ bezeichnet das letzte Bit).
+
+ Wird <deststart> nicht angegeben, wird <dest> von Anfang an kopiert.
+ Ist <deststart> negativ, wird vom letzten Bit her gezaehlt (d.h. -1
+ bezeichnet das letzte Bit).
+
+ Wird <copylen> nicht angegeben wird, so wird der gesamte Bitstring
+ <src> kopiert. Das Resultat besteht dann aus dem Bitstring <dest>
+ bis zur Position <deststart>, gefolgt von <src> ab der Position
+ <srcstart>.
+
+ Wenn <copylen> negativ ist, werden abs(<copylen>) _vor_ <srcstart> in
+ das Resultat kopiert.
+
+BEISPIELE
+ copy_bits(src, dest, 10) === src[10..]
+ copy_bits(src, dest, 10, 5) === dest[0..4] + src[10..]
+ copy_bits(src, dest, 10, 5, 3) === dest[0..4] + src[10..12] + dest[8..]
+
+ (Die Notation src[] / dest[] dient nur der Illustration!)
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9
+
+SIEHE AUCH
+ clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E),
+ count_bits(E), or_bits(E), xor_bits(E), invert_bits(E), and_bits(E)
diff --git a/doc/efun/copy_file b/doc/efun/copy_file
new file mode 100644
index 0000000..6e091ed
--- /dev/null
+++ b/doc/efun/copy_file
@@ -0,0 +1,19 @@
+SYNOPSIS
+ int copy_file(string from, string to)
+
+DESCRIPTION
+ The efun copy_file() will copy the file <from> to the new name <to>.
+ If <to> exists and is a directory, then <from> will be placed in that
+ directory and keep its original name.
+
+ You must have read permission for <from> and write permission for
+ the target file to copy the file.
+
+ On successful completion copy_file() will return 0. If any
+ occurs, 1 is returned, or a runtime is generated.
+
+EXAMPLE
+ copy_file("/players/wizard/obj.c", "/players/wizard/newobj.c");
+
+SEE ALSO
+ mkdir(E), rmdir(E), rm(E), rename(E)
diff --git a/doc/efun/cos b/doc/efun/cos
new file mode 100644
index 0000000..85f3e92
--- /dev/null
+++ b/doc/efun/cos
@@ -0,0 +1,11 @@
+SYNOPSIS
+ float cos(int|float)
+
+BESCHREIBUNG
+ Liefert den Kosinus des Argumentes.
+
+AENDERUNGEN
+ LDMud 3.2.9: Ganzzahlen (Integers) als Argument hinzugefuegt.
+
+SIEHE AUCH
+ sin(E), asin(E), acos(E), tan(E), atan(E), atan2(E)
diff --git a/doc/efun/count_bits b/doc/efun/count_bits
new file mode 100644
index 0000000..1b725d0
--- /dev/null
+++ b/doc/efun/count_bits
@@ -0,0 +1,20 @@
+SYNOPSIS
+ int count_bits(string str);
+
+BESCHREIBUNG
+ 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
+
+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
diff --git a/doc/efun/crypt b/doc/efun/crypt
new file mode 100644
index 0000000..932089d
--- /dev/null
+++ b/doc/efun/crypt
@@ -0,0 +1,16 @@
+SYNOPSIS
+ string crypt(string str, int seed);
+ string crypt(string str, string seed);
+
+BESCHREIBUNG
+ Verschluesselt den String <str> mit dem Schluessel <seed>. <seed> kann
+ entweder ein Integer sein oder zwei Zeichen aus dem String <seed>.
+ Wenn <seed> 0 ist, wird ein zufaelliger Schluessel erzeugt.
+
+ Das Resultat enthaelt den Schluessel als die ersten beiden Zeichen.
+
+ Fuer Passwortabfragen, die ohne Echo eingegeben werden koennen sollen,
+ bietet input_to() ein spezielles Flag.
+
+SIEHE AUCH
+ md5_crypt(E), md5(E), sha1(E), hash(E), hmac(E)
\ No newline at end of file
diff --git a/doc/efun/ctime b/doc/efun/ctime
new file mode 100644
index 0000000..8db61f8
--- /dev/null
+++ b/doc/efun/ctime
@@ -0,0 +1,22 @@
+SYNOPSIS
+ string ctime(int clock);
+ string ctime(int* uclock);
+
+BESCHREIBUNG
+ Interpretiert das Argument <clock> als Anzahl Sekunden seit dem
+ 01.JAN.1970, 00:00 Uhr und konvertiert dieses in einen ansehnlichen
+ String, der Datum und Zeit enthaelt. Wenn <clock> nicht angegeben
+ wird, wird time() verwendet.
+
+ Die zweite Form entspricht der ersten, ausser dass das Argument ein
+ Array mit zwei Integer Elementen ist. Das erste Element int[0] gibt
+ die Anzahl Sekunden seit dem 01.JAN.1970 an, das zweite Element
+ int[1] die Anzahl Millisekunden innerhalb dieser Sekunde.
+
+BEISPIEL
+ write(ctime()+"\n");
+
+ Dies gibt etwas aus wie "Sun Oct 26 19:28:30 2003".
+
+SIEHE AUCH
+ dtime(E), gmtime(E), localtime(E), strftime(E), time(E), utime(E)
diff --git a/doc/efun/db_affected_rows b/doc/efun/db_affected_rows
new file mode 100644
index 0000000..1ea2783
--- /dev/null
+++ b/doc/efun/db_affected_rows
@@ -0,0 +1,24 @@
+OPTIONAL
+SYNOPSIS
+ int db_affected_rows(int handle)
+
+BESCHREIBUNG
+ Resultat ist die Anzaehl der Zeilen die vom letzten SQL-Befehl
+ beeinflusst wurden, welches zum SQL-server via <handle> gesendet
+ wurde. Diese Funktion ist nuetzlich lediglich fuer DELETE-
+ und UPDATE-Befehle.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_affected_rows").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_conv_string(E), db_close(E), db_coldefs(E), db_connect(E),
+ db_exec(E), db_error(E), db_fetch(E), db_insert_id(E), db_handles(E),
+ mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_close b/doc/efun/db_close
new file mode 100644
index 0000000..208176c
--- /dev/null
+++ b/doc/efun/db_close
@@ -0,0 +1,22 @@
+OPTIONAL
+SYNOPSIS
+ int db_close(int handle)
+
+BESCHREIBUNG
+ Schliesse die Verbindung <handle> zum SQL-Server. Resultat ist
+ <handle> bei Erfolg.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_close").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_coldefs(E), db_connect(E),
+ db_exec(E), db_error(E), db_fetch(E), db_handles(E), db_insert_id(E),
+ mysql(C, privilege_violation(M))
diff --git a/doc/efun/db_coldefs b/doc/efun/db_coldefs
new file mode 100644
index 0000000..c135a11
--- /dev/null
+++ b/doc/efun/db_coldefs
@@ -0,0 +1,23 @@
+OPTIONAL
+SYNOPSIS
+ string * db_coldefs (int handle)
+
+BESCHREIBUNG
+ Resultat ist ein Array mit den Spaltennamen der Tabelle des
+ letzten QUERY-Befehls. Gab die Datenbank keine Tabelle zurueck, dann
+ gibt die Efun 0 als Ergebnis.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_coldefs").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_connect(E),
+ db_exec(E), db_error(E), db_fetch(E), db_handles(E), db_insert_id(E),
+ mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_connect b/doc/efun/db_connect
new file mode 100644
index 0000000..abe20c9
--- /dev/null
+++ b/doc/efun/db_connect
@@ -0,0 +1,32 @@
+OPTIONAL
+SYNOPSIS
+ int db_connect(string database)
+ int db_connect(string database, string user)
+ int db_connect(string database, string user, string password)
+
+BESCHREIBUNG
+ Stelle eine Verbindung zur SQL-Datenbank <database> des
+ lokalen SQL-Servers her. Das Ergebnis ist die Handle-Nummer fuer diese
+ Verbindung und muss fuer alle Anfragen zu dieser Datenbank verwendet
+ werden.
+
+ Existiert die Datenbank nicht, oder kann der lokale SQL-Server nicht
+ gefunden werden, wird ein Laufzeitfehler erzeugt.
+
+ Wenn angegeben, wird die Verbindung fuer <user> mit <password>
+ erzeugt.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_connect").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_coldefs(E),
+ db_exec(E), db_error(E), db_fetch(E), db_handles(E),
+ db_insert_id(E), mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_conv_string b/doc/efun/db_conv_string
new file mode 100644
index 0000000..b630d6f
--- /dev/null
+++ b/doc/efun/db_conv_string
@@ -0,0 +1,20 @@
+OPTIONAL
+SYNOPSIS
+ string db_conv_string(string str)
+
+BESCHREIBUNG
+ Wandele den String <str> in einen String um, der von der Datenbank
+ korrekt interpretiert werden kann; z.B. werden all Apostrophe
+ durch \' ersetzt.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ db_affected_rows(E), db_close(E), db_coldefs(E), db_connect(E),
+ db_exec(E), db_error(E), db_fetch(E), db_handles(E), db_insert_id(E),
+ mysql(C)
diff --git a/doc/efun/db_error b/doc/efun/db_error
new file mode 100644
index 0000000..cb6d291
--- /dev/null
+++ b/doc/efun/db_error
@@ -0,0 +1,23 @@
+OPTIONAL
+SYNOPSIS
+ string db_error(int handle)
+
+BESCHREIBUNG
+ Result ist ein String, der den Fehler der letzten
+ Datenbanktransaktion beschreibt. War die letzte Transaktion
+ erfolgreich, ist das Ergebnis 0.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_error").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_coldefs(E),
+ db_connect(E), db_exec(E), db_fetch(E), db_handles(E), db_insert_id(E),
+ mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_exec b/doc/efun/db_exec
new file mode 100644
index 0000000..274c983
--- /dev/null
+++ b/doc/efun/db_exec
@@ -0,0 +1,22 @@
+OPTIONAL
+SYNOPSIS
+ int db_exec(int handle, string statement)
+
+BESCHREIBUNG
+ Fuehre den SQL-Befehl <statement> fuer die Verbindung <handle> aus.
+ Resultat ist das Handle bei Erfolg, oder 0 bei einem Fehler.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_exec").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_coldefs(E),
+ db_connect(E), db_error(E), db_fetch(E), db_handles(E),
+ db_insert_id(E), mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_fetch b/doc/efun/db_fetch
new file mode 100644
index 0000000..b143e8a
--- /dev/null
+++ b/doc/efun/db_fetch
@@ -0,0 +1,23 @@
+OPTIONAL
+SYNOPSIS
+ mixed db_fetch(int handle)
+
+BESCHREIBUNG
+ Hole _eine_ Resultatzeile der letzten SQL-Aktion fuer Verbindung
+ <handle>. Sind keine weiteren Zeilen verfuegbar, wird 0
+ zurueckgegeben.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_fetch").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_coldefs(E),
+ db_connect(E), db_error(E), db_exec(E), db_handles(E), db_insert_id(E),
+ mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_handles b/doc/efun/db_handles
new file mode 100644
index 0000000..1a304b5
--- /dev/null
+++ b/doc/efun/db_handles
@@ -0,0 +1,24 @@
+OPTIONAL
+SYNOPSIS
+ int *db_handles()
+
+BESCHREIBUNG
+ Result ist ein Array mit allen aktiven Verbindungshandles zum
+ SQL-Server. Das Array ist nach der Zeit der letzten Aktion sortiert:
+ das zuletzt genutzte Handle kommt an erster Stelle. Sind keine
+ Verbindungen aktiv, ist das Array leer.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_handles").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_coldefs(E),
+ db_connect(E), db_error(E), db_exec(E), db_fetch(E), db_insert_id(E),
+ mysql(C), privilege_violation(M)
diff --git a/doc/efun/db_insert_id b/doc/efun/db_insert_id
new file mode 100644
index 0000000..25e2a17
--- /dev/null
+++ b/doc/efun/db_insert_id
@@ -0,0 +1,23 @@
+OPTIONAL
+SYNOPSIS
+ int db_insert_id (int handle)
+
+BESCHREIBUNG
+ Nach dem Einfuegen einer Zeile in eine Tabelle mit einem
+ AUTO_INCREMENT-Feld, diese Efun kann dazu benutzt werden den neuen
+ Wert dieses Feldes zurueckzugeben.
+
+ Die Funktion ist nur verfuegbar wenn der Driver mit
+ mySQL-Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __MYSQL__ definiert.
+
+ Die Efun ist privilegiert als ("mysql", "db_insert_id").
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.9.
+ LDMud 3.2.11 machte die Efun privilegiert.
+
+SIEHE AUCH
+ db_affected_rows(E), db_conv_string(E), db_close(E), db_coldefs(E),
+ db_connect(E), db_error(E), db_exec(E), db_fetch(E), db_handles(E),
+ mysql(C), privilege_violation(M)
diff --git a/doc/efun/debug_message b/doc/efun/debug_message
new file mode 100644
index 0000000..07e75e6
--- /dev/null
+++ b/doc/efun/debug_message
@@ -0,0 +1,36 @@
+SYNOPSIS
+ #include <sys/debug_message.h>
+
+ void debug_message(string text);
+ void debug_message(string text, int flags);
+
+BESCHREIBUNG
+ Gibt <text> an die Ausgaenge stdout und stderr sowie an die Datei
+ <host>.debug.log, oder an eine beliebige Kombination dieser drei.
+
+ Das Argument <flag> bezeichnet durch eine Kombination von Bitflags das
+ Ziel und die Art, in der das Resultat geschrieben wird.
+
+ Die Ziel-Flags sind: DMSG_STDOUT, DMSG_STDERR und DMS_LOGFILE. Wird
+ zusaetzlich das Flag DMSG_STAMP gesetzt, erhaelt jeder Eintrag einen
+ Zeitstempel (Timestamp) im Format 'YYYY.MM.DD HH:MM:SS '.
+
+ Wenn <flags> 0 ist, weggelassen wird oder kein Ziel-Flag enthaelt,
+ wird <text> standardmaessig an stdout und ins Logfile ausgegeben.
+
+BEISPIEL
+ debug_message("Dieser Text geht an stdout und ins Logfile.\n");
+ debug_message("Dies geht an stderr.\n", DMSG_STDERR);
+ debug_message("Dies geht an stdout und stderr.\n", DMSG_STDOUT
+ | DMSG_STDERR);
+ debug_message("Dies geht an stdout und ins Logfile, mit Timestamp.\n",
+ DMSG_STAMP);
+ debug_message("Die geht an stdout, mit vorangestelltem Timestamp.\n",
+ DMSG_STDOUT | DMSG_STAMP);
+
+AENDERUNGEN
+ Eingefuehrt in 3.2.1@34.
+ LDMud 3.2.9 fuehrte das Argument <flags> ein.
+
+SIEHE AUCH
+ last_instructions(E)
diff --git a/doc/efun/deep_copy b/doc/efun/deep_copy
new file mode 100644
index 0000000..1cef9a8
--- /dev/null
+++ b/doc/efun/deep_copy
@@ -0,0 +1,27 @@
+SYNOPSIS
+ mixed deep_copy(mixed arg);
+
+BESCHREIBUNG
+ Erzeugt eine echte Kopie von <arg> und liefert diese zurueck. Fuer
+ Arrays und Mappings bedeutet dies, dass ein neues Array oder Mapping
+ erzeugt wird, das exakte Kopien der Eintraege des Originals enthaelt.
+ Eingebettete Arrays und Mappings werden ebenso echt kopiert.
+
+ Fuer andere Typen als Mappings und Arrays bewirkt diese Funktion
+ nichts.
+
+ Wenn im Driver DYNAMIC_COST definiert ist, zaehlt jedes eingebettete
+ Mapping oder Array zu den Evaluationskosten sowohl in der Groesse als
+ auch in der Einbettungstiefe.
+
+BEISPIEL
+ mixed *a, *b;
+ a = ({ 1, ({ 21, 22 }) });
+ b = deep_copy(a);
+ a[0] = -1; a[1][0] = -21;
+ --> a ist jetzt ({ -1, ({ -21, 22 }) })
+ b bleibt ({ 1, ({ 21, 22 }) })
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6.
+ LDMud 3.2.9 fuegte die dynamischen Kosten zur Efun hinzu.
diff --git a/doc/efun/deep_inventory b/doc/efun/deep_inventory
new file mode 100644
index 0000000..51f4c66
--- /dev/null
+++ b/doc/efun/deep_inventory
@@ -0,0 +1,36 @@
+SYNOPSIS
+ *object deep_inventory();
+ *object deep_inventory(object ob);
+ object *deep_inventory(object ob, int depth)
+
+BESCHREIBUNG
+ Gibt ein Array der Objekte zurueck, die in <obj> enthalten sind.
+ Wenn <obj> nicht angegeben wird, wird standardmaessig this_object()
+ verwendet. Ebenso werden alle Objekte angegeben, die sich im Inventory
+ der in <obj> enthaltenen Objekte befinden. Die Suche verlaeuft
+ rekursiv absteigend.
+
+ Ist <depth> angegeben und ungleich 0, ist das Resultat wie folgt
+ gefiltert:
+ <depth> > 0: Nur die Objekte in den ersten <depth> Ebenen
+ werden zurueckgegeben.
+ <depth> < 0: Nur die Objekte in der -<depth>ten Ebene werden
+ zurueckgegeben.
+
+BEISPIEL
+ ob
+ +- ob1
+ +- ob2
+ | +- ob21
+ | ob3
+ | +- ob31
+ +- ob4
+
+
+ deep_inventory(ob) => ({ob1, ob2, ob3, ob4, ob21, ob31})
+ deep_inventory(ob, 1) => ({ob1, ob2, ob3, ob4})
+ deep_inventory(ob, 2) => ({ob1, ob2, ob3, ob4, ob21, ob31})
+ deep_inventory(ob, -2) => ({ob21, ob31})
+
+SIEHE AUCH
+ first_inventory(E), next_inventory(E), all_inventory(E)
diff --git a/doc/efun/destruct b/doc/efun/destruct
new file mode 100644
index 0000000..f64de56
--- /dev/null
+++ b/doc/efun/destruct
@@ -0,0 +1,43 @@
+SYNOPSIS
+ void destruct(object ob)
+
+BESCHREIBUNG
+ Zerstoert und entfernt das Objekt ob. Ist ob == 0 (ob wurde schon
+ zerstoert), so passiert nichts. Nach dem Aufruf von destruct()
+ existieren keine globalen Variablen mehr, sondern nur noch lokale
+ Variablen und Argumente.
+
+ Wenn sich ein Objekt selbst zerstoert, wird die Ausfuehrung nicht
+ sofort abgebrochen. Wird die Efun this_object() aufgerufen, so
+ liefert diese 0 zurueck.
+
+ Die meisten Mudlibs moegen es nicht, wenn andere Objekte mittels
+ destruct() ins Daten-Nirwana geschickt werden. Stattdessen erwarten
+ sie den Aufruf einer speziellen Lfun im zu zerstoerenden Objekt,
+ welche normalerweise remove() heisst. Damit kann das zu
+ zerstoerende Objekt noch abschliessende Arbeiten im Zusammenhang
+ mit seinem Ableben erledigen, wie z. B. die Anpassung des Gewichtes
+ seiner Umgebung etc. pp.
+
+ Der Interpreter zerstoert das Objekt nicht sofort, sondern er
+ markiert es als zerstoert, entfernt es von der Liste, die alle
+ Objekte enthaelt, und fuegt es zu der Liste zu zerstoerenden
+ Objekte hinzu. Die tatsaechliche Zerstoerung geschieht erst dann,
+ wenn keine Referenzen mehr auf das Objekt existieren. Deshalb ist
+ es moeglich, dass ein Objekt noch lange nach seiner Zerstoerung
+ Speicher belegt, obwohl es von ausserhalb nicht mehr gefunden wird.
+
+BEISPIEL
+ ob->remove();
+ if(ob) // es existiert noch, vielleicht ist die Lfun
+ // remove() nicht definiert?
+ destruct(ob);
+
+ Dies ist die Standard-Methode, ein Objekt zu zerstoeren, ihm aber
+ vorher noch die Chance zu geben, es selber zu tun.
+
+AENDERUNGEN
+ LDMud 3.2.7: 0 (zerstoerte Objekt) als Argument annehmen.
+
+SIEHE AUCH
+ clone_object(E), remove(A)
diff --git a/doc/efun/disable_commands b/doc/efun/disable_commands
new file mode 100644
index 0000000..0b6757e
--- /dev/null
+++ b/doc/efun/disable_commands
@@ -0,0 +1,10 @@
+SYNOPSIS
+ void disable_commands();
+
+BESCHREIBUNG
+ Verbietet dem Objekt, Kommandi zu verwenden, die normalerweise Usern
+ zugaenglich sind. Diese Funktion ist das Gegenteil von
+ enable_commands().
+
+SIEHE AUCH
+ enable_commands(E)
diff --git a/doc/efun/driver_info b/doc/efun/driver_info
new file mode 100644
index 0000000..f1eaa66
--- /dev/null
+++ b/doc/efun/driver_info
@@ -0,0 +1,685 @@
+SYNOPSIS
+ #include <driver_info.h>
+
+ mixed driver_info(int what)
+
+DESCRIPTION
+ Returns some internal information about the driver.
+ The argument <what> determines which information is returned.
+
+ It can be either a configuration option as given to
+ configure_driver() or one of the following options:
+
+
+
+ Driver Environment:
+
+ <what> == DI_BOOT_TIME:
+ The time() when the driver was started.
+
+
+
+ LPC Runtime status:
+
+ <what> == DI_CURRENT_RUNTIME_LIMITS:
+ Return an array with the current runtime limits.
+ The entries in the returned array are:
+
+ int[LIMIT_EVAL]: the max number of eval costs
+ int[LIMIT_ARRAY]: the max number of array entries
+ int[LIMIT_MAPPING_SIZE]: the max number of mapping values
+ int[LIMIT_MAPPING_KEYS]: the max number of mapping entries
+ (LIMIT_MAPPING is an alias for LIMIT_MAPPING_KEYS)
+ int[LIMIT_BYTE]: the max number of bytes handled with
+ one read_bytes()/write_bytes() call.
+ int[LIMIT_FILE]: the max number of bytes handled with
+ one read_file()/write_file() call.
+ int[LIMIT_CALLOUTS]: the number of callouts at one time.
+ int[LIMIT_COST]: how to account the current cost.
+ int[LIMIT_MEMROY]: the max. number of bytes which can be
+ _additionally_ allocated/used
+ _per top-level execution thread_
+
+ For all limits except LIMIT_COST a limit of '0' aka LIMIT_UNLIMITED
+ means 'no limit'.
+
+ The value for LIMIT_COST has these meanings:
+
+ value > 0: the execution will cost minimum(<value>, actual cost) .
+ value = 0: if the current LIMIT_EVAL is larger than the calling
+ LIMIT_EVAL, the evaluation will cost only 10; otherwise
+ the full cost will be accounted.
+ value < 0: (-value)% of the current evaluation cost will be
+ accounted; -100 obviously means 'full cost'.
+
+ <what> == DI_EVAL_NUMBER:
+ Return the current evaluation number.
+ The number is incremented for each top-level call. Top-level
+ calls are initiated by the driver, usually in reaction to an
+ external event:
+ - commands (added by add_action)
+ - heart_beat, reset, clean_up
+ - calls from call_out or input_to
+ - master applies triggered by external events
+ - calls of driver hooks in reaction to external events
+ - send_erq callbacks
+ - logon in interactives
+
+ The number can be used to detect cases where the same code is
+ executed twice in the same top level evaluation (say, heart_beat),
+ and also for time stamps for ordering some events.
+
+ Please note that the counter may overflow, especially on 32 bit
+ systems. As a result, it can also be negative.
+
+
+
+ Network configuration:
+
+ <what> == DI_MUD_PORTS:
+ Returns an array with all open ports, which the driver
+ listens for player connections on.
+
+ <what> == DI_UDP_PORT:
+ Returns the port number of the UDP socket.
+
+
+
+ Memory management:
+
+ <what> == DI_MEMORY_RESERVE_USER:
+ Current size of the user memory reserve.
+ The user memory reserve is allocated at startup and is used
+ when the driver runs out of memory.
+
+ <what> == DI_MEMORY_RESERVE_MASTER:
+ Current size of the master memory reserve.
+ The master memory reserve is allocated at startup and is used
+ when the driver runs out of memory while executing master
+ code.
+
+ <what> == DI_MEMORY_RESERVE_SYSTEM:
+ Current size of the system memory reserve.
+ The system memory reserve is allocated at startup and is used
+ when the driver runs out of memory while executing internal
+ operations.
+
+
+
+ Traces:
+
+ <what> == DI_TRACE_CURRENT:
+ Returns the current stack trace in array form.
+
+ If the array has more than one entries, the first entry is 0 or
+ the name of the object with the heartbeat which started the
+ current thread; all following entries describe the call stack
+ starting with the topmost function called.
+
+ All call entries are arrays themselves with the following elements:
+
+ int[TRACE_TYPE]: The type of the call frame:
+ TRACE_TYPE_SYMBOL (0): a function symbol (shouldn't happen).
+ TRACE_TYPE_SEFUN (1): a simul-efun.
+ TRACE_TYPE_EFUN (2): an efun closure.
+ TRACE_TYPE_LAMBDA (3): a lambda closure.
+ TRACE_TYPE_LFUN (4): a normal lfun.
+
+ mixed[TRACE_NAME]: The 'name' of the called frame:
+ _TYPE_EFUN: either the name of the efun, or the code of
+ the instruction for operator closures
+ _TYPE_LAMBDA: the numeric lambda identifier.
+ _TYPE_LFUN: the name of the lfun.
+
+ string[TRACE_PROGRAM]: The (file)name of the program holding
+ the code.
+
+ string[TRACE_OBJECT]: The name of the object for which the code
+ was executed.
+ int[TRACE_LOC]:
+ _TYPE_LAMBDA: current program offset from the start of the
+ closure code.
+ _TYPE_LFUN: the line number.
+
+ <what> == DI_TRACE_CURRENT_DEPTH:
+ Return the current number of frames on the control stack
+ (recursion depth).
+
+ <what> == DI_TRACE_CURRENT_AS_STRING:
+ Returns the current stack trace as a string.
+
+ <what> == DI_TRACE_LAST_ERROR:
+ Returns the stack trace of the last error in array form
+ (same format as DI_TRACE_CURRENT). Stack traces of errors
+ before the last GC might not be available anymore.
+
+ <what> == DI_TRACE_LAST_ERROR_AS_STRING:
+ Returns the stack trace of the last error as a string.
+
+ <what> == DI_TRACE_LAST_UNCAUGHT_ERROR:
+ Returns the stack trace of the last uncaught error in array form
+ (same format as DI_TRACE_CURRENT). Stack traces of errors
+ before the last GC might not be available anymore.
+
+ <what> == DI_TRACE_LAST_UNCAUGHT_ERROR_AS_STRING:
+ Returns the stack trace of the last uncaught error as a string.
+
+
+
+ LPC Runtime statistics:
+
+ <what> == DI_NUM_FUNCTION_NAME_CALLS:
+ Number of function calls by name (like call_other).
+
+ <what> == DI_NUM_FUNCTION_NAME_CALL_HITS:
+ Function calls by name are cached (to accelerate
+ lookup of the corresponding program code).
+ This returns the number of cache hits.
+
+ <what> == DI_NUM_FUNCTION_NAME_CALL_MISSES:
+ The number of function call cache misses.
+
+ <what> == DI_NUM_OBJECTS_LAST_PROCESSED:
+ Number of listed objects processed in the last backend cycle.
+
+ <what> == DI_NUM_HEARTBEAT_TOTAL_CYCLES:
+ Total number of heart_beats cycles so far.
+
+ <what> == DI_NUM_HEARTBEAT_ACTIVE_CYCLES:
+ Number of active heart_beat cycles executed so far
+ (ie. cycles in which at least one heart_beat() function
+ was called).
+
+ <what> == DI_NUM_HEARTBEATS_LAST_PROCESSED:
+ Number of heart_beats calls in the last backend cycle
+
+ <what> == DI_NUM_STRING_TABLE_STRINGS_ADDED:
+ Number of distinct strings added to the string table so far.
+
+ <what> == DI_NUM_STRING_TABLE_STRINGS_REMOVED:
+ Number of distinct strings removed from the string table so far.
+
+ <what> == DI_NUM_STRING_TABLE_LOOKUPS_BY_VALUE:
+ Number of string searches by value.
+
+ <what> == DI_NUM_STRING_TABLE_LOOKUPS_BY_INDEX:
+ Number of string searches by address.
+
+ <what> == DI_NUM_STRING_TABLE_LOOKUP_STEPS_BY_VALUE:
+ Number of lookup steps needed for string searches by value.
+
+ <what> == DI_NUM_STRING_TABLE_LOOKUP_STEPS_BY_INDEX:
+ Number of lookup steps needed for string searches by address.
+
+ <what> == DI_NUM_STRING_TABLE_HITS_BY_VALUE:
+ Number of successful lookups of strings by value.
+
+ <what> == DI_NUM_STRING_TABLE_HITS_BY_INDEX:
+ Number of successful lookups of strings by address.
+
+ <what> == DI_NUM_STRING_TABLE_COLLISIONS:
+ Number of distinct strings added to an existing hash chain so far.
+
+ <what> == DI_NUM_REGEX_LOOKUPS:
+ Number of requests for new regexps.
+
+ <what> == DI_NUM_REGEX_LOOKUP_HITS:
+ Number of requested regexps found in the table.
+
+ <what> == DI_NUM_REGEX_LOOKUP_MISSES:
+ Number of requested regexps not found in the table.
+
+ <what> == DI_NUM_REGEX_LOOKUP_COLLISIONS:
+ Number of requested new regexps which collided with a cached one.
+
+
+
+ Network statistics:
+
+ <what> == DI_NUM_MESSAGES_OUT:
+ Number of messages sent to a player.
+
+ <what> == DI_NUM_PACKETS_OUT:
+ Number of packets sent to a player.
+
+ <what> == DI_NUM_PACKETS_IN:
+ Number of packets received from a player.
+
+ <what> == DI_SIZE_PACKETS_OUT:
+ Number of bytes sent to a player.
+
+ <what> == DI_SIZE_PACKETS_IN:
+ Number of bytes received from a player.
+
+
+
+ Load:
+
+ <what> == DI_LOAD_AVERAGE_COMMANDS:
+ A float value that shows the number of executed player commands
+ per second.
+
+ <what> == DI_LOAD_AVERAGE_LINES:
+ A float value that shows the number of compiled code lines
+ per second.
+
+ <what> == DI_LOAD_AVERAGE_PROCESSED_OBJECTS:
+ A float value that shows the average number of objects processed
+ each backend cycle.
+
+ <what> == DI_LOAD_AVERAGE_PROCESSED_OBJECTS_RELATIVE:
+ Average number of objects processed each cycle, expressed
+ as percentage (0..1.0) of the number of present objects.
+
+ <what> == DI_LOAD_AVERAGE_PROCESSED_HEARTBEATS_RELATIVE:
+ Average number of heart_beats called each cycle, expressed
+ as fraction (0..1.0) of the number of active heartbeats.
+
+
+
+ Memory use statistics:
+
+ <what> == DI_NUM_ACTIONS:
+ Number of allocated actions.
+
+ <what> == DI_NUM_CALLOUTS:
+ Number of pending call_outs.
+
+ <what> == DI_NUM_HEARTBEATS:
+ Number of objects with a heartbeat.
+
+ <what> == DI_NUM_SHADOWS:
+ Number of allocated shadows.
+
+ <what> == DI_NUM_OBJECTS:
+ Number of objects.
+
+ <what> == DI_NUM_OBJECTS_SWAPPED:
+ Number of objects that are swapped-out.
+
+ <what> == DI_NUM_OBJECTS_IN_LIST:
+ Number of objects in the object list
+ (i.e. not destructed objects).
+
+ <what> == DI_NUM_OBJECTS_IN_TABLE:
+ Number of objects in the object table.
+
+ <what> == DI_NUM_OBJECTS_DESTRUCTED:
+ Number of destructed, but still referenced objects.
+ (Not counting DI_NUM_OBJECTS_NEWLY_DESTRUCTED).
+
+ <what> == DI_NUM_OBJECTS_NEWLY_DESTRUCTED:
+ Number of newly destructed objects (ie. objects destructed
+ in this execution thread, that will really be destroyed in
+ the next backend cycle).
+
+ <what> == DI_NUM_OBJECT_TABLE_SLOTS:
+ Number of hash slots provided by the object table.
+
+ <what> == DI_NUM_PROGS:
+ Size occupied by the object table.
+
+ <what> == DI_NUM_PROGS_SWAPPED:
+ Number of swapped-out program blocks
+
+ <what> == DI_NUM_PROGS_UNSWAPPED:
+ Number of programs that were swapped-out, are now swapped-in,
+ but still have allocated space in the swap file.
+
+ <what> == DI_NUM_ARRAYS:
+ Number of currently existing arrays.
+
+ <what> == DI_NUM_MAPPINGS:
+ Number of currently existing mappings.
+
+ <what> == DI_NUM_MAPPINGS_CLEAN:
+ Number of clean mappings (mappings without a hash part).
+
+ <what> == DI_NUM_MAPPINGS_HASH:
+ Number of hash mappings.
+
+ <what> == DI_NUM_MAPPINGS_HYBRID:
+ Number of hybrid mappings (mappings that have a
+ condensed and hash part).
+
+ <what> == DI_NUM_STRUCTS:
+ Number of currently existing structs.
+
+ <what> == DI_NUM_STRUCT_TYPES:
+ Number of currently existing struct types.
+
+ <what> == DI_NUM_VIRTUAL_STRINGS:
+ Number of currently existing virtual strings
+ (identical strings are counted separately).
+
+ <what> == DI_NUM_STRINGS:
+ Number of real strings (identical strings
+ are counted once).
+
+ <what> == DI_NUM_STRINGS_TABLED:
+ Number of directly tabled strings.
+
+ <what> == DI_NUM_STRINGS_UNTABLED:
+ Number of untabled strings.
+
+ <what> == DI_NUM_STRING_TABLE_SLOTS:
+ Number of hash slots in the string table.
+
+ <what> == DI_NUM_STRING_TABLE_SLOTS_USED:
+ Number of hash chains in the string table.
+
+ <what> == DI_NUM_REGEX:
+ Number of cached regular expressions.
+
+ <what> == DI_NUM_REGEX_TABLE_SLOTS:
+ Number of slots in the regexp cache table.
+
+ <what> == DI_SIZE_ACTIONS:
+ Total size of allocated actions.
+
+ <what> == DI_SIZE_CALLOUTS:
+ Total size of pending call_outs.
+
+ <what> == DI_SIZE_HEARTBEATS:
+ Total size of the heart_beat list.
+
+ <what> == DI_SIZE_SHADOWS:
+ Total size of allocated shadows.
+
+ <what> == DI_SIZE_OBJECTS:
+ Total size of objects (not counting the size of the values
+ of their variables).
+
+ <what> == DI_SIZE_OBJECTS_SWAPPED:
+ Total size of swapped-out variable blocks.
+
+ <what> == DI_SIZE_OBJECT_TABLE:
+ Size occupied by the object table.
+
+ <what> == DI_SIZE_PROGS:
+ Total size of all programs.
+
+ <what> == DI_SIZE_PROGS_SWAPPED:
+ Total size of swapped-out program blocks
+
+ <what> == DI_SIZE_PROGS_UNSWAPPED:
+ Total size of unswapped program blocks
+
+ <what> == DI_SIZE_ARRAYS:
+ Total size of all arrays (not counting additional sizes
+ of array element values).
+
+ <what> == DI_SIZE_MAPPINGS:
+ Total size of all mapping (not counting additional sizes
+ of contained values).
+
+ <what> == DI_SIZE_STRUCTS:
+ Total size of all structs (not counting additional sizes
+ of contained values).
+
+ <what> == DI_SIZE_STRUCT_TYPES:
+ Total size of all struct type definitions.
+
+ <what> == DI_SIZE_STRINGS:
+ Total size of all strings.
+
+ <what> == DI_SIZE_STRINGS_TABLED:
+ Total size of all tabled strings.
+
+ <what> == DI_SIZE_STRINGS_UNTABLED:
+ Total size of all untabled strings.
+
+ <what> == DI_SIZE_STRING_TABLE:
+ Size of the string table structure itself.
+
+ <what> == DI_SIZE_STRING_OVERHEAD:
+ Size of the overhead per string (compared to a raw string).
+
+ <what> == DI_SIZE_REGEX:
+ Total size of all cached regular expressions.
+
+ <what> == DI_SIZE_BUFFER_FILE:
+ The size of the memory buffer for file operations.
+
+ <what> == DI_SIZE_BUFFER_SWAP:
+ The size of the memory buffer for the swap file.
+
+
+
+ Memory swapper statistics:
+
+ <what> == DI_NUM_SWAP_BLOCKS:
+ Number of blocks in the swap file.
+
+ <what> == DI_NUM_SWAP_BLOCKS_FREE:
+ Number of free blocks in the swap file.
+
+ <what> == DI_NUM_SWAP_BLOCKS_REUSE_LOOKUPS:
+ Number of searches for blocks to reuse in the swap file.
+
+ <what> == DI_NUM_SWAP_BLOCKS_REUSE_LOOKUP_STEPS:
+ Total number of lookup steps in searches for blocks
+ to reuse in the swap file.
+
+ <what> == DI_NUM_SWAP_BLOCKS_FREE_LOOKUPS:
+ Number of searches for blocks to free in the swap file.
+
+ <what> == DI_NUM_SWAP_BLOCKS_FREE_LOOKUP_STEPS:
+ Total number of lookup steps in searches for blocks
+ to free in the swap file.
+
+ <what> == DI_SIZE_SWAP_BLOCKS:
+ Size of the swap file.
+
+ <what> == DI_SIZE_SWAP_BLOCKS_FREE:
+ Size of free blocks in the swap file.
+
+ <what> == DI_SIZE_SWAP_BLOCKS_REUSED:
+ Total reused space in the swap file.
+
+ <what> == DI_SWAP_RECYCLE_PHASE:
+ True if the swapper is currently recycling free block.
+
+
+
+ Memory allocator statistics:
+
+ <what> == DI_MEMORY_ALLOCATOR_NAME:
+ The name of the allocator: "sysmalloc", "smalloc", "slaballoc
+
+ <what> == DI_NUM_SYS_ALLOCATED_BLOCKS:
+ Number of memory blocks requested from the operating system.
+
+ <what> == DI_NUM_LARGE_BLOCKS_ALLOCATED:
+ Number of large allocated blocks.
+ (With smalloc: The large allocated blocks include
+ the small chunk blocks.)
+
+ <what> == DI_NUM_LARGE_BLOCKS_FREE:
+ Number of large free blocks.
+
+ <what> == DI_NUM_LARGE_BLOCKS_WASTE:
+ Number of unusable large memory fragments.
+
+ <what> == DI_NUM_SMALL_BLOCKS_ALLOCATED:
+ Number of small allocated blocks.
+
+ <what> == DI_NUM_SMALL_BLOCKS_FREE:
+ Number of small free blocks.
+
+ <what> == DI_NUM_SMALL_BLOCKS_WASTE:
+ Number of unusably small memory fragments.
+
+ <what> == DI_NUM_SMALL_BLOCK_CHUNKS:
+ Number of small chunk/slab blocks.
+ (That are large blocks that are used as a
+ base for small blocks.)
+
+ <what> == DI_NUM_UNMANAGED_BLOCKS:
+ Number of unmanaged (non-GC-able) allocations.
+
+ <what> == DI_NUM_FREE_BLOCKS_AVL_NODES:
+ Number of AVL nodes used to manage the large free
+ blocks. This value might go away again.
+
+ <what> == DI_SIZE_SYS_ALLOCATED_BLOCKS:
+ Total size of memory requested from the operating system.
+
+ <what> == DI_SIZE_LARGE_BLOCKS_ALLOCATED:
+ Total size of large allocated blocks.
+
+ <what> == DI_SIZE_LARGE_BLOCKS_FREE:
+ Total size of large free blocks.
+
+ <what> == DI_SIZE_LARGE_BLOCKS_WASTE:
+ Total size of unusable large memory fragments.
+
+ <what> == DI_SIZE_LARGE_BLOCK_OVERHEAD:
+ The overhead of every large block allocation.
+
+ <what> == DI_SIZE_SMALL_BLOCKS_ALLOCATED:
+ Total size of small allocated blocks.
+
+ <what> == DI_SIZE_SMALL_BLOCKS_FREE:
+ Total size of small free blocks.
+
+ <what> == DI_SIZE_SMALL_BLOCKS_WASTE:
+ Total size of unusably small memory fragments.
+
+ <what> == DI_SIZE_SMALL_BLOCK_OVERHEAD:
+ The overhead of every small block allocation.
+
+ <what> == DI_SIZE_SMALL_BLOCK_CHUNKS:
+ Total size of small chunk/slab blocks.
+
+ <what> == DI_SIZE_UNMANAGED_BLOCKS:
+ Total size of unmanaged (non-GC-able) allocations.
+
+ <what> == DI_SIZE_MEMORY_USED:
+ The amount of memory currently allocated from the allocator.
+
+ <what> == DI_SIZE_MEMORY_UNUSED:
+ The amount of memory allocated from the system, but
+ not used by the driver.
+
+ <what> == DI_SIZE_MEMORY_OVERHEAD:
+ Amount of memory used for the management of the memory.
+
+ <what> == DI_NUM_INCREMENT_SIZE_CALLS:
+ Number of requests to increase the size of a memory block.
+
+ <what> == DI_NUM_INCREMENT_SIZE_CALL_SUCCESSES:
+ Number of successful requests to increase the
+ size of a memory block.
+
+ <what> == DI_SIZE_INCREMENT_SIZE_CALL_DIFFS:
+ Total size of additionally allocated memory by
+ increasing already allocated memory blocks.
+
+ <what> == DI_NUM_REPLACEMENT_MALLOC_CALLS:
+ Number of allocations done through the
+ clib functions (if supported by the allocator).
+
+ <what> == DI_SIZE_REPLACEMENT_MALLOC_CALLS:
+ Total size of allocations done through the
+ clib functions (if supported by the allocator).
+
+ <what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALLS_FULL:
+ Total number of requests to defragment all small memory chunks.
+
+ <what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALLS_TARGETED:
+ Total number of requests to defragment small memory chunks
+ for a desired size.
+
+ <what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALL_TARGET_HITS:
+ Total number of successful requests to defragment small
+ memory chunks for a desired size.
+
+ <what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_INSPECTED:
+ Number of blocks inspected during defragmentations.
+
+ <what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_MERGED:
+ Number of blocks merged during defragmentations.
+
+ <what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_RESULTING:
+ Number of defragmented blocks (ie. merge results).
+
+ <what> == DI_MEMORY_EXTENDED_STATISTICS:
+ If the driver was compiled with extended memory statistics,
+ they are returned in this entry; if the driver was compiled
+ without the statistics, 0 is returned.
+
+ The array contains NUM+2 entries, where NUM is the number
+ of distinct small block sizes. Entry [NUM] describes the
+ statistics of oversized small blocks (smalloc) resp. for
+ all slabs (slaballoc), entry [NUM+1] summarizes all large
+ blocks. Each entry is an array of these fields:
+
+ int DIM_ES_MAX_ALLOC:
+ Max number of allocated blocks of this size.
+
+ int DIM_ES_CUR_ALLOC:
+ Current number of allocated blocks of this size.
+
+ int DIM_ES_MAX_FREE:
+ Max number of allocated blocks of this size.
+
+ int DIM_ES_CUR_FREE:
+ Current number of allocated blocks of this size.
+
+ float DIM_ES_AVG_XALLOC:
+ Number of explicit allocation requests per
+ second.
+
+ float DIM_ES_AVG_XFREE:
+ Number of explicit deallocation requests per
+ second.
+
+ int DIM_ES_FULL_SLABS:
+ Number of fully used slabs (slaballoc only).
+
+ int DIM_ES_FREE_SLABS:
+ Number of fully free slabs (slaballoc only).
+
+ int DIM_ES_TOTAL_SLABS:
+ Total number of slabs: partially used, fully used
+ and fully free (slaballoc only).
+
+ The allocation/deallocation-per-second statistics do
+ not cover internal shuffling of the freelists.
+
+ The slab statistics (entry [NUM], slaballoc only) shows
+ in the AVG statistics the frequence with which slabs were
+ allocated from resp. returned to the large memory pool.
+
+
+
+ Status texts:
+
+ <what> == DI_STATUS_TEXT_MEMORY:
+ A printable string containing information about
+ the memory usage.
+
+ <what> == DI_STATUS_TEXT_TABLES:
+ A printable string containing information about
+ the LPC runtime.
+
+ <what> == DI_STATUS_TEXT_SWAP:
+ A printable string containing information about
+ the swap system.
+
+ <what> == DI_STATUS_TEXT_MALLOC:
+ A printable string containing information about
+ memory allocations.
+
+ <what> == DI_STATUS_TEXT_MALLOC_EXTENDED:
+ A printable strings with extended memory statistics
+ (if the driver was compiled with them).
+
+
+HISTORY
+ Introduced in LDMud 3.5.0.
+
+SEE ALSO
+ configure_driver(E), object_info(E), interactive_info(E),
+ dump_driver_info(E)
diff --git a/doc/efun/dump_driver_info b/doc/efun/dump_driver_info
new file mode 100644
index 0000000..111f8ad
--- /dev/null
+++ b/doc/efun/dump_driver_info
@@ -0,0 +1,75 @@
+SYNOPSIS
+ #include <driver_info.h>
+
+ int dump_driver_info(int what)
+ int dump_driver_info(int what, string filename)
+
+DESCRIPTION
+ Dumps information specificied by <what> into a file
+ specified by <filename>. If <filename> is omitted,
+ a default file name is used. The function calls
+ master->valid_write() to check that it can write
+ the files. The file in question is always written anew
+
+ On success the efun returns 1, or 0 if an error occured.
+
+ <what> == DDI_OBJECTS:
+ Dumps information about all live objects.
+ Default filename is '/OBJ_DUMP',
+ valid_write() will read 'objdump' for the function.
+
+ For every object, a line is written into the file with the
+ following information in the given order:
+ - object name
+ - size in memory, shared data counted only once
+ - size in memory if data wouldn't be shared
+ - number of references
+ - 'HB' if the object has a heartbeat, nothing if not.
+ - the name of the environment, or '--' if the object
+ has no environment
+ - in parentheses the number of execution ticks spent
+ in this object
+ - the swap status:
+ nothing if not swapped,
+ 'PROG SWAPPED' if only the program is swapped
+ 'VAR SWAPPED' if only the variabes are swapped
+ 'SWAPPED' if both program and variables are swapped
+ - the time the object was created
+
+ <what> == DDI_OBJECTS_DESTRUCTED:
+ Dumps information about all destructed objects.
+ Default filename is '/DEST_OBJ_DUMP',
+ valid_write() will read 'objdump' for the function.
+
+ For every object, a line is written into the file with the
+ following information in the given order:
+ - object name
+ - number of references
+ - 'NEW' if the object was destructed in this execution
+ thread, nothing if it is older already.
+
+ <what> == DDI_OPCODES:
+ Dumps usage information about the opcodes.
+ Default filename is '/OPC_DUMP',
+ valid_write() will read 'opcdump' for the function.
+
+ <what> == DDI_MEMORY:
+ Dumps a list of all allocated memory blocks (if the allocator
+ supports this).
+ Default filename is '/MEMORY_DUMP',
+ valid_write() will read 'memdump' for the function,
+ and the new data will be appended to the end of the file.
+
+ If the allocator doesn't support memory dumps, this call will
+ always return 0, and nothing will be written.
+
+ This works best if the allocator is compiled with
+ MALLOC_TRACE and/or MALLOC_LPC_TRACE.
+
+ NOTE: Make sure that this option can't be abused!
+
+HISTORY
+ Introduced in LDMud 3.5.0.
+
+SEE ALSO
+ driver_info(E), object_info(E), interactive_info(E)
diff --git a/doc/efun/ed b/doc/efun/ed
new file mode 100644
index 0000000..8a8dc33
--- /dev/null
+++ b/doc/efun/ed
@@ -0,0 +1,19 @@
+SYNOPSIS
+ void ed()
+ void ed(string file)
+ void ed(string file, string func)
+
+DESCRIPTION
+ Calling without arguments will start the editor ed with the
+ name of the error file, that was returned by
+ master->valid_read(0, geteuid(this_player()), "ed_start",
+ this_player()), usually something like ~/.err. If that file is
+ empty, ed will immediatly exit again.
+ Calling ed() with argument file will start the editor on the
+ file. If the optional argument func is given, this function
+ will be called after exiting the editor.
+
+ The editor ed is almost ed(1) compatible.
+
+SEE ALSO
+ enable_commands(E), query_editing(E), ed0(LPC)
diff --git a/doc/efun/efun b/doc/efun/efun
new file mode 100644
index 0000000..88cd3f5
--- /dev/null
+++ b/doc/efun/efun
@@ -0,0 +1,45 @@
+NAME
+ efun
+
+BESCHREIBUNG
+ Dieses Directory enthaelt die Beschreibungen fuer die Efuns in
+ LDMud 3.3 .
+
+ Diese Funktionen werden vom Driver zur Verfuegung gestellt und koennen
+ von jedem LPC-Objekt verwendet werden.
+
+ Spezielle Arten dieser Efuns sind:
+
+ - 'Optional'
+
+ Es steht dem Mud-Betreiber frei, diese Efuns zu deaktivieren.
+
+ assoc()
+ break_point()
+ db_*()
+ insert_alist()
+ intersect_alist()
+ parse_command()
+ process_string()
+ rusage()
+ set_is_wizard()
+ set_light()
+ transfer()
+
+ - 'Vorlaeufig'
+
+ Das Verhalten dieser Efuns kann sich in spaeteren Driverversionene
+ aendern.
+
+
+ - 'Obsolet' or 'Veraltet'
+
+ make_shared_string()
+
+ Diese Efuns sollten nicht weiter verwendet werden. Sie stehen
+ lediglich aus Kompatibilitaetsgruenden zur Verfuegung, und
+ werden in einer spaeteren Drivervariante entfernt werden.
+
+
+SIEHE AUCH
+ efuns(LPC), applied(A), master(M), lpc(LPC), concepts(C), driver(D)
diff --git a/doc/efun/efun__m_delete b/doc/efun/efun__m_delete
new file mode 100644
index 0000000..32b9e02
--- /dev/null
+++ b/doc/efun/efun__m_delete
@@ -0,0 +1,24 @@
+SYNOPSIS:
+ mapping m_delete(mapping map, mixed key)
+
+DESCRIPTION:
+ Remove the entry with index 'key' from mapping 'map', and
+ return the changed mapping. If the mapping does not have an
+ entry with index 'key', the first argument is returned.
+
+ If you don't want to modify the mapping map, checkout the
+ simul_efun m_delete().
+
+EXAMPLE:
+
+ mapping m1, m2;
+
+ m1 = ([ "a":1, "b":2, "c":3 ]);
+
+ m2 = efun::m_delete(m1, "b");
+ => m1 = ([ "a":1, "c":3 ])
+ m2 = ([ "a":1, "c":3 ])
+
+SEE ALSO:
+ mappingp(E), mkmapping(E), m_indices(E), m_values(E),
+ sizeof(E)
diff --git a/doc/efun/environment b/doc/efun/environment
new file mode 100644
index 0000000..ea10b3d
--- /dev/null
+++ b/doc/efun/environment
@@ -0,0 +1,69 @@
+SYNOPSIS
+ object environment();
+ object environment(object obj);
+ object environment(string obj);
+
+ARGUMENTE:
+ obj
+ Objekt oder Pfad-String eines Objektes dessen Umgebungsobjekt
+ gesucht ist
+
+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.
+
+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.
+
+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)
+ all_environment(E)
+
+20. Sep. 2002 Gloinson@MG
\ No newline at end of file
diff --git a/doc/efun/exec b/doc/efun/exec
new file mode 100644
index 0000000..c86d3e0
--- /dev/null
+++ b/doc/efun/exec
@@ -0,0 +1,39 @@
+SYNOPSIS
+ int exec(object new, object old)
+
+DESCRIPTION
+ exec() switches the connection from the interactive object old
+ to the object new. If the new object is also interactive, it's
+ connection will be transferred to the old object, thus
+ exchaning the two connections between the object. If the new
+ object is not interactive, the old will not be interactive
+ anymore after the exec call succeeded.
+
+ The result is 1 on success, and 0 on failure.
+
+ exec() is used to load different "user objects" or to reconnect
+ link dead users.
+
+ To provide security mechanisms, the interpreter calls
+ master->valid_exec(current_program, new, old), which must
+ return anything other than 0 to allow this exec() invocation.
+
+ After the exec(), if arg 2 was this_player(), this_player()
+ becomes arg 1, else vice versa. Ditto for this_interactive().
+
+ Take care when writing a simul-efun around exec(): the
+ 'current_program' passed to the valid_exec() function will be
+ that of the simul-efun object. To get around this, use
+ bind_lambda() to bind #'exec to the real object and funcall()
+ the resulting closure.
+
+EXAMPLE
+ ob = clone_object("std/player");
+ exec(ob, this_object());
+ destruct(this_object());
+
+HISTORY
+ LDMud 3.2.9 added the switchover of this_interactive().
+
+SEE ALSO
+ connect(M), disconnect(M), logon(A), interactive(E)
diff --git a/doc/efun/execute_command b/doc/efun/execute_command
new file mode 100644
index 0000000..0784c7e
--- /dev/null
+++ b/doc/efun/execute_command
@@ -0,0 +1,21 @@
+VORLAEUFIG, GESCHUETZT
+SYNOPSIS
+ int execute_command(string command, object origin, object player);
+
+BESCHREIBUNG
+ Diese Funktion bietet Low-Level Zugriff auf den Kommandoparser:
+ <command> wird in Verb und Rest aufgespaltet und es werden die
+ entsprechenden add_actions in <origin> aufgerufen. Fuer die
+ Ausfuehrung der Funktion(en) wird this_player() auf <player> gesetzt.
+ execute_command() setzt auch passende Werte fuer query_command()
+ und query_verb(), die dem angegebenen <command> entsprechen.
+
+ execute_command() beruecksichtigt weder den H_MODIFY_COMMAND noch den
+ H_NOTIFY_FAIL Hook. Zwar kann notify_fail() verwendet werden, die
+ Verarbeitung muss jedoch durch das aufrufende Objekt erfolgen.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7
+
+SIEHE AUCH
+ hooks(C), command(E), notify_fail(E), command_stack(E)
diff --git a/doc/efun/exp b/doc/efun/exp
new file mode 100644
index 0000000..c5746dc
--- /dev/null
+++ b/doc/efun/exp
@@ -0,0 +1,8 @@
+SYNOPSIS
+ float exp(int|float zahl);
+
+BESCHREIBUNG
+ Die Exponentialfunktion. Liefert e^zahl.
+
+SIEHE AUCH
+ log(E), pow(E)
diff --git a/doc/efun/expand_define b/doc/efun/expand_define
new file mode 100644
index 0000000..c6ff189
--- /dev/null
+++ b/doc/efun/expand_define
@@ -0,0 +1,24 @@
+SYNOPSIS
+ string expand_define (string name)
+ string expand_define (string name, string arg, ...)
+
+DESCRIPTION
+ Expands the macro <name> with the argument(s) <arg>... (default is
+ one empty string "").
+ Result is the expanded macro, or 0 if there is no macro with
+ that name.
+
+ This efun is applicable only while an object is compiled,
+ therefore its usage is restricted to a few functions like the
+ H_INCLUDE_DIRS driver hook, or the masters runtime_error()
+ function.
+
+EXAMPLE
+ While compiling 'foo.c':
+ expand_define("__FILE__") --> "foo.c"
+
+HISTORY
+ Introduced in 3.2.1@93.
+
+SEE ALSO
+ hooks(C), runtime_error(M)
diff --git a/doc/efun/explode b/doc/efun/explode
new file mode 100644
index 0000000..096eaa1
--- /dev/null
+++ b/doc/efun/explode
@@ -0,0 +1,28 @@
+SYNOPSIS
+ string *explode(string str, string del)
+
+BESCHREIBUNG
+ Liefert ein Feld (Array) mit Zeichenketten (Strings), indem alle
+ Vorkommen von del (delimiter = Trenner) aus str herausgeschnitten
+ werden und so str in mehrere Zeichenketten zerlegt wird.
+
+ implode(explode(str, del), del) == str ist immer wahr.
+
+BEISPIELE
+ Funktion Rueckgabewert
+ -------------------------------------------------------------------
+ explode(" ab cd ef ", " ") ({ "", "ab", "cd", "ef", "" })
+ explode("abc", "abc") ({ "", "" })
+ explode("", "") ({})
+ explode("abc", "xyz") ({ "abc" })
+ explode("abc", "") ({ "a", "b", "c" })
+
+AENDERUNGEN
+ Zeitpunkt der Aenderung unbekannt.
+ explode(" ab cd ef ", " ") lieferte frueher ({ "ab", "cd", "ef" })
+ anstatt ({ "", "ab", "cd", "ef", "" }), d. h., leere Zeichenketten
+ wurden ignoriert. Das neue Verhalten ist schoener, da nun
+ implode(explode(str, del), del) == str immer wahr ist.
+
+SIEHE AUCH
+ sscanf(E), implode(E), regexplode(E)
diff --git a/doc/efun/export_uid b/doc/efun/export_uid
new file mode 100644
index 0000000..5b1f6a3
--- /dev/null
+++ b/doc/efun/export_uid
@@ -0,0 +1,15 @@
+SYNOPSIS
+ void export_uid(object ob)
+
+DESCRIPTION
+ Set the uid of object ob to the current object's effective uid.
+ It is only possible when object ob has an effective uid of 0.
+
+ This efun is not available in Morgengrauen.
+
+HISTORY
+ Since 3.2.1@47, this efun is availabe only when using euids.
+ Since 3.2.7, this efun is always available.
+
+SEE ALSO
+ seteuid(E), getuid(E), geteuid(E), uids(C), native(C)
diff --git a/doc/efun/extern_call b/doc/efun/extern_call
new file mode 100644
index 0000000..03dca5f
--- /dev/null
+++ b/doc/efun/extern_call
@@ -0,0 +1,12 @@
+SYNOPSIS
+ int extern_call();
+
+BESCHREIBUNG
+ Liefert 0, wenn die momentane ausgefuehrte Funktion durch eine lokale
+ Funktion aufgerufen wurde, einen Wert ungleich 0 fuer Aufrufe durch
+ call_other(), den Treiber, Closures etc. Im Moment liefert die
+ Funktion in all diesen Faellen 1 zurueck, in Zukunft koennte
+ allerdings eine Unterscheidung der Aufrufe moeglich werden.
+
+SIEHE AUCH
+ call_other(E), previous_object(E)
\ No newline at end of file
diff --git a/doc/efun/file_size b/doc/efun/file_size
new file mode 100644
index 0000000..d49dd53
--- /dev/null
+++ b/doc/efun/file_size
@@ -0,0 +1,35 @@
+FUNKTION:
+ int file_size(string file)
+
+BESCHREIBUNG:
+ Liefert die Groesse des Files in Bytes.
+
+RUECKGABEWERT:
+ Liefert die Dateigroesse in Bytes.
+
+ Davon abweichend kann auch folgendes als Rueckgabewert vor-
+ kommen:
+
+ 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.
+
+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
diff --git a/doc/efun/filter b/doc/efun/filter
new file mode 100644
index 0000000..61bc1e8
--- /dev/null
+++ b/doc/efun/filter
@@ -0,0 +1,189 @@
+filter(E)
+
+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...)
+
+ mapping filter (mapping arg, string func, string|object ob
+ , mixed extra...)
+ mapping filter (mapping arg, closure cl, mixed extra...)
+
+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
+
+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.
+
+ Ist <arg> ein Array, wird <fun> mit jedem Element des Arrays 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.
+
+ 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.
+
+ Wenn <arg> ein Mapping ist, wird die Funktion <func> mit jedem Key
+ als erstem und (falls vorhanden) den Werten dieses Keys als restliche
+ Parameter, gefolgt von den <extra> Argumenten, aufgerufen. Wenn die
+ Funktion TRUE ergibt, wird das betreffende Element des Mappings ins
+ Ergebnis aufgenommen.
+
+ Abhaengig von der Groesse des Mappings <arg> erfolgt der Aufruf der
+ Funktion auf drei unterschiedliche Arten:
+
+ widthof(arg) == 0: ob->func(key, 0, extra,...);
+ widthof(arg) == 1: ob->func(key, arg[key], extra, ...);
+ widthof(arg) >1: ob->fund(key, ({arg[key,0]...arg[key, n-1]}),
+ extra, ...);
+
+ 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.
+
+ 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.
+
+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 Lambda-Closure (langsamer, nicht fuer alle leserlich)
+ idle_usr = filter(users(), lambda(({'u}), ({#'query_idle, 'u})));
+
+ #4: erreicht dasselbe wie #3 mit besser lesbarer 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 Lambda-Closure (langsamer, nicht fuer alle leserlich)
+ idle_usr = filter(users(),
+ lambda(({'u, 'l}), ({#'>,({#'query_idle, 'u}),'l})),
+ 20);
+
+ #4: erreicht dasselbe wie #3 mit einer deutlich besser lesbaren
+ Inline-Closure (gegenueber Lambdas zu empfehlende Variante):
+ idle_usr = filter(users(), function int (object user, int length) {
+ return (query_idle(user) > length);
+ }, 20);
+
+
+AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
+ int i;
+ mixed *ret; mixed *input;
+
+ ret=allocate(0);
+ i=sizeof(input);
+ while(i--)
+ if(ob->fun(input[i] [, extra1, extra2, ...]))
+ // if(funcall(cl, input[i] [, extra1, extra2, ...]))
+ // if(member(map, input[i]))
+ ret+=({input[i]});
+
+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)
+
+----------------------------------------------------------------------------
+09.04.2008, Zesstra
+
diff --git a/doc/efun/filter.eng b/doc/efun/filter.eng
new file mode 100644
index 0000000..5d0be29
--- /dev/null
+++ b/doc/efun/filter.eng
@@ -0,0 +1,49 @@
+filter(E)
+SYNOPSIS
+ mixed *filter(mixed *arr, string fun, string|object ob
+ [, mixed extra, ...])
+ mixed *filter(mixed *arr, closure cl [, mixed extra, ...])
+ mixed *filter(mixed *arr, mapping map [, mixed extra, ...])
+
+DESCRIPTION
+ Returns an array holding the items of arr filtered through
+ ob->fun(element, extra, ...), the closure cl, or the mapping map.
+ The function 'fun' in 'ob' resp. the closure 'cl' is called
+ for each element in arr with that element as parameter. The
+ extra and following parameters are in each call if given.
+ The mapping 'map' is likewise indexed by each element.
+ If ob->fun(arr[index], extra) returns != 0 resp.
+ map[arr[index]] exists, the element is included in the
+ returned array.
+
+ If arr is not an array, an error occurs.
+
+ The extra argument(s) are optional and must not be protected
+ references like &(i[0]).
+ If <ob> is omitted, or neither a string nor an object, it
+ defaults to this_object().
+
+ Since 3.2.1@36, the second arg can also be a mapping. Then
+ only the elements of the array which belong to the map (as
+ keys) will be returned (i.e. map[arr[index]] != 0).
+
+EXAMPLE
+ int check_if_idle(object user) { return query_idle(user); }
+
+ ...
+
+ object *idle_users;
+
+ idle_users = filter(users(), "check_if_idle");
+ /* equivalent but smaller and faster */
+ idle_users = filter(users(), #'query_idle );
+
+ Now idle_users contains all users that have been idle for more
+ than 1 second.
+
+SEE ALSO:
+ Similar filter: filter(E), filter_object(E), filter_indices(E)
+ Mapping: map(E), map_objects(E), map_indices(E)
+ Related: sort_aray(E), unique_array(E)
+
+29.10.2006 Zesstra
diff --git a/doc/efun/filter_indices b/doc/efun/filter_indices
new file mode 100644
index 0000000..54fdadf
--- /dev/null
+++ b/doc/efun/filter_indices
@@ -0,0 +1,115 @@
+filter_indices(E)
+
+FUNKTION:
+ mapping filter_indices(mapping map, string fun, string|object ob
+ [, mixed extra, ...])
+ mapping filter_indices(mapping map, closure cl [, mixed extra, ...])
+
+PARAMETER:
+ map - zu filterndes Mapping
+ fun/cl - zu rufende Methode/Closure
+ ob - Objekt/Dateiname, an dem Methode gerufen werden soll
+ extra - weitere Parameter fuer Methode/Closure
+
+BESCHREIBUNG:
+ Filtert die Elemente (jeweils Schluessel) aus 'map' durch die
+ Methode 'fun' oder die Closure 'cl' in ein neues Mapping.
+ Fuer jedes Element aus 'map' wird 'fun' oder 'cl' mit dem Schluessel als
+ erstem Parameter [und folgend den optionalen Extra-Parametern] gerufen.
+
+ Wenn der Aufruf
+ ob->fun(element [, extra1, extra2, ...]) bzw.
+ funcall(cl, element [, extra1, extra2, ...])
+ als Rueckgabewert !=0 zurueckgibt dann wird der Schluessel+Werte in das
+ neue Array aufgenommen, sonst nicht.
+
+ Wenn auf die Werte zugegriffen werden muss, kann das Mapping 'map'
+ zusaetzlich als 'extra'-Parameter uebergeben werden. Alternativ kann man
+ walk_mapping() benutzen und das Rueckgabemapping selbst erstellen.
+
+
+ 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:
+ Gefiltertes Mapping mit Filterbedingung erfuellenden Elementen.
+
+BEMERKUNGEN:
+ (1) Achtung, die Elemente in 'map' werden nicht tief kopiert, sind sie
+ also selbst Arrays oder Mappings, so fuehrt eine spaetere Aenderung im
+ Rueckgabe-Mapping zur Aenderung im Ursprungsmapping:
+
+ mapping m,n;
+ m=([1:({1,2}),0:({2,3,4})]);
+ n=filter_indicdes(m, #'!); // filtert alle Keys !=0 heraus
+ n[0][0]=8;
+
+ fuehrt zu: n=([0:({8,3,4})])
+ m=([0:({8,3,4}),1:({1,2})])
+
+ (2) Das Kopieren in das Rueckgabemapping erfolgt fuer jedes Element nach
+ Ausfuehrung der Filtermethode. Aenderungen der Werte im Mapping in dieser
+ Methode (globale Variable/Uebergabe als Referenz an filter_indices)
+ schlagen sich also im Rueckgabemapping nieder.
+
+BEISPIELE:
+ ### erfundene Liste mit Spielern saeubern ... ###
+ mapping x=([ [/human:liafar]: 20,
+ [/dwarf:mesirii]: 50,
+ [/elf:zarniya]: 40,
+ [/feline:turbo]: 30]);
+
+ int is_badguy(object who) {
+ if(who->InFight()) return 1;
+ return 0;
+ }
+
+ mapping result=filter_indices(x, #'is_badguy);
+ // 'result' enthaelt nur noch kaempfende Spieler
+
+ ### erfundene Liste ueber ihre Werte saeubern ###
+ int is_badguy(object who, mapping m) {
+ if(m[x]<30) return 1;
+ return 0;
+ }
+
+ mapping result=filter_indices(x, #'is_badguy, &x); // Referenz
+ // 'result' enthaelt nur Spieler mit Werten >= 30
+
+AeQUIVALENZCODE (nicht empfohlen, nur zum Verstaendnis!):
+ int i, width;
+ mapping ret; mapping input;
+ mixed *index;
+
+ width=get_type_info(input)[1];
+ ret=m_allocate(0, width);
+ index=m_indices(input);
+ i=sizeof(index);
+ while(i--)
+ if(ob->fun(index[i] [, extra1, extra2, ...]))
+ // if(funcall(cl, index[i] [, extra1, extra2, ...]))
+ {
+ int j;
+ j=width;
+
+ while(j--)
+ ret[index[i],j]=input[index[i],j];
+ }
+
+SIEHE AUCH:
+ Arrays: filter(E), map(E)
+ Objektarrays: filter_objects(E), map_objects(E)
+ Mappings: map_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/filter_objects b/doc/efun/filter_objects
new file mode 100644
index 0000000..9fb6922
--- /dev/null
+++ b/doc/efun/filter_objects
@@ -0,0 +1,59 @@
+filter_objects(E)
+
+FUNKTION:
+ object *filter_objects(mixed *arr, string fun, [, mixed extra, ...])
+
+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
diff --git a/doc/efun/find_call_out b/doc/efun/find_call_out
new file mode 100644
index 0000000..0e94337
--- /dev/null
+++ b/doc/efun/find_call_out
@@ -0,0 +1,41 @@
+FUNKTION:
+ int find_call_out(string func)
+ int find_call_out(closure 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.
+
+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);
+
+ // Alle call_out auf Funktion 'func' werden gefunden und gestoppt.
+ // (Beispielsweise weil ein Spieler den Raum verlaesst oder sich
+ // disconnectet).
+
+ while(find_call_out("func") > -1)
+ remove_call_out("func");
+
+ // Die Suche nach call_out()s auf Closures funktioniert nur, wenn der
+ // genaue Wert der Closure gesucht wird.
+
+ // Das funktioniert:
+ closure cl = symbol_function("main", obj);
+ call_out(cl, 2);
+ find_call_out(cl);
+
+ // Das funktioniert nicht:
+ call_out(symbol_function("main", obj), 2);
+ find_call_out(symbol_function("main", obj));
+
+SIEHE AUCH:
+ call_out(E), remove_call_out(E), call_out_info(E)
+
+4.Aug 2007 Gloinson
diff --git a/doc/efun/find_input_to b/doc/efun/find_input_to
new file mode 100644
index 0000000..cb299c0
--- /dev/null
+++ b/doc/efun/find_input_to
@@ -0,0 +1,26 @@
+SYNOPSIS
+ int find_input_to (object player, string fun);
+ int find_input_to (object player, closure fun);
+ int find_input_to (object player, object fun);
+ int find_input_to (object player, object ob, string fun);
+
+BESCHREIBUNG
+ Findet den zuletzt fuer <player> gestarteten input_to(), abhaengig vom
+ Argument <fun>:
+ - <fun> ist ein String: der Funktionsname des input_to() muss passen
+ - <fun> ist ein Objekt: das Objekt, an welches die Funktion des
+ input_to() gebunden ist, muss passen
+ - <fun> ist eine Closure: die input_to() Closure muss passen
+ - <ob> und <fun> sind angegeben: sowohl Objekt als auch
+ Funktionsname muessen passen.
+
+ Die Funktion liefert -1, wenn kein input_to() gefunden wurde, sonst
+ die Position im input_to() Stack (wobei 0 den als letztes
+ hinzugefuegten input_to() bezeichnet).
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9
+
+SIEHE AUCH
+ input_to(E), input_to_info(E), remove_input_to(E),
+ query_input_pending(E)
diff --git a/doc/efun/find_object b/doc/efun/find_object
new file mode 100644
index 0000000..2a4f0d0
--- /dev/null
+++ b/doc/efun/find_object
@@ -0,0 +1,23 @@
+SYNOPSIS:
+ object find_object(string str)
+
+DESCRIPTION:
+ Find an object with the object_name str. If the object isn't loaded,
+ it will not be found.
+
+EXAMPLE:
+ object obj;
+ obj = find_object("std/thing");
+ obj = find_object("std/thing.c");
+ obj = find_object("/std/thing");
+ obj = find_object("/std/thing.c");
+
+ All four statements are equal.
+
+ obj = find_object("/std/thing#42");
+
+ returns the clone whose object_name is "std/thing#42", if
+ it exists.
+
+SEE ALSO:
+ find_living(E), find_player(E), object_name(E)
diff --git a/doc/efun/first_inventory b/doc/efun/first_inventory
new file mode 100644
index 0000000..99be7fd
--- /dev/null
+++ b/doc/efun/first_inventory
@@ -0,0 +1,34 @@
+SYNOPSIS
+ object first_inventory();
+ object first_inventory(string ob);
+ object first_inventory(object ob);
+
+BESCHREIBUNG
+ Liefert das erste Objekt im Inventory von <obj>, wobei <obj> entweder
+ ein Objekt oder der Name eines Objekts ist. Wenn <obj> nicht angegeben
+ wird, wird standardmaessig this_object() verwendet.
+
+BEISPIELE
+ Diese Efun verwendet man am haeufigsten im folgenden Kontext:
+
+ for(obj=first_inventory(container);obj;obj=next_inventory(obj))
+ {
+ <irgendwelcher Code>
+ }
+
+ ACHTUNG: Wenn das Objekt <obj> innerhalb von <irgendwelcher Code>
+ bewegt wird, liefert next_inventory() ein Objekt aus dem neuen
+ Inventory von <obj>. Auch sollte next_inventory() nicht fuer
+ zerstoerte Objekte <obj> aufgerufen werden. Fuer den Fall, dass
+ <obj> bewegt und/oder zerstoert wird, ist folgende Loesung
+ vorzuziehen:
+
+ for(obj=first_inventory(container);obj;)
+ {
+ next=next_inventory(obj);
+ <irgendwelcher Code mit Moves oder Removes>
+ obj=next;
+ }
+
+SIEHE AUCH
+ next_inventory(E), all_inventory(E), environment(E), deep_inventory(E)
diff --git a/doc/efun/floatp b/doc/efun/floatp
new file mode 100644
index 0000000..109cace
--- /dev/null
+++ b/doc/efun/floatp
@@ -0,0 +1,10 @@
+SYNOPSIS
+ int floatp(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument eine Fliesskommazahl (float) ist,
+ ansonsten 0.
+
+SIEHE AUCH
+ intp(E), mappingp(E), stringp(E), closurep(E), objectp(E),
+ referencep(E), pointerp(E), symbolp(E), clonep(E)
diff --git a/doc/efun/floor b/doc/efun/floor
new file mode 100644
index 0000000..e7b85e6
--- /dev/null
+++ b/doc/efun/floor
@@ -0,0 +1,19 @@
+SYNOPSIS
+ float floor(float arg);
+
+BESCHREIBUNG
+ Rundet das Argument <arg> ab auf die naechste ganze Zahl und gibt
+ diesen Wert zurueck. Wenn <arg> ein Integer ist, wird das Resultat
+ trotzdem als Float zurueckgegeben.
+
+BEISPIELE
+ floor(4.5) --> liefert 4.0
+ floor(-4.5) --> liefert -5.0
+ floor(5) --> liefert 5.0
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+ LDMud 3.2.9 erlaubt auch Integer als Argumente.
+
+SIEHE AUCH
+ abs(E), ceil(E)
diff --git a/doc/efun/funcall b/doc/efun/funcall
new file mode 100644
index 0000000..6bb9833
--- /dev/null
+++ b/doc/efun/funcall
@@ -0,0 +1,10 @@
+SYNOPSIS
+ mixed funcall(closure cl, mixed arg, ...);
+
+BESCHREIBUNG
+ Wertet die Closure 'cl' aus. Die Argumente 'args' werden als Argumente
+ an die Closure uebergeben. Wenn 'cl' keine Closure ist, wird 'cl'
+ zurueck gegeben.
+
+SIEHE AUCH
+ apply(E), quote(E)
diff --git a/doc/efun/function_exists b/doc/efun/function_exists
new file mode 100644
index 0000000..43f2da2
--- /dev/null
+++ b/doc/efun/function_exists
@@ -0,0 +1,14 @@
+SYNOPSIS
+ string function_exists(string str, object ob)
+
+DESCRIPTION
+ Return the file name of the object that defines the function
+ str in object ob. The returned value can be other than
+ object_name(ob) if the function is defined in an inherited
+ object. In !compat mode, the returned name always begins with a
+ '/' (absolute path). 0 is returned if the function was not
+ defined, or was defined as static (protected function on the
+ other hand are found).
+
+SEE ALSO
+ call_other(E), call_resolved(E), functionlist(E)
diff --git a/doc/efun/functionlist b/doc/efun/functionlist
new file mode 100644
index 0000000..46f2cba
--- /dev/null
+++ b/doc/efun/functionlist
@@ -0,0 +1,55 @@
+GESCHUETZT
+SYNOPSIS
+ #include <sys/functionlist.h>
+ #include <sys/lpctypes.h>
+
+ mixed *functionlist(object ob, int flags = RETURN_FUNCTION_NAME)
+
+BESCHREIBUNG
+ Liefert ein Array mit Informationen zu den Lfuns von <ob>. Fuer jede
+ Funktion werden 1 bis 4 Werte (abhaengig von <flags>) in das Ergebnis
+ eingetragen, und zwar in folgender Reihenfolge:
+ - der Name der Funktion
+ - die Flags der Funktion (vergleiche weiter unten)
+ - den Rueckgabetyp (aufgelistet in mudlib/sys/lpctypes.h)
+ - die Anzahl Argumente, die die Funktion akzeptiert.
+
+ <ob> kann als echtes Objekt oder als Objektname uebergeben werden. Im
+ zweiten Fall versucht die Efun nicht, das Objekt vorher zu laden.
+
+ <flags> bestimmt sowohl, welche Informationen im Ergebnis gesammelt
+ werden, als auch, fuer welche Funktionen die Pruefung durchgefuehrt
+ wird. Der Wert von <flags> wird durch binaere Veroderung folgender
+ Konstanten aus mudlib/sys/functionlist.h festgelegt:
+
+ Festlegen der gesammelten Information:
+ RETURN_FUNCTION_NAME liefert den Funktionsnamen
+ RETURN_FUNCTION_FLAGS liefert die Flas der Funktion
+ RETURN_FUNCTION_TYPE liefert den Rueckgabetyp der Funktion
+ RETURN_FUNCTION_NUMARG liefert die Anzahl moeglicher
+ Argumente.
+
+ RETURN_FUNCTION_ARGTYPE ist definiert, aber nicht
+ implementiert.
+
+ Festlegen der geprueften Funktionen:
+ NAME_INHERITED geerbte Funktionen nicht beachten
+ TYPE_MOD_STATIC static deklarierte Funktion nicht beachten
+ TYPE_MOD_PRIVATE private deklarierte Funktionen nicht beachten
+ TYPE_MOD_PROTECTED protected deklarierte Funktionen nicht
+ beachten
+ NAME_HIDDEN nur beachten, wenn sichtbar durch Vererbung
+
+ <flags> besteht aus der binaeren Veroderung der oben genannten Flags,
+ zusammen mit den folgenden:
+ TYPE_MOD_VARARGS die Funktion ist varargs deklariert
+ NAME_UNDEFINED die Funktion ist noch nicht definiert, aber
+ referenziert
+ NAME_CROSS_DEFINED die Funktion ist definiert, um in einem
+ anderen Programm verwendet zu werden
+ TYPE_MOD_NOMASK die Funktion ist nomask deklariert
+ TYPE_MOD_PUBLIC die Funktion ist public deklariert
+
+SIEHE AUCH
+ inherit_list(E), function_exists(E), variable_list(E),
+ call_resolved(E)
diff --git a/doc/efun/garbage_collection b/doc/efun/garbage_collection
new file mode 100644
index 0000000..5c6a738
--- /dev/null
+++ b/doc/efun/garbage_collection
@@ -0,0 +1,22 @@
+GESCHUETZT
+SYNOPSIS
+ void garbage_collection();
+ void garbage_collection(string filename);
+
+BESCHREIBUNG
+ Befiehlt dem Treiber, nach Ende der aktuellen Ausfuehrung eine
+ Garbage Collection zu beginnen. Je nachdem, welcher Memory Allocator
+ verwendet wird, ist die Garbage Collection mehr oder weniger
+ gruendlich.
+
+ Wird der smalloc Memory Allocator verwendet, erzeugt GC einen Output
+ in einem Logfile. Der Standardname fuer das Logfile wird beim
+ Programmstart festgelegt, kann aber zur Laufzeit veraendert werden,
+ wenn das Argument <filename> angegeben ist. Der Log-Output wird in
+ diesem Fall an das bezeichnete Logfile angefuegt.
+
+ Fuer andere Memory Allocators erzeugt garbage_collection() keinen
+ Output. Ein allfaelliges Argument <filename> wird ignoriert.
+
+SIEHE AUCH
+ rusage(E), valid_write(M)
diff --git a/doc/efun/get_dir b/doc/efun/get_dir
new file mode 100644
index 0000000..b14288a
--- /dev/null
+++ b/doc/efun/get_dir
@@ -0,0 +1,113 @@
+SYNOPSIS
+ #include <files.h>
+
+ mixed *get_dir(string str)
+ mixed *get_dir(string str, int mask)
+
+BESCHREIBUNG
+ Benoetigt einen Pfad als erstes Argument und liefert ein Feld
+ (Array) mit Dateinamen bzw. Eigenschaften der gefundenen Dateien im
+ angegebenen Verzeichnis.
+
+ Liefert 0 zurueck, wenn es das Verzeichnis, in dem gesucht werden
+ soll, nicht gibt.
+
+ Der Dateinamen-Teil des Pfades darf "*" und "?" als Platzhalter
+ enthalten: jeder "*" steht fuer eine beliebige Anzahl Zeichen (oder
+ sich selber), "?" fuer ein beliebiges Zeichen. Entsprechend liefert
+ get_dir("/pfad/*") ein alphabetisch sortiertes Feld aller Dateien
+ im Verzeichnis "/pfad" oder ({ "/pfad/*" }), wenn es diese Datei
+ geben sollte.
+
+ Gibt man den Pfad eines Verzeichnisses mit abschliessendem "/" oder
+ "/." an (z. B. get_dir("/pfad/.")), so erhaelt man den Inhalt des
+ Verzeichnisses. Um Informationen ueber das Verzeichnis selber zu
+ erhalten, muss man den Pfad des Verzeichnisses angeben.
+
+ Das optionale zweite Argument ist eine Bitmaske, mit der man
+ angeben kann, welche Informationen man ueber die angegebenen
+ Dateien erhalten moechte.
+
+ GETDIR_EMPTY (0x00) get_dir() liefert ein leeres Feld (nicht
+ wirklich sinnvoll)
+ GETDIR_NAMES (0x01) liefert die alphabetisch sortierten
+ Dateinamen.
+ GETDIR_SIZES (0x02) liefert die unsortierten Dateigroessen
+ (file_size()), Verzeichnisse haben die
+ Dateigroesse FSIZE_DIR (-2).
+ GETDIR_DATES (0x04) liefert die unsortierten Zeiten der jeweils
+ letzten Aenderung in Sekunden seit dem
+ 01.01.1970.
+ GETDIR_ACCESS (0x40) liefert die unsortierten Zeiten des jeweils
+ letzten Zugriffes in Sekunden seit dem
+ 01.01.1970.
+ GETDIR_MODES (0x80) liefert die Filemode-Maske
+
+ GETDIR_ALL (0xDF) Liefert all Werte zurueck.
+
+ GETDIR_PATH (0x10) Dateinamen werden als volle Pfade geliefert.
+ (ein ev. fehlendes GETDIR_NAMES wird als
+ vorhanden angenommen).
+ GETDIR_UNSORTED (0x20) Das Ergebnis wird nicht sortiert.
+
+ Wichtig: Man muss GETDIR_NAMES|GETDIR_UNSORTED verwenden, wenn man
+ die Eintraege in der selben Reihenfolge wie bei GETDIR_SIZES und
+ GETDIR_DATES haben moechte.
+
+ Die Eintraege in der Bitmaske koennen miteinander kombiniert
+ werden.
+
+BEISPIELE
+ Funktion Rueckgabewert
+ -------------------------------------------------------------------
+ get_dir("/obj/.") Alle Dateien, die im Verzeichnis
+ /obj enthalten sind.
+ get_dir("/obj/") Wie get_dir("/obj/").
+
+ get_dir("/obj/fackel.c") ({ "fackel.c" }), sofern
+ /obj/fackel.c existiert (als
+ Datei oder Verzeichnis), ansonsten
+ ({}), sofern /obj ein Verzeichnis
+ ist, ansonsten 0.
+
+ get_dir("/obj/*") ({ "*" }), sofern * existiert.
+ Ansonsten und normalerweise ein
+ alphabetisch sortiertes Feld mit
+ den Namen aller Dateien und
+ Verzeichnisse in /obj, sofern /obj
+ ein Verzeichnis ist, ansonsten 0.
+
+ get_dir("/obj/fackel.c", GETDIR_SIZES)
+ ({ <Groesse von /obj/fackel.c> }),
+ sofern /obj/fackel.c existiert.
+ get_dir("/obj/.", GETDIR_NAMES) Wie get_dir("/obj/.").
+ get_dir("/obj/.", GETDIR_SIZES) Ein unsortiertes Feld mit den
+ Groessen der Dateien in /obj.
+ get_dir("/obj/.", GETDIR_NAMES|GETDIR_SIZES|GETDIR_DATES)
+ oder kuerzer
+ get_dir("/obj/.", GETDIR_ALL) Ein eindimensionales und nach
+ Namen sortiertes Feld, das fuer
+ jede Datei in /obj den Namen, die
+ Groesse und den Zeitpunkt der
+ letzten Aenderung enthaelt, z.B.
+ ({
+ "axt.c" , 927, 994539583,
+ "fackel.c", 1283, 998153903,
+ }).
+
+ get_dir("/obj/fackel.c", GETDIR_NAMES|GETDIR_PATH)
+ ({ "/obj/fackel.c" }), sofern
+ vorhanden.
+ get_dir("/obj/fackel.c", GETDIR_PATH) Kurzform dafuer.
+
+ transpose_array(({ get_dir(str, GETDIR_NAMES|GETDIR_UNSORTED)
+ , get_dir(str, GETDIR_SIZES)
+ , get_dir(str, GETDIR_DATES) }));
+ Liefert ein unsortiertes Feld mit Feldern, von denen ein jedes
+ Name, Groesse und Zeit einer Datei enthaelt, z. B.
+ ({
+ ({ "fackel.c", 1283, 998153903 }),
+ ({ "axt.c" , 927, 994539583 }),
+ }).
+SIEHE AUCH
+ cat(E), mkdir(E), rmdir(E), file_size(E)
diff --git a/doc/efun/get_error_file b/doc/efun/get_error_file
new file mode 100644
index 0000000..797e523
--- /dev/null
+++ b/doc/efun/get_error_file
@@ -0,0 +1,21 @@
+SYNOPSIS
+ mixed * get_error_file(string name, int set_forget_flag)
+
+DESCRIPTION
+ Return information about the last error which occured for
+ <name> (where <name> is a valid name from the wiz list).
+
+ Result is an array of four elements: the filename of the
+ program where the error occured, the linenumber in the
+ program, the error message (runtime error messages usually
+ start with a '*'), and a numerical flag (the 'forget flag') if
+ the error information has been queried already.
+
+ If there is no error stored for the given <name>, 0 is
+ returned.
+
+ If <set_forget_flag> is non-zero, the 'forget' flag is set
+ for the error message after it has been returned.
+
+SEE ALSO
+ ed(E), valid_read(M)
diff --git a/doc/efun/get_eval_cost b/doc/efun/get_eval_cost
new file mode 100644
index 0000000..50bc012
--- /dev/null
+++ b/doc/efun/get_eval_cost
@@ -0,0 +1,33 @@
+FUNKTION:
+ int get_eval_cost(void)
+
+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);
+ }
+
+SIEHE AUCH:
+ caller_stack_depth(E), rusage(E), command(E), query_limits(E)
+ Konstante: __MAX_EVAL_COST__
+
+4.Aug 2007 Gloinson
diff --git a/doc/efun/get_extra_wizinfo b/doc/efun/get_extra_wizinfo
new file mode 100644
index 0000000..c356fba
--- /dev/null
+++ b/doc/efun/get_extra_wizinfo
@@ -0,0 +1,19 @@
+SYNOPSIS
+ mixed get_extra_wizinfo (object wiz)
+ mixed get_extra_wizinfo (string wiz)
+ mixed get_extra_wizinfo (int wiz)
+
+DESCRIPTION
+ Returns the 'extra' information that was set for the given
+ wizard <wiz> in the wizlist.
+
+ If <wiz> is an object, the entry of its creator (uid) is used.
+ If <wiz> is a string (a creator aka uid), it names the entry
+ to use.
+ If <wiz> is the number 0, the data is get from the default wizlist
+ entry.
+
+ The function causes a privilege violation.
+
+SEE ALSO
+ wizlist_info(E), set_extra_wizinfo(E)
diff --git a/doc/efun/get_type_info b/doc/efun/get_type_info
new file mode 100644
index 0000000..81b1f8b
--- /dev/null
+++ b/doc/efun/get_type_info
@@ -0,0 +1,57 @@
+SYNOPSIS
+ mixed get_type_info(mixed arg, int flag);
+
+BESCHREIBUNG
+ Liefert Informationen uber den Typ von <arg>, wie von <flag>
+ angegeben.
+
+ Wenn <flag> keine Zahl ist, liefert get_type_info() ein Array, dessen
+ erstes Element ein Integer ist, der den Datentyp bezeichnet, wie in
+ <lpctypes.h> definiert. Der zweite Eintrag kann zusaetzliche
+ Informationen zu <arg> enthalten.
+
+ Ist <flag> 0, wird nur das erste Element (d.h. der Datentyp) geliefert.
+ Ist <flag> 1, wird nur das zweite Element geliefert.
+
+ Wenn <arg> eine Closure enthaelt, so kann get_type_info() das Objekt
+ der Closure liefern, wenn fuer <flag> 2 gesetzt ist. (Fuer 'alien
+ lfun closures' ist das das Objekt, in dem die Closure definiert ist,
+ nicht das Objekt, an das die Closure gebunden ist.)
+
+ Wenn <arg> eine LFun/Context-Closure enthaelt, so kann get_type_info()
+ den Namen des definierenden Programmes liefern, wenn fuer <flag> 3
+ gesetzt ist. Fur andere Closures wird 0 zurueckgegeben.
+
+ Wenn <arg> eine LFun/Context-Closure enthaelt, so kann get_type_info()
+ den Namen der Funktion liefern, wenn fuer <flag> 4
+ gesetzt ist. Fur andere Closures wird 0 zurueckgegeben.
+
+ Fuer jeden anderen Wert fuer <flag> liefert die Funktion -1.
+
+ Die zusaetzlichen Informationen (also der zweite Eintrag des Arrays)
+ beinhalten:
+ - fuer Mappings deren Breite, also die Anzahl Datenwerte pro Key.
+ - fuer Symbole und gequotete Arrays die Anzahl Quotes.
+ - fuer Closures den (internen) Typ der Closure.
+ - fuer gemeinsam verwendete Strings 0, ungleich 0 fuer andere Strings
+ - fuer structs der eindeutige Identifizierungsstring
+ - -1 fuer alle anderen Datentypen
+
+BUGS
+ Diese Funktion unterliegt haeufigen Veraenderungen im Zug der
+ Treiberentwicklung.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2@127
+ Flagwert 2 eingefuehrt in 3.2.1@84
+ Zusatzinformationen zu Strings eingefuehrt in 3.2.7
+ Bis und mit 3.2.7 lieferte get_type_info(closure, 2) keine Objekte
+ von Lamda Closures und gebundenen Lambda Closures.
+ Bis und mit 3.2.7 lieferte get_type_info(closure, 2) keine Objekte von
+ Efun-, Simul-Efun- oder Operator-Closures.
+ LDMud 3.3.276 fuegte die zusaetzliche Information fuer structs hinzu.
+ LDMud 3.3.548 fuegte Flagwert '3' hinzu.
+ LDMud 3.3.708 fuegte Flagwert '4' hinzu.
+
+SIEHE AUCH
+ debug_info(E), typeof(E), to_object(E)
diff --git a/doc/efun/geteuid b/doc/efun/geteuid
new file mode 100644
index 0000000..75cc3d1
--- /dev/null
+++ b/doc/efun/geteuid
@@ -0,0 +1,12 @@
+SYNOPSIS
+ string geteuid(object ob);
+
+BESCHREIBUNG
+ Liefert die effektive User-ID des Objekts <obj> (normalerweise ein
+ Magier oder eine Domain). Objekte, die durch <obj> geclonet werden,
+ erhalten diese User-ID. Die effektive User-ID wird auch fuer
+ Zugriffschecks verwendet. Wenn <obj> nicht angegeben wird, wird
+ standardmaessig this_object() verwendet.
+
+SIEHE AUCH
+ seteuid(E), getuid(E), getuuid(E), export_uid(E)
\ No newline at end of file
diff --git a/doc/efun/getuid b/doc/efun/getuid
new file mode 100644
index 0000000..bf38fe8
--- /dev/null
+++ b/doc/efun/getuid
@@ -0,0 +1,17 @@
+SYNOPSIS
+ string getuid(object ob);
+
+BESCHREIBUNG
+ User-IDs werden im Compat Modus nicht verwendet.
+
+ Die Funktion liefert die UID des Objekts, also den Namen des Magiers
+ oder der Domain oder Gruppe, die fuer das Objekt verantwortlich ist.
+ Der Name entspricht dem Namen, der in der Wizlist verwendet wird.
+ Wird <ob> nicht angegeben, wird standardmaessig this_object()
+ genommen.
+
+AENDERUNGEN
+ Seit 3.2.1@47 ist diese Efun ein Alias fuer creator()
+
+SIEHE AUCH
+ seteuid(E), geteuid(E), export_uid(E), creator(E), getuuid(E)
diff --git a/doc/efun/gmtime b/doc/efun/gmtime
new file mode 100644
index 0000000..ab12eff
--- /dev/null
+++ b/doc/efun/gmtime
@@ -0,0 +1,38 @@
+SYNOPSIS
+ #include <sys/time.h>
+
+ int *gmtime(int clock);
+ int *gmtime(int *uclock);
+
+BESCHREIBUNG
+ Interpretiert <clock> als Anzahl Sekunden seit dem 01. Januar 1970,
+ 00:00:00 Uhr und gibt die Zeit in UTC in einer schoenen Struktur
+ aus. Wird <clock> nicht angegeben, wird stattdessen time() verwendet.
+
+ Alternativ kann auch ein Array mit zwei Elementen angegeben werden,
+ wie es von uclock() geliefert wird: das erste Element wird
+ interpretiert wie <clock>, das zweite Element bezeichnet die
+ Mikrosekunden in der aktuellen Sekunde. Dieses zweite Element wird
+ ignoriert.
+
+ Das Resultat von gmtime() ist ein Array, das folgende Werte beinhaltet:
+ int TM_SEC (0) : Sekunden (0..59)
+ int TM_MIN (1) : Minuten (0..59)
+ int TM_HOUR (2) : Stunden (0..23)
+ int TM_MDAY (3) : Tag im Monat (1..31)
+ int TM_MON (4) : Monat im Jahr (0..11)
+ int TM_YEAR (5) : Jahr (z.B. 2001)
+ int TM_WDAY (6) : Wochentag (Sunday = 0)
+ int TM_YDAY (7) : Tag im Jahr (0..365)
+ int TM_ISDST (8) : TRUE: Daylight saving time
+
+BEISPIEL
+ printf("Heute ist %s\n", ({ "Sonntag", "Montag", "Dienstag",
+ "Mittwoch", "Donnerstag", "Freitag", "Samstag"})
+ [gmtime()[TM_WDAY]]);
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ ctime(E), localtime(E), time(E), utime(E)
diff --git a/doc/efun/hash b/doc/efun/hash
new file mode 100644
index 0000000..e3457c1
--- /dev/null
+++ b/doc/efun/hash
@@ -0,0 +1,36 @@
+SYNOPSIS
+ #include <sys/tls.h>
+
+ string hash(int method, string arg [, int iterations ] )
+ string hash(int method, int * arg [, int iterations ] )
+
+BESCHREIBUNG
+ Berechne den Hash <method> vom Argument <arg>. Der Hash wird
+ mit <iterations> Wiederholungen berechnet, wird der Wert weggelassen,
+ wird eine Wiederholung verwendet.
+
+ <method> ist eine der TLS_HASH_-Konstanten in tls.h; nicht jede
+ beschriebene Methode ist in einem gegebenen Driver vorhanden:
+
+ TLS_HASH_SHA1 (1)
+ TLS_HASH_SHA224 (2)
+ TLS_HASH_SHA256 (3)
+ TLS_HASH_SHA384 (4)
+ TLS_HASH_SHA512 (5)
+ TLS_HASH_MD5 (6)
+ TLS_HASH_RIPEMD160 (7)
+
+ Diese Funktion ist nur verfuegbar wenn der Driver mit OpenSSL
+ compiliert wurde.
+
+BEISPIELE
+ string s;
+
+ s = hash(TLS_HASH_SHA1, "Hello", 2);
+ s = hash(TLS_HASH_SHA1, ({ 'H', 'e', 'l', 'l', 'o' }) )
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.714
+
+SIEHE AUCH
+ crypt(E), md5(E), md5_crypt(E), sha1(E), hmac(E)
diff --git a/doc/efun/heart_beat_info b/doc/efun/heart_beat_info
new file mode 100644
index 0000000..dee8d52
--- /dev/null
+++ b/doc/efun/heart_beat_info
@@ -0,0 +1,9 @@
+SYNOPSIS
+ object *heart_beat_info()
+
+BESCHREIBUNG
+ Resultat ist ein Array mit allen Objekten, die einen aktiven
+ heart_beat() haben.
+
+SIEHE AUCH
+ set_heart_beat(E), heart_beat(A), call_out_info(E)
diff --git a/doc/efun/hmac b/doc/efun/hmac
new file mode 100644
index 0000000..d41d6d5
--- /dev/null
+++ b/doc/efun/hmac
@@ -0,0 +1,35 @@
+SYNOPSIS
+ #include <sys/tls.h>
+
+ string hmac(int method, string key, string arg )
+ string hmac(int method, string key, int * arg )
+
+BESCHREIBUNG
+ Berechnet den Hashed Message Authenication Code fuer <arg>
+ nach Methode <method> und fuer das Password <key>.
+
+ <method> ist eine der TLS_HASH_-Konstanten in tls.h; nicht jede
+ beschriebene Methode ist in einem gegebenen Driver vorhanden:
+
+ TLS_HASH_SHA1 (1)
+ TLS_HASH_SHA224 (2)
+ TLS_HASH_SHA256 (3)
+ TLS_HASH_SHA384 (4)
+ TLS_HASH_SHA512 (5)
+ TLS_HASH_MD5 (6)
+ TLS_HASH_RIPEMD160 (7)
+
+ Diese Funktion ist nur verfuegbar wenn der Driver mit OpenSSL
+ compiliert wurde.
+
+BEISPIELE
+ string s;
+
+ s = hmac(TLS_HASH_SHA1, "secret", "Hello");
+ s = hmac(TLS_HASH_SHA1, "secret", ({ 'H', 'e', 'l', 'l', 'o' }) )
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.714
+
+SIEHE AUCH
+ crypt(E), md5(E), md5_crypt(E), sha1(E), hmac(E)
diff --git a/doc/efun/idna_stringprep b/doc/efun/idna_stringprep
new file mode 100644
index 0000000..7001140
--- /dev/null
+++ b/doc/efun/idna_stringprep
@@ -0,0 +1,22 @@
+OPTIONAL
+SYNOPSIS
+ #include <sys/idn.h>
+
+ string idna_stringprep (string str, int profile, int flags = 0)
+
+BESCHREIBUNG
+ Prepariere den UTF-8 String <str> passend zum Profil <profile>
+ (siehe auch libidn stringprep(3)).
+
+ <profile> und <flags> sind definiert in idn.h .
+
+ Sollte ein Fehler auftreten, wird eine Exception geworfen.
+
+ Diese Efun is nur verfuegbar auf Systemen mit libidn
+ installiert - in diesem Fall ist das Makro __IDNA__ definiert.
+
+GESCHICHTE
+ Introduced in LDMud 3.3.713.
+
+SIEHE AUCH
+ convert_charset(E), idna_to_ascii(E), idna_to_unicode(E)
diff --git a/doc/efun/idna_to_ascii b/doc/efun/idna_to_ascii
new file mode 100644
index 0000000..63c66b9
--- /dev/null
+++ b/doc/efun/idna_to_ascii
@@ -0,0 +1,20 @@
+OPTIONAL
+SYNOPSIS
+ #include <sys/idn.h>
+
+ string idna_to_ascii (string name)
+
+BESCHREIBUNG
+ Wandle den String <name> von UTF-8 to IDNA Darstellung (8z
+ punycode).
+
+ Sollte ein Fehler auftreten, wird eine Exception geworfen.
+
+ Diese Efun is nur verfuegbar auf Systemen mit libidn
+ installiert - in diesem Fall ist das Makro __IDNA__ definiert.
+
+GESCHICHTE
+ Introduced in LDMud 3.3.713.
+
+SIEHE AUCH
+ convert_charset(E), idna_to_unicode(E), idna_stringprep(E)
diff --git a/doc/efun/idna_to_unicode b/doc/efun/idna_to_unicode
new file mode 100644
index 0000000..183dce8
--- /dev/null
+++ b/doc/efun/idna_to_unicode
@@ -0,0 +1,20 @@
+OPTIONAL
+SYNOPSIS
+ #include <sys/idn.h>
+
+ string idna_to_unicode (string name)
+
+BESCHREIBUNG
+ Wandle den String <name> von IDNA Darstellung (8z punycode)
+ nach UTF-8.
+
+ Sollte ein Fehler auftreten, wird eine Exception geworfen.
+
+ Diese Efun is nur verfuegbar auf Systemen mit libidn
+ installiert - in diesem Fall ist das Makro __IDNA__ definiert.
+
+GESCHICHTE
+ Introduced in LDMud 3.3.713.
+
+SIEHE AUCH
+ convert_charset(E), idna_to_ascii(E), idna_stringprep(E)
diff --git a/doc/efun/implode b/doc/efun/implode
new file mode 100644
index 0000000..85a723b
--- /dev/null
+++ b/doc/efun/implode
@@ -0,0 +1,25 @@
+SYNOPSIS
+ string implode(mixed *arr, string del)
+
+BESCHREIBUNG
+ Setzt alle Zeichenketten (Strings) aus dem Feld (Array) arr zu
+ einer Zeichenkette zusammen und fuegt dabei die Zeichenkette del
+ zwischen je zwei Elementen ein. Elemente aus dem Feld arr, welche
+ keine Zeichenketten sind, werden ignoriert.
+
+BEISPIELE
+ Funktion Rueckgabewert
+ -------------------------------------------------------------------
+ implode(({ "foo", "bar", "" }), "*") "foo*bar*"
+ implode(({ "a", 2, this_object(), "c" }), "b") "abc"
+
+ Kann zusammen mit explode() als Funktion zum Ersetzen von
+ Zeichenketten verwendet werden:
+ implode(explode("a short text", " "), "_") "a_short_text"
+
+ Heutzutage kann man stattdessen auch
+ regreplace("a short text", " ", "_", 1)
+ verwenden.
+
+SIEHE AUCH
+ explode(E)
diff --git a/doc/efun/include_list b/doc/efun/include_list
new file mode 100644
index 0000000..cc44fa9
--- /dev/null
+++ b/doc/efun/include_list
@@ -0,0 +1,80 @@
+SYNOPSIS
+ #include <sys/include_list.h>
+
+ string *include_list();
+ string *include_list(object ob);
+ string *include_list(object ob, int flags);
+
+BESCHREIBUNG
+ Diese Funktion liefert Informationen ueber alle Dateien, die bei der
+ Kompilierung von <ob> in dieses Objekt eingebunden wurden, inklusive
+ den Programmnamen von <ob>. Wird <ob> nicht angegeben, wird
+ standardmaessig das aktuelle Objekt verwendet.
+
+ Im resultierenden Array besteht die Information zu einem Includefile
+ aus drei Elementen:
+ - string [i+0]: der Name des Includefiles, wie er im Programm
+ auftaucht, inklusive den Trennzeichen wie " " oder
+ < >.
+ - string [i+1]: der absolute Dateipfad des Includefiles.
+ - int [i+2]: die Tiefe der Inklusion (gewoehnlich 1, fuer
+ verschachtelte Includes auch groesser als 1)
+
+ Der erste Eintrag im Resultat ist der Name des Programmes selbst in
+ [i+0], die anderen beiden Elemente [i+1] und [i+2] sind 0.
+
+ <flag> bezeichnet die Struktur des Ergebnisses:
+ - <flag> = INCLIST_FLAT (0, Standard):
+ Das Resultat ist ein flaches Array. Der erste Eintrag bezeichnet
+ <ob> selbst, die restlichen Eintraege bezeichnen alle Includefiles
+ in der Reihenfolge, in der sie auftreten.
+ - <flag> = INCLIST_TREE (1):
+ Das Resultat ist ein Array, dessen erster Eintrag das Objekt <ob>
+ selbst bezeichnet. Alle folgenden Eintraege bezeichnen die
+ Includefiles von <ob>. Wenn ein Includefile von <ob> selbst keine
+ Includefiles hat, wird seine Information direkt im Array
+ gespeichert. Fuer verschachtelte Includefiles wird ein Untervektor
+ erzeugt und dann in diesem Untervektor abgespeichert (wiederum
+ in [i+0], [i+1] und [i+2] sind 0). Diese Untervektoren haben
+ die gleiche Struktur wie das Resultatarray.
+
+ Wenn ein Objekt, inklusive <ob>, einem replace_programm() unterworfen
+ war, spiegeln die gelieferten Dateinamen das effektiv aktive Programm
+ wider.
+
+ Die Includepfade, die geliefert werden, beginnen immer mit '/'
+ (absolute Pfade), auch wenn der Treiber im COMPAT Modus laeuft.
+ Trotzdem beginnt der tatsaechliche Dateiname nicht mit einem '/',
+ wenn der Treiber im COMPAT Modus laeuft.
+
+BEISPIEL
+ Dieser Code erzeugt (mit /sys als Includeverzeichnis des Systems):
+
+ a.c: #include "b.h"
+ #include <c.h>
+ b.h: #include "d.h"
+ c.h: #define BAR
+ d.h: #define FOO
+
+ Die Efun liefert drei Resultate:
+
+ include_list(a, INCLIST_FLAT)
+ -> ({ "a.c", 0, 0
+ , "\"b.h\"", "/.../b.h", 1
+ , "\"d.h\"", "/.../d.h", 2
+ , "<c.h>", "/sys/c.h", 1
+ })
+
+ include_list(a, INCLIST_TREE)
+ -> ({ "a.c", 0, 0
+ , ({ "\"b.h\"", "/.../b.h", 1
+ , "\"d.h\"", "/.../d.h", 2
+ }), 0, 0
+ , "<c.h>", "/sys/c.h", 1
+ })
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9, 3.3.128
+
+SIEHE AUCH
+ debug_info(E), inherit_list(E)
diff --git a/doc/efun/inherit_list b/doc/efun/inherit_list
new file mode 100644
index 0000000..97c738e
--- /dev/null
+++ b/doc/efun/inherit_list
@@ -0,0 +1,60 @@
+SYNOPSIS
+ #include <sys/inherit_list.h>
+
+ string *inherit_list();
+ string *inherit_list(object ob);
+ string *inherit_list(object ob, int flags);
+
+BESCHREIBUNG
+ Liefert die Namen von allen Dateien, die von <ob> geerbt werden,
+ inklusive <ob>s eigener Dateiname. Wird <ob> nicht angegeben, wird
+ standarndmaessig das aktuelle Objekt verwendet.
+
+ Der Wert von <flags> bestimmt die Struktur des Rueckgabewertes:
+ - <flag> = INHLIST_FLAT (0, default):
+ inherit_list() liefert ein Array von Dateinamen, beginnend mit dem
+ Namen von <ob> selbst, gefolgt von den Namen aller geerbten
+ Objekten.
+ - <flag> = INHLIST_TREE (1):
+ inherit_list() liefert ein Array von Dateinamen, beginnend mit dem
+ Namen von <ob> selbst. Wenn ein geerbte File selbst keine Files
+ erbt, wird sein Name direkt in das Ergebnis eingetragen. Wenn ein
+ geerbtes File selbst Files erbt, wird ein Untervektor erzeugt, in
+ dem die Inherits eingetragen werden. Der Untervektor hat die
+ gleiche Struktur wie der Haupvektor.
+ - <flag> = INHLIST_TAG_VIRTUAL (2):
+ Alle Namen im Ergebnisvektor haben ein leeres Tag " " (zwei
+ Leerschlaege) fuer normale Inherits und "v " fuer virtuelle
+ Inherits als Praefix vorangestellt.
+
+ Alle Flags koennen mit einem binaeren Oder | verbunden werden, wobei
+ INHLIST_FLAT und INHLIST_TREE sich gegenseitig ausschliessen.
+
+ Wenn ein Objekt, inklusive <ob>, einem replace_programm() unterworfen
+ war, spiegeln die gelieferten Dateinamen das effektiv aktive Programm
+ wider.
+
+ Die Inheritpfade, die geliefert werden, beginnen immer mit '/'
+ (absolute Pfade), auch wenn der Treiber im COMPAT Modus laeuft.
+
+BEISPIEL
+ Gegeben folgende Vererbungsstruktur:
+
+ / c - d
+ a
+ \ b
+
+ Wobei d virtuell geerbt wird, ergeben sich folgende Resultate:
+
+ inherit_list(a) -> ({ "a", "c", "b", "d" })
+ inherit_list(c) -> ({ "c", "d" })
+ inherit_list(a, 1) -> ({ "a", ({ "c", "d" }), "b" })
+ inherit_list(a, 3) -> ({ " a", ({ " c", "v d" }), " b" })
+
+AENDERUNGEN
+ Vor 3.2.8, begannen die gelieferten Namen niemals mit einem '/'.
+ LDMud 3.2.9 fuehrte die Baumstruktur (_TREE) und Tags fuer virtuelle
+ Inherits ("v ") ein.
+
+SIEHE AUCH
+ debug_info(E), include_list(E)
diff --git a/doc/efun/input_to b/doc/efun/input_to
new file mode 100644
index 0000000..11cbd97
--- /dev/null
+++ b/doc/efun/input_to
@@ -0,0 +1,146 @@
+SYNOPSIS
+ #include <sys/input_to.h>
+
+ void input_to(string|closure fun);
+ void input_to(string|closure fun, int flag, ...);
+ void input_to(string|closure fun, int flag, string|closure prompt, ...);
+
+BESCHREIBUNG
+ Die naechste Zeile, die der Spieler eintippt, wird als Argument an die
+ Funktion <fun> uebergeben. Ausnahme: wenn die naechste Zeile mit einem
+ '!' beginnt, wird sie als Kommando ausgewertet bzw. an das letzte
+ input_to() uebergeben, das das INPUT_IGNORE_BANG Flag gesetzt hat.
+ Die Funktion <fun> kann "static" deklariert sein, nicht aber "private"
+ (sonst wird sie nicht gefunden).
+
+ Der Aufruf von <fun> erfolgt nicht sofort, sondern erst, wenn der
+ Spieler die Entertaste drueckt.
+
+ Wenn input_to() mehr als einmal pro Funktion aufgerufen wird,
+ wird normalerweise nur das erste input_to() beruecksichtigt.
+ Diese Verhalten kann durch die Angabe von INPUT_APPEND
+ modifiziert werden: in diesem Fall wird das input_to() an die
+ Liste der bereits anhaengigen input_tos angehaengt (siehe
+ BEISPIELE).
+
+ Wird andererseits waehrend einem laufenden input_to() (mittels "!" am
+ Zeilenanfang) eine neue Funktion aufgerufen, die wiederum ein
+ input_to() enthaelt, wird das urspruengliche input_to() so lange
+ unterbrochen, bis das neue input_to() abgearbeitet wurde,
+ anschliessend wird es wieder aktiv.
+
+ Das optionale <flag> kann ein binaeres Oder (|) der folgenden
+ Werte sein:
+
+ INPUT_NOECHO (1):
+ Die vom Spieler eingegebene Zeile erzeugt kein Echo und wird auch
+ nicht erkannt, wenn der Spieler beobachtet wird.
+
+ Dieser Modus kann nur geaendert werden, wenn telnet enabled ist.
+
+ INPUT_CHARMODE (2):
+ Die Verbindung zum User wechselt von Zeilen- auf Zeichenmodus. So
+ wird nur ein einzelnes Zeichen (!) vom Spieler empfangen.
+
+ Ist telnet disabled, wird lediglich die Interpretation der
+ einkommenden Daten durch den Driver umgeschaltet - das
+ Clientprogramm des Spieler verbleibt im gerade aktiven Modus.
+
+ Nachdem die Funktion <fun> ausgefuehrt wurde, wechselt die
+ Verbindung zurueck in Zeilenmodus, ausser ein nachfolgendes
+ input_to( , 2) wurde gestartet.
+
+ Zeilenumbrueche werden je nach Client unterschiedlich empfangen,
+ entweder als "", als "\r" gefolgt von "" oder als "\r" (letzteres
+ kommt vor allem bei Windows Clients vor).
+
+ Das Frontend des Spielers kann dauernd im Zeilenmodus bleiben.
+ Auch wenn input_to() nur ein einzelnes Zeichen fordert, muss der
+ Spieler unter Umstaenden das Zeichen und einen Zeilenumbruch
+ druecken (und senden). Normalerweise erhaelt <fun> dann den
+ gesamten Input auf einmal.
+
+ Will man laenger im Zeichenmodus bleiben, kann der Overhead
+ reduziert werden, indem set_combine_charset() verwendet wird. So
+ koennen Zeichensequenzen als ein String anstelle von
+ Zeichen-fuer-Zeichen empfangen werden. In einem screenorientierten
+ Editor gilt dies fuer die meisten druckbaren Zeichen.
+
+ INPUT_PROMPT (4):
+ Das Argument nach dem <flag> wird als Prompt fuer die Eingabe
+ verwendet. Wenn dieses Argument nicht angegeben (und damit kein
+ Propmt definiert) ist, wird kein Prompt ausgegeben.
+
+ INPUT_NO_TELNET (8):
+ Modifiziert das INPUT_CHARMODE Argument: der Driver aendert
+ seine Behandlung von eingehenden Daten entsprechend dem _CHARMODE
+ Argument, sendet aber keine Telnetkommandos zur Anpassung
+ des Verhaltens des Clientprogrammes.
+
+ INPUT_APPEND (16):
+ Das input_to() wird an die Liste der bereits anhaengigen
+ input_tos angehaengt.
+
+ INPUT_IGNORE_BANG (128):
+ Eingaben, die mit ! beginnen, werden NICHT als Kommandi geparset,
+ sondern auch als Argument an die Funkion <fun> uebergeben. Die
+ Verwendung dieses Flags ist eingeschraenkt.
+
+ Alle nachfolgenden Argumente werden als zweites bzw. drittes usw.
+ Argument an <fun> uebergeben.
+
+BEISPIEL
+ void func()
+ {
+ ...
+ input_to("enter_name", INPUT_PROMPT, "Wie lautet dein Name?:");
+ /* Frueher erledigte man dies mit:
+ * write("Wie lautet dein Name?:");
+ * input_to("enter_name");
+ */
+ ...
+ }
+
+ enter_name(string str)
+ {
+ write("Heisst du wirklich '"+str+"'?? *kicher*\n");
+ ...
+ }
+
+ Bei der input_to() Anweisung fuehrt der Driver die Funktion
+ func() aus, erwartet aber gleichzeitig Input vom Spieler. Wenn
+ dieser etwas eingegeben UND DIE ENTERTASTE GEDRUECKT HAT, arbeitet
+ der Driver die Funktion enter_name() mit dem eingegebenen String
+ als Argument ab.
+
+
+ void func() {
+ ..
+ input_to("enter_firstname");
+ input_to("enter_lastname, INPUT_APPEND);
+ ...
+ }
+
+ Diese Sequenze erzeugt zwei input_tos: Eingaben gehen zuerst
+ an enter_firstname(); und wenn diese Funktion fertig ist
+ (einschliesslich etwaiger eigener non-INPUT_APPEND input_tos), geht
+ die naechste Eingabe an enter_lastname().
+
+AENDERUNGEN
+ Die Bedeutung von <flag> wurde in 3.2.1@93 erweitert.
+ Die Limitierung fuer das "stapeln" von input_to()s aus !-Kommandi
+ wurde in LDMud 3.2.8 implementiert.
+ Seit LDMud 3.2.8 kann <fun> in Form einer Closure angegeben werden.
+ LDMud 3.2.9 fuehrte das Flag INPUT_PROMPT samt zugehoerigem Argument
+ ein.
+ LDMud 3.2.11/3.3.593 fuehrte das INPUT_NO_TELNET Flag ein.
+ LDMud 3.2.11/3.3.637 fuehrte das INPUT_APPEND Flag ein.
+
+BUGS
+ Im Zeichenmodus sollten Zeilenumbrueche eigentlich als "\n" zurueck
+ gegeben werden. Dies allerdings kann existierenden Code zerstoeren.
+
+SIEHE AUCH
+ call_other(E), sscanf(E), privilege_violation(M),
+ set_combine_charset(E), query_input_pending(E), find_input_to(E),
+ input_to_info(E), remove_input_to(E), enable_telnet(E)
diff --git a/doc/efun/input_to_info b/doc/efun/input_to_info
new file mode 100644
index 0000000..8dac3d3
--- /dev/null
+++ b/doc/efun/input_to_info
@@ -0,0 +1,21 @@
+SYNOPSIS
+ *mixed input_to_info(object player);
+
+BESCHREIBUNG
+ Liefert ein Array aller fuer <player> haengigen input_to()s. Der
+ erste Eintrag im Array ist der aelteste haengige input_to()
+ (derjenige, welcher als erstes gestartet wurde), der letzte
+ Eintrag ist der neuste input_to().
+
+ Jeder Eintrag im Array ist wiederum ein Array von 2 oder mehr
+ Eintraegen, das folgende Elemente enthaelt:
+ 0: Das Objekt (nur, wenn die Funktion ein string ist)
+ 1: Die Funktion (String oder Closure)
+ 2ff: Die Argumente
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ input_to(E), find_input_to(E), remove_input_to(E),
+ query_input_pending(E)
diff --git a/doc/efun/insert_alist b/doc/efun/insert_alist
new file mode 100644
index 0000000..01aca4e
--- /dev/null
+++ b/doc/efun/insert_alist
@@ -0,0 +1,28 @@
+OPTIONAL, VERALTET
+SYNOPSIS
+ mixed *insert_alist(mixed key, mixed data, ... , mixed *alist);
+ int insert_alist(mixed key, mixed *keys);
+
+BESCHREIBUNG
+ 1. Form: Einfuegen in eine Alist.
+ Der <key> und alle foglenden <data> Argumente werden in die Alist
+ eingefuegt. Wenn bereits ein Eintrag fuer <key> existiert, werden
+ nur die <data> Eintraege ersetzt. Natuerlich muss die Anzahl <data>
+ Argumente der Anzahl der Datenarrays in der Alist entsprechen.
+ Das Resultat dieser Operation ist die neue Alist.
+
+ 2. Form: Einfuegen eines Keys
+ Der <key> wird in ein (geordnetes) Array von <keys> eingeordnet,
+ sodass nachfolgendes assoc()s schnell suchen koennen. Das Resultat
+ ist der Index, unter dem <key> eingefuegt oder bereits gefunden
+ wurde.
+
+ANMERKUNG
+ Wird mit String-Keys gearbeitet, kann der Index nach dem naechsten
+ Aufruf von insert_alist() nicht mehr gueltig sein.
+
+ Komplexitaet: O(lg(n) + a*n) fuer n gleich der Anzahl der Keys und
+ eine sehr kleine Konstante s (fuer Blockverschiebungen).
+
+SIEHE AUCH
+ alists(LPC), assoc(E), order_alist(E)
diff --git a/doc/efun/interactive b/doc/efun/interactive
new file mode 100644
index 0000000..c326f8a
--- /dev/null
+++ b/doc/efun/interactive
@@ -0,0 +1,10 @@
+SYNOPSIS
+ int interactive(object obj);
+
+BESCHREIBUNG
+ Liefert 1 zurueck, wenn <obj> ein interaktiver User (ein Spieler)
+ ist. Wird <obj> weggelassen, dann wird this_object() verwendet.
+
+SIEHE AUCH
+ query_once_interactive(E), query_ip_number(E), query_ip_name(E),
+ query_idle(E)
diff --git a/doc/efun/interactive_info b/doc/efun/interactive_info
new file mode 100644
index 0000000..f7c2877
--- /dev/null
+++ b/doc/efun/interactive_info
@@ -0,0 +1,106 @@
+SYNOPSIS
+ #include <interactive_info.h>
+
+ mixed interactive_info(object ob, int what)
+
+DESCRIPTION
+ Returns some internal information about the interactive user <ob>.
+ The argument <what> determines which information is returned.
+
+ It can be either a configuration option as given to
+ configure_interactive() or one of the following options:
+
+
+
+ Connection Information:
+
+ <what> == II_IP_NAME:
+ The hostname of <ob>. The hostname will asynchronously
+ looked up by the ERQ daemon and might therefore not be
+ available at the time of the first connection.
+ If no name is available the address will be returned.
+
+ <what> == II_IP_NUMBER:
+ The IP address of <ob> given as a string.
+
+ <what> == II_IP_PORT:
+ The client port number of <ob>.
+
+ <what> == II_IP_ADDRESS:
+ The full socket address structure given as an array of bytes.
+
+ For IPv4 (sockaddr_in):
+ array[0.. 1]: sin_family
+ array[2.. 3]: sin_port
+ array[4.. 7]: sin_addr
+ array[8..15]: undefined.
+
+ For IPv6 (sockaddr_in6):
+ array[ 0.. 1]: sin6_family
+ array[ 2.. 3]: sin6_port
+ array[ 4.. 7]: sin6_flowinfo
+ array[ 8..23]: sin6_addr
+ array[24..27]: sin6_scope_id
+
+ <what> == II_MUD_PORT:
+ The server port number that <ob> connected to.
+
+
+
+ Telnet Related Information:
+
+ <what> == II_MCCP_STATS:
+ Statistics about the current compression of <ob> given
+ as an array ({ uncompressed bytes, compressed bytes }).
+
+ If the connection is not compressed, 0 is returned.
+
+ Available only if the driver is compiled with MCCP enabled;
+ __MCCP__ is defined in that case.
+
+
+
+ Input Handling:
+
+ <what> == II_INPUT_PENDING:
+ If <ob> has an input_to() pending, the object that has called
+ the input_to() is returned, else 0.
+
+ <what> == II_EDITING:
+ If <ob> is currently editing with ed() and ed() was called with
+ an exit function, then the object that has called ed()
+ will be returned, 0 otherwise.
+
+ <what> == II_IDLE:
+ The number of seconds that the interactive object <ob> has been
+ idle.
+
+
+
+ Output Handling:
+
+ <what> == II_SNOOP_NEXT:
+ Returns the user who is currently snooping <ob>.
+ The calling object must be privileged by the master object
+ via valid_query_snoop().
+
+ <what> == II_SNOOP_PREV:
+ Returns the victim who is currently snooped by <ob>.
+ The calling object must be privileged by the master object
+ via valid_query_snoop().
+
+ <what> == II_SNOOP_ALL:
+ Returns all objects who are currently snooping <ob>.
+ Only one object can snoop <ob> directly, but that user might
+ be snooped, too, and so building a chain that is returned
+ as an array.
+
+ The calling object must be privileged by the master object
+ via valid_query_snoop().
+
+
+HISTORY
+ Introduced in LDMud 3.5.0.
+
+SEE ALSO
+ configure_interactive(E), object_info(E), driver_info(E)
diff --git a/doc/efun/intp b/doc/efun/intp
new file mode 100644
index 0000000..6a6a0f2
--- /dev/null
+++ b/doc/efun/intp
@@ -0,0 +1,10 @@
+SYNOPSIS
+ int intp(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument eine Ganzzahl (Integer) ist, ansonsten
+ 0.
+
+SIEHE AUCH
+ closurep(E), floatp(E), mappingp(E), objectp(E), pointerp(E),
+ referencep(E), stringp(E), symbolp(E), clonep(E)
diff --git a/doc/efun/invert_bits b/doc/efun/invert_bits
new file mode 100644
index 0000000..27bbe6d
--- /dev/null
+++ b/doc/efun/invert_bits
@@ -0,0 +1,17 @@
+SYNOPSIS
+ string invert_bits(string str);
+
+BESCHREIBUNG
+ Invertiert den Status aller Bits im Bitstring <str> und liefert den
+ neuen String zurueck. Dabei bleibt die Laenge von <str>, also die
+ gesamte Anzahl Bits, die gleiche.
+
+BEISPIEL
+ string s;
+ s = set_bit("", 3); s = set_bit(s, 4); s = set_bit(s, 15);
+ --> s ist nun "8 ("
+ invert_bits(s) --> liefert "G_W"
+
+SIEHE AUCH
+ set_bit(E), clear_bit(E), test_bit(E), last_bit(E), and_bits(E),
+ or_bits(E), xor_bits(E), count_bits(E), copy_bits(E)
diff --git a/doc/efun/json_parse b/doc/efun/json_parse
new file mode 100644
index 0000000..a9f4c31
--- /dev/null
+++ b/doc/efun/json_parse
@@ -0,0 +1,45 @@
+OPTIONAL
+EXPERIMENTAL
+SYNOPSIS
+
+ mixed json_parse(string jsonstring)
+
+DESCRIPTION
+ This efun parses the JSON object encoded as string in <jsonstr> into a
+ suitable LPC type.
+
+ Handles the following JSON types:
+ <null> -> int (0)
+ <boolean> -> int (0 or 1)
+ <int | int64> -> int
+ <double> -> float
+ <string> -> string
+ <object> -> mapping
+ <array> -> arrays
+ All other JSON types cause a runtime error.
+
+ The JSON object can nest other JSON objects.
+
+ The function is available only if the driver is compiled with Iksemel
+ support. In that case, __JSON__ is defined.
+
+LIMITATIONS
+ 64 bit wide integers can only be parsed losslessly on hosts with
+ a 64 bit wide LPC int and json-c library newer than 0.90.
+
+BUGS
+ __FLOAT_MIN__ is not serialized/parsed losslessly.
+
+EXAMPLES
+ json_parse("42") -> 42
+ json_parse("42.0") -> 42.0
+ json_parse("\"hello world\\n\"") -> "hello world\n"
+ json_parse("[ 1, 2, 3, 4, 5, 6 ]") -> ({1,2,3,4,5,6})
+ json_parse("{ \"test 2\": 42.000000, \"test 1\": 42 }")
+ -> ([ "test 1": 42, "test 2": 42.0 ])
+
+HISTORY
+ Added in LDMud 3.5.0
+
+SEE ALSO
+ json_serialize(E)
diff --git a/doc/efun/json_serialize b/doc/efun/json_serialize
new file mode 100644
index 0000000..fd68deb
--- /dev/null
+++ b/doc/efun/json_serialize
@@ -0,0 +1,45 @@
+OPTIONAL
+EXPERIMENTAL
+SYNOPSIS
+
+ string json_serialize(mixed <data>)
+
+DESCRIPTION
+ This efun creates a JSON object from the given LPC variable and
+ returns the object encoded as a LPC string. For container types like
+ arrays, mappings and structs, this will be done recursively.
+
+ Only the following LPC types are serialized. All other LPC types cause
+ a runtime error.
+ <int> -> JSON int
+ <float> -> JSON double
+ <string> -> JSON string
+ <mapping> -> JSON objects
+ <array> -> JSON arrays
+ <struct> -> JSON objects
+
+ The function is available only if the driver is compiled with Iksemel
+ support. In that case, __JSON__ is defined.
+
+LIMITATIONS
+ Only mappings with a width of 1 value per key and only string keys
+ can be serialized.
+ 64 bit wide integers can only be serialized losslessly on hosts with
+ a 64 bit wide LPC int and json-c library newer than 0.90.
+
+BUGS
+ __FLOAT_MIN__ is not serialized/parsed losslessly.
+
+EXAMPLES
+ json_serialize(42) -> "42"
+ json_serialize(42.0) -> "42.0"
+ json_serialize("hello world\n") -> "\"hello world\\n\""
+ json_serialize(({1,2,3,4,5,6})) -> "[ 1, 2, 3, 4, 5, 6 ]"
+ json_serialize(([ "test 1": 42, "test 2": 42.0 ]))
+ -> "{ \"test 2\": 42.000000, \"test 1\": 42 }"
+
+HISTORY
+ Added in LDMud 3.5.0
+
+SEE ALSO
+ json_parse(E)
diff --git a/doc/efun/lambda b/doc/efun/lambda
new file mode 100644
index 0000000..b156798
--- /dev/null
+++ b/doc/efun/lambda
@@ -0,0 +1,28 @@
+SYNOPSIS
+ closure lambda(mixed *arr, mixed);
+
+BESCHREIBUNG
+ Erzeugt eine Lambda Closure, entsprechend den Lamda Closures in LISP.
+ Die Closure ist an das Objekt gebunden, das sie erzeugt hat, und kann
+ deshalb Verweise auf globale Variablen enthalten.
+
+ Das erste Argument ist ein Array, das die Argumente (Symbole)
+ 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"
+ })));
+
+SIEHE AUCH
+ Verwandt: unbound_lambda(E), apply(E), funcall(E), bind_lambda(E)
+ Generell: closures-abstract(LPC), closures(LPC)
diff --git a/doc/efun/last_bit b/doc/efun/last_bit
new file mode 100644
index 0000000..d0d2471
--- /dev/null
+++ b/doc/efun/last_bit
@@ -0,0 +1,19 @@
+SYNOPSIS
+ int last_bit(string str);
+
+BESCHREIBUNG
+ Liefert die Nummer des letzten gesetzten Bits im Bitstring <str>.
+
+ Jedes Zeichen enthaelt 6 Bits. Also kann in jedem Zeichen ein Wert von
+ 0 bis 63 gespeichert werden (2^6=64). Das erste Zeichen ist der
+ Leerschlag " " mit dem Wert 0. Das erste Zeichen im String ist jenes
+ mit den niedrigsten Bits (0-5).
+
+BEISPIEL
+ string s;
+ s = set_bit("", 4); s = set_bit(s, 2);
+ last_bit(s) --> liefert 4
+
+SIEHE AUCH
+ set_bit(E), clear_bit(E), next_bit(E), test_bit(E), count_bits(E),
+ and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/last_instructions b/doc/efun/last_instructions
new file mode 100644
index 0000000..ca447d9
--- /dev/null
+++ b/doc/efun/last_instructions
@@ -0,0 +1,28 @@
+GESCHUETZT
+SYNOPSIS
+ string *last_instructions(int lenght, int verbose);
+
+BESCHREIBUNG
+ Liefert ein Array mit der "Laenge" der zuletzt ausgefuehrten
+ Anweisungen. Wenn <verbose> ungleich 0 ist (standardmaessig so),
+ werden auch Infos zur Zeilennummer angezeigt. Jeder String hat
+ folgende Form:
+
+ Opcode-Adresse: Opcode Operand Mnemonic (Stapeltiefe) Zeilennummer
+
+ Die Information zur Stapeltiefe besteht aus zwei Zahlen <rel>:<abs>,
+ wobei <rel> der relative Stapelverbrauch der Funktion ist, <abs> der
+ absolute Stapelverbrauch.
+
+ Die Information zur Zeilennummer wird angefuegt, wenn das Flag gesetzt
+ ist und eine neue Zeile im Quellcode erreicht wird. Ebenso erzeugen
+ Aufrufe zwischen Objekten einen Eintrag im Resultatarray (allerdings
+ nur, wenn das verbose-Flag gesetzt ist). Dieser Eintrag hat die Form:
+
+ Objektname Programmname Zeilennummer.
+
+ Es gibt ein vorkonfiguriertes oberes Limit, wie viele Instruktionen
+ zurueckverfolgt werden koennen.
+
+SIEHE AUCH
+ debug_message(E)
diff --git a/doc/efun/limited b/doc/efun/limited
new file mode 100644
index 0000000..c967812
--- /dev/null
+++ b/doc/efun/limited
@@ -0,0 +1,64 @@
+VORLAEUFIG, GESCHUETZT
+SYNOPSIS
+ #include <sys/rtlimits.h>
+
+ mixed limited(closure fun);
+ mixed limited(closure fun, int tag, int value, ...);
+ 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.
+
+ Beim Ende der Funktion <fun> werden die momentan aktiven
+ Laufzeitlimiten 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 Limiteneinstellung 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
+
+ Fuer LIMIT_COST, die Spezialwerte haben diese 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
+
+ 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.
+
+ limited(#'function, ({ 200000 }), "foo")
+ --> 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
+ aus. Die Funktion wird als 'function("foo")' aufgerufen.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+ LDMud 3.3.563 fuehrte LIMIT_COST ein.
+
+SIEHE AUCH
+ query_limits(E), set_limits(E)
+ get_eval_cost(E)
+
+16.05.2007, Zesstra
+
diff --git a/doc/efun/living b/doc/efun/living
new file mode 100644
index 0000000..6f0a886
--- /dev/null
+++ b/doc/efun/living
@@ -0,0 +1,13 @@
+SYNOPSIS
+ int living(object ob);
+
+BESCHREIBUNG
+ Liefert 1 zurueck, wenn <ob> ein lebendiges Objekt (living) ist.
+ <ob> ist living, wenn enable_commands() aus <obj> aufgerufen wurde.
+ <ob> kann auch 0 sein.
+
+BEISPIEL
+ living(this_player()); -> Dies liefert (hoffentlich) 1 zuerueck.
+
+SIEHE AUCH
+ enable_commands(E)
diff --git a/doc/efun/load_name b/doc/efun/load_name
new file mode 100644
index 0000000..f26c1ea
--- /dev/null
+++ b/doc/efun/load_name
@@ -0,0 +1,47 @@
+SYNOPSIS
+ string load_name()
+ string load_name(object|string obj)
+
+BESCHREIBUNG
+ Die Funktion liefert den Namen, mit dem <obj> geladen wurde. <obj>
+ kann direkt als Objekt oder als String mit seinem Namen angegeben
+ werden.
+
+ Wenn <obj> ein Clon ist, liefert die Funktion den Namen des Blueprints.
+ Wenn <obj> ein Blueprint ist, liefert die Funktion den Namen des Files,
+ aus dem der Blueprint kompiliert wurde.
+
+ Wenn <obj> ueber seinen Namen angegeben wurde, aber nicht / nicht mehr
+ existiert, generiert die Funktion den Namen, wie er sein muesste und
+ gibt diesen zurueck. Wenn der angegebene Name ungueltig ist, liefert
+ die Funktion 0.
+
+ Als Spezialfall liefert die Funktion 0, wenn <ob> 0 ist.
+
+ Fuer virtuelle Objekte liefert load_name() den originalen Ladenamen
+ des Objekts, welches der virtuelle Compiler erzeugte.
+
+ Wird <obj> nicht angegeben, wird der Name fuer das momentan gueltige
+ Objekt angegeben.
+
+ Im Gegensatz zum object_name() kann der load_name() nicht durch
+ rename_object() oder einen VC veraendert werden. Ist ein <obj> jedoch
+ einem replace_program() unterworfen, spiegelt der load_name() nicht
+ mehr das effektive Verhalten des Objekts wider.
+
+BEISPIELE
+ object o;
+ o = clone_object("/std/thing");
+ write(load_name(o)); --> liefert "/std/thing" in !Compat Modus
+ und "std/thing" im Compat Modus
+ write(load_name("/std/thing")); --> gleich wie oben
+ write(load_name("/std/thing#4n5")); --> liefert 0
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.6.
+ Strings als Argumente sind moeglich seit 3.2.8.
+ 0 ist zulaessig seit 3.2.9.
+
+SIEHE AUCH
+ clone_object(E), clonep(E), object_name(E), load_object(E),
+ replace_program(E), program_name(E), present_clone(E)
diff --git a/doc/efun/load_object b/doc/efun/load_object
new file mode 100644
index 0000000..847d0b8
--- /dev/null
+++ b/doc/efun/load_object
@@ -0,0 +1,23 @@
+SYNOPSIS
+ object load_object(string name)
+
+DESCRIPTION
+ Load the object from the file <name> and return it. If the
+ object already exists, just return it.
+
+ This efun can be used only to load blueprints - for clones, use
+ the efun clone_object().
+
+ If strict euids are enforced, the cloning object must have
+ a non-zero euid.
+
+EXAMPLE
+ // Update and reload the standard player object
+ destruct(find_object("/std/player"));
+ load_object("/std/player");
+
+HISTORY
+ Introduced in LDMud 3.2.6.
+
+SEE ALSO
+ clone_object(E)
diff --git a/doc/efun/localtime b/doc/efun/localtime
new file mode 100644
index 0000000..a522dc4
--- /dev/null
+++ b/doc/efun/localtime
@@ -0,0 +1,39 @@
+SYNOPSIS
+ #include <sys/time.h>
+
+ int *localtime(int clock);
+ int *localtime(int *uclock);
+
+BESCHREIBUNG
+ Interpretiert das Argument <clock> als Anzahl Sekunden seit dem
+ 01. Januar 1970, 00:00:00, und gibt die Zeit in Lokalzeit in einer
+ sauberen Struktur zurueck. Wird <clock> nicht angegeben, wird
+ standardmaessig time() verwendet.
+
+ Alternativ kann auch ein Array von zwei Zahlen als Argument angegeben
+ werden. Das erste Element wird interpretiert wie <clock>, das zweite
+ Argument enthaelt die vergangenen Mikrosekunden in dieser Sekunde und
+ wird ignoriert.
+
+ Das Resultat ist ein Array mit folgenden Elementen:
+
+ int TM_SEC (0): Sekunde in der Minute (0..59)
+ int TM_MIN (1): Minute in der Stunde (0..59)
+ int TM_HOUR (2): Stunde des Tages (0..23)
+ int TM_MDAY (3): Tag im Monat (1..31)
+ int TM_MON (4): Monat des Jahres (0..11)
+ int TM_YEAR (5): Jahr (z.B. 2001)
+ int TM_WDAY (6): Wochentag (0..6, Sonntag = 0)
+ int TM_YDAY (7): Tag im Jahr (0..365)
+ inz TM_ISDST (8): TRUE: Daylight Saving Time
+
+BEISPIEL
+ printf("Today is %s\n", ({ "Sonntag", "Montag", "Dienstag",
+ "Mittwoch", "Donnerstag", "Freitag", "Samstag"})
+ [localtime()[TM_WDAY]]);
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9
+
+SIEHE AUCH
+ ctime(E), gmtime(E), time(E), utime(E)
diff --git a/doc/efun/log b/doc/efun/log
new file mode 100644
index 0000000..1b2abff
--- /dev/null
+++ b/doc/efun/log
@@ -0,0 +1,8 @@
+SYNOPSIS
+ float log(int|float arg);
+
+BESCHREIBUNG
+ Liefert den natuerlichen Logarithmus von <arg>.
+
+SIEHE AUCH
+ exp(E), pow(E)
diff --git a/doc/efun/lower_case b/doc/efun/lower_case
new file mode 100644
index 0000000..9701e20
--- /dev/null
+++ b/doc/efun/lower_case
@@ -0,0 +1,12 @@
+SYNOPSIS
+ string lower_case(string str);
+
+BESCHREIBUNG
+ Konvertiert alle Zeichen in <str> in Kleinbuchstaben und liefert den
+ neuen String.
+
+BEISPIEL
+ lower_case("Hallo WeLT!") -> "hallo welt!"
+
+SIEHE AUCH
+ capitalize(E), upper_case(E)
diff --git a/doc/efun/m_add b/doc/efun/m_add
new file mode 100644
index 0000000..624f4b9
--- /dev/null
+++ b/doc/efun/m_add
@@ -0,0 +1,29 @@
+SYNOPSIS
+ mapping m_add(mapping map, mixed key, [mixed data, ...]);
+
+BESCHREIBUNG
+ Fuegt einen neuen Eintrag mit Index <key> zum Mapping <map> hinzu
+ oder ersetzt diesen. Das veraenderte Mapping wird als Ergebnis
+ zurueck geliefert. Werte, die nicht zugeordnet werden koennen, werden
+ als 0 interpretiert, irrelevante Argumente werden ignoriert.
+
+BEISPIELE
+ mapping m;
+ m = ([ "foo" ]);
+ m_add(m, "bar", 1) --> ([ "foo", "bar" ])
+
+ m = ([ "foo":1 ]);
+ m_add(m, "bar", 1) --> ([ "foo":1, "bar":1 ])
+
+ m = ([ "foo":1;2 ]);
+ m_add(m, "bar", 1) --> ([ "foo":1;2, "bar":1;0 ])
+
+ apply(#'m_add, m, "baz", ({ 4, 5 }))
+ --> ([ "foo":1;2, "bar":1;0, "baz":4;5 ])
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ mappingp(E), mkmapping(E), m_delete(E), m_entry(E), m_indices(E),
+ m_values(E), sizeof(E), widthof(E)
diff --git a/doc/efun/m_allocate b/doc/efun/m_allocate
new file mode 100644
index 0000000..255f3b9
--- /dev/null
+++ b/doc/efun/m_allocate
@@ -0,0 +1,46 @@
+SYNOPSIS
+ mapping m_allocate(int size)
+ mapping m_allocate(int size, int width)
+
+BESCHREIBUNG
+ Die Funktion reserviert Speicher fuer ein Mapping. <size> ist die
+ Anzahl Eintraege (d.h. die Anzahl Keys), <width> ist die Anzahl
+ Dateneintraege pro Key. Wird <width> nicht angegeben, werden Keys
+ mit einem Datenelement erzeugt.
+
+ Die Funktion ist nur sinnvoll, wenn man ein Mapping erzeugt, dessen
+ ungefaehre Groesse von vornherein bekannt ist, um so den Overhead
+ von wiederholten Speicherallokation zu minimieren. Wenn nicht alle
+ allozierten Datenelemente mit Daten bestueckt werden, werden die
+ Ueberbleibsel einige Zeit spaeter bei Gelegenheit wieder freigegeben
+ (s. Bemerkungen).
+ m_allocate() ist auch nuetzlich, wenn ein Mapping bestimmter Breite
+ erzeugt werden soll, ohne bereits die Daten zu den Keys bereit zu
+ stellen.
+
+ Wenn bloss ein leeres Mapping bestimmter Breite erzeugt werden soll,
+ so kann folgende Notation verwendet werden:
+
+ ([ ]) : erzeugt ein leeres Mapping mit Breite 1.
+ ([:<width>]) : erzeugt ein leeres Mapping der Breite <width>,
+ wobei <width> eine beliebige Anweisung sein kann, die eine
+ Integerzahl zurueck liefert. Tatsaechlich wird diese Notation
+ als 'm_allocate(0, <width>)' kompiliert.
+
+BEISPIELE
+ m_allocate(3,7) -> erzeugt ein Mapping mit 7 Werten pro Key und Platz
+ fuer 3 Eintraege.
+ ([:2*3]) -> entspricht m_allocate(0,6).
+
+BEMERKUNGEN
+ Ungenutzer Speicher des allozierten Mappins wird waehrend des sog.
+ Kompaktierens des Mappings freigegeben. Dies passiert waehrend eines
+ "data cleanups" oder einer "garbage collection". Die Zeit zwischen
+ "data cleanups" ist mit configure_driver() konfigurierbar.
+
+GESCHICHTE
+ Umbenannt von allocate_mapping() in LDMud 3.2.6.
+ Die ([:<width>]) Notation wurde in 3.2.9 eingefuehrt.
+
+SIEHE AUCH
+ mappings(LPC), walk_mapping(E), get_type_info(E), m_reallocate(E)
diff --git a/doc/efun/m_contains b/doc/efun/m_contains
new file mode 100644
index 0000000..e941ff3
--- /dev/null
+++ b/doc/efun/m_contains
@@ -0,0 +1,18 @@
+SYNOPSIS
+ int m_contains(mixed &data1, ... , &dataN, mapping map, mixed key);
+
+BESCHREIBUNG
+ Wenn <map> den Key <key> enthaelt, werden die entsprechenden Werte
+ den Datenargumenten von <key> zugeordnet, welche per Referenz
+ uebergeben werden muessen. m_contains liefert in diesem Fall 1 zurueck.
+ Wenn <key> nicht in <map> enthalten ist, liefert die Funktion 0
+ zurueck und die Datenargumente bleiben unveraendert.
+
+ Man kann diese Funktion auch fuer 0-Wert Mappings verwenden, wobei
+ sie den gleichen Effekt wie member(E) hat.
+
+AENDERUNGEN
+ Umbenannt von 'mapping_contains' in LDMud 3.2.6.
+
+SIEHE AUCH
+ m_entry(E), mappings(LPC), member(E)
diff --git a/doc/efun/m_delete b/doc/efun/m_delete
new file mode 100644
index 0000000..bb9d453
--- /dev/null
+++ b/doc/efun/m_delete
@@ -0,0 +1,11 @@
+SYNOPSIS
+ mapping m_delete(mapping map, mixed key)
+
+BESCHREIBUNG
+ Loescht den Eintrag mit dem Index <key> aus dem Mapping <map> und
+ liefert das veraenderte Mapping zurueck. Wenn <map> keinen Eintag
+ mit dem Index <key> enthaelt, wird nichts veraendert.
+
+SIEHE AUCH
+ mappingp(E), mkmapping(E), m_add(E), m_indices(E), m_values(E),
+ sizeof(E), widthof(E)
diff --git a/doc/efun/m_entry b/doc/efun/m_entry
new file mode 100644
index 0000000..20ea2af
--- /dev/null
+++ b/doc/efun/m_entry
@@ -0,0 +1,24 @@
+SYNOPSIS
+ *mixed m_entry(mapping map, mixed key);
+
+BESCHREIBUNG
+ Durchsucht das Mapping <map> nach dem Eintrag mit Index <key> und
+ liefert alle Werte von <key> in einem Array zurueck.
+
+ Wenn <map> keinen Eintrag mit Index <key> enthaelt, liefert
+ m_entry() 0.
+
+BEISPIEL
+ mapping m = ([1:"bla":-1, 2:"fasel":-2 ])
+ m_entry(m, 0) -> 0
+ m_entry(m, 1) -> ({"bla", -1})
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.10.
+
+ANMEKRUNG
+ Mit der Efun m_add() koennen alle Werte eines Eintrages auf einmal
+ addiert werden.
+
+SIEHE AUCH
+ m_add(E), m_contains(E), mappings(LPC), member(E)
diff --git a/doc/efun/m_indices b/doc/efun/m_indices
new file mode 100644
index 0000000..4d84c4e
--- /dev/null
+++ b/doc/efun/m_indices
@@ -0,0 +1,9 @@
+SYNOPSIS:
+ mixed *m_indices(mapping map)
+
+DESCRIPTION:
+ Return an array containing the indices of mapping 'map'.
+
+SEE ALSO:
+ mappingp(E), mkmapping(E), m_values(E), m_delete(E),
+ sizeof(E), widthof(E)
diff --git a/doc/efun/m_reallocate b/doc/efun/m_reallocate
new file mode 100644
index 0000000..627bc97
--- /dev/null
+++ b/doc/efun/m_reallocate
@@ -0,0 +1,23 @@
+SYNOPSIS
+ mapping m_reallocate(mapping m, int width);
+
+BESCHREIBUNG
+ Erzeugt ein neues Mapping mit <width> Werten pro Key und fuellt das
+ Mapping mit den Werten aus <m>. Wenn <m> weniger als <width> Werte
+ pro Key hat, werden im neuen Mapping die restlichen Werte auf 0
+ gesetzt. Wenn <m> mehr als <width> Werte pro Key hat, werden die
+ ueberzaehligen Werte ignoriert.
+
+ Das urspruengliche Mapping <m> wird nicht veraendert.
+
+BEISPIEL
+ mapping m = ([ "foo":1;2;3, "bar":4;5;6 ])
+
+ m_reallocate(m, 1) --> liefert ([ "foo":1, "bar:4 ])
+ m_reallocate(m, 4) --> liefert ([ "foo":1;2;3;0, "bar:4;5;6;0 ])
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6, auf Vorschlag von TubMud.
+
+SIEHE AUCH
+ m_allocate(E), m_values(E), widthof(E)
diff --git a/doc/efun/m_values b/doc/efun/m_values
new file mode 100644
index 0000000..4b94154
--- /dev/null
+++ b/doc/efun/m_values
@@ -0,0 +1,14 @@
+SYNOPSIS:
+ mixed *m_values(mapping map)
+ mixed *m_values(mapping map, int index)
+
+DESCRIPTION:
+ If index is 0 or not given, return an array with the first values of
+ mapping 'map'.
+ For values of index >0, return an array with the corresponding higher
+ values of mapping 'map', i.e. m_values(map,2) returns the third
+ values.
+
+SEE ALSO:
+ mappingp(E), mkmapping(E), m_indices(E), m_delete(E),
+ sizeof(E), widthof(E), mappings(LPC)
diff --git a/doc/efun/make_shared_string b/doc/efun/make_shared_string
new file mode 100644
index 0000000..3bb6732
--- /dev/null
+++ b/doc/efun/make_shared_string
@@ -0,0 +1,24 @@
+VERALTET
+SYNOPSIS
+ string make_shared_string (string str);
+
+BESCHREIBUNG
+ Fuegt <str> in die Tabelle der gemeinsam verwendeten String des Spiels
+ ein.
+
+ Wenn ein String von mehreren Variablen / Objekten verwendet wird,
+ spart dies Speicher. Keys von Alists und Mappings sind immer gemeinsam
+ verwendete Strings.
+
+ In LDMud 3.3 ist diese Funktion nicht laenger nuetzlich: Strings
+ werden sowieso so weit wie moeglich gemeinsam verwendet, und der
+ Driver wandelt untablierte Strings nach einiger Zeit automatisch in
+ tablierte Strings um um
+
+BUGS
+ Ein besseres Stringhandling im Driver sollte diese Efun ueberfluessig
+ machen.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6, auf Vorschlag von TubMud.
+ Veraltet seit LDMud 3.3 .
diff --git a/doc/efun/map b/doc/efun/map
new file mode 100644
index 0000000..808f065
--- /dev/null
+++ b/doc/efun/map
@@ -0,0 +1,93 @@
+SYNOPSIS
+ mixed * map(mixed *arg, string func, string|object ob, mixed extra...)
+ mixed * map(mixed *arg, closure cl, mixed extra...)
+ mixed * map(mixed *arg, mapping m [, int idx])
+
+ mixed * map(struct arg, string func, string|object ob, mixed extra...)
+ mixed * map(struct arg, closure cl, mixed extra...)
+ mixed * map(struct arg, mapping m [, int idx])
+
+ mapping map(mapping arg, string func, string|object ob, mixed extra...)
+ mapping map(mapping arg, closure cl, mixed extra...)
+
+ string map(string arg, string func, string|object ob, mixed extra...)
+ string map(string arg, closure cl, mixed extra...)
+ string map(string arg, mapping m [, int idx])
+
+BESCHREIBUNG
+ Ruft die Funktion <ob>-><func>() bzw. die Closure <cl> fuer jedes
+ Element des Strings, Arrays, Mappings oder der Struktur <arg> auf
+ und liefert ein Resultat, das aus den verschiedenen Rueckgabewerten
+ erstellt wurde.
+
+ Wurde <ob> nicht angegeben, oder ist es weder ein String noch ein
+ Objekt, wird stattdessen this_object() verwendet.
+
+ Ist <arg> ein Array, ein String oder eine Struktur, wird die Funktion
+ mit jedem Element des Arrays als erstem Parameter aufgerufen, gefolgt
+ von den <extra> Argumenten. Das Resultat der Efun ist ein Array, das
+ die Rueckgabewerte der Funktionsaufrufe enthaelt. Man koennte die
+ Operation map() deshalb umschreiben als:
+
+ foreach(index) result[index] = ob->func(arg[index], extra...)
+
+ Ist <arg> ein Array, ein String oder eine Struktur, und wurde statt
+ einer Funktion ein Mapping angegeben, so liefert map() ein Array mit
+ den Werten, die im Mapping an Stelle der urspruenglichen Werte stehen,
+ bzw. mit den Originalwerten, wenn fuer sie kein Mappingeintrag
+ existiert. Ist <idx> angegeben, so wird die entsprechende Spalte des
+ Mappings verwendet. Mit anderen Worten:
+
+ foreach(index)
+ if (arg[index] ist ein Key in <arg>)
+ result[index] = map[arg[index]] oder map[arg[index]]
+ else
+ result[index] = arg[index]
+
+ Ist <arg> ein Mapping, wird die Funktion fuer jeden Key des Mappings
+ als erstem Parameter und den Datenwerten (sofern vorhanden) als
+ zusaetzliche Argumente aufgerufen, gefolgt von den <extra> Argumenten.
+ Die <extra> Argumente duerfen keine geschuetzten Referenzen enthalten
+ (wie z.B. &(i[0])). Das Ergebnis der Efun ist ein Mapping, das die
+ Resultate der Funktionsaufrufe als Zuordnung zum jeweiligen Key
+ enthaelt.
+
+ Abhaengig von der Breite des Mappings <arg>, kann die Operation
+ umschrieben werden als:
+
+ foreach (key in arg)
+ switch (widthof(arg))
+ case 0:
+ result[key] = ob->func(key, 0, extra...)
+ case 1:
+ result[key] = ob->func(key, arg[key], extra...)
+ else :
+ result[key] = ob->func( key
+ , ({ arg[key,0] ...arg[key,width-1] })
+ , extra...)
+
+ Der Vorteil dieses Ansatzes ist, dass beide Arten von mehrdimensionalen
+ Mappings (Mappings mit mehreren Werten pro Key und Mappings von Arrays)
+ gleich behandelt werden koennen.
+
+BEISPIELE
+ arr = ({ 1, 2, 3, 4 });
+ m = ([ 1:-1, 3:-3 ]);
+
+ map(arr, #'%, 2) --> liefert ({ 1, 0, 1, 0 })
+ map(arr, m) --> liefert ([ -1, 2, -3, 4 })
+
+ANMERKUNGEN
+ map() auf Arrays angewandt verhaelt sich wie map_array(), auf Mappings
+ angewandt hingegen verhaelt es sich wie eine Verallgemeinerung von
+ map_indices().
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.2.6, loest map_array() ab.
+ LDMud 3.2.8 fuehrt neu die Moeglichkeit ein, ein Array durch ein
+ Mapping zu mappen.
+ LDMud 3.3.439 fuehrt map() fuer Strings ein.
+ LDMud 3.3.719 fuehrt den <idx>-Parameter fuer mappen mit Mappings ein.
+
+SIEHE AUCH
+ filter(E), filter_indices(E), map_indices(E), map_objects(E)
diff --git a/doc/efun/map_indices b/doc/efun/map_indices
new file mode 100644
index 0000000..de3b15f
--- /dev/null
+++ b/doc/efun/map_indices
@@ -0,0 +1,75 @@
+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
new file mode 100644
index 0000000..4543a2e
--- /dev/null
+++ b/doc/efun/map_objects
@@ -0,0 +1,51 @@
+map_objects(E)
+
+FUNKTION:
+ object *map_objects(object *arr, string fun [, mixed extra])
+
+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
diff --git a/doc/efun/mappingp b/doc/efun/mappingp
new file mode 100644
index 0000000..fef2ac7
--- /dev/null
+++ b/doc/efun/mappingp
@@ -0,0 +1,9 @@
+SYNOPSIS:
+ int mappingp(mixed arg)
+
+DESCRIPTION:
+ Return 1 if the argument is a mapping, or 0 if it is not.
+
+SEE ALSO:
+ intp(E), stringp(E), objectp(E), pointerp(E), mkmapping(E),
+ m_indices(E), m_values(E), m_delete(E), sizeof(E)
diff --git a/doc/efun/master b/doc/efun/master
new file mode 100644
index 0000000..cdf55b6
--- /dev/null
+++ b/doc/efun/master
@@ -0,0 +1,17 @@
+SYNOPSIS
+ object master();
+ object master(int dont_load);
+
+BESCHREIBUNG
+ Die Funktion liefert das Masterobjekt.
+
+ Wenn <dont_load> nicht wahr ist, stellt master() zuerst sicher, dass
+ das Masterobjekt auf existiert. Wenn <dont_load> wahr ist, liefert
+ master() nur das Masterobjekt oder 0, falls das aktuelle Masterobjekt
+ zerstoert wurde.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.10
+
+SIEHE AUCH
+ master(M)
diff --git a/doc/efun/match_command b/doc/efun/match_command
new file mode 100644
index 0000000..cd495d7
--- /dev/null
+++ b/doc/efun/match_command
@@ -0,0 +1,27 @@
+SYNOPSIS
+ #include <sys/commands.h>
+
+ mixed * match_command (string command, object origin)
+
+DESCRIPTION
+ Take the command <command>, parse it, and return an array of all
+ matching actions added to <origin> (read: <origin> is the object
+ 'issuing' the command).
+
+ Each entry in the result array is itself an array of:
+
+ string [CMDM_VERB]: The matched verb.
+ string [CMDM_ARG]: The argument string remaining, or 0 if none.
+ object [CMDM_OBJECT]: The object defining the action.
+ string [CMDM_FUN]: The name of the function to call in
+ CMDM_OBJECT, which may be static.
+
+ The efun is useful for both debugging, and for implementing your
+ own H_COMMAND handling.
+
+HISTORY
+ Introduced in LDMud 3.3.259.
+
+SEE ALSO
+ hooks(C), execute_command(E), command(E), notify_fail(E),
+ command_stack(E)
diff --git a/doc/efun/max b/doc/efun/max
new file mode 100644
index 0000000..189f4a5
--- /dev/null
+++ b/doc/efun/max
@@ -0,0 +1,23 @@
+SYNOPSIS
+ string max(string arg, ...);
+ string max(string *arg);
+
+ int|float max(int|float arg, ...);
+ int|float max(int|float *arg);
+
+BESCHREIBUNG
+ Die Funktion liefert den groessten Wert aller <arg> und liefert ihn
+ zurueck. Wird max() nur mit einem Array aufgerufen wird (das nicht
+ leer sein darf), liefert die Funktion das groesste Element aus <arg>.
+
+BEISPIEL
+ max(1) - liefert 1
+ max(1, 1.1) - liefert 1.1
+ max("foo", "bar") - liefert "foo"
+ max( ({ "foo", "bar" }) ) - liefert "foo"
+
+AENDERUNGEN
+ Eingefuehrt in LDMued 3.2.9.
+
+SIEHE AUCH
+ min(E)
diff --git a/doc/efun/md5_crypt b/doc/efun/md5_crypt
new file mode 100644
index 0000000..d91ba18
--- /dev/null
+++ b/doc/efun/md5_crypt
@@ -0,0 +1,20 @@
+SYNOPSIS
+ string md5_crypt(string str, int seed)
+ string md5_crypt(string str, string seed)
+
+BESCHREIBUNG
+ Verschluesselt den String <str> mit dem Schluessel <seed>.
+ <seed> kann entweder ein Integer sein oder zwei Zeichen aus
+ dem String <seed>. Wenn <seed> 0 ist, wird ein zufaelliger
+ Schluessel erzeugt.
+
+ Das Resultat enthaelt den Schluessel als die ersten beiden Zeichen.
+
+ Die Efun verwendet den MD5-Algorithmus, und das Resultat ist
+ kompatible mit der Passwordverschluesselung des Apache Webservers.
+
+ Fuer Passwortabfragen, die ohne Echo eingegeben werden koennen sollen,
+ bietet input_to() ein spezielles Flag.
+
+SIEHE AUCH
+ crypt(E), md5(E), sha1(E), input_to(E)
diff --git a/doc/efun/member b/doc/efun/member
new file mode 100644
index 0000000..9f0e66a
--- /dev/null
+++ b/doc/efun/member
@@ -0,0 +1,24 @@
+SYNOPSIS
+ int member(mixed *array, mixed elem [, int start]);
+ int member(string s, int elem [, int start]);
+ int member(mapping map, mixed key);
+
+BESCHREIBUNG
+ Fuer Arrays und String liefert member() den Index des ersten
+ Auftretens von <elem> in <arg>. Ist <elem> nicht in <arg> enthalten,
+ wird -1 zurueck gegeben.
+
+ Ist <start> als Zahl >= 0 gegeben, beginnt die Suche ab der
+ angegebenen Position. Eine Startposition groesser als die
+ Laenge des Strings/Arrays liefert stets das Resultat -1.
+
+ Fuer Mapping prueft member(), ob <key> in <map> enthalten ist und
+ liefert 1 zurueck falls ja, 0 sonst.
+
+BEISPIELE
+ member( ({ "abc", "defg" }), "defg" ) = 1
+ member( ({ "abc", "defg" }), "x" ) = -1
+ member( "abcdefg", 100 ) = member( "abcdefg", 'd' ) = 3
+
+SIEHE AUCH
+ rmember(E), mappings(LPC)
\ No newline at end of file
diff --git a/doc/efun/min b/doc/efun/min
new file mode 100644
index 0000000..c11f9b5
--- /dev/null
+++ b/doc/efun/min
@@ -0,0 +1,22 @@
+SYNOPSIS
+ string min(string arg, ... );
+ string min(string *arg_array);
+ int|float min(int|float arg, ...);
+ int|flaot min(int|float *arg_array);
+
+BESCHREIBUNG
+ Liefert das kleinste der Argumente <arg>. Wenn min() fuer ein
+ einzelnes (nicht leeres) Array aufgerufen wird, liefert min() das
+ kleinste Element im Array.
+
+BEISPIEL
+ min(1) -> liefert 1
+ min(1, -1.1) -> liefert -1.1
+ min("bla", "fasel") -> liefert "bla"
+ min( ({ "bla", "fasel" }) ) -> liefert "bla"
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ max(E)
diff --git a/doc/efun/mkdir b/doc/efun/mkdir
new file mode 100644
index 0000000..8c7a683
--- /dev/null
+++ b/doc/efun/mkdir
@@ -0,0 +1,9 @@
+SYNOPSIS
+ int mkdir(string path);
+
+BESCHREIBUNG
+ Erstellt ein Verzeichnis <path> und liefert 1, wenn das Verzeichnis
+ erstellt werden konnte, sonst 0.
+
+SIEHE AUCH
+ rmdir(E), rm(E), get_dir(E), file_size(E)
diff --git a/doc/efun/mkmapping b/doc/efun/mkmapping
new file mode 100644
index 0000000..75cf827
--- /dev/null
+++ b/doc/efun/mkmapping
@@ -0,0 +1,37 @@
+SYNOPSIS
+ mapping mkmapping(mixed *arr1, mixed *arr2, mixed *arr3, ...);
+ mapping mkmapping(struct st);
+
+BESCHREIBUNG
+ Liefert ein Mapping mit Keys aus <arr1> und Datenelementen aus
+ <arr2>, <arr3>.... Dem Key <arr1[0]> werden die Datenelemente
+ <arr2[0]>, <arr3[0]>... zugeordnet. Wenn die Datenarrays
+ ungleich gross sind, enthaelt das Mapping nur so viele Eintraege,
+ wie im kleinsten Datenarray enthalten sind.
+
+ Die zweite Form konvertiert die angegebene struct <st> in ein Mapping.
+ Hierbei werden die Namen des jeweiligen Elementes in der struct als
+ als Schluessel.
+
+ Gewoehnlich werden Mappings erweitert, indem einfach neue Elemente
+ eingefuegt werden. Diese Funktion ist nuetzlich, wenn der
+ ungefaehr benoetigte Speicherplatz bereits vorher bekannt ist,
+ um so den Overhead bei der Speicherallokation zu minimieren.
+ Allenfalls zu viel allozierter Speicher wird freigegeben, sobald
+ die Funktion, die die mkmapping() Anweisung enthaelt, beendet ist.
+
+BESIPIEL
+ mkmapping( ({ 1, 2 }), ({ 10, 11 }), ({ 20, 21, 22}));
+ liefert ([ 1:10;20, 2:11;21 ])
+
+ struct s { int a, b, c; };
+ mkmapping( (<s> 1, ({ 2, 3 }), 3 )
+ liefert ([ "a":1, "b":({2,3}), "c":3 ])
+
+AeNDERUNGEN
+ LDMud 3.3.433 ermoeglichte die Konversion von structs.
+
+VERGLEICHE
+ mappings(LPC), mappingp(E), m_indices(E), m_values(E),
+ m_add(E), m_delete(E), sizeof(E), widthof(E), unmkmapping(E),
+ to_struct(E)
diff --git a/doc/efun/mktime b/doc/efun/mktime
new file mode 100644
index 0000000..b71227b
--- /dev/null
+++ b/doc/efun/mktime
@@ -0,0 +1,38 @@
+SYNOPSIS
+ #include <sys/time.h>
+
+ int mktime(int *ts);
+
+BESCHREIBUNG
+ Ist das Argument <ts> ein Array mit 9 Elementen (int), entsprechend
+ des Rueckgabewertes von local_time()/gm_time(), liefert die Funktion
+ die Anzahl Sekunden seit dem 01. Januar 1970, 00:00:00 zurueck.
+ Dies ist von Nutzen, wenn man ein Datum/Uhrzeit hat, diese aber als
+ Ganzzahl-Wert speichern will oder eine Zeitdifferenz zwischen zwei
+ Daten ausrechnen will.
+
+ Das Array muss dabei so aufgebaut sein:
+ int TM_SEC (0): Sekunde in der Minute (0..59)
+ int TM_MIN (1): Minute in der Stunde (0..59)
+ int TM_HOUR (2): Stunde des Tages (0..23)
+ int TM_MDAY (3): Tag im Monat (1..31)
+ int TM_MON (4): Monat des Jahres (0..11)
+ int TM_YEAR (5): Jahr (z.B. 2001)
+ int TM_WDAY (6): Wochentag (0..6, Sonntag = 0)
+ int TM_YDAY (7): Tag im Jahr (0..365)
+ inz TM_ISDST (8): TRUE: Daylight Saving Time
+
+ TM_YDAY und TM_WDAY werden ignoriert und koennen beliebige Zahlen
+ enthalten.
+
+BEISPIEL
+ Man hat ein Datum/Uhrzeit (z.B. Benutzereingabe), welches als
+ Unix-Zeitstmepel gespeichert werden soll:
+ // "Mit, 24. Okt 2007, 10:48:00" entspricht folgendem Zeitstempel:
+ int unixzeit = mktime( ({0, 48, 09, 24, 09, 2007, 0, 01, 0}) );
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.3.71x
+
+SIEHE AUCH
+ ctime(E), gmtime(E), local_time(E), time(E), utime(E)
diff --git a/doc/efun/modify_command b/doc/efun/modify_command
new file mode 100644
index 0000000..eea6070
--- /dev/null
+++ b/doc/efun/modify_command
@@ -0,0 +1,21 @@
+SYNOPSIS
+ int|string modify_command(string cmd)
+
+DESCRIPTION
+ After set_modify_command(mob) was called for an interactive
+ object iob, all commands for that user will be passed to
+ mob->modify_command(), and the return will then be checked for
+ actions.
+
+ If the result is a string, it is the new command to execute
+ instead of the given one. Note that it is not possible to
+ make several commands from one this way!
+ If the result is a non-zero number, the given command is to
+ be ignored. In case of the closure/lfun setting this may
+ mean that the closure/lfun already executed it.
+ If the result is 0, the originally given command is to be
+ used.
+
+
+SEE ALSO
+ set_modify_command(E), hooks(C)
diff --git a/doc/efun/move_object b/doc/efun/move_object
new file mode 100644
index 0000000..48b23e9
--- /dev/null
+++ b/doc/efun/move_object
@@ -0,0 +1,18 @@
+SYNOPSIS:
+ void move_object(mixed item, mixed dest)
+
+ item->move(object dest, string methods)
+
+DESCRIPTION:
+ The item, which can be a object_name or an object, is moved into
+ it's new environment dest, which can also be object_name or an
+ object. In native mode, the only object that can be moved
+ with move_object() is the calling object itself. This function
+ is only used to implement the lfun move().
+
+ Use the lfun move() instead by inheriting standard objects.
+ move() must be called in the object to be moved. This gives
+ the moved object full control over its movement.
+
+SEE ALSO:
+ move(L), remove(L), init(L), transfer(E), native(C)
diff --git a/doc/efun/negate b/doc/efun/negate
new file mode 100644
index 0000000..b1f0bdf
--- /dev/null
+++ b/doc/efun/negate
@@ -0,0 +1,6 @@
+SYNOPSIS
+ int negate(int arg);
+ float negate(float arg);
+
+BESCHREIBUNG
+ Liefert den negativen Wert von <arg>.
diff --git a/doc/efun/net_connect b/doc/efun/net_connect
new file mode 100644
index 0000000..f3aae2f
--- /dev/null
+++ b/doc/efun/net_connect
@@ -0,0 +1,30 @@
+SYNOPSIS
+ int net_connect(string host, int port)
+
+BESCHREIBUNG
+ Oeffne eine nicht-blockierende TCP Netzverbindung zu
+ <host>:<port> . Bei Erfolg wird die Verbindung zum
+ aufrufenden Objekt gebunden und die lfun logon() wird in dem
+ Objekt aufgerufen.
+
+ Resultat ist 0 bei Erfolg, und eine Unix ERRNO bei Misserfolg.
+
+ Ist der Driver fuer IPv6 konfiguriert, wird <host> erst als
+ IPv6-Name interpretiert, und wenn das fehlschlaegt, als
+ IPv4-Name.
+
+ Wenn die Verbindung nicht sofort erzeugt werden kann, gibt die
+ Funktion 'Erfolg' zurueck, und der Driver vollendet die
+ Funktion im Hintergrund. Sollte die Verbindungsaufbau im
+ Hintergrund fehlschlagen, wird logon(-1) im aktuellen Objekt
+ aufgerufen.
+
+ Die Funktion erzeugt eine privilege violation ("net_connect",
+ host, port).
+
+ WARNUNG: Ist <host> ein Name und keine IP, fuehrt die Funktion
+ einen DNS-Aufruf durch, der den Driver fuer einige Zeit
+ blockieren kann.
+
+SIEHE AUCH
+ logon(A)
diff --git a/doc/efun/next_bit b/doc/efun/next_bit
new file mode 100644
index 0000000..31fb90a
--- /dev/null
+++ b/doc/efun/next_bit
@@ -0,0 +1,32 @@
+SYNOPSIS
+ int next_bit(string str, int start);
+ int next_bit(string str, int start, int find_cleared);
+
+BESCHREIBUNG
+ Liefert den Zahlenwert des naechsten Bits im Bitstring <bit> nach
+ der Position <start>. Gewoehnlich ist dies das naechste gesetzte
+ Bit, aber wenn <find_cleared> angegeben und nicht 0 ist, wird
+ die Postion des naechsten geloeschten Bits zurueck gegeben.
+
+ Dabei ist das Finden von geloeschten Bits nach dem letzten gesetzten
+ Bit auf die tatsaechliche Laenge von <str> beschraenkt.
+
+ Jedes Zeichen enthaelt 6 Bits. In jedem Zeichen kann deshalb eine
+ Zahl von 0 bis 63 gespeichert werde (2^6=64). Das erste Zeichen
+ ist der Leerschlag " " mit dem Wert 0. Das erste Zeichen im String
+ ist jenes mit den niedrigsten Bits (0-5).
+
+BEISPIEL
+ string s;
+ int p;
+
+ s = set_bit("", 4); s = set_bit(s, 2);
+
+ for (p = -1; -1 != (p = next_bit(s, p); )
+ write(p+"\n");
+
+ --> das gibt 2 und 4 aus.
+
+SIEHE AUCH
+ set_bit(E), clear_bit(E), test_bit(E), last_bit(E), count_bits(E),
+ and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/next_inventory b/doc/efun/next_inventory
new file mode 100644
index 0000000..61370a0
--- /dev/null
+++ b/doc/efun/next_inventory
@@ -0,0 +1,17 @@
+SYNOPSIS
+ object next_inventory();
+ object next_inventory(object ob);
+
+BESCHREIBUNG
+ Liefert das naechste Objekt aus dem Inventar von <ob>. Wird <ob>
+ nicht angegeben, wird this_object() verwendet.
+
+ Diese Efun wird meistens zusammen mit first_inventory() verwendet
+ um ueber Raum- und Containerinhalte zu iterieren.
+ Fuer ein Beispiel siehe dort.
+
+SIEHE AUCH
+ first_inventory(E), all_inventory(E), environment(E),
+ deep_inventory(E)
+
+7.Aug 2007 Gloinson
\ No newline at end of file
diff --git a/doc/efun/object_info b/doc/efun/object_info
new file mode 100644
index 0000000..4a773fc
--- /dev/null
+++ b/doc/efun/object_info
@@ -0,0 +1,202 @@
+SYNOPSIS
+ #include <object_info.h>
+
+ mixed object_info(object ob, int what)
+
+DESCRIPTION
+ Returns some internal information about object <ob>. The
+ Argument <what> determines which information is returned.
+
+ It can be either a configuration option as given to
+ configure_object() or one of the following options:
+
+
+
+ Object Flags:
+
+ <what> == OI_ONCE_INTERACTIVE:
+ 1 if <ob> was once (or still is) interactive, 0 else.
+
+ <what> == OI_RESET_STATE:
+ 1 if <ob> is (still) reset, 0 else.
+
+ <what> == OI_WILL_CLEAN_UP:
+ 1 if <ob>'s clean_up() will be called, 0 else.
+
+ <what> == OI_LAMBDA_REFERENCED:
+ 1 if <ob> has lambdas (and there replace_program()
+ is not allowed anymore), 0 else.
+
+ <what> == OI_REPLACED:
+ 1 if the program for <ob> was replaced, 0 else.
+
+
+
+ Program Flags:
+
+ <what> == OI_NO_INHERIT:
+ 1 if the program can't be inherited.
+
+ <what> == OI_NO_CLONE:
+ 1 if the program/blueprint can't be cloned.
+
+ <what> == OI_NO_SHADOW:
+ 1 if the program's functions can't be shadowed.
+
+ <what> == OI_SHARE_VARIABLES:
+ 1 if clones of this program share their initial
+ variable values with the blueprint.
+
+
+
+ Swapping Information:
+
+ <what> == OI_SWAPPED:
+ 1 if <ob> is swapped, 0 else.
+
+ <what> == OI_PROG_SWAPPED:
+ 1 if <ob>'s program is swapped, 0 else.
+
+ <what> == OI_VAR_SWAPPED:
+ 1 if <ob>'s variables are swapped, 0 else.
+
+ <what> == OI_SWAP_NUM:
+ The swap number for <ob>s program, or -1 if not swapped.
+
+
+
+ Time Information:
+
+ <what> == OI_NEXT_RESET_TIME:
+ Time of the next reset.
+
+ <what> == OI_NEXT_CLEANUP_TIME:
+ Time of the next data cleanup.
+
+ <what> == OI_LAST_REF_TIME:
+ Time of the last call to <ob>.
+
+
+
+ Object List:
+
+ <what> == OI_OBJECT_NEXT:
+ The next object in the global object list.
+
+ <what> == OI_OBJECT_PREV:
+ The previous object in the global object list.
+
+ <what> == OI_OBJECT_POS:
+ The position of <ob> in the global object list,
+ counting from 0 up. This can be expensive to compute.
+
+
+
+ Shadows:
+
+ <what> == OI_SHADOW_NEXT:
+ The next object in the shadow list, i.e. the object
+ that is shadowing <ob>, or 0 if <ob> is not shadowed.
+
+ <what> == OI_SHADOW_PREV:
+ The previous object in the shadow list, i.e. the object
+ that <ob> is currently shadowing, or 0 if <ob> is not a shadow.
+
+ <what> == OI_SHADOW_ALL:
+ Returns an array of all objects that are currently
+ shadowing <ob>, or an empty array if <ob> is not shadowed.
+
+
+
+ Object Statistics:
+
+ <what> == OI_OBJECT_REFS:
+ The number of references to <ob>.
+
+ <what> == OI_TICKS:
+ The accumulated evaluation cost spend in <ob> modulo 1000000000.
+
+ <what> == OI_GIGATICKS:
+ The accumulated evaluation cost spend in <ob> divided by 1000000000.
+
+ <what> == OI_DATA_SIZE:
+ The total size of the values held in the object's variables,
+ scaled down according to the extend of data sharing.
+
+ <what> == OI_DATA_SIZE_TOTAL:
+ The unmodified total size of the values held in the
+ object's variables
+
+
+
+ Program Statistics:
+
+ <what> == OI_PROG_REFS:
+ The number of references to <ob>'s program.
+
+ <what> == OI_NUM_FUNCTIONS:
+ The number of functions in the program.
+
+ <what> == OI_NUM_VARIABLES:
+ The number of variables in the program.
+
+ <what> == OI_NUM_STRINGS:
+ The number of strings in the program.
+
+ <what> == OI_NUM_INHERITED:
+ The number of explicitely inherited programs.
+
+ <what> == OI_NUM_INCLUDED:
+ The number of included files in the program.
+
+ <what> == OI_SIZE_FUNCTIONS:
+ The size needed for the function structures.
+ Note that this does not include size of the function code.
+
+ <what> == OI_SIZE_VARIABLES:
+ The size needed for the variable structures.
+ Note that this does not include size of the variable data,
+ See OI_DATA_SIZE/OI_DATA_SIZE_TOTAL for that.
+
+ <what> == OI_SIZE_STRINGS:
+ The size needed for the string pointers.
+
+ <what> == OI_SIZE_STRINGS_DATA:
+ The size needed for the string values,
+ scaled down according to the extend of data sharing.
+
+ <what> == OI_SIZE_STRINGS_DATA_TOTAL:
+ The unmodified size needed for the string values.
+
+ <what> == OI_SIZE_INHERITED:
+ The size needed for the inherit structures.
+
+ <what> == OI_SIZE_INCLUDED:
+ The size needed for the include structures.
+
+ <what> == OI_PROG_SIZE:
+ The size of the program structure.
+
+ <what> == OI_PROG_SIZE_TOTAL:
+ The total size of the program.
+
+
+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.
+ LDMud 3.5.0 redesigned the whole efun.
+
+SEE ALSO
+ configure_object(E), interactive_info(E), driver_info(E)
diff --git a/doc/efun/object_name b/doc/efun/object_name
new file mode 100644
index 0000000..6ba82ed
--- /dev/null
+++ b/doc/efun/object_name
@@ -0,0 +1,26 @@
+SYNOPSIS:
+ string object_name()
+ string object_name(object ob)
+
+DESCRIPTION:
+ Get the file name of an object or if no argument is given of the current
+ object. If the object is a cloned object, then it will not have a
+ corresponding file name, but rather a new name based on the original
+ file name.
+
+ The returned name always begins with '/' (absolute path),
+ except when the parser runs in COMPAT (-o) mode.
+
+EXAMPLES:
+ find_object(object_name(ob)) == ob
+ This is guaranteed to be true for all objects ob that are not
+ destructed.
+
+ sizeof(explode(object_name(ob), "#")) == 1
+ This is always true if ob is a blue print.
+
+SEE ALSO:
+ find_object(E)
+
+29.10.2006 Zesstra
+
diff --git a/doc/efun/object_time b/doc/efun/object_time
new file mode 100644
index 0000000..db4d91c
--- /dev/null
+++ b/doc/efun/object_time
@@ -0,0 +1,10 @@
+SYNOPSIS
+ int object_time();
+ int object_time(object ob);
+
+BESCHREIBUNG
+ Liefert die Zeit, zu der das Objekt <ob> erstellt wurde. Wird <obj>
+ nicht angegeben, wird standardmaessig this_object() verwendet.
+
+SIEHE AUCH
+ program_time(E), program_name(E)
diff --git a/doc/efun/objectp b/doc/efun/objectp
new file mode 100644
index 0000000..2b0758c
--- /dev/null
+++ b/doc/efun/objectp
@@ -0,0 +1,9 @@
+SYNOPSIS
+ int objectp(mixed arg);
+
+BESCHREIBUNG
+ Liefert 1, wenn <arg> ein Objekt ist.
+
+SIEHE AUCH
+ clonep(E), intp(E), stringp(E), pointerp(E), symbolp(E),
+ referencep(E), symbolp(E)
diff --git a/doc/efun/or_bits b/doc/efun/or_bits
new file mode 100644
index 0000000..25406e4
--- /dev/null
+++ b/doc/efun/or_bits
@@ -0,0 +1,27 @@
+SYNOPSIS
+ string or_bits(string str1, string str2);
+
+BESCHREIBUNG
+ <str1> und <str2> sind beides Bitstrings. Das Resultat von or_bits()
+ ist ein Bitstring, der das binaere Oder von <str1> und <str2>
+ enthaelt, d.h. ein String, in dem ein Bit gesetzt ist, wenn es
+ in <str1> oder <str2> oder in beiden gesetzt ist.
+
+ Jedes Zeichen enthaelt 6 Bits. In jedem Zeichen kann deshalb eine
+ Zahl von 0 bis 63 gespeichert werde (2^6=64). Das erste Zeichen
+ ist der Leerschlag " " mit dem Wert 0. Das erste Zeichen im String
+ ist jenes mit den niedrigsten Bits (0-5).
+
+BEISPIEL
+ string s1, s2, s3;
+
+ s1 = set_bit("", 3); s1 = set_bit(s1, 15); -> s1 is "( ("
+ s2 = set_bit("", 3); s2 = set_bit(s2, 4); -> s2 is "8"
+
+ s3 = or_bits(s1, s2);
+
+ -> s3 is now "8 (", ie. a bitstring with bits 3, 4 and 15 set.
+
+SIEHE AUCH
+ clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E),
+ count_bits(E), and_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/parse_command b/doc/efun/parse_command
new file mode 100644
index 0000000..83b7731
--- /dev/null
+++ b/doc/efun/parse_command
@@ -0,0 +1,132 @@
+OPTIONAL
+SYNOPSIS
+ int parse_command (string cmd, object env, string fmt, mixed &var, ...)
+ int parse_command (string cmd, object* arr, string fmt, mixed &var, ...)
+
+DESCRIPTION
+ parse_command() is basically a spiffed up sscanf operating
+ on word basis and targeted at recognizing object descriptions from
+ command strings.
+
+ The efun takes the command string <cmd> and the object(s) <env>/<arr>
+ and tries to match it against the format string <fmt>. Successfully
+ matched elements are assigned to the variables <var>.... The result
+ from the efun is 1 if the command could be fully matched, and 0
+ otherwise.
+
+ If the objects are given as a single object <env>, the efun matches
+ against the given object and all objects contained therein. Otherwise,
+ if the objects are given as an array <arr> of objects, the efun
+ matches only against the given objects.
+
+ The format string <fmt> consists of words, syntactic markers, and
+ %-directives for the values to parse and return in the variables.
+ A typical example is " 'get' / 'take' %i " or
+ " 'spray' / 'paint' [paint] %i ". The elements in detail are:
+
+ 'word': obligatory text
+ [word]: optional text
+ / : Alternative marker
+ %o : Single item, object
+ %s : Any text
+ %w : Any word
+ %p : One of a list of prepositions.
+ If the variable associated with %p is used to pass
+ a list of words to the efun, the matching will take
+ only against this list.
+ %l : non-compat: Living objects
+ compat: a single living object
+ %i : Any objects
+ %d : Number >= 0, or when given textual: 0-99.
+
+ A <word> in this context is any sequence of characters not containing
+ a space. 'living objects' are searched by calls to the (simul)efuns
+ find_player() and find_living(): both functions have to accept a name
+ as argument and return the object for this name, or 0 if there
+ is none.
+
+ The results assigned to the variables by the %-directives are:
+
+ %o : returns an object
+ %s : returns a string of words
+ %w : returns a string of one word
+ %p : if passed empty: a string
+ if passed as array of words: var[0] is the matched word
+ %i : returns an array with the following content:
+ [0]: int: the count/number recognized in the object spec
+ > 0: a count (e.g. 'three', '4')
+ < 0: an ordinal (e.g. 'second', 'third')
+ = 0: 'all' or a generic plural such as 'apples'
+ [1..]: object: all(!) objects matching the item description.
+ In the <env> form this may be the whole
+ recursive inventory of the <env> object.
+ It is up to the caller to interpret the recognized numeral
+ and to apply it on the list of matched objects.
+ %l : non-compat: as %i, except that only living objects are
+ returned.
+ compat: as %o, except that only a living object is returned.
+
+ %i (and non-compat-%l) match descriptions like 'three red roses',
+ 'all nasty bugs' or 'second blue sword'.
+
+ Note: Patterns of type: "%s %w %i" might not work as one would expect.
+ %w will always succeed so the arg corresponding to %s will always be
+ empty.
+
+ To make the efun useful it must have a certain support from the
+ mudlib: it calls a set of functions in objects to get the
+ information it needs to parse a string.
+
+ 1. string *parse_command_id_list()
+ Normal singular names of the object.
+
+ 2. string *parse_command_plural_id_list() - optional
+ Plural forms of the names returned by 1.
+ If this function doesn't exist, the parser tries to pluralize
+ the names returned by 1.
+
+ 3. string *parse_command_adjectiv_id_list() - optional
+ All adjectives associated with this object.
+
+ All names and adjectives may consist of several words separated
+ by spaces.
+
+ These functions should exist in all objects and are therefore best
+ put into a mandatory inherit file (e.g. /std/object.c).
+
+ In addition the master object may offer the same functions to provide
+ reasonable defaults (like 'thing' as generic singular name):
+
+ string *parse_command_id_list()
+ - Would normally return: ({ "one", "thing" })
+
+ string *parse_command_plural_id_list()
+ - Would normally return: ({ "ones", "things", "them" })
+
+ string *parse_command_adjectiv_id_list()
+ - Would normally return ({ "iffish" })
+
+ Two additional functions in the master object provide the default
+ list of prepositions (needed for %p) and the single 'all' word:
+
+ string *parse_command_prepos_list()
+ - Would normally return: ({ "in", "on", "under", "behind",
+ "beside" })
+
+ string parse_command_all_word()
+ - Would normally return: "all"
+
+
+ int parse_command(string, object|object*, string, destargs...)
+
+
+EXAMPLE
+ object *items;
+ parse_command( "take apple",environment(this_player())
+ , " 'get' / 'take' %i ",items);
+
+HISTORY
+ LDMud 3.3.258 removed the compat-mode parse_command().
+
+SEE ALSO
+ sscanf(E)
diff --git a/doc/efun/people b/doc/efun/people
new file mode 100644
index 0000000..e04c3bf
--- /dev/null
+++ b/doc/efun/people
@@ -0,0 +1,8 @@
+void people()
+
+A function that will list all interactive players, and some info about them.
+This function is normally
+
+connected to the people command, that wizards have.
+
+THIS FUNCTION IS OBSOLETE. LOOK AT users() INSTEAD.
diff --git a/doc/efun/pg_close b/doc/efun/pg_close
new file mode 100644
index 0000000..af4f8f0
--- /dev/null
+++ b/doc/efun/pg_close
@@ -0,0 +1,19 @@
+OPTIONAL
+SYNOPSIS
+ void pg_close()
+
+DESCRIPTION
+ Close the database connection for the current object, if there is one.
+
+ The function is available only if the driver is compiled with
+ PostgreSQL support. In that case, __PGSQL__ is defined.
+
+ The efun triggers a privilege violation ("pgsql", "pg_close").
+
+HISTORY
+ Added in 3.3.445.
+ LDMud 3.3.640 added the privilege violation.
+
+SEE ALSO
+ pgsql(C), pg_connect(E), pg_conv_string(E), pg_query(E), pg_pending(E),
+ privilege_violation(M)
diff --git a/doc/efun/pg_connect b/doc/efun/pg_connect
new file mode 100644
index 0000000..a9d4d58
--- /dev/null
+++ b/doc/efun/pg_connect
@@ -0,0 +1,39 @@
+OPTIONAL
+SYNOPSIS
+ int pg_connect (string conn, string fun)
+ int pg_connect (string conn, string fun, string|object obj, mixed extra, ...)
+ int pg_connect (string conn, closure cl, mixed extra, ...)
+
+DESCRIPTION
+ Open a database connection as directed by <conn>, and assign the
+ callback function <fun>/<cl> with the optional <extra> parameters
+ to it.
+
+ The object holding the callback function becomes the controlling
+ object; obiously it is an error to assign more than one connection
+ to the same controlling object.
+
+ The <conn> string is in the format accepted by Postgres'
+ PQconnectStart() API functions. Pass an empty string to use the
+ default options, or a string holding the '<key>=<value>' options
+ separated by whitespace.
+
+ The most useful options are:
+ dbname: The database name
+ user: The user name to connect as.
+ password: Password to be used.
+
+ Return 0 on success, and -1 on failure.
+
+ The function is available only if the driver is compiled with
+ PostgreSQL support. In that case, __PGSQL__ is defined.
+
+ The efun triggers a privilege violation ("pgsql", "pg_connect").
+
+HISTORY
+ Added in 3.3.445.
+ LDMud 3.3.640 added the privilege violation.
+
+SEE ALSO
+ pgsql(C), pg_query(E), pg_pending(E), pg_conv_string(E), pg_close(E),
+ privilege_violation(M)
diff --git a/doc/efun/pg_conv_string b/doc/efun/pg_conv_string
new file mode 100644
index 0000000..d849d06
--- /dev/null
+++ b/doc/efun/pg_conv_string
@@ -0,0 +1,20 @@
+OPTIONAL
+SYNOPSIS
+ string pg_conv_string(string str)
+
+DESCRIPTION
+ Convert the string <str> into a string that is correctly interpretated
+ for usage as a string in pg_query(), e.g. ' is replaced with \' and so
+ on.
+
+ The function is available only if the driver is compiled with
+ PostgreSQL support. In that case, __PGSQL__ is defined.
+
+ The efun triggers a privilege violation ("pgsql", "pg_connect").
+
+HISTORY
+ Added in 3.3.708.
+
+SEE ALSO
+ pgsql(C), pg_query(E), pg_pending(E), pg_conv_string(E), pg_close(E),
+ privilege_violation(M)
diff --git a/doc/efun/pg_pending b/doc/efun/pg_pending
new file mode 100644
index 0000000..46a6dcc
--- /dev/null
+++ b/doc/efun/pg_pending
@@ -0,0 +1,22 @@
+OPTIONAL
+SYNOPSIS
+ int pg_pending ()
+ int pg_pending (object obj)
+
+DESCRIPTION
+ Return the number of pending queries for the connection on the given
+ object <obj> (default is the current object). The object has no
+ database connection, return -1.
+
+ The function is available only if the driver is compiled with
+ PostgreSQL support. In that case, __PGSQL__ is defined.
+
+ The efun triggers a privilege violation ("pgsql", "pg_pending").
+
+HISTORY
+ Added in 3.3.445.
+ LDMud 3.3.640 added the privilege violation.
+
+SEE ALSO
+ pgsql(C), pg_connect(E), pg_conv_string(E), pg_query(E), pg_close(E),
+ privilege_violation(M)
diff --git a/doc/efun/pg_query b/doc/efun/pg_query
new file mode 100644
index 0000000..d95f2cc
--- /dev/null
+++ b/doc/efun/pg_query
@@ -0,0 +1,28 @@
+OPTIONAL
+SYNOPSIS
+ #include <pgsql.h>
+
+ int pg_query (string query)
+ int pg_query (string query, int flags)
+
+DESCRIPTION
+ Queue a new query <query> to the database connection on the current
+ object. Return the unique id of the query. The query result itself
+ will be passed as argument to the callback function.
+
+ <flags> can be one of these values:
+ PG_RESULT_ARRAY: Pass the query result as array.
+ PG_RESULT_MAP: Pass the query result as mapping.
+
+ The function is available only if the driver is compiled with
+ PostgreSQL support. In that case, __PGSQL__ is defined.
+
+ The efun triggers a privilege violation ("pgsql", "pg_query").
+
+HISTORY
+ Added in 3.3.445.
+ LDMud 3.3.640 added the privilege violation.
+
+SEE ALSO
+ pgsql(C), pg_connect(E), pg_conv_string(E), pg_pending(E), pg_close(E),
+ privilege_violation(M)
diff --git a/doc/efun/pointerp b/doc/efun/pointerp
new file mode 100644
index 0000000..a6f2c2c
--- /dev/null
+++ b/doc/efun/pointerp
@@ -0,0 +1,9 @@
+SYNOPSIS
+ int pointerp(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument ein Feld (Array) ist, ansonsten 0.
+
+SIEHE AUCH
+ closurep(E), floatp(E), mappingp(E), objectp(E), intp(E),
+ referencep(E), stringp(E), symbolp(E), clonep(E)
diff --git a/doc/efun/pow b/doc/efun/pow
new file mode 100644
index 0000000..f0ff586
--- /dev/null
+++ b/doc/efun/pow
@@ -0,0 +1,16 @@
+SYNOPSIS
+ float pow(int|flaot base, int|flaot exp);
+
+BESCHREIBUNG
+ Die Potenzfunktion. Sie liefert das Resultat von "<base> hoch <exp>".
+
+BEISPIEL
+ pow(-2, 3) -> liefert -8.0
+ pow(8, 1.0/3.0) -> liefert 2.0
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+ LDMud 3.2.9. erlaubte neu Integer als Argumente.
+
+SIEHE AUCH
+ exp(E), log(E)
diff --git a/doc/efun/present b/doc/efun/present
new file mode 100644
index 0000000..7b7d8d3
--- /dev/null
+++ b/doc/efun/present
@@ -0,0 +1,84 @@
+SYNOPSIS
+ object present(string str)
+ object present(string str, int n)
+ object present(string str, object env)
+ object present(string str, int n, object env)
+
+ object present(object ob)
+ object present(object ob, object env)
+
+BESCHREIBUNG
+ Wenn ein Objekt mit der Id <str> sich im Inventar oder in der Umgebung
+ von this_object() befindet, wird es zurueck geliefert.
+
+ Ist das Argument <n> gegeben, wird das n-te Objekt mit Namen <id>
+ zurueck geliefert. Das heisst, der Driver fuehrt fuer alle Objekte
+ im Inventar und in der Umgebung von this_object() die Funktion
+ id(str) aus, bis ein Treffer erzielt wird (wenn ueberhaupt).
+
+ Ist <n> nicht gegeben, aber <str> hat die Form "<id> <n>" , wird
+ ebenfalls das n-te Objekt mit Namen <id> zurueckgeliefert.
+
+ Es ist: id(str) { return str == <name>; }
+
+ <str> kann auch ein Objekt (anstatt einem object_name()) sein, was den
+ Test schneller und einfacher macht.
+
+ Das Argument <env> ist optional. <env> gibt an, wo nach <str> gesucht
+ wird. Nur das Inventory von <env> wird durchsucht, nicht jedoch dessen
+ Umgebung. Oftmals wird fuer <env> this_player() gesetzt.
+
+
+ANMERKUNG
+ Diese efun kann u.U. _sehr_ teuer sein! Bitte schaut euch auf jeden
+ Fall auch die efun present_clone() an und schaut, ob die evtl. das
+ kann, was ihr machen wollt. present_clone() ist erheblich billiger.
+
+ Wenn die efun sowohl in this_object() als auch dessen Umgebung
+ sucht, werden, soweit es die Numerierung betrifft, die beiden
+ Umgebungen zusammenhaengend betrachtet.
+
+BEISPIELE
+ present("chest");
+ --> findet das erste 'chest' Objekt
+
+ present("chest 2");
+ --> findet das zweite 'chest' Objekt
+
+ present("chest 2", 1);
+ --> findet das erste 'chest 2' Objekt
+
+ Wenn sich eine "chest" im this_object() befindet, und zwei
+ ausserhalb:
+ present("chest", 1) -> findet die chest im Objekt
+ present("chest", 2) -> findet die erste chest ausserhalb
+ present("chest", 3) -> findet die zweite chest ausserhalb
+
+ Wenn ein Objekt die Forum "<id> <n>" in Verbindung mit einem selbst
+ ueber add_action() gesetzten Verb unterstuetzen soll (damit z. B.
+ "oeffne Kiste 3" funktioniert), kann das folgendermassen geloest
+ werden:
+
+ void init() { add_action("oeffne_kiste", "oeffne"); }
+
+ int oeffne_kiste(string str)
+ {
+ if(present(str) != this_object() )
+ {
+ return 0; /* nicht diese Kiste */
+ ...
+ }
+ }
+
+HISTORY
+ LDMud 3.2.11/3.3.610 fuehrte die (str, n)-Form ein.
+ LDMud 3.3.713 aenderte die Numerierung wenn sowohl Inventory
+ als auch Umgebung durchsucht werden. In der vorherigen
+ Implementierung wurde eine Numerierung auf beiden Umgebungen
+ einzeln angewandt, was zur Folge hatte, dass niedere Objekte
+ in der aeusseren Umgebung nicht gefunden werden koennten, da
+ sie von den Objekten in Inneren verdeckt wurden.
+
+SIEHE AUCH
+ move_object(E), environment(E), this_object(E), present_clone(E),
+ id(A), init(A)
diff --git a/doc/efun/present_clone b/doc/efun/present_clone
new file mode 100644
index 0000000..cd64488
--- /dev/null
+++ b/doc/efun/present_clone
@@ -0,0 +1,41 @@
+VORLAEUFIG
+SYNOPSIS
+ object present_clone(string str [, object env] );
+ object present_clone(object obj [, object env] );
+
+BESCHREIBUNG
+ Diese Efun durchsucht das Inventar von <env> nach einem Objekt mit
+ einem bestimmten Blueprint . Wird <env> nicht angegeben, wird in
+ this_object() gesucht. Der Blueprint kann entweder mit seinem Namen
+ <str> angegeben werden, oder als Blueprint des Objekts <obj>. Gesucht
+ wird in beiden Faellen aufgrund von load_name().
+ Wird kein passendes Objekt gefunden, liefert die Efun 0 zurueck.
+
+ Fuer Driver im Plain Modus beginnt der Name in jedem Fall mit '/', im
+ Compat Modus nicht.
+
+BEISPIELE
+ Angenommen, das Objekt <env> enthalte die Objekte /items/money#8,
+ /std/weapon#9, /std/weapon#12 und /obj/key in der angegeben
+ Reihenfolge.
+
+ +--------------------------------------------------+---------------+
+ | Funktion | Liefert |
+ +--------------------------------------------------+---------------+
+ | present_clone("/items/money", env) | /items/money#8|
+ | present_clone("/std/weapon#12", env) | /std/weapon#9 |
+ | present_clone(find_object("/items/money#1"), env)| /items/money#8|
+ | present_clone("/obj/key#18", env) | /obj/key |
+ +--------------------------------------------------+---------------+
+
+ Fuer Driver im Compat Modus liefert die Funktion keine '/' am Anfang.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2.7.
+
+ANMERKUNG
+ Im Unterschied zu present() sucht present_clone() niemals in der
+ Umgebung von <env>.
+
+SIEHE AUCH
+ load_name(E), present(E)
diff --git a/doc/efun/previous_object b/doc/efun/previous_object
new file mode 100644
index 0000000..6a712ad
--- /dev/null
+++ b/doc/efun/previous_object
@@ -0,0 +1,50 @@
+SYNOPSIS
+ object previous_object();
+ object previous_object(int i);
+
+BESCHREIBUNG
+ Liefert einen Pointer auf das letzte Objekt, das einen Aufruf (mittels
+ call_other(), funcall() etc.) auf das aktuelle Objekt this_object()
+ gemacht hat. Wenn dieses aufrufende Objekt inzwischen zerstoert wurde,
+ liefert previous_object() 0.
+ Bei einem Aufruf einer eigenen Funktion durch ein Objekt bleibt das
+ bisherige previous_object() unveraendert.
+
+ Wird das Argument <i> angegeben, so verfolgt previous_object() den
+ Aufruf <i> Stufen zurueck. Zum Beispiel liefert previous_object(1) das
+ aufrufende Objekt des aufrufenden Objekts. Fuer <i> muss gelten:
+ 0 <= i < call_stack_depth(). Ein Wert <i> < 0 liefert das erste
+ aufrufende Object zurueck.
+
+ Es gibt einen wichtigen Spezialfall: in Funktionen, die vom Gamedriver
+ auf Grund eines externen Ereignises aufgerufen wurden (zum Beispiel
+ Kommandi, die mit add_action() definiert wurden), liefert
+ previous_object() this_object(), previous_object(0) hingegen 0.
+
+BEISPIEL
+ int sicherheitscheck()
+ {
+ object prev;
+ if(!(prev=previous_object()));
+ else if(getuid(prev)!=getuid(this_object()));
+ else if(geteuid(prev)!=geteuid(this_object()));
+ else return 1;
+ return 0;
+ }
+ void sensible_funktion()
+ {
+ if(!sicherheitscheck())
+ return;
+ ...
+ }
+
+ Diese Funktion zeigt, wie man ueberpruefen kann, ob der letzte Aufruf
+ einer Funktion im aktuellen Objekt sicher war, oder ob die
+ Verarbeitung abgebrochen werden sollte.
+
+FEHLER
+ Werte von <i> < 0 werden wie <i> == 0 behandelt - dies ist historisch.
+
+SIEHE AUCH
+ call_other(E), this_object(E), this_player(E)
+ caller_stack(E), caller_stack_depth(E), extern_call(E)
\ No newline at end of file
diff --git a/doc/efun/printf b/doc/efun/printf
new file mode 100644
index 0000000..d58233b
--- /dev/null
+++ b/doc/efun/printf
@@ -0,0 +1,9 @@
+SYNOPSIS
+ void printf(string format, ...);
+
+BESCHREIBUNG
+ Eine Mischung aus sprintf() und write(). Gibt void zurueck und den
+ String an den Benutzer aus.
+
+SIEHE AUCH
+ sprintf(E), write(E), terminal_colour(E)
diff --git a/doc/efun/program_name b/doc/efun/program_name
new file mode 100644
index 0000000..44162d5
--- /dev/null
+++ b/doc/efun/program_name
@@ -0,0 +1,38 @@
+SYNOPSIS
+ string program_name()
+ string program_name(object obj)
+
+BESCHREIBUNG
+ Liefert den Name des Programms, aus dem <obj> kompiliert wurde.
+ Wenn <obj> nicht angegeben wird, wird standardmaessig this_object()
+ verwendet.
+
+ Der Name ist fuer Clones der Name des Files, aus dem der Blueprint
+ kompliert wurde. Der Name wechselt, wenn ein Objekt sein Programm
+ durch replace_program() aendert.
+
+ Fuer den Spezialfall, dass <obj> als 0 uebergeben wird, liefert
+ program_name() 0 zurueck.
+
+ Der Name endet immer mit '.c'. Er beginnt mit einem '/', wenn der
+ Driver sich nicht im Compat Modus befindet.
+
+BEISPIEL
+ object o;
+ o = clone_object("/std/dings");
+ write(program_name(o));
+
+ liefert:
+ --> "/std/dings.c", wenn der Driver nicht im Compat Modus laeuft.
+ --> "std/dings.c", wenn der Driver im Compat Modus laeuft.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6.
+ Seit 3.2.9 ist das Argument 0 erlaubt.
+
+ANMERKUNG
+ Die Efun swapt zum Programm, wenn dieses geswapt ist.
+
+SIEHE AUCH
+ clone_object(E), clonep(E), load_name(E), load_object(E),
+ object_name(E), replace_program(E)
diff --git a/doc/efun/program_time b/doc/efun/program_time
new file mode 100644
index 0000000..62a6297
--- /dev/null
+++ b/doc/efun/program_time
@@ -0,0 +1,17 @@
+SYNOPSIS
+ int program_time()
+ int program_time(object ob)
+
+DESCRIPTION
+ Returns the creation (compilation) time of the object's
+ program. In other words, this is the object_time() of
+ the blueprint.
+
+ Default is this_object(), if no arg is given.
+
+
+ CAVEAT: If the objects program is swapped out, this efun
+ swaps it back in.
+
+SEE ALSO
+ object_time(E), program_name(E)
diff --git a/doc/efun/query_actions b/doc/efun/query_actions
new file mode 100644
index 0000000..90acaba
--- /dev/null
+++ b/doc/efun/query_actions
@@ -0,0 +1,37 @@
+SYNOPSIS
+ #include <sys/commands.h>
+
+ mixed *query_actions(object|string ob, mixed mask_or_verb);
+
+BESCHREIBUNG
+ Das erste Argument von query_actions() ist entweder ein Objekt
+ oder der Dateiname eines Objekts. Das zweite Argument muss
+ entweder eine Bitmaske (ein Integer) oder ein String sein.
+
+ Ist das zweite Argument ein String, liefert query_actions() ein
+ Array mit Informationen ueber das Verb oder 0 zurueck, wenn
+ das lebendige Objekt <ob> das Verb nicht verwenden kann.
+
+ Wenn das zweite Argument ein Integer ist, liefert query_actions()
+ ein flaches Array mir den Informationen entsprechend der Bitmaske
+ zu allen Verben von <ob>.
+
+ QA_VERB ( 1): das Verb,
+ QA_TYPE ( 2): der Typ,
+ QA_SHORT_VERB ( 4): das short_verb,
+ QA_OBJECT ( 8): das Objekt,
+ QA_FUNCTION (16): die Funktion.
+
+ Der Typ ist ein Wert wie in <sent.h> (bzw. /sys/sent.h) definiert,
+ der vom Parser Quellcode geliefert wird.
+
+ SENT_PLAIN durch add_action(fun, cmd) hinzugefuegt
+ SENT_SHORT_VERB durch add_action(fun, cmd, 1) hinzugefuegt
+ SENT_NO_SPACE durch add_action(fun); add_xverb(cmd);
+ SENT_NO_VERB nur eine Funktion mit add_action(fun), ohne Verb
+ SENT_MARKER intern, ist nicht im Array enthalten
+ negativer Wert das Verb muss nur in den ersten -<wert> Zeichen
+ uebereinstimmen.
+
+SIEHE AUCH
+ add_action(E), init(A)
diff --git a/doc/efun/query_command b/doc/efun/query_command
new file mode 100644
index 0000000..bbabdbd
--- /dev/null
+++ b/doc/efun/query_command
@@ -0,0 +1,34 @@
+SYNOPSIS
+ string query_command();
+
+BESCHREIBUNG
+ Liefert den Text des aktuellen Kommandos oder 0, wenn keines
+ ausgefuehrt wird.
+
+ Der Text entspricht dem, was der Parser "sieht", also nachdem
+ modify_command() ausgefuehrt und nachfolgende Leerzeichen
+ abgeschnitten wurden.
+
+ query_command() liefert 0, wenn es von einer Funktion gestartet wurde,
+ die wiederum von einem call_out() oder dem heart_beat() aufgerufen
+ wurde. Auch Kommandi, die beim Userlogin aufgerufen werden, liefern 0.
+
+BEISPIEL
+ void init()
+ {
+ ...
+ add_action("sing","sing");
+ ...
+ }
+
+ int sing(string str)
+ {
+ write("Dein Kommando war:"+query_command()+"\n");
+ return 1;
+ }
+
+ Jedesmal, wenn jemand "sing blafasel" eingibt, liefert das Programm
+ "Dein Kommando war: sing blafasel".
+
+SIEHE AUCH
+ add_action(E), query_verb(E)
diff --git a/doc/efun/query_notify_fail b/doc/efun/query_notify_fail
new file mode 100644
index 0000000..3d98423
--- /dev/null
+++ b/doc/efun/query_notify_fail
@@ -0,0 +1,21 @@
+SYNOPSIS
+ mixed query_notify_fail();
+ mixed query_notify_fail(int flag);
+
+BESCHREIBUNG
+ Wenn <flag> nicht angegeben oder 0 ist, liefert die Funktion den String
+ oder die Closure, die zuletzt als Fehlermeldung fuer ein Kommando
+ gesetzt wurde (mit notify_fail()).
+
+ Wurde keine Meldung gesetzt, wird 0 geliefert.
+
+ Ist <flag> != 0 wird das Objekt zurueckgeliefert, was das letzte
+ Notify-Fail gesetzt hat.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7.
+ LDMud 3.2.8 fuegte den Paramter <flag> hinzu.
+
+SIEHE AUCH
+ add_action(E), query_verb(E), query_command(E), notify_fail(E),
+ hooks(C)
diff --git a/doc/efun/query_verb b/doc/efun/query_verb
new file mode 100644
index 0000000..f216591
--- /dev/null
+++ b/doc/efun/query_verb
@@ -0,0 +1,53 @@
+SYNOPSIS
+ string query_verb();
+ string query_verb(int flag);
+
+BESCHREIBUNG
+ Liefert das Verb des aktuellen Kommandos oder 0, wenn kein Kommando
+ bearbeitet wird.
+
+ Wenn <flag> nicht angegeben oder 0 ist, wird das Verb wie vom User
+ eingegeben geliefert (das ist das erste Wort der Inputzeile des
+ Spielers, bis zum (aber ohne) den ersten Leerschlag / Zeilenumbruch).
+ Wenn <flag> nicht 0 ist, wird das Verb entsprechend der add_action()
+ zurueck gegeben.
+
+ Innerhalb einer add_action()-Funktion, die von mehreren Kommandos
+ aufgerufen wird kann man so zwischen diesen Kommandos unterscheiden.
+
+BEMERKUNGEN
+ Die fruehere Einschraenkung, dass bei geschachtelten Kommandos
+ query-verb() nach dem inneren Kommando 0 zurueck gibt ist jetzt
+ entfallen.
+
+BEISPIEL
+ void init()
+ {
+ ...
+ add_action("sing","singe");
+ add_action("sing","jodel", 1);
+ ...
+ }
+
+ int sing(string str)
+ {
+ write("Das Kommando war:"+query_verb()+(str ? str : "")+"\n");
+ write("Das Verb war:"+query_verb(1)+(str ? str : "")+"\n");
+ }
+
+ Das Kommando "sing blafasel" liefert:
+ Das Kommando war: sing
+ Das Verb war: sing
+
+ Das Kommando "jodel blafasel" liefert:
+ Das Kommando war: jodel
+ Das Verb war: jodel
+
+ Das Kommando "jodele blafasel" liefert:
+ Das Kommando war: jodele
+ Das Verb war: jodel
+
+SIEHE AUCH
+ query_command(E), add_action(E), AddCmd(L), AddAction(L)
+
+7.Aug 2007 Gloinson
\ No newline at end of file
diff --git a/doc/efun/quote b/doc/efun/quote
new file mode 100644
index 0000000..ce01fd7
--- /dev/null
+++ b/doc/efun/quote
@@ -0,0 +1,13 @@
+SYNOPSIS
+ mixed quote(mixed arg);
+
+BESCHREIBUNG
+ Konvertiert ein Array zu einem quoted Array und Strings zu Symbolen.
+ Symbole und quoted Arrays werden erneut gequoted.
+
+BEISPIEL
+ quote("foo") -> 'foo
+ quote(({1,2,3})) -> '({1,2,3})
+
+SIEHE AUCH
+ sympolp(E), unquote(E)
diff --git a/doc/efun/raise_error b/doc/efun/raise_error
new file mode 100644
index 0000000..40ac234
--- /dev/null
+++ b/doc/efun/raise_error
@@ -0,0 +1,23 @@
+SYNOPSIS
+ void raise_error(string arg);
+
+BESCHREIBUNG
+ Bricht die Ausfuehrung des laufenden Programms ab. Wenn das Programm
+ durch catch() aufgerufen wurde, liefert dieses catch() <arg> als
+ Fehlercode, sonst wird <arg> als Fehlermeldung ausgegeben.
+
+ raise_error() gleicht in der Funktion throw(), aber waehrend throw()
+ aus catch() heraus aufgerufen werden soll, kann raise_error() von
+ ueberall her aufgerufen werden.
+
+ Da raise_error() sich wie andere 'echte' Laufzeitfehler verhaelt,
+ 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
new file mode 100644
index 0000000..a98542b
--- /dev/null
+++ b/doc/efun/random
@@ -0,0 +1,42 @@
+FUNKTION:
+ int random(int n)
+
+ARGUMENTE:
+ n: Zahlen-Bereich aus dem gewaehlt werden soll.
+
+BESCHREIBUNG:
+ Gibt eine zufaellige Zahl im Bereich von 0..(n-1) zurueck.
+
+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
diff --git a/doc/efun/read_bytes b/doc/efun/read_bytes
new file mode 100644
index 0000000..95cabbd
--- /dev/null
+++ b/doc/efun/read_bytes
@@ -0,0 +1,19 @@
+SYNOPSIS
+ string read_bytes(string file, int start, int anzahl)
+
+BESCHREIBUNG
+ Liest eine bestimmte Anzahl Bytes aus dem File <file>. Wenn <start>
+ nicht angegeben oder 0 ist, wird das File von Beginn weg gelesen,
+ sonst vom Byte mit der Nummer <start>. Wenn <start> negativ ist,
+ werden die Bytes vom Ende des Files her gezaehlt. <anzahl> ist die
+ Anzahl Bytes, die gelesen werden sollen. Werte von 0 oder negative
+ Werte sind zwar moeglich, aber wenig sinnvoll.
+
+ Wenn <start> ausserhalb der Groesse des Files liegt, liefert
+ read_byte() anstelle eines Strings 0 zurueck.
+
+ Die max. Anzahl einzulesender Bytes pro Aufruf dieser Funktion
+ betraegt LIMIT_BYTE (s. query_limits()).
+
+SIEHE AUCH
+ read_file(E), write_bytes(E), write_file(E)
diff --git a/doc/efun/read_file b/doc/efun/read_file
new file mode 100644
index 0000000..7f1ccfc
--- /dev/null
+++ b/doc/efun/read_file
@@ -0,0 +1,19 @@
+SYNOPSIS
+ string read_file(string file, int start, int anzahl)
+
+BESCHREIBUNG
+ Liest Zeilen aus einem File <file>. Wenn <start> angegeben ist und
+ nicht 0, wird von Beginn der Zeile <start> an gelesen; ist <start> 0
+ oder nicht angegeben, wird vom Beginn des Files gelesen.
+
+ Wenn <anzahl> nicht angegeben oder 0 ist, wird das gesamte File
+ gelesen, sonst nur <anzahl> Zeilen.
+
+ Wenn <start> ausserhalb der Groesse des Files liegt, liefert
+ read_file() anstelle eines Strings 0 zurueck.
+
+ Die max. Anzahl einzulesender Bytes (nicht Zeilen!) pro Aufruf dieser
+ Funktion betraegt LIMIT_FILE (s. query_limits()).
+
+SIEHE AUCH
+ read_bytes(E), write_file(E)
diff --git a/doc/efun/referencep b/doc/efun/referencep
new file mode 100644
index 0000000..5c2c0df
--- /dev/null
+++ b/doc/efun/referencep
@@ -0,0 +1,13 @@
+SYNOPSIS
+ int referencep(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument an die aktuelle Funktion per Referenz
+ uebergeben wurde, ansonsten 0.
+
+ Man beachte, dass das Argument als Referenz an referencep()
+ uebergeben werden muss, z. B. referencep(&x).
+
+SIEHE AUCH
+ closurep(E), floatp(E), mappingp(E), objectp(E), intp(E),
+ pointerp(E), stringp(E), symbolp(E), clonep(E), references(LPC)
diff --git a/doc/efun/regexp b/doc/efun/regexp
new file mode 100644
index 0000000..354e6a6
--- /dev/null
+++ b/doc/efun/regexp
@@ -0,0 +1,41 @@
+SYNOPSIS
+ #include <regexp.h>
+
+ string *regexp(string *list, string pattern)
+ string *regexp(string *list, string pattern, int opt)
+
+DESCRIPTION
+ Match the pattern <pattern> (interpreted according to <opt> if
+ given) against all strings in list, and return a new array with all
+ strings that matched.
+
+ If there is an error in the regular expression, a runtime
+ error will be raised.
+
+EXAMPLE
+ string strs;
+ string pattern;
+
+ if (regexp_package() == RE_PCRE)
+ pattern = "\\<help\\>.*\\<me\\>";
+ else
+ pattern = "\\bhelp\\b.*\\bme\\b";
+
+ if (strs = regexp( ({"please, help me Sir John."}),
+ , pattern
+ ))
+ {
+ if (sizeof(strs)
+ write("It matches.\n");
+ }
+
+ The regular expression will test the given string (which is
+ packed into an array) if there is something like "help ... me"
+ inside of it.
+
+HISTORY
+ LDMud 3.3 added the optional <opt> argument.
+
+SEE ALSO
+ regexplode(E), regmatch(E), regreplace(E), regexp_package(E), sscanf(E),
+ regexp(C)
diff --git a/doc/efun/regexp_package b/doc/efun/regexp_package
new file mode 100644
index 0000000..8b8d29f
--- /dev/null
+++ b/doc/efun/regexp_package
@@ -0,0 +1,48 @@
+SYNOPSIS
+ #include <regexp.h>
+
+ int regexp_package()
+
+DESCRIPTION
+ Return which regexp package is used by default:
+
+ RE_TRADITIONAL: traditional regexps
+ RE_PCRE: PCRE
+
+ As the package can be selected at runtime through the
+ REGEXP_PACKAGE driver hook, there is no good way to determine
+ the package at LPC compile time.
+ Match the pattern <pattern> (interpreted according to <opt> if
+ given) against all strings in list, and return a new array with all
+ strings that matched.
+
+ If there is an error in the regular expression, a runtime
+ error will be raised.
+
+EXAMPLE
+ string strs;
+ string pattern;
+
+ if (regexp_package() == RE_PCRE)
+ pattern = "\\<help\\>.*\\<me\\>";
+ else
+ pattern = "\\bhelp\\b.*\\bme\\b";
+
+ if (strs = regexp( ({"please, help me Sir John."}),
+ , pattern
+ ))
+ {
+ if (sizeof(strs)
+ write("It matches.\n");
+ }
+
+ The regular expression will test the given string (which is
+ packed into an array) if there is something like "help ... me"
+ inside of it.
+
+HISTORY
+ Introduced in LDMud 3.3.634.
+
+SEE ALSO
+ regexp(E), regexplode(E), regmatch(E), regreplace(E), sscanf(E),
+ regexp(C), regexp_package(H)
diff --git a/doc/efun/regexplode b/doc/efun/regexplode
new file mode 100644
index 0000000..595e9df
--- /dev/null
+++ b/doc/efun/regexplode
@@ -0,0 +1,28 @@
+SYNOPSIS
+ #include <regexp.h>
+
+ 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
+ expression <pattern> as delimiter (interpreted according to <opt>
+ if given).
+
+ If flag RE_OMIT_DELIM is not set in <opt>, then every second element
+ in the result vector will be the text that matched the delimiter.
+ If the flag is set, then the result vector will contain only
+ the text between the delimiters.
+
+EXAMPLES
+ regexplode("abcdef", "cde") -> ({ "ab", "cde", "f" })
+ regexplode("abcdef", "cde", RE_OMIT_DELIM) -> ({ "ab", "f" })
+
+HISTORY
+ Introduced in 3.2@61
+ LDMud 3.3 added the optional <opt> argument and the RE_OMIT_DELIM
+ flag.
+
+SEE ALSO
+ explode(E), regexp(E), regmatch(E), regreplace(E),
+ regexp_package(E), regexp(C)
diff --git a/doc/efun/regmatch b/doc/efun/regmatch
new file mode 100644
index 0000000..dbb73f5
--- /dev/null
+++ b/doc/efun/regmatch
@@ -0,0 +1,46 @@
+SYNOPSIS
+ #include <regexp.h>
+
+ string regmatch (string text, string pattern)
+ string regmatch (string text, string pattern, int opt)
+ string regmatch (string text, string pattern, int opt, int start)
+ string *regmatch (string text, string pattern, int opt)
+ string *regmatch (string text, string pattern, int opt, int start)
+
+DESCRIPTION
+ Match the string <txt> against <pattern> (interpreted according
+ to <opt> if given). If <start> is given, it is the start
+ position for the match and must be in the range [0..strlen(text)].
+
+ If there is no match, the result is 0. If there is a match, the exact
+ result is determined by the flag RE_MATCH_SUBS:
+
+ If the flag RE_MATCH_SUBS is not set, the result is the matched
+ expression.
+
+ If the flag RE_MATCH_SUBS is set, the result is an array of the
+ matched string(s) of the first match. Entry [0] is the full string
+ matching the <pattern>, following entries are the string segments
+ matching parenthesized subexpressions in <pattern>. If a particular
+ subexpression didn't have a match, the corresponding array entry will
+ be 0.
+
+ The last entry in the array will be the new start index in case you
+ want to repeat the match on the remaining parts of the string. This
+ new index is usually equal the length of the match, but at least one
+ higher than the original start index.
+
+EXAMPLE
+ regmatch("abcdefcdf", "cd") -> "cd"
+ regmatch("abcdefcdf", "cd(e)") -> "cde"
+
+ regmatch("abcdefcdf", "cd", RE_MATCH_SUBS) -> ({ "cd" })
+ regmatch("abcdefcdf", "cd(e)", RE_MATCH_SUBS) -> ({ "cde", "e" })
+
+HISTORY
+ Introduced in LDMud 3.3.198.
+ Modified in 3.3.214 to return 0 for non-matches, and to take and
+ return a start position.
+
+SEE ALSO
+ regexplode(E), regreplace(E), regexp(E), regexp_package(E), regexp(C)
diff --git a/doc/efun/regreplace b/doc/efun/regreplace
new file mode 100644
index 0000000..d459bb2
--- /dev/null
+++ b/doc/efun/regreplace
@@ -0,0 +1,57 @@
+SYNOPSIS
+ string regreplace(string txt, string pattern,
+ string|closure replacepattern, int flags)
+
+BESCHREIBUNG
+ Die Funktion durchsucht den String txt nach einem Vorkommen
+ des regulaeren Ausdrucks pattern, und ersetzt ihn durch
+ den String replacepattern. (replacepattern kann auch eine Closure
+ sein. Sie bekommt als argument den passenden Substring und muss
+ den Ersatzstring zurueckliefern.)
+
+ Im replacestring kann man via '&' auf den zum Suchausdruck
+ passenden Teilstring im Original zugreifen. Mit \n (wobei n
+ eine Ganzzahl ist) kann man auf den n-ten Unterausdruck
+ des regulaeren Ausdrucks zugreifen. Um "&" oder "\\1" als
+ Ersetzung zu erreichen, muss "\\&" bzw "\\\\1" verwendet werden.
+
+ Beim Flag bestimmt ein gesetztes Bit 0, dass der Ausdruck so oft
+ wie vorhanden ersetzt wird, sonst nur das erste Auftreten.
+ Bit 1 bestimmt, ob der regulaere Ausdruck 'ed' oder 'sed' kompatibel
+ ist (Bit geloescht) oder 'ex' kompatibel (gesetzt).
+
+ Die Funktion wirkt wie s/pattern/replacepattern/flags in
+ Editoren wie vi oder sed. Sie ist besonders gut geeignet um
+ variable Strings zu ersetzen, im Gegensatz zu regexplode, wo
+ man den String nur nach einem regulaeren Ausdruck zerlegen kann.
+
+BEISPIELE
+ // ersetzt @@wer@@ durch den Namen des Objektes
+ regreplace(str,"@@wer@@",(string)obj->name(WER,2),1)
+
+ // ersetze alle doppelten Leerzeichen durch ein einzelnes
+ regreplace(str, " *", " ", 1);
+
+ // Sucht nach 'teilt Dir mit: ' und schliesst den nachfolgenden
+ // Text mit <underline> und </underline> ein; bei jedem Auftreten.
+
+ msgin = regreplace(msgin, "teilt Dir mit: (.*)",
+ "teilt Dir mit: <underline>\\1</underline>",
+ 1);
+
+ // Ersetzt die <underline> html-Tags durch die vt100
+ // Escape-Sequenzen fuer Unterstreichung
+ txt = regreplace(txt, "<underline>", "<ESC>[5m", 1);
+
+ // Ersetzt das Wort HOUSE in Kleinbuchstaben.
+ txt = regreplace(txt, "HOUSE", #'lower_case, 1);
+
+BUGS:
+ I have written that efun. It doesn't have BUGS. By definition.
+ Well, in fact it crashed as I first tried it on running TAPPMud.
+ *sigh*
+ Marcus@TAPPMud
+
+SIEHE AUCH
+ Verwandt: regexp(E), regexplode(E), sscanf(E)
+ Aehnlich: replace_personal(L)
diff --git a/doc/efun/remove_action b/doc/efun/remove_action
new file mode 100644
index 0000000..b939a51
--- /dev/null
+++ b/doc/efun/remove_action
@@ -0,0 +1,21 @@
+SYNOPSIS
+ int remove_action(int|string verb);
+ int remove_action(int|string verb, object obj);
+
+BESCHREIBUNG
+ Wenn <verb> ein String ist: entferne das erste im Objekt <obj> durch
+ add_action() definierte Kommando <verb>. Wenn <obj> nicht
+ angegeben wird, wird standardmaessig this_player() verwendet.
+ Gib 1 zurueck, wenn ein Kommando gefunden und entfernt wurde,
+ sonst 0.
+
+ Wenn <verb> ein Integer ist: wenn verb nicht 0 ist, entferne alle
+ durch das Objekt <obj> definierten Kommandi. Wenn <obj> nicht
+ angegeben wird, wird standardmaessig this_player() verwendet. Gibt
+ die Anzahl der entfernten Kommandi zurueck.
+
+SIEHE AUCH
+ Verwandt: add_action(E), init(E)
+ Alternativ: AddAction(L), AddCmd(L)
+
+7.Aug 2007 Gloinson
diff --git a/doc/efun/remove_call_out b/doc/efun/remove_call_out
new file mode 100644
index 0000000..d5a22db
--- /dev/null
+++ b/doc/efun/remove_call_out
@@ -0,0 +1,32 @@
+SYNOPSIS
+ int remove_call_out(string fun);
+ int remove_call_out(closure fun);
+
+BESCHREIBUNG:
+ Entfernt den naechsten laufenden call_out() auf die Funktion <fun>
+ im aktuellen Objekt bzw. den naechsten laufenden call_out() auf die
+ Closure <fun>. Die verbleibende Zeit wird zurueckgeliefert.
+
+ Wenn es keine laufenden call_out()s auf gibt, wird -1 zurueck
+ geliefert.
+
+BEISPIEL
+ Um alle call_out()s auf MeineFunktion() zu entfernen:
+
+ while(remove_call_out("MeineFunktion") != -1); /* wiederhole */
+
+BUGS
+ Das Entfernen von call_out()s auf Closures funktioniert nur, wenn der
+ exakt gleiche Wert fuer die Closure verwendet wird.
+
+ Das funktioniert:
+ closure cl = symbol_function("main", obj);
+ call_out(cl, 2);
+ remove_call_out(cl);
+
+ Das funktioniert nicht:
+ call_out(symbol_function("main", obj), 2);
+ remove_call_out(symbol_function("main", obj));
+
+SIEHE AUCH
+ call_out(E), call_out_info(E), find_call_out(E)
diff --git a/doc/efun/remove_input_to b/doc/efun/remove_input_to
new file mode 100644
index 0000000..7cd9393
--- /dev/null
+++ b/doc/efun/remove_input_to
@@ -0,0 +1,38 @@
+SYNOPSIS
+ int remove_input_to (object player);
+ int remove_input_to (object player, string fun);
+ int remove_input_to (object player, closure fun);
+ int remove_input_to (object player, object fun);
+ int remove_input_to (object player, object obj, string fun);
+
+BESCHREIBUNG
+ Entfernt ein haengiges input_to() aus dem interaktiven Playerobjekt.
+ Wenn <fun> nicht angegeben ist, wird der zuletzt aufgerufen input_to()
+ entfernt.
+
+ Wurde <fun> angegeben, entfernt remove_input_to das neueste auf <fun>
+ aufgerufene input_to. Je nach der Definition von <fun> wird nach
+ unterschiedlichen Kriterien gesucht:
+ - <fun> ist ein String: gesucht wird nach dem Funktionsnamen
+ - <fun> ist ein Objekt: gesucht wird nach dem Objekt, in dem
+ input_to() aufgerufen wurde
+ - <fun> ist eine Closure: gesucht wird nach der Closure, die
+ input_to() enthaelt
+ - <obj> und <fun> wurden angegeben: es wird nach Objekt und
+ Funktionsname gesucht. Beide muessen uebereinstimmen.
+
+ remove_input_to() liefert 1 bei Erfolg, sonst 0 (es wurde kein
+ input_to() gefunden, das Objekt ist nicht interaktiv oder es gibt
+ kein haengiges input_to() auf dem Objekt).
+
+BEISPIELE
+ Entfernt alle haengigen input_to()s des aktuellen Spielers, falls
+ vorhanden:
+ while(remove_input_to(this_interactive()));
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ input_to(E), find_input_to(E), input_to_info(E),
+ query_input_pending(E)
diff --git a/doc/efun/remove_interactive b/doc/efun/remove_interactive
new file mode 100644
index 0000000..0d6d200
--- /dev/null
+++ b/doc/efun/remove_interactive
@@ -0,0 +1,13 @@
+SYNOPSIS
+ void remove_interactive(object ob)
+
+DESCRIPTION
+ Close the connection to the interactive object ob.
+
+ For the time of the LPC execution, the object is only marked
+ internally as 'about to be closed', meaning that while all
+ output will be redirected to stdout, the actual network connection
+ will continue to exist until the LPC execution ends.
+
+SEE ALSO
+ connect(M), logon(A), disconnect(M)
diff --git a/doc/efun/rename b/doc/efun/rename
new file mode 100644
index 0000000..2f74492
--- /dev/null
+++ b/doc/efun/rename
@@ -0,0 +1,25 @@
+SYNOPSIS
+ int rename(string from, string to);
+
+BESCHREIBUNG
+ Die Efun rename() verschiebt <from> nach <to>. Wenn <from> ein File
+ ist, kann <to> entweder ein andere File oder ein Verzeichnis sein.
+ Wenn <from> ein Verzeichnis ist, muss <to> auch ein Verzeichnis sein.
+ Wenn in diesem Fall <to> existiert und ein Verzeichnis ist, wird
+ <from> in <to> verschoben und behaelt seinen Namen.
+
+ <from> umzubenennen erfordert Schreibrechte auf <from>.
+
+ Unterverzeichnisse (Verzeichnisse in Verzeichnissen) koennen nur auf
+ Maschinen umbenannt werden, die unter System V laufen, d.h. es ist
+ nicht moeglich, diese in ein anderes Verzeichnis zu verschieben. Das
+ Verschieben von Verzeichnissen von einem Filesystem zum andreren ist
+ unter keinem System moeglich.
+
+ Bei Erfolg liefert rename() 0, bei Fehlschlag einen Wert ungleich 0.
+
+BEISPIEL
+ rename("/players/wizard/obj.c", "/players/wizard/newobj.c");
+
+SIEHE AUCH
+ copy_file(E), mkdir(E), rmdir(E), rm(E)
diff --git a/doc/efun/rename_object b/doc/efun/rename_object
new file mode 100644
index 0000000..2d31674
--- /dev/null
+++ b/doc/efun/rename_object
@@ -0,0 +1,10 @@
+SYNOPSIS:
+ void rename_object (object ob, string new_name);
+
+DESCRIPTION:
+ Give the current object a new object_name. Causes a privilege
+ violation. The new name must not contain a # character, except
+ at the end, to avoid confusion with clone numbers.
+
+SEE ALSO:
+ creator(E), object_name(E)
diff --git a/doc/efun/replace_program b/doc/efun/replace_program
new file mode 100644
index 0000000..4812d4e
--- /dev/null
+++ b/doc/efun/replace_program
@@ -0,0 +1,52 @@
+SYNOPSIS
+ void replace_program();
+ void replace_program(string program);
+
+BESCHREIBUNG
+ Ersetzt ein Programm mit dem geerbten Programm (inherit) <program>.
+ Das Argument <program> kann weggelassen werden, wenn nur ein Programm
+ geerbt wird. In diesem Fall waehlt der Treiber automatisch dieses eine
+ geerbte Programm.
+
+ Diese Efun ist nuetzlich, wenn es um Leistung und Speicherverbrauch
+ des Treibers geht. Ein Programm, welches keine zusaetzlichen Variablen
+ oder Funktionen braucht (ausser waehrend der Erstellung), kann
+ replace_program() aufrufen, um die Trefferquote des Treibers auf den
+ Funktionen-Caches zu erhoehen. Dies verringert die Anzahl Programme
+ im System.
+
+ Raeume sind ein gutes Beispiel fuer die Anwendung dieser Funktion, da
+ viele Raeume nur aus einem Inherit und einer Konfigurationsfunktion
+ bestehen. Jedes Objekt kann replace_program() aufrufen, verliert dabei
+ jedoch alle Variablen und Funktionen, die nicht im geerbten Programm
+ definiert sind.
+
+ Wenn replace_program() angewendet wird, werden Shadows vom Objekt
+ entfernt, in dem replace_program() stattfindet. Dies ist so seit
+ 3.2@166.
+
+ Es ist nicht moeglich, replace_program() aufzurufen, wenn es an das
+ Objekt gebundene (Lambda-) Closures gibt. Hingegen ist es moeglich,
+ zuerst das Programm des Objekts zu ersetzen und dann Lambdaclosures
+ daran zu binden.
+
+ Das Ersetzen des Programms findet erst statt, wenn das Objekt
+ vollstaendig abgearbeitet wurde, nicht schon beim Aufruf der Funktion
+ replace_program(). Das kann dazu fuehren, dass Closures auf inzwischen
+ 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
+ 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
+ LDMud 3.2.9 liess zu, dass das Argument <program> weggelassen wird,
+ wenn nur ein Inherit existiert.
diff --git a/doc/efun/restore_object b/doc/efun/restore_object
new file mode 100644
index 0000000..fa991d6
--- /dev/null
+++ b/doc/efun/restore_object
@@ -0,0 +1,45 @@
+SYNOPSIS
+ int restore_object(string name);
+ int restore_object(string str); (VORLAEUFIG)
+
+BESCHREIBUNG
+ Laedt Werte von Variablen fuer das aktuelle Objekt aus der Datei
+ <name> oder direkt aus dem String <str>.
+
+ Um direkt aus einem String Variablen laden zu koennen, muss dieser
+ mit der typischen Zeile "#x:y" beginnen. Strings, die von der Efun
+ save_object() erzeugt wurden, beginnen so.
+
+ Wenn Variablen aus einer Datei geladen werden, kann <name> mit .c
+ enden. Diese Dateiendung wird vom Treiber entfernt. Das Masterobjekt
+ fuegt dem Dateinamen ein .o hinzu. Die Gueltigkeit des Dateinamens
+ wird mit der Funktion check_valid_path() automatisch ueberprueft.
+
+ Die Funktion gibt 1 zurueck, wenn die Variablen erfolgreich geladen
+ wurden und 0, wenn es nichts zu laden gab.
+
+ Variablen mit dem Typenvermerk nosave werden nicht geladen, zum
+ Beispiel nosave int xxx;
+
+ Closures aus Lfuns, Variablne und simul_efuns werden nur geladen,
+ wenn sie gefunden werden. Falls nicht, werden sie mit dem Wert '0'
+ geladen.
+
+ Wenn Vererbung verwendet wird, kann es vorkommen, dass mehrere
+ Variablen mit dem gleichen Namen an unterschiedlichen Orten vorkommen
+ und deshalb in der Speicherdatei mehrmals auftreten. Beim Laden der
+ Variablen werden sie in Reihenfolge ihres Auftretens im Vererbungsbaum
+ geladen. Ein geeignetes Vorgehen ist die Verwendung von Verbose und
+ einzigartigen Namen bei nicht-statischen Variablen. So wird auch das
+ manuelle Lesen oder Editieren des Savefiles einfacher.
+
+AENDERUNGEN
+ Das direkte Laden aus einem String wurde in LDMud 3.2.8 eingefuehrt,
+ wird aber moeglicherweise in Zukunft in eine separate Efun
+ ausgelagert.
+ LDMud 3.2.9 ergaenzte die Funktion um die Moeglichkeit,
+ NonLambda-Closures, Symbole und gequotete Arrays zu laden,
+ indem ein neues Format fuer das Savefile verwendet wird.
+
+SIEHE AUCH
+ save_object(E), restore_value(E), valid_read(M)
diff --git a/doc/efun/restore_value b/doc/efun/restore_value
new file mode 100644
index 0000000..fa44b18
--- /dev/null
+++ b/doc/efun/restore_value
@@ -0,0 +1,17 @@
+SYNOPSIS
+ mixed restore_value(string str);
+
+BESCHREIBUNG
+ Wandelt die String-Entsprechung <str> eines Wertes zurueck in den Wert
+ selbst und gibt diesen Wert zurueck. <str> ist ein String, wie er von
+ save_value() erzeugt wird. Die Spezifikation des Speicherformates
+ '#x:y' ist optional.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.8.
+ Mit LDMud 3.2.9 kam das Laden von Non-Lambda Closures, Symbolen und
+ gequoteten Arrays hinzu, wozu ein neues Format fuer die Speicherdatei
+ verwendet wird.
+
+SIEHE AUCH
+ save_value(E), restore_object(E), save_object(E)
diff --git a/doc/efun/reverse b/doc/efun/reverse
new file mode 100644
index 0000000..90c7890
--- /dev/null
+++ b/doc/efun/reverse
@@ -0,0 +1,31 @@
+SYNOPSIS
+ inti reverse (int arg)
+ string reverse (string arg)
+ mixed * reverse (mixed * arg)
+ mixed * reverse (mixed * & arg)
+
+DESCRIPTION
+ Kehrt die Reihenfolge des Inhaltes von Array oder String <arg>
+ um und liefert den neuen Wert als Resultat.
+ Ist <arg> eine Zahl, wird die Reihenfolge der Bits in <arg> umgekehrt.
+
+ Wenn in der Referenz-Variante verwendet, wird das Argumentarray selber
+ invertiert und auch zurueckgegeben.
+
+EXAMPLES
+ reverse (0x306a) - return 0x560c0000
+
+ reverse ("test") - return "tset"
+
+ mixed * a = ({ 1, 2 });
+ reverse(a) - returns ({ 2, 1 }), a ist unveraendert.
+ reverse(&a) - returns ({ 2, 1 }), a ist nun ({ 2, 1 })
+
+BUGS
+ Referenz-Teilarrays wie reverse(&(a[1..2])) sind nicht unterstuetzt.
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.529.
+ LDMud 3.3.532 fuegte die Bitumkehr von Zahlen ein.
+
+SEE ALSO
diff --git a/doc/efun/rm b/doc/efun/rm
new file mode 100644
index 0000000..d1b59e3
--- /dev/null
+++ b/doc/efun/rm
@@ -0,0 +1,9 @@
+SYNOPSIS
+ int rm(string file);
+
+BESCHREIBUNG
+ Loescht die Datei <file>. Gibt 0 zurueck, wenn etwas nicht geklappt
+ hat, 1 bei Erfolg.
+
+SIEHE AUCH
+ mkdir(E), rmdir(E), rename(E)
diff --git a/doc/efun/rmdir b/doc/efun/rmdir
new file mode 100644
index 0000000..19af329
--- /dev/null
+++ b/doc/efun/rmdir
@@ -0,0 +1,8 @@
+SYNOPSIS
+ int rmdir(string dir);
+
+BESCHREIBUNG
+ Loescht das Verzeichnis <dir>. Liefert 1 bei Erfolg, 0 bei Misserfolg.
+
+SIEHE AUCH
+ mkdir(E), rm(E), rename(E)
diff --git a/doc/efun/rmember b/doc/efun/rmember
new file mode 100644
index 0000000..dc1962c
--- /dev/null
+++ b/doc/efun/rmember
@@ -0,0 +1,20 @@
+SYNOPSIS
+ int rmember(mixed *array, mixed elem [, int start]);
+ int rmember(string str, int elem [, int start]);
+
+BESCHREIBUNG
+ Liefert fuer Arrays und Strings den Index des letzten Auftretens des
+ Arguments <elem> im Array <*array> bzw. im String <str>. Wenn <elem>
+ nicht gefunden wird, liefert die Funktion -1 zurueck.
+
+ Ist <start> als Zahl >= 0 gegeben, beginnt die Suche ab der
+ angegebenen Position. Eine Startposition groesser als die
+ Laenge des Strings/Arrays liefert stets das Resultat -1.
+
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.10.
+ LDMud 3.3.556 fuegte den <start>-Parameter hinzu.
+
+SIEHE AUCH
+ member(E)
diff --git a/doc/efun/rusage b/doc/efun/rusage
new file mode 100644
index 0000000..8dc2523
--- /dev/null
+++ b/doc/efun/rusage
@@ -0,0 +1,18 @@
+OPTIONAL
+SYNOPSIS
+ int *rusage();
+
+BESCHREIBUNG
+ Liefert ein Array mit Informationen ueber den momentanen
+ Systemzustand; Benutzungsstatistiken, wie sie vom Unix-Kommando
+ getrusage(2) generiert werden, namentlich:
+ utime, stime, maxrss, rus.ru_ixrss, rus.ru_idrss, rus.ru_isrss,
+ rus.ru_minflt, rus.ru_majflt, rus.ru_nswap, rus.ru_inblock,
+ rus.ru_oublock, rus.ru_msgsnd, rus.ru_msgrcv, rus.ru_nsignals,
+ rus.ru_nvcsw, rus.ru_nivcsw
+
+ANMERKUNG
+ Diese Funktion ist optional.
+
+SIEHE AUCH
+ sys/resource.h(Unix)
diff --git a/doc/efun/save_object b/doc/efun/save_object
new file mode 100644
index 0000000..681946b
--- /dev/null
+++ b/doc/efun/save_object
@@ -0,0 +1,54 @@
+SYNOPSIS
+ 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.
+
+ In der ersten Form wir der String in die Datei <name> geschrieben. Eine
+ Endung ".c" in <name> wird entfernt, dafuer kann eine Endung ".o"
+ durch das Masterobjekt angefuegt werden, waehrend der Ueberpruefung
+ durch valid_read(). Die Efun save_object() liefert 0, wenn die
+ Speicherdatei erfolgreich erstellt wurde, sonst eine Zahl ungleich 0,
+ wenn ein nicht schwerwiegendee Fehler aufgetreten ist (die Datei
+ konnte nicht geschrieben werden oder das aktuelle Objekt wurde
+ inzwischen zerstoert).
+
+ In der zweiten Form wird der String direkt zurueck gegeben. Wenn das
+ Objekt zerstoert wurde, wird 0 zurueck gegeben. In beiden Faellen kann
+ durch das optionale Argument <format> das Format der Speicherdatei
+ angegeben werden:
+
+ -1: das normale Format des Treibers (Standard)
+ 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
+
+ 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
+ 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
+ umgezogen.
+ LDMud 3.2.9 ergaenzte die Funktion um das Speichern von Non-Lambda
+ Closures, Symbolen und gequoteten Arrays. Dazu wurde ein neues
+ Format fuer die Speicherdatei eingefuehrt.
+ LDMud 3.2.10 fuehrte das Argument <format> ein.
+
+SIEHE AUCH
+ restore_object(E), save_value(E), save_object (Sefun)
diff --git a/doc/efun/save_value b/doc/efun/save_value
new file mode 100644
index 0000000..d9e1486
--- /dev/null
+++ b/doc/efun/save_value
@@ -0,0 +1,31 @@
+SYNOPSIS
+ string save_value(mixed wert [, int format]);
+
+BESCHREIBUNG
+ Schreibt <wert> in einen String, der sich mit restore_value()
+ auswerten laesst. Der String wird zurueck gegeben.
+
+ Das optionale Argument <format> bestimmt das Format des Strings:
+
+ -1: das normale Format des Treibers (Standard)
+ 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
+
+ Der erzeugte String besteht aus zwei Zeilen, die jeweils mit einem
+ Zeilenumbruch enden. Die erste Zeile beschreibt das Format, in dem der
+ Wert gespeichert wird, in der '#x:y'-Schreibweise. Die zweite Zeile
+ stellt den eigentlichen Wert da.
+
+ Das Format zum Schreiben des Wertes in den String entspricht dem von
+ save_object() und restore_object() verwendeten Format.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.8.
+ LDMud 3.2.9. ergaenzte die Funktion um die Moeglichkeit, Non-Lambda
+ Closures, Symbole und gequotete Arrays zu speichern. Dazu wurde
+ ein neues Format fuer den String eingefuehrt.
+ LDMud 3.2.10 fuehrte das Argument <format> ein.
+
+SIEHE AUCH
+ restore_value(E), restore_object(E), save_object(E)
diff --git a/doc/efun/say b/doc/efun/say
new file mode 100644
index 0000000..6f0958f
--- /dev/null
+++ b/doc/efun/say
@@ -0,0 +1,98 @@
+SYNOPSIS
+ 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);
+
+BESCHREIBUNG
+ Es bestehen zwei Hauptanwendungen fuer say():
+
+ Wenn das erste Argument ein String <str> ist, wird er an alle
+ 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 zweite Argument, die Nachricht, kein String ist, wird in
+ allen Lebewesen, die den Text erhalten, catch_msg() anstatt
+ catch_tell() aufgerufen.
+
+ 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.
+
+ Das aufrufende Objekt wird nach folgenden Regeln bestimmt:
+ - Wenn say() aus einem lebendigen Objekt aufgerufen wird, gilt
+ dieses als das aufrufende Objekt.
+ - Wenn say() aus einem nicht-lebendigen Objekt als Resultat einer
+ 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()}))
+
+BEISPIELE
+ // Folgende Aufrufe sind gleich, wenn sie durch ein Spielerkommando
+ // in einem nicht lebendigen Objekt aufgeloest 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.
+
+ Objekt 1 (living):
+ void catch_tell(string str) {
+ write("Empfangen: "+str+"\n");
+ }
+
+ Objekt 2 (nicht living):
+ 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.
+
+ Object 1 (living):
+ void catch_msg(mixed *arr, object who) {
+ foreach(mixed element: arr)
+ tell_object(who, sprintf("%O\n", element));
+ }
+
+ Object 2 (nicht living):
+ void func() {
+ ...
+ 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)
+
+7.Aug 2007 Gloinson
\ No newline at end of file
diff --git a/doc/efun/send_erq b/doc/efun/send_erq
new file mode 100644
index 0000000..d3521e1
--- /dev/null
+++ b/doc/efun/send_erq
@@ -0,0 +1,24 @@
+GESCHUETZT
+SYNOPSIS
+ int send_erq(int request, string|int *data, closure callback);
+
+BESCHREIBUNG
+ Eine Anfrage vom Typ <request> (standardmaessig 0) wird mit Inhalt
+ <data> word an den ERQ gesandt. Wenn <callback> angegeben ist,
+ wird diese Closure aufgerufen, wenn eine Antwort vom ERQ eintrifft
+ (ein Status Code), vorausgesetzt die Antwort enthaelt ausreichend
+ Daten, um damit zu arbeiten:
+
+ void <closure>(int *response_data, int len);
+
+ <data> kann entweder ein String oder ein Array von Integers sein,
+ wobei im zweiten Fall die Zahlen als Zeichen interpretiert werden.
+ Die unterschiedlichen Anfragen sind in /sys/erq.h definiert.
+
+ Die Funktion liefert 0 zurueck, wenn das Senden fehlgeschlagen ist,
+ etwas anderes sost.
+
+ Die Funktion verursacht eine Schutzverletzung "erq".
+
+SIEHE AUCH
+ attach_erq_demon(E), erq(C)
diff --git a/doc/efun/send_udp b/doc/efun/send_udp
new file mode 100644
index 0000000..8ad0c33
--- /dev/null
+++ b/doc/efun/send_udp
@@ -0,0 +1,12 @@
+SYNOPSIS:
+ int send_udp(string host, int port, string message)
+
+DESCRIPTION:
+ Sends The message in an UDP packet to the given host and port
+ number. Causes a privilege violation.
+ Returns 1 on success, 0 on failure.
+
+SEE ALSO:
+ receive_udp(M)
+
+29.10.2006 Zesstra
diff --git a/doc/efun/set_auto_include_string b/doc/efun/set_auto_include_string
new file mode 100644
index 0000000..247e50d
--- /dev/null
+++ b/doc/efun/set_auto_include_string
@@ -0,0 +1,19 @@
+DEPRECATED
+SYNOPSIS:
+ void set_auto_include_string(string arg)
+
+DESCRIPTION:
+
+ The arg will be automatically included into every compiled LPC
+ object. This is useful to enforce global definitions, e.g.
+ ``#pragma combine_strings'' or ``#pragma strict_types''. The
+ calling objectneeds to be privileged by the master object.
+
+NOTE:
+ Not available in LDMud 3.3.x
+ Please use the driver hook H_AUTO_INCLUDE in LDMud > 3.2.9
+
+SEE ALSO:
+ privilege_violation(M), pragma(LPC)
+
+29.10.2006 Zesstra
diff --git a/doc/efun/set_bit b/doc/efun/set_bit
new file mode 100644
index 0000000..847c6b5
--- /dev/null
+++ b/doc/efun/set_bit
@@ -0,0 +1,30 @@
+SYNOPSIS
+ string set_bit(string str, int n);
+
+BESCHREIBUNG
+ Liefert einen neuen String, bei dem das Bit <n> in <str> gesetzt
+ ist. Dabei wird der urspruengliche String <str> nicht veraendert.
+
+ Jedes Zeichen enthaelt 6 Bits. In jedem Zeichen kann deshalb eine
+ Zahl von 0 bis 63 gespeichert werde (2^6=64). Das erste Zeichen
+ ist der Leerschlag " " mit dem Wert 0. Das erste Zeichen im String
+ ist jenes mit den niedrigsten Bits (0-5).
+
+ Der neue String wird automatisch verlaengert, falls noetig.
+
+BEISPIEL
+ string s;
+ s=set_bit("?",5);
+
+ Weil "?" einen Wert von 31 hat, ist das 6. Bit nicht gesetzt. Wird
+ es gesetzt, so ergibt sich "_". Der String s enthaelt nun also "_".
+
+ string s;
+ s=set_bit("78",3);
+ s=set_bit(s,8);
+
+ s enthaelt nun "?<".
+
+SIEHE AUCH
+ clear_bit(E), last_bit(E), next_bit(E), test_bit(E), count_bits(E),
+ and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/set_driver_hook b/doc/efun/set_driver_hook
new file mode 100644
index 0000000..5489120
--- /dev/null
+++ b/doc/efun/set_driver_hook
@@ -0,0 +1,98 @@
+SYNOPSIS
+ void set_driver_hook(int what, closure arg)
+ void set_driver_hook(int what, string arg)
+ void set_driver_hook(int what, string * arg)
+
+DESCRIPTION
+ This privileged efun sets the driver hook 'what' (values are
+ defined in /sys/driver_hook.h) to 'arg'.
+ The exact meanings and types of 'arg' depend of the hook set.
+ To remove a hook, set 'arg' to 0.
+
+ These hooks exist:
+
+ H_MOVE_OBJECT0
+ H_MOVE_OBJECT1
+ arg: unbound lambda
+ Mandatory hooks implementing the move_object() efun.
+
+ H_LOAD_UIDS
+ H_CLONE_UIDS
+ arg: unbound lambda or lfun closure
+ Mandatory hooks to determine the (e)uid of new objects.
+
+ H_CREATE_SUPER
+ H_CREATE_OB
+ H_CREATE_CLONE
+ H_RESET
+ H_CLEAN_UP
+ arg: lambda closure (H_CLEAN_UP also accepts a lfun
+ closure), function name.
+ Optional hooks for creation/reset/clean up-actions.
+
+ H_DEFAULT_METHOD
+ arg: lambda closure, lfun closure, function name.
+ Optional hook for default method implementation.
+
+ H_DEFAULT_PROMPT
+ arg: lambda closure, lfun closure, prompt string.
+ Optional hook for the default command prompt.
+
+ H_PRINT_PROMPT
+ arg: lambda closure, lfun closure, function name.
+ Optional hook to print the command prompt.
+
+ H_MODIFY_COMMAND
+ arg: lambda closure, lfun closure, function name, mapping
+ Optional hook for modifying player commands before the
+ parser sees them.
+
+ H_NOTIFY_FAIL
+ arg: lambda closure, lfun closure, string.
+ Mandatory hook to generate the default message if an entered
+ command couldn't be parsed and no notify_fail() command is
+ in effect.
+
+ H_SEND_NOTIFY_FAIL
+ arg: lambda closure, lfun closure, string.
+ Optional hook to deliver the notify fail message from a failed
+ command.
+
+ H_NO_IPC_SLOT
+ arg: string.
+ Optional hook specifying the 'sorry' messages if logins are
+ rejected due to fullness of the mud.
+
+ H_INCLUDE_DIRS
+ arg: lambda closure, lfun closure, string array.
+ Semi-mandatory hook specifying the directories where <>-type
+ include files are searched.
+
+ H_AUTO_INCLUDE
+ arg: lambda closure, lfun closure, string
+ Optional hook to specify a string to be included before the
+ source of every compiled LPC object.
+
+ H_TELNET_NEG
+ arg: lambda closure, lfun closure, string.
+ Optional hook to specifiy how to perform a single telnet
+ negotiation.
+
+ H_NOECHO
+ arg: lambda closure, lfun closure, string.
+ Optional hook to specifiy how to perform the telnet actions
+ to switch the echo mode (used for e.g. password input_to()s).
+
+ H_ERQ_STOP
+ arg: lambda closure, lfun closure.
+ Optional hook to notify the mudlib about the termination of
+ the erq demon.
+
+ See hooks(C) for a detailed discussion.
+
+HISTORY
+ Introduced in 3.2.1@1 as efun309(), renamed to
+ set_driver_hook() in 3.2.1@13
+
+SEE ALSO
+ hooks(C)
diff --git a/doc/efun/set_environment b/doc/efun/set_environment
new file mode 100644
index 0000000..fe3a969
--- /dev/null
+++ b/doc/efun/set_environment
@@ -0,0 +1,20 @@
+SYNOPSIS
+ void set_environment(object item, object env)
+
+DESCRIPTION
+ The item is moved into its new environment env, which may be 0.
+ This efun is to be used in the move_object() hook, as it does
+ nothing else than moving the item - no calls to init() or such.
+
+ Don't use it in your own objects!
+
+HISTORY
+ Introduced in 3.2.1@1 as 'efun308()', renamed to 'set_environment()'
+ in 3.2.6 and LP "03.02.1@150".
+
+SEE ALSO
+ remove(A), init(A), move_object(E), transfer(E), hooks(C),
+ native(C)
+
+29.10.2006 Zesstra
+
diff --git a/doc/efun/set_extra_wizinfo b/doc/efun/set_extra_wizinfo
new file mode 100644
index 0000000..f0095c9
--- /dev/null
+++ b/doc/efun/set_extra_wizinfo
@@ -0,0 +1,22 @@
+SYNOPSIS
+ void set_extra_wizinfo (object wiz, mixed extra)
+ void set_extra_wizinfo (string wiz, mixed extra)
+ void set_extra_wizinfo (int wiz, mixed extra)
+
+DESCRIPTION
+ Set the value <extra> as the 'extra' information for the wizlist
+ entry of <wiz>.
+
+ If <wiz> is an object, the entry of its creator (uid) is used.
+ If <wiz> is a string (a creator aka uid), it names the entry
+ to use.
+ If <wiz> is the number 0, the data is set in the default wizlist
+ entry. It can be used to store data for the lifetime of this
+ driver run, like the time of the last reboot.
+
+ The <extra> argument may be any value.
+
+ The function causes a privilege violation.
+
+SEE ALSO
+ get_extra_wizinfo(E), set_extra_wizinfo_size(E), wizlist_info(E)
diff --git a/doc/efun/set_next_reset b/doc/efun/set_next_reset
new file mode 100644
index 0000000..c4cd3b7
--- /dev/null
+++ b/doc/efun/set_next_reset
@@ -0,0 +1,55 @@
+FUNKTION
+ int set_next_reset(int delay)
+
+ARGUMENTE
+ delay - minimale Zeit bis zum naechsten Reset des Objektes
+
+BESCHREIBUNG
+ Mit dieser efun ist es moeglich Einfluss auf das Resetverhalten des
+ Objektes zu nehmen:
+
+ 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.
+
+ 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.
+
+BEISPIELE
+ // ein Objekt mit verkuerzter reset()-Zeit
+ void create() {
+ ...
+ set_next_reset(15*60); // ~ 15 Minuten
+ ...
+ }
+
+ 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
diff --git a/doc/efun/set_this_object b/doc/efun/set_this_object
new file mode 100644
index 0000000..2afda56
--- /dev/null
+++ b/doc/efun/set_this_object
@@ -0,0 +1,60 @@
+GESCHUETZT
+SYNOPSIS
+ void set_this_object(object objekt-an-stelle-von-originalobjekt);
+
+BESCHREIBUNG
+ Dies ist eine geschuetzte Funktion, die nur vom Master-Objekt und im
+ Simul-Efun-Objekt genutzt werden darf. Bei sonstiger Benutzung
+ erzeugt diese Funktion einen Fehler.
+
+ Die Funktion aendert das Resultat von this_object() in der laufenden
+ Funktion, ebenso das Resultat von previous_object() in Funktionen in
+ anderen Objekten, die einen call_other() Aufruf machen.
+
+ Der Effekt von set_this_object() bleibt bestehen, bis ein externer
+ Funktionsaufruf abgeschlossen ist oder bis zu einem erneuten
+ set_this_object(). Waehrend der Ausfuehrung von Code im Master-Objekt
+ oder im Simul-Efun-Objekt ist set_this_object() garantiert, auch wenn
+ this_object() durch set_this_object() veraendert wird. Die gilt
+ nicht fuer Funktionen, die aus anderen Programmen inheritet werden.
+
+ Diese Funktion darf nur mit hoechster Sorgfalt verwendet werden, um
+ Inkonsistenzen zu vermeiden. Nach einem Aufruf von set_this_object()
+ koennen sich gewisse LPC-Konstrukte merkwuerdig verhalten oder gar
+ das System zum Absturz bringen. Insbesondere die Verwendung von
+ globalen Variablen oder der Aufruf von lokalen Funktionen (ausser
+ durch call_other()) ist unzulaessig und wird aktiv verhindert.
+
+ Erlaubt sind call_other(), map(), der Zugriff auf lokale Variablen
+ (die auch Pointer auf globale Arrays enthalten duerfen), einfache
+ Arithmetik und der Zuweisungs-Operator.
+
+BUGS
+ Es ist momentan nicht moeglich, das originale gueltige Objekt wieder
+ herzustellen. Anstelle von:
+
+ object ich = this_object();
+ set_this_object(dings);
+ <irgendwelcher Code>
+ set_this_object(ich);
+ <mehr Code>
+
+ muss das ueber einen Umweg geloest werden:
+
+ private void tuwas(object dings)
+ {
+ set_this_object(dings);
+ <irgendwelcher code>
+ }
+
+ funcall(#'tuwas, dings);
+ <mehr Code>
+
+ Manche Leute bezeichnen das als Feature.
+
+AENDERUNGEN
+ LDMud 3.2.10 verhindert aktiv die Referenz auf globale Variablen und
+ Funktionsaufrufe nach Adresse, waehren set_this_object() gilt.
+
+SIEHE AUCH
+ this_object(E), set_this_player(E)
diff --git a/doc/efun/set_this_player b/doc/efun/set_this_player
new file mode 100644
index 0000000..085c529
--- /dev/null
+++ b/doc/efun/set_this_player
@@ -0,0 +1,31 @@
+GESCHUETZT
+SYNOPSIS
+ void set_this_player(object ob);
+
+BESCHREIBUNG
+ Aendert den momentanen Kommandogeber zu <ob>. Dabei kann <ob> auch
+ 0 sein, wenn der aktuelle Kommandogeber 'deaktiviert' werden soll.
+
+ Diese Funktion ist nicht geschuetzt und sollte deshalb von einer
+ simul_efun ueberlagert werden, die die Efun entweder komplett
+ abschaltet, oder mindestens gewisse Sicherheitschecks durchfuehrt.
+ Es ist sonst einfach, die Sicherheit eines Muds mit Hilfe dieser
+ Efun zu untergraben.
+
+ Die Efun ist nur in 3.2.1 verfuegbar. Eine moegliche Simulation fuer
+ 3.2 koennte etwa so aussehen:
+
+ void set_this_player(object ob)
+ {
+ /* Insert your privilege checks here */
+ if (living(ob))
+ funcall(bind_lambda(#'enable_commands, ob));
+ }
+ (suggested by Mark Lewis (Nostradamus@Zebedee))
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.1.
+ LDMud 3.2.6 fuehrte die 0 als moeglichen Parameter ein.
+
+SIEHE AUCH
+ set_this_object(E), this_player(E)
diff --git a/doc/efun/seteuid b/doc/efun/seteuid
new file mode 100644
index 0000000..5c2793a
--- /dev/null
+++ b/doc/efun/seteuid
@@ -0,0 +1,17 @@
+SYNOPSIS
+ int seteuid(string str);
+
+BESCHREIBUNG
+ Setzt die effektive UID auf <str>. Das aufrufende Objekt muss dazu
+ vom Masterobjekt berechtigt sein. In den meisten Installationen
+ kann die effektive UID jederzeit auf die momentane UID des Objekts,
+ auf die UID des Erschaffers des Objekts oder auf 0 gesetzt werden.
+
+ Nur wenn dieser Wert 0 ist, kann die UID des Objekts durch
+ export_uid() veraendert werden.
+
+ Unter strikten eUID Regeln koennen Objekte mit UID 0 keine anderen
+ Objekte laden oder clonen.
+
+SIEHE AUCH
+ export_uid(E), getuid(E), getuuid(E), geteuid(E), native(C)
diff --git a/doc/efun/sgn b/doc/efun/sgn
new file mode 100644
index 0000000..2331c0d
--- /dev/null
+++ b/doc/efun/sgn
@@ -0,0 +1,17 @@
+SYNOPSIS
+ int sgn (int|float arg)
+
+BESCHREIBUNG
+ Liefert das Vorzeichen des Argumentes.
+
+ arg sgn(arg)
+ --------------
+ > 0 1
+ 0 0
+ < 0 -1
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ abs(E)
diff --git a/doc/efun/shutdown b/doc/efun/shutdown
new file mode 100644
index 0000000..46ef0af
--- /dev/null
+++ b/doc/efun/shutdown
@@ -0,0 +1,18 @@
+SYNOPSIS
+ void shutdown();
+ void shutdown(int exit_code);
+
+BESCHREIBUNG
+ Faehrt das Mud herunter. Diese Funktion darf nie verwendet werden!
+ Wenn das Mud heruntergefahren werden muss, so hat dies ueber den
+ Shutdownbefehl zu erfolgen.
+
+ Ist ein <exit_code> Argument gegeben, wird sein Wert als der
+ Unix-Resultatwert verwendet; andernfalls wird 0 verwendet.
+
+ Man fragt sich nun vielleicht, wozu es dann diese Funktion gibt,
+ wenn man sie nicht verwenden darf. Sorry, das darf hier nicht
+ bekannt gegeben werden. Streng geheim.
+
+SIEHE AUCH
+ break_point(E), swap(E)
diff --git a/doc/efun/sin b/doc/efun/sin
new file mode 100644
index 0000000..6eab7ec
--- /dev/null
+++ b/doc/efun/sin
@@ -0,0 +1,8 @@
+SYNOPSIS
+ float sin(int|float)
+
+BESCHREIBUNG
+ Liefert den Sinus des Argumentes.
+
+SIEHE AUCH
+ asin(E), cos(E), acos(E), tan(E), atan(E), atan2(E)
diff --git a/doc/efun/sizeof b/doc/efun/sizeof
new file mode 100644
index 0000000..b5023b4
--- /dev/null
+++ b/doc/efun/sizeof
@@ -0,0 +1,16 @@
+SYNOPSIS
+ int sizeof(mixed * val);
+ int sizeof(string val);
+ int sizeof(mapping val);
+
+BESCHREIBUNG
+ Liefert die Anzahl Elemente in einem Array <val>, die Anzahl
+ Zeichen in einem String <val> oder die Anzahl Keys in einem Mapping
+ <val>.
+
+ Als Spezialfall kann <val> auch 0 sein. In diesem Fall liefert die
+ Funktion 0 zurueck.
+
+SIEHE AUCH
+ allocate(E), pointerp(E), mappingp(E), m_allocate(E),
+ widthof(E)
diff --git a/doc/efun/sl_close b/doc/efun/sl_close
new file mode 100644
index 0000000..753948d
--- /dev/null
+++ b/doc/efun/sl_close
@@ -0,0 +1,17 @@
+OPTIONAL
+SYNOPSIS
+ void sl_close()
+
+BESCHREIBUNG
+ Schliesst die SQLite-Datenbank, welche vom aktuellen Objekt
+ geoeffnet wurde.
+
+ Diese Funktion ist nur verfuegbar, wenn der Driver mit SQLite-
+ Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __SQLITE__ definiert.
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.713.
+
+SIEHE AUCH
+ sl_open(E), sl_exec(E), sl_insert_id(E)
diff --git a/doc/efun/sl_exec b/doc/efun/sl_exec
new file mode 100644
index 0000000..e8c4a8f
--- /dev/null
+++ b/doc/efun/sl_exec
@@ -0,0 +1,25 @@
+OPTIONAL
+SYNOPSIS
+ mixed* sl_exec(string statement, ...)
+
+BESCHREIBUNG
+ Fuehrt den SQL-Befehl <statement> in der aktuell geoeffneten
+ SQLite-Datenbank aus. Dieser SQL-Befehl kann Wildcards wie '?'
+ nd '?nnn', wobei 'nnn' eine Zahl ist, enthalten. Diese Wildcards
+ koennen als weitere Parameter an sl_exec uebergeben werden.
+ Mit '?nnn' kann direkt die Nummer eines bestimmten Parameters
+ angegeben werden, der erste Parameter hat die Nummer 1.
+
+ Falls der SQL-Befehl Daten zurueckliefert, liefert sl_exec ein
+ Array aus den einzelnen Zeilen (welche wieder Arrays der einzelnen
+ Felder sind) zurueck.
+
+ Diese Funktion ist nur verfuegbar, wenn der Driver mit SQLite-
+ Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __SQLITE__ definiert.
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.713.
+
+SIEHE AUCH
+ sl_open(E), sl_insert_id(E), sl_close(E)
diff --git a/doc/efun/sl_insert_id b/doc/efun/sl_insert_id
new file mode 100644
index 0000000..a425cef
--- /dev/null
+++ b/doc/efun/sl_insert_id
@@ -0,0 +1,18 @@
+OPTIONAL
+SYNOPSIS
+ int sl_insert_id()
+
+BESCHREIBUNG
+ Nachdem eine Zeile in eine Tabelle mit einer AUTO_INCREMENT-Spalte
+ eingefuegt wurde, kann man mit dieser Funktion den (neuen) Wert
+ dieses AUTO_INCREMENT-Feldes der eingefuegten Zeile abfragen.
+
+ Diese Funktion ist nur verfuegbar, wenn der Driver mit SQLite-
+ Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __SQLITE__ definiert.
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.713.
+
+SIEHE AUCH
+ sl_open(E), sl_exec(E), sl_close(E)
diff --git a/doc/efun/sl_open b/doc/efun/sl_open
new file mode 100644
index 0000000..b54685d
--- /dev/null
+++ b/doc/efun/sl_open
@@ -0,0 +1,20 @@
+OPTIONAL
+SYNOPSIS
+ int sl_open(string filename)
+
+BESCHREIBUNG
+ Oeffnet die Datei <filename> als SQLite-Datenbank. Falls
+ sie noch nicht existiert, wird sie erstellt. Es ist nur
+ eine geoeffnete Datenbank pro Objekt erlaubt. Im Erfolgsfalle
+ liefert diese Funktion 1 zurueck, anderenfalls wird
+ normalerweise ein Fehler ausgeloest.
+
+ Diese Funktion ist nur verfuegbar, wenn der Driver mit SQLite-
+ Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __SQLITE__ definiert.
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.713.
+
+SIEHE AUCH
+ sl_exec(E), sl_insert_id(E), sl_close(E)
diff --git a/doc/efun/snoop b/doc/efun/snoop
new file mode 100644
index 0000000..484b202
--- /dev/null
+++ b/doc/efun/snoop
@@ -0,0 +1,22 @@
+GESCHUETZT
+SYNOPSIS
+ int snoop(object snooper);
+ int snoop(object snooper, object snoopee);
+
+BESCHREIBUNG
+ Beginnt die Beobachtung des Objekts <snoopee> durch <snooper>. Wenn
+ <snoopee> nicht angegeben wird, werden alle Beobachtungen von
+ <snooper> beendet.
+
+ Die Funktion liefert 1 bei Erfolg, -1 wenn eine Schleife entstehen
+ wuerde und 0 fuer alle anderen Fehler.
+
+ Die Beobachtung wird mit dem Master-Objekt auf Gueltigkeit geprueft.
+ Es wird auch ein Fehler verursacht, wenn eine Beobachtung zu einer
+ Rekursion fuehren wuerde.
+
+ANMERKUNG
+ Diese Funktion ist geschuetzt.
+
+SIEHE AUCH
+ query_snoop(E)
diff --git a/doc/efun/sort_array b/doc/efun/sort_array
new file mode 100644
index 0000000..b4a65ca
--- /dev/null
+++ b/doc/efun/sort_array
@@ -0,0 +1,111 @@
+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
+
+BESCHREIBUNG
+ Erzeugt eine (flache) Kopie des Arrays 'arr' und sortiert diese mit der
+ Sortierfunktion 'func'. Die sortierte Kopie wird dann zurueckgegeben.
+
+ 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.
+
+ Verwendung von Methoden:
+ Wenn bei der Angabe von 'func' kein Objekt 'ob' in Form eines Strings
+ oder Objekts angegeben wird, wird this_object() angenommen.
+
+ 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.
+
+BEMERKUNGEN:
+ (1) sort_array() unterstuetzt keinen extra-Parameter
+
+ (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:
+
+ 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
+
+ resultieren folgende Arrays: i == ({ ({1}),({2,3}),({8,5,6}) })
+ j == ({ ({8,5,6}),({2,3}),({1}) })
+
+BEISPIELE:
+ ### Sortieren von Zahlen in aufsteigender Reihenfolge ###
+
+ int *arr = ({ 3, 8, 1, 3 })
+
+ // Folgend identische Resultate, aber andere Ansaetze:
+
+ #1: nutzt die 'Efun' > als Lfun-Closure (ideal hier):
+ sort_array(arr, #'>);
+
+ #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")
+
+ #2b: nutzt die Lfun is_greater() als Lfun-Closure (Funktionspointer)
+ sort_array(arr, #'is_greater)
+
+ #3: nutzt eine Lambda-Closure (langsamer, nicht fuer alle leserlich)
+ sort_array(arr, lambda(({'a, 'b}), ({#'>, 'a, 'b})))
+
+ #4: analog zu 3, mit Inline-Closure
+ sort_array(arr, function int (int a, int b) {
+ return a > b; } );
+
+ Resultat in allen Faellen: ({1,3,3,8})
+
+ ### Sortieren von geschachtelten Arrays ###
+
+ arr = ({ ({ "foo", 3 }), ({ "quux", 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];
+ }
+
+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
diff --git a/doc/efun/sprintf b/doc/efun/sprintf
new file mode 100644
index 0000000..3cb6970
--- /dev/null
+++ b/doc/efun/sprintf
@@ -0,0 +1,147 @@
+SYNOPSIS
+ string sprintf(string fmt, ...)
+
+BESCHREIBUNG
+ Mit dieser Funktion kann man auf einfache Weise aus dem Inhalt
+ von Variablen einen String bauen; und dies effektiver als
+ mit der ueblichen "Du hast "+anzahl+" Punkt(e)"-Methode.
+
+ Die Funktion bekommt als erstes Argument einen Formatstring fmt,
+ der Informationen darueber enthaelt, wie die weiteren beliebigen
+ Argumente in den Ergebnisstring eingebaut werden sollen.
+ Die meisten Zeichen gelangen vom Formatstring unveraendert in
+ den Ausgabestring. Die Regeln zum Einbau eines Arguments werden
+ immer mit '%' eingeleitet. Moechte man ein '%' in die Ausgabe
+ bringen, so muss man im Formatstring "%%" verwenden.
+
+ Ein einfaches Beispiel ist erg=sprintf("%s %d", str, i);
+ '%' leitet einen Argumentformatstring (AFS) ein. Das 's' schliesst
+ ihn ab und besagt, dass ein String eingebaut werden soll. Das
+ folgende Leerzeichen wird unveraendert uebernommen. '%' leitet
+ wieder einen neuen Formatstring ein, wobei 'd' eine Ganzzahl
+ bezeichnet (eine Variable von Typ int).
+ Dies ist ein allerdings nur ein sehr einfaches Beispiel.
+
+ Jeder Argumentformatstring kennzeichnet also, auf welche Art
+ ein Argument in das Ergebnis eingebaut werden soll. Der erste
+ AFS ist fuer das zweite Argument der Funktion, der zweite AFS
+ fuer das dritte Argument u.s.w. (das erste Argument der Funktion
+ ist ja der Formatstring selbst).
+
+ Jeder AFS beginnt mit einem '%' und endet mit einem der
+ folgenden Zeichen (Argumenttyp-Kennzeichner):
+ Zeichen Argumenttyp Bemerkung
+ 's' string
+ 'c' integer als ASCII-Zeichen
+ 'd' 'i' integer Dezimalschreibweise
+ 'o' integer Oktalschreibweise
+ 'b' 'B' integer Binaerschreibweise
+ 'x' 'X' integer Hexadezimalschreibweise
+ 'e' 'E' float Exponentialschreibweise
+ 'f' 'F' float Gleitkommadarstellung
+ 'g' 'G' float Gleitkommadarstellung
+ 'O' mixed Gibt fuer Debugging alles irgendwie
+ lesbar aus, auch Arrays und Mappings
+ 'Q' mixed Wie 'O', gibt jedoch Sonderzeichen in
+ Strings in der LPC-Notation aus
+
+ Zwischen dem '%' und dem Argumenttyp-Kennzeichner kann man
+ noch mehrere Modifikatoren setzen, die das Verhalten
+ beeinflussen.
+ Hier eine Uebersicht. n steht hier fuer eine Ganzzahl, also
+ zum Beispiel "12".
+ Modifikator Bedeutung
+ n Minimale Stringlaenge, die fuer dieses Argument
+ verwendet werden soll. Fehlende Zeichen werden mit
+ einem Fuellzeichen aufgefuellt. Beginnt n mit einer
+ '0' (etwa "08") so ist das Fuellzeichen '0' sonst
+ ist es per Default ' '. (sogenannte 'Feldbreite')
+ .n Bei Ganzzahlen die Maxanzahl der Stellen, bei Gleit-
+ kommazahlen die Maximalzahl der Nachkommastellen.
+ Bei (einfachen) Strings die Maximallaenge.
+ :n Ist dasselbe wie n.n - setzt also beide Werte auf
+ dieselbe Zahl.
+ 'X' Als Fuellzeichen wird X genutzt. X koennen dabei
+ auch mehrere Zeichen sein, etwa fuehrt '-=' zu
+ Fuellungen der Art "-=-=-=-=". Um mit Hochkommas
+ zu fuellen ist '\\'' anzugeben. Rueckwaerts-
+ schraegstrich entsprechend mit '\\\\'.
+ <Space> Vor positive Zahlen wird ein Leerzeichen gefuegt.
+ + Vor positive Zahlen wird ein '+' gefuegt.
+ - Der Wert wird linksbuendig in das fuer dieses Argument
+ vorgesehene Feld eingefuegt (Standard ist rechts-
+ buendig). Bei Strings wird meistens diese Ausrichtung
+ die sinnvollste sein.
+ | Der Wert wird zentriert in das Feld eingefuegt.
+ (Siehe Modifikator n, Feldbreite)
+ $ Blocksatz. Benoetigt eine Feldbreite, funktioniert nur
+ bei Strings (auch im Spaltenmodus).
+ = Spaltenmodus (siehe unten).
+ # Fuer Strings: Tabellenmodus (siehe unten).
+ Fuer '%O'/'%Q': kompakte Ausgabe.
+ @ Arraymodus (siehe unten).
+ * Ein Stern kann immer dort eingesetzt werden, wo
+ hier weiter oben ein n fuer eine Ganzzahl steht.
+ Der Wert der Zahl muss dann als weiterer Parameter
+ an die Funktion uebergeben werden.
+
+BEISPIELE
+ Mit den bis jetzt erwaehnten Moeglichkeiten kann man zB machen:
+
+ sprintf("%d (dec) == %o (octal) == %x (hex)", 20, 20, 20);
+ => "20 (dec) == 24 (octal) == 14 (hex)"
+
+ sprintf("Du drehst den Knopf um %.3f Umdrehungen", 12.3456);
+ => "Du drehst den Knopf um 12.345 Umdrehungen"
+
+ sprintf("Du liest %|'*':9s", "Fiona");
+ => "Du liest **Fiona**"
+
+ sprintf("Auf dem Zettelstueck steht: %-.*s...", 7, "Hallo Du da");
+ => "Auf dem Zettelstueck steht: Hallo D...
+
+ERWEITERTE MODI
+ Mit dem Modifikatoren = # und @ stehen maechtige Werkzeuge zur
+ Verfuegung. Mit ein wenig Ueberlegung kann man sich oft viele
+ Zeilen Code ersparen.
+ Arraymodus (@):
+ sprintf("%@s", arr_of_string);
+ Der Argumentformatstring (allerdings ohne das @) wird sooft
+ hintereinandergereiht, wieviele Elemente das Array hat.
+ Jeder AFS wird dann fuer ein Element des Arrays benutzt.
+ sprintf("%@s", ({"aaa","bbb"})) ist somit dasselbe wie
+ sprintf("%s%s", "aaa", "bbb"). Allerdings passt es sich
+ immer an die Elementzahl der uebergebenden Arrays an.
+ Dies ist nuetzlich um Ergebnisse von map() oder aehnlich
+ auszugeben.
+ sprintf("%@s", map_objects(all_inventory(), "short"));
+ Der Argumenttyp-Kennzeichner muss hierbei immer dem Typen
+ eines Elementes des Arrays entsprechen.
+ Spaltenmodus (=):
+ Diese Funktion bricht Text um. Die Feldbreite muss angegeben
+ werden. Wird neben der Feldbreite auch eine maximale String-
+ laenge angegeben, so wird die letztere fuer die Breite des
+ Umbrechens verwendet, die Feldbreite wird mit Fuellzeichen
+ aufgefuellt.
+ sprintf("%=-20s", str); bricht den String str 'wordwrap'end
+ auf 20 Zeichen Laenge um. sprintf("%=-*s", len, str);
+ ist schon eine einfache break_string() Variante.
+ Tabellenmodus (#):
+ Diese Funktion gibt Strings tabellenartig aus. Die Teilstrings
+ muessen mit \n getrennt als ein String als Argument uebergeben
+ werden. Die Feldbreite muss angegeben werden und bezeichnet
+ die (maximale) Gesamtbreite der Tabelle.
+ Die Anzahl der Spalten der Tabelle wird moeglichst optimal
+ bestimmt, und ist fuer alle Spalten gleich. Wird ein
+ Wert als 'Praezision' angegeben, so ist dies die Anzahl von
+ Spalten, die verwendet werden soll.
+ sprintf("%#30.4s", str) erzeugt eine Tabelle, die maximal
+ 30 Zeichen breit ist und 4 Spalten enthaelt.
+ sprintf("%#30s", str) legt die Spaltenzahl dynamisch anhand
+ der Einzelstringlaengen fest, so dass der laengste String
+ noch genau in die Tabelle passt.
+ Wenn string* worte die in die Tabelle einzubettenden Worte
+ enthaelt, so muss str=implode(worte,"\n") sein.
+
+SIEHE AUCH:
+ printf(E)
diff --git a/doc/efun/sqrt b/doc/efun/sqrt
new file mode 100644
index 0000000..44c4805
--- /dev/null
+++ b/doc/efun/sqrt
@@ -0,0 +1,9 @@
+SYNOPSIS
+ float sqrt(int value);
+ float sqrt(floag value);
+
+BESCHREIBUNG
+ Liefert die Quadratwurzel von <value>.
+
+SIEHE AUCH
+ log(E), pow(E)
\ No newline at end of file
diff --git a/doc/efun/sscanf b/doc/efun/sscanf
new file mode 100644
index 0000000..a616bf2
--- /dev/null
+++ b/doc/efun/sscanf
@@ -0,0 +1,115 @@
+FUNKTION:
+ int sscanf(string str,string fmt,mixed var1,mixed var2,...)
+
+ARGUMENTE:
+ str
+ - String, der nach einem Muster zu durchsuchen ist
+ - darf nicht NULL sein
+ fmt
+ - Format-String, nach dessen Muster untersucht wird
+ var1,var2,...
+ - Argumente die mit %d oder %s korrespondieren
+
+RUeCKGABEWERT:
+ Anzahl der gefundenen Argumente.
+
+BESCHREIBUNG:
+ Wertet einen String <str> unter Beruecksichtigung des Formats <fmt>
+ aus. <fmt> kann Strings beinhalten, die durch %d und %s getrennt
+ werden. Jedes %d und %s entspricht einer der Variablen <var1>, <var2>,
+ etc. in die gespeichert werden soll.
+
+ Die Operatoren im Format-String <fmt> haben eines der folgenden
+ Formate:
+
+ %[+][!|~][<size>[.<minmatch>]]<type>
+
+ <type> kann folgendes sein:
+ d: steht fuer eine Zahl
+ D: steht fuer eine Zahl
+ U:
+ s: steht fuer eine Zeichenkette
+ %: steht fuer das %-Zeichen
+ t: steht fuer Whitespaces (also Leerschlaege und Tabulatoren),
+ speichert diese aber nicht.
+
+ <size> ist die erwartete Feldgroesse, <minmatch> die verlangte
+ minimale Laenge fuer einen Treffer (Standardwerte sind 0 fuer
+ Strings und 1 fuer Nummern). Sowohl <size> als auch <minmatch> kann
+ entweder numerisch oder mit '*' angegeben werden - im zweiten Fall
+ wird die gueltige Variable in der Liste der Argumente benutzt.
+
+ Wird + angegeben, muessen die Zeichen nach dem Feld ebenfalls
+ matchen. Ist dies nicht der Fall, wird auch dieses Feld als
+ Misserfolg in der Rueckgabe betrachtet (auch wenn der Wert
+ bereits an die zugehoerige Variable zugewiesen wurde).
+
+ Wird ! angegeben, wird zwar die Suche durchgefuehrt, aber Treffer
+ werden weder gespeichert noch gezaehlt. Mit ~ als Argument wird
+ zwar die Suche durchgefuehrt und die Treffer gezaehlt, das Resultat
+ wird aber nicht gespeichert.
+
+ Wenn ein %s nicht am Ende von <fmt> steht, wird nur ein Treffer
+ registriert, wenn auch der nachfolgende String bzw. das
+ nachfolgende Format gefunden wird. Weiter unten gibt es dazu
+ ein Beispiel.
+ Bei einem %d allerdings muss dieses Verhalten mit einem '+'
+ erzwungen werden.
+
+ Der Unterschied zwischen %d und %D %U ist, dass letzteres ein
+ unmittelbar vorausgehendes %s so bald als moeglich abbricht,
+ waehrend ersteres zuerst versucht, einen moeglichst grossen Treffer
+ fuer %s zu erzielen. Trotzdem ueberspringt %D/%U keine Whitespaces,
+ dazu muss %.0t%D gesetzt werden.
+
+ Die Funktion sscanf() ist insofern ein Spezialfall, als dass
+ Argumente automatisch nach Referenz uebergeben werden.
+
+BEISPIELE:
+ string who, what;
+ if (sscanf("wirf frisbee zu rex",
+ "wirf %s zu %s", what, who) != 2)
+ write("Usage: Wirf <what> zu <who>\n");
+ else
+ write("Du wirfst einen "+what+" zu "+who+".\n");
+
+ sscanf("ab", "%s%s", who, what)
+ ==> liefert 2, who = "", what = "ab"
+
+ sscanf("ab", "%s %s", who, what)
+ ==> liefert 0, who = 0, what = 0
+
+ sscanf("ab ", "%s %s", who, what)
+ ==> liefert 2, who = "ab", what = ""
+
+
+ // Achtung bei %d
+ sscanf("12 ","%d xyz", num1);
+ ==> liefert 1, num1 = 12
+
+ sscanf("12 ","%s xyz", num1);
+ ==> liefert 0, num1 = 0
+
+ // mit '+' wird das Parsen des Restformats erzwungen:
+ sscanf("12 ","%+d xyz", num1);
+ ==> liefert 0, num1 = 12
+
+
+ // Weiteres Beispiel zu %d:
+ sscanf("get 12 coins","get %d rubys",num)
+ ==> ergibt 1, weil 'rubys' ignoriert wird
+
+ // Beispiel Format-Ignore 2
+ sscanf("get 12 coins","get %+d rubys",num);
+ ==> ergibt 0, da mit dem '+' das Parsen des Restformats erzwungen wird
+ ==> ergibt 1 bei 'get 12 rubys'
+
+ // Beispiel Format-Ignore 3 [alte Variante]
+ sscanf("get 12 coins","get %d rubys%s", num, dummy)
+ ==> ergibt 1
+ ==> ergibt 2 bei "get 12 rubys"
+
+SIEHE AUCH:
+ explode(E), regexp(E)
+
+8.Aug 2007 Gloinson
diff --git a/doc/efun/strftime b/doc/efun/strftime
new file mode 100644
index 0000000..c167afb
--- /dev/null
+++ b/doc/efun/strftime
@@ -0,0 +1,112 @@
+SYNOPSIS
+ string strftime()
+ string strftime(string fmt)
+ string strftime(int clock)
+ string strftime(string fmt, int clock)
+ string strftime(string fmt, int clock, int localized)
+
+BESCHREIBUNG
+ Gibt, aehnliche wie ctime(), eine Zeit als formatierten String zurueck.
+ Hierbei kann ein String mit div. Platzhaltern vom Benutzer angegeben
+ werden (s.u.). Wird kein String angegeben, wird "%c" als Formatstring
+ benutzt.
+
+ Das Argument <clock> wird als Anzahl Sekunden seit dem 01.01.1970, 00:00
+ Uhr interpretiert. Wenn <clock> nicht angegeben wird, wird time()
+ verwendet.
+
+ Das Argument <localized> gibt an, ob die Ausgabe englisch (das sog.
+ klassische "C" locale) oder in der jeweiligen Landessprache (z.B.
+ deutsch) erfolgen soll. Hierbei haengt die Sprache allerdings von den auf
+ dem Mudrechner gesetzten Umgebungsvariablen LC_TIME oder LC_ALL ab, sie
+ kann nicht selber gewaehlt werden. Wird kein <localized> angegeben, wird
+ 1 verwendet, was einer Ausgabe in Landessprache entspricht.
+ 0: Ausgabe im klassischen "C" locale (english)
+ 1: Ausgabe in Landessprache des Mudrechners.
+
+BEMERKUNGEN:
+ Der zurueckgebene Ergebnisstring ist max. 511 Zeichen lang.
+
+PLATZHALTER:
+ Diese Funktion versteht alle Platzhalter, die die Funktion strftime() aus
+ der C-Standardbibliothek versteht. Momentan sind dies:
+ %a Der abgekuerzte Wochentag abhaengig von der momentanen Locale.
+ %A Der gesamte Wochentag abhaengig von der momentanen Locale.
+ %b Der abgekuerzte Monatsname abhaengig von der momentanen Locale.
+ %B Der volle Monatsname abhaengig von der momentanen Locale.
+ %c Das bevorzugte Datums- und Uhrzeit-Repraesentation laut Einstel-
+ lungen der momentanen Locale.
+ %C Das Jahrhundert als zweistellige Zahl.
+ %d Der Tag im Monat als Dezimalzahl (01 - 31).
+ %D Aequivalent zu %m/%d/%y. (US-amerikanisches Format. In anderen
+ Laendern ist %d/%m/%y durchaus ueblich . In internationalem Kon-
+ text ist dieses Format daher mehrdeutig und sollte nicht verwen-
+ det werden.)
+ %e Wie %d, der Tag im Monat als Dezimalzahl, aber eine fuehrende
+ Null ist durch ein Leerzeichen ersetzt.
+ %E Modifikator: Alternatives Format benutzen, s.u.
+ %g Wie %G, aber ohne das Jahrhundert, also mit zweistelligem Jahr
+ (00-99).
+ %G Das Jahr laut ISO 8601 mit dem Jahrhundert als Dezimalzahl. Das
+ vierstellige Jahr, das zu ISO-Wochennummer (siehe %V) passt. Es
+ hat dasselbe Format und denselben Wert wie %y, nur dass, wenn
+ die ISO-Wochennummer zum vorhergehenden oder naechsten Jahr
+ gehoert, dieses Jahr stattdessen benutzt wird.
+ %h Aequivalent zu %b.
+ %H Die Stunde im 24h-Format als Ganzzahl (00 - 23).
+ %I Die Stunde im 12h-Format als Ganzzahl (01 - 12).
+ %j Der Tag im Jahr als Ganzzahl (001 - 366).
+ %k Die Stunde im 24h-Format als Ganzzahl (0 - 23); einzelne Ziffern
+ haben ein vorangestelltes Leerzeichen. (Siehe %H.)
+ %l Die Stunde im 12h-Format als Ganzzahl (0 - 12); einzelne Ziffern
+ haben ein vorangestelltes Leerzeichen. (Siehe %I.)
+ %m Der Monat als Ganzzahl (01 - 12).
+ %M Die Minute als Ganzzahl (00 - 59).
+ %n Ein Zeilenvorschub.
+ %p Entweder 'AM' oder 'PM', je nach der uebergebenen Uhrzeit, oder
+ die zugehoerigen Zeichenketten in der momentanen Locale. Mittag
+ erhaelt 'PM', Mitternacht 'AM'.
+ %P Wie %p, aber in Kleinbuchstaben.
+ %r Zeit in AM/PM-Notation; in der POSIX-Locale ist das Aequivalent
+ zu '%I:%M:%S %p'.
+ %R Zeit in 24h-Notation (%H:%M). (SU) Fuer eine Version mit Sekunden
+ siehe %T.
+ %s Die Zahl der Sekunden seit der Epoche, also seit 1970-01-01
+ 00:00:00 UTC.
+ %S Die Sekunde als Ganzzahl (00 - 61).
+ %t Ein Tabulatorzeichen.
+ %T Zeit in 24h-Notation (%H:%M:%S).
+ %u Der Tag der Woche als Zahl von 1 bis 7, mit Montag als 1. Siehe
+ auch %w.
+ %U Die Wochennummer des aktuellen Jahres als Ganzzahl von 00 bis
+ 53, beginnend mit dem ersten Sonntag als erster Tag der ersten
+ Woche. Siehe auch %V und %W.
+ %V Die Wochennummer nach ISO 8601:1988 als Dezimalzahl von 01 bis
+ 53, wobei Woche 1 die erste Woche ist, die wenigstens 4 Tage im
+ laufenden Jahr hat, mit Montag als dem ersten Tag der Woche.
+ Siehe auch %U und %W.
+ %w Der Tag der Woche als Zahl von 0 bis 6, mit Sonntag als 0.
+ Siehe auch %u.
+ %W Die Wochennummer des aktuellen Jahres als Ganzzahl von 00 bis
+ 53, beginnend mit dem ersten Montag als erster Tag der ersten
+ Woche.
+ %x Die bevorzugte Datums-Repraesentation ohne die Zeit in der momen-
+ tanen Locale.
+ %X Die bevorzugte Uhrzeit-Repraesentation ohne das Datum in der
+ momentanen Locale.
+ %y Das Jahr als Ganzzahl ohne das Jahrhundert (00 - 99).
+ %Y Das Jahr als Ganzzahl mit dem Jahrhundert.
+ %z Die Zeitzone als Stundendifferenz zu GMT. Benoetigt, um
+ RFC822-konforme Datumsangaben zu erhalten (mit '%a, %d %b %Y
+ %H:%M:%S %z').
+ %Z Die Zeitzone oder der Name oder die Abkuerzung.
+ %+ Datum und Zeit im Format von date(1).
+ %% Das Zeichen '%'.
+
+BEISPIEL
+ write(strftime("Heute ist %A, der %d. %B %Y.\n"))
+ ergibt z.B.
+ "Heute ist Montag, der 24. September 2007.\n"
+
+SIEHE AUCH
+ ctime(E), gmtime(E), localtime(E), mktime(E), time(E), utime(E)
diff --git a/doc/efun/strftime.en b/doc/efun/strftime.en
new file mode 100644
index 0000000..ca0aa65
--- /dev/null
+++ b/doc/efun/strftime.en
@@ -0,0 +1,122 @@
+SYNOPSIS
+ string strftime()
+ string strftime(string fmt)
+ string strftime(int clock)
+ string strftime(string fmt, int clock)
+ string strftime(string fmt, int clock, int localized)
+
+BESCHREIBUNG
+ Gibt, aehnliche wie ctime(), eine Zeit als formatierten String zurueck.
+ Hierbei kann ein String mit div. Platzhaltern vom Benutzer angegeben
+ werden (s.u.). Wird kein String angegeben, wird "%c" als Formatstring
+ benutzt.
+
+ Das Argument <clock> wird als Anzahl Sekunden seit dem 01.01.1970, 00:00
+ Uhr interpretiert. Wenn <clock> nicht angegeben wird, wird time()
+ verwendet.
+
+ Das Argument <localized> gibt an, ob die Ausgabe englisch (das sog.
+ klassische "C" locale) oder in der jeweiligen Landessprache (z.B.
+ deutsch) erfolgen soll. Hierbei haengt die Sprache allerdings von den auf
+ dem Mudrechner gesetzten Umgebungsvariablen LC_TIME oder LC_ALL ab, sie
+ kann nicht selber gewaehlt werden. Wird kein <localized> angegeben, wird
+ 1 verwendet, was einer Ausgabe in Landessprache entspricht.
+
+BEMERKUNGEN:
+ Der zurueckgebene Ergebnisstring ist max. 511 Zeichen lang.
+ Im MG erfolgt momentan immer eine englische Ausgabe.
+
+PLATZHALTER:
+ Diese Funktion versteht alle Platzhalter, die die Funktion strftime() aus
+ der C-Standardbibliothek versteht. Momentan sind dies:
+
+ %a
+ is replaced by the locale's abbreviated weekday name.
+ %A
+ is replaced by the locale's full weekday name.
+ %b
+ is replaced by the locale's abbreviated month name.
+ %B
+ is replaced by the locale's full month name.
+ %c
+ is replaced by the locale's appropriate date and time representation.
+ %C
+ is replaced by the century number (the year divided by 100 and
+ truncated to an integer) as a decimal number [00-99].
+ %d
+ is replaced by the day of the month as a decimal number [01,31].
+ %D
+ same as %m/%d/%y.
+ %e
+ is replaced by the day of the month as a decimal number [1,31]; a
+ single digit is preceded by a space.
+ %h
+ same as %b.
+ %H
+ is replaced by the hour (24-hour clock) as a decimal number
+ [00,23].
+ %I
+ is replaced by the hour (12-hour clock) as a decimal number
+ [01,12].
+ %j
+ is replaced by the day of the year as a decimal number
+ [001,366].
+ %m
+ is replaced by the month as a decimal number [01,12].
+ %M
+ is replaced by the minute as a decimal number [00,59].
+ %n
+ is replaced by a newline character.
+ %p
+ is replaced by the locale's equivalent of either a.m. or p.m.
+ %r
+ is replaced by the time in a.m. and p.m. notation; in the POSIX
+ locale this is equivalent to %I:%M:%S %p.
+ %R
+ is replaced by the time in 24 hour notation (%H:%M).
+ %S
+ is replaced by the second as a decimal number [00,61].
+ %t
+ is replaced by a tab character.
+ %T
+ is replaced by the time (%H:%M:%S).
+ %u
+ is replaced by the weekday as a decimal number [1,7], with 1
+ representing Monday.
+ %U
+ is replaced by the week number of the year (Sunday as the first day
+ of the week) as a decimal number [00,53].
+ %V
+ is replaced by the week number of the year (Monday as the first day
+ of the week) as a decimal number [01,53]. If the week containing 1
+ January has four or more days in the new year, then it is considered
+ week 1. Otherwise, it is the last week of the previous year, and the
+ next week is week 1.
+ %w
+ is replaced by the weekday as a decimal number [0,6], with 0
+ representing Sunday.
+ %W
+ is replaced by the week number of the year (Monday as the first day
+ of the week) as a decimal number [00,53]. All days in a new year
+ preceding the first Monday are considered to be in week 0.
+ %x
+ is replaced by the locale's appropriate date representation.
+ %X
+ is replaced by the locale's appropriate time representation.
+ %y
+ is replaced by the year without century as a decimal number [00,99].
+ %Y
+ is replaced by the year with century as a decimal number.
+ %Z
+ is replaced by the timezone name or abbreviation, or by no bytes if
+ no timezone information exists.
+ %%
+ is replaced by %.
+
+BEISPIEL
+ write(strftime("Heute ist %A, der %d. %B %Y.\n"))
+ ergibt z.B.
+ "Heute ist Montag, der 24. September 2007.\n"
+
+SIEHE AUCH
+ gmtime(E), localtime(E), mktime(), time(E), utime(E)
diff --git a/doc/efun/stringp b/doc/efun/stringp
new file mode 100644
index 0000000..97d82b0
--- /dev/null
+++ b/doc/efun/stringp
@@ -0,0 +1,10 @@
+SYNOPSIS
+ int stringp(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument eine Zeichenkette (String) ist,
+ ansonsten 0.
+
+SIEHE AUCH
+ closurep(E), floatp(E), mappingp(E), objectp(E), intp(E),
+ referencep(E), pointerp(E), symbolp(E), clonep(E)
diff --git a/doc/efun/strlen b/doc/efun/strlen
new file mode 100644
index 0000000..e081a7a
--- /dev/null
+++ b/doc/efun/strlen
@@ -0,0 +1,11 @@
+SYNOPSIS
+ int strlen(string str)
+
+BESCHREIBUNG
+ Liefert die Laenge eines Strings.
+ Diese efun ist VERALTET und ersetzt durch sizeof().
+ Bitte in neuem Code nicht mehr benutzen und in altem
+ Code sukzessive ersetzen.
+
+SIEHE AUCH
+ sizeof(E), extract(E)
diff --git a/doc/efun/strrstr b/doc/efun/strrstr
new file mode 100644
index 0000000..bc039b6
--- /dev/null
+++ b/doc/efun/strrstr
@@ -0,0 +1,25 @@
+SYNOPSIS
+ int strrstr(string str, string muster);
+ int strrstr(string str, string muster, int pos);
+
+BESCHREIBUNG:
+ Liefert den Index des ersten Auftretens von <muster> im String <str>,
+ ausgehend von der Position <pos> her rueckwaerts gesucht. Wird <pos>
+ nicht angegeben, wird als Standard -1 gesetzt, was dem Ende von <str>
+ entspricht. Mit anderen Worten: die Funktion liefert den Index des
+ letzten Auftretens von <muster> vor <pos>.
+
+ Der Index, der zurueck gegeben wird, ist relativ zum Beginn des
+ Strings <str>.
+
+ Wenn <muster> nicht in <str> gefunden wird, wird -1 zurueck gegeben.
+
+ Wenn <pos> negativ ist, bezeichnet <pos> den Index vom Ende des
+ Strings aus gezaehlt. Dabei wird die Suche aber dennoch rueckwaerts
+ im String <str> durchgefuehrt.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.10
+
+SIEHE AUCH
+ strstr(E), strlen(E), sscanf(E), sprintf(E), explode(E)
diff --git a/doc/efun/strstr b/doc/efun/strstr
new file mode 100644
index 0000000..ea5cb83
--- /dev/null
+++ b/doc/efun/strstr
@@ -0,0 +1,17 @@
+SYNOPSIS
+ int strstr(string str, string muster);
+ int strstr(string str, string muster, int pos);
+
+BESCHREIBUNG
+ Liefert den Index des ersten Auftretens von <muster> in <str>,
+ ausgehend von der Position <pos>, wobei in <str> vorwaerts gesucht
+ wird. Wird <pos> nicht angegeben, wird als Standardwert 0 gesetzt,
+ also vom Beginn von <str> her gesucht.
+
+ Wenn <muster> nicht gefunden wird, wird -1 zurueck geliefert.
+
+ Wenn <pos> negativ ist, bezeichnet <pos> die Startposition der Suche
+ relativ zum Ende von <str>, es wird aber weiterhin vorwaerts gesucht.
+
+SIEHE AUCH
+ strrstr(E), strlen(E), sscanf(E), sprintf(E), explode(E)
diff --git a/doc/efun/struct_info b/doc/efun/struct_info
new file mode 100644
index 0000000..4d4cd0b
--- /dev/null
+++ b/doc/efun/struct_info
@@ -0,0 +1,46 @@
+SYNOPSIS
+ #include <struct_info.h>
+ #include <lpctypes.h>
+
+ mixed * struct_info (struct st, int what)
+
+DESCRIPTION
+ Return information about the structure of struct <st> in an array.
+ If <st> has a base struct, <what> determines how the information
+ is returned:
+
+ <what> == SINFO_FLAT:
+ All members of <st>, including those inherited from the base
+ struct, are returned on the top level of the result.
+ The base struct is signified by just its name.
+
+ <what> == SINFO_NESTED:
+ Only the members defined in <st> itself are returned on
+ the top level of the result. The information for the base
+ struct is a array by itself, as it would be returned
+ by a call to struct_info() for a base struct instance.
+
+ The elements in the resulting array are:
+
+ string [SI_NAME]: the name of the struct
+ string [SI_PROG_NAME]: the name of program defining the struct
+ string [SI_PROG_ID]: the id of the program defining the struct
+ mixed [SI_BASE]: 0, or the base struct information
+ mixed* [SI_MEMBER+0]: the first member information
+ mixed* [SI_MEMBER+n]: the last member information
+
+ The member information entries are arrays themselves with
+ these elements:
+
+ string [SIM_NAME]: name of the member
+ int [SIM_TYPE]: the type of the member (compile-time value)
+ string [SIM_EXTRA]: 0, or if the member is a struct, the
+ struct name
+
+HISTORY
+ Introduced in LDMud 3.3.344.
+ LDMud 3.3.417 introduced SI_PROG_NAME and SI_PROG_ID in exchange
+ for SI_UNIQUE_NAME.
+
+SEE ALSO
+ structs(LPC)
diff --git a/doc/efun/structp b/doc/efun/structp
new file mode 100644
index 0000000..0b1668d
--- /dev/null
+++ b/doc/efun/structp
@@ -0,0 +1,13 @@
+SYNOPSIS
+ int structp(mixed arg)
+
+DESCRIPTION
+ Return 1 if arg is a struct.
+
+HISTORY
+ Introducted in LDMud 3.3.273.
+
+SEE ALSO
+ baseof(E), closurep(E), floatp(E), mappingp(E), objectp(E),
+ intp(E), referencep(E), pointerp(E), stringp(E), symbolp(E),
+ clonep(E)
diff --git a/doc/efun/swap b/doc/efun/swap
new file mode 100644
index 0000000..fd242e4
--- /dev/null
+++ b/doc/efun/swap
@@ -0,0 +1,7 @@
+GESCHUETZT
+SYNOPSIS
+ void swap(object obj);
+
+BESCHREIBUNG
+ Lagert ein Objekt aus. Diese Efun ist nur fuer systeminternes
+ Debugging und kann einen Absturz verursachen.
diff --git a/doc/efun/symbol_function b/doc/efun/symbol_function
new file mode 100644
index 0000000..dbb53d0
--- /dev/null
+++ b/doc/efun/symbol_function
@@ -0,0 +1,36 @@
+SYNOPSIS
+ closure symbol_function(symbol arg);
+ closrue symbol_function(string arg);
+ closure symbol_function(string arg, object|string obj);
+
+BESCHREIBUNG
+ Erzeugt eine Lfun-, Efun- oder Operator-Closure aus <arg>, wobei
+ <arg> entweder ein string oder ein symbol sein muss. Fuer
+ Lfun-Closures gibt <obj> an, zu welchem Objekt die Lfun gehoert,
+ entweder angegeben durch das Objekt selbst (bzw. einen pointer
+ darauf) oder durch den Objektnamen als String. Wenn ein String
+ angegeben wird, wird das Objekt beim Aufruf geladen.
+
+ Wenn die Closure fuer eine Lfun in einem anderen als dem momentanen
+ Objekt erzeugt wird, ergibt dies eine "alien lfun closure". Solche
+ Closures sind an das Objekt gebunden, das symbol_function()
+ aufgerufen hat (dieses Objekt wird von to_object() geliefert),
+ obwohl der eigentliche Code in einem anderen Objekt steht (das mit
+ get_type_info() gefunden werden kann).
+
+ Als "private" deklarierte Funktionen koennen auf diese Weise nie
+ zu einer Closure gewandelt werden, "static" und "protected"
+ deklarierte Lfuns nur dann, wenn <obj> das gueltige Objekt
+ (d.h. this_object()) ist.
+ Expord.h. tiert man die Closures, koennen sie unabhaengig vom Modifier der
+ Ursprungsfunktionen von jedem gerufen werden.
+ umgehen).
+
+BEISPIELE
+ symbol_function("efun::users");
+ --> ergibt: #'users
+ symbol_function("QueryProp", other_obj);
+ --> ergibt: other_obj->QueryProp()
+
+SIEHE AUCH
+ lambda(E), quote(E)
diff --git a/doc/efun/symbol_variable b/doc/efun/symbol_variable
new file mode 100644
index 0000000..b3a66d4
--- /dev/null
+++ b/doc/efun/symbol_variable
@@ -0,0 +1,29 @@
+SYNOPSIS
+ closure symbol_variable(string arg);
+ closure symbol_variable(symbol arg);
+ closure symbol_variable(int arg);
+
+BESCHREIBUNG
+ Erzeugt eine Identifier (Lfun) Closure aus der globalen Variablen
+ <arg> des gueltigen Objekts. Die Variable kann angegeben werden
+ als Symbol, mit ihrem Namen oder durch die ordinale Nummer in der
+ Variablentabelle des Objekts.
+
+ Wenn keine solche Variable existiert oder sie von aussen nicht
+ sichtbar ist, wird 0 zurueck geliefert.
+
+ Wenn <arg> ein Integer ist und sich auf eine geerbte Variable
+ bezieht, die im geerbten Objekt "private" deklariert ist (d.h.
+ versteckt), fuehrt dies zu einer Schutzverletzung.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2.1@8
+
+BEISPIELE
+ int base;
+ int var;
+ symbol_variable("var"); ergibt: #'<this_object>->var
+ symbol_variable(0); ergibt: #'<this_object>->base
+
+SIEHE AUCH
+ lambda(E), quote(E), symbol_function(E)
diff --git a/doc/efun/symbolp b/doc/efun/symbolp
new file mode 100644
index 0000000..92c64b7
--- /dev/null
+++ b/doc/efun/symbolp
@@ -0,0 +1,14 @@
+SYNOPSIS
+ int symbolp(mixed arg)
+
+BESCHREIBUNG
+ Liefert 1, wenn das Argument ein Symbol ist, ansonsten 0.
+
+BEISPIEL
+ symbolp('foo) liefert 1.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2@70.
+
+SIEHE AUCH
+ intp(E), quote(E)
diff --git a/doc/efun/tail b/doc/efun/tail
new file mode 100644
index 0000000..8c50b35
--- /dev/null
+++ b/doc/efun/tail
@@ -0,0 +1,9 @@
+SYNOPSIS
+ void tail(string file);
+
+BESCHREIBUNG
+ Listet das Ende eines Files. Es gibt kein Zeilenlimit, es werden aber
+ maximal 1000 Bytes ausgegeben.
+
+SIEHE AUCH
+ cat(E), ed(E)
diff --git a/doc/efun/tan b/doc/efun/tan
new file mode 100644
index 0000000..f99a085
--- /dev/null
+++ b/doc/efun/tan
@@ -0,0 +1,11 @@
+SYNOPSIS
+ float tan(int|float)
+
+BESCHREIBUNG
+ Liefert den Tangens des Argumentes.
+
+AENDERUNGEN
+ LDMud 3.2.9: Ganzzahlen (Integers) als Argument hinzugefuegt.
+
+SIEHE AUCH
+ sin(E), asin(E), cos(E), acos(E), atan(E), atan2(E)
diff --git a/doc/efun/tell_object b/doc/efun/tell_object
new file mode 100644
index 0000000..e2cfd9c
--- /dev/null
+++ b/doc/efun/tell_object
@@ -0,0 +1,47 @@
+SYNOPSIS
+ 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).
+
+ Ist die Nachricht ein String, wird der Text an interaktive Objekte
+ direkt ausgegeben, fuer andere Objekte wird die lfun catch_tell()
+ in diesen 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:
+
+ 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:
+
+ Objekt1:
+ void catch_tell(string str) {
+ write("Erhaltener Text: "+str+"\n");
+ }
+
+ Objekt2:
+ void fun() {
+ object wer;
+ wer = find_living("dummymonster");
+ tell_object(wer, "Folge mir, Sterblicher!\n");
+ ...
+ }
+
+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
diff --git a/doc/efun/tell_room b/doc/efun/tell_room
new file mode 100644
index 0000000..77f302c
--- /dev/null
+++ b/doc/efun/tell_room
@@ -0,0 +1,79 @@
+FUNKTION:
+ 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);
+
+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.
+
+ 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, die Nachricht, kein String ist, wird in
+ allen Lebewesen, die den Text erhalten, catch_msg() anstatt
+ catch_tell() aufgerufen.
+
+ 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.
+
+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!)
+
+ - 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()):
+ void catch_tell(string str) {
+ write("Empfangen: "+str+"\n");
+ }
+
+ Objekt2:
+ void fun() {
+ 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)
+
+7.Aug 2007 Gloinson
diff --git a/doc/efun/terminal_colour b/doc/efun/terminal_colour
new file mode 100644
index 0000000..6cd1bce
--- /dev/null
+++ b/doc/efun/terminal_colour
@@ -0,0 +1,127 @@
+SYNOPSIS
+ varargs string terminal_colour(string str,
+ null | mapping | closure map,
+ int wrap, int indent);
+BESCHREIBUNG
+ Ist <map> ein Wert ungleich 0, ersetzt diese Efun alle Farb-
+ Definitionen der Form "%^KEY%^" (siehe unten fuer Details) im
+ String <str> und ersetzt sie durch die entsprechenden Werte aus dem
+ unter <map> angegebenen Farbschluessel.
+
+ Ist <map> ein Mapping, muessen die Eintraege das Format
+ "KEY" : "wert" haben; Eintraege, die keine Strings enthalten,
+ werden ignoriert. Einzige Ausnahme dazu: enthaelt <map> einen
+ Eintrag der Form 0:wert, wird dieser fuer alle Farbdefinitionen
+ verwendet, die keinem anderen Schluessel zugeordnet werden koennen.
+ <wert> kann in diesem Fall ein String oder eine Closure sein. Handelt
+ es sich um eine Closure, erhaelt diese den <KEY> als Argument und
+ muss einen String zurueck liefern, der <KEY> ersetzt.
+
+ Ist <map> eine Closure, wird diese mit den Farbdefinitionen <KEY>
+ als Argument aufgerufen und muss einen String zurueck liefern, der
+ die <KEY>s ersetzt.
+
+ Die speziellen Schluessel "%^%^" und "%%^^" werden immer durch das
+ Literal "%^" ersetzt.
+
+ Die Parameter <wrap> und <indent> sind optional. Ist nur <wrap>
+ angegeben, wird <str> in der Spalte <wrap> umgebrochen. Ist
+ zusaetzlich <indent> angegeben, werden alle umgebrochenen Zeilen
+ um <indent> Spalten eingerueckt.
+
+ Der Zeilenumbruch ignoriert die Laenge der Farbmakros und ihrer
+ Inhalte. Er bricht <str> anhand der Laenge der uebrigen Zeichen
+ um, ist also farb-neutral.
+
+ Ist <map> als 0 angegeben, fuehrt die Efun kein Suchen und Ersetzen
+ von Farbdefinitionen durch. Die Funktionalitaet von Zeilenumbruch
+ und Einrueckung bleiben erhalten, wenn gewuenscht. Auf diese Weise
+ dupliziert terminal_colour() die Funktion von sprintf("%-=s") und
+ wirkt als einfache Zeilenumbruch Funktion.
+
+
+ ERKENNEN VON FARBDEFINITIONEN
+
+ Wie bereits erwaehnt, werden die speziellen Schluessel "%^%^" und
+ "%%^^" durch das Literal "%^" ersetzt und spielen im Weiteren
+ keine Rolle.
+
+ Fuer den Eingabestring wird das folgende Format vorausgesetzt:
+
+ text { '%^' colorkey '%^' text } [ '%^' colorkey ]
+
+ Oder in Worten: die Efun trennt den String bei jedem '%^', das
+ sie antrifft und behandelt anschliessend jeden zweiten Teilstring
+ als Farbschluessel.
+
+ Merke: dieses Verhalten unterscheidet sich von der Behandlung des
+ Eingabestrings unter MudOS. Dort lautet die Syntax:
+
+ key_oder_text { '%^' key_oder_text }
+
+ Oder in Worten: die MudOS Efun trennt den String bei jedem '%^'
+ und versucht dann jeden Teilstring als Farbschluessel zu behandeln.
+ Dieses Verhalten laesst sich auch unter LPC erreichen:
+
+ string mudos_terminal_colour(string str, mapping ext, int w, int i)
+ {
+ return terminal_colour("%^"+implode(explode(str, "%^")-({""})
+ ,"%^%^")
+ , ext, w, i);
+ }
+
+
+BEISPIELE
+ mapping trans;
+ string str;
+
+ trans = ([ "GREEN" : "ansi-green", "RED" : "", "BLUE" : 1 ]);
+
+ str = terminal_colour( "%^GREEN%^ and %^RED%^ and %^BLUE%^", trans );
+
+ Dies fuehrt zu str == "ansi-green and and BLUE".
+
+ "%^GREEN^%" wird ersetzt durch "ansi-green", weil <trans> das so
+ definiert,
+ "%^RED%^" wird aus <str> entfernt, weil es mit "" ersetzt wird, und
+ "%^BLUE%^" wird um die "%^" verkuert, weil der Eintrag zu BLUE in
+ <trans> keinen gueltigen Wert enthaelt (d.h. kein String ist). Das
+ selbe wuerde passieren, wenn <str> "%^DEFINE%^" enthalten wuerde,
+ zu dem es keinen Eintrag in <trans> gibt.
+
+ Merke: um direkt benachbarte Schluessel zu ersetzen, soll die
+ Efun wie folgt verwendet werden:
+
+ str = terminal_colour( "%^GREEN%^%^RED%^", trans );
+
+ Eine Eingabe der Form
+
+ str = terminal_colour( "%^GREEN%^RED%^", trans );
+
+ fuehrt zum logischen, aber vielleicht unerwarteten Ergebnis
+ "ansi-greenRED".
+
+
+ Einige Worte zum Zeilenumbruch:
+
+ Ein String, der ohne Einrueckung umgebrochen wird (<indent> ist 0),
+ sieht so aus:
+
+ "dies ist die erste Zeile\nund dies ist die zweite Zeile"
+
+ Ein String, der mit <indent> 3 umgebrochen wird, sieht so aus:
+
+ "dies ist die erste Zeile\n und dies ist die zweite Zeile"
+
+AENDERUNGEN
+ Die Idee fuer diese Efun und die erste Implementierung stammen
+ aus MudOS; die Strategie fuer das Erkennen von Schluesseln
+ (eingeschlossen die pure Zeilenumbruch Funktion) wurde in
+ LDMud 3.2.8 geglaettet.
+ LDMud 3.2.9 fuegte die Verwendung von Closures zur Definition
+ von Farbschluesseln hinzu. Es erklaerte zudem offiziell das
+ Verhalten betreffen "%%^^" aus Gruenden besserer Kompatibilitaet
+ mit MudOS.
+
+SIEHE AUCH
+ sprintf(E)
diff --git a/doc/efun/test_bit b/doc/efun/test_bit
new file mode 100644
index 0000000..af82c95
--- /dev/null
+++ b/doc/efun/test_bit
@@ -0,0 +1,21 @@
+SYNOPSIS
+ int test_bit(string str, int n);
+
+BESCHREIBUNG
+ Gibt 0 oder 1 des <n>-ten Bits im String <str> zurueck.
+
+ Jedes Zeichen besteht aus 6 Bits. Jedem Zeichen ist also ein Wert
+ zwischen 0 und 63 zugeordnet (weil 2^6=64). Das erste Zeichen ist der
+ Leerschlag " " mit dem Wert 0 (keines der Bits ist gesetzt). Das
+ erste Zeichen im String ist dasjenige mit den niedrigsten Bits (0-5).
+
+BEISPIELE
+ test_bit("_", 5); Liefert 1, weil "_" das 63. Zeichen ist und
+ deshalb das 5. Bit gesetzt hat.
+
+ test_bit(" ", 3); Liefert 0, weil " " das 0. Zeichen ist und deshalb
+ kein Bit gesetzt hat.
+
+SIEHE AUCH
+ set_bit(E), clear_bit(E), last_bit(E), next_bit(E), count_bits(E),
+ and_bits(E), or_bits(E), xor_bits(E), invert_bits(E), copy_bits(E)
diff --git a/doc/efun/this_interactive b/doc/efun/this_interactive
new file mode 100644
index 0000000..92938bb
--- /dev/null
+++ b/doc/efun/this_interactive
@@ -0,0 +1,9 @@
+SYNOPSIS
+ object this_interactive();
+
+BESCHREIBUNG
+ Die Funktion gibt das momentane interaktive Objekt zurueck, falls
+ vorhanden, also dasjenige welches "die Entertaste gedrueckt hat".
+
+SIEHE AUCH
+ this_player(E), previous_object(E), interactive(E), living(E)
diff --git a/doc/efun/this_object b/doc/efun/this_object
new file mode 100644
index 0000000..5b60276
--- /dev/null
+++ b/doc/efun/this_object
@@ -0,0 +1,10 @@
+SYNOPSIS:
+ object this_object(void)
+
+DESCRIPTION:
+ Return the object pointer for this object. This is not to be
+ confused with the internal name of an object, which is used by
+ the id() function.
+
+SEE ALSO:
+ this_player(E), previous_object(E), object_name(E), find_object(E)
diff --git a/doc/efun/this_player b/doc/efun/this_player
new file mode 100644
index 0000000..5ab6420
--- /dev/null
+++ b/doc/efun/this_player
@@ -0,0 +1,18 @@
+SYNOPSIS
+ object this_player();
+
+BESCHREIBUNG
+ Liefert den momentanen Kommandogeber. Das kann ein interaktiver
+ Benutzer oder ein lebendiges Objekt sein, zum Beispiel ein NPC.
+
+ Wenn die Funktion von innerhalb des heart_beat() eines nicht
+ lebendigen Objekts aufgerufen wird, wird 0 zurueck gegeben.
+
+BEISPIEL
+ if(this_player() != this_interactive())
+ {
+ write("Hey, jemand zwingt uns, Kommandos auszufuehren!\n");
+ }
+
+SIEHE AUCH
+ this_object(E), previous_object(E), interactive(E), living(E)
diff --git a/doc/efun/throw b/doc/efun/throw
new file mode 100644
index 0000000..2a21cde
--- /dev/null
+++ b/doc/efun/throw
@@ -0,0 +1,16 @@
+SYNOPSIS
+ void throw(mixed arg);
+
+BESCHREIBUNG
+ Bricht die Programmverarbeitung ab. Wenn die Verarbeitung mit catch()
+ gestartet wurde, gibt dieses catch() <arg> als Fehlermeldung aus.
+
+ Der Aufruf von throw() ohne vorheriges catch() ist sinnlos und
+ erzeugt einen "throw without catch" Fehler.
+
+BEISPIEL
+ catch(throw("Verarbeitung abgebrochen!"));
+ Das macht nichts als "Verarbeitung abgebrochen!" auszugeben.
+
+SIEHE AUCH
+ catch(E), raise_error(E)
diff --git a/doc/efun/time b/doc/efun/time
new file mode 100644
index 0000000..f7016a4
--- /dev/null
+++ b/doc/efun/time
@@ -0,0 +1,21 @@
+SYNOPSIS
+ int time();
+
+BESCHREIBUNG
+ Liefert die Anzahl Sekunden, die seit dem 01. Januar 1970,
+ 00:00:00 GMT verstrichen sind.
+
+ Die Zeitangabe basiert auf der Systemzeit des Hosts, der Driver
+ stellt jedoch sicher, dass das Resultat von time() monoton ansteigt
+ (also immer nur zu hoeheren Werten wechselt).
+
+ Das Resultat von time() veraendert sich nicht waehrend dem Abarbeiten
+ eines Kommandos.
+
+BEISPIEL
+ Um das aktuelle Datum und die aktuelle Zeit anzuzeigen:
+
+ write(ctime(time())+"\n");
+
+SIEHE AUCH
+ ctime(E), gmtime(E), localtime(E), utime(E)
diff --git a/doc/efun/tls_available b/doc/efun/tls_available
new file mode 100644
index 0000000..804a03d
--- /dev/null
+++ b/doc/efun/tls_available
@@ -0,0 +1,19 @@
+PRELIMINARY
+SYNOPSIS
+ int tls_available()
+
+DESCRIPTION
+ If the global TLS initialisation could not been set up,
+ tls_is_available() returns 0, otherwise 1.
+ It is not very useful calling any other tls_*-efun if this one
+ returns 0, since there is no TLS-encryption available.
+ Most likely the global initialisation fails due to missing or
+ unreadable key resp. certificate-file.
+
+HISTORY
+ Introduced in LDMud 3.3.474 and following, backported to 3.2.11.
+
+SEE ALSO
+ tls_init_connection(E), tls_deinit_connection(E),
+ tls_query_connection_state(E), tls_query_connection_info(E),
+ tls_check_certificate(E), tls_refresh_certs(E)
diff --git a/doc/efun/tls_check_certificate b/doc/efun/tls_check_certificate
new file mode 100644
index 0000000..f8afc8e
--- /dev/null
+++ b/doc/efun/tls_check_certificate
@@ -0,0 +1,49 @@
+PRELIMINARY
+SYNOPSIS
+ mixed *tls_check_certificate(object obj);
+ mixed *tls_check_certificate(object obj, int extra);
+
+DESCRIPTION
+ tls_check_certificate() checks the certificate of the secured
+ connection bound to <obj> (default is the current object). If
+ <obj> is not interactive, or if TLS is not available, an error
+ is thrown.
+
+ If <obj> doesn't have a secure connection up and running, an
+ error is thrown.
+ Otherwise, the result is an array with these values:
+
+ int [0] : Result code of SSL_get_verify_result (see man 1 verify
+ subsection DIAGNOSTICS for possible values)
+ array [1] : array with 3*n entries of extra x509 data.
+ structure is:
+ 3*i : numerical form of object name,
+ e.g. "2.5.4.3"
+ 3*i + 1: long or short name if available,
+ e.g. "commonName"
+ 3*i + 2: value
+ array [2] : if extra is set:
+ array with 3*n entries of x509 extension data
+ data structure is:
+ 3*i : numerical form of extension name
+ 3*i + 1: long or short name of extension
+ name if available
+ 3*i + 2: array of strings with the data
+ structure of [1]
+
+ Note: a x509 certificate can have more than one object with
+ the same name
+
+BUGS
+ Not supported when using GnuTLS.
+
+HISTORY
+ Introduced in LDMud 3.3.672/3.2.11.
+ LDMud 3.3.711/3.2.12 modified the behaviour to return the
+ low-level API result value, and to throw an error if the connection
+ is not secure.
+
+SEE ALSO
+ tls_init_connection(E), tls_deinit_connection(E), tls_error(E),
+ tls_query_connection_state(E), tls_query_connection_info(E),
+ tls_available(E), tls_refresh_certs(E), mudlib/psyc-tls.c
diff --git a/doc/efun/tls_deinit_connection b/doc/efun/tls_deinit_connection
new file mode 100644
index 0000000..7883801
--- /dev/null
+++ b/doc/efun/tls_deinit_connection
@@ -0,0 +1,20 @@
+PRELIMINARY
+SYNOPSIS
+ void tls_deinit_connection(object ob)
+
+DESCRIPTION
+ tls_deinit_connection() shuts down a TLS connection to
+ the interactive object <ob> (or this_object() if <ob> is not
+ given) but the connection is not closed.
+
+ Under normal circumstances there is no need to use this efun: most
+ clients operate in either secure or unsecure mode, but don't allow
+ switching connection security on the fly.
+
+HISTORY
+ Introduced in LDMud 3.3.474 and following, backported to 3.2.11.
+
+SEE ALSO
+ tls_init_connection(E), tls_error(E), tls_query_connection_state(E),
+ tls_query_connection_info(E), tls_available(E),
+ tls_check_certificate(E), tls_refresh_certs(E)
diff --git a/doc/efun/tls_error b/doc/efun/tls_error
new file mode 100644
index 0000000..2b5c788
--- /dev/null
+++ b/doc/efun/tls_error
@@ -0,0 +1,15 @@
+PRELIMINARY
+SYNOPSIS
+ string tls_error(int errorno)
+
+DESCRIPTION
+ tls_error() returns a string describing the error behind the
+ error number errorno.
+
+HISTORY
+ Introduced in LDMud 3.3.474 and following, backported to 3.2.11.
+
+SEE ALSO
+ tls_init_connection(E), tls_deinit_connection(E),
+ tls_query_connection_state(E), tls_query_connection_info(E),
+ tls_available(E), tls_check_certificate(E), tls_refresh_certs(E)
diff --git a/doc/efun/tls_init_connection b/doc/efun/tls_init_connection
new file mode 100644
index 0000000..e33afae
--- /dev/null
+++ b/doc/efun/tls_init_connection
@@ -0,0 +1,50 @@
+PRELIMINARY
+SYNOPSIS
+ int tls_init_connection(object ob)
+ int tls_init_connection(object ob, string fun, string|object fob, mixed extra...)
+ int tls_init_connection(object ob, closure fun, mixed extra...)
+
+DESCRIPTION
+ tls_init_connection() tries to start a TLS secured connection to
+ the interactive object <ob> (or this_object() if <ob> is not given).
+
+ Result:
+ errorcode < 0: unsuccessful, use tls_error() to get an useful
+ description of the error
+ number > 0: the secure connection is still being set up in the
+ background
+ number == 0: the secure connection is active.
+
+ OpenSSL only:
+
+ If the callback <fun>/<fun>:<fob> is specified, it will be called
+ once the fate of the secure connection has been determined. The
+ first argument will be the return code from the handshake
+ (errorcode < 0 on failure, or 0 on success), followed by the
+ interactive object <ob> and any <extra> arguments.
+
+ If the TLS setup fails, it is not necessary to call
+ tls_deinit_connection().
+
+ IMPORTANT: During the TLS handshake nothing else must be sent
+ to the client! For the most cases (TLS-capable clients logging in)
+ this means that the TLS handshake is the first and only thing the
+ client gets to see while the handshake is in progress.
+
+ The driver automatically suppresses the printing of the prompt
+ while the TLS handshake is in progress.
+
+ If tls_init_connection() is called in the master::connect() function,
+ the driver will either call the set callback in place of logon(), or
+ if not callback has been set, delay the call of logon() until the
+ state of the connection is clear.
+
+HISTORY
+ Introduced in LDMud 3.3.474 and following, backported to 3.2.11.
+ LDMud 3.2.13/3.3.713 streamlined the handling of secure connections
+ during logon.
+
+SEE ALSO
+ tls_deinit_connection(E), tls_error(E), tls_query_connection_state(E),
+ tls_query_connection_info(E), tls_available(E),
+ tls_check_certificate(E), tls_refresh_certs(E), connect(M), logon(A)
diff --git a/doc/efun/tls_query_connection_info b/doc/efun/tls_query_connection_info
new file mode 100644
index 0000000..32aeef7
--- /dev/null
+++ b/doc/efun/tls_query_connection_info
@@ -0,0 +1,37 @@
+PRELIMINARY
+SYNOPSIS
+ #include <sys/ tls.h>
+ int *tls_query_connection_info (object ob)
+
+DESCRIPTION
+ If <ob> does not have a TLS connection or if the connection
+ is still being set-up, or if <ob> is not interactive, the efun
+ returns 0.
+
+ If <ob> has a TLS connection, tls_query_connection_info()
+ returns an array that contains some parameters of <ob>'s
+ connection:
+
+ int|string [TLS_CIPHER]: the cipher used
+ int [TLS_COMP]: the compression used
+ int [TLS_KX]: the key-exchange used
+ int [TLS_MAC]: the digest algorithm used
+ int|string [TLS_PROT]: the protocol used
+
+ To translate these numbers into strings, <tls.h> offers a
+ number of macros:
+
+ TLS_xxx_TABLE: a literal array of strings describing the
+ value in question.
+ TLS_xxx_NAME(x): a macro translating the numeric result
+ value into a string.
+
+ xxx: CIPHER, COMP, KX, MAC, PROT
+
+HISTORY
+ Introduced in LDMud 3.3.474 and following, backported to 3.2.11.
+
+SEE ALSO
+ tls_init_connection(E), tls_deinit_connection(E), tls_error(E),
+ tls_query_connection_state(E), tls_available(E),
+ tls_check_certificate(E), tls_refresh_certs(E)
diff --git a/doc/efun/tls_query_connection_state b/doc/efun/tls_query_connection_state
new file mode 100644
index 0000000..2624f20
--- /dev/null
+++ b/doc/efun/tls_query_connection_state
@@ -0,0 +1,16 @@
+PRELIMINARY
+SYNOPSIS
+ int tls_query_connection_state(object ob)
+
+DESCRIPTION
+ tls_query_connection_state() returns a positive number if <ob>'s
+ connection is TLS secured, 0 if it's unsecured, and a negative number
+ if the TLS connection setup is still being set-up.
+
+HISTORY
+ Introduced in LDMud 3.3.474 and following, backported to 3.2.11.
+
+SEE ALSO
+ tls_init_connection(E), tls_deinit_connection(E), tls_error(E),
+ tls_query_connection_info(E), tls_available(E),
+ tls_check_certificate(E), tls_refresh_certs(E)
diff --git a/doc/efun/tls_refresh_certs b/doc/efun/tls_refresh_certs
new file mode 100644
index 0000000..c8364c5
--- /dev/null
+++ b/doc/efun/tls_refresh_certs
@@ -0,0 +1,17 @@
+PRELIMINARY
+SYNOPSIS
+ void tls_refresh_certs()
+
+DESCRIPTION
+ Reload the certificates and certificate revocation information.
+
+BUGS
+ Not supported when using GnuTLS.
+
+HISTORY
+ Introduced in LDMud 3.3.714/3.2.15.
+
+SEE ALSO
+ tls_init_connection(E), tls_deinit_connection(E), tls_error(E),
+ tls_query_connection_state(E), tls_query_connection_info(E),
+ tls_available(E), tls_check_certificate(E), mudlib/psyc-tls.c
diff --git a/doc/efun/to_array b/doc/efun/to_array
new file mode 100644
index 0000000..21b1a93
--- /dev/null
+++ b/doc/efun/to_array
@@ -0,0 +1,30 @@
+SYNOPSIS
+ mixed *to_array(string arg);
+ mixed *to_array(symbol arg);
+ mixed *to_array(quotedarray arr);
+ mixed *to_array(mixed *arg);
+ mixed *to_array(struct);
+
+ (int*)<value>
+
+BESCHREIBUNG
+ Strings und Symbole werden umgewandelt in ein Integer-Array, das aus
+ den Zeichen von <arg> besteht.
+
+ Gequotete Arrays werden "entquotet", und Arrays bleiben, wie sie sind.
+
+ Structs werden in normale Arrays umgewandelt.
+
+BEISPIELE:
+ to_array("12") liefert ({33,34}).
+
+BUGS
+ Die Cast-Schreibweise funktioniert nur, wenn der genaue Wert von
+ <value> zum Zeitpunkt der Kompilierung bekannt ist. Dies wird
+ nicht geaendert werden, da die Funktionsform verwendet werden kann.
+
+HISTORY
+ LDMud 3.3.250 added structs to the accepted data types.
+
+SIEHE AUCH
+ to_int(E), to_string(E), to_struct(E)
diff --git a/doc/efun/to_float b/doc/efun/to_float
new file mode 100644
index 0000000..7b989ce
--- /dev/null
+++ b/doc/efun/to_float
@@ -0,0 +1,19 @@
+SYNOPSIS
+ float to_float(int arg);
+ float to_float(string arg);
+ float to_flaot(float arg);
+
+ (float)<value>
+
+BESCHREIBUNG
+ Integers werden zu Floats erweitert, Strings werden in Floats
+ konvertiert bis zum ersten Zeichen, das nicht mehr zum Float
+ gehoert. Floats werden direkt zurueck gegeben.
+
+BUGS
+ Die Cast-Schreibweise funktioniert nur, wenn der genaue Wert von
+ <value> zum Zeitpunkt der Kompilierung bekannt ist. Dies wird nicht
+ geaendert werden, da die Funktionsform verwendet werden kann.
+
+SIEHE AUCH
+ to_string(E), to_int(E), sscanf(E)
diff --git a/doc/efun/to_int b/doc/efun/to_int
new file mode 100644
index 0000000..6c648e4
--- /dev/null
+++ b/doc/efun/to_int
@@ -0,0 +1,32 @@
+SYNOPSIS
+ int to_int(string arg);
+ int to_int(float arg);
+ int to_int(int arg);
+ int to_int(closure arg);
+
+ (int)<value>
+
+BESCHREIBUNG
+ Bei Floats werden die Nachkommastellen abgeschnitten, Strings mit
+ Ziffern am Anfang werden bis zum ersten Nicht-Ziffern-Zeichen in
+ Integers umgewandelt. Lfun-Closures werden in ihren Funktionsindex
+ konvertiert, Variablen-Closures in ihren Variablenindex. Integers
+ werden unveraendert zurueck gegeben.
+
+ Bezueglich Floats ist es wichtig, Rundungseffekte zu beachten:
+ to_int(3.1*10.0) ergibt nicht 31, sondern 30, weil intern das
+ Resultat der Multiplikation 30.999999 ergibt.
+
+ Diese Funktion unterstuetzt die Basisprefixe '0x', '0o' und '0b'.
+
+BUGS
+ Die Cast-Schreibweise funktioniert nur, wenn der genaue Wert von
+ <value> zum Zeitpunkt der Kompilierung bekannt ist. Dies wird
+ nicht geaendert werden, da die Funktionsform verwendet werden kann.
+
+AENDERUNGEN
+ Eingefuehrt in 3.2.1@2
+ LDMud 3.2.11 fuehrte die Basisprefixe ein.
+
+SIEHE AUCH
+ to_string(E), sscanf(E)
diff --git a/doc/efun/to_object b/doc/efun/to_object
new file mode 100644
index 0000000..bb577f0
--- /dev/null
+++ b/doc/efun/to_object
@@ -0,0 +1,15 @@
+SYNOPSIS
+ object to_object(string arg)
+ object to_object(closure arg)
+ object to_object(object arg)
+
+DESCRIPTION
+ The argument is converted into an object, if possible.
+ For strings, the object with a matching object_name() is
+ returned, or 0 if there is none, as find_object() does.
+ For (bound!) closures, the object holding the closure is
+ returned.
+ Objects and the number 0 return themselves.
+
+SEE ALSO
+ find_object(E), to_array(E), to_int(E), to_string(E)
diff --git a/doc/efun/to_string b/doc/efun/to_string
new file mode 100644
index 0000000..1d23ef6
--- /dev/null
+++ b/doc/efun/to_string
@@ -0,0 +1,29 @@
+SYNOPSIS
+ string to_string(mixed arg)
+
+BESCHREIBUNG
+ <arg> wird in einen String umgewandelt. Das klappt mit Werten vom Typ
+ int, float, object, array, struct, symbol, string oder closure.
+
+ Closures werden in einen passenden Namen umgewandelt (vorwiegend fuer
+ Debugging-Zwecke geeignet).
+
+ANMERKUNGEN
+ Arrays werden als "explodete" Strings betrachtet, also Arrays von
+ Zeichencodes. Sie werden bis zur ersten 0 oder bis zum ersten
+ nicht-numerischen Eintrag "implodet", je nachdem, was zuerst eintritt.
+
+ Das bedeutet, dass to_string( ({ 49, 50 }) ); "12" liefert, und nicht
+ "({ 49, 50 })"
+
+FEHLER
+ Die Cast-Schreibweise funktioniert nur, wenn der genaue Wert von
+ <value> zum Zeitpunkt der Kompilierung bekannt ist. Dies wird nicht
+ geaendert werden, da die Funktionsform verwendet werden kann.
+
+GESCHICHTE
+ LDMud 3.2.8 laesst Lambdaclosures als gueltige Datentypen zu.
+ LDMud 3.3.250 laesst structs als gueltige Datentypen zu.
+
+SIEHE AUCH
+ to_array(E), to_int(E), to_object(E), to_struct(E), sprintf(E)
diff --git a/doc/efun/to_struct b/doc/efun/to_struct
new file mode 100644
index 0000000..e5b0bfa
--- /dev/null
+++ b/doc/efun/to_struct
@@ -0,0 +1,47 @@
+SYNOPSIS
+ mixed to_struct(mixed *|mapping data)
+ mixed to_struct(mixed *|mapping data, struct template)
+ mixed to_struct(struct data)
+ mixed to_struct(struct data, struct template)
+
+DESCRIPTION
+ The given array, mapping or struct <data> is returned as a struct.
+ If a <template> struct is given, the returned struct is of the same
+ type. Without a template, an anonymous struct is returned in case of
+ arrays and mappings and in case of structs <data> is returned
+ unchanged.
+
+ If <data> is an array, its elements are assigned in order to the
+ resulting struct. For an anonymous struct, all elements of <data>
+ are assigned, for a templated struct only as many as fit into
+ the struct.
+
+ If <data> is a mapping and no template is given, the resulting
+ anonymous struct contains all elements from <data> with a string
+ key; the key name is used as struct member name.
+
+ If <data> is a mapping and a template is given, the struct
+ member names are used as keys for lookups in <data>; the found
+ data is assigned to the struct members.
+
+ If <data> is a struct and a template is given, a struct of the type
+ of template is created and all members from <data> are copied to the
+ new struct, which exist in both structs. This conversion is only
+ allowed between a struct and one of its base structs or a base struct
+ and one of its children. Otherwise an error is raised.
+
+ Neither <data> nor <template> will be changed in this process - the
+ result is a new struct value. The actual value of <template> does not
+ matter, only its type.
+
+ Since the returned struct can't be known at compile time, the
+ efun is declared to return 'mixed'.
+
+HISTORY
+ Introduced in LDMud 3.3.250 .
+ LDMud 3.3.344 added the template argument.
+ LDMud 3.3.433 added the conversion from mappings.
+ LDMud 3.3.720 added the conversion of structs into another struct.
+
+SEE ALSO
+ to_array(E), to_string(E), mkmapping(E), structs(LPC)
diff --git a/doc/efun/trace b/doc/efun/trace
new file mode 100644
index 0000000..36edc79
--- /dev/null
+++ b/doc/efun/trace
@@ -0,0 +1,54 @@
+GESCHUETZT
+SYNOPSIS
+ #include <sys/trace.h>
+
+ int trace(int traceflags);
+
+BESCHREIBUNG
+ Setzt die Trace Flags und liefert die alten Trace Flags zurueck.
+ Wenn Tracing eingeschaltet ist, wird waehrend der Ausfuehrung eine
+ Menge Informationen ausgegeben. Zu viel Output kann die Verbindung
+ lahm legen oder sogar den ganzen Treiber zum Absturz bringen.
+
+ Tracing erfolgt auf einer Pro-Verbindung-Basis: jeder interaktive (!)
+ User kann sein eigenes Tracelevel und -praefix festlegen. Jeder
+ erhaelt nur den Traceoutput fuer den Code, der waehrend der
+ Auswertung eines vom User eingegeben Kommandos ausgefuehrt wird.
+
+ Die Trace-Bits (aus <trace.h>) sind:
+
+ TRACE_NOTHING ( 0): Beendet das Tracing
+ TRACE_CALL ( 1): Tracet alle Aufrufe von Lfuns
+ TRACE_CALL_OTHER ( 2): Tracet alle call_other() Aufrufe
+ TRACE_RETURN ( 4): Tracet Resultate von Funktionen
+ TRACE_ARGS ( 8): Gibt Argumente und Resultate von
+ Funktionen aus
+ TRACE_EXEC ( 16): Tracet alle ausgefuehrten Anweisungen
+ TRACE_HEART_BEAT ( 32): Tracet den Heartbeat Code
+ TRACE_APPLY ( 64): Tracet Treiber-Applies
+ TRACE_OBJNAME (128): Gibt den Namen des Objektes aus
+
+ TRACE_EXEC und TRACE_HEART_BEAT sollten nicht verwendet werden, weil
+ sie massiven Output verursachen. TRACE_OBJNAME sollte nicht verwendet
+ werden, wenn bekannt ist, welches Objekt getracet wird.
+
+ Die Master-Lfun valid_trace() wird mit ("trace", traceflags)
+ aufgerufen, um die Erlaubnis fuer die Nutzung von trace() zu erhalten.
+
+BEISPIEL
+ object obj;
+ string prefix;
+ obj=find_player("thomas");
+ prefix=objec_name(obj);
+ prefix=prefix[1..strlen(prefix)-1]; /* entfernt den Praefix "/" */
+ traceprefix(prefix);
+ /* Von hier an wird nur Code im Objekt std/player#69 getracet */
+ trace(TRACE_CALL|TRACE_CALL_OTHER|TRACE_RETURN|TRACE_ARGS);
+ ...
+ trace(TRACE_NOTHING);
+
+AENDERUNGEN
+ LDMud 3.2.9 uebergibt auch <traceflags> an valid_trace()
+
+SIEHE AUCH
+ traceprefix(E)
diff --git a/doc/efun/traceprefix b/doc/efun/traceprefix
new file mode 100644
index 0000000..0f46f45
--- /dev/null
+++ b/doc/efun/traceprefix
@@ -0,0 +1,25 @@
+SYNOPSIS:
+ string traceprefix(string prefix)
+ string traceprefix(int dummy)
+
+DESCRIPTION:
+ If called with a string, only objects matching this prefix will
+ be traced. The string must not contain a leading "/" because
+ the object names are stored internally without it. If called
+ with a number, the traceprefix will be ignored and all objects
+ will be traced. Returns the last traceprefix or 0 if there
+ wasn't any.
+
+EXAMPLE:
+ object obj;
+ string prefix;
+ obj = find_player("deepthought");
+ prefix = object_name(obj);
+ prefix = prefix[1..strlen(prefix)-1]; /* cut off the leading "/" */
+ traceprefix(prefix);
+ trace(1|2|4|8);
+ ...
+ trace(0);
+
+SEE ALSO:
+ trace(E)
diff --git a/doc/efun/transfer b/doc/efun/transfer
new file mode 100644
index 0000000..b413f02
--- /dev/null
+++ b/doc/efun/transfer
@@ -0,0 +1,25 @@
+VERALTET
+SYNOPSIS
+ int transfer(object item, object dest)
+
+BESCHREIBUNG
+ Diese Funktion existiert lediglich aus Kompatibilitaetsgrunden, und
+ dann auch nur, wennn der Driver mit USE_DEPRECATED kompiliert wird.
+
+ Das Object <item> wird in Objekt <dest> bewegt. Verschiedene Tests
+ werden durchgefuehrt, und das Resultat beschreibt den (Miss)Erfolg:
+
+ 0: Erfolg.
+ 1: Zu schwer fuer <dest>
+ 2: Kann nicht fallen gelassen werden.
+ 3: Kann nicht aus seinem Behaelter genommen werden.
+ 4: <item> kann in keinen Behaelter gesteckt werden.
+ 5: <dest> akzeptiert <item> nicht.
+ 6: <item> kann nicht aufgenommen werden.
+
+ Die Funktion ruft die lfuns add_weight(), drop(), get(),
+ prevent_insert(), add_weight(), und can_put_and_get() nach Bedarf..
+
+SIEHE AUCH
+ move_object(E), drop(A), get(A), prevent_insert(A),
+ can_put_and_get(A), add_weight(A)
diff --git a/doc/efun/transpose_array b/doc/efun/transpose_array
new file mode 100644
index 0000000..68e2a78
--- /dev/null
+++ b/doc/efun/transpose_array
@@ -0,0 +1,22 @@
+SYNOPSIS:
+ mixed *transpose_array (mixed *arr);
+
+DESCRIPTION:
+ transpose_array ( ({ ({1,2,3}), ({a,b,c}) }) )
+ == ({ ({1,a}), ({2,b)}, ({3,c}) })
+
+ transpose_array() applied to an alist results in an array of
+ ({ key, data }) pairs, useful if you want to use sort_array()
+ or filter() on the alist.
+
+EXAMPLE:
+ sort_array(transpose_array( ({ m_indices(map), m_values(map) }) ),
+ lambda( ({ 'a, 'b }),
+ ({ #'<, ({ #'[, 'a, 0 }),
+ ({ #'[, 'b, 0}) }) ) )
+
+ The given mapping 'map' is returned as an array of
+ ({ key, data }) pairs, sorted by the keys.
+
+SEE ALSO:
+ alists(LPC), sort_array(E)
diff --git a/doc/efun/trim b/doc/efun/trim
new file mode 100644
index 0000000..4525a82
--- /dev/null
+++ b/doc/efun/trim
@@ -0,0 +1,33 @@
+SYNOPSIS
+ #include <sys/strings.h>
+
+ string trim(string str);
+ string trim(string str, int where);
+ string trim(string str, int where, string char);
+
+BESCHREIBUNG
+ Entfernt alle vorausgehenden und abschliessenden Zeichen <char> in
+ einem String <str> und gibt den neuen String zurueck.
+
+ <char> kann entweder ein oder mehrere Zeichen sein. Wird <char> nicht
+ angegeben, wird standardmaessig der Leerschlag " \t" genutzt.
+
+ Mit <where> kann angegeben werden, wo Zeichen entfernt werden:
+
+ TRIM_LEFT (1): entfernt alle vorausgehenden
+ Zeichen <char>
+ TRIM_RIGHT (2): entfernt alle abschliessenden
+ Zeichen <char>
+ TRIM_BOTH (3 oder 0): entfernt sowohl vorausgehende als auch
+ abschliessende Zeichen <char>
+
+BEISPIEL
+ trim(" 1234 "); ergibt: "1234"
+ trim(" 1234 ", TRIM_RIGHT); ergibt: " 1234"
+ trim(" 1234 ", TRIM_BOTH, " 1"); ergibt: "234"
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.7
+
+SIEHE AUCH
+ regreplace(E)
diff --git a/doc/efun/typeof b/doc/efun/typeof
new file mode 100644
index 0000000..151bb96
--- /dev/null
+++ b/doc/efun/typeof
@@ -0,0 +1,13 @@
+SYNOPSIS
+ int typeof(mixed arg);
+
+BESCHREIBUNG
+ Gibt einen Code fuer den Typ des Arguments <arg>. Die Typen sind
+ definiert in <sys/lpctypes.h>
+
+AENDERUNGEN
+ Eingefuehrt in 3.2@63
+
+SIEHE AUCH
+ get_type_info(E), intp(E), objectp(E), floatp(E), pointerp(E),
+ closurep(E), symbolp(E), stringp(E), mappingp(E)
diff --git a/doc/efun/unbound_lambda b/doc/efun/unbound_lambda
new file mode 100644
index 0000000..804b1b5
--- /dev/null
+++ b/doc/efun/unbound_lambda
@@ -0,0 +1,27 @@
+SYNOPSIS
+ closure unbound_lambda(mixed *arg, mixed code);
+
+BESCHREIBUNG
+ Erzeugt eine Lambda-Closure, die nicht an ein Objekt gebunden ist,
+ entsprechend einer Lambda-Funktion in LISP.
+
+ Die Closure kann keine Referenz zu globalen Variablen enthalten.
+ Lfun-Closures werden unveraendert in die Closure eingebunden, da es
+ kein Ursprungsobjekt fuer diese Closure gibt.
+
+ Bevor die Closure aufgerufen werden kann, muss sie an ein Objekt
+ gebunden werden. Normale Objekte koennen Closures nur an sich selbst
+ binden, das Binden an andere Objekte erzeugt eine Schutzverletzung.
+
+ Der Punkt ist, dass previous_object() fuer Aufrufe innerhalb der
+ Closure auf das Objekt zeigt, das bind_lambda() aufgerufen hat, und
+ alle objekt- oder uid-basierten Sicherheitschecks beziehen sich
+ auf jenes Objekt.
+
+ Das erste Argument <*arg> ist ein Array, das die Argumente (Symbole)
+ enthaelt, die an die Closure uebergeben werden, wenn diese mit
+ funcall() oder apply() ausgewertet wird. Das zweite Argument <code>
+ enthaelt den Code der Closure.
+
+SIEHE AUCH
+ closures(LPC), lambda(E), apply(E), funcall(E), bind_lambda(E)
diff --git a/doc/efun/unique_array b/doc/efun/unique_array
new file mode 100644
index 0000000..390c56e
--- /dev/null
+++ b/doc/efun/unique_array
@@ -0,0 +1,47 @@
+SYNOPSIS
+ mixed unique_array(object *obj, string|closure fun)
+ mixed unique_array(object *obj, string|closure fun, mixed skip)
+ mixed unique_array(object *obj, string|closure fun, mixed extra...
+ , mixed skip)
+
+BESCHREIBUNG
+ Gruppiert alle Objekte aus <*obj>, fuer die die Funktion <fun>
+ den gleichen Wert liefert. Wenn <*obj> etwas anderes als Objekte
+ enthaelt, werden diese ignoriert.
+
+ Ist die Funktion mit Namen angegeben, wird sie in jedem Objekt
+ in <*obj> einmal aufgerufen. Wurden <extra> Argumente
+ gegeben, werden diese an die Funktion bei jedem Aufruf als
+ Parameter uebergeben.
+
+ Ist die Funktion als Closure angegeben, wird sie fuer jedes Objekt
+ in <*obj> einmal aufgerufen, wobei das Objekt als erstes Argument
+ uebergeben wird, gefolgt von etwaiigen <extra> Argumenten.
+
+ Wird ein Argument <skip> angegeben (bei Verwendung von <extra>
+ Argumenten muss dies geschehen), und entspricht <skip> dem
+ Resultat von <separator> fuer ein Element aus <*obj>, so wird
+ dieses Element nicht in das Resultat von unique_array()
+ uebernommen.
+
+ Das Resultat von unique_array() hat die Form:
+
+ ({ ({same1:1, same1:2, ... same1:n}),
+ ({same2:1, same2:2, ... same2:n}),
+ ({samem:1, samem:2, ... samem:n}) })
+
+BEISPIEL
+ Um ein Array von Arrays zu erhalten, das alle Benutzer, nach Level
+ gruppiert, enthaelt:
+
+ mixed *arr;
+ arr=unique_array(users(), "_query_level", -1);
+
+ Goetter haben einen Level von -1. Sie werden nicht in arr aufgenommen,
+ weil <skip> == -1.
+
+SIEHE AUCH
+ Arrays: filter(E), map(E)
+ Objektarrays: filter_objects(E), map_objects(E)
+ Mappings: filter(E), map(E), filter_indices(E), map_indices(E)
+
diff --git a/doc/efun/unmkmapping b/doc/efun/unmkmapping
new file mode 100644
index 0000000..3beeccb
--- /dev/null
+++ b/doc/efun/unmkmapping
@@ -0,0 +1,27 @@
+SYNOPSIS
+ *mixed unmkmapping(mapping map);
+
+BESCHREIBUNG
+ Wandelt das Mapping <map> in ein Array von Arrays aus, das alle Keys
+ und Werte von <map> enthaelt und gibt dieses Array zurueck.
+
+ Das Resultat von unmkmapping() hat die Form ({ keys[], data0[],
+ data1[] ... }), wobei keys[] ein Array aller Keys ist, data0[] ein
+ Array mit allen Werten aus der ersten Spalte, data1[] ein Array mit
+ allen Werten aus der zweiten Spalte etc. Das heisst, dass die
+ Werte von key[x] in data0[x], data1[x] usw. gespeichert sind.
+
+ unmkmapping() ist die Umkehrfunktion von mkmapping(), sodass gilt:
+
+ apply(#'mkmapping, unmkmapping(m)) == m
+
+BEISPIEL
+ mapping m = ([ 1:10;20, 2:11;21 ]);
+ unmkmapping(m) ergibt: ({ ({1, 2}) , ({10, 11}) , ({20, 21}) })
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6.
+
+SIEHE AUCH
+ mappings(LPC), mappingp(E), m_indices(E), m_values(E), m_delete(E),
+ sizeof(E), widthof(E).
diff --git a/doc/efun/unquote b/doc/efun/unquote
new file mode 100644
index 0000000..8000060
--- /dev/null
+++ b/doc/efun/unquote
@@ -0,0 +1,17 @@
+SYNOPSIS
+ quoted_array unquote(quoted_array arr);
+ string|symbol unquote(symbol sym);
+
+BESCHREIBUNG
+ Entfernt ein Quote von einem gequoteten Array oder Symbol. Wenn das
+ letzte Quote von einem Symbol entfernt wird, entsteht ein String.
+
+BEISPIELE:
+ unquote('foo); ergibt: "foo"
+ unquote( '({1,2,3}) ); ergibt: ({1,2,3})
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ quote(E), symbolp(E)
diff --git a/doc/efun/unshadow b/doc/efun/unshadow
new file mode 100644
index 0000000..688d5ff
--- /dev/null
+++ b/doc/efun/unshadow
@@ -0,0 +1,21 @@
+FUNKTION
+ void unshadow()
+
+BESCHREIBUNG
+ Das aufrufende Objekt wird als Shadow von allen anderen Objekten
+ entfernt, denen es uebergeworfen war. Wenn dem aufrufenden Objekt
+ selbst ein Shadow uebergeworfen war, wird dieser entfernt.
+ Man sollte diese (s)efun rufen, bevor man den Schatten zerstoert.
+
+BEISPIELE
+ // B beschattet A
+ void b::stop_shadowing() {
+ unshadow();
+ }
+
+SIEHE AUCH
+ Generell: shadow(E)
+ Rechte: query_allow_shadow(M), query_prevent_shadow(L)
+ Informationen: query_shadowing(E)
+
+20.08.2009, Zesstra
diff --git a/doc/efun/upper_case b/doc/efun/upper_case
new file mode 100644
index 0000000..ac1ffa5
--- /dev/null
+++ b/doc/efun/upper_case
@@ -0,0 +1,12 @@
+SYNOPSIS
+ string upper_case(string str);
+
+BESCHREIBUNG
+ Wandelt alle Zeichen in <str> in Grossbuchstaben um und gibt das
+ Resultat zurueck.
+
+BEISPIEL
+ upper_case("Heya!") ergibt: "HEYA!"
+
+SIEHE AUCH
+ capitalize(E), lower_case(E)
diff --git a/doc/efun/users b/doc/efun/users
new file mode 100644
index 0000000..48b4ae3
--- /dev/null
+++ b/doc/efun/users
@@ -0,0 +1,5 @@
+SYNOPSIS
+ *object users();
+
+BESCHREIBUNG
+ Liefert ein Array, das alle interaktiven Benutzer enthaelt.
diff --git a/doc/efun/utime b/doc/efun/utime
new file mode 100644
index 0000000..96218af
--- /dev/null
+++ b/doc/efun/utime
@@ -0,0 +1,22 @@
+SYNOPSIS
+ *int utime()
+
+BESCHREIBUNG
+ Liefert ein Array der Zeit, die seit dem 01. Januar 1970,
+ 00:00:00 GMT vergangen ist, mit Genauigkeit in Mikrosekunden
+ (0.000001 Sekunden).
+
+ Zurueck gegeben wird ein Array der Form:
+ int[0]: Anzahl Sekunden seit Beginn der Zeitrechnung
+ int[1]: Anzahl Mikrosekunden innerhalb der aktuellen Sekunde
+
+BEISPIEL
+ write(ctime(utime())+"\n");
+
+ Gibt das aktuelle Datum und Zeit zurueck.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.9.
+
+SIEHE AUCH
+ ctime(E), gmtime(E), localtime(E), time(E)
diff --git a/doc/efun/variable_exists b/doc/efun/variable_exists
new file mode 100644
index 0000000..1bbd843
--- /dev/null
+++ b/doc/efun/variable_exists
@@ -0,0 +1,29 @@
+SYNOPSIS
+ #include <functionlist.h>
+
+ string variable_exists(string str [, int flags]);
+ string variable_exists(string str, object obj [, int flags]);
+
+BESCHREIBUNG
+ Sucht eine Varialbe <str> in this_object() oder (falls angegeben)
+ im Objekt <obj>.
+
+ Das Resultat ist der Name des Programms, in dem die Variable definiert
+ ist. Das kann entweder object_name(obj) sein oder der Name eines
+ geerbten Programms. Wenn sich der Treiber nicht im Compat-Modus
+ befindet, beginnt der zurueck gelieferte Name immer mit '/'.
+
+ Wird <flags> NAME_HIDDEN gesetzt, so liefert variable_exists() auch
+ Informationen ueber Variablen vom Typ "static" und "protected" in
+ anderen Objekten. Es ist nicht moeglich, Informationen ueber "private"
+ deklarierte Variablen zu erhalten.
+
+ Wird die Variable nicht gefunden (weil sie nicht existiert oder weil
+ sie fuer das aufrufende Objekt nicht sichtbar sind), wird 0 zurueck
+ geliefert.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.10.
+
+SIEHE AUCH
+ function_exists(E), variable_list(E)
diff --git a/doc/efun/variable_list b/doc/efun/variable_list
new file mode 100644
index 0000000..673b377
--- /dev/null
+++ b/doc/efun/variable_list
@@ -0,0 +1,60 @@
+GESCHUETZT
+SYNOPSIS
+ #include <sys/functionlist.h>
+ #include <sys/lpctypes.h>
+
+ *mixed variable_list(object obj, int flags = RETURN_FUNCTION_NAME);
+
+BESCHREIBUNG
+ Liefert ein Array mit Informationen ueber die Variablen von <obj>.
+ Fuer jede Variable werden 1 bis 4 Werte in diesem Array gespeichert,
+ abhaengig von <flags>. Die Resultate werden in dieser Reihenfolge
+ im Array abgespeichert:
+ - der Name der Variablen
+ - die Flags der Variablen (siehe weiter unten)
+ - der Rueckgabetyp (gemaess mudlib/sys/lpctypes.h)
+ - der Wert der Variablen
+
+ <obj> kann als Objekt oder als Dateinamen uebergeben werden. Im
+ zweiten Fall versucht variable_list() nicht, das Objekt vor der
+ Verarbeitung zu laden.
+
+ Wenn <obj> nicht das aufrufende Objekt ist und der Wert der Variablen
+ abgefragt wird, erzeugt dies eine Schutzverletzung ("variable_list",
+ <obj>).
+
+ Mit <flags> wird festgelegt, welche Informationen ueber welche
+ Variablen abgefragt werden. Folgende Flags aus <sys/functionlist.h>
+ koennen mit binaerem Oder kombiniert werden:
+
+ Auswahl der gesammelten Information:
+ RETURN_FUNCTION_NAME liefert den Namen der Variablen
+ RETURN_FUNCTION_FLAGS liefert die Flags der Variablen (s. unten)
+ RETURN_FUNCTION_TYPE liefert den Rueckgabetyp
+ RETURN_VARIABLE_VALUE liefert den Wert der Variablen
+
+ Auswahl der Variablen, die ausgewertet werden:
+ NAME_INHERITED schliesst geerbte Variablen aus
+ TYPE_MOD_STATIC schliesst "static" deklarierte Variablen aus
+ TYPE_MOD_NOSAVE schliesst "nosave" deklarierte Variablen aus
+ TYPE_MOD_PRIVATE schliesst "private" deklarierte Variablen aus
+ TYPE_MOD_PROTECTED schliesst "protected" deklarierte Variablen
+ aus
+ NAME_HIDDEN enthaelt Variablen, die geerbt wurden.
+
+ Die Flags der Variablen koennen die Auswahl-Flags enthalten und
+ zusaeztlich folgende Werte:
+ TYPE_MOD_VIRTUAL die Variable wurde virtuell geerbt
+ TYPE_MOD_NO_MASGK die Variable ist "nomask" deklariert
+ TYPE_MOD_PUBLIC die Variable ist "public" deklariert
+
+ All diese Flags sind in mudlib/sys/functionlist.h definiert und
+ sollten an einen allgemein zugaenglichen Platz kopiert werden.
+ Die Rueckgabewerte sind in mudlib/sys/lpctypes.h definiert, die
+ auch in die Mudlib kopiert werden sollten.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.10
+
+SIEHE AUCH
+ inherit_list(E), functionlist(E), variable_exists(E)
diff --git a/doc/efun/walk_mapping b/doc/efun/walk_mapping
new file mode 100644
index 0000000..7396fcf
--- /dev/null
+++ b/doc/efun/walk_mapping
@@ -0,0 +1,88 @@
+walk_mapping(E)
+
+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,...)
+
+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
+
+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,...)
+
+ Die Schluessel werden als Wert uebergeben und die dazugehoerigen Werte
+ per Referenz, diese koennen somit also in der Funktion/Closure geaendert
+ werden.
+
+
+ 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
diff --git a/doc/efun/widthof b/doc/efun/widthof
new file mode 100644
index 0000000..e3ac599
--- /dev/null
+++ b/doc/efun/widthof
@@ -0,0 +1,16 @@
+SYNOPSIS
+ int widthof(mapping map);
+
+BESCHREIBUNG
+ Liefert die Anzahl Values pro Key im Mapping <map>. Wenn <map> 0 ist,
+ ist das Resultat 0.
+
+BEISPIEL
+ mapping map = (["foo" : 1;2]);
+ widthof(map) ergibt 2.
+
+AENDERUNGEN
+ Eingefuehrt in LDMud 3.2.6
+
+SIEHE AUCH
+ sizeof(E), mkmapping(E), m_reallocate(E), m_values(E), unmkmapping(E)
diff --git a/doc/efun/wizlist_info b/doc/efun/wizlist_info
new file mode 100644
index 0000000..674ec9a
--- /dev/null
+++ b/doc/efun/wizlist_info
@@ -0,0 +1,38 @@
+SYNOPSIS
+ #include <wizlist.h>
+
+ mixed * wizlist_info()
+
+DESCRIPTION
+ Returns an array with the interesting entries of the wizlist.
+ Needs to be privileged by the master object.
+
+ The result is an array with one entry for every wizard (uid).
+ Every entry is an array itself:
+
+ string w[WL_NAME] = Name of the wizard.
+ int w[WL_COMMANDS] = Weighted number of commands execute by
+ objects of this wizard.
+ int w[WL_COST],
+ int w[WL_GIGACOST] = Weighted sum of eval_costs.
+ int w[WL_TOTAL_COST],
+ int w[WL_TOTAL_GIGACOST] = Total sum of eval_costs.
+ int w[WL_HEART_BEATS] = Weighted count of heart_beats.
+ int w[WL_CALL_OUT] = Reserved for call_out() (unused yet).
+ int w[WL_ARRAY_TOTAL] = Total size of arrays in elements.
+ int w[WL_MAPPING_TOTAL] = Total size of mappings in elements.
+ int w[WL_STRUCT_TOTAL] = Total size of structs in elements.
+ mixed w[WL_EXTRA] = Extra wizlist-info if set.
+
+ The 'weighted' entries decay every hour by 10%.
+
+HISTORY
+ LDMud 3.2.10 split the old WL_EVAL_COST into WL_COST and WL_GIGACOST
+ to accomodate for longer uptimes, and introduced
+ WL_TOTAL_COST/WL_TOTAL_GIGACOST.
+ LDMud 3.3.174 added WL_MAPPING_TOTAL.
+ LDMud 3.3.? added WL_STRUCT_TOTAL.
+
+SEE ALSO
+ privilege_violation(M), set_extra_wizinfo_size(E)
+ get_extra_wizinfo(E), set_extra_wizinfo(E)
diff --git a/doc/efun/write b/doc/efun/write
new file mode 100644
index 0000000..a3041b0
--- /dev/null
+++ b/doc/efun/write
@@ -0,0 +1,37 @@
+SYNOPSIS:
+ void write(mixed msg)
+
+DESCRIPTION:
+ Write out something to the current player. What exactly will
+ be printed in the end depends of the type of msg.
+ Please mind: if there is no current player (this_player()), the
+ function will output directly to the driver debug log. Please check
+ before!
+
+ If it is a string or a number then just prints it out.
+
+ If it is an object then the object will be printed in the
+ form: "OBJ("+object_name((object)mix)+")"
+
+ If it is an array just "<ARRAY>" will be printed.
+
+ If the write() function is invoked by a command of an living
+ but not interactive object and the given argument is a string
+ then the lfun catch_tell() of the living will be invoked with
+ the message as argument.
+
+EXAMPLES:
+ write("Hello world!\n");
+
+ Just print out a string.
+
+ write(this_player());
+
+ This will print out something like "OBJ(std/player#1234)".
+
+ write( ({ "blub" }) );
+
+ Will print out "<ARRAY>".
+
+SEE ALSO:
+ say(E), tell_object(E), tell_room(E), shout(E), catch_tell(L)
diff --git a/doc/efun/write_bytes b/doc/efun/write_bytes
new file mode 100644
index 0000000..bb75484
--- /dev/null
+++ b/doc/efun/write_bytes
@@ -0,0 +1,11 @@
+SYNOPSIS
+ int write_bytes(string file, int start, string str);
+
+BESCHREIBUNG
+ Schreibt den String <str> ins File <file> und ueberschreibt dabei die
+ alten Bytes ab Position <start>. Wenn <start> eine negative Zahl ist,
+ werden die Zeichen vom Ende von <file> an gezaehlt. write_bytes()
+ liefert 1 bei Erfolg, 0 bei Misserfolg.
+
+SIEHE AUCH
+ save_object(E), write_file(E)
diff --git a/doc/efun/write_file b/doc/efun/write_file
new file mode 100644
index 0000000..e79fb6b
--- /dev/null
+++ b/doc/efun/write_file
@@ -0,0 +1,14 @@
+SYNOPSIS
+ int write_file(string file, string str);
+ int write_file(string file, string str, int flags);
+
+BESCHREIBUNG
+ Haengt den String <str> an die Datei <file> an. Liefert 1 bei Erfolg,
+ 0 bei Misserfolg.
+
+ If <flags> = 1, dann wird die Datei vor dem eigentlichen
+ Schreiben geloescht; das 'anhaengen' wird so effektiv ein
+ 'ueberschreiben'. Defaultwert fuer <flags> ist 0.
+
+SIEHE AUCH
+ file_size(E), cat(E), write_bytes(E), read_file(E), rm(E)
diff --git a/doc/efun/xml_generate b/doc/efun/xml_generate
new file mode 100644
index 0000000..86506e0
--- /dev/null
+++ b/doc/efun/xml_generate
@@ -0,0 +1,77 @@
+OPTIONAL
+EXPERIMENTAL
+SYNOPSIS
+ #include <xml.h>
+
+ string xml_generate(mixed *xml)
+
+BESCHREIBUNG
+ Wandelt das uebergebene <xml>-Array in einen XML-konformen String um,
+ sofern moeglich. Der <xml>-Parameter muss folgende Struktur haben:
+
+ Er muss Tag-Arrays mit folgenden drei Elementen enthalten:
+
+ string XML_TAG_NAME
+ Der Name des XML-Tags.
+
+ mapping XML_TAG_ATTRIBUTES
+ Alle Attribute dieses XML-Tags als ein Mapping mit dem
+ jeweiligen Attributnamen als Schluessel und den Attributwert
+ als der dazugehoerige String.
+
+ Falls ein XML-Tag keine Attribute enthaelt, so ist dieses
+ Element 0.
+
+ mixed * XML_TAG_CONTENTS
+ Der Inhalt des XML-Tags als ein Array. Dieses Array kann
+ entweder Strings (reine Zeichendaten) oder Arrays
+ als weitere Tags enthalten, welche wiederum diese
+ drei Elemente besitzen.
+
+ Falls das XML-Tag nichts enthaelt, so ist dieses Element 0.
+
+ Falls der uebergebe Parameter nicht diese Struktur besitzt, so wird
+ eine Fehlermeldung ausgegeben. Ansonsten ist ein gueltiger XML-String
+ das Resultat.
+
+ Diese Funktion ist nur verfuegbar, wenn der Driver mit Iksemel-
+ Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __XML_DOM__ definiert.
+
+BEISPIEL
+ xml_generate(({ "abc", 0, 0 })) -> "<abc/>"
+ xml_generate(({ "abc", ([ "xyz" : "cde" ]), 0 })) -> "<abc xyz="cde"/>"
+
+ mixed* xml = ({ "buch"
+ , ([ "sprache" : "deutsch" ])
+ , ({ ({ "titel"
+ , 0
+ , ({ "Dies ist der Titel" })
+ })
+ , ({ "kapitel"
+ , 0
+ , ({ "Dies ist ein Kapitel" })
+ })
+ , ({ "kapitel"
+ , 0
+ , ({ "Das soll "
+ , ({ "b"
+ , 0
+ , ({ "fettgedruckt" })
+ })
+ , " sein."
+ })
+ })
+ })
+ })
+
+ xml_generate(xml)
+ -> "<buch sprache="deutsch"><titel>Dies ist der Titel</titel>"
+ "<kapitel>Dies ist ein Kapitel</kapitel><kapitel>Das soll "
+ "<b>fettgedruckt</b> sein.</kapitel></buch>"
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.718.
+
+SIEHE AUCH
+ xml_parse(E)
diff --git a/doc/efun/xml_parse b/doc/efun/xml_parse
new file mode 100644
index 0000000..4649c9a
--- /dev/null
+++ b/doc/efun/xml_parse
@@ -0,0 +1,78 @@
+OPTIONAL
+EXPERIMENTAL
+SYNOPSIS
+ #include <xml.h>
+
+ mixed* xml_parse(string xml)
+
+BESCHREIBUNG
+ Parst den angegebenen String <xml> als XML. Der String darf nur ein
+ einziges Root-Tag enthalten, weitere Root-Tags werden ignoriert.
+
+ Falls der String XML-konform war, so wird ein Array mit drei Elementen
+ zurueckgegeben, dessen Elemente folgendermassen definiert sind:
+
+ string XML_TAG_NAME
+ Der Name des XML-Tags.
+
+ mapping XML_TAG_ATTRIBUTES
+ Alle Attribute dieses XML-Tags als ein Mapping mit dem
+ jeweiligen Attributnamen als Schluessel und den Attributwert
+ als der dazugehoerige String.
+
+ Falls ein XML-Tag keine Attribute enthaelt, so ist dieses
+ Element 0.
+
+ mixed * XML_TAG_CONTENTS
+ Der Inhalt des XML-Tags als ein Array. Dieses Array kann
+ entweder Strings (reine Zeichendaten) oder Arrays
+ als weitere Tags enthalten, welche wiederum diese
+ drei Elemente besitzen.
+
+ Falls das XML-Tag nichts enthaelt, so ist dieses Element 0.
+
+ Falls der XML-String nicht wohlgeformt ist oder falls nicht genug Speicher
+ zur Verfuegung steht, wird eine Fehlermeldung ausgegeben.
+
+ Diese Funktion ist nur verfuegbar, wenn der Driver mit Iksemel-
+ Unterstuetzung compiliert wurde. In diesem Fall ist das Makro
+ __XML_DOM__ definiert.
+
+BEISPIEL
+ xml_parse("<abc/>") -> ({ "abc", 0, 0 })
+ xml_parse("<abc xyz="cde"/>") -> ({ "abc", ([ "xyz" : "cde" ]), 0 })
+
+ xml_parse("<buch sprache="deutsch">" +
+ " <titel>Dies ist der Titel</titel>" +
+ " <kapitel>Dies ist ein Kapitel</kapitel>" +
+ " <kapitel>Das soll <b>fettgedruckt</b> sein.</kapitel>" +
+ "</buch>")
+
+ -> ({ "buch"
+ , ([ "sprache" : "deutsch" ])
+ , ({ ({ "titel"
+ , 0
+ , ({ "Dies ist der Titel" })
+ })
+ , ({ "kapitel"
+ , 0
+ , ({ "Dies ist ein Kapitel" })
+ })
+ , ({ "kapitel"
+ , 0
+ , ({ "Dies soll "
+ , ({ "b"
+ , 0
+ , ({ "fettgedruckt" })
+ })
+ , "sein."
+ })
+ })
+ })
+ })
+
+GESCHICHTE
+ Eingefuehrt in LDMud 3.3.718.
+
+SIEHE AUCH
+ xml_generate(E)
diff --git a/doc/efun/xor_bits b/doc/efun/xor_bits
new file mode 100644
index 0000000..6f9eab9
--- /dev/null
+++ b/doc/efun/xor_bits
@@ -0,0 +1,19 @@
+SYNOPSIS
+ string xor_bits(string str1, string str2);
+
+BESCHREIBUNG
+ <str1> und <str2> sind beiden Bitstrings. Das Resultat von xor_bits()
+ ist ein Bitstring mit dem binaeren XOR von <str1> und <str2>, also
+ ein String, in dem ein Bit nur gesetzt ist, wenn es entweder in <str1>
+ oder in <str2> vorkommt, nicht aber in beiden.
+
+BEISPIELE
+ string s1, s2, s3;
+ s1 = set_bit("", 3); s1 = set_bit(s1, 15); -> s1 ist "( ("
+ s2 = set_bit("", 3); s2 = set_bit(s2, 4); -> s2 ist "8"
+ s3 = xor_bits(s1, s2);
+ -> s3 ist "0 (", es sind also das 4. und das 15. Bit gesetzt.
+
+SIEHE AUCH
+ clear_bit(E), set_bit(E), test_bit(E), next_bit(E), last_bit(E)
+ count_bits(E), and_bits(E), or_bits(E), invert_bits(E), copy_bits(E)