GtkSharp/generator/DESIGN
Dan Winship bf07e92f42 * generator/DESIGN: Document what the different classes do
svn path=/trunk/gtk-sharp/; revision=36140
2004-11-15 16:00:08 +00:00

87 lines
3.8 KiB
Plaintext

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.