Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/doc/efun/call_direct b/doc/efun/call_direct
new file mode 100644
index 0000000..94ab028
--- /dev/null
+++ b/doc/efun/call_direct
@@ -0,0 +1,75 @@
+SYNOPSIS
+ unknown call_direct (object ob, string fun, mixed arg, ...)
+ unknown call_direct (object *ob, string fun, mixed arg, ...)
+
+DESCRIPTION
+ Call a member function <fun> in another object <ob> with an
+ the argument(s) <arg...>. Result is the value returned from
+ the called function (or 0 for non-existing or void functions).
+
+ This efun is a twin to call_other(), with the difference
+ being that call_direct() never calls a default method.
+
+ Optionally the driver can be configured to accept an array of
+ objects as <ob>: the function is called with the same
+ arguments in all the given objects. The single results are
+ collected in an array and yield the final result. Array
+ elements can be objects or the names of existing objects;
+ destructed objects and 0s will yield a '0' as result, but
+ don't cause an error.
+
+ If the array-calling mode is available, the macro
+ __LPC_ARRAY_CALLS__ is defined.
+
+ The object(s) can be given directly or via a string (i.e. its
+ object_name). If it is given by a string and the object does not
+ exist yet, it will be loaded.
+
+ ob->fun(args) and "ob_name"->fun(args) is equivalent to
+ call_other(ob, "fun", args). Nowadays the ob_name string can
+ also be a variable.
+
+ ob->fun(args) and ob->"fun"(args) are equivalent to
+ call_other(ob, "fun", args). ob->(fun)(args) are equivalent
+ to call_other(ob, fun, args) where fun is a runtime expression
+ returning the function name.
+
+ If ob::fun does not define a publicly accessible function, the
+ call_other() will return 0, which is indistinguishable from
+ a function returning 0.
+
+ "publicly accessible" means "public" when calling other objects,
+ and "public" or "static" when calling this_object(). "private"
+ and "protected" function can never be called with call_other().
+
+ The return type of call_other() is 'any' be default. However,
+ if your LPC code uses #pragma strict_types, the return type is
+ 'unknown', and the result of call_other() must be casted to
+ the appropriate type before you can use it for anything.
+
+EXAMPLES
+ // All the following statements call the lfun QueryProp()
+ // in the current player with the argument P_SHORT.
+ string str, fun;
+
+ str = (string)call_direct(this_player(), "QueryProp", P_SHORT);
+ fun = "QueryProp";
+ str = (string)call_direct(this_player(), fun, P_SHORT);
+
+ You have to do explicit type casting because of the unknown
+ return type, if you have set #pragma strict_types.
+
+ // This statement calls the lfun short() in all interactive users
+ // and stores the collected results in a variable.
+ string * s;
+
+ s = (string *)call_direct(users(), "short");
+
+
+HISTORY
+ Introduced in LDMud 3.3.113 with the H_DEFAULT_METHOD hook.
+ LDMud 3.2.10 made the call on arrays of objects configurable.
+
+SEE ALSO
+ call_other(E), call_direct_resolved(E), create(A), pragma(LPC),
+ extern_call(E), function_exists(E), functions(LPC)