📄 system.pas
字号:
{ TContainedObject is an aggregated object that isolates
QueryInterface on the aggregate from the controller.
TContainedObject will return only interfaces that the
contained object itself implements, not interfaces
that the controller implements. This is useful for
implementing nodes that are attached to a controller and
have the same lifetime as the controller, but whose
interface identity is separate from the controller.
You might do this if you don't want the consumers of
an aggregated interface to have access to other interfaces
implemented by the controller - forced encapsulation.
This is a less common case than TAggregatedObject. }
TContainedObject = class(TAggregatedObject, IInterface)
protected
{ IInterface }
function QueryInterface(const IID: TGUID; out Obj): HResult; virtual; stdcall;
end;
PShortString = ^ShortString;
PAnsiString = ^AnsiString;
PWideString = ^WideString;
PString = PAnsiString;
UCS2Char = WideChar;
PUCS2Char = PWideChar;
UCS4Char = type LongWord;
{$NODEFINE UCS4CHAR}
PUCS4Char = ^UCS4Char;
{$NODEFINE PUCS4CHAR}
TUCS4CharArray = array [0..$effffff] of UCS4Char;
PUCS4CharArray = ^TUCS4CharArray;
UCS4String = array of UCS4Char;
{$NODEFINE UCS4String}
UTF8String = type string;
PUTF8String = ^UTF8String;
{$NODEFINE UTF8String}
{$NODEFINE PUTF8String}
IntegerArray = array[0..$effffff] of Integer;
PIntegerArray = ^IntegerArray;
PointerArray = array [0..512*1024*1024 - 2] of Pointer;
PPointerArray = ^PointerArray;
TBoundArray = array of Integer;
TPCharArray = packed array[0..(MaxLongint div SizeOf(PChar))-1] of PChar;
PPCharArray = ^TPCharArray;
(*$HPPEMIT 'namespace System' *)
(*$HPPEMIT '{' *)
(*$HPPEMIT ' typedef int *PLongint;' *)
(*$HPPEMIT '}' *)
PLongint = ^Longint;
{$EXTERNALSYM PLongint}
PInteger = ^Integer;
PCardinal = ^Cardinal;
PWord = ^Word;
PSmallInt = ^SmallInt;
PByte = ^Byte;
PShortInt = ^ShortInt;
PInt64 = ^Int64;
PLongWord = ^LongWord;
PSingle = ^Single;
PDouble = ^Double;
PDate = ^Double;
PDispatch = ^IDispatch;
PPDispatch = ^PDispatch;
PError = ^LongWord;
PWordBool = ^WordBool;
PUnknown = ^IUnknown;
PPUnknown = ^PUnknown;
{$NODEFINE PByte}
PPWideChar = ^PWideChar;
PPChar = ^PChar;
PPAnsiChar = PPChar;
PExtended = ^Extended;
PComp = ^Comp;
PCurrency = ^Currency;
PVariant = ^Variant;
POleVariant = ^OleVariant;
PPointer = ^Pointer;
PBoolean = ^Boolean;
TDateTime = type Double;
PDateTime = ^TDateTime;
THandle = LongWord;
TVarArrayBound = packed record
ElementCount: Integer;
LowBound: Integer;
end;
TVarArrayBoundArray = array [0..0] of TVarArrayBound;
PVarArrayBoundArray = ^TVarArrayBoundArray;
TVarArrayCoorArray = array [0..0] of Integer;
PVarArrayCoorArray = ^TVarArrayCoorArray;
PVarArray = ^TVarArray;
TVarArray = packed record
DimCount: Word;
Flags: Word;
ElementSize: Integer;
LockCount: Integer;
Data: Pointer;
Bounds: TVarArrayBoundArray;
end;
TVarType = Word;
PVarData = ^TVarData;
{$EXTERNALSYM PVarData}
TVarData = packed record
case Integer of
0: (VType: TVarType;
case Integer of
0: (Reserved1: Word;
case Integer of
0: (Reserved2, Reserved3: Word;
case Integer of
varSmallInt: (VSmallInt: SmallInt);
varInteger: (VInteger: Integer);
varSingle: (VSingle: Single);
varDouble: (VDouble: Double);
varCurrency: (VCurrency: Currency);
varDate: (VDate: TDateTime);
varOleStr: (VOleStr: PWideChar);
varDispatch: (VDispatch: Pointer);
varError: (VError: HRESULT);
varBoolean: (VBoolean: WordBool);
varUnknown: (VUnknown: Pointer);
varShortInt: (VShortInt: ShortInt);
varByte: (VByte: Byte);
varWord: (VWord: Word);
varLongWord: (VLongWord: LongWord);
varInt64: (VInt64: Int64);
varString: (VString: Pointer);
varAny: (VAny: Pointer);
varArray: (VArray: PVarArray);
varByRef: (VPointer: Pointer);
);
1: (VLongs: array[0..2] of LongInt);
);
2: (VWords: array [0..6] of Word);
3: (VBytes: array [0..13] of Byte);
);
1: (RawData: array [0..3] of LongInt);
end;
{$EXTERNALSYM TVarData}
type
TVarOp = Integer;
const
opAdd = 0;
opSubtract = 1;
opMultiply = 2;
opDivide = 3;
opIntDivide = 4;
opModulus = 5;
opShiftLeft = 6;
opShiftRight = 7;
opAnd = 8;
opOr = 9;
opXor = 10;
opCompare = 11;
opNegate = 12;
opNot = 13;
opCmpEQ = 14;
opCmpNE = 15;
opCmpLT = 16;
opCmpLE = 17;
opCmpGT = 18;
opCmpGE = 19;
type
{ Dispatch call descriptor }
PCallDesc = ^TCallDesc;
TCallDesc = packed record
CallType: Byte;
ArgCount: Byte;
NamedArgCount: Byte;
ArgTypes: array[0..255] of Byte;
end;
PDispDesc = ^TDispDesc;
TDispDesc = packed record
DispID: Integer;
ResType: Byte;
CallDesc: TCallDesc;
end;
PVariantManager = ^TVariantManager;
{$EXTERNALSYM PVariantManager}
TVariantManager = record
VarClear: procedure(var V : Variant);
VarCopy: procedure(var Dest: Variant; const Source: Variant);
VarCopyNoInd: procedure; // ARGS PLEASE!
VarCast: procedure(var Dest: Variant; const Source: Variant; VarType: Integer);
VarCastOle: procedure(var Dest: Variant; const Source: Variant; VarType: Integer);
VarToInt: function(const V: Variant): Integer;
VarToInt64: function(const V: Variant): Int64;
VarToBool: function(const V: Variant): Boolean;
VarToReal: function(const V: Variant): Extended;
VarToCurr: function(const V: Variant): Currency;
VarToPStr: procedure(var S; const V: Variant);
VarToLStr: procedure(var S: string; const V: Variant);
VarToWStr: procedure(var S: WideString; const V: Variant);
VarToIntf: procedure(var Unknown: IInterface; const V: Variant);
VarToDisp: procedure(var Dispatch: IDispatch; const V: Variant);
VarToDynArray: procedure(var DynArray: Pointer; const V: Variant; TypeInfo: Pointer);
VarFromInt: procedure(var V: Variant; const Value: Integer; const Range: ShortInt);
VarFromInt64: procedure(var V: Variant; const Value: Int64);
VarFromBool: procedure(var V: Variant; const Value: Boolean);
VarFromReal: procedure; // var V: Variant; const Value: Real
VarFromTDateTime: procedure; // var V: Variant; const Value: TDateTime
VarFromCurr: procedure; // var V: Variant; const Value: Currency
VarFromPStr: procedure(var V: Variant; const Value: ShortString);
VarFromLStr: procedure(var V: Variant; const Value: string);
VarFromWStr: procedure(var V: Variant; const Value: WideString);
VarFromIntf: procedure(var V: Variant; const Value: IInterface);
VarFromDisp: procedure(var V: Variant; const Value: IDispatch);
VarFromDynArray: procedure(var V: Variant; const DynArray: Pointer; TypeInfo: Pointer);
OleVarFromPStr: procedure(var V: OleVariant; const Value: ShortString);
OleVarFromLStr: procedure(var V: OleVariant; const Value: string);
OleVarFromVar: procedure(var V: OleVariant; const Value: Variant);
OleVarFromInt: procedure(var V: OleVariant; const Value: Integer; const Range: ShortInt);
VarOp: procedure(var Left: Variant; const Right: Variant; OpCode: TVarOp);
VarCmp: procedure(const Left, Right: TVarData; const OpCode: TVarOp); { result is set in the flags }
VarNeg: procedure(var V: Variant);
VarNot: procedure(var V: Variant);
DispInvoke: procedure(Dest: PVarData; const Source: TVarData;
CallDesc: PCallDesc; Params: Pointer); cdecl;
VarAddRef: procedure(var V: Variant);
VarArrayRedim: procedure(var A : Variant; HighBound: Integer);
VarArrayGet: function(var A: Variant; IndexCount: Integer;
Indices: Integer): Variant; cdecl;
VarArrayPut: procedure(var A: Variant; const Value: Variant;
IndexCount: Integer; Indices: Integer); cdecl;
WriteVariant: function(var T: Text; const V: Variant; Width: Integer): Pointer;
Write0Variant: function(var T: Text; const V: Variant): Pointer;
end deprecated;
{$EXTERNALSYM TVariantManager}
{ Dynamic array support }
PDynArrayTypeInfo = ^TDynArrayTypeInfo;
{$EXTERNALSYM PDynArrayTypeInfo}
TDynArrayTypeInfo = packed record
kind: Byte;
name: string[0];
elSize: Longint;
elType: ^PDynArrayTypeInfo;
varType: Integer;
end;
{$EXTERNALSYM TDynArrayTypeInfo}
PVarRec = ^TVarRec;
TVarRec = record { do not pack this record; it is compiler-generated }
case Byte of
vtInteger: (VInteger: Integer; VType: Byte);
vtBoolean: (VBoolean: Boolean);
vtChar: (VChar: Char);
vtExtended: (VExtended: PExtended);
vtString: (VString: PShortString);
vtPointer: (VPointer: Pointer);
vtPChar: (VPChar: PChar);
vtObject: (VObject: TObject);
vtClass: (VClass: TClass);
vtWideChar: (VWideChar: WideChar);
vtPWideChar: (VPWideChar: PWideChar);
vtAnsiString: (VAnsiString: Pointer);
vtCurrency: (VCurrency: PCurrency);
vtVariant: (VVariant: PVariant);
vtInterface: (VInterface: Pointer);
vtWideString: (VWideString: Pointer);
vtInt64: (VInt64: PInt64);
end;
PMemoryManager = ^TMemoryManager;
TMemoryManager = record
GetMem: function(Size: Integer): Pointer;
FreeMem: function(P: Pointer): Integer;
ReallocMem: function(P: Pointer; Size: Integer): Pointer;
end;
THeapStatus = record
TotalAddrSpace: Cardinal;
TotalUncommitted: Cardinal;
TotalCommitted: Cardinal;
TotalAllocated: Cardinal;
TotalFree: Cardinal;
FreeSmall: Cardinal;
FreeBig: Cardinal;
Unused: Cardinal;
Overhead: Cardinal;
HeapErrorCode: Cardinal;
end;
{$IFDEF PC_MAPPED_EXCEPTIONS}
PUnwinder = ^TUnwinder;
TUnwinder = record
RaiseException: function(Exc: Pointer): LongBool; cdecl;
RegisterIPLookup: function(fn: Pointer; StartAddr, EndAddr: LongInt; Context: Pointer; GOT: LongInt): LongBool; cdecl;
UnregisterIPLookup: procedure(StartAddr: LongInt) cdecl;
DelphiLookup: function(Addr: LongInt; Context: Pointer): Pointer; cdecl;
ClosestHandler: function(Context: Pointer): LongWord; cdecl;
end;
{$ENDIF PC_MAPPED_EXCEPTIONS}
PackageUnitEntry = packed record
Init, FInit : Pointer;
end;
{ Compiler generated table to be processed sequentially to init & finit all package units }
{ Init: 0..Max-1; Final: Last Initialized..0 }
UnitEntryTable = array [0..9999999] of PackageUnitEntry;
PUnitEntryTable = ^UnitEntryTable;
PackageInfoTable = packed record
UnitCount : Integer; { number of entries in UnitInfo array; always > 0 }
UnitInfo : PUnitEntryTable;
end;
PackageInfo = ^PackageInfoTable;
{ Each package exports a '@GetPackageInfoTable' which can be used to retrieve }
{ the table which contains compiler generated information about the package DLL }
GetPackageInfoTable = function : PackageInfo;
{$IFDEF DEBUG_FUNCTIONS}
{ Inspector Query; implementation in GETMEM.INC; no need to conditionalize that }
THeapBlock = record
Start: Pointer;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -