GCOOPE Version 1.0 BASIC Class library

		by Brian Lee Price

	    Released as Public Domain  July, 1994.


	The class library in the initial Version 1.0 release:

		Char
		ShortInt
		Unsigned
		LongInt
		Pointer
		Dynmem
		Collection
		Array
		LowStream
		String
		StdStream
		Stream
                File


	    The classes Char, ShortInt, and Unsigned are flag classes,
	normally requiring no instance memory unless inherited.  The
	other base classes (no ancestors or special functionality) are
	LongInt, and Pointer.

	    Collection is actually more of a pseudo-class, it is an
	example of a 'wrapper' class that provides an object oriented
	interface to standard 'C' library type functions.  (In this
	case the functions are defined in the kernel module listmgr.c).
	It does not inherit any classes.

	    LowStream is an example of an expansion class.  While it
	does not inherit any classes, any class inheriting LowStream
	must also have Dynmem as an ancestor.  LowStream adds low
	level stream i/o capability to any Dynmem based class.

	    StdStream is another example of a 'wrapper' class, it
	provides an object oriented interface to the standard ANSI-C
	stream i/o library functions.  It shares the same interface
	specification as the Stream class.

	    Stream is a special class, it provides high level stream
	i/o to any user defined class that has low level stream i/o
	using the same interface as LowStream.  It does not necessarily
	need to be inherited in order to provide this functionality but
	in most cases it will prove simpler to inherit it.

	    Dynmem is a low level example of multiple inheritance,
	while it could be implemented (and probably be more efficient)
	as a base class, it is very simple to define it in terms of
	an Unsigned and Pointer child.  Note the redefinition of
	valueOf for both inherited classes by means of renaming them
	to sizeOf and addressOf.

	    Array class is a child of Dynmem and provides basic
	dynamic array class functionality.  The provided methods
	can work with items of various sizes but any one array sub-
	class must use items of the same size.

	    The String class is an especially potent mixture of
	previously defined classes.  It combines an Array with
	LowStream providing a construct which can be the target
	of stream i/o operations, be addressed as an array of
	characters, or be accessed as a string.  However, it should
	be noted that string access is NOT to a null terminated
	string.  The length of the string must be obtained through
	the lengthOf generic.

	    The last class defined in the initial release class
	library is the File class.  This class inherits the
	StdStream class and provides automatic file closing for
	temporary files.


	    The provided classes are not meant to be a complete
	set of basic class types, nor are they optimized in any
	way.  However, they do serve to illustrate many of the
	possible operations that can be performed with the GCOOPE
	framework.  Frankly, I'm still experimenting with the
	capabilities of the system.  As I develop higher level
	constructs, I intend to let the need for a fuller and
	richer set of base classes and generic methods make itself
	apparent rather than blindly developing classes and methods
	that may end up being unneccessary.