Creates and returns a new object whose parent is parent and whose owner
is as described below. Either the given parent object must be #-1
or valid and fertile (i.e., its `f' bit must be set) or else the
programmer must own parent or be a wizard; otherwise E_PERM is
raised. E_PERM is also raised if owner is provided and not
the same as the programmer, unless the programmer is a wizard. After the new
object is created, its initialize verb, if any, is called with no
arguments.

The new object is assigned the least non-negative object number that has not
yet been used for a created object. Note that no object number is ever reused,
even if the object with that number is recycled.

The owner of the new object is either the programmer (if owner is not
provided), the new object itself (if owner was given as #-1), or
owner (otherwise).

The other built-in properties of the new object are initialized as follows:

name ""
location #-1
contents {}
programmer 0
wizard 0
r 0
w 0
f 0

The function `is_player()' returns false for newly created objects.

In addition, the new object inherits all of the other properties on
parent. These properties have the same permission bits as on
parent. If the `c' permissions bit is set, then the owner of the
property on the new object is the same as the owner of the new object itself;
otherwise, the owner of the property on the new object is the same as that on
parent. The initial value of every inherited property is clear;
see the description of the built-in function clear_property() for
details.

If the intended owner of the new object has a property named
`ownership_quota' and the value of that property is an integer, then
create() treats that value as a quota. If the quota is less than
or equal to zero, then the quota is considered to be exhausted and
create() raises E_QUOTA instead of creating an object.
Otherwise, the quota is decremented and stored back into the
`ownership_quota' property as a part of the creation of the new object.

Function: none chparent(obj object, obj new-parent)

Changes the parent of object to be new-parent. If object is
not valid, or if new-parent is neither valid nor equal to #-1,
then E_INVARG is raised. If the programmer is neither a wizard or the
owner of object, or if new-parent is not fertile (i.e., its
`f' bit is not set) and the programmer is neither the owner of
new-parent nor a wizard, then E_PERM is raised. If
new-parent is equal to object or one of its current ancestors,
E_RECMOVE is raised. If object or one of its descendants
defines a property with the same name as one defined either on new-parent
or on one of its ancestors, then E_INVARG is raised.

Changing an object's parent can have the effect of removing some properties
from and adding some other properties to that object and all of its descendants
(i.e., its children and its children's children, etc.). Let common be
the nearest ancestor that object and new-parent have in common
before the parent of object is changed. Then all properties defined by
ancestors of object under common (that is, those ancestors of
object that are in turn descendants of common) are removed from
object and all of its descendants. All properties defined by
new-parent or its ancestors under common are added to object
and all of its descendants. As with create(), the newly-added
properties are given the same permission bits as they have on new-parent,
the owner of each added property is either the owner of the object it's added
to (if the `c' permissions bit is set) or the owner of that property on
new-parent, and the value of each added property is clear; see the
description of the built-in function clear_property() for details. All
properties that are not removed or added in the reparenting process are
completely unchanged.

If new-parent is equal to #-1, then object is given no
parent at all; it becomes a new root of the parent/child hierarchy. In this
case, all formerly inherited properties on object are simply removed.

Function: int valid(obj object)

Returns a non-zero integer (i.e., a true value) if object is a valid
object (one that has been created and not yet recycled) and zero (i.e., a false
value) otherwise.

valid(#0) => 1
valid(#-1) => 0

Function: obj parent(obj object)

Function: list children(obj object)

These functions return the parent and a list of the children of object,
respectively. If object is not valid, then E_INVARG is raised.

Function: none recycle(obj object)

The given object is destroyed, irrevocably. The programmer must either
own object or be a wizard; otherwise, E_PERM is raised. If
object is not valid, then E_INVARG is raised. The children of
object are reparented to the parent of object. Before object
is recycled, each object in its contents is moved to #-1 (implying a
call to object's exitfunc verb, if any) and then object's
`recycle' verb, if any, is called with no arguments.

After object is recycled, if the owner of the former object has a
property named `ownership_quota' and the value of that property is a
integer, then recycle() treats that value as a quota and increments
it by one, storing the result back into the `ownership_quota' property.

Function: int object_bytes(obj object)

Returns the number of bytes of the server's memory required to store the given
object, including the space used by the values of all of its non-clear
properties and by the verbs and properties defined directly on the object.
Raised E_INVARG if object is not a valid object and E_PERM
if the programmer is not a wizard.

Function: obj max_object()

Returns the largest object number yet assigned to a created object. Note that
the object with this number may no longer exist; it may have been recycled.
The next object created will be assigned the object number one larger than the
value of max_object().