hp/befpc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TNames -> BNames and other minor changes.

Browse Source
This commit is contained in:
oscarl-2
2003-12-20 03:18:05 +00:00
parent 337fbe9499
commit 199a50758f
4 changed files with 280 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
bepascal/source/bepascal/pas/src/be/support/bstring.pp
View File

@@ -1,5 +1,6 @@
{ BePascal - A pascal wrapper around the BeOS API { BePascal - A pascal wrapper around the BeOS API
Copyright (C) 2002 Eric Jourde Copyright (C) 2002 - 2003 Eric Jourde
Oscar Lesta
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public modify it under the terms of the GNU Library General Public
@@ -15,19 +16,17 @@
License along with this library; if not, write to the Free License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
} }
unit BString; unit BString;
interface interface
uses uses
beobj, SupportDefs, os; BeObj, SupportDefs, OS;
type type
TString = class(TBeObject) BString = class(TBeObject)
private
public public
constructor Create; override; constructor Create; override;
// constructor Create(value : PChar); override; // constructor Create(value : PChar); override;
destructor Destroy; override; destructor Destroy; override;
@@ -36,29 +35,36 @@ type
function String_pchar : PChar; function String_pchar : PChar;
// Affectation // Affectation
procedure SetTo(value:PChar; lenght : cardinal); procedure SetTo(value : PChar; lenght : cardinal);
procedure SetTo( from: TString); procedure SetTo(from : TString);
procedure SetTo( value:TString; length1: cardinal); procedure SetTo(value : TString; length1 : cardinal);
procedure Adopt( from:TString); procedure Adopt(from : TString);
end; end;
function BString_Create(AObject : TBeObject) : TCPlusObject;
cdecl; external BePascalLibName name 'BString_Create';
function BString_Create(AObject : TBeObject; value : PChar) : TCPlusObject;
cdecl; external BePascalLibName name 'BString_Create_1';
procedure BString_Free(AObject : TCPlusObject);
cdecl; external BePascalLibName name 'BString_Free';
function BString_CountChars(AObject : TCPlusObject) : cardinal;
cdecl; external BePascalLibName name 'BString_CountChars';
function BString_Length(AObject : TCPlusObject) : cardinal;
cdecl; external BePascalLibName name 'BString_Length';
function BString_String(AObject : TCPlusObject) : Pchar;
cdecl; external BePascalLibName name 'BString_String';
function BString_Create(AObject : TBeObject):TCPlusObject; cdecl; external BePascalLibName name 'BString_Create'; procedure BString_SetTo(AObject : TCPlusObject; value : Pchar; length : cardinal);
function BString_Create(AObject : TBeObject;value : PChar):TCPlusObject; cdecl; external BePascalLibName name 'BString_Create_1'; cdecl; external BePascalLibName name 'BString_SetTo';
procedure BString_Free(AObject : TCPlusObject);cdecl; external BePascalLibName name 'BString_Free'; procedure BString_SetTo_1(AObject : TCPlusObject; from : TBeObject);
function BString_CountChars(AObject : TCPlusObject): cardinal;cdecl; external BePascalLibName name 'BString_CountChars'; cdecl; external BePascalLibName name 'BString_SetTo_1';
function BString_Length(AObject : TCPlusObject): cardinal;cdecl; external BePascalLibName name 'BString_Length'; procedure BString_SetTo_2(AObject : TCPlusObject; value : TBeObject; length : cardinal);
function BString_String(AObject : TCPlusObject): Pchar;cdecl; external BePascalLibName name 'BString_String'; cdecl; external BePascalLibName name 'BString_SetTo_2';
procedure BString_SetTo(AObject : TCPlusObject;value:Pchar;length:cardinal);cdecl; external BePascalLibName name 'BString_SetTo';
procedure BString_SetTo_1(AObject : TCPlusObject; from: TBeObject);cdecl; external BePascalLibName name 'BString_SetTo_1';
procedure BString_SetTo_2(AObject : TCPlusObject; value:TBeObject;length: cardinal);cdecl; external BePascalLibName name 'BString_SetTo_2';
procedure BString_Adopt(AObject : TCPlusObject; from:TBeObject);cdecl; external BePascalLibName name 'BString_Adopt';
procedure BString_Adopt(AObject : TCPlusObject; from : TBeObject);
cdecl; external BePascalLibName name 'BString_Adopt';
{ {
BString & BString &
BString_Adopt_1(BString *String, BString &from, BString_Adopt_1(BString *String, BString &from,
int32 length) int32 length)
@@ -71,14 +77,14 @@ BString_SetTo_3(BString *String, char value,
BString & BString &
BString_CopyInto(BString *String, BString &into, BString_CopyInto(BString *String, BString &into,
int32 fromOffset, int32 fromOffset,
int32 length) int32 length)
void void
BString_CopyInto_1 BString_CopyInto_1
(BString *String, char *into, (BString *String, char *into,
int32 fromOffset, int32 fromOffset,
int32 length) int32 length)
BString & BString &
@@ -200,124 +206,124 @@ BString_MoveInto_1
int32 length) int32 length)
int int
BString_Compare(BString *String, const BString &value) BString_Compare(BString *String, const BString &value)
int int
BString_Compare_1 BString_Compare_1
(BString *String, const char *value) (BString *String, const char *value)
int int
BString_Compare_2 BString_Compare_2
(BString *String, const BString &value, (BString *String, const BString &value,
int32 n) int32 n)
int int
BString_Compare_3 BString_Compare_3
(BString *String, const char *value, (BString *String, const char *value,
int32 n) int32 n)
int int
BString_ICompare(BString *String, const BString &value) BString_ICompare(BString *String, const BString &value)
int int
BString_ICompare_1 BString_ICompare_1
(BString *String, const char *value) (BString *String, const char *value)
int int
BString_ICompare_2 BString_ICompare_2
(BString *String, const BString &value, (BString *String, const BString &value,
int32 n) int32 n)
int int
BString_ICompare_3 BString_ICompare_3
(BString *String, const char *value, (BString *String, const char *value,
int32 n) int32 n)
int32 int32
BString_FindFirst(BString *String, const BString &value) BString_FindFirst(BString *String, const BString &value)
int32 int32
BString_FindFirst_1 BString_FindFirst_1
(BString *String, const char *value) (BString *String, const char *value)
int32 int32
BString_FindFirst_2 BString_FindFirst_2
(BString *String, const BString &value, (BString *String, const BString &value,
int32 fromOffset) int32 fromOffset)
int32 int32
BString_FindFirst_3 BString_FindFirst_3
(BString *String, const char *value, (BString *String, const char *value,
int32 fromOffset) int32 fromOffset)
int32 int32
BString_FindFirst_4 BString_FindFirst_4
(BString *String, char value) (BString *String, char value)
int32 int32
BString_FindFirst_5 BString_FindFirst_5
(BString *String, char value, (BString *String, char value,
int32 fromOffset) int32 fromOffset)
int32 int32
BString_FindLast(BString *String, const BString &value) BString_FindLast(BString *String, const BString &value)
int32 int32
BString_FindLast_1 BString_FindLast_1
(BString *String, const char *value) (BString *String, const char *value)
int32 int32
BString_FindLast_2 BString_FindLast_2
(BString *String, const BString &value, (BString *String, const BString &value,
int32 beforeOffset) int32 beforeOffset)
int32 int32
BString_FindLast_3 BString_FindLast_3
(BString *String, const char *value, (BString *String, const char *value,
int32 beforeOffset) int32 beforeOffset)
int32 int32
BString_FindLast_4 BString_FindLast_4
(BString *String, char value) (BString *String, char value)
int32 int32
BString_FindLast_5 BString_FindLast_5
(BString *String, char value, (BString *String, char value,
int32 fromOffset) int32 fromOffset)
int32 int32
BString_IFindFirst(BString *String, const BString &value) BString_IFindFirst(BString *String, const BString &value)
int32 int32
BString_IFindFirst_1 BString_IFindFirst_1
(BString *String, const char *value) (BString *String, const char *value)
int32 int32
BString_IFindFirst_2 BString_IFindFirst_2
(BString *String, const BString &value, (BString *String, const BString &value,
int32 fromOffset) int32 fromOffset)
int32 int32
BString_IFindFirst_3 BString_IFindFirst_3
(BString *String, const char *value, (BString *String, const char *value,
int32 fromOffset) int32 fromOffset)
int32 int32
BString_IFindLast(BString *String, const BString &value) BString_IFindLast(BString *String, const BString &value)
int32 int32
BString_IFindLast_1 BString_IFindLast_1
(BString *String, const char *value) (BString *String, const char *value)
int32 int32
BString_IFindLast_2 BString_IFindLast_2
(BString *String, const BString &value, (BString *String, const BString &value,
int32 beforeOffset) int32 beforeOffset)
int32 int32
BString_IFindLast_3 BString_IFindLast_3
(BString *String, const char *value, (BString *String, const char *value,
int32 beforeOffset) int32 beforeOffset)
BString & BString &
BString_ReplaceFirst(BString *String, char replaceThis, BString_ReplaceFirst(BString *String, char replaceThis,
@@ -442,69 +448,64 @@ BString_CharacterDeescape(BString *String, const char *original,
BString & BString &
BString_CharacterDeescape_1 BString_CharacterDeescape_1
(BString *String, char escapeChar) (BString *String, char escapeChar)
} }
implementation implementation
constructor BString.Create;
constructor TString.Create;
begin begin
inherited; inherited;
CPlusObject := BString_Create(Self); CPlusObject := BString_Create(Self);
end; end;
{constructor TString.Create_1(value:PChar); {
constructor BString.Create_1(value:PChar);
begin begin
inherited; inherited;
CPlusObject := BString_Create_1(Self,value); CPlusObject := BString_Create_1(Self, value);
end; end;
} }
destructor TString.Destroy;
destructor BString.Destroy;
begin begin
if CPlusObject <> nil then if CPlusObject <> nil then
BString_Free(CPlusObject); BString_Free(CPlusObject);
inherited; inherited;
end; end;
function TString.CountChars : integer; function BString.CountChars : integer;
begin begin
result:=BString_CountChars(CPlusObject); Result := BString_CountChars(CPlusObject);
end; end;
function TString.length : integer; function BString.length : integer;
begin begin
result:=BString_Length(CPlusObject); Result := BString_Length(CPlusObject);
end; end;
function TString.String_pchar : PChar; function BString.String_pchar : PChar;
begin begin
result:=BString_String(CPlusObject); Result := BString_String(CPlusObject);
end; end;
procedure TString.SetTo(value:PChar; lenght : cardinal); procedure BString.SetTo(value : PChar; lenght : cardinal);
begin begin
BString_SetTo(CPlusObject,value,lenght); BString_SetTo(CPlusObject,value,lenght);
end; end;
procedure BString.SetTo(from : TString);
procedure TString.SetTo( from: TString);
begin begin
BString_SetTo_1(CPlusObject, from); BString_SetTo_1(CPlusObject, from);
end; end;
procedure TString.SetTo( value:TString;length1: cardinal); procedure BString.SetTo( value : TString; length1 : cardinal);
begin begin
BString_SetTo_2(CPlusObject, value,length1); BString_SetTo_2(CPlusObject, value, length1);
end; end;
procedure TString.Adopt( from:TString); procedure BString.Adopt(from : TString);
begin begin
BString_Adopt(CPlusObject, from); BString_Adopt(CPlusObject, from);
end; end;
end. end.

260
bepascal/source/bepascal/pas/src/be/support/dataio.pp
View File

@@ -1,36 +1,36 @@
{ BePascal - A pascal wrapper around the BeOS API { BePascal - A pascal wrapper around the BeOS API
Copyright (C) 2002 Olivier Coursiere Copyright (C) 2002 - 2003 Olivier Coursiere
Eric Jourde Eric Jourde
Oscar Lesta
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public This library is free software; you can redistribute it and/or
License as published by the Free Software Foundation; either modify it under the terms of the GNU Library General Public
version 2 of the License, or (at your option) any later version. License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of This library is distributed in the hope that it will be useful,
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU but WITHOUT ANY WARRANTY; without even the implied warranty of
Library General Public License for more details. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free You should have received a copy of the GNU Library General Public
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA License along with this library; if not, write to the Free
} Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
unit dataio; }
unit DataIO;
interface interface
uses uses
beobj, supportdefs; BeObj, SupportDefs;
type type
BDataIO = class(TBeObject) BDataIO = class(TBeObject)
private
public public
constructor Create; override; constructor Create; override;
destructor Destroy; override; destructor Destroy; override;
function Read(buffer : Pointer; size : Size_t) : SSize_t; virtual; abstract; function Read(buffer : Pointer; size : size_t) : ssize_t; virtual; abstract;
function Write(buffer : Pointer; size : Size_t) : SSize_t; virtual; abstract; function Write(buffer : Pointer; size : size_t) : ssize_t; virtual; abstract;
{ procedure _ReservedDataIO1; { procedure _ReservedDataIO1;
procedure _ReservedDataIO2; procedure _ReservedDataIO2;
procedure _ReservedDataIO3; procedure _ReservedDataIO3;
@@ -48,19 +48,18 @@ type
// function operator=( : BDataIO) : BDataIO; // function operator=( : BDataIO) : BDataIO;
// procedure int32 _reserved[2]; // procedure int32 _reserved[2];
end; end;
type
TPositionIO = class(BDataIO) BPositionIO = class(BDataIO)
private
public public
constructor Create; override; constructor Create; override;
destructor Destroy; override; destructor Destroy; override;
// function Read(buffer : Pointer; size : Size_t) : SSize_t; override; // function Read(buffer : Pointer; size : size_t) : ssize_t; override;
// function Write(buffer : Pointer; size : Size_t) : SSize_t; override; // function Write(buffer : Pointer; size : size_t) : ssize_t; override;
function ReadAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; virtual; abstract; function ReadAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t; virtual; abstract;
function WriteAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; virtual; abstract; function WriteAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t; virtual; abstract;
function Seek(aposition : off_t; seek_mode : Cardinal) : off_t; virtual; abstract; function Seek(aposition : off_t; seek_mode : Cardinal) : off_t; virtual; abstract;
// function Position : off_t; virtual; // function Position : off_t; virtual;
function SetSize(size : off_t) : Status_t; virtual; function SetSize(size : off_t) : status_t; virtual;
{ procedure _ReservedPositionIO1; { procedure _ReservedPositionIO1;
procedure _ReservedPositionIO2; procedure _ReservedPositionIO2;
procedure _ReservedPositionIO3; procedure _ReservedPositionIO3;
@@ -76,63 +75,61 @@ type
} }
// procedure int32 _reserved[2]; // procedure int32 _reserved[2];
end; end;
type
TMallocIO = class(TPositionIO) BMallocIO = class(BPositionIO)
private
public public
constructor Create; override; constructor Create; override;
destructor Destroy; override; destructor Destroy; override;
function ReadAt(pos : off_t; abuffer : Pointer; size : Size_t) : SSize_t; override; function ReadAt(pos : off_t; abuffer : Pointer; size : size_t) : ssize_t; override;
function WriteAt(pos : off_t; abuffer : Pointer; size : Size_t) : SSize_t; override; function WriteAt(pos : off_t; abuffer : Pointer; size : size_t) : ssize_t; override;
function Seek(pos : off_t; seek_mode : Cardinal) : off_t; override; function Seek(pos : off_t; seek_mode : Cardinal) : off_t; override;
// function Position : off_t; override; // function Position : off_t; override;
function SetSize(size : off_t) : Status_t; override; function SetSize(size : off_t) : status_t; override;
procedure SetBlockSize(blocksize : Size_t); virtual; procedure SetBlockSize(blocksize : size_t); virtual;
function Buffer : Pointer; function Buffer : Pointer;
// function BufferLength : Size_t; // function BufferLength : size_t;
{ procedure _ReservedMallocIO1; { procedure _ReservedMallocIO1;
procedure _ReservedMallocIO2; procedure _ReservedMallocIO2;
} }
// constructor Create(MallocIO : TMallocIO); // constructor Create(MallocIO : TMallocIO);
// function operator=( : TMallocIO) : TMallocIO; // function operator=( : TMallocIO) : TMallocIO;
{ function fBlockSize : Size_t; { function fBlockSize : size_t;
function fMallocSize : Size_t; function fMallocSize : size_t;
function fLength : Size_t; function fLength : size_t;
function fData : PChar; function fData : PChar;
function fPosition : off_t; function fPosition : off_t;
} }
// procedure _reserved[1] : integer; // procedure _reserved[1] : integer;
end; end;
type
TMemoryIO = class(TPositionIO) BMemoryIO = class(BPositionIO)
private
public public
constructor Create; override; constructor Create; override;
constructor Create(p : Pointer; len : Size_t); virtual; constructor Create(p : Pointer; len : size_t); virtual;
destructor Destroy; override; destructor Destroy; override;
function ReadAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; override; function ReadAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t; override;
function WriteAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; override; function WriteAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t; override;
function Seek(pos : off_t; seek_mode : Cardinal) : off_t; override; function Seek(pos : off_t; seek_mode : Cardinal) : off_t; override;
// function Position : off_t; override; // function Position : off_t; override;
function SetSize(size : off_t) : Status_t; override; function SetSize(size : off_t) : status_t; override;
{ procedure _ReservedMemoryIO1; { procedure _ReservedMemoryIO1;
procedure _ReservedMemoryIO2; procedure _ReservedMemoryIO2;
} }
constructor Create(MemoryIO : TMemoryIO); constructor Create(MemoryIO : BMemoryIO);
// function operator=(MemoryIO : TMemoryIO) : TMemoryIO; // function operator=(MemoryIO : BMemoryIO) : BMemoryIO;
{ function fReadOnly : boolean; { function fReadOnly : boolean;
function fBuf : PChar; function fBuf : PChar;
function fLen : Size_t; function fLen : size_t;
function fPhys : Size_t; function fPhys : size_t;
function fPos : Size_t; function fPos : size_t;
} }
// function _reserved[1] : int32; // function _reserved[1] : int32;
end; end;
function BDataIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BDataIO_Create_1'; function BDataIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BDataIO_Create_1';
procedure BDataIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO_Free'; procedure BDataIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO_Free';
//function BDataIO_Read(AObject : TCPlusObject; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BDataIO_Read'; //function BDataIO_Read(AObject : TCPlusObject; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BDataIO_Read';
//function BDataIO_Write(AObject : TCPlusObject; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BDataIO_Write'; //function BDataIO_Write(AObject : TCPlusObject; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BDataIO_Write';
{procedure BDataIO__ReservedDataIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO__ReservedDataIO1'; {procedure BDataIO__ReservedDataIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO__ReservedDataIO1';
procedure BDataIO__ReservedDataIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO__ReservedDataIO2'; procedure BDataIO__ReservedDataIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO__ReservedDataIO2';
procedure BDataIO__ReservedDataIO3(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO__ReservedDataIO3'; procedure BDataIO__ReservedDataIO3(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO__ReservedDataIO3';
@@ -151,13 +148,13 @@ function BDataIO_Create(AObject : TBeObject; DataIO : BDataIO) : TCPlusObject; c
//procedure BDataIO_int32 _reserved[2](AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO_int32 _reserved[2]'; //procedure BDataIO_int32 _reserved[2](AObject : TCPlusObject); cdecl; external BePascalLibName name 'BDataIO_int32 _reserved[2]';
function BPositionIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BPositionIO_Create'; function BPositionIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BPositionIO_Create';
procedure BPositionIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO_Free'; procedure BPositionIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO_Free';
function BPositionIO_Read(AObject : TCPlusObject; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BPositionIO_Read'; function BPositionIO_Read(AObject : TCPlusObject; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BPositionIO_Read';
function BPositionIO_Write(AObject : TCPlusObject; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BPositionIO_Write'; function BPositionIO_Write(AObject : TCPlusObject; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BPositionIO_Write';
function BPositionIO_ReadAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BPositionIO_ReadAt'; function BPositionIO_ReadAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BPositionIO_ReadAt';
function BPositionIO_WriteAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BPositionIO_WriteAt'; function BPositionIO_WriteAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BPositionIO_WriteAt';
function BPositionIO_Seek(AObject : TCPlusObject; position : off_t; seek_mode : Cardinal) : off_t; cdecl; external BePascalLibName name 'BPositionIO_Seek'; function BPositionIO_Seek(AObject : TCPlusObject; position : off_t; seek_mode : Cardinal) : off_t; cdecl; external BePascalLibName name 'BPositionIO_Seek';
//function BPositionIO_Position(AObject : TCPlusObject) : off_t; cdecl; external BePascalLibName name 'BPositionIO_Position'; //function BPositionIO_Position(AObject : TCPlusObject) : off_t; cdecl; external BePascalLibName name 'BPositionIO_Position';
function BPositionIO_SetSize(AObject : TCPlusObject; size : off_t) : Status_t; cdecl; external BePascalLibName name 'BPositionIO_SetSize'; function BPositionIO_SetSize(AObject : TCPlusObject; size : off_t) : status_t; cdecl; external BePascalLibName name 'BPositionIO_SetSize';
{procedure BPositionIO__ReservedPositionIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO__ReservedPositionIO1'; {procedure BPositionIO__ReservedPositionIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO__ReservedPositionIO1';
procedure BPositionIO__ReservedPositionIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO__ReservedPositionIO2'; procedure BPositionIO__ReservedPositionIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO__ReservedPositionIO2';
procedure BPositionIO__ReservedPositionIO3(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO__ReservedPositionIO3'; procedure BPositionIO__ReservedPositionIO3(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO__ReservedPositionIO3';
@@ -174,14 +171,14 @@ procedure BPositionIO__ReservedPositionIO12(AObject : TCPlusObject); cdecl; exte
//procedure BPositionIO_int32 _reserved[2](AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO_int32 _reserved[2]'; //procedure BPositionIO_int32 _reserved[2](AObject : TCPlusObject); cdecl; external BePascalLibName name 'BPositionIO_int32 _reserved[2]';
function BMallocIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BMallocIO_Create'; function BMallocIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BMallocIO_Create';
procedure BMallocIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO_Free'; procedure BMallocIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO_Free';
function BMallocIO_ReadAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BMallocIO_ReadAt'; function BMallocIO_ReadAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BMallocIO_ReadAt';
function BMallocIO_WriteAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BMallocIO_WriteAt'; function BMallocIO_WriteAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BMallocIO_WriteAt';
function BMallocIO_Seek(AObject : TCPlusObject; pos : off_t; seek_mode : Cardinal) : off_t; cdecl; external BePascalLibName name 'BMallocIO_Seek'; function BMallocIO_Seek(AObject : TCPlusObject; pos : off_t; seek_mode : Cardinal) : off_t; cdecl; external BePascalLibName name 'BMallocIO_Seek';
//function BMallocIO_Position(AObject : TCPlusObject) : off_t; cdecl; external BePascalLibName name 'BMallocIO_Position'; //function BMallocIO_Position(AObject : TCPlusObject) : off_t; cdecl; external BePascalLibName name 'BMallocIO_Position';
function BMallocIO_SetSize(AObject : TCPlusObject; size : off_t) : Status_t; cdecl; external BePascalLibName name 'BMallocIO_SetSize'; function BMallocIO_SetSize(AObject : TCPlusObject; size : off_t) : status_t; cdecl; external BePascalLibName name 'BMallocIO_SetSize';
procedure BMallocIO_SetBlockSize(AObject : TCPlusObject; blocksize : Size_t); cdecl; external BePascalLibName name 'BMallocIO_SetBlockSize'; procedure BMallocIO_SetBlockSize(AObject : TCPlusObject; blocksize : size_t); cdecl; external BePascalLibName name 'BMallocIO_SetBlockSize';
function BMallocIO_Buffer(AObject : TCPlusObject) : Pointer; cdecl; external BePascalLibName name 'BMallocIO_Buffer'; function BMallocIO_Buffer(AObject : TCPlusObject) : Pointer; cdecl; external BePascalLibName name 'BMallocIO_Buffer';
//function BMallocIO_BufferLength(AObject : TCPlusObject) : Size_t; cdecl; external BePascalLibName name 'BMallocIO_BufferLength'; //function BMallocIO_BufferLength(AObject : TCPlusObject) : size_t; cdecl; external BePascalLibName name 'BMallocIO_BufferLength';
{procedure BMallocIO__ReservedMallocIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO__ReservedMallocIO1'; {procedure BMallocIO__ReservedMallocIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO__ReservedMallocIO1';
procedure BMallocIO__ReservedMallocIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO__ReservedMallocIO2'; procedure BMallocIO__ReservedMallocIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO__ReservedMallocIO2';
} }
@@ -195,18 +192,18 @@ procedure BMallocIO_off_t fPosition(AObject : TCPlusObject); cdecl; external BeP
procedure BMallocIO_int32 _reserved[1](AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO_int32 _reserved[1]'; procedure BMallocIO_int32 _reserved[1](AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMallocIO_int32 _reserved[1]';
} }
function BMemoryIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BMemoryIO_Create'; function BMemoryIO_Create(AObject : TBeObject) : TCPlusObject; cdecl; external BePascalLibName name 'BMemoryIO_Create';
function BMemoryIO_Create(AObject : TBeObject; p : Pointer; len : Size_t) : TCPlusObject; cdecl; external BePascalLibName name 'BMemoryIO_Create_1'; function BMemoryIO_Create(AObject : TBeObject; p : Pointer; len : size_t) : TCPlusObject; cdecl; external BePascalLibName name 'BMemoryIO_Create_1';
procedure BMemoryIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_Free'; procedure BMemoryIO_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_Free';
function BMemoryIO_ReadAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BMemoryIO_ReadAt'; function BMemoryIO_ReadAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BMemoryIO_ReadAt';
function BMemoryIO_WriteAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; cdecl; external BePascalLibName name 'BMemoryIO_WriteAt'; function BMemoryIO_WriteAt(AObject : TCPlusObject; pos : off_t; buffer : Pointer; size : size_t) : ssize_t; cdecl; external BePascalLibName name 'BMemoryIO_WriteAt';
function BMemoryIO_Seek(AObject : TCPlusObject; pos : off_t; seek_mode : Cardinal) : off_t; cdecl; external BePascalLibName name 'BMemoryIO_Seek'; function BMemoryIO_Seek(AObject : TCPlusObject; pos : off_t; seek_mode : Cardinal) : off_t; cdecl; external BePascalLibName name 'BMemoryIO_Seek';
function BMemoryIO_Position(AObject : TCPlusObject) : off_t; cdecl; external BePascalLibName name 'BMemoryIO_Position'; function BMemoryIO_Position(AObject : TCPlusObject) : off_t; cdecl; external BePascalLibName name 'BMemoryIO_Position';
function BMemoryIO_SetSize(AObject : TCPlusObject; size : off_t) : Status_t; cdecl; external BePascalLibName name 'BMemoryIO_SetSize'; function BMemoryIO_SetSize(AObject : TCPlusObject; size : off_t) : status_t; cdecl; external BePascalLibName name 'BMemoryIO_SetSize';
{procedure BMemoryIO__ReservedMemoryIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO__ReservedMemoryIO1'; {procedure BMemoryIO__ReservedMemoryIO1(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO__ReservedMemoryIO1';
procedure BMemoryIO__ReservedMemoryIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO__ReservedMemoryIO2'; procedure BMemoryIO__ReservedMemoryIO2(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO__ReservedMemoryIO2';
} }
function BMemoryIO_Create(AObject : TBeObject; MemoryIO : TCPlusObject) : TCPlusObject; cdecl; external BePascalLibName name 'BMemoryIO_Create'; function BMemoryIO_Create(AObject : TBeObject; MemoryIO : TCPlusObject) : TCPlusObject; cdecl; external BePascalLibName name 'BMemoryIO_Create';
//function BMemoryIO_operator=(AObject : TCPlusObject; : TMemoryIO) : TMemoryIO; cdecl; external BePascalLibName name 'BMemoryIO_operator='; //function BMemoryIO_operator=(AObject : TCPlusObject; : BMemoryIO) : BMemoryIO; cdecl; external BePascalLibName name 'BMemoryIO_operator=';
{procedure BMemoryIO_bool fReadOnly(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_bool fReadOnly'; {procedure BMemoryIO_bool fReadOnly(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_bool fReadOnly';
procedure BMemoryIO_char *fBuf(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_char *fBuf'; procedure BMemoryIO_char *fBuf(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_char *fBuf';
procedure BMemoryIO_size_t fLen(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_size_t fLen'; procedure BMemoryIO_size_t fLen(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BMemoryIO_size_t fLen';
@@ -309,321 +306,320 @@ begin
end; end;
} }
constructor TPositionIO.Create; constructor BPositionIO.Create;
begin begin
CPlusObject := BPositionIO_Create(Self); CPlusObject := BPositionIO_Create(Self);
end; end;
destructor TPositionIO.Destroy; destructor BPositionIO.Destroy;
begin begin
BPositionIO_Free(CPlusObject); BPositionIO_Free(CPlusObject);
end; end;
{function TPositionIO.Read(buffer : Pointer; size : Size_t) : SSize_t; {function BPositionIO.Read(buffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BPositionIO_Read(CPlusObject, buffer, size); Result := BPositionIO_Read(CPlusObject, buffer, size);
end; end;
function TPositionIO.Write(buffer : Pointer; size : Size_t) : SSize_t; function BPositionIO.Write(buffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BPositionIO_Write(CPlusObject, buffer, size); Result := BPositionIO_Write(CPlusObject, buffer, size);
end; end;
} }
{function TPositionIO.ReadAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; {function BPositionIO.ReadAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BPositionIO_ReadAt(CPlusObject, pos, buffer, size); Result := BPositionIO_ReadAt(CPlusObject, pos, buffer, size);
end; end;
function TPositionIO.WriteAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; function BPositionIO.WriteAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BPositionIO_WriteAt(CPlusObject, pos, buffer, size); Result := BPositionIO_WriteAt(CPlusObject, pos, buffer, size);
end; end;
function TPositionIO.Seek(aposition : off_t; seek_mode : Cardinal) : off_t; function BPositionIO.Seek(aposition : off_t; seek_mode : Cardinal) : off_t;
begin begin
Result := BPositionIO_Seek(CPlusObject, aposition, seek_mode); Result := BPositionIO_Seek(CPlusObject, aposition, seek_mode);
end; end;
} }
{function TPositionIO.Position : off_t; {function BPositionIO.Position : off_t;
begin begin
Result := BPositionIO_Position(CPlusObject); Result := BPositionIO_Position(CPlusObject);
end; end;
} }
function TPositionIO.SetSize(size : off_t) : Status_t; function BPositionIO.SetSize(size : off_t) : status_t;
begin begin
Result := BPositionIO_SetSize(CPlusObject, size); Result := BPositionIO_SetSize(CPlusObject, size);
end; end;
{procedure TPositionIO._ReservedPositionIO1; {procedure BPositionIO._ReservedPositionIO1;
begin begin
BPositionIO__ReservedPositionIO1(CPlusObject); BPositionIO__ReservedPositionIO1(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO2; procedure BPositionIO._ReservedPositionIO2;
begin begin
BPositionIO__ReservedPositionIO2(CPlusObject); BPositionIO__ReservedPositionIO2(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO3; procedure BPositionIO._ReservedPositionIO3;
begin begin
BPositionIO__ReservedPositionIO3(CPlusObject); BPositionIO__ReservedPositionIO3(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO4; procedure BPositionIO._ReservedPositionIO4;
begin begin
BPositionIO__ReservedPositionIO4(CPlusObject); BPositionIO__ReservedPositionIO4(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO5; procedure BPositionIO._ReservedPositionIO5;
begin begin
BPositionIO__ReservedPositionIO5(CPlusObject); BPositionIO__ReservedPositionIO5(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO6; procedure BPositionIO._ReservedPositionIO6;
begin begin
BPositionIO__ReservedPositionIO6(CPlusObject); BPositionIO__ReservedPositionIO6(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO7; procedure BPositionIO._ReservedPositionIO7;
begin begin
BPositionIO__ReservedPositionIO7(CPlusObject); BPositionIO__ReservedPositionIO7(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO8; procedure BPositionIO._ReservedPositionIO8;
begin begin
BPositionIO__ReservedPositionIO8(CPlusObject); BPositionIO__ReservedPositionIO8(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO9; procedure BPositionIO._ReservedPositionIO9;
begin begin
BPositionIO__ReservedPositionIO9(CPlusObject); BPositionIO__ReservedPositionIO9(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO10; procedure BPositionIO._ReservedPositionIO10;
begin begin
BPositionIO__ReservedPositionIO10(CPlusObject); BPositionIO__ReservedPositionIO10(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO11; procedure BPositionIO._ReservedPositionIO11;
begin begin
BPositionIO__ReservedPositionIO11(CPlusObject); BPositionIO__ReservedPositionIO11(CPlusObject);
end; end;
procedure TPositionIO._ReservedPositionIO12; procedure BPositionIO._ReservedPositionIO12;
begin begin
BPositionIO__ReservedPositionIO12(CPlusObject); BPositionIO__ReservedPositionIO12(CPlusObject);
end; end;
} }
{procedure TPositionIO.int32 _reserved[2]; {procedure BPositionIO.int32 _reserved[2];
begin begin
BPositionIO_int32 _reserved[2](CPlusObject); BPositionIO_int32 _reserved[2](CPlusObject);
end; end;
} }
constructor TMallocIO.Create; constructor BMallocIO.Create;
begin begin
CPlusObject := BMallocIO_Create(Self); CPlusObject := BMallocIO_Create(Self);
end; end;
destructor TMallocIO.Destroy; destructor BMallocIO.Destroy;
begin begin
BMallocIO_Free(CPlusObject); BMallocIO_Free(CPlusObject);
end; end;
function TMallocIO.ReadAt(pos : off_t; abuffer : Pointer; size : Size_t) : SSize_t; function BMallocIO.ReadAt(pos : off_t; abuffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BMallocIO_ReadAt(CPlusObject, pos, abuffer, size); Result := BMallocIO_ReadAt(CPlusObject, pos, abuffer, size);
end; end;
function TMallocIO.WriteAt(pos : off_t; abuffer : Pointer; size : Size_t) : SSize_t; function BMallocIO.WriteAt(pos : off_t; abuffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BMallocIO_WriteAt(CPlusObject, pos, abuffer, size); Result := BMallocIO_WriteAt(CPlusObject, pos, abuffer, size);
end; end;
function TMallocIO.Seek(pos : off_t; seek_mode : Cardinal) : off_t; function BMallocIO.Seek(pos : off_t; seek_mode : Cardinal) : off_t;
begin begin
Result := BMallocIO_Seek(CPlusObject, pos, seek_mode); Result := BMallocIO_Seek(CPlusObject, pos, seek_mode);
end; end;
{function TMallocIO.Position : off_t; {function BMallocIO.Position : off_t;
begin begin
Result := BMallocIO_Position(CPlusObject); Result := BMallocIO_Position(CPlusObject);
end; end;
} }
function TMallocIO.SetSize(size : off_t) : Status_t; function BMallocIO.SetSize(size : off_t) : status_t;
begin begin
Result := BMallocIO_SetSize(CPlusObject, size); Result := BMallocIO_SetSize(CPlusObject, size);
end; end;
procedure TMallocIO.SetBlockSize(blocksize : Size_t); procedure BMallocIO.SetBlockSize(blocksize : size_t);
begin begin
BMallocIO_SetBlockSize(CPlusObject, blocksize); BMallocIO_SetBlockSize(CPlusObject, blocksize);
end; end;
function TMallocIO.Buffer : Pointer; function BMallocIO.Buffer : Pointer;
begin begin
Result := BMallocIO_Buffer(CPlusObject); Result := BMallocIO_Buffer(CPlusObject);
end; end;
{function TMallocIO.BufferLength : Size_t; {function BMallocIO.BufferLength : size_t;
begin begin
Result := BMallocIO_BufferLength(CPlusObject); Result := BMallocIO_BufferLength(CPlusObject);
end; end;
} }
{procedure BMallocIO._ReservedMallocIO1;
{procedure TMallocIO._ReservedMallocIO1;
begin begin
BMallocIO__ReservedMallocIO1(CPlusObject); BMallocIO__ReservedMallocIO1(CPlusObject);
end; end;
procedure TMallocIO._ReservedMallocIO2; procedure BMallocIO._ReservedMallocIO2;
begin begin
BMallocIO__ReservedMallocIO2(CPlusObject); BMallocIO__ReservedMallocIO2(CPlusObject);
end; end;
} }
//constructor TMallocIO.Create(MallocIO : TMallocIO); //constructor BMallocIO.Create(MallocIO : BMallocIO);
//begin //begin
// CPlusObject := BMallocIO_Create(Self, MallocIO); // CPlusObject := BMallocIO_Create(Self, MallocIO);
//end; //end;
{function TMallocIO.operator=( : TMallocIO) : TMallocIO; {function BMallocIO.operator=( : BMallocIO) : BMallocIO;
begin begin
BMallocIO_operator=(CPlusObject, ); BMallocIO_operator=(CPlusObject, );
end; end;
} }
{function TMallocIO.fBlockSize : Size_t; {function BMallocIO.fBlockSize : size_t;
begin begin
Result := BMallocIO_fBlockSize(CPlusObject); Result := BMallocIO_fBlockSize(CPlusObject);
end; end;
function TMallocIO.fMallocSize : Size_t; function BMallocIO.fMallocSize : size_t;
begin begin
Result := BMallocIO_size_t fMallocSize(CPlusObject); Result := BMallocIO_size_t fMallocSize(CPlusObject);
end; end;
function TMallocIO.fLength : Size_t; function BMallocIO.fLength : size_t;
begin begin
BMallocIO_size_t fLength(CPlusObject); BMallocIO_size_t fLength(CPlusObject);
end; end;
function TMallocIO.fData : PChar; function BMallocIO.fData : PChar;
begin begin
Result := BMallocIO_char *fData(CPlusObject); Result := BMallocIO_char *fData(CPlusObject);
end; end;
function TMallocIO.fPosition : off_t; function BMallocIO.fPosition : off_t;
begin begin
Result := BMallocIO_fPosition(CPlusObject); Result := BMallocIO_fPosition(CPlusObject);
end; end;
} }
{procedure TMallocIO.int32 _reserved[1]; {procedure BMallocIO.int32 _reserved[1];
begin begin
BMallocIO_int32 _reserved[1](CPlusObject); BMallocIO_int32 _reserved[1](CPlusObject);
end; end;
} }
constructor TMemoryIO.Create; constructor BMemoryIO.Create;
begin begin
CPlusObject := BMemoryIO_Create(Self); CPlusObject := BMemoryIO_Create(Self);
end; end;
constructor TMemoryIO.Create(p : Pointer; len : Size_t); constructor BMemoryIO.Create(p : Pointer; len : size_t);
begin begin
CPlusObject := BMemoryIO_Create(Self, p, len); CPlusObject := BMemoryIO_Create(Self, p, len);
end; end;
destructor TMemoryIO.Destroy; destructor BMemoryIO.Destroy;
begin begin
BMemoryIO_Free(CPlusObject); BMemoryIO_Free(CPlusObject);
end; end;
function TMemoryIO.ReadAt(pos : off_t; buffer : Pointer; size : Size_t) : SSize_t; function BMemoryIO.ReadAt(pos : off_t; buffer : Pointer; size : size_t) : ssize_t;
begin begin
Result := BMemoryIO_ReadAt(CPlusObject, pos, buffer, size); Result := BMemoryIO_ReadAt(CPlusObject, pos, buffer, size);
end; end;
function TMemoryIO.WriteAt(pos : off_t; buffer : Pointer; size :Size_t) :SSize_t; function BMemoryIO.WriteAt(pos : off_t; buffer : Pointer; size :size_t) :ssize_t;
begin begin
Result := BMemoryIO_WriteAt(CPlusObject, pos, buffer, size); Result := BMemoryIO_WriteAt(CPlusObject, pos, buffer, size);
end; end;
function TMemoryIO.Seek(pos : off_t; seek_mode : Cardinal) : off_t; function BMemoryIO.Seek(pos : off_t; seek_mode : Cardinal) : off_t;
begin begin
Result := BMemoryIO_Seek(CPlusObject, pos, seek_mode); Result := BMemoryIO_Seek(CPlusObject, pos, seek_mode);
end; end;
{function TMemoryIO.Position : off_t; {function BMemoryIO.Position : off_t;
begin begin
Result := BMemoryIO_Position(CPlusObject); Result := BMemoryIO_Position(CPlusObject);
end; end;
} }
function TMemoryIO.SetSize(size : off_t) : Status_t; function BMemoryIO.SetSize(size : off_t) : status_t;
begin begin
Result := BMemoryIO_SetSize(CPlusObject, size); Result := BMemoryIO_SetSize(CPlusObject, size);
end; end;
{procedure TMemoryIO._ReservedMemoryIO1; {procedure BMemoryIO._ReservedMemoryIO1;
begin begin
BMemoryIO__ReservedMemoryIO1(CPlusObject); BMemoryIO__ReservedMemoryIO1(CPlusObject);
end; end;
procedure TMemoryIO._ReservedMemoryIO2; procedure BMemoryIO._ReservedMemoryIO2;
begin begin
BMemoryIO__ReservedMemoryIO2(CPlusObject); BMemoryIO__ReservedMemoryIO2(CPlusObject);
end; end;
} }
constructor TMemoryIO.Create(MemoryIO : TMemoryIO); constructor BMemoryIO.Create(MemoryIO : BMemoryIO);
begin begin
CPlusObject := BMemoryIO_Create(Self, MemoryIO.CPlusObject); CPlusObject := BMemoryIO_Create(Self, MemoryIO.CPlusObject);
end; end;
{function TMemoryIO.operator=( : TMemoryIO) : TMemoryIO; {function BMemoryIO.operator=( : BMemoryIO) : BMemoryIO;
begin begin
BMemoryIO_operator=(CPlusObject, ); BMemoryIO_operator=(CPlusObject, );
end; end;
} }
{procedure TMemoryIO.bool fReadOnly; {procedure BMemoryIO.bool fReadOnly;
begin begin
BMemoryIO_bool fReadOnly(CPlusObject); BMemoryIO_bool fReadOnly(CPlusObject);
end; end;
procedure TMemoryIO.char *fBuf; procedure BMemoryIO.char *fBuf;
begin begin
BMemoryIO_char *fBuf(CPlusObject); BMemoryIO_char *fBuf(CPlusObject);
end; end;
procedure TMemoryIO.size_t fLen; procedure BMemoryIO.size_t fLen;
begin begin
BMemoryIO_size_t fLen(CPlusObject); BMemoryIO_size_t fLen(CPlusObject);
end; end;
procedure TMemoryIO.size_t fPhys; procedure BMemoryIO.size_t fPhys;
begin begin
BMemoryIO_size_t fPhys(CPlusObject); BMemoryIO_size_t fPhys(CPlusObject);
end; end;
procedure TMemoryIO.size_t fPos; procedure BMemoryIO.size_t fPos;
begin begin
BMemoryIO_size_t fPos(CPlusObject); BMemoryIO_size_t fPos(CPlusObject);
end; end;
procedure TMemoryIO.int32 _reserved[1]; procedure BMemoryIO.int32 _reserved[1];
begin begin
BMemoryIO_int32 _reserved[1](CPlusObject); BMemoryIO_int32 _reserved[1](CPlusObject);
end; end;
} }
end. end.

75
bepascal/source/bepascal/pas/src/be/support/flattenable.pp
View File

@@ -1,6 +1,7 @@
{ BePascal - A pascal wrapper around the BeOS API { BePascal - A pascal wrapper around the BeOS API
Copyright (C) 2002 Olivier Coursière Copyright (C) 2002 - 2003 Olivier Coursière
Eric Jourde Eric Jourde
Oscar Lesta
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public modify it under the terms of the GNU Library General Public
@@ -16,81 +17,81 @@
License along with this library; if not, write to the Free License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
} }
unit Flattenable; unit Flattenable;
interface interface
uses uses
beobj, SupportDefs, os; BeObj, SupportDefs, OS;
type type
BFlattenable = class(TBeObject) BFlattenable = class(TBeObject)
private
public public
constructor Create; override; constructor Create; override;
destructor Destroy; override; destructor Destroy; override;
function IsFixedSize : boolean; function IsFixedSize : Boolean;
function TypeCode : Type_code; function TypeCode : type_code;
function Flatten( buffer :pointer; size : ssize_t) : Status_t; function Flatten(buffer : Pointer; size : ssize_t) : status_t;
function AllowsTypeCode( code : Type_code) : boolean; function AllowsTypeCode(code : Type_code) : Boolean;
function Unflatten(c :Type_code ; buf :pointer ; size: ssize_t) : Status_t; function Unflatten(c : type_code; buf : Pointer; size : ssize_t) : status_t;
end; end;
procedure BFlattenable_Free(AObject : TCPlusObject);
cdecl; external BePascalLibName name 'BFlattenable_Free';
procedure BFlattenable_Free(AObject : TCPlusObject); cdecl; external BePascalLibName name 'BFlattenable_Free'; function BFlattenable_IsFixedSize(AObject : TCPlusObject) : Boolean;
cdecl; external BePascalLibName name 'BFlattenable_IsFixedSize';
function BFlattenable_IsFixedSize(AObject : TCPlusObject) : boolean;cdecl; external BePascalLibName name 'BFlattenable_IsFixedSize'; function BFlattenable_TypeCode(AObject : TCPlusObject) : type_code;
function BFlattenable_TypeCode(AObject : TCPlusObject) : Type_code;cdecl; external BePascalLibName name 'BFlattenable_TypeCode'; cdecl; external BePascalLibName name 'BFlattenable_TypeCode';
function BFlattenable_Flatten( AObject : TCPlusObject;buffer :pointer; size : ssize_t) : Status_t;cdecl; external BePascalLibName name 'BFlattenable_Flatten'; function BFlattenable_Flatten(AObject : TCPlusObject; buffer : Pointer;
function BFlattenable_AllowsTypeCode( AObject : TCPlusObject;code : Type_code) : boolean;cdecl; external BePascalLibName name 'BFlattenable_AllowsTypeCode'; size : ssize_t) : status_t;
function BFlattenable_Unflatten(AObject : TCPlusObject;c :Type_code ; buf :pointer ; size: ssize_t) : Status_t;cdecl; external BePascalLibName name 'BFlattenable_Unflatten'; cdecl; external BePascalLibName name 'BFlattenable_Flatten';
function BFlattenable_AllowsTypeCode(AObject : TCPlusObject;code : type_code)
: boolean;
cdecl; external BePascalLibName name 'BFlattenable_AllowsTypeCode';
function BFlattenable_Unflatten(AObject : TCPlusObject; c : type_code;
buf : Pointer; size : ssize_t) : Status_t;
cdecl; external BePascalLibName name 'BFlattenable_Unflatten';
implementation implementation
constructor BFlattenable.Create; constructor BFlattenable.Create;
begin begin
CreatePas; CreatePas;
CPlusObject:=self; CPlusObject := self;
end; end;
destructor BFlattenable.Destroy;
destructor BFlattenable.Destroy;
begin begin
if CPlusObject <> nil then if CPlusObject <> nil then
BFlattenable_Free(CPlusObject); BFlattenable_Free(CPlusObject);
inherited; inherited;
end; end;
function BFlattenable.IsFixedSize : boolean; function BFlattenable.IsFixedSize : Boolean;
begin begin
result:=BFlattenable_IsFixedSize(CPlusObject); Result := BFlattenable_IsFixedSize(CPlusObject);
end; end;
function BFlattenable.TypeCode : Type_code; function BFlattenable.TypeCode : type_code;
begin begin
result:=BFlattenable_TypeCode(CPlusObject); Result := BFlattenable_TypeCode(CPlusObject);
end; end;
function BFlattenable.Flatten( buffer :pointer; size : ssize_t) : Status_t; function BFlattenable.Flatten(buffer : Pointer; size : ssize_t) : status_t;
begin begin
result:=BFlattenable_Flatten(CPlusObject,buffer,size); Result := BFlattenable_Flatten(CPlusObject, buffer, size);
end; end;
function BFlattenable.AllowsTypeCode( code : Type_code) : boolean; function BFlattenable.AllowsTypeCode(code : type_code) : Boolean;
begin begin
result:=BFlattenable_AllowsTypeCode(CPlusObject,code); Result := BFlattenable_AllowsTypeCode(CPlusObject, code);
end; end;
function BFlattenable.Unflatten(c :Type_code ; buf :pointer ; size: ssize_t) : Status_t; function BFlattenable.Unflatten(c : type_code; buf : Pointer; size : ssize_t) : status_t;
begin begin
result:=BFlattenable_Unflatten(CPlusObject,c,buf,size); Result := BFlattenable_Unflatten(CPlusObject, c, buf, size);
end; end;
end. end.

54
bepascal/source/bepascal/pas/src/be/support/supportdefs.pp
View File

@@ -1,6 +1,7 @@
{ BePascal - A pascal wrapper around the BeOS API { BePascal - A pascal wrapper around the BeOS API
Copyright (C) 2002 Olivier Coursiere Copyright (C) 2002-2003 Olivier Coursiere
Eric Jourde Eric Jourde
Oscar Lesta
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public modify it under the terms of the GNU Library General Public
@@ -16,34 +17,47 @@
License along with this library; if not, write to the Free License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
} }
unit SupportDefs; unit SupportDefs;
interface interface
type type
// Descriptive formats
Status_t = Longint;
Bigtime_t = int64;
Type_code = Cardinal;
Perform_code = Cardinal;
// For Storage kit // For Storage kit
// TODO : move these declarations in a different unit (but which one ?). // TODO : move these declarations in a different unit (but which one ?).
// C++ declarations are in /boot/develop/headers/posix/sys/types.h, // C++ declarations are in /boot/develop/headers/posix/sys/types.h,
// not in SupportDefs.h // not in SupportDefs.h
Dev_t = Longint; dev_t = Longint;
Off_t = int64; off_t = Int64;
// pointer types for FreePascal : to make life easier // import from stddef.h
PStatus_t = ^Status_t; size_t = Longword;
ssize_t = Longint;
// TODO : import other functions !
// ------------------
// Descriptive formats
status_t = Longint;
bigtime_t = int64;
type_code = Longword;
perform_code = Longword;
// pointer types for FreePascal : to make life easier
Pstatus_t = ^status_t;
const
B_EMPTY_STRING = '';
//----- Atomic functions; old value is returned -----------------
function atomic_add(var value : Longint; addvalue : Longint) : Longint;
cdecl; external 'root' name 'atomic_add';
function atomic_and(var value : Longint; andvalue : Longint) : Longint;
cdecl; external 'root' name 'atomic_and';
function atomic_or(var value : Longint; orvalue : Longint) : Longint;
cdecl; external 'root' name 'atomic_or';
//----- Other stuff ---------------------------------------------
function get_stack_frame : Pointer; cdecl; external 'root' name 'get_stack_frame';
// import from stddef.h
Size_t = Cardinal;
SSize_t = Longint;
implementation implementation
end. end.