Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/doc/LPC/operators b/doc/LPC/operators
new file mode 100644
index 0000000..18406a3
--- /dev/null
+++ b/doc/LPC/operators
@@ -0,0 +1,213 @@
+NAME
+ operators
+
+DESCRIPTION
+
+ These are the operators availailable in LPC. They are listed
+ in the order of precedence (low priority first):
+
+
+ expr1 , expr2 Evaluate 'expr1' and then 'expr2'. The
+ returned value is the result of 'expr2'. The
+ returned value of 'expr1' is thrown away.
+
+ var = expr Evaluate 'expr', and assign the value to
+ 'var'. The new value of 'var' is the result.
+
+ var += expr Assign the value of 'expr' + 'var' to 'var'.
+ This is mostly equivalent to "var = var + expr".
+
+ var -= expr Similar to '+=' above.
+ var &= expr
+ var |= expr
+ var ^= expr
+ var <<= expr
+ var >>= expr
+ var >>>= expr
+ var *= expr
+ var %= expr
+ var /= expr
+ var &&= expr
+ var ||= expr
+
+ expr1 ? expr2 : expr3
+ Evaluates 'expr1' and branches according to
+ its truth value. If it is true, the 'expr2' is
+ evaluated and returned as result, else
+ 'expr3'.
+
+ expr1 || expr2 The result is true if 'expr1' or 'expr2' is
+ true. 'expr2' is not evaluated if 'expr1' was
+ true.
+
+ expr1 && expr2 The result is true i 'expr1' and 'expr2' is
+ true. 'expr2' is not evaluated if 'expr1' was
+ false.
+
+ expr1 | expr2 The result is the bitwise or of 'expr1' and
+ 'expr2'.
+ For arrays, the union set is computed: all elements
+ from <expr1> plus all those from <expr2> which
+ are not in <expr1>.
+
+ expr1 ^ expr2 The result is the bitwise xor of 'expr1' and
+ 'expr2'.
+ For arrays, the symmetric difference is computed:
+ all elements from <expr1> which are not in <expr2>,
+ plus all those from <expr2> which are not in <expr1>.
+
+ expr1 & expr2 The result is the bitwise and of 'expr1' and
+ 'expr2'.
+
+ For arrays and strings, the intersection set
+ (all elements resp. characters from expr1 which
+ which are also in the expr2) is computed.
+ Note: "aab" & "a" -> "aa"
+ but ({ 'a','a','b' }) & ({ 'a' }) -> ({ 'a' })
+ Eventually the array behaviour will be changed
+ to match the string behaviour.
+
+ Intersecting an array with a mapping is equivalent
+ to intersecting the array with the indices of the
+ mapping: array & mapping = array & m_indices(mapping)
+
+ Mappings can be intersected with another mapping
+ or an array. The resulting mapping holds all
+ those entries from the first mapping, which are
+ also mentioned in the second mapping (as index)
+ resp. in the array.
+
+ expr1 == expr2 Compare values. Valid for strings, numbers,
+ objects and closures.
+
+ expr1 != expr1 Compare values. Valid for strings, numbers,
+ objects and closures.
+
+ expr1 > expr2 Valid for strings and numbers.
+
+ expr1 >= expr2 Valid for strings and numbers.
+
+ expr1 < expr2 Valid for strings and numbers.
+
+ expr1 <= expr2 Valid for strings and numbers.
+
+ expr1 << expr2 Shift 'expr1' left by 'expr2' bits; the sign
+ bit is not preserved.
+
+ expr1 >> expr2 Shift 'expr1' right by 'expr2' bits.
+ This shift preserves the sign of 'expr1'.
+
+ expr1 >>> expr2 Shift 'expr1' right by 'expr2' bits.
+ This shift does not preserve the sign of 'expr1',
+ instead it shifts in 0 bits.
+
+ expr1 + expr2 Add 'expr1' and 'expr2'. If numbers, then
+ arithmetic addition is used. If one of the
+ expressions are a string, then that string is
+ concatenated with the other value.
+ If the expressions are arrays, the result is
+ the right array appended to the left.
+ If the expressions are mappings of equal width,
+ the result is merger of the two mappings. If one
+ key exists in both mappings, the element from the
+ right mapping appears in the result. If the two
+ mappings are of different width, the result is
+ <expr1> if non-empty, and <expr2> otherwise.
+
+ expr1 - expr2 Subtract 'expr2' from 'expr1'. Valid for
+ numbers, strings, arrays, mappings.
+ For arrays and strings, all occurences of the
+ elements resp. characters in 'expr2' are removed
+ from 'expr1', and the result is returned.
+ For mapping, all occurances of elemens in 'expr1'
+ which have a matching key in 'expr2' are removed, and
+ the result is returned.
+
+ expr1 * expr2 Multiply 'expr1' with 'expr2'.
+ If strings or arrays are multiplied with a number
+ (zero or positive), the result is a repetition of the
+ original string or array.
+
+ expr1 % expr2 The modulo operator of numeric arguments.
+
+ expr1 / expr2 Integer division.
+
+ ++ var Increment the value of variable 'var', and
+ return the new value.
+
+ -- var Decrement the value of variable 'var', and
+ return the new value.
+
+ - var Compute the negative value of 'var'.
+
+ ! var Compute the logical 'not' of an integer.
+
+ ~ var The boolean 'not' of an integer.
+
+ ( type ) var Return the value of <var> converted to <type>.
+ <type> can be 'string', 'int', 'object', 'float'
+ or 'int*'. <var> must be of a specific type
+ for a conversion to take place; if <var> is 'mixed'
+ or unknown, the cast is purely declarative.
+ Also, if the declared type of <var> is that of <type>,
+ the value is not changed.
+
+ NB. The literal number 0 is of unknown type, as
+ it doubles as 'not initialized' for strings, objects,
+ and arrays.
+
+ The operator acts like the efuns
+ to_string(), to_int(), to_object(), to_float()
+ and to_array(). It is advisable to use the
+ efuns directly instead of the cast.
+
+ ({ type }) var <var> is now assumed to have the type <type>.
+ This is purely declarative, the actual value
+ of <var> is not changed.
+
+ var ++ Increment the value of variable 'var', and
+ return the old value.
+
+ var -- Decrement the value of variable 'var', and
+ return the old value.
+
+ expr1[expr2] The array or mapping given by 'expr1' is
+ indexed by 'expr2'.
+
+ expr1[expr2..expr3] Extracts a
+ piece from an array or string.
+ expr2 or expr3 may be omitted, default is the begin
+ or end of expr1.
+ Negative numbers for expr2 or expr3
+ mean ``count from before the beginning'', i.e.
+ foo[-2..-1] is an empty array or string.
+ foo[<2..<1] gives the 2nd and last element of
+ the array resp. chars of the string.
+
+ expr1->name(...) The symbolic form of call_other(). 'expr1'
+ gives either an object or a string which is
+ used as the file_name of an object, and calls
+ the function 'name' in this object.
+
+ ident::name(...)
+ Call the inherited function 'name' with the
+ given parameters in the parent 'ident'.
+ 'ident' may be given as string containing the
+ full pathname, or as identifier containing the
+ pure basename.
+ If 'ident' is omitted, the last inherited
+ function of this 'name' is called.
+
+ ({ }) Array constructor.
+ ([ ]) Mapping constructor.
+
+NOTE
+ The closure operators are not described here.
+
+HISTORY
+ LDMud 3.2.9 added '>>>', '>>>=', '&&=' and '||='.
+ LDMud 3.2.10 extended '&' to mappings.
+ LDMud 3.3 extended '|' and '^' to arrays.
+
+SEE ALSO
+ arrays(LPC), alists(LPC), mappings(LPC), closures(LPC)