diff --git a/doc/efun/driver_info b/doc/efun/driver_info
new file mode 100644
index 0000000..f1eaa66
--- /dev/null
+++ b/doc/efun/driver_info
@@ -0,0 +1,685 @@
+SYNOPSIS
+        #include <driver_info.h>
+
+        mixed driver_info(int what)
+
+DESCRIPTION
+        Returns some internal information about the driver.
+        The argument <what> determines which information is returned.
+
+        It can be either a configuration option as given to
+        configure_driver() or one of the following options:
+
+
+
+        Driver Environment:
+
+        <what> == DI_BOOT_TIME:
+          The time() when the driver was started.
+
+
+
+        LPC Runtime status:
+
+        <what> == DI_CURRENT_RUNTIME_LIMITS:
+          Return an array with the current runtime limits.
+          The entries in the returned array are:
+
+            int[LIMIT_EVAL]:         the max number of eval costs
+            int[LIMIT_ARRAY]:        the max number of array entries
+            int[LIMIT_MAPPING_SIZE]: the max number of mapping values
+            int[LIMIT_MAPPING_KEYS]: the max number of mapping entries
+               (LIMIT_MAPPING is an alias for LIMIT_MAPPING_KEYS)
+            int[LIMIT_BYTE]:         the max number of bytes handled with
+                                     one read_bytes()/write_bytes() call.
+            int[LIMIT_FILE]:         the max number of bytes handled with
+                                     one read_file()/write_file() call.
+            int[LIMIT_CALLOUTS]:     the number of callouts at one time.
+            int[LIMIT_COST]:         how to account the current cost.
+            int[LIMIT_MEMROY]:       the max. number of bytes which can be 
+                                     _additionally_ allocated/used 
+                                     _per top-level execution thread_
+
+          For all limits except LIMIT_COST a limit of '0' aka LIMIT_UNLIMITED
+          means 'no limit'.
+
+          The value for LIMIT_COST has these meanings:
+
+            value > 0: the execution will cost minimum(<value>, actual cost) .
+            value = 0: if the current LIMIT_EVAL is larger than the calling
+                       LIMIT_EVAL, the evaluation will cost only 10; otherwise
+                       the full cost will be accounted.
+            value < 0: (-value)% of the current evaluation cost will be
+                       accounted; -100 obviously means 'full cost'.
+
+        <what> == DI_EVAL_NUMBER:
+          Return the current evaluation number.
+          The number is incremented for each top-level call. Top-level
+          calls are initiated by the driver, usually in reaction to an
+          external event:
+              - commands (added by add_action)
+              - heart_beat, reset, clean_up
+              - calls from call_out or input_to
+              - master applies triggered by external events
+              - calls of driver hooks in reaction to external events
+              - send_erq callbacks
+              - logon in interactives
+
+          The number can be used to detect cases where the same code is
+          executed twice in the same top level evaluation (say, heart_beat),
+          and also for time stamps for ordering some events.
+
+          Please note that the counter may overflow, especially on 32 bit
+          systems. As a result, it can also be negative.
+
+
+
+        Network configuration:
+
+        <what> == DI_MUD_PORTS:
+          Returns an array with all open ports, which the driver
+          listens for player connections on.
+
+        <what> == DI_UDP_PORT:
+          Returns the port number of the UDP socket.
+
+
+
+        Memory management:
+
+        <what> == DI_MEMORY_RESERVE_USER:
+          Current size of the user memory reserve.
+          The user memory reserve is allocated at startup and is used
+          when the driver runs out of memory.
+
+        <what> == DI_MEMORY_RESERVE_MASTER:
+          Current size of the master memory reserve.
+          The master memory reserve is allocated at startup and is used
+          when the driver runs out of memory while executing master
+          code.
+
+        <what> == DI_MEMORY_RESERVE_SYSTEM:
+          Current size of the system memory reserve.
+          The system memory reserve is allocated at startup and is used
+          when the driver runs out of memory while executing internal
+          operations.
+
+
+
+        Traces:
+
+        <what> == DI_TRACE_CURRENT:
+          Returns the current stack trace in array form.
+
+          If the array has more than one entries, the first entry is 0 or
+          the name of the object with the heartbeat which started the
+          current thread; all following entries describe the call stack
+          starting with the topmost function called.
+
+          All call entries are arrays themselves with the following elements:
+
+               int[TRACE_TYPE]: The type of the call frame:
+                   TRACE_TYPE_SYMBOL (0): a function symbol (shouldn't happen).
+                   TRACE_TYPE_SEFUN  (1): a simul-efun.
+                   TRACE_TYPE_EFUN   (2): an efun closure.
+                   TRACE_TYPE_LAMBDA (3): a lambda closure.
+                   TRACE_TYPE_LFUN   (4): a normal lfun.
+
+               mixed[TRACE_NAME]: The 'name' of the called frame:
+                   _TYPE_EFUN:   either the name of the efun, or the code of
+                                 the instruction for operator closures
+                   _TYPE_LAMBDA: the numeric lambda identifier.
+                   _TYPE_LFUN:   the name of the lfun.
+
+               string[TRACE_PROGRAM]: The (file)name of the program holding
+                                      the code.
+
+               string[TRACE_OBJECT]:  The name of the object for which the code
+                                      was executed.
+               int[TRACE_LOC]:
+                   _TYPE_LAMBDA: current program offset from the start of the
+                                 closure code.
+                   _TYPE_LFUN:   the line number.
+
+        <what> == DI_TRACE_CURRENT_DEPTH:
+          Return the current number of frames on the control stack
+          (recursion depth).
+
+        <what> == DI_TRACE_CURRENT_AS_STRING:
+          Returns the current stack trace as a string.
+
+        <what> == DI_TRACE_LAST_ERROR:
+          Returns the stack trace of the last error in array form
+          (same format as DI_TRACE_CURRENT). Stack traces of errors
+          before the last GC might not be available anymore.
+
+        <what> == DI_TRACE_LAST_ERROR_AS_STRING:
+          Returns the stack trace of the last error as a string.
+
+        <what> == DI_TRACE_LAST_UNCAUGHT_ERROR:
+          Returns the stack trace of the last uncaught error in array form
+          (same format as DI_TRACE_CURRENT). Stack traces of errors
+          before the last GC might not be available anymore.
+
+        <what> == DI_TRACE_LAST_UNCAUGHT_ERROR_AS_STRING:
+          Returns the stack trace of the last uncaught error as a string.
+
+
+
+        LPC Runtime statistics:
+
+        <what> == DI_NUM_FUNCTION_NAME_CALLS:
+          Number of function calls by name (like call_other).
+
+        <what> == DI_NUM_FUNCTION_NAME_CALL_HITS:
+          Function calls by name are cached (to accelerate
+          lookup of the corresponding program code).
+          This returns the number of cache hits.
+
+        <what> == DI_NUM_FUNCTION_NAME_CALL_MISSES:
+          The number of function call cache misses.
+
+        <what> == DI_NUM_OBJECTS_LAST_PROCESSED:
+          Number of listed objects processed in the last backend cycle.
+
+        <what> == DI_NUM_HEARTBEAT_TOTAL_CYCLES:
+          Total number of heart_beats cycles so far.
+
+        <what> == DI_NUM_HEARTBEAT_ACTIVE_CYCLES:
+          Number of active heart_beat cycles executed so far
+          (ie. cycles in which at least one heart_beat() function
+          was called).
+
+        <what> == DI_NUM_HEARTBEATS_LAST_PROCESSED:
+          Number of heart_beats calls in the last backend cycle
+
+        <what> == DI_NUM_STRING_TABLE_STRINGS_ADDED:
+          Number of distinct strings added to the string table so far.
+
+        <what> == DI_NUM_STRING_TABLE_STRINGS_REMOVED:
+          Number of distinct strings removed from the string table so far.
+
+        <what> == DI_NUM_STRING_TABLE_LOOKUPS_BY_VALUE:
+          Number of string searches by value.
+
+        <what> == DI_NUM_STRING_TABLE_LOOKUPS_BY_INDEX:
+          Number of string searches by address.
+
+        <what> == DI_NUM_STRING_TABLE_LOOKUP_STEPS_BY_VALUE:
+          Number of lookup steps needed for string searches by value.
+
+        <what> == DI_NUM_STRING_TABLE_LOOKUP_STEPS_BY_INDEX:
+          Number of lookup steps needed for string searches by address.
+
+        <what> == DI_NUM_STRING_TABLE_HITS_BY_VALUE:
+          Number of successful lookups of strings by value.
+
+        <what> == DI_NUM_STRING_TABLE_HITS_BY_INDEX:
+          Number of successful lookups of strings by address.
+
+        <what> == DI_NUM_STRING_TABLE_COLLISIONS:
+          Number of distinct strings added to an existing hash chain so far.
+
+        <what> == DI_NUM_REGEX_LOOKUPS:
+          Number of requests for new regexps.
+
+        <what> == DI_NUM_REGEX_LOOKUP_HITS:
+          Number of requested regexps found in the table.
+
+        <what> == DI_NUM_REGEX_LOOKUP_MISSES:
+          Number of requested regexps not found in the table.
+
+        <what> == DI_NUM_REGEX_LOOKUP_COLLISIONS:
+          Number of requested new regexps which collided with a cached one.
+
+
+
+        Network statistics:
+
+        <what> == DI_NUM_MESSAGES_OUT:
+          Number of messages sent to a player.
+
+        <what> == DI_NUM_PACKETS_OUT:
+          Number of packets sent to a player.
+
+        <what> == DI_NUM_PACKETS_IN:
+          Number of packets received from a player.
+
+        <what> == DI_SIZE_PACKETS_OUT:
+          Number of bytes sent to a player.
+
+        <what> == DI_SIZE_PACKETS_IN:
+          Number of bytes received from a player.
+
+
+
+        Load:
+
+        <what> == DI_LOAD_AVERAGE_COMMANDS:
+          A float value that shows the number of executed player commands
+          per second.
+
+        <what> == DI_LOAD_AVERAGE_LINES:
+          A float value that shows the number of compiled code lines
+          per second.
+
+        <what> == DI_LOAD_AVERAGE_PROCESSED_OBJECTS:
+          A float value that shows the average number of objects processed
+          each backend cycle.
+
+        <what> == DI_LOAD_AVERAGE_PROCESSED_OBJECTS_RELATIVE:
+          Average number of objects processed each cycle, expressed
+          as percentage (0..1.0) of the number of present objects.
+
+        <what> == DI_LOAD_AVERAGE_PROCESSED_HEARTBEATS_RELATIVE:
+          Average number of heart_beats called each cycle, expressed
+          as fraction (0..1.0) of the number of active heartbeats.
+
+
+
+        Memory use statistics:
+
+        <what> == DI_NUM_ACTIONS:
+          Number of allocated actions.
+
+        <what> == DI_NUM_CALLOUTS:
+          Number of pending call_outs.
+
+        <what> == DI_NUM_HEARTBEATS:
+          Number of objects with a heartbeat.
+
+        <what> == DI_NUM_SHADOWS:
+          Number of allocated shadows.
+
+        <what> == DI_NUM_OBJECTS:
+          Number of objects.
+
+        <what> == DI_NUM_OBJECTS_SWAPPED:
+          Number of objects that are swapped-out.
+
+        <what> == DI_NUM_OBJECTS_IN_LIST:
+          Number of objects in the object list
+          (i.e. not destructed objects).
+
+        <what> == DI_NUM_OBJECTS_IN_TABLE:
+          Number of objects in the object table.
+
+        <what> == DI_NUM_OBJECTS_DESTRUCTED:
+          Number of destructed, but still referenced objects.
+          (Not counting DI_NUM_OBJECTS_NEWLY_DESTRUCTED).
+
+        <what> == DI_NUM_OBJECTS_NEWLY_DESTRUCTED:
+          Number of newly destructed objects (ie. objects destructed
+          in this execution thread, that will really be destroyed in
+          the next backend cycle).
+
+        <what> == DI_NUM_OBJECT_TABLE_SLOTS:
+          Number of hash slots provided by the object table.
+
+        <what> == DI_NUM_PROGS:
+          Size occupied by the object table.
+
+        <what> == DI_NUM_PROGS_SWAPPED:
+          Number of swapped-out program blocks
+
+        <what> == DI_NUM_PROGS_UNSWAPPED:
+          Number of programs that were swapped-out, are now swapped-in,
+          but still have allocated space in the swap file.
+
+        <what> == DI_NUM_ARRAYS:
+          Number of currently existing arrays.
+
+        <what> == DI_NUM_MAPPINGS:
+          Number of currently existing mappings.
+
+        <what> == DI_NUM_MAPPINGS_CLEAN:
+          Number of clean mappings (mappings without a hash part).
+
+        <what> == DI_NUM_MAPPINGS_HASH:
+          Number of hash mappings.
+
+        <what> == DI_NUM_MAPPINGS_HYBRID:
+          Number of hybrid mappings (mappings that have a
+          condensed and hash part).
+
+        <what> == DI_NUM_STRUCTS:
+          Number of currently existing structs.
+
+        <what> == DI_NUM_STRUCT_TYPES:
+          Number of currently existing struct types.
+
+        <what> == DI_NUM_VIRTUAL_STRINGS:
+          Number of currently existing virtual strings
+          (identical strings are counted separately).
+
+        <what> == DI_NUM_STRINGS:
+          Number of real strings (identical strings
+          are counted once).
+
+        <what> == DI_NUM_STRINGS_TABLED:
+          Number of directly tabled strings.
+
+        <what> == DI_NUM_STRINGS_UNTABLED:
+          Number of untabled strings.
+
+        <what> == DI_NUM_STRING_TABLE_SLOTS:
+          Number of hash slots in the string table.
+
+        <what> == DI_NUM_STRING_TABLE_SLOTS_USED:
+          Number of hash chains in the string table.
+
+        <what> == DI_NUM_REGEX:
+          Number of cached regular expressions.
+
+        <what> == DI_NUM_REGEX_TABLE_SLOTS:
+          Number of slots in the regexp cache table.
+
+        <what> == DI_SIZE_ACTIONS:
+          Total size of allocated actions.
+
+        <what> == DI_SIZE_CALLOUTS:
+          Total size of pending call_outs.
+
+        <what> == DI_SIZE_HEARTBEATS:
+          Total size of the heart_beat list.
+
+        <what> == DI_SIZE_SHADOWS:
+          Total size of allocated shadows.
+
+        <what> == DI_SIZE_OBJECTS:
+          Total size of objects (not counting the size of the values
+          of their variables).
+
+        <what> == DI_SIZE_OBJECTS_SWAPPED:
+          Total size of swapped-out variable blocks.
+
+        <what> == DI_SIZE_OBJECT_TABLE:
+          Size occupied by the object table.
+
+        <what> == DI_SIZE_PROGS:
+          Total size of all programs.
+
+        <what> == DI_SIZE_PROGS_SWAPPED:
+          Total size of swapped-out program blocks
+
+        <what> == DI_SIZE_PROGS_UNSWAPPED:
+          Total size of unswapped program blocks
+
+        <what> == DI_SIZE_ARRAYS:
+          Total size of all arrays (not counting additional sizes
+          of array element values).
+
+        <what> == DI_SIZE_MAPPINGS:
+          Total size of all mapping (not counting additional sizes
+          of contained values).
+
+        <what> == DI_SIZE_STRUCTS:
+          Total size of all structs (not counting additional sizes
+          of contained values).
+
+        <what> == DI_SIZE_STRUCT_TYPES:
+          Total size of all struct type definitions.
+
+        <what> == DI_SIZE_STRINGS:
+          Total size of all strings.
+
+        <what> == DI_SIZE_STRINGS_TABLED:
+          Total size of all tabled strings.
+
+        <what> == DI_SIZE_STRINGS_UNTABLED:
+          Total size of all untabled strings.
+
+        <what> == DI_SIZE_STRING_TABLE:
+          Size of the string table structure itself.
+
+        <what> == DI_SIZE_STRING_OVERHEAD:
+          Size of the overhead per string (compared to a raw string).
+
+        <what> == DI_SIZE_REGEX:
+          Total size of all cached regular expressions.
+
+        <what> == DI_SIZE_BUFFER_FILE:
+          The size of the memory buffer for file operations.
+
+        <what> == DI_SIZE_BUFFER_SWAP:
+          The size of the memory buffer for the swap file.
+
+
+
+        Memory swapper statistics:
+
+        <what> == DI_NUM_SWAP_BLOCKS:
+          Number of blocks in the swap file.
+
+        <what> == DI_NUM_SWAP_BLOCKS_FREE:
+          Number of free blocks in the swap file.
+
+        <what> == DI_NUM_SWAP_BLOCKS_REUSE_LOOKUPS:
+          Number of searches for blocks to reuse in the swap file.
+
+        <what> == DI_NUM_SWAP_BLOCKS_REUSE_LOOKUP_STEPS:
+          Total number of lookup steps in searches for blocks
+          to reuse in the swap file.
+
+        <what> == DI_NUM_SWAP_BLOCKS_FREE_LOOKUPS:
+          Number of searches for blocks to free in the swap file.
+
+        <what> == DI_NUM_SWAP_BLOCKS_FREE_LOOKUP_STEPS:
+          Total number of lookup steps in searches for blocks
+          to free in the swap file.
+
+        <what> == DI_SIZE_SWAP_BLOCKS:
+          Size of the swap file.
+
+        <what> == DI_SIZE_SWAP_BLOCKS_FREE:
+          Size of free blocks in the swap file.
+
+        <what> == DI_SIZE_SWAP_BLOCKS_REUSED:
+          Total reused space in the swap file.
+
+        <what> == DI_SWAP_RECYCLE_PHASE:
+          True if the swapper is currently recycling free block.
+
+
+
+        Memory allocator statistics:
+
+        <what> == DI_MEMORY_ALLOCATOR_NAME:
+          The name of the allocator: "sysmalloc", "smalloc", "slaballoc
+
+        <what> == DI_NUM_SYS_ALLOCATED_BLOCKS:
+          Number of memory blocks requested from the operating system.
+
+        <what> == DI_NUM_LARGE_BLOCKS_ALLOCATED:
+          Number of large allocated blocks.
+          (With smalloc: The large allocated blocks include
+          the small chunk blocks.)
+
+        <what> == DI_NUM_LARGE_BLOCKS_FREE:
+          Number of large free blocks.
+
+        <what> == DI_NUM_LARGE_BLOCKS_WASTE:
+          Number of unusable large memory fragments.
+
+        <what> == DI_NUM_SMALL_BLOCKS_ALLOCATED:
+          Number of small allocated blocks.
+
+        <what> == DI_NUM_SMALL_BLOCKS_FREE:
+          Number of small free blocks.
+
+        <what> == DI_NUM_SMALL_BLOCKS_WASTE:
+          Number of unusably small memory fragments.
+
+        <what> == DI_NUM_SMALL_BLOCK_CHUNKS:
+          Number of small chunk/slab blocks.
+          (That are large blocks that are used as a
+          base for small blocks.)
+
+        <what> == DI_NUM_UNMANAGED_BLOCKS:
+          Number of unmanaged (non-GC-able) allocations.
+
+        <what> == DI_NUM_FREE_BLOCKS_AVL_NODES:
+          Number of AVL nodes used to manage the large free
+          blocks. This value might go away again.
+
+        <what> == DI_SIZE_SYS_ALLOCATED_BLOCKS:
+          Total size of memory requested from the operating system.
+
+        <what> == DI_SIZE_LARGE_BLOCKS_ALLOCATED:
+          Total size of large allocated blocks.
+
+        <what> == DI_SIZE_LARGE_BLOCKS_FREE:
+          Total size of large free blocks.
+
+        <what> == DI_SIZE_LARGE_BLOCKS_WASTE:
+          Total size of unusable large memory fragments.
+
+        <what> == DI_SIZE_LARGE_BLOCK_OVERHEAD:
+          The overhead of every large block allocation.
+
+        <what> == DI_SIZE_SMALL_BLOCKS_ALLOCATED:
+          Total size of small allocated blocks.
+
+        <what> == DI_SIZE_SMALL_BLOCKS_FREE:
+          Total size of small free blocks.
+
+        <what> == DI_SIZE_SMALL_BLOCKS_WASTE:
+          Total size of unusably small memory fragments.
+
+        <what> == DI_SIZE_SMALL_BLOCK_OVERHEAD:
+          The overhead of every small block allocation.
+
+        <what> == DI_SIZE_SMALL_BLOCK_CHUNKS:
+          Total size of small chunk/slab blocks.
+
+        <what> == DI_SIZE_UNMANAGED_BLOCKS:
+          Total size of unmanaged (non-GC-able) allocations.
+
+        <what> == DI_SIZE_MEMORY_USED:
+          The amount of memory currently allocated from the allocator.
+
+        <what> == DI_SIZE_MEMORY_UNUSED:
+          The amount of memory allocated from the system, but
+          not used by the driver.
+
+        <what> == DI_SIZE_MEMORY_OVERHEAD:
+          Amount of memory used for the management of the memory.
+
+        <what> == DI_NUM_INCREMENT_SIZE_CALLS:
+          Number of requests to increase the size of a memory block.
+
+        <what> == DI_NUM_INCREMENT_SIZE_CALL_SUCCESSES:
+          Number of successful requests to increase the
+          size of a memory block.
+
+        <what> == DI_SIZE_INCREMENT_SIZE_CALL_DIFFS:
+          Total size of additionally allocated memory by
+          increasing already allocated memory blocks.
+
+        <what> == DI_NUM_REPLACEMENT_MALLOC_CALLS:
+          Number of allocations done through the
+          clib functions (if supported by the allocator).
+
+        <what> == DI_SIZE_REPLACEMENT_MALLOC_CALLS:
+          Total size of allocations done through the
+          clib functions (if supported by the allocator).
+
+        <what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALLS_FULL:
+          Total number of requests to defragment all small memory chunks.
+
+        <what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALLS_TARGETED:
+          Total number of requests to defragment small memory chunks
+          for a desired size.
+
+        <what> == DI_NUM_MEMORY_DEFRAGMENTATION_CALL_TARGET_HITS:
+          Total number of successful requests to defragment small
+          memory chunks for a desired size.
+
+        <what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_INSPECTED:
+          Number of blocks inspected during defragmentations.
+
+        <what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_MERGED:
+          Number of blocks merged during defragmentations.
+
+        <what> == DI_NUM_MEMORY_DEFRAGMENTATION_BLOCKS_RESULTING:
+          Number of defragmented blocks (ie. merge results).
+
+        <what> == DI_MEMORY_EXTENDED_STATISTICS:
+          If the driver was compiled with extended memory statistics,
+          they are returned in this entry; if the driver was compiled
+          without the statistics, 0 is returned.
+
+          The array contains NUM+2 entries, where NUM is the number
+          of distinct small block sizes. Entry [NUM] describes the
+          statistics of oversized small blocks (smalloc) resp. for
+          all slabs (slaballoc), entry [NUM+1] summarizes all large
+          blocks. Each entry is an array of these fields:
+
+               int DIM_ES_MAX_ALLOC:
+                       Max number of allocated blocks of this size.
+
+               int DIM_ES_CUR_ALLOC:
+                       Current number of allocated blocks of this size.
+
+               int DIM_ES_MAX_FREE:
+                       Max number of allocated blocks of this size.
+
+               int DIM_ES_CUR_FREE:
+                       Current number of allocated blocks of this size.
+
+               float DIM_ES_AVG_XALLOC:
+                       Number of explicit allocation requests per
+                       second.
+
+               float DIM_ES_AVG_XFREE:
+                       Number of explicit deallocation requests per
+                       second.
+
+               int DIM_ES_FULL_SLABS:
+                       Number of fully used slabs (slaballoc only).
+
+               int DIM_ES_FREE_SLABS:
+                       Number of fully free slabs (slaballoc only).
+
+               int DIM_ES_TOTAL_SLABS:
+                       Total number of slabs: partially used, fully used
+                       and fully free (slaballoc only).
+
+           The allocation/deallocation-per-second statistics do
+           not cover internal shuffling of the freelists.
+
+           The slab statistics (entry [NUM], slaballoc only) shows
+           in the AVG statistics the frequence with which slabs were
+           allocated from resp. returned to the large memory pool.
+
+
+
+        Status texts:
+
+        <what> == DI_STATUS_TEXT_MEMORY:
+          A printable string containing information about
+          the memory usage.
+
+        <what> == DI_STATUS_TEXT_TABLES:
+          A printable string containing information about
+          the LPC runtime.
+
+        <what> == DI_STATUS_TEXT_SWAP:
+          A printable string containing information about
+          the swap system.
+
+        <what> == DI_STATUS_TEXT_MALLOC:
+          A printable string containing information about
+          memory allocations.
+
+        <what> == DI_STATUS_TEXT_MALLOC_EXTENDED:
+          A printable strings with extended memory statistics
+          (if the driver was compiled with them).
+
+
+HISTORY
+        Introduced in LDMud 3.5.0.
+
+SEE ALSO
+        configure_driver(E), object_info(E), interactive_info(E),
+        dump_driver_info(E)