20120629:

The tsctl application has additional features: you can now use any class,
and you can run multiple commands from a single invocation of tsctl either
by reading them from a file (-f filename), from stdin (--), or by separating
each command on the command line with a semi-colon ("\;" to avoid shell
interpretation).

The "-fms-extensions" flag is now required when compiling with gcc. All 
classes now properly "inherit" their base class via an anonymous reference 
to their base class.  If you need to compile with a compiler that does not
support this feature you will need to create a #define for each definition
instead.

The API has been altered for functions which take pointers. Now all functions
follow these constraints:
1. Caller allocated storage that a function uses to return data which is not
the same length on every call are denoted by a regular pointer as a function 
parameter.  If the data is always the same length, it is denoted by an
array.
2. Caller data that is passed to the function by a pointer is denoted by a 
const array or const pointer as a function paramter, depending on if the
length of the array is always the same or not, respectively.
3. Return data that is allocated by the function is denoted by a pointer
being returned from the function.  This occurs when the caller does not
know in advance how much data the function will return.
4. All pointers in function parameters and returns are to the start of an
Array.  The Array is encapsulates meta-data such as the length of the Array.
It is otherwise accessed like a normal C array (and you should not access 
beyond the bounds of the array), although you must use the functions in 
Array.h for allocating, freeing, and performing Array functions on it.  
For a constant length C array, the array is passed instead of a pointer.

More complete documentation on this can be found here:
http://oz.embeddedARM.com/~michael/Array.html
http://oz.embeddedARM.com/~michael/Conventions.html

Functions which are affected by this change, and their new prototypes, are
shown below:
    System:
    LockHolder* LockHolderInfo(void *);
    ConnWaitInfo* ConnWaitInfo(void *);
    void BuildInfo(void *,BuildInfo*);
    char* MapGet(void *,int n);
    int MapLookup(void *,const char*);
    char* MapLookupPartial(void *,const char* stem,int value);
    int MapAdd(void *,const char* key,int value);
    int MapDelete(void *,const char* key);

    Bus:
    void PeekStream(void *,int address,int direction,char* dest);
    void PokeStream(void *,int address,int direction,const char* data);

    DIO:
    void Wait(void *,int* match,int min,int max,const int* nh,const int* nl);

    CAN:
    int (*Tx)(CAN *,unsigned flags,unsigned id,const char* data);
    int (*Rx)(CAN *,CANMessage [1]);
    int (*RxMulti)(CAN *,CANMessage* msgbuf,int min);

    TWI:
    int Write(void *,int devadr,int adrslen,int adrs,const char* data);
    int Read(void *,int devadr,int adrslen,int adrs,char* dest);

    SPI:
    int Read(void *,int adrs,char* dest);
    int Write(void *,int adrs,const char* data);
    int ReadWrite(void *,int adrs, const char* data, char* dest);

    EDIO and AIO prototypes will change later when we actually have a
    complete implementation of these objects.

The arguments to the tsctl client will also be changing to exactly match
the corresponding C prototypes.  The procedure for doing this is:
    Distinguish request and reply portions of the C prototype by
    treating all non-const pointers after the first (which is the "this"
    pointer) as sequential portions of the reply following the initial
    value returned by the function.  These are then removed, leaving
    the remaining parameters to be the sequential arguments to the function.

The network protocol will also be changing to exactly match the corresponding
C prototypes.

20120614:
The "API" pointer has been eliminated.

Old method:
    bus->API->Peek16(bus,0);
New method:
    bus->Peek16(bus,0);

This makes it much easier to bind libtsctl to other languages such as
Python which support OOP out of the box.  For example:
       bus.Peek16(0)

