Show: Delphi C++
Display Preferences

System

From XE2 API Documentation
Jump to: navigation, search

Contents

Contains the Delphi run-time library (RTL) units, classes, functions, types, variables, and constants. Also contains the System.Bindings, System.Generics, and System.Win unit scopes. Note that the System unit scope and the System unit are the same.

Unit Scopes

System.BindingsIs the unit scope for the LiveBindings framework engine. Contains units that implements the LiveBindings engine.
System.Generics
System.Win

Units

SystemContains the Delphi run-time library (RTL) units, classes, functions, types, variables, and constants. Also contains the System.Bindings, System.Generics, and System.Win unit scopes. Note that the System unit scope and the System unit are the same.
System.AnsiStrings
System.Character
System.Classes
System.Contnrs
System.ConvUtils
System.DateUtils
System.Diagnostics
System.HelpIntfs
System.IniFiles
System.Internal.VarHlpr
System.IOUtils
System.Masks
System.MaskUtils
System.Math
System.ObjAuto
System.RegularExpressions
System.RegularExpressionsCore
System.Rtti
System.StdConvs
System.StrUtils
System.SyncObjs
System.SysUtils
System.TimeSpan
System.Types
System.TypInfo
System.UIConsts
System.UITypes
System.VarCmplx
System.VarConv
System.Variants
System.VarUtils
System.WideStrings
System.WideStrUtils
System.Zip
System.ZLibContains the zLib compression library. For more information, see http://www.zlib.net/manual.html


Classes

__IObjCastGUIDHolderFor internal use.
_InterfaceCastHlprFor internal use.
AnsiStringBaseAnsiStringBase is the base class for the C++ analog of the Delphi long string type.
AnsiStringTAnsiStringT is the C++ analog for the Delphi long string type.
AutoCmdAutoCmd represents a command that can be executed by an Automation interface wrapped by a Variant class.
CompRepresents a type for numbers that can be represented with floating-point notation.
CompBaseBase type for Comp.
CurrencyCurrency is the C++ implementation of the Delphi Currency data type.
CurrencyBaseFunctionality wrapper around the Delphi class.
DelphiInterfaceDelphiInterface is a C++ implementation of the Delphi interface.
DynamicArrayDynamicArray is the C++ analog for the Delphi dynamic array type.
DynArrayExceptionBase class for dynamic array exceptions.
DynArrayNullDataThe exception thrown when the array data pointer is found to be NULL.
DynArrayOutOfRangeThe exception thrown when accessing a dynamic array with an out-of-range index.
FunctionFunction represents a method on an Automation interface that returns a value.
IComparableIComparable is the generic interface used to compare two objects.
IDispatchIDispatch is the interface used to support Automation.
IEnumerableIEnumerable is the generic interface for enumerable containers.
IEnumeratorIEnumerator is the generic interface for container enumerators.
IEquatableIEquatable is the generic interface used to check the equality of two objects.
IInterfaceIInterface is the base class for all interfaces defined in Delphi code.
IInvokableIInvokable is the base class for invokable interfaces.
IOleInPlaceFrame
IOleInPlaceUIWindow
IOleWindow
IUnknownIs a special base interface.
NamedParmNamedParm represents a named parameter assigned to a TAutoCmd descendant.
OleVariantOLE-compatible Variant type.
OpenArrayC++ encapsulation of the Delphi Open Array type.
OpenArrayCounterUtility class for open array macros.
OpenArrayCountHlprUtility class for open array macros.
PackageInfoTableA variable of type PackageInfoTable provides information about initializing or finalizing a series of package units.
PackageUnitEntryA variable of type PackageUnitEntry provides information about initializing or finalizing a package unit.
ProcedureProcedure represents a method on an Automation interface that does not return a value.
PropertyGetPropertyGet represents a property access method on an Automation interface.
PropertySetPropertySet represents a property access method on an Automation interface.
SetSet is a C++ template for emulating the set types found in Delphi.
SetBaseBase class for Set.
SmallStringA string with maximum sz characters (sz is a template parameter).
SmallStringBaseBase class for SmallString.
sPointerA type of low overhead smart pointer.
StaticArrayA fixed-length array of T. T is any type.
TAggregatedObjectTAggregatedObject provides the functionality for an inner object of an aggregate by implementing the IInterface methods to delegate to the controlling IInterface.
TCallDescIs the dispatch call descriptor for variants.
TClassTClass defines the metaclass for TObject.
TClassHelperBase
TClassHelperBaseClassDefines the metaclass for TClassHelperBase.
TContainedObjectTContainedObject implements the IInterface interface as an inner object in an aggregate.
TCppAggregatedObjectTCppAggregatedObject is identical to TAggregatedObject, except that IUnknown is already implemented.
TCppInterfacedObjectTCppInterfacedObject is identical to TInterfacedObject, except that IUnknown is already implemented.
TCustomAttributeTCustomAttribute is the base class for all Delphi attributes.
TCVModInfoIs used internally.
TDateTimeTDateTime is the C++ analog for the Delphi TDateTime data type.
TDateTimeBaseBase class for TDateTime.
TDispatchMessageIs a structure with a word field for a message ID.
TDispDescIs a structure used when performing dispinterfaces method calls.
TDoubleRecProvides support for manipulating double precision floating-point values.
TExceptionRecordException information.
TExtended80RecProvides support for manipulating extended precision floating-point values.
TFileRecIs the internal format for typed and untyped files in the Delphi language.
THeapStatusTHeapStatus represents information about the global heap.
TInitContextIs used internally.
TInterfacedClassTInterfacedClass defines the metaclass for TInterfacedObject.
TInterfacedObjectTInterfacedObject is a base for simple classes that need a basic IInterface implementation.
TInterfaceEntryTInterfaceEntry encapsulates the information needed to dispatch interface calls.
TInterfaceTableTInterfaceTable lists the interfaces that a class supports, and PInterfaceTable points to this list.
TLargestVarDataFor internal use.
TLibModuleTLibModule describes a module that is compiled with the application.
TMemoryManagerTMemoryManager defines the memory block entry points.
TMemoryManagerExTMemoryManagerEx defines extended memory block entry points.
TMemoryManagerStateTMemoryManagerState holds statistics about memory allocations.
TMethodStores Code and Data fields to represent a method.
TModuleUnloadRecIs a node in the module unload linked list.
TMonitorTMonitor provides methods for synchronizing the access of several threads to a single object.
TMonitorSupportRepresents a structure that contains a number of function pointers used by the monitor support routines.
TObjectTObject is the ultimate ancestor of all objects and components.
TPackageTypeInfoFor internal use.
TResStringRecRepresents a string resource.
TSingleRecProvides support for manipulating single precision floating-point values.
TSmallBlockTypeStateTSmallBlockTypeState holds statistics about a small memory block.
TTextRecTTextRec is the internal format for text files.
TVarArrayThis is the descriptor type for safe arrays.
TVarArrayBoundGives bound information for one dimension of a safe array.
TVarDataTVarData represents Variant information.
TVariantManagerTVariantManager defines entry points for variant conversion routines and other procedures that define variant behavior.
TVariantTGeneral purpose VARIANT wrapper.
TVarRecTVarRec is used inside a function with an untyped array parameter.
TVarRecordFor internal use.
UnicodeStringUnicodeString is the C++ analog for the Delphi UnicodeString type.
VariantUsed for variables that can change type at run time.
VariantErrorEncapsulates a variant error code.
WideStringWide-character string.

Routines

__currMul__currMul is used internally by the Delphi compiler.
_roundToInt64_roundToInt64 is used internally by the Delphi compiler.
AbsReturns an absolute value.
AcquireExceptionObjectRetains access to the exception object.
AddModuleUnloadProcAddModuleUnloadProc adds a call to your defined routine when a package is unloaded.
AddrReturns a pointer to a specified object.
AllocMemAllocMem allocates a memory block and initializes each byte to zero.
AnsiToUtf8Converts a string encoded in Ansi to UTF-8.
AppendPrepares an existing file for adding text to its end.
ArcTanCalculates the arctangent of a given number.
AssertTests whether a Boolean expression is true.
AssignAssociates the name of an external file with a file variable.
AssignedTests for a nil (unassigned) pointer or procedural variable.
AssignFileAssociates the name of an external file with a file variable.
AttemptToUseSharedMemoryManagerAttempts to use a shared memory manager.
BeginThreadSpawns a separate thread of execution.
BlockReadReads one or more records from an open file into a variable.
BlockWriteWrites one or more records from a variable to an open file.
BreakCauses the flow of control to exit a for, while, or repeat statement.
ChDirChanges the current directory.
CheckSafecallResult
ChrReturns the character for a specified ASCII value.
CloseTerminates the association between a file variable and an external file.
CloseFileTerminates the association between a file variable and an external disk file.
CompToCurrencyConverts a Comp value to a Currency value.
CompToDoubleConverts a Comp value to a double value.
ConcatConcatenates two or more strings into one.
ContinueAllows the flow of control to proceed to the next iteration of for, while, or repeat statements.
CopyReturns a substring of a string or a segment of a dynamic array.
CopyArrayCopies an array whose elements' type is specified by the TypeInfo variable.
CosCalculates the cosine of an angle.
CurrencyToCompConverts a Currency value to a Comp value.
DecDecrements a variable by 1 or N.
DeleteRemoves a substring from a string.
DisposeReleases the memory allocated for a dynamic variable.
DoubleToCompConverts a double value to a Comp.
DynArrayBoundsReturns the bounds of a DynamicArray.
DynArrayClearClears a dynamic array.
DynArrayDimReturns the number of dimensions of a dynamic array.
DynArrayIndexReturns a pointer to a specific dynamic array element.
DynArraySetLengthResizes a dynamic array.
DynArraySizeReturns the size of a dynamic array.
EndThreadTerminates the execution of a thread.
EnumModulesExecutes a callback for all the modules in an application.
EnumResourceModulesExecutes a callback for all resource modules in an application.
EofTests whether the file position is at the end of a file.
EolnTests whether the file pointer is at the end of a line.
EraseDeletes an external file.
ErrorError is used to generate a run-time exception.
ExceptAddrReturns the address at which the current exception was raised.
ExceptObjectReturns the current exception object.
ExcludeRemoves an element from a Delphi set.
ExitExits from the current procedure.
ExpReturns the exponential of X.
ExpMinus1

Returns eX-1.

FailCancels the construction of an object (Turbo Pascal object model).
FilePosReturns the current file position.
FileSizeReturns the number of records in a file.
FillCharFills contiguous bytes with a specified value.
FinalizeUninitializes a dynamically-allocated variable.
FinalizeArrayCompiler helper for array finalization.
FindClassHInstanceReturns the instance handle for the module in which a class type is defined.
FindDynaInst
FindHInstanceReturns the instance handle of the module that contains a specified address.
FindResourceLocates a resource in a module.
FindResourceHInstanceReturns the instance handle of the resource module associated with a specified HInstance.
FlushEmpties the buffer of a text file opened for output.
FPower10Deprecated. Consider Power10 instead.
FracReturns the fractional part of a real number.
FreeMemFreeMem frees a memory block previously allocated with GetMem.
FreeMemoryFreeMemory frees a memory block previously allocated with GetMemory.
FreeResourceReturns True.
Get8087CWReturns the value of the 8087 control word.
GetDirReturns the current directory.
GetDynaMethodFor internal use.
GetHeapStatusReturns the current status of the memory manager.
GetLastErrorReturns the last error reported by an operating system API call.
GetLocaleOverrideReturns the locale override for the application specified by the AppName parameter.
GetMemGetMem allocates a memory block.
GetMemoryGetMemory allocates a memory block.
GetMemoryManagerReturns the entry points of the currently installed memory manager.
GetMemoryManagerStateFetches state information for the Memory Manager.
GetMemoryMapFetches the memory map.
GetMinimumBlockAlignmentGets the minimum memory block alignment.
GetMXCSR

Returns the value of the MXCSR register.

GetResourceModuleNameReturns the localized name for a module.
GetTextCodePageGets the code page of a text file.
GetUILanguagesGetUILanguages returns a list of UI languages.
GetVariantManagerReturns the entry points of the routines that define variant behavior.
HaltInitiates the abnormal termination of a program.
HiReturns the high-order byte of X as an unsigned value.
HighReturns the highest value in the range of an argument.
IncIncrements an ordinal value by 1 or N.
IncludeAdds an element to a Delphi set.
InitializeInitializes a dynamically allocated variable.
InitializeArrayInitializes the elements of a dynamic array.
InsertInserts a substring into a string, beginning at a specified position.
IntReturns the integer part of a real number.
IntToStrConverts an integer to a string.
IOResultReturns the status of the last I/O operation performed.
IsDynArrayRectangularReturns whether a dynamic array is rectangular.
IsMemoryManagerSetIndicates whether the memory manager has been overridden using the SetMemoryManager procedure.
IsVariantManagerSetIndicates whether variant support is implemented in an application.
LengthReturns the number of characters in a string or of elements in an array.
LnReturns the natural logarithm of a real expression.
LnXPlus1

Returns ln(X+1).

LoReturns the low-order Byte of argument X.
LoadResourceReturns a handler to the data of a resource.
LoadResourceModuleLoads a resource module by a given name.
LoadResourceString
LoadResStringLoads a string from a resource.
LocaleCharsFromUnicodeMaps a wide string to a new string.
LockResourceReturns a pointer to a resource.
LowReturns the lowest value in a range.
MarkMark is no longer used.
MemoryBarrierEnforces an ordering constraint on memory operations.
MkDirCreates a new subdirectory.
MonitorEnterProhibits the access of all other threads but the calling one to the specified object.
MonitorExitReleases a lock of the calling thread on the specified object.
MonitorPulseNotifies the next thread in the waiting queue that it will be able to lock the specified object as soon as the calling thread releases it.
MonitorPulseAllSignals all threads in the waiting queue that each one of them will be able to lock the specified object as soon as the calling thread releases it.
MonitorTryEnterAttempts to lock the specified object, so that only the calling thread is able to access it.
MonitorWaitDrops the lock on the specified object and puts the calling thread in the waiting queue for a specified amount of time.
MoveCopies bytes from a source to a destination.
MoveCharsCopies bytes from a source to a destination.
NewCreates a new dynamic variable and sets P to point to it.
OddReturns True if argument is an odd number.
OleStrToStringCopies data received from a COM interface to a string.
OleStrToStrVarCopies a string from its COM representation to an existing Delphi string.
OrdReturns the ordinal value of an ordinal-type expression.
ParamCountReturns the number of parameters passed on the command line.
ParamStrReturns a specified parameter from the command line.
PiReturns 3.1415926535897932385.
PosReturns the index value of the first character in a specified substring that occurs in a given string.
Power10Returns the value of given floating-point value scaled by a power of 10.
PredReturns the predecessor of the argument.
PtrConverts a specified address to a pointer.
PUCS4CharsConverts a UCS4 string to a null-terminated array of UCS4 characters.
RaiseListRaiseList is used internally by the Delphi compiler.
RandomGenerates random numbers within a specified range.
RandomizeInitializes the random number generator with a random value.
ReadReads data from a file.
ReadlnReads a line of text from a file.
ReallocMemReallocMem reallocates a memory block.
ReallocMemoryReallocMemory resizes a memory block.
RegisterExpectedMemoryLeakRegisters an expected memory leak.
RegisterModuleRegisters the specified module.
ReleaseRelease is no longer used.
ReleaseExceptionObjectReleases an exception object acquired by AcquireExceptionObject.
RemoveModuleUnloadProcRemoveModuleUnloadProc removes a call to your defined routine when a package is unloaded.
RenameChanges the name of an external file.
ResetOpens an existing file.
Reset8087CWSets the 8087 (FPU) control word to Default8087CW.
ResetMXCSRResets the SSE MXCSR register to the default value.
RewriteCreates a new file and opens it.
RmDirDeletes an empty subdirectory.
RoundReturns the value of X rounded to the integer number.
RunErrorStops execution and generates a run-time error.
SeekMoves the current position of a file to a specified component.
SeekEofReturns the end-of-file status of a file, ignoring whitespace.
SeekEolnReturns the end-of-line status of a file, ignoring whitespace.
Set8087CWSets the FPU control word.
SetAnsiStringSets the contents and length of the given AnsiString.
SetCodePageSets the code page for a RawByteString type variable.
SetInOutResSets the value of the IO error code.
SetLastErrorSetLastError sets the last API error code.
SetLengthSets the length of a string or dynamic array variable.
SetLineBreakStyleDetermines the end-of-line and end-of-file conventions for text file I/O.
SetLocaleOverrideSets locale override.
SetMemoryManagerSets the entry points of the memory manager.
SetMinimumBlockAlignmentSets the minimum memory block alignment.
SetMultiByteConversionCodePageSets the code page used internally whenever multibyte characters are converted to/from WideChar.
SetMXCSRSets the MXCSR register in the SSE.
SetRaiseListSetRaiseList is used internally by the Delphi compiler.
SetStringSets the contents and length of the given string.
SetTextBufAssigns an I/O buffer to a text file.
SetTextCodePageSets the code page of a text file.
SetVariantManagerSets the entry points of the routines that define variant behavior.
ShareMemoryManagerShares the module's memory manager.
SinReturns the sine of the angle, in radians.
SineCosine

Returns sin(X) and cos(X).

SizeOfReturns the number of bytes occupied by a variable or type.
SizeofResourceReturns the size of a resource, in bytes.
SliceReturns a subsection of an array.
SqrReturns the square of a number.
SqrtReturns the square root of X.
StrFormats a string and returns it to a variable.
StringCodePageReturns the code page associated with the string.
StringElementSizeReturns the number of bytes that represent a character in the string.
StringOfCharReturns a string with a specified number of repeating characters.
StringRefCountReturns the reference count of a string.
StringToOleStrAllocates memory and copies an AnsiString string to the OLE format.
StringToWideCharReturns a UNICODE string from an AnsiString.
SuccReturns the successor of an argument.
SwapExchanges the high-order byte with the low-order byte of a 16-bit integral value (word).
SysAllocMemReturns a pointer to a specified number of bytes.
SysFreeMemFrees the memory pointed to by a specified pointer.
SysGetMemAllocates a specified number of bytes and returns a pointer to them.
SysReallocMemReturns a pointer to a specified number of bytes, preserving the values pointed to by the Pointer parameter.
SysRegisterExpectedMemoryLeakRegisters expected memory leaks.
SysUnregisterExpectedMemoryLeakRemoves expected memory leaks.
Tangent

Returns tan(X).

TextStartTextStart is used internally by the Delphi compiler.
TruncTruncates a real number to an integer.
TruncateDeletes all the records after the current file position.
TypeHandleReturns the RTTI information for a given type.
TypeInfoReturns the RTTI information for a given type.
TypeOfTypeOf is deprecated.
UCS4StringToUnicodeStringConverts a UCS-4 encoded string to a Unicode string.
UCS4StringToWideStringConverts a string of 4-byte Unicode characters to a WideString value.
UnicodeFromLocaleCharsMaps a string to a wide string.
UnicodeStringToUCS4StringConverts a Unicode string to its UCS-4 encoded representation.
UnicodeToUtf8Converts a string of Unicode characters into a UTF-8 string.
UniqueStringEnsures that a given string has a reference count of one.
UnlockResourceReturns False.
UnregisterExpectedMemoryLeakUnregisters an expected memory leak.
UnregisterModuleUnregisters the specified module.
UpCaseConverts a character to uppercase.
UTF8DecodeConverts a UTF8 string to a Unicode string (WideString).
UTF8EncodeConverts a WideString value to a UTF8 string.
UTF8EncodeToShortStringConverts a string to its UTF-8 encoded representation.
Utf8ToAnsiConverts a UTF8 string to a string of Ansi characters.
UTF8ToStringConverts a UTF-8 encoded string to a string.
Utf8ToUnicodeConverts a string of UTF-8 characters to a Unicode string.
UTF8ToUnicodeStringConverts a UTF-8 encoded string to a Unicode string.
UTF8ToWideStringConverts a UTF-8 encoded string to a WideString.
ValConverts a string to a numeric representation.
VarArrayRedimResizes a Variant array.
VarCastConverts a variant to a specified type.
VarClearEmpties a Variant so that it is unassigned.
VarCopyCopies a Variant to another Variant.
WideCharLenToStringConverts WideString characters to UnicodeString.
WideCharLenToStrVarWideCharLenToStrVar converts WideString characters to UnicodeString or AnsiString.
WideCharToStringConverts null-terminated WideString strings to UnicodeString.
WideCharToStrVarConverts WideString strings to UnicodeString.
WideCharToUCS4StringConverts a sequence of wide characters to a UCS4 string.
WideStringToUCS4StringConverts a WideString value to a string of 4-byte Unicode characters.
WriteWrites to either a typed file or a text file.
WritelnWrites to a text file and adds an end-of-line marker.
YieldProcessorProvides the processor with a hint displaying that the current code is in a spin loop.

Types

_DCHARAlias for WideChar.
_di_IComparableDelphi interface of IComparable.
_di_IDispatchDelphi interface of IDispatch.
_di_IEnumerableDelphi interface of IEnumerable.
_di_IEnumeratorDelphi interface of IEnumerator.
_di_IInterfaceDelphi interface of IInterface.
_di_IStreamDelphi interface of IStream.
_di_IUnknownDelphi interface of IUnknown.
AnsiCharRepresents a byte-sized (8-bits) character type.
AnsiStringRepresents a dynamically allocated string whose maximum length is limited only by available memory.
BooleanRepresents the preferred predefined Boolean type.
ByteRepresents a 8-bit unsigned integer type.
ByteBoolRepresents an 8-bit predefined Boolean type.
CardinalRepresents an unsigned 32-bit integer type.
CharRepresents a word-sized (16-bits) character type.
CompRepresents a type for numbers that can be represented with floating-point notation.
CompReturnC++ return type for Pascal functions that have Comp result type.
CppLongIntIs an alias for LongInt.
CppULongIntIs an alias for LongWord.
CurrencyCurrency is the C++ implementation of the Delphi Currency data type.
DoubleRepresents a double-precision floating-point value.
DWordInteger type with the range [0; 4294967295].
ExtendedRepresents a high-precision floating-point value.
Extended80For internal use only.
fileRepresents the C++ analog of a Delphi file type.
GetPackageInfoTableRepresents a function used to retrieve a table of compiler-generated information.
HGLOBALRepresents a handle to a loaded Windows resource.
HINSTIs a handle to a loaded Windows resource.
HMODULEIs a Windows module instance handle.
HResultHResult is the return type for functions that return an error code.
HRSRCIs a Windows resource handle.
Int16Alias for Smallint.
Int32Alias for Integer.
Int64Defines a 64-bit signed integer type.
Int64ArrayRepresents a very large array of Int64 values.
Int8Alias for ShortInt.
IntegerRepresents a signed 32-bit integer type.
IntegerArrayIs an array of integers.
IntPtrRepresents an integer whose value is a pointer.
LargeintInteger type with the range [-263; 263-1].
LongBoolRepresents a 32-bit predefined Boolean type.
LongintInteger type with the range [-2147483648; 2147483647].
LongWordDefines a 32-bit unsigned integer type.
NativeIntDefines a platform-dependent signed integer.
NativeUIntDefines a platform-dependent unsigned integer.
OleVariantOLE-compatible Variant type.
OpenstringString type designed to pass strings as parameters.
PackageInfoIs a pointer to a PackageInfoTable variable.
PackageInfoTableA variable of type PackageInfoTable provides information about initializing or finalizing a series of package units.
PackageUnitEntryA variable of type PackageUnitEntry provides information about initializing or finalizing a package unit.
PAnsiCharDefines a null-terminated ANSI string.
PAnsiStringIs a pointer to an AnsiString.
PBooleanIs a pointer to a Boolean.
PByteIs a pointer to a Byte.
PCallDescIs a pointer to a TCallDesc value.
PCardinalIs a pointer to a Cardinal.
PCharDefines a null-terminated string.
PCompIs a pointer to a Comp.
PCurrencyIs a pointer to a Currency.
PCVModInfoIs a pointer to a TCVModInfo.
PDateIs a pointer to a Date.
PDateTimeIs a pointer to a TDateTime.
PDispatchIs a pointer to an IDispatch.
PDispDescIs a pointer to a TDispDesc.
PDoubleIs a pointer to a Double.
PDoubleRecPointer to TDoubleRec.
PDynArrayTypeInfoIs a pointer to a TDynArrayTypeInfo.
PErrorIs a pointer to a LongWord.
PExceptionRecordPointer to a TExceptionRecord.
PExtendedIs a pointer to an Extended.
PExtended80RecPointer to TExtended80Rec.
PExtendedRecPointer to TExtendedRec.
PGUIDIs a pointer to a TGUID.
PInitContextIs a pointer to a TInitContext.
PInt64Is a pointer to an Int64.
PInt64ArrayPointer to Int64Array.
PIntegerIs a pointer to an Integer.
PIntegerArrayIs a pointer to an IntegerArray.
PInterfaceEntryIs a pointer to a TInterfaceEntry.
PInterfaceTableIs a pointer to a TInterfaceTable.
PLibModuleIs a pointer to a TLibModule variable.
PLongBoolPointer to a LongBool.
PLongintIs a pointer to a LongInt.
PLongWordIs a pointer to a LongWord.
PMemoryManagerIs a pointer to a TMemoryManager.
PMemoryManagerExIs a pointer to a TMemoryManagerEx.
PModuleUnloadRecIs a pointer to a TModuleUnloadRec.
PMonitorIs a pointer to a TMonitor.
PMonitorSupportIs a pointer to a TMonitorSupport.
PNativeIntPointer to a NativeInt native signed integer.
PNativeUIntPointer to a NativeUInt native unsigned integer.
PointerAddress of a byte in memory.
PointerArrayIs an array of pointers.
POleVariantIs a pointer to a OleVariant.
PPackageTypeInfoFor internal use.
PPAnsiCharIs a pointer to a PAnsiChar.
PPCharIs a pointer to a PWideChar.
PPCharArrayIs a pointer to a TPCharArray.
PPDispatchIs a pointer to a PDispatch.
PPMonitorIs a pointer to a PMonitor.
PPointerRepresents a pointer to a Pointer.
PPointerArrayIs a pointer to a PointerArray.
PPUnknownIs a pointer to a PUnknown.
PPWideCharIs a pointer to a PWideChar.
PRawByteStringIs a pointer to a RawByteString.
PResStringRecIs a pointer to a TResStringRec.
PShortIntIs a pointer to a ShortInt.
PShortStringIs a pointer to a ShortString.
PSingleIs a pointer to a Single.
PSingleRecPointer to TSingleRec.
PSmallIntIs a pointer to a SmallInt.
PStringIs a pointer to a String.
PTextBufIs a pointer to a TTextBuf.
PTypeTableFor internal use.
PUCS2CharIs an alias for PWideChar.
PUCS4CharIs a pointer to a UCS4Char.
PUCS4CharArrayIs a pointer to a TUCS4CharArray.
PUInt64Pointer to UInt64.
PUnicodeStringIs a pointer to a UnicodeString.
PUnitEntryTableIs a pointer to a UnitEntryTable.
PUnknownIs a pointer to an IUnknown.
PUTF8StringPUTF8String is a pointer to a UTF8String.
PVarArrayIs a pointer type to a TVarArray.
PVarArrayBoundPointer to TVarArrayBound.
PVarArrayBoundArrayIs a pointer to a TVarArrayBoundArray.
PVarArrayCoorArrayIs a pointer type to a TVarArrayCoorArray.
PVarDataPointer to a TVarData.
PVariantIs a pointer to a Variant.
PVariantManagerIs a pointer to a TVariantManager.
PVarRecIs a pointer to a TVarRec.
PVarRecordPointer to TVarRecord.
PWideCharDefines a null-terminated Unicode string.
PWideStringIs a pointer to a WideString.
PWordIs a pointer to a Word.
PWordBoolIs a pointer to a WordBool.
RawByteStringEnables the passing of string data of any code page without doing any codepage conversions.
RealRepresents a double-precision floating-point value.
Real48Represents a type for numbers that can be represented with floating-point notation.
ResourceString
SAFEARRAYMultidimensional array for COM technology.
ShortintInteger type with the range [-128; 127].
ShortStringRepresents a string whose maximum length is 255 characters.
ShortStringBaseFor internal use.
SingleRepresents a single-precision floating-point value.
SmallintInteger type with the range [-32768; 32767].
StringRepresents an alias for the generic UnicodeString type.
SystemVisibility classes.
TAssertErrorProcSpecifies a routine called upon an assertion failure.
TBooleanDynArrayIs a dynamic array of Boolean.
TBoundArrayRepresents an array of NativeInt integers with array bound information.
TByteDynArrayIs a dynamic array of Bytes.
TCallDescIs the dispatch call descriptor for variants.
TCardinalDynArrayIs a dynamic array of Cardinal.
TChunkStatusTChunkStatus enumerates the possible states of a chunk of memory.
TCVModInfoIs used internally.
TDateIs used to represent a date.
TDateTimeTDateTime is the C++ analog for the Delphi TDateTime data type.
TDispatchMessageIs a structure with a word field for a message ID.
TDispDescIs a structure used when performing dispinterfaces method calls.
TDLLProcIs used internally.
TDLLProcExIs used internally.
TDoubleDynArrayIs a dynamic array of Double.
TDoubleRecProvides support for manipulating double precision floating-point values.
TDynArrayTypeInfoRepresents the type information of a dynamic array.
TEnumModuleFuncIs the type of the callback function used in module enumeration.
TEnumModuleFuncLWTEnumModuleFuncLW is the type of the callback function used in module enumeration.
TExceptClsProcType of pointer to function.
TExceptionRecordException information.
TExceptObjProcType of pointer to function.
TextRepresents the C++ analog of the Delphi text data type.
TExtended80RecProvides support for manipulating extended precision floating-point values.
TExtendedRecAlias to TExtended80Rec.
TextFileAlias for the Text type.
TFileIOFuncIs used internally.
TFileRecIs the internal format for typed and untyped files in the Delphi language.
TFloatSpecialRepresents special floating-point values.
TGUIDTGUID is a structured form of the value that uniquely identifies an interface.
THandleTHandle is a general purpose data reference (handle).
THeapStatusTHeapStatus represents information about the global heap.
TInitContextIs used internally.
TInt64DynArrayIs a dynamic array of Int64.
TInt8DynArray

Represents a dynamic array of System.Int8.

TIntegerDynArrayIs a dynamic array of Integer.
TInterfacedClassTInterfacedClass defines the metaclass for TInterfacedObject.
TInterfaceEntryTInterfaceEntry encapsulates the information needed to dispatch interface calls.
TInterfaceTableTInterfaceTable lists the interfaces that a class supports, and PInterfaceTable points to this list.
TLargestVarDataFor internal use.
TLibModuleTLibModule describes a module that is compiled with the application.
TLongWordDynArrayIs a dynamic array of LongWord.
TMemoryManagerTMemoryManager defines the memory block entry points.
TMemoryManagerExTMemoryManagerEx defines extended memory block entry points.
TMemoryManagerStateTMemoryManagerState holds statistics about memory allocations.
TMemoryMapIs a map of an application's address space as an array of TChunkStatus values.
TMethodStores Code and Data fields to represent a method.
TMinimumBlockAlignmentTMinimumBlockAlignment defines the mimimum byte alignment for memory block allocation.
TModuleUnloadProcTModuleUnloadProc defines a procedure that can be called during package unload.
TModuleUnloadProcLWTModuleUnloadProcLW defines a procedure that can be called during package unload.
TModuleUnloadRecIs a node in the module unload linked list.
TMonitorTMonitor provides methods for synchronizing the access of several threads to a single object.
TMonitorSupportRepresents a structure that contains a number of function pointers used by the monitor support routines.
TPackageTypeInfoFor internal use.
TPCharArrayRepresents an array of null-terminated strings.
TRaiseExceptionProcType of pointer to procedure.
TRaiseExceptObjProcType of pointer to procedure.
TResourceHandleIs an alias for HRSRC.
TResStringRecRepresents a string resource.
TRuntimeErrorIs an enumeration of internal run-time error codes.
TSafeCallErrorProcIs a procedural type used when registering a routine.
TShortIntDynArrayIs a dynamic array of ShortInt.
TSingleDynArrayIs a dynamic array of Single.
TSingleRecProvides support for manipulating single precision floating-point values.
TSmallBlockTypeStateTSmallBlockTypeState holds statistics about a small memory block.
TSmallBlockTypeStatesTSmallBlockTypeStates is an array of TSmallBlockTypeState.
TSmallIntDynArrayIs a dynamic array of SmallInt.
TStringDynArrayIs a dynamic array of String.
TSystemThreadEndProcRepresents a procedural type used when defining a global routine that is called whenever a system thread ends.
TSystemThreadFuncProcRepresents a procedural type used when defining a global routine that is called whenever a system thread is started.
TTextBufIs used internally.
TTextIOFuncIs used internally.
TTextLineBreakStyleTTextLineBreakStyle indicates the default set of characters used to divide lines in text.
TTextRecTTextRec is the internal format for text files.
TThreadFuncTThreadFunc is a pointer to the starting address of a routine for a new thread of execution.
TThreadIDA thread's ID.
TTimeTTime is used to represent a time.
TTypeTableFor internal use.
TUCS4CharArrayRepresents an array of UCS4 characters.
TVarArrayThis is the descriptor type for safe arrays.
TVarArrayBoundGives bound information for one dimension of a safe array.
TVarArrayBoundArrayGives bound information for all the dimensions of a safe array.
TVarArrayCoorArrayGives the position of an element in a safe array.
TVarDataTVarData represents Variant information.
TVariantVARIANT wrapper.
TVariantManagerTVariantManager defines entry points for variant conversion routines and other procedures that define variant behavior.
TVarOpTVarOp defines a Variant operation.
TVarRecTVarRec is used inside a function with an untyped array parameter.
TVarRecordFor internal use.
TVarTypeIs a variant type code.
TVisibilityClassesTVisibilityClasses enumerates the possible visibility classes for extended RTTI information.
TWideStringDynArrayIs a dynamic array of WideString.
TWordDynArrayIs a dynamic array of Word.
UCS2CharAlias for WideChar.
UCS4CharUCS4Char is used for working with 4–byte Unicode characters.
UCS4StringUCS4String is used for working with 4–byte Unicode characters.
UInt16Alias for Word.
UInt32Alias for Cardinal.
UInt64Defines a 64-bit unsigned integer type.
UInt8Alias for Byte.
UIntPtrRepresents an unsigned integer whose value is a pointer.
UnicodeStringUnicodeString is the C++ analog for the Delphi UnicodeString type.
UnitEntryTableUnitEntryTable is an array type with entries of type PackageUnitEntry.
UTF8StringUTF8String represents UTF-8 encoded Unicode strings.
VariantUsed for variables that can change type at run time.
WideCharRepresents a word-sized (16-bits) character type.
WideStringWide-character string.
WordRepresents a 16-bit unsigned integer type.
WordBoolRepresents a 16-bit predefined Boolean type.

Variables

AbstractErrorProcAbstractErrorProc defines a callback routine for abstract method call errors.
AllocMemCountRepresents the total number of allocated memory blocks in a Delphi application.
AllocMemSizeRepresents the total size of allocated memory blocks.
AlternateWriteUnicodeStringProc
AssertErrorProcPoints to the assertion error-handler.
CmdLinePoints to the command-line arguments specified when the application is invoked.
CmdShowSpecifies the flags for displaying the application's main window.
CPUCountRepresents the number of CPU cores detected.
DebugHookDebugHook is set if an application is running under the IDE debugger.
Default8087CWSpecifies the Default 8087 control word.
DefaultMXCSRThe default value of the MXCSR register.
DefaultSystemCodePageRepresents the default code page.
DefaultTextLineBreakStyleSpecifies the characters that are used by default to separate lines in text.
DefaultUnicodeCodePageRepresents the default code page for a string.
DispCallByIDProcDispCallByIDProc contains the address of a function.
ErrorAddrContains the address of a statement causing a run-time error.
ErrorProcPoints to the RTL run-time error handler.
ErrOutputErrOutput specifies a write-only Text file associated with the process's error output file.
ExceptClsProcExceptClsProc defines a pointer to a function called during exception handling.
ExceptionAcquiredRepresents a notification that a given exception object has been acquired.
ExceptionClassRepresents the exception base class.
ExceptObjProcExceptObjProc defines a pointer to a function called during exception handling.
ExceptProcPoints to the lowest-level exception handler.
ExitCodeContains the application's exit code.
ExitProcPoints to a program's exit procedure (provided for backward compatibility).
ExitProcessProcSpecifies the last procedure to execute before the application shuts down.
FileModeIndicates the access mode on typed and untyped files opened by the Reset procedure.
HeapAllocFlagsIndicates how the memory manager obtains memory from the operating system.
HPrevInstIndicates the handle of the previous instance.
InitProcInitProc is the last installed initialization procedure.
InputSpecifies a read-only Text file associated with the process' standard Input file.
Int64ArrayRepresents a very large array of Int64 values.
IntegerArrayIs an array of integers.
IsConsoleIndicates whether the module was compiled as a console application.
IsLibraryIndicates whether the module is a shared library.
IsMultiThreadIndicates whether the application spawned additional threads using BeginThread or TThread objects.
JITEnableControls when the just-in-time debugger is called.
LibModuleListLists module records for enumeration procedures.
MainInstanceIndicates the instance handle for the main executable.
MainThreadIDIndicates the instance handle for the current module's main thread of execution.
ModuleUnloadListRepresents a list of unload procedures.
MonitorSupportPointer to a set of function pointers.
NeverSleepOnMMThreadContentionDictates memory manager behavior during a thread contention.
NoErrMsgControls whether the application displays an error message when a run-time error occurs.
OutputSpecifies a write-only Text file associated with the process' standard output file.
PointerArrayIs an array of pointers.
RaiseExceptionProcPoints to the RaiseException Windows function.
RaiseExceptObjProcRepresents a notification on the raise of an exception object.
RandSeedRandSeed stores the built-in random number generator's seed.
ReportMemoryLeaksOnShutdownReport memory leaks on shutdown.
RTLUnwindProcIs used internally.
SafeCallErrorProcSafeCallErrorProc defines a procedure that is called when a safecall routine incurs an error.
SystemThreadEndProcVariable set during the startup code.
SystemThreadFuncProcVariable set during the startup code.
TArrayDefines a generic array.
TBoundArrayRepresents an array of NativeInt integers with array bound information.
Test8086Represents the CPU family.
Test8087Represents the FPU family.
TestFDIVSpecifies whether the floating-point division operation is flawed.
TestSSE
TMemoryMapIs a map of an application's address space as an array of TChunkStatus values.
TPCharArrayRepresents an array of null-terminated strings.
TSmallBlockTypeStatesTSmallBlockTypeStates is an array of TSmallBlockTypeState.
TTextBufIs used internally.
TTypeTableFor internal use.
TUCS4CharArrayRepresents an array of UCS4 characters.
TVarArrayBoundArrayGives bound information for all the dimensions of a safe array.
TVarArrayCoorArrayGives the position of an element in a safe array.
UCS4StringUCS4String is used for working with 4–byte Unicode characters.
UnitEntryTableUnitEntryTable is an array type with entries of type PackageUnitEntry.
UTF8CompareLocaleSpecifies the locale used when comparing two strings.
VarAddRefProcThe VarAddRefProc variable is used internally.
VarClearProcThe VarClearProc variable is used internally.
VarCopyProcThe VarCopyProc variable is used internally.
VarToLStrProcThe VarToLStrProc variable is used internally.
VarToUStrProcFor internal use.
VarToWStrProcThe VarToWStrProc variable is used internally.

Constants

CompilerVersionCompilerVersion: Extended = 23;
CPUi386CPUi386: Integer = 2;
CPUi486CPUi486: Integer = 3;
CPUPentiumCPUPentium: Integer = 4;
csAllocatedcsAllocated: TChunkStatus = csAllocated;
csReservedcsReserved: TChunkStatus = csReserved;
csSysAllocatedcsSysAllocated: TChunkStatus = csSysAllocated;
csSysReservedcsSysReserved: TChunkStatus = csSysReserved;
csUnallocatedcsUnallocated: TChunkStatus = csUnallocated;
DefaultFieldRttiVisibilityDefaultFieldRttiVisibility: Set = [vcPrivate..vcPublished];
DefaultMethodRttiVisibilityDefaultMethodRttiVisibility: Set = [vcPublic..vcPublished];
DefaultPropertyRttiVisibilityDefaultPropertyRttiVisibility: Set = [vcPublic..vcPublished];
E_NOINTERFACEE_NOINTERFACE: HRESULT = $80004002;
E_NOTIMPLE_NOTIMPL: HRESULT = $80004001;
E_UNEXPECTEDE_UNEXPECTED: HRESULT = $8000FFFF;
FalseFalse: Boolean = False;
fmClosedfmClosed: Word = $D7B0;
fmInOutfmInOut: Word = $D7B3;
fmInputfmInput: Word = $D7B1;
fmOutputfmOutput: Word = $D7B2;
fsDenormalfsDenormal: TFloatSpecial = fsDenormal;
fsInffsInf: TFloatSpecial = fsInf;
fsNaNfsNaN: TFloatSpecial = fsNaN;
fsNDenormalfsNDenormal: TFloatSpecial = fsNDenormal;
fsNegativefsNegative: TFloatSpecial = fsNegative;
fsNInffsNInf: TFloatSpecial = fsNInf;
fsNZerofsNZero: TFloatSpecial = fsNZero;
fsPositivefsPositive: TFloatSpecial = fsPositive;
fsZerofsZero: TFloatSpecial = fsZero;
hfFieldSizehfFieldSize: Integer = 4;
hfMonitorOffsethfMonitorOffset: Integer = 0;
INFINITEINFINITE: Cardinal = $FFFFFFFF;
MaxIntMaxInt: Integer = $7FFFFFFF;
MaxLongintMaxLongint: Integer = $7FFFFFFF;
mba16Bytemba16Byte: TMinimumBlockAlignment = mba16Byte;
mba8Bytemba8Byte: TMinimumBlockAlignment = mba8Byte;
NumSmallBlockTypesNumSmallBlockTypes: Integer = $37;
opAddopAdd: Integer = 0;
opAndopAnd: Integer = 8;
opCmpEQopCmpEQ: Integer = $E;
opCmpGEopCmpGE: Integer = $13;
opCmpGTopCmpGT: Integer = $12;
opCmpLEopCmpLE: Integer = $11;
opCmpLTopCmpLT: Integer = $10;
opCmpNEopCmpNE: Integer = $F;
opCompareopCompare: Integer = $B;
opDivideopDivide: Integer = 3;
opIntDivideopIntDivide: Integer = 4;
opModulusopModulus: Integer = 5;
opMultiplyopMultiply: Integer = 2;
opNegateopNegate: Integer = $C;
opNotopNot: Integer = $D;
opOropOr: Integer = 9;
opShiftLeftopShiftLeft: Integer = 6;
opShiftRightopShiftRight: Integer = 7;
opSubtractopSubtract: Integer = 1;
opXoropXor: Integer = $A;
reAccessViolationreAccessViolation: TRuntimeError = reAccessViolation;
reAssertionFailedreAssertionFailed: TRuntimeError = reAssertionFailed;
reControlBreakreControlBreak: TRuntimeError = reControlBreak;
reDivByZeroreDivByZero: TRuntimeError = reDivByZero;
reExternalExceptionreExternalException: TRuntimeError = reExternalException;
reIntfCastErrorreIntfCastError: TRuntimeError = reIntfCastError;
reIntOverflowreIntOverflow: TRuntimeError = reIntOverflow;
reInvalidCastreInvalidCast: TRuntimeError = reInvalidCast;
reInvalidOpreInvalidOp: TRuntimeError = reInvalidOp;
reInvalidPtrreInvalidPtr: TRuntimeError = reInvalidPtr;
reMonitorNotLockedreMonitorNotLocked: TRuntimeError = reMonitorNotLocked;
reNoMonitorSupportreNoMonitorSupport: TRuntimeError = reNoMonitorSupport;
reNonereNone: TRuntimeError = reNone;
reOutOfMemoryreOutOfMemory: TRuntimeError = reOutOfMemory;
reOverflowreOverflow: TRuntimeError = reOverflow;
rePlatformNotImplementedrePlatformNotImplemented: TRuntimeError = rePlatformNotImplemented;
rePrivInstructionrePrivInstruction: TRuntimeError = rePrivInstruction;
reRangeErrorreRangeError: TRuntimeError = reRangeError;
reSafeCallErrorreSafeCallError: TRuntimeError = reSafeCallError;
reStackOverflowreStackOverflow: TRuntimeError = reStackOverflow;
reUnderflowreUnderflow: TRuntimeError = reUnderflow;
reVarArrayBoundsreVarArrayBounds: TRuntimeError = reVarArrayBounds;
reVarArrayCreatereVarArrayCreate: TRuntimeError = reVarArrayCreate;
reVarDispatchreVarDispatch: TRuntimeError = reVarDispatch;
reVarInvalidOpreVarInvalidOp: TRuntimeError = reVarInvalidOp;
reVarNotArrayreVarNotArray: TRuntimeError = reVarNotArray;
reVarTypeCastreVarTypeCast: TRuntimeError = reVarTypeCast;
reZeroDividereZeroDivide: TRuntimeError = reZeroDivide;
RTLVersionRTLVersion: Comp = 23;
S_FALSES_FALSE: Integer = 1;
S_OKS_OK: Integer = 0;
sLineBreaksLineBreak: AnsiString = ;
tfCRLFtfCRLF: Integer = 1;
tlbsCRLFtlbsCRLF: TTextLineBreakStyle = tlbsCRLF;
tlbsLFtlbsLF: TTextLineBreakStyle = tlbsLF;
TrueTrue: Boolean = True;
varAnyvarAny: Integer = $101;
varArrayvarArray: Integer = $2000;
varBooleanvarBoolean: Integer = $B;
varByRefvarByRef: Integer = $4000;
varBytevarByte: Integer = $11;
varCurrencyvarCurrency: Integer = 6;
varDatevarDate: Integer = 7;
varDispatchvarDispatch: Integer = 9;
varDoublevarDouble: Integer = 5;
varEmptyvarEmpty: Integer = 0;
varErrorvarError: Integer = $A;
varInt64varInt64: Integer = $14;
varIntegervarInteger: Integer = 3;
varLongWordvarLongWord: Integer = $13;
varNullvarNull: Integer = 1;
varObjectvarObject: Integer = $49;
varOleStrvarOleStr: Integer = 8;
varRecordvarRecord: Integer = $24;
varShortIntvarShortInt: Integer = $10;
varSinglevarSingle: Integer = 4;
varSmallintvarSmallint: Integer = 2;
varStrArgvarStrArg: Integer = $48;
varStringvarString: Integer = $100;
varTypeMaskvarTypeMask: Integer = $FFF;
varUInt64varUInt64: Integer = $15;
varUnknownvarUnknown: Integer = $D;
varUStrArgvarUStrArg: Integer = $4A;
varUStringvarUString: Integer = $102;
varVariantvarVariant: Integer = $C;
varWordvarWord: Integer = $12;
vcPrivatevcPrivate: :1 = vcPrivate;
vcProtectedvcProtected: :1 = vcProtected;
vcPublicvcPublic: :1 = vcPublic;
vcPublishedvcPublished: :1 = vcPublished;
vmtAddRefvmtAddRef: Integer = 4;
vmtAfterConstructionvmtAfterConstruction: ShortInt = $FFFFFFE4;
vmtAutoTablevmtAutoTable: ShortInt = $FFFFFFB0;
vmtBeforeDestructionvmtBeforeDestruction: ShortInt = $FFFFFFE8;
vmtClassNamevmtClassName: ShortInt = $FFFFFFC8;
vmtCreateObjectvmtCreateObject: Integer = $C;
vmtDefaultHandlervmtDefaultHandler: ShortInt = $FFFFFFF0;
vmtDestroyvmtDestroy: ShortInt = $FFFFFFFC;
vmtDispatchvmtDispatch: ShortInt = $FFFFFFEC;
vmtDynamicTablevmtDynamicTable: ShortInt = $FFFFFFC4;
vmtEqualsvmtEquals: ShortInt = $FFFFFFD4;
vmtFieldTablevmtFieldTable: ShortInt = $FFFFFFBC;
vmtFreeInstancevmtFreeInstance: ShortInt = $FFFFFFF8;
vmtGetHashCodevmtGetHashCode: ShortInt = $FFFFFFD8;
vmtInitTablevmtInitTable: ShortInt = $FFFFFFB4;
vmtInstanceSizevmtInstanceSize: ShortInt = $FFFFFFCC;
vmtIntfTablevmtIntfTable: ShortInt = $FFFFFFAC;
vmtMethodTablevmtMethodTable: ShortInt = $FFFFFFC0;
vmtNewInstancevmtNewInstance: ShortInt = $FFFFFFF4;
vmtParentvmtParent: ShortInt = $FFFFFFD0;
vmtQueryInterfacevmtQueryInterface: Integer = 0;
vmtReleasevmtRelease: Integer = 8;
vmtSafeCallExceptionvmtSafeCallException: ShortInt = $FFFFFFE0;
vmtSelfPtrvmtSelfPtr: ShortInt = $FFFFFFA8;
vmtToStringvmtToString: ShortInt = $FFFFFFDC;
vmtTypeInfovmtTypeInfo: ShortInt = $FFFFFFB8;
vtAnsiStringvtAnsiString: Integer = $B;
vtBooleanvtBoolean: Integer = 1;
vtCharvtChar: Integer = 2;
vtClassvtClass: Integer = 8;
vtCurrencyvtCurrency: Integer = $C;
vtExtendedvtExtended: Integer = 3;
vtInt64vtInt64: Integer = $10;
vtIntegervtInteger: Integer = 0;
vtInterfacevtInterface: Integer = $E;
vtObjectvtObject: Integer = 7;
vtPCharvtPChar: Integer = 6;
vtPointervtPointer: Integer = 5;
vtPWideCharvtPWideChar: Integer = $A;
vtStringvtString: Integer = 4;
vtUnicodeStringvtUnicodeString: Integer = $11;
vtVariantvtVariant: Integer = $D;
vtWideCharvtWideChar: Integer = 9;
vtWideStringvtWideString: Integer = $F;


Personal tools
Previous Versions
Translations