New release of the ASL components (new license!)

[Corey Minyard <minyard@acm.org>]

I have put a new version of my ASL components on my web page
(http://www.concentric.net/~Minyard).

I haven't added any new functionality to the components, and nobody
has reported any bugs (I guess no one else is using it :-).  I have
re-licensed it using a modified GPL, the same as GNAT.  Hopefully this
will make them more accessible to others.  It compiles and passes all
tests with gnat-3.11p, btw.  It will not work with gnat-3.10p.


Containers
----------

The container classes consist of the main container types: 

 * Vector - A variable-sized array

 * AList - A list based upon an array.  This is good for stacks and
   queues that don't require insertions in the middle.

 * DList - A doubly linked list, also good for stacks and queues.
   This one is good at insertions in the middle.

 * Tree - An ordered binary tree, balance or unbalanced. 

 * List - A singly linked list, good for traversing in order, but you
   can't go backwards.

 * Hash - A hash table.  Good for fast lookups, sets, and bags. 

 * Heap - An ordered heap.  Good for finding the largest or smallest
   value in a set.

 * Graph - A standard graph.  The links are all bidirectional 

 * DiGraph - A directed graph.  The links are uni-directional. 

 * BTree - Good for fast lookups.  Not quite as fast as heaps, but
   more deterministic.

Containers come in three flavors: 

 * Fixed - Implemented using a fixed size array.  These containers are
   guaranteed to not allocate any dynamic store for their operations.

 * Expandable - Implemented using a pointer to an array that will be
   reallocated as necessary.

 * Dynamic - Each node in the container is dynamically allocated.

All containers come in all flavors, except a few do not have dynamic
flavors because it doesn't make sense and Btrees are only dynamic.
Actually, some other combinations don't seem to make much sense, but
someone might use them so they are provided.

All containers come in versions that use the default storage
management or allow the user to specify the storage management.

The containers are quite functional, each has a rich set of functions.
Tests and example programs are provided as well as some reasonable
documentation.

Semaphores
----------

The ASL contains several semaphore objects implemented using protected types: 

 * Binary - A standard binary semaphore 
 * Counting - A standard counting semaphore 
 * Nested - A binary semaphore, but the same task can claim it
   multiple times.  It must be released the same number of times (by
   that task) to release the semaphore.
 * Nested_Prio - A nested semaphore, but it does priority inheritance.
   This doesn't really work yet because setting dynamic priorities in
   Ada doesn't work immediately.  If anyone has an idea how to make it
   work, I'd like to know.

Leak Detection Storage Manager

A storage manager that tracks all the allocated data and lets the user
iterate over it.  Useful for finding memory leaks.  It has found a
few for me :-).

-- 
Corey Minyard                   Internet:  minyard@acm.org
  Work: minyard@nortelnetworks.com  UUCP:  minyard@wf-rch.cirr.com