From RAD Studio API Documentation
Jump to: navigation, search

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. See Delphi Intrinsic Routines for a list of Delphi-only intrinsic routines that are exposed by the System unit.

Unit Scopes

System.BeaconProvides classes to use the Beacons capabilities of the device that is running your application.

Is the unit scope for the LiveBindings framework engine. Contains units that implement the LiveBindings engine.

System.BluetoothProvides classes to use the Bluetooth capabilities of the device that is running your application to connect to applications running on remote devices.

Contains two units that define classes, types, and routines for using generics -- algorithms that contain generalized types that are instantiated later and used as parameters. For more information, see Overview of Generics.

System.JSONRTL API of classes and routines to work with JavaScript Object Notation or JSON, a human-readable format for serialized data, used mainly as an alternative to XML.
System.MathDefines classes, routines, types, variables, and constants related to mathematical operations, vectors and matrixes.
System.SensorsSensors are pieces of hardware or software that can provide measures of physical quantities to your applications. This unit provides classes and components that let you obtain information and manage system sensors.
System.TetherUnits implementing the app tethering feature.

Contains Windows related functionality, such as Windows registry, COM and MTS.


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. See Delphi Intrinsic Routines for a list of Delphi-only intrinsic routines that are exposed by the System unit.
System.ActionsProvides action features that do not depend on the GUI application framework.
System.AnsiStringsProvides routines to work with strings of type AnsiString.
System.CharacterProvides helpers and types to work with UTF-16 characters.
System.ImageListSystem.ImageList contains the common for both FireMonkey and VCL code implementing the most basic device-independent features of image lists. System.ImageList contains the code supporting interaction between images in an image list and using them components (like controls, menu items, and so on).
System.MessagingDefines the classes and methods that are in charge with message handling on different platforms.
System.NetEncodingProvides classes for encoding and decoding data in formats often used in networking (base64, HTML, URL).
System.NotificationThe Notification API allows you to use notifications on supported platforms.
System.ThreadingDefines classes and types that implement the parallel programming library.
System.ZLibContains the zLib compression library. For more information, see


__IObjCastGUIDHolderFor internal use.
_InterfaceCastHlprFor internal use.
AlignAttributeInternal use only.
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.
CompBaseBase type for Comp.
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.
HFAAttributeFor internal use only.
HPPGENAttributeRepresents an attribute that is intended for improving the generation of hpp header files.
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.
IUnknownIs a special base interface.
NamedParmNamedParm represents a named parameter assigned to a TAutoCmd descendant.
OpenArrayC++ encapsulation of the Delphi Open Array type.
OpenArrayCounterUtility class for open array macros.
OpenArrayCountHlprUtility class for open array macros.
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.
RefAttributeRepresents an attribute.
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.
TClassTClass defines the metaclass for TObject.
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.
TDateTimeBaseBase class for TDateTime.
TDynArrayRecRepresents the basic mechanism for memory management for dynamic arrays.
TInterfacedClassTInterfacedClass defines the metaclass for TInterfacedObject.
TInterfacedObjectTInterfacedObject is a base for simple classes that need a basic IInterface implementation.
TMarshalTMarshal is a class that facilitates working with memory buffers.
TObjectTObject is the ultimate ancestor of all objects and components.
TVariantTGeneral purpose VARIANT wrapper.
UnsafeAttributeRepresents an attribute that can be applied to variables (members), functions and parameters.
VariantErrorEncapsulates a variant error code.


__currMul__currMul is used internally by the Delphi compiler.
AbsReturns an absolute value.
AcquireExceptionObjectExtracts 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.
AtomicCmpExchangeAtomic intrinsic Compare and Exchange function compares the contents of the Target to a given value (Comparand) and, only if they are the same, modifies the contents of Target to the new value.
AtomicDecrementAtomic intrinsic Decrement function for use with Delphi mobile compilers.
AtomicExchangeAtomic intrinsic Exchange function for use with Delphi mobile compilers. Writes the given value to the target and returns the previous value of the target.
AtomicIncrementAtomic intrinsic Increment function for use with Delphi mobile compilers.
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.
BuiltInArcTanCalculates the arctangent of a given number.
BuiltInArcTan2Calculates the arctangent angle and quadrant of a given number.
BuiltInCosCalculates the cosine of an angle.
BuiltInLnCalculates the natural logarithm of a real expression.
BuiltInLnXPlus1Calculates the natural logarithm of (X+1).
BuiltInLog10Calculates log base 10.
BuiltInLog2Calculates log base 2.
BuiltInSinCalculates the sine of the angle.
BuiltInSqrtCalculates the square root of X.
BuiltInTanCalculates the tangent of X.
ChDirChanges the current directory.
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 string, or two or more dynamic arrays into one dynamic array.
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.
CopyRecordCopies fields in Record.
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 or elements range from a dynamic array.
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.

Returns eX-1.

FailCancels the construction of an object (Turbo Pascal object model).
FGetExceptFlagRetrieves whether the floating-point exception event flags specified by the Excepts parameter are set.
FGetExceptMaskGets the floating point exception mask flags.
FGetRoundGets the floating point rounding mode.
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.
FinalizeRecordFinalizes fields in Record.
FindClassHInstanceReturns the instance handle for the module in which a class type is defined.
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.
FPower10 (deprecated)Deprecated. 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.
FSetExceptFlagSets the floating-point exception flags.
FSetExceptMaskSets the floating point exception mask flags.
FSetRoundSets the floating point rounding mode.
Get8087CWReturns the value of the 8087 control word.
GetDirReturns the current directory.
GetDynaMethodFor internal use.
GetHeapStatus (deprecated)Returns 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.

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.
GetVariantManager (deprecated)Returns 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 (or inserts a dynamic array into a dynamic array), 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.
IsVariantManagerSet (deprecated)Indicates 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.

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.
LoadResourceStringAlternative definition of LoadResString that allows you to pass a constant pointer to a constant ResourceString instead of a pointer to a TResStringRec or a PResStringRec.
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.
Mark (deprecated)Mark is no longer used.
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.
MoveArrayMoves Count items in Array.
MoveCharsCopies bytes from a source to a destination.
MoveRecordMoves fields in Record.
MulDivInt64Returns the value of this expression: Int64((Int128(AValue) * Int128(AMul)) div Int128(ADiv)).
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.
PosLocates a substring 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.
RaiseList (deprecated)RaiseList 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.
Release (deprecated)Release is no longer used.
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.
SetMXCSRExceptionFlagSets the specified NewExceptionFlag floating-point exception flags in the Intel SSE’s MXCSR register.
SetRaiseList (deprecated)SetRaiseList 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.
SetUTF8CompareLocaleSets the UTF-8 compare locale.
SetVariantManager (deprecated)Sets the entry points of the routines that define variant behavior.
ShareMemoryManagerShares the module's memory manager.
SinReturns the sine of the angle, in radians.

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.

Returns tan(X).

TextStart (deprecated)TextStart 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.
UTF8Decode (deprecated)Converts 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 that represents an integer (decimal or hex notation) into a number.
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.


_DCHARAlias for WideChar.
AnsiCharRepresents a byte-sized (8-bits) character type.
AnsiString represents a dynamically allocated string whose maximum length is limited only by available memory.
BooleanRepresents the preferred predefined Boolean type.
ByteRepresents an 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.
FixedIntDefines a 32-bit signed integer type.
FixedUIntDefines a 32-bit unsigned integer 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.
LongBoolRepresents a 32-bit predefined Boolean type.
LongintPlatform-dependent signed integer type.
LongWordPlatform-dependent unsigned integer type.
MarshaledAStringMarshaledAString is an alias for PAnsiChar.
MarshaledStringDefines a null-terminated Unicode string.
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.
PFixedIntIs a pointer to a FixedInt.
PFixedUIntIs a pointer to a FixedUInt.
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 an 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.
PWideChar PWideChar is a pointer to a null-terminated string of WideChar values, that is, Unicode characters.
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.
ResourceStringAlias of TResStringRec.
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.
TArrayDefines a generic array.
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.
TDoubleRec (deprecated)Provides 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.
TExtended80RecProvides support for manipulating extended precision floating-point values.
TExtendedRecAlias to TExtended80Rec or TDoubleRec.
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).
THeapStatus (deprecated)THeapStatus represents information about the global heap.
TInitContextIs used internally.
TInt64DynArrayIs a dynamic array of Int64.

Represents a dynamic array of System.Int8.

TIntegerDynArrayIs a dynamic array of Integer.
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.
TMemoryManager (deprecated)TMemoryManager 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.
TPtrWrapperTPtrWrapper is a pointer-sized value representing a pointer.
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.
TSingleRec (deprecated)

TSingleRec can perform low-level operations on a single precision floating-point value.

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.
TVariantManager (deprecated)TVariantManager 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.
WideStringA null-terminated string of wide characters, with no reference counting.
WordRepresents a 16-bit unsigned integer type.
WordBoolRepresents a 16-bit predefined Boolean type.


AbstractErrorProcAbstractErrorProc defines a callback routine for abstract method call errors.
AllocMemCount (deprecated)Represents the total number of allocated memory blocks in a Delphi application.
AllocMemSize (deprecated)Represents the total size of allocated memory blocks.
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.
HPrevInst (deprecated)Indicates 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.
IsConsoleIndicates whether the excecutable module was compiled as a console application.
IsLibraryIs True if the module is a dynamic link library (.dll) or shared library (.dylib in macOS or .so in Linux) and False if it is a runtime-package.
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.
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.
ReportMemoryLeaksOnShutdownReports 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.
Test8086Represents the CPU family.
Test8087Represents the FPU family.
TestFDIVSpecifies whether the floating-point division operation is flawed.
TestSSETestSSE represents the SSE (Streaming SIMD Extensions) functionality on the computer in use.
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.


CompilerVersionCompilerVersion: Extended = 35;
CP_ACPCP_ACP: Integer = 0;
CP_UTF7CP_UTF7: Word = $FDE8;
CP_UTF8CP_UTF8: Word = $FDE9;
CPUi386CPUi386: Integer = 2;
CPUi486CPUi486: Integer = 3;
CPUPentiumCPUPentium: Integer = 4;
DefaultFieldRttiVisibilityDefaultFieldRttiVisibility: Set = [vcPrivate..vcPublished];
DefaultMethodRttiVisibilityDefaultMethodRttiVisibility: Set = [vcPublic..vcPublished];
DefaultPropertyRttiVisibilityDefaultPropertyRttiVisibility: Set = [vcPublic..vcPublished];
feeALLEXCEPTfeeALLEXCEPT: Integer = $3F;
feeDIVBYZEROfeeDIVBYZERO: Integer = 4;
feeINEXACTfeeINEXACT: Integer = $20;
feeINVALIDfeeINVALID: Integer = 1;
feeOVERFLOWfeeOVERFLOW: Integer = 8;
feeUNDERFLOWfeeUNDERFLOW: Integer = $10;
femALLEXCEPTfemALLEXCEPT: Integer = $3F;
femDIVBYZEROfemDIVBYZERO: Integer = 4;
femINEXACTfemINEXACT: Integer = $20;
femINVALIDfemINVALID: Integer = 1;
femOVERFLOWfemOVERFLOW: Integer = 8;
femUNDERFLOWfemUNDERFLOW: Integer = $10;
ferALLROUNDferALLROUND: Integer = $C00;
ferDOWNWARDferDOWNWARD: Integer = $400;
ferTONEARESTferTONEAREST: Integer = 0;
ferUPWARDferUPWARD: Integer = $800;
fmClosedfmClosed: Word = $D7B0;
fmInOutfmInOut: Word = $D7B3;
fmInputfmInput: Word = $D7B1;
fmOutputfmOutput: Word = $D7B2;
hfFieldSizehfFieldSize: Integer = 4;
hfMonitorOffsethfMonitorOffset: Integer = 0;
MaxIntMaxInt: Integer = $7FFFFFFF;
MaxLongIntMaxLongInt: Integer = $7FFFFFFF;
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;
RTLVersionRTLVersion: Comp = 35;
RTLVersion111RTLVersion111: Boolean = True;
RTLVersion112RTLVersion112: Boolean = True;
RTLVersion113RTLVersion113: Boolean = True;
S_FALSES_FALSE: Integer = 1;
S_OKS_OK: Integer = 0;
sLineBreaksLineBreak: AnsiString = ;
tfCRLFtfCRLF: Integer = 1;
tkAnsiChartkAnsiChar: TTypeKind = tkChar;
tkAnsiStringtkAnsiString: TTypeKind = tkLString;
tkShortStringtkShortString: TTypeKind = tkString;
tkUnicodeStringtkUnicodeString: TTypeKind = tkUString;
tkWideChartkWideChar: TTypeKind = tkWChar;
tkWideStringtkWideString: TTypeKind = tkWString;
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;
varUInt32varUInt32: Integer = $13;
varUInt64varUInt64: Integer = $15;
varUnknownvarUnknown: Integer = $D;
varUStrArgvarUStrArg: Integer = $4A;
varUStringvarUString: Integer = $102;
varVariantvarVariant: Integer = $C;
varWordvarWord: Integer = $12;
vmtAddRefvmtAddRef: Integer = 4;
vmtAfterConstructionvmtAfterConstruction: ShortInt = $FFFFFFE4;
vmtArcOffsetvmtArcOffset: Integer = 0;
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;