Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/doc/LPC/functions b/doc/LPC/functions
new file mode 100644
index 0000000..50c39a0
--- /dev/null
+++ b/doc/LPC/functions
@@ -0,0 +1,174 @@
+CONCEPT
+ functions
+
+DESCRIPTION
+ Functions are named blocks of code which are be called with
+ a number of argument values, and which return a result value
+ to the caller.
+
+ Functions are defined in an object and are also known as
+ "local funs" or short "lfuns".
+
+
+ DEFINING A FUNCTION
+
+ A function definition takes the form
+
+ <modifiers> <type> name ( <arguments> ) {
+ statements...
+ }
+
+ The parts in detail:
+ - <modifiers> can be any one of "static", "private", "public"
+ and "protected" (see modifiers(LPC)), optionally combined
+ with "varargs" (see varargs(LPC)) and/or "nomask".
+ If not specified, the function behaves as if it was
+ specified as "public", but this visibility can be restricted
+ in derived object through non-public inheritance.
+ - <type> is the type of the result returned by the function.
+ If specified as "void", the function is compiled to return
+ the value 0 under all circumstances. If not specified, the
+ type is assumed to be "mixed", furthermore typechecking is
+ disabled for this function.
+ - name is the name of the function, e.g. "short", or "Nice_Try",
+ under which it is made known.
+ - <arguments> is a list of variable definitions in the
+ normal '<type> <name>' style, separated by comma.
+ Examples: () : no argument taken
+ (int a) : takes on integer argument
+ (mixed a, object *b): takes two arguments, one
+ arbitrary type, one array of objects.
+ - { statements... } defines the code for this function. This
+ is a normal block (see block(LPC)) and as such can define
+ its own local variables.
+
+
+ DECLARING A FUNCTION
+
+ A function declaration makes the name and type of a function known
+ to the compiler with the assertion that the code for this function
+ will be provided "elsewhere".
+
+ The form is:
+
+ <modifiers> <type> name ( <arguments> );
+
+ Typical uses are:
+ - to declare in advance functions which are called before they
+ can be defined; for example if the create() function of an object
+ calls other functions which are defined after the create().
+ - to declare functions which will be provided by an inheriting
+ object.
+
+ Calling a declared but undefined function results in a runtime error.
+
+
+ CALLING A FUNCTION
+
+ Functions in other objects are called with the call_other() efun,
+ which can be shortened to '->':
+
+ ob->fun(a, b, c)
+ call_other(ob, "fun", a, b, c)
+
+ Note: See the entry H_DEFAULT_METHOD in hooks(C) for a modification
+ of this behaviour.
+
+ Functions in the same object are called just by writing their name,
+ followed by the arguments in parenthesis:
+
+ short()
+ compute(a)
+ do_that(a, "foo")
+
+ Array function arguments can be 'flattened' with the '...' operator.
+ For example:
+
+ mixed * m = ({ "foo", "bar" });
+ fun(m..., 1);
+
+ will be executed as:
+
+ fun("foo", "bar", 1);
+
+
+ If the number of values passed to the function does not match the
+ number of expected arguments (and if type checking is not enabled), the
+ driver will perform the necessary adaption at call time: excess
+ values are ignored, missing values are substituted by the number 0.
+ The values passed to the called function are massaged by the driver
+ to match the argument list
+
+
+ FUNCTIONS AND INHERITANCE
+
+ A "public" or "protected" (== "static") function defined in one
+ object is also visible in all inheriting objects. The exception from
+ this rule is when an inheriting child redefines ("overloads") the
+ inherited function with its own. When compiling with type checking,
+ the argument list of the redefined function has to match the
+ original one.
+
+ When a function is called, the driver looks for the function first
+ in the object called, and if not found there, then in the inherited
+ objects.
+
+ To explicitely call an inherited function (useful when a redefining
+ functions wants to use the original one), the "::" operator is used:
+
+ ::create()
+ ::compute(a)
+
+ The named function is searched only in the inherited objects, and
+ the first found is used.
+
+
+ If the function is inherited from several objects and a specific
+ one is to be called, the "::" can be extended to contain the
+ partial or full name of the inherited object:
+
+ inherit "/obj/cooker";
+ inherit "/obj/container";
+
+ tainer::create()
+ container::create()
+ "tainer"::create()
+ "container"::create()
+ "obj/container"::create()
+ "/obj/container"::create()
+
+ all call the create() in the container inherit. Note that the
+ name given to the :: operator is matched against the ends of
+ the inherited names.
+
+
+ One special form of this call is
+
+ efun::find_object()
+
+ which bypasses any redefinition of an efun (here find_object())
+ and directly calls the efun itself. This is only possible for
+ efun-redefinitions which do not use the "nomask" modifier.
+
+
+ Additionally, a call to a function inherited from several objects
+ can be instructed to call _all_ inherited functions through the
+ use of the wildcards "*" (match any number of arbitrary characters)
+ and "?" (match one arbitrary character):
+
+ inherit "/obj/cooker";
+ inherit "/obj/container";
+
+ "*"::create()
+ "co*"::create()
+ "*er"::create()
+
+ all call both inherited create()s. The function called this way
+ must not take arguments, and the single results from all calls are
+ combined into one array used as final result. If there is no such
+ function inherited at all, the statement will just return
+ an empty array.
+
+SEE ALSO
+ types(LPC), modifiers(LPC), varargs(LPC), references(LPC),
+ call_other(E), simul_efun(C), call_out(E)