paxCompiler for Delphi. Import unit IMPORT_Classes.pas.

unit IMPORT_Classes;
interface
uses
  Classes,
  PaxCompiler;

procedure Register_Classes;

implementation

// TList -----------------------------------------------------------------------

function TList_GetCapacity(Self: TList): Integer;
begin
  result := Self.Capacity;
end;

procedure TList_SetCapacity(Self: TList; Value: Integer);
begin
  Self.Capacity := Value;
end;

function TList_GetCount(Self: TList): Integer;
begin
  result := Self.Count;
end;

function TList_GetItem(Self: TList; I: Integer): Pointer;
begin
  result := Self.Items[I];
end;

procedure TList_SetItem(Self: TList; I: Integer; Value: Pointer);
begin
  Self.Items[I] := Value;
end;

function TList_GetList(Self: TList): PPointerList;
begin
  result := Self.List;
end;

// TBits -----------------------------------------------------------------------

function TBits_GetBit(Self: TBits; I: Integer): Boolean;
begin
  result := Self.Bits[I];
end;

procedure TBits_SetBit(Self: TBits; I: Integer; Value: Boolean);
begin
  Self.Bits[I] := Value;
end;

function TBits_GetSize(Self: TBits): Integer;
begin
  result := Self.Size;
end;

// TCollectionItem -------------------------------------------------------------

function TCollectionItem_GetCollection(Self: TCollectionItem): TCollection;
begin
  result := Self.Collection;
end;

procedure TCollectionItem_SetCollection(Self: TCollectionItem; Value: TCollection);
begin
  Self.Collection := Value;
end;

function TCollectionItem_GetID(Self: TCollectionItem): Integer;
begin
  result := Self.ID;
end;

function TCollectionItem_GetIndex(Self: TCollectionItem): Integer;
begin
  result := Self.Index;
end;

procedure TCollectionItem_SetIndex(Self: TCollectionItem; Value: Integer);
begin
  Self.Index := Value;
end;

function TCollectionItem_GetDisplayName(Self: TCollectionItem): String;
begin
  result := Self.DisplayName;
end;

procedure TCollectionItem_SetDisplayName(Self: TCollectionItem; const Value: String);
begin
  Self.DisplayName := Value;
end;

// TCollection -----------------------------------------------------------------

function TCollection_GetCount(Self: TCollection): Integer;
begin
  result := Self.Count;
end;

function TCollection_GetItemClass(Self: TCollection): TCollectionItemClass;
begin
  result := Self.ItemClass;
end;

function TCollection_GetItem(Self: TCollection; I: Integer): TCollectionItem;
begin
  result := Self.Items[I];
end;

procedure TCollection_SetItem(Self: TCollection; I: Integer; Value: TCollectionItem);
begin
  Self.Items[I] := Value;
end;

// TStrings --------------------------------------------------------------------

function TStrings_GetCapacity(Self: TStrings): Integer;
begin
  result := Self.Capacity;
end;

procedure TStrings_SetCapacity(Self: TStrings; Value: Integer);
begin
  Self.Capacity := Value;
end;

function TStrings_GetCommaText(Self: TStrings): String;
begin
  result := Self.CommaText;
end;

procedure TStrings_SetCommaText(Self: TStrings; const Value: String);
begin
  Self.CommaText := Value;
end;

function TStrings_GetCount(Self: TStrings): Integer;
begin
  result := Self.Count;
end;

function TStrings_GetName(Self: TStrings; I: Integer): String;
begin
  result := Self.Names[I];
end;

function TStrings_GetObject(Self: TStrings; I: Integer): TObject;
begin
  result := Self.Objects[I];
end;

procedure TStrings_SetObject(Self: TStrings; I: Integer; Value: TObject);
begin
  Self.Objects[I] := Value;
end;

function TStrings_GetValue(Self: TStrings; const I: String): String;
begin
  result := Self.Values[I];
end;

procedure TStrings_SetValue(Self: TStrings; const I: String; const Value: String);
begin
  Self.Values[I] := Value;
end;

function TStrings_GetString(Self: TStrings; I: Integer): String;
begin
  result := Self.Strings[I];
end;

procedure TStrings_SetString(Self: TStrings; I: Integer; const Value: String);
begin
  Self.Strings[I] := Value;
end;

function TStrings_GetText(Self: TStrings): String;
begin
  result := Self.Text;
end;

procedure TStrings_SetText(Self: TStrings; const Value: String);
begin
  Self.Text := Value;
end;

// TStringList -----------------------------------------------------------------

function TStringList_GetDuplicates(Self: TStringList): TDuplicates;
begin
  result := Self.Duplicates;
end;

procedure TStringList_SetDuplicates(Self: TStringList; Value: TDuplicates);
begin
  Self.Duplicates := Value;
end;

function TStringList_GetSorted(Self: TStringList): Boolean;
begin
  result := Self.Sorted;
end;

procedure TStringList_SetSorted(Self: TStringList; Value: Boolean);
begin
  Self.Sorted := Value;
end;

// TStream ---------------------------------------------------------------------

function TStream_GetPosition(Self: TStream): Integer;
begin
  result := Self.Position;
end;

procedure TStream_SetPosition(Self: TStream; Value: Integer);
begin
  Self.Position := Value;
end;

function TStream_GetSize(Self: TStream): Longint;
begin
  result := Self.Size;
end;

procedure TStream_SetSize(Self: TStream; Value: Longint);
begin
  Self.Size := Value;
end;

// TStream ---------------------------------------------------------------------

function THandleStream_GetHandle(Self: THandleStream): Integer;
begin
  result := Self.Handle;
end;

// TCustomMemoryStream ---------------------------------------------------------

function TCustomMemoryStream_GetMemory(Self: TCustomMemoryStream): Pointer;
begin
  result := Self.Memory;
end;

// TStringStream ---------------------------------------------------------------

function TStringStream_GetDataString(Self: TStringStream): String;
begin
  result := Self.DataString;
end;

// TParser ---------------------------------------------------------------------

function TParser_GetFloatType(Self: TParser): Char;
begin
  result := Self.FloatType;
end;

function TParser_GetSourceLine(Self: TParser): Integer;
begin
  result := Self.SourceLine;
end;

function TParser_GetToken(Self: TParser): Char;
begin
  result := Self.Token;
end;

// TComponent ------------------------------------------------------------------

function TComponent_GetComponent(Self: TComponent; I: Integer): TComponent;
begin
  result := Self.Components[I];
end;

function TComponent_GetComponentCount(Self: TComponent): Integer;
begin
  result := Self.ComponentCount;
end;

function TComponent_GetComponentIndex(Self: TComponent): Integer;
begin
  result := Self.ComponentIndex;
end;

procedure TComponent_SetComponentIndex(Self: TComponent; Value: Integer);
begin
  Self.ComponentIndex := Value;
end;

function TComponent_GetComponentState(Self: TComponent): TComponentState;
begin
  result := Self.ComponentState;
end;

function TComponent_GetComponentStyle(Self: TComponent): TComponentStyle;
begin
  result := Self.ComponentStyle;
end;

function TComponent_GetDesignInfo(Self: TComponent): Integer;
begin
  result := Self.DesignInfo;
end;

procedure TComponent_SetDesignInfo(Self: TComponent; Value: Integer);
begin
  Self.DesignInfo := Value;
end;

function TComponent_GetOwner(Self: TComponent): TComponent;
begin
  result := Self.Owner;
end;

//------------------------------------------------------------------------------

procedure Register_Classes;
var
  H, G: Integer;
begin
  RegisterTypeAlias(0, 'Longint', _typeINTEGER);

  H := RegisterNamespace(0, 'Classes');

{ Maximum TList size }

  RegisterConstant(H, 'MaxListSize', MaxListSize);

{ TStream seek origins }

  RegisterConstant(H, 'soFromBeginning', soFromBeginning);
  RegisterConstant(H, 'soFromCurrent', soFromCurrent);
  RegisterConstant(H, 'soFromEnd', soFromEnd);

{ TFileStream create mode }

  RegisterConstant(H, 'fmCreate', fmCreate);

{ TParser special tokens }

  RegisterConstant(H, 'toEOF', toEOF);
  RegisterConstant(H, 'toSymbol', toSymbol);
  RegisterConstant(H, 'toString', toString);
  RegisterConstant(H, 'toInteger', toInteger);
  RegisterConstant(H, 'toFloat', toFloat);
  RegisterConstant(H, 'toWString', toWString);

{ Text alignment types }

  RegisterRTTIType(H, TypeInfo(TAlignment));
  RegisterRTTIType(H, TypeInfo(TLeftRight));
  RegisterRTTIType(H, TypeInfo(TBiDiMode));

{ Types used by standard events }

  RegisterRTTIType(H, TypeInfo(TShiftState));
  RegisterRTTIType(H, TypeInfo(THelpContext));

{ Duplicate management }

  RegisterRTTIType(H, TypeInfo(TDuplicates));

  RegisterClassType(H, TComponent);
  RegisterClassType(H, TStream);
  RegisterClassType(H, TFiler);
  RegisterClassType(H, TReader);
  RegisterClassType(H, TWriter);

// TList -----------------------------------------------------------------------

  G := RegisterArrayType(H, 'TPointerList',
                            RegisterSubrangeType(H, '', _typeINTEGER, 0, MaxListSize - 1),
                            _typePOINTER);
  RegisterPointerType(H, 'PPointerList', G);

  G := RegisterHeader(H, 'function __TListSortCompare(Item1, Item2: Pointer): Integer;', nil);
  RegisterProceduralType(H, 'TListSortCompare', G);
  RegisterRTTIType(H, TypeInfo(TListNotification));

  G := RegisterClassType(H, TList);

  RegisterHeader(G, 'constructor Create;', @TList.Create);
  RegisterHeader(G, 'function Add(Item: Pointer): Integer;', @TList.Add);
  RegisterHeader(G, 'procedure Clear; virtual;', @TList.Clear);
  RegisterHeader(G, 'procedure Delete(Index: Integer);', @TList.Delete);
  RegisterHeader(G, 'procedure Exchange(Index1, Index2: Integer);', @TList.Exchange);
  RegisterHeader(G, 'function Expand: TList;', @TList.Expand);
  RegisterHeader(G, 'function Extract(Item: Pointer): Pointer;', @TList.Extract);
  RegisterHeader(G, 'function First: Pointer;', @TList.First);
  RegisterHeader(G, 'function IndexOf(Item: Pointer): Integer;', @TList.IndexOf);
  RegisterHeader(G, 'procedure Insert(Index: Integer; Item: Pointer);', @TList.Insert);
  RegisterHeader(G, 'function Last: Pointer;', @TList.Last);
  RegisterHeader(G, 'procedure Move(CurIndex, NewIndex: Integer);', @TList.Move);
  RegisterHeader(G, 'function Remove(Item: Pointer): Integer;', @TList.Remove);
  RegisterHeader(G, 'procedure Pack;', @TList.Pack);
  RegisterHeader(G, 'procedure Sort(Compare: TListSortCompare);', @TList.Sort);

  RegisterHeader(G, 'function _GetCapacity: Integer;', @TList_GetCapacity);
  RegisterHeader(G, 'procedure _SetCapacity(Value: Integer);', @TList_SetCapacity);
  RegisterProperty(G, 'property Capacity: Integer read _GetCapacity write _SetCapacity;');

  RegisterHeader(G, 'function _GetCount: Integer;', @TList_GetCount);
  RegisterProperty(G, 'property Count: Integer read _GetCount;');

  RegisterHeader(G, 'function _GetItem(I: Integer): Pointer;', @TList_GetItem);
  RegisterHeader(G, 'procedure _SetItem(I: Integer; Value: Pointer);', @TList_SetItem);
  RegisterProperty(G, 'property Items[Index: Integer]: Pointer read _GetItem write _SetItem; default;');

  RegisterHeader(G, 'function _GetList: PPointerList;', @TList_GetList);
  RegisterProperty(G, 'property List: PPointerList read _GetList;');

// TBits -----------------------------------------------------------------------

  G := RegisterClassType(H, TBits);
  RegisterHeader(G, 'constructor Create;', @TBits.Create);
  RegisterHeader(G, 'function OpenBit: Integer;', @TBits.OpenBit);

  RegisterHeader(G, 'function _GetBit(I: Integer): Boolean;', @TBits_GetBit);
  RegisterHeader(G, 'procedure _SetBit(I: Integer; Value: Boolean);', @TBits_SetBit);
  RegisterProperty(G, 'property Bits[Index: Integer]: Boolean read _GetBit write _SetBit; default;');

  RegisterHeader(G, 'function _GetSize: Integer;', @TBits_GetSize);
  RegisterProperty(G, 'property Size: Integer read _GetSize;');

// TPersistent -----------------------------------------------------------------

  G := RegisterClassType(H, TPersistent);
  RegisterClassReferenceType(H, 'TPersistentClass', G);

  RegisterHeader(G, 'constructor Create;', @TPersistent.Create);
  RegisterHeader(G, 'procedure Assign(Source: TPersistent); virtual;', @TPersistent.Assign);
  RegisterHeader(G, 'function  GetNamePath: string; dynamic;', @TPersistent.GetNamePath);

// TCollectionItem -------------------------------------------------------------

  RegisterClassType(H, TCollection);
  G := RegisterClassType(H, TCollectionItem);
  RegisterClassReferenceType(H, 'TCollectionItemClass', G);

  RegisterHeader(G, 'constructor Create(Collection: TCollection); virtual;', @TCollectionItem.Create);
  RegisterHeader(G, 'function GetNamePath: string; override;', @TCollectionItem.GetNamePath);

  RegisterHeader(G, 'function _GetCollection: TCollection;', @TCollectionItem_GetCollection);
  RegisterHeader(G, 'procedure _SetCollection(Value: TCollection);', @TCollectionItem_SetCollection);
  RegisterProperty(G, 'property Collection: TCollection read _GetCollection write _SetCollection;');

  RegisterHeader(G, 'function _GetID: Integer;', @TCollectionItem_GetID);
  RegisterProperty(G, 'property ID: Integer read _GetID;');

  RegisterHeader(G, 'function _GetIndex: Integer;', @TCollectionItem_GetIndex);
  RegisterHeader(G, 'procedure _SetIndex(Value: Integer);', @TCollectionItem_SetIndex);
  RegisterProperty(G, 'property Index: Integer read _GetIndex write _SetIndex;');

  RegisterHeader(G, 'function _GetDisplayName: String;', @TCollectionItem_GetDisplayName);
  RegisterHeader(G, 'procedure _SetDisplayName(const Value: String);', @TCollectionItem_SetDisplayName);
  RegisterProperty(G, 'property DisplayName: string read _GetDisplayName write _SetDisplayName;');

// TCollection -----------------------------------------------------------------

  G := RegisterClassType(H, TCollection);

  RegisterHeader(G, 'constructor Create(ItemClass: TCollectionItemClass);', @TCollection.Create);
  RegisterHeader(G, 'function Add: TCollectionItem;', @TCollection.Add);
  RegisterHeader(G, 'procedure Assign(Source: TPersistent); override;', @TCollection.Assign);
  RegisterHeader(G, 'procedure BeginUpdate; virtual;', @TCollection.BeginUpdate);
  RegisterHeader(G, 'procedure Clear;', @TCollection.Clear);
  RegisterHeader(G, 'procedure Delete(Index: Integer);',  @TCollection.Delete);
  RegisterHeader(G, 'procedure EndUpdate; virtual;',  @TCollection.EndUpdate);
  RegisterHeader(G, 'function FindItemID(ID: Integer): TCollectionItem;', @TCollection.FindItemId);
  RegisterHeader(G, 'function GetNamePath: string; override;',  @TCollection.GetNamePath);
  RegisterHeader(G, 'function Insert(Index: Integer): TCollectionItem;',  @TCollection.Insert);

  RegisterHeader(G, 'function _GetCount: Integer;', @TCollection_GetCount);
  RegisterProperty(G, 'property Count: Integer read _GetCount;');

  RegisterHeader(G, 'function _GetItemClass: TCollectionItemClass;',
                    @TCollection_GetItemClass);
  RegisterProperty(G, 'property ItemClass: TCollectionItemClass read _GetItemClass;');

  RegisterHeader(G, 'function _GetItem(I: Integer): TCollectionItem;', @TCollection_GetItem);
  RegisterHeader(G, 'procedure _SetItem(I: Integer; Value: TCollectionItem);', @TCollection_SetItem);
  RegisterProperty(G, 'property Items[Index: Integer]: TCollectionItem read _GetItem write _SetItem;');

// TStrings --------------------------------------------------------------------

  G := RegisterClassType(H, TStrings);

  RegisterHeader(G, 'constructor Create;', @TStrings.Create);
  RegisterHeader(G, 'function Add(const S: string): Integer; virtual;', @TStrings.Add);
  RegisterHeader(G, 'function AddObject(const S: string; AObject: TObject): Integer; virtual;', @TStrings.AddObject);
  RegisterHeader(G, 'procedure Append(const S: string);', @TStrings.Append);
  RegisterHeader(G, 'procedure AddStrings(Strings: TStrings); virtual;', @TStrings.AddStrings);
  RegisterHeader(G, 'procedure Assign(Source: TPersistent); override;', @TStrings.Assign);
  RegisterHeader(G, 'procedure BeginUpdate;', @TStrings.BeginUpdate);
  RegisterHeader(G, 'procedure Clear; virtual; abstract;', nil);
  RegisterHeader(G, 'procedure Delete(Index: Integer); virtual; abstract;', nil);
  RegisterHeader(G, 'procedure EndUpdate;', @TStrings.EndUpdate);
  RegisterHeader(G, 'function Equals(Strings: TStrings): Boolean;', @TStrings.Equals);
  RegisterHeader(G, 'procedure Exchange(Index1, Index2: Integer); virtual;', @TStrings.Exchange);
  RegisterHeader(G, 'function GetText: PChar; virtual;', @TStrings.GetText);
  RegisterHeader(G, 'function IndexOf(const S: string): Integer; virtual;', @TStrings.IndexOf);
  RegisterHeader(G, 'function IndexOfName(const Name: string): Integer;', @TStrings.IndexOfName);
  RegisterHeader(G, 'function IndexOfObject(AObject: TObject): Integer;', @TStrings.IndexOfObject);
  RegisterHeader(G, 'procedure Insert(Index: Integer; const S: string); virtual; abstract;', nil);
  RegisterHeader(G, 'procedure InsertObject(Index: Integer; const S: string; AObject: TObject);', @TStrings.InsertObject);
  RegisterHeader(G, 'procedure LoadFromFile(const FileName: string); virtual;', @TStrings.LoadFromFile);
  RegisterHeader(G, 'procedure LoadFromStream(Stream: TStream); virtual;', @TStrings.LoadFromStream);
  RegisterHeader(G, 'procedure Move(CurIndex, NewIndex: Integer); virtual;', @TStrings.Move);
  RegisterHeader(G, 'procedure SaveToFile(const FileName: string); virtual;', @TStrings.SaveToFile);
  RegisterHeader(G, 'procedure SaveToStream(Stream: TStream); virtual;', @TStrings.SaveToStream);
  RegisterHeader(G, 'procedure SetText(Text: PChar); virtual;', @TStrings.SetText);

  RegisterHeader(G, 'function _GetCapacity: Integer;', @TStrings_GetCapacity);
  RegisterHeader(G, 'procedure _SetCapacity(Value: Integer);', @TStrings_SetCapacity);
  RegisterProperty(G, 'property Capacity: Integer read _GetCapacity write _SetCapacity;');

  RegisterHeader(G, 'function _GetCommaText: String;', @TStrings_GetCommaText);
  RegisterHeader(G, 'procedure _SetCommaText(const Value: String);', @TStrings_SetCommaText);
  RegisterProperty(G, 'property CommaText: string read _GetCommaText write _SetCommaText;');

  RegisterHeader(G, 'function _GetCount: Integer;', @TStrings_GetCount);
  RegisterProperty(G, 'property Count: Integer read _GetCount;');

  RegisterHeader(G, 'function _GetName(I: Integer): String;', @TStrings_GetName);
  RegisterProperty(G, 'property Names[Index: Integer]: string read _GetName;');

  RegisterHeader(G, 'function _GetObject(I: Integer): TObject;', @TStrings_GetObject);
  RegisterHeader(G, 'procedure _SetObject(I: Integer; Value: TObject);', @TStrings_SetObject);
  RegisterProperty(G, 'property Objects[Index: Integer]: TObject read _GetObject write _SetObject;');

  RegisterHeader(G, 'function _GetValue(const I: String): String;', @TStrings_GetValue);
  RegisterHeader(G, 'procedure _SetValue(const I: String; const Value: String);', @TStrings_GetValue);
  RegisterProperty(G, 'property Values[const Name: string]: string read _GetValue write _SetValue;');

  RegisterHeader(G, 'function _GetString(I: Integer): String;', @TStrings_GetString);
  RegisterHeader(G, 'procedure _SetString(I: Integer; const Value: String);', @TStrings_SetString);
  RegisterProperty(G, 'property Strings[Index: Integer]: string read _GetString write _SetString; default;');

  RegisterHeader(G, 'function _GetText: String;', @TStrings_GetText);
  RegisterHeader(G, 'procedure _SetText(const Value: String);', @TStrings_SetText);
  RegisterProperty(G, 'property Text: string read _GetText write _SetText;');

// TStringList -----------------------------------------------------------------

  G := RegisterClassType(H, TStringList);
  RegisterProceduralType(H, 'TStringListSortCompare',  RegisterHeader(H, 'function __TStringListSortCompare(List: TStringList; Index1, Index2: Integer): Integer;', nil));

  RegisterHeader(G, 'constructor Create;', @TStringList.Create);
  RegisterHeader(G, 'function Add(const S: string): Integer; override;', @TStringList.Add);
  RegisterHeader(G, 'procedure Clear; override;', @TStringList.Clear);
  RegisterHeader(G, 'procedure Delete(Index: Integer); override;', @TStringList.Delete);
  RegisterHeader(G, 'procedure Exchange(Index1, Index2: Integer); override;', @TStringList.Exchange);
  RegisterHeader(G, 'function Find(const S: string; var Index: Integer): Boolean; virtual;', @TStringList.Find);
  RegisterHeader(G, 'function IndexOf(const S: string): Integer; override;', @TStringList.IndexOf);
  RegisterHeader(G, 'procedure Insert(Index: Integer; const S: string); override;', @TStringList.Insert);
  RegisterHeader(G, 'procedure Sort; virtual;', @TStringList.Sort);
  RegisterHeader(G, 'procedure CustomSort(Compare: TStringListSortCompare); virtual;', @TStringList.CustomSort);

  RegisterHeader(G, 'function _GetDuplicates: TDuplicates;', @TStringList_GetDuplicates);
  RegisterHeader(G, 'procedure _SetDuplicates(Value: TDuplicates);', @TStringList_SetDuplicates);
  RegisterProperty(G, 'property Duplicates: TDuplicates read _GetDuplicates write _SetDuplicates;');

  RegisterHeader(G, 'function _GetSorted: Boolean;', @TStringList_GetSorted);
  RegisterHeader(G, 'procedure _SetSorted(Value: Boolean);', @TStringList_SetSorted);
  RegisterProperty(G, 'property Sorted: Boolean read _GetSorted write _SetSorted;');

// TStream ---------------------------------------------------------------------

  G := RegisterClassType(H, TStream);

  RegisterHeader(G, 'constructor Create;', @TStream.Create);
  RegisterHeader(G, 'function Read(var Buffer; Count: Longint): Longint; virtual; abstract;', nil);
  RegisterHeader(G, 'function Write(const Buffer; Count: Longint): Longint; virtual; abstract;', nil);
  RegisterHeader(G, 'function Seek(Offset: Longint; Origin: Word): Longint; virtual; abstract;', nil);
  RegisterHeader(G, 'procedure ReadBuffer(var Buffer; Count: Longint);', @TStream.ReadBuffer);
  RegisterHeader(G, 'procedure WriteBuffer(const Buffer; Count: Longint);', @TStream.WriteBuffer);
  RegisterHeader(G, 'function CopyFrom(Source: TStream; Count: Longint): Longint;', @TStream.CopyFrom);
  RegisterHeader(G, 'function ReadComponent(Instance: TComponent): TComponent;', @TStream.ReadComponent);
  RegisterHeader(G, 'function ReadComponentRes(Instance: TComponent): TComponent;', @TStream.ReadComponentRes);
  RegisterHeader(G, 'procedure WriteComponent(Instance: TComponent);', @TStream.WriteComponent);
  RegisterHeader(G, 'procedure WriteResourceHeader(const ResName: string; out FixupInfo: Integer);', @TStream.WriteResourceHeader);
  RegisterHeader(G, 'procedure FixupResourceHeader(FixupInfo: Integer);', @TStream.FixupResourceHeader);
  RegisterHeader(G, 'procedure ReadResHeader;', @TStream.ReadResHeader);

  RegisterHeader(G, 'function _GetPosition: Integer;', @TStream_GetPosition);
  RegisterHeader(G, 'procedure _SetPosition(Value: Integer);', @TStream_SetPosition);
  RegisterProperty(G, 'property Position: Longint read _GetPosition write _SetPosition;');

  RegisterHeader(G, 'function _GetSize: Longint;', @TStream_GetSize);
  RegisterHeader(G, 'procedure _SetSize(Value: Longint);', @TStream_SetSize);
  RegisterProperty(G, 'property Size: Longint read _GetSize write _SetSize;');

// THandleStream ---------------------------------------------------------------

  G := RegisterClassType(H, THandleStream);

  RegisterHeader(G, 'constructor Create(AHandle: Integer);', @THandleStream.Create);
  RegisterHeader(G, 'function Read(var Buffer; Count: Longint): Longint; override;', @THandleStream.Read);
  RegisterHeader(G, 'function Write(const Buffer; Count: Longint): Longint; override;', @THandleStream.Write);
  RegisterHeader(G, 'function Seek(Offset: Longint; Origin: Word): Longint; override;', @THandleStream.Seek);

  RegisterHeader(G, 'function _GetHandle: Integer;', @THandleStream_GetHandle);
  RegisterProperty(G, 'property Handle: Integer read _GetHandle;');

// TFileStream -----------------------------------------------------------------

  G := RegisterClassType(H, TFileStream);

  RegisterHeader(G, 'constructor Create(const FileName: string; Mode: Word);', @TFileStream.Create);

// TCustomMemoryStream ---------------------------------------------------------

  G := RegisterClassType(H, TCustomMemoryStream);

  RegisterHeader(G, 'constructor Create;', @TCustomMemoryStream.Create);
  RegisterHeader(G, 'function Read(var Buffer; Count: Longint): Longint; override;', @TCustomMemoryStream.Read);
  RegisterHeader(G, 'function Seek(Offset: Longint; Origin: Word): Longint; override;', @TCustomMemoryStream.Seek);
  RegisterHeader(G, 'procedure SaveToStream(Stream: TStream);', @TCustomMemoryStream.SaveToStream);
  RegisterHeader(G, 'procedure SaveToFile(const FileName: string);', @TCustomMemoryStream.SaveToFile);

  RegisterHeader(G, 'function _GetMemory: Pointer;', @TCustomMemoryStream_GetMemory);
  RegisterProperty(G, 'property Memory: Pointer read _GetMemory;');

// TMemoryStream ---------------------------------------------------------------

  G := RegisterClassType(H, TMemoryStream);

  RegisterHeader(G, 'constructor Create;', @TMemoryStream.Create);
  RegisterHeader(G, 'procedure Clear;', @TMemoryStream.Clear);
  RegisterHeader(G, 'procedure LoadFromStream(Stream: TStream);', @TMemoryStream.LoadFromStream);
  RegisterHeader(G, 'procedure LoadFromFile(const FileName: string);', @TMemoryStream.LoadFromFile);
  RegisterHeader(G, 'procedure SetSize(NewSize: Longint); override;', @TMemoryStream.SetSize);
  RegisterHeader(G, 'function Write(const Buffer; Count: Longint): Longint; override;', @TMemoryStream.Write);

// TStringStream ---------------------------------------------------------------

  G := RegisterClassType(H, TStringStream);

  RegisterHeader(G, 'constructor Create(const AString: string);', @TStringStream.Create);
  RegisterHeader(G, 'function Read(var Buffer; Count: Longint): Longint; override;', @TStringStream.Read);
  RegisterHeader(G, 'function ReadString(Count: Longint): string;', @TStringStream.ReadString);
  RegisterHeader(G, 'function Seek(Offset: Longint; Origin: Word): Longint; override;', @TStringStream.Seek);
  RegisterHeader(G, 'function Write(const Buffer; Count: Longint): Longint; override;', @TStringStream.Write);
  RegisterHeader(G, 'procedure WriteString(const AString: string);', @TStringStream.WriteString);

  RegisterHeader(G, 'function _GetDataString: String;', @TStringStream_GetDataString);
  RegisterProperty(G, 'property DataString: string read _GetDataString;');

// TResourceStream -------------------------------------------------------------

  G := RegisterClassType(H, TResourceStream);

  RegisterTypeAlias(0, 'THandle', _typeINTEGER);

  RegisterHeader(G, 'constructor Create(Instance: THandle; const ResName: string; ResType: PChar);', @TResourceStream.Create);
  RegisterHeader(G, 'constructor CreateFromID(Instance: THandle; ResID: Integer; ResType: PChar);', @TResourceStream.CreateFromID);
  RegisterHeader(G, 'function Write(const Buffer; Count: Longint): Longint; override;', @TResourceStream.Write);

// TParser ---------------------------------------------------------------------

  G := RegisterClassType(H, TParser);

  RegisterHeader(G, 'constructor Create(Stream: TStream);', @TParser.Create);
  RegisterHeader(G, 'procedure CheckToken(T: Char);', @TParser.CheckToken);
  RegisterHeader(G, 'procedure CheckTokenSymbol(const S: string);', @TParser.CheckTokenSymbol);
  RegisterHeader(G, 'procedure Error(const Ident: string);', @TParser.Error);
  RegisterHeader(G, 'procedure ErrorStr(const Message: string);', @TParser.ErrorStr);
  RegisterHeader(G, 'procedure HexToBinary(Stream: TStream);', @TParser.HexToBinary);
  RegisterHeader(G, 'function NextToken: Char;', @TParser.NextToken);
  RegisterHeader(G, 'function SourcePos: Longint;', @TParser.SourcePos);
  RegisterHeader(G, 'function TokenComponentIdent: string;', @TParser.TokenComponentIdent);
  RegisterHeader(G, 'function TokenFloat: Extended;', @TParser.TokenFloat);
  RegisterHeader(G, 'function TokenString: string;', @TParser.TokenString);
  RegisterHeader(G, 'function TokenSymbolIs(const S: string): Boolean;', @TParser.TokenSymbolIs);

  RegisterHeader(G, 'function _GetFloatType: Char;', @TParser_GetFloatType);
  RegisterProperty(G, 'property FloatType: Char read _GetFloatType;');

  RegisterHeader(G, 'function _GetSourceLine: Integer;', @TParser_GetSourceLine);
  RegisterProperty(G, 'property SourceLine: Integer read _GetSourceLine;');

  RegisterHeader(G, 'function _GetToken: Char;', @TParser_GetToken);
  RegisterProperty(G, 'property Token: Char read _GetToken;');

// TComponent ------------------------------------------------------------------

  RegisterClassType(H, TBasicAction);
  RegisterRTTIType(H, TypeInfo(TComponentState));
  RegisterRTTIType(H, TypeInfo(TComponentStyle));
  RegisterTypeAlias(0, 'HRESULT', _typeINTEGER);

  G := RegisterClassType(H, TComponent);

  RegisterHeader(G, 'constructor Create(AOwner: TComponent); virtual;', @TComponent.Create);
  RegisterHeader(G, 'procedure BeforeDestruction; override;', @TComponent.BeforeDestruction);
  RegisterHeader(G, 'procedure DestroyComponents;', @TComponent.DestroyComponents);
  RegisterHeader(G, 'procedure Destroying;', @TComponent.Destroying);
  RegisterHeader(G, 'function ExecuteAction(Action: TBasicAction): Boolean; dynamic;', @TComponent.ExecuteAction);
  RegisterHeader(G, 'function FindComponent(const AName: string): TComponent;', @TComponent.FindComponent);
  RegisterHeader(G, 'procedure FreeNotification(AComponent: TComponent);', @TComponent.FreeNotification);
  RegisterHeader(G, 'procedure RemoveFreeNotification(AComponent: TComponent);', @TComponent.RemoveFreeNotification);
  RegisterHeader(G, 'procedure FreeOnRelease;', @TComponent.FreeOnRelease);
  RegisterHeader(G, 'function GetParentComponent: TComponent; dynamic;', @TComponent.GetParentComponent);
  RegisterHeader(G, 'function GetNamePath: string; override;', @TComponent.GetNamePath);
  RegisterHeader(G, 'function HasParent: Boolean; dynamic;', @TComponent.HasParent);
  RegisterHeader(G, 'procedure InsertComponent(AComponent: TComponent);', @TComponent.InsertComponent);
  RegisterHeader(G, 'procedure RemoveComponent(AComponent: TComponent);', @TComponent.RemoveComponent);
  RegisterHeader(G, 'function SafeCallException(ExceptObject: TObject; ExceptAddr: Pointer): HResult; override;', @TComponent.SafeCallException);
  RegisterHeader(G, 'function UpdateAction(Action: TBasicAction): Boolean; dynamic;', @TComponent.UpdateAction);

  RegisterHeader(G, 'function _GetComponent(I: Integer): TComponent;', @TComponent_GetComponent);
  RegisterProperty(G, 'property Components[Index: Integer]: TComponent read _GetComponent;');

  RegisterHeader(G, 'function _GetComponentCount: Integer;', @TComponent_GetComponentCount);
  RegisterProperty(G, 'property ComponentCount: Integer read _GetComponentCount;');

  RegisterHeader(G, 'function _GetComponentIndex: Integer;', @TComponent_GetComponentIndex);
  RegisterHeader(G, 'procedure _SetComponentIndex(Value: Integer);', @TComponent_SetComponentIndex);
  RegisterProperty(G, 'property ComponentIndex: Integer read _GetComponentIndex write _SetComponentIndex;');

  RegisterHeader(G, 'function _GetComponentState: TComponentState;', @TComponent_GetComponentState);
  RegisterProperty(G, 'property ComponentState: TComponentState read _GetComponentState;');

  RegisterHeader(G, 'function _GetComponentStyle: TComponentStyle;', @TComponent_GetComponentStyle);
  RegisterProperty(G, 'property ComponentStyle: TComponentStyle read _GetComponentStyle;');

  RegisterHeader(G, 'function _GetDesignInfo: Integer;', @TComponent_GetDesignInfo);
  RegisterHeader(G, 'procedure _SetDesignInfo(Value: Integer);', @TComponent_SetDesignInfo);
  RegisterProperty(G, 'property DesignInfo: Longint read _GetDesignInfo write _SetDesignInfo;');

  RegisterHeader(G, 'function _GetOwner: TComponent;', @TComponent_GetOwner);
  RegisterProperty(G, 'property Owner: TComponent read _GetOwner;');

{ Point and rectangle constructors }

  RegisterHeader(H, 'function Point(AX, AY: Integer): TPoint;', @Point);
  RegisterHeader(H, 'function Rect(ALeft, ATop, ARight, ABottom: Integer): TRect;', @Rect);
  RegisterHeader(H, 'function Bounds(ALeft, ATop, AWidth, AHeight: Integer): TRect;', @Bounds);

{ Class registration routines }

  RegisterHeader(H, 'procedure RegisterClass(AClass: TPersistentClass);', @RegisterClass);
  RegisterHeader(H, 'procedure UnRegisterClass(AClass: TPersistentClass);', @UnRegisterClass);
  RegisterHeader(H, 'function FindClass(const ClassName: string): TPersistentClass;', @FindClass);
  RegisterHeader(H, 'function GetClass(const AClassName: string): TPersistentClass;', @GetClass);
end;

initialization

Register_Classes;

end.