Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/doc/concepts/memory b/doc/concepts/memory
new file mode 100644
index 0000000..9524eb3
--- /dev/null
+++ b/doc/concepts/memory
@@ -0,0 +1,56 @@
+CONCEPT
+ memory
+ swapping
+
+DESCRIPTION
+
+ TODO: This is out of date. Also document the relation with reset
+
+ (Collected from the Changelogs of the driver source)
+
+ The swapping algorithm has been changed. A test is done for
+ every object, comparing to a time stamp. If the object hasn't
+ been touched for a while, it could be subject for swapping.
+ Here comes the new thing: the function 'clean_up()' will be
+ called in the object. If the object still remains, the old
+ swapping algorithm will continue. That means that objects that
+ would never be subject to swapping (cloned objects) now have a
+ chance to self-destruct. It also means that rooms that
+ contains no important data can self-destruct. Self-destruction
+ saves more memory than swapping, as swapping only frees the
+ program code, while self-destruction also frees the internal
+ object representation.
+
+ The call of clean_up() has been modified. There is a constant
+ in config.h that defines how long time until clean_up is
+ called in an object. This call is independent of reset() and
+ swapping. It is recommended that the swapping time is
+ something short, like 10 minutes to 30 minutes, while the time
+ to clean_up is longer.
+
+ Fixed several bugs in the swap/reset/clean_up logic.
+ Recommended values are that the swap time is short (less than
+ 30 minutes), and that reset time is medium (aprox 60 minutes),
+ and that time to clean_up is long (greater than 1.5h hours).
+ Any feedback of how to best tune these values are welcome. The
+ call of reset will be done once, and not yet again until the
+ object has been touched. This enables reset'ed objects to stay
+ swapped out. If you have a mudlib that has no ojbects that
+ defines 'clean_up', then you may better define this time as 0,
+ which means never call clean_up (and thus never swap the
+ object in needlessly). A well implemented usage of clean_up is
+ better than the swap algorithm, as even cloned objects can be
+ cleaned up and a self destruction is more efficient than
+ swapping (memory wise).
+
+ Changed mechanism of calling clean_up() slightly. Only objects
+ that defines the function will be called. And, only clean_up()
+ that returns non-zero will be called again. This will minimize
+ calls of clean_up(), while still cost very litte to maintain.
+
+ clean_up() now gets a flag as argument, which will be non-zero
+ if the the program of this object is used for inheritance by
+ other objects.
+
+SEE ALSO
+ clean_up(A), slow_shut_down(M), quota_demon(M), malloc(D)