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.