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