Global

class method Abs(X: Int64): Int64

static Int64 Abs(Int64 X)

static func Abs(_ X: Int64) -> Int64

static Int64 Abs(Int64 X)

Shared Function Abs(X As Int64) As Int64

class method Abs(X: Integer): Integer

static Integer Abs(Integer X)

static func Abs(_ X: Integer) -> Integer

static Integer Abs(Integer X)

Shared Function Abs(X As Integer) As Integer

class method Abs(X: Real): Real

static Real Abs(Real X)

static func Abs(_ X: Real) -> Real

static Real Abs(Real X)

Shared Function Abs(X As Real) As Real

class method Addr(var X: lifetimestrategy(void)Object): Pointer

static Pointer Addr(ref lifetimestrategy(void)Object X)

static func Addr(_ X: lifetimestrategy(void)Object) -> Pointer

static Pointer Addr(__ref lifetimestrategy(void)Object X)

Shared Function Addr(ByRef X As lifetimestrategy(void)Object) As Pointer

class method AtomicCmpExchange(var Target: Int64; NewValue: Int64; Comparand: Int64; out Succeeded: Boolean): Int64

static Int64 AtomicCmpExchange(ref Int64 Target, Int64 NewValue, Int64 Comparand, out Boolean Succeeded)

static func AtomicCmpExchange(_ Target: Int64, _ NewValue: Int64, _ Comparand: Int64, _ Succeeded: Boolean) -> Int64

static Int64 AtomicCmpExchange(__ref Int64 Target, Int64 NewValue, Int64 Comparand, __out Boolean Succeeded)

Shared Function AtomicCmpExchange(ByRef Target As Int64, NewValue As Int64, Comparand As Int64, <OutAttribute> ByRef Succeeded As Boolean) As Int64

class method AtomicCmpExchange(var Target: Integer; NewValue: Integer; Comparand: Integer; out Succeeded: Boolean): Integer

static Integer AtomicCmpExchange(ref Integer Target, Integer NewValue, Integer Comparand, out Boolean Succeeded)

static func AtomicCmpExchange(_ Target: Integer, _ NewValue: Integer, _ Comparand: Integer, _ Succeeded: Boolean) -> Integer

static Integer AtomicCmpExchange(__ref Integer Target, Integer NewValue, Integer Comparand, __out Boolean Succeeded)

Shared Function AtomicCmpExchange(ByRef Target As Integer, NewValue As Integer, Comparand As Integer, <OutAttribute> ByRef Succeeded As Boolean) As Integer

class method AtomicCmpExchange(var Target: Pointer; NewValue: Pointer; Comparand: Pointer; out Succeeded: Boolean): Pointer

static Pointer AtomicCmpExchange(ref Pointer Target, Pointer NewValue, Pointer Comparand, out Boolean Succeeded)

static func AtomicCmpExchange(_ Target: Pointer, _ NewValue: Pointer, _ Comparand: Pointer, _ Succeeded: Boolean) -> Pointer

static Pointer AtomicCmpExchange(__ref Pointer Target, Pointer NewValue, Pointer Comparand, __out Boolean Succeeded)

Shared Function AtomicCmpExchange(ByRef Target As Pointer, NewValue As Pointer, Comparand As Pointer, <OutAttribute> ByRef Succeeded As Boolean) As Pointer

class method AtomicDecrement(var Target: Int64): Int64

static Int64 AtomicDecrement(ref Int64 Target)

static func AtomicDecrement(_ Target: Int64) -> Int64

static Int64 AtomicDecrement(__ref Int64 Target)

Shared Function AtomicDecrement(ByRef Target As Int64) As Int64

class method AtomicDecrement(var Target: Int64; Decrement: Int64): Int64

static Int64 AtomicDecrement(ref Int64 Target, Int64 Decrement)

static func AtomicDecrement(_ Target: Int64, _ Decrement: Int64) -> Int64

static Int64 AtomicDecrement(__ref Int64 Target, Int64 Decrement)

Shared Function AtomicDecrement(ByRef Target As Int64, Decrement As Int64) As Int64

class method AtomicDecrement(var Target: Integer): Integer

static Integer AtomicDecrement(ref Integer Target)

static func AtomicDecrement(_ Target: Integer) -> Integer

static Integer AtomicDecrement(__ref Integer Target)

Shared Function AtomicDecrement(ByRef Target As Integer) As Integer

class method AtomicDecrement(var Target: Integer; Decrement: Integer): Integer

static Integer AtomicDecrement(ref Integer Target, Integer Decrement)

static func AtomicDecrement(_ Target: Integer, _ Decrement: Integer) -> Integer

static Integer AtomicDecrement(__ref Integer Target, Integer Decrement)

Shared Function AtomicDecrement(ByRef Target As Integer, Decrement As Integer) As Integer

class method AtomicDecrement(var Target: Pointer): Pointer

static Pointer AtomicDecrement(ref Pointer Target)

static func AtomicDecrement(_ Target: Pointer) -> Pointer

static Pointer AtomicDecrement(__ref Pointer Target)

Shared Function AtomicDecrement(ByRef Target As Pointer) As Pointer

class method AtomicDecrement(var Target: Pointer; Decrement: NativeInt): Pointer

static Pointer AtomicDecrement(ref Pointer Target, NativeInt Decrement)

static func AtomicDecrement(_ Target: Pointer, _ Decrement: NativeInt) -> Pointer

static Pointer AtomicDecrement(__ref Pointer Target, NativeInt Decrement)

Shared Function AtomicDecrement(ByRef Target As Pointer, Decrement As NativeInt) As Pointer

class method AtomicExchange(var Target: Int64; Value: Int64): Int64

static Int64 AtomicExchange(ref Int64 Target, Int64 Value)

static func AtomicExchange(_ Target: Int64, _ Value: Int64) -> Int64

static Int64 AtomicExchange(__ref Int64 Target, Int64 Value)

Shared Function AtomicExchange(ByRef Target As Int64, Value As Int64) As Int64

class method AtomicExchange(var Target: Integer; Value: Integer): Integer

static Integer AtomicExchange(ref Integer Target, Integer Value)

static func AtomicExchange(_ Target: Integer, _ Value: Integer) -> Integer

static Integer AtomicExchange(__ref Integer Target, Integer Value)

Shared Function AtomicExchange(ByRef Target As Integer, Value As Integer) As Integer

class method AtomicExchange(var Target: Pointer; Value: Pointer): Pointer

static Pointer AtomicExchange(ref Pointer Target, Pointer Value)

static func AtomicExchange(_ Target: Pointer, _ Value: Pointer) -> Pointer

static Pointer AtomicExchange(__ref Pointer Target, Pointer Value)

Shared Function AtomicExchange(ByRef Target As Pointer, Value As Pointer) As Pointer

class method AtomicIncrement(var Target: Int64): Int64

static Int64 AtomicIncrement(ref Int64 Target)

static func AtomicIncrement(_ Target: Int64) -> Int64

static Int64 AtomicIncrement(__ref Int64 Target)

Shared Function AtomicIncrement(ByRef Target As Int64) As Int64

class method AtomicIncrement(var Target: Int64; Increment: Int64): Int64

static Int64 AtomicIncrement(ref Int64 Target, Int64 Increment)

static func AtomicIncrement(_ Target: Int64, _ Increment: Int64) -> Int64

static Int64 AtomicIncrement(__ref Int64 Target, Int64 Increment)

Shared Function AtomicIncrement(ByRef Target As Int64, Increment As Int64) As Int64

class method AtomicIncrement(var Target: Integer): Integer

static Integer AtomicIncrement(ref Integer Target)

static func AtomicIncrement(_ Target: Integer) -> Integer

static Integer AtomicIncrement(__ref Integer Target)

Shared Function AtomicIncrement(ByRef Target As Integer) As Integer

class method AtomicIncrement(var Target: Integer; Increment: Integer): Integer

static Integer AtomicIncrement(ref Integer Target, Integer Increment)

static func AtomicIncrement(_ Target: Integer, _ Increment: Integer) -> Integer

static Integer AtomicIncrement(__ref Integer Target, Integer Increment)

Shared Function AtomicIncrement(ByRef Target As Integer, Increment As Integer) As Integer

class method AtomicIncrement(var Target: Pointer): Pointer

static Pointer AtomicIncrement(ref Pointer Target)

static func AtomicIncrement(_ Target: Pointer) -> Pointer

static Pointer AtomicIncrement(__ref Pointer Target)

Shared Function AtomicIncrement(ByRef Target As Pointer) As Pointer

class method AtomicIncrement(var Target: Pointer; Increment: NativeInt): Pointer

static Pointer AtomicIncrement(ref Pointer Target, NativeInt Increment)

static func AtomicIncrement(_ Target: Pointer, _ Increment: NativeInt) -> Pointer

static Pointer AtomicIncrement(__ref Pointer Target, NativeInt Increment)

Shared Function AtomicIncrement(ByRef Target As Pointer, Increment As NativeInt) As Pointer

class method Concat(S1: string; S2: string): string

static string Concat(string S1, string S2)

static func Concat(_ S1: string, _ S2: string) -> string

static string Concat(string S1, string S2)

Shared Function Concat(S1 As string, S2 As string) As string

class method Concat(S1: string; params S2: IEnumerable<DelphiUnicodeString>): string

static string Concat(string S1, params IEnumerable<DelphiUnicodeString> S2)

static func Concat(_ S1: string, _ S2: IEnumerable<DelphiUnicodeString>...) -> string

static string Concat(string S1, IEnumerable<DelphiUnicodeString>... S2)

Shared Function Concat(S1 As string, ParamArray S2 As IEnumerable<DelphiUnicodeString>) As string

class method Concat<T>(S1: array of T; S2: array of T): array of T

static T[] Concat<T>(T[] S1, T[] S2)

static func Concat<T>(_ S1: T..., _ S2: T...) -> T...

static T[] Concat<T>(T[] S1, T[] S2)

Shared Function Concat<T>(S1 As T(), S2 As T()) As T()

class method Concat<T>(S1: array of T; params S2: array of array of T): array of T

static T[] Concat<T>(T[] S1, params T[][] S2)

static func Concat<T>(_ S1: T..., _ S2: T......) -> T...

static T[] Concat<T>(T[] S1, T[][]... S2)

Shared Function Concat<T>(S1 As T(), ParamArray S2 As T()()) As T()

class method Copy(aString: DelphiAnsiString; aIndex: Integer; aCount: Integer): DelphiAnsiString

static DelphiAnsiString Copy(DelphiAnsiString aString, Integer aIndex, Integer aCount)

static func Copy(_ aString: DelphiAnsiString, _ aIndex: Integer, _ aCount: Integer) -> DelphiAnsiString

static DelphiAnsiString Copy(DelphiAnsiString aString, Integer aIndex, Integer aCount)

Shared Function Copy(aString As DelphiAnsiString, aIndex As Integer, aCount As Integer) As DelphiAnsiString

class method Copy(aString: DelphiShortString; aIndex: Integer; aCount: Integer): DelphiShortString

static DelphiShortString Copy(DelphiShortString aString, Integer aIndex, Integer aCount)

static func Copy(_ aString: DelphiShortString, _ aIndex: Integer, _ aCount: Integer) -> DelphiShortString

static DelphiShortString Copy(DelphiShortString aString, Integer aIndex, Integer aCount)

Shared Function Copy(aString As DelphiShortString, aIndex As Integer, aCount As Integer) As DelphiShortString

class method Copy(aString: DelphiUnicodeString; aIndex: Integer; aCount: Integer): DelphiUnicodeString

static DelphiUnicodeString Copy(DelphiUnicodeString aString, Integer aIndex, Integer aCount)

static func Copy(_ aString: DelphiUnicodeString, _ aIndex: Integer, _ aCount: Integer) -> DelphiUnicodeString

static DelphiUnicodeString Copy(DelphiUnicodeString aString, Integer aIndex, Integer aCount)

Shared Function Copy(aString As DelphiUnicodeString, aIndex As Integer, aCount As Integer) As DelphiUnicodeString

class method Copy(aString: DelphiWideString; aIndex: Integer; aCount: Integer): DelphiWideString

static DelphiWideString Copy(DelphiWideString aString, Integer aIndex, Integer aCount)

static func Copy(_ aString: DelphiWideString, _ aIndex: Integer, _ aCount: Integer) -> DelphiWideString

static DelphiWideString Copy(DelphiWideString aString, Integer aIndex, Integer aCount)

Shared Function Copy(aString As DelphiWideString, aIndex As Integer, aCount As Integer) As DelphiWideString

class method Delete(var S: string; Index: Integer; Count: Integer)

static void Delete(ref string S, Integer Index, Integer Count)

static func Delete(_ S: string, _ Index: Integer, _ Count: Integer)

static void Delete(__ref string S, Integer Index, Integer Count)

Shared Sub Delete(ByRef S As string, Index As Integer, Count As Integer)

class method Delete<T>(var S: array of T; Index: Integer; Count: Integer)

static void Delete<T>(ref T[] S, Integer Index, Integer Count)

static func Delete<T>(_ S: T..., _ Index: Integer, _ Count: Integer)

static void Delete<T>(__ref T[] S, Integer Index, Integer Count)

Shared Sub Delete<T>(ByRef S As T(), Index As Integer, Count As Integer)

class method FillChar(var X: lifetimestrategy(void)Object; Count: Integer; Value: Integer)

static void FillChar(ref lifetimestrategy(void)Object X, Integer Count, Integer Value)

static func FillChar(_ X: lifetimestrategy(void)Object, _ Count: Integer, _ Value: Integer)

static void FillChar(__ref lifetimestrategy(void)Object X, Integer Count, Integer Value)

Shared Sub FillChar(ByRef X As lifetimestrategy(void)Object, Count As Integer, Value As Integer)

class method FreeMem(var P: Pointer)

static void FreeMem(ref Pointer P)

static func FreeMem(_ P: Pointer)

static void FreeMem(__ref Pointer P)

Shared Sub FreeMem(ByRef P As Pointer)

class method FreeMem(var P: Pointer; Size: Integer)

static void FreeMem(ref Pointer P, Integer Size)

static func FreeMem(_ P: Pointer, _ Size: Integer)

static void FreeMem(__ref Pointer P, Integer Size)

Shared Sub FreeMem(ByRef P As Pointer, Size As Integer)

class method Hi(X: Integer): Byte

static Byte Hi(Integer X)

static func Hi(_ X: Integer) -> Byte

static Byte Hi(Integer X)

Shared Function Hi(X As Integer) As Byte

class method Insert(Source: string; var Dest: string; Index: Integer)

static void Insert(string Source, ref string Dest, Integer Index)

static func Insert(_ Source: string, _ Dest: string, _ Index: Integer)

static void Insert(string Source, __ref string Dest, Integer Index)

Shared Sub Insert(Source As string, ByRef Dest As string, Index As Integer)

class method Insert<T>(Source: array of T; var Dest: array of T; Index: Integer)

static void Insert<T>(T[] Source, ref T[] Dest, Integer Index)

static func Insert<T>(_ Source: T..., _ Dest: T..., _ Index: Integer)

static void Insert<T>(T[] Source, __ref T[] Dest, Integer Index)

Shared Sub Insert<T>(Source As T(), ByRef Dest As T(), Index As Integer)

class method Lo(X: Integer): Byte

static Byte Lo(Integer X)

static func Lo(_ X: Integer) -> Byte

static Byte Lo(Integer X)

Shared Function Lo(X As Integer) As Byte

class method MulDivInt64(AValue: Int64; AMul: Int64; ADiv: Int64): Int64

static Int64 MulDivInt64(Int64 AValue, Int64 AMul, Int64 ADiv)

static func MulDivInt64(_ AValue: Int64, _ AMul: Int64, _ ADiv: Int64) -> Int64

static Int64 MulDivInt64(Int64 AValue, Int64 AMul, Int64 ADiv)

Shared Function MulDivInt64(AValue As Int64, AMul As Int64, ADiv As Int64) As Int64

class method MulDivInt64(AValue: Int64; AMul: Int64; ADiv: Int64; out Remainder: Int64): Int64

static Int64 MulDivInt64(Int64 AValue, Int64 AMul, Int64 ADiv, out Int64 Remainder)

static func MulDivInt64(_ AValue: Int64, _ AMul: Int64, _ ADiv: Int64, _ Remainder: Int64) -> Int64

static Int64 MulDivInt64(Int64 AValue, Int64 AMul, Int64 ADiv, __out Int64 Remainder)

Shared Function MulDivInt64(AValue As Int64, AMul As Int64, ADiv As Int64, <OutAttribute> ByRef Remainder As Int64) As Int64

class method Odd(X: Integer): Boolean

static Boolean Odd(Integer X)

static func Odd(_ X: Integer) -> Boolean

static Boolean Odd(Integer X)

Shared Function Odd(X As Integer) As Boolean

class method Pi: Extended

static Extended Pi()

static func Pi() -> Extended

static Extended Pi()

Shared Function Pi() As Extended

class method Ptr(Address: Integer): Pointer

static Pointer Ptr(Integer Address)

static func Ptr(_ Address: Integer) -> Pointer

static Pointer Ptr(Integer Address)

Shared Function Ptr(Address As Integer) As Pointer

class method Round(X: Real): Int64

static Int64 Round(Real X)

static func Round(_ X: Real) -> Int64

static Int64 Round(Real X)

Shared Function Round(X As Real) As Int64

class method RunError

static void RunError()

static func RunError()

static void RunError()

Shared Sub RunError()

class method RunError(ErrorCode: Byte)

static void RunError(Byte ErrorCode)

static func RunError(_ ErrorCode: Byte)

static void RunError(Byte ErrorCode)

Shared Sub RunError(ErrorCode As Byte)

class method SetLength<T>(var aArray: array of T; aNewLength: Int32)

static void SetLength<T>(ref T[] aArray, Int32 aNewLength)

static func SetLength<T>(_ aArray: T..., _ aNewLength: Int32)

static void SetLength<T>(__ref T[] aArray, Int32 aNewLength)

Shared Sub SetLength<T>(ByRef aArray As T(), aNewLength As Int32)

class method SetString(var aString: DelphiAnsiString; aBuffer: PAnsiChar; aLength: Integer)

static void SetString(ref DelphiAnsiString aString, PAnsiChar aBuffer, Integer aLength)

static func SetString(_ aString: DelphiAnsiString, _ aBuffer: PAnsiChar, _ aLength: Integer)

static void SetString(__ref DelphiAnsiString aString, PAnsiChar aBuffer, Integer aLength)

Shared Sub SetString(ByRef aString As DelphiAnsiString, aBuffer As PAnsiChar, aLength As Integer)

class method SetString(var aString: DelphiShortString; aBuffer: PAnsiChar; aLength: Integer)

static void SetString(ref DelphiShortString aString, PAnsiChar aBuffer, Integer aLength)

static func SetString(_ aString: DelphiShortString, _ aBuffer: PAnsiChar, _ aLength: Integer)

static void SetString(__ref DelphiShortString aString, PAnsiChar aBuffer, Integer aLength)

Shared Sub SetString(ByRef aString As DelphiShortString, aBuffer As PAnsiChar, aLength As Integer)

class method SetString(var aString: DelphiUnicodeString; aBuffer: PChar; aLength: Integer)

static void SetString(ref DelphiUnicodeString aString, PChar aBuffer, Integer aLength)

static func SetString(_ aString: DelphiUnicodeString, _ aBuffer: PChar, _ aLength: Integer)

static void SetString(__ref DelphiUnicodeString aString, PChar aBuffer, Integer aLength)

Shared Sub SetString(ByRef aString As DelphiUnicodeString, aBuffer As PChar, aLength As Integer)

class method SetString(var aString: DelphiWideString; aBuffer: ^Char; aLength: Integer)

static void SetString(ref DelphiWideString aString, Char* aBuffer, Integer aLength)

static func SetString(_ aString: DelphiWideString, _ aBuffer: UnsafeMutablePointer<Char>, _ aLength: Integer)

static void SetString(__ref DelphiWideString aString, Char* aBuffer, Integer aLength)

Shared Sub SetString(ByRef aString As DelphiWideString, aBuffer As Ptr(Of Char), aLength As Integer)

class method SetString(var aString: IslandString; aBuffer: ^Char; aLength: Integer)

static void SetString(ref IslandString aString, Char* aBuffer, Integer aLength)

static func SetString(_ aString: IslandString, _ aBuffer: UnsafeMutablePointer<Char>, _ aLength: Integer)

static void SetString(__ref IslandString aString, Char* aBuffer, Integer aLength)

Shared Sub SetString(ByRef aString As IslandString, aBuffer As Ptr(Of Char), aLength As Integer)

class method Slice(var A: Array; Count: Integer): Pointer

static Pointer Slice(ref Array A, Integer Count)

static func Slice(_ A: Array, _ Count: Integer) -> Pointer

static Pointer Slice(__ref Array A, Integer Count)

Shared Function Slice(ByRef A As Array, Count As Integer) As Pointer

class method Sqr(X: Int64): Int64

static Int64 Sqr(Int64 X)

static func Sqr(_ X: Int64) -> Int64

static Int64 Sqr(Int64 X)

Shared Function Sqr(X As Int64) As Int64

class method Sqr(X: Integer): Integer

static Integer Sqr(Integer X)

static func Sqr(_ X: Integer) -> Integer

static Integer Sqr(Integer X)

Shared Function Sqr(X As Integer) As Integer

class method Sqr(X: Real): Extended

static Extended Sqr(Real X)

static func Sqr(_ X: Real) -> Extended

static Extended Sqr(Real X)

Shared Function Sqr(X As Real) As Extended

class method Str(X: Object; var S: string)

static void Str(Object X, ref string S)

static func Str(_ X: Object, _ S: string)

static void Str(Object X, __ref string S)

Shared Sub Str(X As Object, ByRef S As string)

class method Swap(X: Word): Word

static Word Swap(Word X)

static func Swap(_ X: Word) -> Word

static Word Swap(Word X)

Shared Function Swap(X As Word) As Word

class method Trunc(X: Real): Int64

static Int64 Trunc(Real X)

static func Trunc(_ X: Real) -> Int64

static Int64 Trunc(Real X)

Shared Function Trunc(X As Real) As Int64

class method VarArrayRedim(var A: Variant; HighBound: Integer)

static void VarArrayRedim(ref Variant A, Integer HighBound)

static func VarArrayRedim(_ A: Variant, _ HighBound: Integer)

static void VarArrayRedim(__ref Variant A, Integer HighBound)

Shared Sub VarArrayRedim(ByRef A As Variant, HighBound As Integer)

class method VarCast(var Dest: Variant; Source: Variant; VarType: Integer)

static void VarCast(ref Variant Dest, Variant Source, Integer VarType)

static func VarCast(_ Dest: Variant, _ Source: Variant, _ VarType: Integer)

static void VarCast(__ref Variant Dest, Variant Source, Integer VarType)

Shared Sub VarCast(ByRef Dest As Variant, Source As Variant, VarType As Integer)

class method VarClear(var V: Variant)

static void VarClear(ref Variant V)

static func VarClear(_ V: Variant)

static void VarClear(__ref Variant V)

Shared Sub VarClear(ByRef V As Variant)

class method VarCopy(var Dest: Variant; Source: Variant)

static void VarCopy(ref Variant Dest, Variant Source)

static func VarCopy(_ Dest: Variant, _ Source: Variant)

static void VarCopy(__ref Variant Dest, Variant Source)

Shared Sub VarCopy(ByRef Dest As Variant, Source As Variant)