diff --git a/doc/hook/auto_include b/doc/hook/auto_include
new file mode 100644
index 0000000..a82adda
--- /dev/null
+++ b/doc/hook/auto_include
@@ -0,0 +1,37 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_AUTO_INCLUDE, value)
+
+        <value> being:
+
+          string <text>
+          string <closure>(string base_file, string current_file
+                          , int sys_include)
+
+DESCRIPTION
+        Optional hook specifying a string to be included before
+        the source of every compiled LPC object.
+        Hook setting can be a string or a closure.
+
+        If the setting is a string, it will be automatically included before
+        the source of every compiled LPC object.
+
+        If the setting is a closure, it is called for every file
+        opened by the compiler. <base_file> will be the filename of
+        the compiled object, <current_file> the name of a file
+        included directly or indirectly by the <base_file>. When the
+        <base_file> itself is opened, <current_file> will be 0. For an
+        included file, <sys_include> will be TRUE if it is a <>-type
+        include.
+
+        If the result from the call is a string, it will be included
+        before the actual text of the file.
+
+        In both cases, the string will be included as-is; in
+        particular no terminating '\n' will be added.
+
+HISTORY
+
+SEE ALSO
+        hooks(C), include_dirs(H)
diff --git a/doc/hook/clean_up b/doc/hook/clean_up
new file mode 100644
index 0000000..e00521a
--- /dev/null
+++ b/doc/hook/clean_up
@@ -0,0 +1,45 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_CLEAN_UP, value)
+
+        <value> being:
+
+          int <closure>(int ref, object ob)
+          void|int <name>(int ref)
+
+DESCRIPTION
+        Optional hook to clean up an object.
+        Hook setting can be any closure, or the name of the function
+        to call in the object.
+
+        This hook is called for an object if it hasn't been used
+        for at least TIME_TO_CLEAN_UP seconds, to give it the
+        opportunity to self destruct.
+
+        If the hook is a closure, it is called with the refcount of
+        the object to clean up as first argument, and with the object
+        itself as second. Lambda closures are also bound to the object
+        prior to the call.
+
+        If the hook is the name of an lfun, it is called in the
+        object with its refcount as argument.
+
+        In both calls, the refcount is constructed as:
+
+          ref = 0: the object is a clone, or a blueprint with
+                   replaced program.
+          ref = 1: the object is a swapped or unused blueprint.
+          ref > 1: the object is a used blueprint with <ref> references.
+
+        The cleanup method has the possibility to destruct the
+        object. To survive this time, but try again some time later,
+        the call has to result in a non-zero value.
+
+        If the hook specifies a non-existing lfun, or if the call
+        returns 0, no further attempt to clean up this object will be done.
+
+HISTORY
+
+SEE ALSO
+        hooks(C)
diff --git a/doc/hook/clone_uids b/doc/hook/clone_uids
new file mode 100644
index 0000000..4bf902a
--- /dev/null
+++ b/doc/hook/clone_uids
@@ -0,0 +1,36 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_CLONE_UIDS, value)
+
+        <value> being:
+
+          mixed <closure>(object blueprint, string objectname)
+
+DESCRIPTION
+        Mandatory hooks to determine the uid and euid of cloned
+        objects.  Hook settings can be any closure.
+
+        When an object is cloned, the H_CLONE_UIDS hook is called with
+        the blueprint object as first and the clone's designated name
+        as second argument. The new object already exists, but has 0
+        uids.
+
+        For the result, the following possibilities exist (<num> is
+        a non-zero number, <no-string> is anything but a string):
+
+           "<uid>"                    -> uid = "<uid>", euid = "<uid>"
+           ({ "<uid>", "<euid>" })    -> uid = "<uid>", euid = "<euid>"
+           ({ "<uid>", <no-string> }) -> uid = "<uid>", euid = 0
+
+        If strict-euids is not active, the following results are
+        possible, too:
+
+           <num>                      -> uid = 0, euid = 0
+           ({ <num>, "<euid>" })      -> uid = 0, euid = "<euid>"
+           ({ <num>, <no-string> })   -> uid = 0, euid = 0
+
+HISTORY
+
+SEE ALSO
+        hooks(C), uids(C), load_uids(H)
diff --git a/doc/hook/command b/doc/hook/command
new file mode 100644
index 0000000..de1b609
--- /dev/null
+++ b/doc/hook/command
@@ -0,0 +1,33 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_COMMAND, value)
+
+        <value> being:
+
+          int <closure>(string command, object command_giver)
+          int <name>(string command, object command_giver)
+
+DESCRIPTION
+        Optional hook to parse and execute commands. If this hook is
+        used, it bypasses the normal command parsing done by the
+        driver (including the MODIFY_COMMAND and NOTIFY_FAIL hooks).
+
+        The hook is called with two parameters: the command received
+        from the living (interactive user or NPC), and the living
+        object (the 'command giver') itself. The hook has to return
+        non-0 if the command was found and executed, and 0 otherwise.
+
+        At the time the hook is called, query_command() returns the
+        command string and this_player() returns the living object.
+        query_verb() and query_notify_fail() return 0.
+
+        If the hook is a string, it is the name of an lfun in the
+        command giver; if the hook is a lambda closure, it is bound to
+        the command giver before the call.
+
+HISTORY
+
+SEE ALSO
+        hooks(C), modify_command(H), modify_command_fname(H), notify_fail(H),
+        send_notify_fail(H)
diff --git a/doc/hook/create_clone b/doc/hook/create_clone
new file mode 100644
index 0000000..bf3100e
--- /dev/null
+++ b/doc/hook/create_clone
@@ -0,0 +1,34 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_CREATE_CLONE, value)
+
+        <value> being:
+
+          void <name> (0)
+          int <closure> ( void )
+          int <closure> (object obj_to_init)
+
+DESCRIPTION
+        Optional hooks to initialize a cloned object after creation.
+        Hook setting can be unbound lambda closures, or the name of
+        the function (static or public) to call in the object.
+
+        If the hook is a closure expecting an argument, it is bound
+        to the current object and called with the created object as
+        argument. If the hook as a closure without arguments, it is bound to
+        the object to be initalized and called.
+
+        If the result of the closure call is a non-zero number, it is used
+        as the interval to wait before the first reset(), else the default
+        interval computed from TIME_TO_RESET is used.
+
+        If the hook is defined as the name of an lfun in the object,
+        it is called in the object with 0 as argument, and any result
+        is ignored.
+
+HISTORY
+        LDMud 3.2.10 allowed static functions to be given by name.
+
+SEE ALSO
+        hooks(C), create_ob(H), create_super(H)
diff --git a/doc/hook/create_ob b/doc/hook/create_ob
new file mode 100644
index 0000000..7de7ba3
--- /dev/null
+++ b/doc/hook/create_ob
@@ -0,0 +1,35 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_CREATE_OB, value)
+
+        <value> being:
+
+          void <name> (0)
+          int <closure> ( void )
+          int <closure> (object obj_to_init)
+
+DESCRIPTION
+        Optional hooks to initialize an explictely loaded
+        object/blueprint after creation.  Hook setting can be unbound
+        lambda closures, or the name of the function (static or public) to
+        call in the object.
+
+        If the hook is a closure expecting an argument, it is bound
+        to the current object and called with the created object as
+        argument. If the hook as a closure without arguments, it is bound to
+        the object to be initalized and called.
+
+        If the result of the closure call is a non-zero number, it is used
+        as the interval to wait before the first reset(), else the default
+        interval computed from TIME_TO_RESET is used.
+
+        If the hook is defined as the name of an lfun in the object,
+        it is called in the object with 0 as argument, and any result
+        is ignored.
+
+HISTORY
+        LDMud 3.2.10 allowed static functions to be given by name.
+
+SEE ALSO
+        hooks(C), create_super(H), create_clone(H)
diff --git a/doc/hook/create_super b/doc/hook/create_super
new file mode 100644
index 0000000..a502730
--- /dev/null
+++ b/doc/hook/create_super
@@ -0,0 +1,35 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_CREATE_SUPER, value)
+
+        <value> being:
+
+          void <name> (0)
+          int <closure> ( void )
+          int <closure> (object obj_to_init)
+
+DESCRIPTION
+        Optional hooks to initialize a blueprint which is loaded by
+        inheritance after creation.
+        Hook setting can be unbound lambda closures, or the name of
+        the function (static or public) to call in the object.
+
+        If the hook is a closure expecting an argument, it is bound
+        to the current object and called with the created object as
+        argument. If the hook as a closure without arguments, it is bound to
+        the object to be initalized and called.
+
+        If the result of the closure call is a non-zero number, it is used
+        as the interval to wait before the first reset(), else the default
+        interval computed from TIME_TO_RESET is used.
+
+        If the hook is defined as the name of an lfun in the object,
+        it is called in the object with 0 as argument, and any result
+        is ignored.
+
+HISTORY
+        LDMud 3.2.10 allowed static functions to be given by name.
+
+SEE ALSO
+        hooks(C), create_ob(H), create_clone(H)
diff --git a/doc/hook/default_method b/doc/hook/default_method
new file mode 100644
index 0000000..427a131
--- /dev/null
+++ b/doc/hook/default_method
@@ -0,0 +1,44 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_DEFAULT_METHOD, value)
+
+        <value> being:
+
+          int <name>(mixed & result, string fun, varargs args)
+          int <closure>(mixed & result, object ob, string fun, varargs args)
+
+DESCRIPTION
+        Optional hook to provide default implementation for unresolved
+        calls. Hook setting can be any closure, or the name of the
+        function to call in the object.
+
+        This hook is called whenever a call_other(), call_resolved()
+        or call_out() on named function (as opposed to a closure)
+        couldn't be resolved. The hook has then the opportunity to
+        provide a default implementation.
+
+        Exempt from this behaviour are calls to the master object, to
+        simul-efuns, and calls done with call_direct() and
+        call_direct_resolved().
+
+        If the hook is the name of an lfun, it is called in the target
+        object; otherwise if it is a closure, the target object is
+        passed as parameter <ob>.
+
+        The other parameters passed are the name <fun> of the called
+        function, the arguments <args> passed to the call (if any),
+        and a reference <result> to a variable for the call result.
+
+        If the hook can resolve the call, it has to return the call
+        result in <result> and 1 as function result.
+
+        If the hook can not (or doesn't want to) resolve the call, it
+        has to return 0.
+
+
+HISTORY
+        Introduced in LDMud 3.3.113
+
+SEE ALSO
+        hooks(C)
diff --git a/doc/hook/default_prompt b/doc/hook/default_prompt
new file mode 100644
index 0000000..6231bb4
--- /dev/null
+++ b/doc/hook/default_prompt
@@ -0,0 +1,24 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_DEFAULT_PROMPT, value)
+
+        <value> being:
+
+          string <prompt>
+          string <closure>()
+
+DESCRIPTION
+        Optional hook for the command prompt. If this hook is not used,
+        the driver will use "> " as the command prompt.
+
+        The hook can be given as string or as closure. If it is a
+        closure, it is called with the commandgiver being the calling
+        object. If the result is a string, it will be printed,
+        otherwise ignored.
+
+HISTORY
+        Introduced in LDMud 3.3.163.
+
+SEE ALSO
+        hooks(C), print_prompt(H)
diff --git a/doc/hook/erq_stop b/doc/hook/erq_stop
new file mode 100644
index 0000000..a135a1c
--- /dev/null
+++ b/doc/hook/erq_stop
@@ -0,0 +1,20 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_ERQ_STOP, value)
+
+        <value> being:
+
+          void <closure>()
+
+DESCRIPTION
+        Optional hook to notify the mudlib about the termination of
+        the erq demon.  Hook setting may be any closure.
+
+        The closure is called without arguments and may do whatever it
+        likes to clean-up after the erq.
+
+HISTORY
+
+SEE ALSO
+        hooks(C)
diff --git a/doc/hook/hook b/doc/hook/hook
new file mode 100644
index 0000000..3218445
--- /dev/null
+++ b/doc/hook/hook
@@ -0,0 +1,18 @@
+CONCEPT
+        driver hooks
+
+DESCRIPTION
+        To allow a greater flexibility of the muds, the gamedrivers
+        since 3.2.1 moved several once hardcoded 'underground'
+        activities from the driver into the mudlib. This includes for
+        example the differences between compat and native mode.
+
+        The hooks are set with the privileged efun set_driver_hook().
+        Some of the hooks are mandatory, some not. Most hooks accept
+        unbound lambda closures as values, some also lfun closures or
+        even strings.
+        The hooks are identified by an ordinal number, for which
+        symbolic names are defined in /sys/driverhooks.h.
+
+SEE ALSO
+        native(C), set_driver_hook(E)
diff --git a/doc/hook/include_dirs b/doc/hook/include_dirs
new file mode 100644
index 0000000..6557359
--- /dev/null
+++ b/doc/hook/include_dirs
@@ -0,0 +1,38 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_INCLUDE_DIRS, value)
+
+        <value> being:
+
+          string *<dirs>
+          string <closure>(string include_name, string current_file)
+
+DESCRIPTION
+        Semi-mandatory hook specifying the directories where <>-type
+        include files are searched (this includes ""-includes not
+        found as specified).  Hook setting may be any closure or a
+        string array. If not set, only ""-type includes may be used in LPC
+        programs.
+
+        The hook is called only if a call to master::include_file()
+        does not return a usable filename.
+
+        If the hook setting is a string array, it has to contain the
+        path names of those directories where <>-type includes are to
+        be searched. The directories are searched in the order they
+        appear in the array. The directory name and the name of the
+        actual include file are concatenated, therefore the directory
+        names have to end in '/'. Leading slashes may be omitted.
+
+        If the setting is a closure, it is called with the name of the
+        desired include file as first, and the name of the compiled
+        LPC file as second argument.  Result has to be the complete
+        path name of the include file to use. Leading slashes may be
+        omitted.  If the closure is a lambda closure, it is bound to
+        this_object() prior to execution.
+
+HISTORY
+
+SEE ALSO
+        hooks(C), auto_include(H), include_file(M)
diff --git a/doc/hook/load_uids b/doc/hook/load_uids
new file mode 100644
index 0000000..9d1e160
--- /dev/null
+++ b/doc/hook/load_uids
@@ -0,0 +1,35 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_LOAD_UIDS, value)
+
+        <value> being:
+
+          mixed <closure> (string objectname)
+
+DESCRIPTION
+        Mandatory hooks to determine the uid and euid of loaded or
+        cloned objects.  Hook settings can be any closure.
+
+        When an object is newly loaded, the H_LOAD_UIDS hook is called
+        with the object name as argument.  The new object already
+        exists, but has 0 uids.
+
+        For the result, the following possibilities exist (<num> is
+        a non-zero number, <no-string> is anything but a string):
+
+           "<uid>"                    -> uid = "<uid>", euid = "<uid>"
+           ({ "<uid>", "<euid>" })    -> uid = "<uid>", euid = "<euid>"
+           ({ "<uid>", <no-string> }) -> uid = "<uid>", euid = 0
+
+        If strict-euids is not active, the following results are
+        possible, too:
+
+           <num>                      -> uid = 0, euid = 0
+           ({ <num>, "<euid>" })      -> uid = 0, euid = "<euid>"
+           ({ <num>, <no-string> })   -> uid = 0, euid = 0
+
+HISTORY
+
+SEE ALSO
+        hooks(C), uids(C), clone_uids(H)
diff --git a/doc/hook/modify_command b/doc/hook/modify_command
new file mode 100644
index 0000000..f478312
--- /dev/null
+++ b/doc/hook/modify_command
@@ -0,0 +1,61 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_MODIFY_COMMAND, value)
+
+        <value> being:
+
+          int|string <closure>(string cmd, object player)
+          int|string <name>(string cmd)
+          <mapping>
+
+DESCRIPTION
+        Optional hook to modify commands (both entered or given by a
+        call to command()) before the parser sees them (this includes
+        special commands like 'status').
+
+        Hook setting can be any closure, the name of the function to
+        call in the object, or a mapping.
+
+        For interactives this hook is used only if the interactive
+        object has no command modifier already set by the efun
+        set_modify_command().
+
+        If the hook is a closure, it is called with the entered
+        command as first, and the command giving player as second
+        argument. Lambda closures are bound to the command giving player,
+        unbound-lambda closures remain unbound.
+
+        If the hook is a string, it is used as the name of an lfun
+        in the command giving player, which is called with the command
+        as argument.
+
+        If the hook is a mapping, it is queried with the given command
+        as index, and the data retrieved is used as new command
+        (defaults to 0 if no data is stored for a given command). If
+        an entry is a closure instead of a string, it is called as
+
+          int|string <closure>(string cmd, object player)
+
+        and the result from the call is used as 'the' command.
+
+        The result is treated equal in all three cases:
+         - If the result is a string, it is the new command to execute
+           instead of the given one. Note that it is not possible to
+           make several commands from one this way!
+         - If the result is a non-zero number, the given command is to
+           be ignored. In case of the closure/lfun setting this may
+           mean that the closure/lfun already executed it.
+         - If the result is 0, the originally given command is to be
+           used.
+
+        It is possible for the hook to change the command giver
+        (this_player()) for the execution of the command. This means that
+        even though the commands are execute for the original commandgiver,
+        this_player() will return the changed commandgiver.
+
+HISTORY
+
+SEE ALSO
+        hooks(C), command(H), modify_command_fname(H), notify_fail(H),
+        send_notify_fail(H)
diff --git a/doc/hook/modify_command_fname b/doc/hook/modify_command_fname
new file mode 100644
index 0000000..095ef80
--- /dev/null
+++ b/doc/hook/modify_command_fname
@@ -0,0 +1,44 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_MODIFY_COMMAND_FNAME, value)
+
+        <value> being:
+
+          int|string <name>(string cmd)
+
+DESCRIPTION
+        Mandatory hook specifying the name of the 'modify_command'
+        lfun to call for newly entered commands as result of a
+        set_modify_command().
+
+        Hook setting must be a string.
+
+        If set_modify_command() is used for an interactive user, all
+        newly entered commands are first passed to the function named
+        by this hook.
+
+        The function is called with the command as argument.
+
+        If the result is a string, it is the new command to execute
+        instead of the given one. Note that it is not possible to make
+        several commands from one this way!
+
+        If the result is a non-zero number, the given command is to be
+        ignored. In case of the closure/lfun setting this may mean
+        that the closure/lfun already executed it.
+
+        If the result is 0, the originally given command is to be
+        used.
+
+        It is possible for the hook to change the command giver
+        (this_player()) for the execution of the command. This means
+        that even though the commands are execute for the original
+        commandgiver, this_player() will return the changed
+        commandgiver.
+
+HISTORY
+
+SEE ALSO
+        hooks(C), command(H), modify_command(H), notify_fail(H),
+        send_notify_fail(H)
diff --git a/doc/hook/move_object b/doc/hook/move_object
new file mode 100644
index 0000000..5b2445d
--- /dev/null
+++ b/doc/hook/move_object
@@ -0,0 +1,27 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_MOVE_OBJECT0, value)
+        set_driver_hook(H_MOVE_OBJECT1, value)
+
+        <value> being:
+
+          void <closure>(object item, object dest)
+
+DESCRIPTION
+        Mandatory hooks to implement the efun void move_object().
+        Hook setting must be an unbound lambda closure.
+
+        Upon call, the hook has to perform the move itself (by using
+        set_environment()) and all depending actions (like the calls to
+        init() to add actions).
+
+        The difference lies in the binding of the set hook prior to
+        the call: the H_MOVE_OBJECT0 closure is bound to the current
+        object, the H_MOVE_OBJECT1 to 'item'.
+        If both hooks are set, H_MOVE_OBJECT0 is ignored.
+
+HISTORY
+
+SEE ALSO
+        move_object(E), set_environment(E), hooks(C)
diff --git a/doc/hook/msg_discarded b/doc/hook/msg_discarded
new file mode 100644
index 0000000..5360dfe
--- /dev/null
+++ b/doc/hook/msg_discarded
@@ -0,0 +1,28 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_MSG_DISCARDED, value)
+
+        <value> being:
+
+          string <msg>
+          string <closure>(object user)
+
+DESCRIPTION
+        Optional hook to specify a message or take other measures
+        when a message had to be discarded, because they could not
+        be delivered to the player <user>. If the hook is not set,
+        a standard message is used.
+
+        If the hook is a string, this text will be sent as soon as
+        possible to the player informing about the lost transmission.
+
+        If the hook is a closure, it is the function to be called
+        and the result is used as the message to be sent. Lambda
+        closures are bound to the interactive <user> first.
+
+HISTORY
+        Introduced in LDMud 3.3.719
+
+SEE ALSO
+        hooks(C), configure_interactive(E)
diff --git a/doc/hook/no_echo b/doc/hook/no_echo
new file mode 100644
index 0000000..b592529
--- /dev/null
+++ b/doc/hook/no_echo
@@ -0,0 +1,41 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_TELNET_NEG, value)
+
+        <value> being:
+
+          void <name>(int flag, object user, int no_telnet)
+          void <closure>(int flag, object user, int no_telnet)
+
+DESCRIPTION
+        Optional hook to specifiy how to perform the telnet actions to
+        switch the echo mode (used for e.g. password input_to()s).
+        Hook setting may be any closure or a string.  If not set, a
+        default handling is performed.
+
+        If the setting is a string, it used as name of an lfun to call
+        in the interactive <user>, where <flag> is the echo-flag
+        passed to the input_to() statement.
+
+        If the setting is a closure, it is called with the same
+        arguments, and unbound lambda-closures being bound to
+        this_player() prior to execution.
+
+        <local> is a boolean flag: it is TRUE when input_to() was
+        called with the INPUT_NO_TELNET flag.
+
+        When set, the hook is called whenever the driver needs to
+        change the echo mode, thus you can negotiate about things that
+        are coupled with it, like LINEMODE or character-at-a-time.
+
+        IMPORTANT: If this hook is used, the control of all telnet
+        negotiation is transferred to the mudlib: all incoming negotiations
+        are passed to H_TELNET_NEG, and the sending of no-echo negotiations
+        is handled by this hook.
+
+HISTORY
+        LDMud 3.2.11/LDMud 3.3.593 added the <no_telnet> argument.
+
+SEE ALSO
+        hooks(C), telnet(C), telnet_neg(H)
diff --git a/doc/hook/no_ipc_slot b/doc/hook/no_ipc_slot
new file mode 100644
index 0000000..4d1b0fb
--- /dev/null
+++ b/doc/hook/no_ipc_slot
@@ -0,0 +1,22 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_NO_IPC_SLOT, value)
+
+        <value> being:
+
+          0
+          string <msg>
+
+DESCRIPTION
+        Optional hook specifying the message given to logins
+        rejected due to space limitations (MAX_PLAYER).
+        Hook setting has to be string.
+
+        If set to 0, the default message "Lpmud is full. Come back
+        later." is issued.
+
+HISTORY
+
+SEE ALSO
+        hooks(C)
diff --git a/doc/hook/notify_fail b/doc/hook/notify_fail
new file mode 100644
index 0000000..8a4bacf
--- /dev/null
+++ b/doc/hook/notify_fail
@@ -0,0 +1,33 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_NOTIFY_FAIL, value)
+
+        <value> being:
+
+          string <msg>
+          string <closure>(string entered_command, object cmd_giver)
+
+DESCRIPTION
+        Mandatory hook to issue the default message if an entered
+        command couldn't be parsed and no notify_fail() command is in
+        effect.  Hook setting can be a any closure, or a string.
+
+        If set to a string, it is the message returned to the
+        player.
+
+        If set to a closure, it is called with the command and the
+        command giver as arguments, and the result is used as failure
+        message. Lambda closures are bound to this_player() prior to
+        execution.
+
+        <cmd_giver> is the object which received the command in the
+        first place. It is usually identical with this_player(),
+        unless the H_MODIFY_COMMAND hook changed it.
+
+HISTORY
+        LDMud 3.2.7 added the new 'command_giver' argument.
+
+SEE ALSO
+        hooks(C), command(H), modify_command(H), modify_command_fname(H),
+        send_notify_fail(H)
diff --git a/doc/hook/print_prompt b/doc/hook/print_prompt
new file mode 100644
index 0000000..f864db7
--- /dev/null
+++ b/doc/hook/print_prompt
@@ -0,0 +1,28 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_PRINT_PROMPT, value)
+
+        <value> being:
+
+          void <name>(string prompt).
+          void <closure>(string prompt)
+
+DESCRIPTION
+        Optional hook to print the current command prompt. If this
+        hook is not set, the driver will just print the prompt to the
+        user.
+
+        The hook is called with the prompt string as single argument
+        and has to print the prompt, e.g. using write() or
+        binary_message().
+
+        If the hook is a string, it is the name of an lfun in the
+        command giver. If the hook is a closure, it is called
+        with the command giver as previous object.
+
+HISTORY
+        Introduced in LDMud 3.3.163.
+
+SEE ALSO
+        hooks(C), default_prompt(H)
diff --git a/doc/hook/regexp_package b/doc/hook/regexp_package
new file mode 100644
index 0000000..ae52e3f
--- /dev/null
+++ b/doc/hook/regexp_package
@@ -0,0 +1,23 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+        #include <sys/regexp.h>
+
+        set_driver_hook(H_REGEXP_PACKAGE, value)
+
+        <value> being an integer:
+          0
+          RE_PCRE
+          RE_TRADITIONAL
+
+DESCRIPTION
+        Optional hook to select the default regexp package to use
+        for regular expression functions.
+
+        If set to 0, the default package determined by the driver's
+        configuration/commandline options is used.
+
+HISTORY
+        Introduced in LDMud 3.3.595.
+
+SEE ALSO
+        hooks(C), default_prompt(H), invocation(D), regexp(C)
diff --git a/doc/hook/reset b/doc/hook/reset
new file mode 100644
index 0000000..23f1dea
--- /dev/null
+++ b/doc/hook/reset
@@ -0,0 +1,38 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_RESET, value)
+
+        <value> being:
+
+          void|int <closure> ( void )
+          void <name>(1)
+
+DESCRIPTION
+        Optional hook to reset an object.
+        Hook setting can be unbound lambda closures, or the name of
+        the function (static or public) to call in the object.
+
+        If the hook is a closure, it is bound to the object to be
+        reset and called with no argument.
+
+        If the result of this call is a positive number, it is used as
+        the interval to wait before the next reset().  If the result
+        is 0, the default interval computed from TIME_TO_RESET is
+        used.  If the result is a negative number, the object will not
+        be reset again, unless directed otherwise by set_next_reset().
+
+        If the hook is defined as the name of an lfun in the object,
+        it is called in the object with 1 as argument, and any result
+        is ignored.  In this call the previous_object() is the object
+        initiating the reset.  If the function does not exist, the
+        object won't be reset again.
+
+        Note that an object is only reset by call to this hook if it
+        has been used since the last reset.
+
+HISTORY
+        LDMud 3.2.10 allowed static functions to be given by name.
+
+SEE ALSO
+        hooks(C)
diff --git a/doc/hook/send_notify_fail b/doc/hook/send_notify_fail
new file mode 100644
index 0000000..7f61bb4
--- /dev/null
+++ b/doc/hook/send_notify_fail
@@ -0,0 +1,34 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_SEND_NOTIFY_FAIL, value)
+
+        <value> being:
+
+          void <name>(string msg, object msgobj, object orig_cmd_giver)
+          void <closure>(string msg, object msgobj, object orig_cmd_giver)
+
+DESCRIPTION
+        Optional hook to send the notify fail message, regardless
+        of how it was determined, to the player. If the hook is not
+        set, the message is delivered using tell_object() internally.
+        Hook setting can be a string or a closure.
+
+        If the hook is a string, it is the name of a (possibly static)
+        function to call in the current command giver. If the hook
+        is a closure, it is the function to be called. Lambda closures
+        are bound to the current command giver first.
+
+        The arguments to the call are:
+         - <msg> is the notify fail message to be delivered.
+         - <msgobj> is the object which set the message. It is 0 for
+           the default message.
+         - <orig_cmd_giver> is the object for which the original
+           command was first received. It is usually identical with
+           the current command giver this_player().
+
+HISTORY
+
+SEE ALSO
+        hooks(C), command(H), modify_command(H), modify_command_fname(H),
+        notify_fail(H)
diff --git a/doc/hook/telnet_neg b/doc/hook/telnet_neg
new file mode 100644
index 0000000..0f8b8c1
--- /dev/null
+++ b/doc/hook/telnet_neg
@@ -0,0 +1,72 @@
+SYNOPSIS
+        #include <sys/driver_hooks.h>
+
+        set_driver_hook(H_TELNET_NEG, value)
+
+        <value> being:
+
+          void|mixed <name>(int action, int option [, int * opts ] )
+          void|mixed <closure>(int action, int option [, int * opts ] )
+
+DESCRIPTION
+        Optional hook to specifiy how to perform a single telnet
+        negotiation.  Hook setting may be any closure or a string.  If
+        not set, most telnet options are rejected (read: only a very
+        minimal negotiation takes place).
+
+        The hook is called whenever the driver receives a demand for
+        option negotiation for any option the driver does not handle itself.
+        By default, the driver deals with the following options:
+            TELOPT_ECHO:      Echo option
+            TELOPT_SGA:       Suppress Go Ahead (nearly always on)
+            TELOPT_COMPRESS:  Mud client compression protocol (obsolete)
+            TELOPT_COMPRESS2: Mud client compression protocol V2
+
+        For all other telnet options negotiations, this hook is called.
+
+        The hook has then to perform the negotiation using the efun
+        binary_message().
+
+        Alternatively, if H_NOECHO is set, this hook is called for
+        _all_ telnet data received.
+
+        If the setting is a string, it used as name of an lfun to call
+        in this_player(). Closures are just called, with unbound
+        lambda-closures being bound to this_player() prior to
+        execution.
+
+        The hook is called for a 'DO/DONT/WILL/WONT <opt>' with the action
+        (DO/DONT/...) as the first, and <opt> as the second argument.
+
+        For example:, if the driver receives the sequence
+
+          IAC SB <opt> <opts>...
+
+        followed by IAC SB/SE,  the hook is called with 'SB' as first
+        argument, <opt> as second, and <opts> as an array of integers as
+        third argument.
+
+REMARKS
+        An incomplete list of telnet negotiations this hook is called
+        for includes the following:
+            SB:               Suboption negotiation
+            TELOPT_LINEMODE:  linemode
+            TELOPT_NAWS:      window size
+            TELOPT_TTYPE:     terminal type
+            TELOPT_TM:        timing mark
+            TELOPT_NEWENV:    remote environment variables
+            TELOPT_ENVIRON:   remote environment variables
+            TELOPT_XDISPLOC:  remote X display address
+            TELOPT_TSPEED:    terminal speed
+            TELOPT_BINARY:    binary data, needed for non-ASCII charsets
+            TELOPT_EOR:       TinyFugue prompt marker (together with EOR)
+
+            TELOPT_MSP:       Mud Sound Protocol
+            TELOPT_MXP:       Mud Extension Protocol
+            TELOPT_MSSP:      Mud Server Status Protocol
+            TELOPT_GMCP:      Generic Mud Communication Protocol
+
+HISTORY
+
+SEE ALSO
+        hooks(C), telnet(C), no_echo(H)