Main Program
------------

CodeGenerator: Static class. Contains Main
GenerationInfo: Stores info passed in on the command line, such as the
                assembly name and glue library name. Passed to
                IGeneratable.Generate().
Parser: Reads the foo-api.xml file and creates IGeneratable objects
Statistics: Static class. Used by other classes to keep statistics on
            generated classes
SymbolTable: Static class. Keeps track of the type hierarchy and the
             mappings between C types and IGeneratable classes


IGeneratables
-------------
The IGeneratable interface is implemented by all classes that
represent types.

GenBase: Abstract base class for any api.xml element that will have
         its own generated .cs file
    CallbackGen: Handles <callback> elements by creating a public
                 delegate type for the public API (in NAME.cs), and an
                 internal type that wraps that delegate, to be passed
                 as the actual unmanaged callback (in
                 NAMESPACESharp.NAMENative.cs)
    ClassBase: Abstract base class for types that will be converted
               to C# classes, structs, or interfaces
        ClassGen: Handles <class> elements (static classes)
        InterfaceGen: Handles <interface> elements
        ObjectGen: Handles <object> elements
        OpaqueGen: Handles <boxed> and <struct> elements with the
                   "opaque" flag (by creating C# classes)
        StructBase: Abstract base class for types that will be
                    translated to C# structs.
            BoxedGen: Handles non-opaque <boxed> elements
            StructGen: Handles non-opaque <struct> elements
    EnumGen: Handles <enum> elements.

The remaining IGeneratable classes don't generate output files
themselves, they are just used to generate references to their
corresponding types in method signatures and the like.

ByRefGen: Handles struct types that must be passed into C code by
          reference (at the moment, only GValue/GLib.Value)
CustomMarshalerGen: Handles types that need custom marshalling.
                    (Currently unused?)
GStringGen: Handles conversion between GString and System.String
ManualGen: Handles types that must be manually marshalled between
           managed and unmanaged code (by handwritten classes such
           as GLib.List)
    GObjectGen: Handles GObjects
SimpleGen: Handles types that can be simply converted from an
           unmanaged type to a managed type (usually IntPtr)
    ConstStringGen: Handles conversion between "const char *" and
                    System.String
        StringGen: Handles conversion between non-const "char *" and
                   System.String
TimeTGen: Handles conversion between time_t and System.DateTime

AliasGen: Handles <alias> elements. "Generates" type aliases by
          ignoring them (eg, outputting "Gdk.Rectangle" wherever the
          API calls for a GtkAllocation).


Other code-generating classes used by IGeneratables
---------------------------------------------------

Ctor: Handles <constructor> elements
Field: Handle <field> elements (only used by StructBase, not
       ClassBase)
Method: Handle <method> elements
Property: Handles <property> elements
    ChildProperty: Handles <childprop> elements
Signal: Handles <signal> elements

ImportSignature: Represents a signature for an unmanaged method
ManagedCallString: Represents a call to a managed method from a
                   method that has unmanaged data
MethodBody: shared by Ctor and Method
Parameter: Represents the parameters to a method
SignalHandler: Used by Signal. Like CallbackGen, this creates an
               internal type to wrap a signal-handler delegate.
Signature: Represents the signature of a method
VMSignature: Used by Signal. Represents the signature of a virtual
             method.