The system unit

The system unit contains the standard supported functions of Free Pascal. It is the same for all platforms. Basically it is the same as the system unit provided with Borland or Turbo Pascal.

Functions are listed in alphabetical order. Arguments of functions or procedures that are optional are put between square brackets.

The pre-defined constants and variables are listed in the first section. The second section contains an overview of all functions, grouped by functionality, and the last section contains the supported functions and procedures.

Integer Types

The following integer types are defined in the System unit:


Shortint = -128..127;
SmallInt = -32768..32767;
Longint  = $80000000..$7fffffff;
byte     = 0..255;
word     = 0..65535;
dword    = longword;
cardinal = longword;
Integer  = smallint;

The following types are used for the functions that need compiler magic such as or :


StrLenInt = LongInt;
ValSInt = Longint;
ValUInt = Cardinal;
ValReal = Extended;

The Real48 type is defined to emulate the old Turbo Pascal Real type:


Real48 = Array[0..5] of byte;

The assignment operator has been overloaded so this type can be assigned to the Free Pascal native Double and Extended types. .

The following character types are defined for Delphi compatibility:


TAnsiChar   = Char;
AnsiChar    = TAnsiChar;

And the following pointer types as well:


  PChar = ^char;
  pPChar = ^PChar;
  PAnsiChar   = PChar;
  PQWord      = ^QWord;
  PInt64      = ^Int64;
  pshortstring = ^shortstring;
  plongstring  = ^longstring;
  pansistring  = ^ansistring;
  pwidestring  = ^widestring;
  pextended    = ^extended;
  ppointer     = ^pointer;

For the and calls, the following jump bufer type is defined (for the I386 processor):


  jmp_buf = record
    ebx,esi,edi : Longint;
    bp,sp,pc : Pointer;
    end;
  PJmp_buf = ^jmp_buf;

The following records and pointers can be used to scan the entries in the string message handler tables:


  tmsgstrtable = record
     name : pshortstring;
     method : pointer;
  end;
  pmsgstrtable = ^tmsgstrtable;

  tstringmessagetable = record
     count : dword;
     msgstrtable : array[0..0] of tmsgstrtable;
  end;
  pstringmessagetable = ^tstringmessagetable;

The base class for all classes is defined as:


Type
  TObject = Class
  Public
    constructor create;
    destructor destroy;virtual;
    class function newinstance : tobject;virtual;
    procedure freeinstance;virtual;
    function safecallexception(exceptobject : tobject;
      exceptaddr : pointer) : longint;virtual;
    procedure defaulthandler(var message);virtual;
    procedure free;
    class function initinstance(instance : pointer) : tobject;
    procedure cleanupinstance;
    function classtype : tclass;
    class function classinfo : pointer;
    class function classname : shortstring;
    class function classnameis(const name : string) : boolean;
    class function classparent : tclass;
    class function instancesize : longint;
    class function inheritsfrom(aclass : tclass) : boolean;
    class function inheritsfrom(aclass : tclass) : boolean;
    class function stringmessagetable : pstringmessagetable;
    procedure dispatch(var message);
    procedure dispatchstr(var message);
    class function methodaddress(const name : shortstring) : pointer;
    class function methodname(address : pointer) : shortstring;
    function fieldaddress(const name : shortstring) : pointer;
    procedure AfterConstruction;virtual;
    procedure BeforeDestruction;virtual;
    procedure DefaultHandlerStr(var message);virtual;
  end;
  TClass = Class Of TObject;
  PClass = ^TClass;

Unhandled exceptions can be treated using a constant of the TExceptProc type:


TExceptProc = Procedure (Obj : TObject; Addr,Frame: Pointer);

Obj is the exception object that was used to raise the exception, Addr and Frame contain the exact address and stack frame where the exception was raised.

The TVarRec type is used to access the elements passed in a \var{Array of Const} argument to a function or procedure:


Type
  PVarRec = ^TVarRec;
  TVarRec = record
    case VType : Longint of
    vtInteger    : (VInteger: Longint);
    vtBoolean    : (VBoolean: Boolean);
    vtChar       : (VChar: Char);
    vtExtended   : (VExtended: PExtended);
    vtString     : (VString: PShortString);
    vtPointer    : (VPointer: Pointer);
    vtPChar      : (VPChar: PChar);
    vtObject     : (VObject: TObject);
    vtClass      : (VClass: TClass);
    vtAnsiString : (VAnsiString: Pointer);
    vtWideString : (VWideString: Pointer);
    vtInt64      : (VInt64: PInt64);
  end;

The heap manager uses the TMemoryManager type:


  PMemoryManager = ^TMemoryManager;
  TMemoryManager = record
    Getmem      : Function(Size:Longint):Pointer;
    Freemem     : Function(var p:pointer):Longint;
    FreememSize : Function(var p:pointer;Size:Longint):Longint;
    AllocMem    : Function(Size:longint):Pointer;
    ReAllocMem  : Function(var p:pointer;Size:longint):Pointer;
    MemSize     : function(p:pointer):Longint;
    MemAvail    : Function:Longint;
    MaxAvail    : Function:Longint;
    HeapSize    : Function:Longint;
  end;

More information on using this record can be found in \progref.

Constants

The following constants define the maximum values that can be used with various types:


  MaxSIntValue = High(ValSInt);
  MaxUIntValue = High(ValUInt);
  maxint   = maxsmallint;
  maxLongint  = $7fffffff;
  maxSmallint = 32767;

The following constants for file-handling are defined in the system unit:


Const
  fmclosed = $D7B0;
  fminput  = $D7B1;
  fmoutput = $D7B2;
  fminout  = $D7B3;
  fmappend = $D7B4;
  filemode : byte = 2;

The filemode variable is used when a non-text file is opened using Reset. It indicates how the file will be opened. filemode can have one of the following values:

0: The file is opened for reading.
1: The file is opened for writing.
2: The file is opened for reading and writing.

The default value is 2. Other values are possible but are operating system specific.

Further, the following non processor specific general-purpose constants are also defined:


const
  erroraddr : pointer = nil;
  errorcode : word = 0;
 { max level in dumping on error }
  max_frame_dump : word = 20;

Processor specific global constants are named Testxxxx where xxxx represents the processor number (such as Test8086, Test68000), and are used to determine on what generation of processor the program is running on.

The following constants are defined to access VMT entries:


   vmtInstanceSize         = 0;
   vmtParent               = 8;
   vmtClassName            = 12;
   vmtDynamicTable         = 16;
   vmtMethodTable          = 20;
   vmtFieldTable           = 24;
   vmtTypeInfo             = 28;
   vmtInitTable            = 32;
   vmtAutoTable            = 36;
   vmtIntfTable            = 40;
   vmtMsgStrPtr            = 44;
   vmtMethodStart          = 48;
   vmtDestroy              = vmtMethodStart;
   vmtNewInstance          = vmtMethodStart+4;
   vmtFreeInstance         = vmtMethodStart+8;
   vmtSafeCallException    = vmtMethodStart+12;
   vmtDefaultHandler       = vmtMethodStart+16;
   vmtAfterConstruction    = vmtMethodStart+20;
   vmtBeforeDestruction    = vmtMethodStart+24;
   vmtDefaultHandlerStr    = vmtMethodStart+28;

The constant names should be used, and never their values, because the VMT table can change, breaking code that uses direct values.

The following constants will be used for the planned variant support:


  varEmpty     = $0000;
  varNull      = $0001;
  varSmallint  = $0002;
  varInteger   = $0003;
  varSingle    = $0004;
  varDouble    = $0005;
  varCurrency  = $0006;
  varDate      = $0007;
  varOleStr    = $0008;
  varDispatch  = $0009;
  varError     = $000A;
  varBoolean   = $000B;
  varVariant   = $000C;
  varUnknown   = $000D;
  varByte      = $0011;
  varString    = $0100;
  varAny       = $0101;
  varTypeMask  = $0FFF;
  varArray     = $2000;
  varByRef     = $4000;

The following constants are used in the TVarRec record:


vtInteger    = 0;
vtBoolean    = 1;
vtChar       = 2;
vtExtended   = 3;
vtString     = 4;
vtPointer    = 5;
vtPChar      = 6;
vtObject     = 7;
vtClass      = 8;
vtWideChar   = 9;
vtPWideChar  = 10;
vtAnsiString = 11;
vtCurrency   = 12;
vtVariant    = 13;
vtInterface  = 14;
vtWideString = 15;
vtInt64      = 16;
vtQWord      = 17;

The ExceptProc is called when an unhandled exception occurs:


Const
  ExceptProc : TExceptProc = Nil;

It is set in the objpas unit, but it can be set by the programmer to change the default exception handling.

The following constants are defined to describe the operating system's file system:


LineEnding = #10;
LFNSupport = true;
DirectorySeparator = '/';
DriveSeparator = ':';
PathSeparator = ':';
FileNameCaseSensitive : Boolean = True;

The shown values are for unix platforms, but will be different on other platforms. The meaning of the constants is the following:

LineEnding: End of line marker. This constant is used when writing end of lines to text files.
LFNSupport: This is True if the system supports long file names, i.e. filenames that are not restricted to 8.3 characters.
DirectorySeparator: The character that is used as a directory separator, i.e. it appears between various parts of a path to a file.
DriveSeparator: On systems that support drive letters, this character separates the drive indication from the rest of a filename.
PathSeparator: This character can be found between elements in a series of paths (such as the contents of the PATH environment variable.
FileNameCaseSensitive: Indicates whether filenames are case sensitive.

When programming cross-platform, use these constants instead of hard-coded characters. This will enhance portability of an application.

Variables

The following variables are defined and initialized in the system unit:


var
  output,input,stderr : text;
  exitproc : pointer;
  exitcode : word;
  stackbottom : Cardinal;

The variables ExitProc, exitcode are used in the Free Pascal exit scheme. It works similarly to the one in Turbo Pascal:

When a program halts (be it through the call of the Halt function or Exit or through a run-time error), the exit mechanism checks the value of ExitProc. If this one is non-Nil, it is set to Nil, and the procedure is called. If the exit procedure exits, the value of ExitProc is checked again. If it is non-Nil then the above steps are repeated. So when an exit procedure must be installed, the old value of ExitProc should be saved (it may be non-Nil, since other units could have set it). In the exit procedure the value of ExitProc should be restored to the previous value, such that if it was non-Nil the exit-procedure can be called.

The ErrorAddr and ExitCode can be used to check for error-conditions. If ErrorAddr is non-Nil, a run-time error has occurred. If so, ExitCode contains the error code. If ErrorAddr is Nil, then {ExitCode} contains the argument to Halt or 0 if the program terminated normally.

ExitCode is always passed to the operating system as the exit-code of the current process.

The maximum error code under linux and unix like operating systems is 127.

Under GO32, the following constants are also defined :


const
   seg0040 = $0040;
   segA000 = $A000;
   segB000 = $B000;
   segB800 = $B800;

These constants allow easy access to the bios/screen segment via mem/absolute.

The randomize function uses a seed stored in the RandSeed variable:


  RandSeed    : Cardinal;

This variable is initialized in the initialization code of the system unit.

Other variables indicate the state of the application.


  IsLibrary : boolean;
  IsMultiThread : boolean;

The IsLibrary variable is set to true if this module is a shared library instead of an application. The IsMultiThread variable is set to True if the application has spawned other threads, otherwise, and by default, it is set to False.

File handling functions

Functions concerning input and output from and to file.

	Name	Description
	Open a file in append mode
	Assign a name to a file
	Read data from a file into memory
	Write data from memory to a file
	Close a file
	Check for end of file
	Check for end of line
	Delete file from disk
	Position in file
	Size of file
	Write file buffers to disk
	Return result of last file IO operation
	Read from file into variable
	Read from file into variable and goto next line
	Rename file on disk
	Open file for reading
	Open file for writing
	Set file position
	Set file position to end of file
	Set file position to end of line
	Set size of file buffer
	Truncate the file at position
	Write variable to file
	Write variable to file and append newline

Memory management functions

Functions concerning memory issues.

	Name	Description
	Return address of variable
	Check if a pointer is valid
	Compare 2 memory buffers byte per byte
	Compare 2 memory buffers byte per byte
	Compare 2 memory buffers byte per byte
	Compare 2 memory buffers byte per byte
	Return code segment
	Free dynamically allocated memory
	Return data segment
	Fill memory region with 8-bit pattern
	Fill memory region with certain character
	Fill memory region with 32-bit pattern
	Fill memory region with 16-bit pattern
	Release allocated memory
	Allocate new memory
	Return current memory manager
	Return highest index of open array or enumerated
	Is the memory manager set
	Return lowest index of open array or enumerated
	Move data from one location in memory to another
MoveChar0	Move data till first zero character
	Dynamically allocate memory for variable
	Return offset of variable
	Combine segment and offset to pointer
	Resize a memory block on the heap
	Return segment
	Set a memory manager
	Return current stack pointer
	Return stack segment register value

Mathematical routines

Functions connected to calculating and coverting numbers.

	Name	Description
	Calculate absolute value
	Calculate inverse tangent
	Calculate cosine of angle
	Decrease value of variable
	Exponentiate
	Return fractional part of floating point value
	Return high byte/word of value
	Increase value of variable
	Calculate integer part of floating point value
	Calculate logarithm
	Return low byte/word of value
	Is a value odd or even ?
	Return the value of pi
	Raise float to integer power
	Generate random number
	Initialize random number generator
	Round floating point value to nearest integer number
	Calculate sine of angle
	Calculate the square of a value
	Calculate the square root of a value
	Swap high and low bytes/words of a variable
	Truncate a floating point value

String handling

All things connected to string handling.

	Name	Description
	Construct binary representation of integer
	Convert ASCII code to character
	Concatenate two strings
	Copy part of a string
	Delete part of a string
	Construct hexadecimal representation of integer
	Insert one string in another
	Return length of string
	Convert string to all-lowercase
	Construct octal representation of integer
	Calculate position of one string in another
	Set length of a string
	Set contents and length of a string
	Convert number to string representation
	Create string consisting of a number of characters
	Convert string to all-uppercase
	Convert string to number

Operating System functions

Functions that are connected to the operating system.

	Name	Description
	Change working directory
	Return current working directory
	Halt program execution
	Number of parameters with which program was called
	Retrieve parameters with which program was called
	Make a directory
	Remove a directory
	Abort program execution with error condition

Miscellaneous functions

Functions that do not belong in one of the other categories.

	Name	Description
	Conditionally abort program with error
	Abort current loop
	Next cycle in current loop
	Exclude an element from a set
	Exit current function or procedure
	Include an element into a set
	Jump to execution point
	Return ordinal value of enumerated type
	Return previous value of ordinal type
	Mark execution point for jump
	Return size of variable or type
	Return next value of ordinal type

Calculate absolute value Abs returns the absolute value of a variable. The result of the function has the same type as its argument, which can be any numerical type. None. Return address of a variable Addr returns a pointer to its argument, which can be any type, or a function or procedure name. The returned pointer isn't typed. The same result can be obtained by the @ operator, which can return a typed pointer (\progref). None Open a file in append mode Append opens an existing file in append mode. Any data written to F will be appended to the file. Only text files can be opened in append mode. After a call to Append, the file F becomes write-only. File sharing is not taken into account when calling Append. If the file doesn't exist when appending, a run-time error will be generated. This behaviour has changed on Windows and Linux platforms, where in versions prior to 1.0.6, the file would be created in append mode. Calculate inverse tangent Arctan returns the Arctangent of X, which can be any Real type. The resulting angle is in radial units. None Check validity of a given condition. With assertions on, Assert tests if expr is false, and if so, aborts the application with a Runtime error 227 and an optional error message in msg. If expr is true, program execution continues normally. If assertions are not enabled at compile time, this routine does nothing, and no code is generated for the Assert call. Enabling and disabling assertions at compile time is done via the \$C or \$ASSERTIONS compiler switches. These are global switches. The default behavior of the assert call can be changed by setting a new handler in the AssertErrorProc variable. Sysutils overrides the default handler to raise a EAssertionFailed exception. None. Assign a name to a file Assign assigns a name to F, which can be any file type. This call doesn't open the file, it just assigns a name to a file variable, and marks the file as closed. None. Check if a pointer is valid Assigned returns True if P is non-nil and retuns False of P is nil. The main use of Assigned is that Procedural variables, method variables and class-type variables also can be passed to Assigned. None Convert integer to string with binary representation. BinStr returns a string with the binary representation of Value. The string has at most cnt characters. (i.e. only the cnt rightmost bits are taken into account) To have a complete representation of any longint-type value, 32 bits are needed, i.e. cnt=32 None. Read data from an untyped file into memory Blockread reads count or less records from file F. A record is a block of bytes with size specified by the or statement. The result is placed in Buffer, which must contain enough room for Count records. The function cannot read partial records. If Result is specified, it contains the number of records actually read. If Result isn't specified, and less than Count records were read, a run-time error is generated. This behavior can be controlled by the \var{\{\$i\}} switch. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Write data from memory to an untyped file BlockWrite writes count records from buffer to the file F.A record is a block of bytes with size specified by the or statement. If the records couldn't be written to disk, a run-time error is generated. This behavior can be controlled by the \var{\{\$i\}} switch. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. For the example, see . Exit current loop construct.

Break jumps to the statement following the end of the current repetitive statement. The code between the Break call and the end of the repetitive statement is skipped. The condition of the repetitive statement is NOT evaluated.

This can be used with For, var{repeat} and While statements.

Note that while this is a procedure, Break is a reserved word and hence cannot be redefined.

None. Change current working directory. Chdir changes the working directory of the process to S. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Convert byte value to character value Chr returns the character which has ASCII value X. None. Close a file Close flushes the buffer of the file F and closes F. After a call to Close, data can no longer be read from or written to F. To reopen a file closed with Close, it isn't necessary to assign the file again. A call to or is sufficient. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Compare 2 memory buffers byte per byte

CompareByte compares two memory regions buf1,buf2 on a byte-per-byte basis for a total of len bytes.

The function returns one of the following values:

less than 0: if buf1 and buf2 contain different bytes in the first len bytes, and the first such byte is smaller in buf1 than the byte at the same position in buf2.
0: if the first len bytes in buf1 and buf2 are equal. \item [greater than 0] if buf1 and buf2 contain different bytes in the first len bytes, and the first such byte is larger in buf1 than the byte at the same position in buf2.

None. ompare 2 memory buffers character per character

CompareChar compares two memory regions buf1,buf2 on a character-per-character basis for a total of len characters.

The CompareChar0 variant compares len bytes, or until a zero character is found.

The function returns one of the following values:

-1: if buf1 and buf2 contain different characters in the first len positions, and the first such character is smaller in buf1 than the character at the same position in buf2.
0: if the first len characters in buf1 and buf2 are equal.
1: if buf1 and buf2 contain different characters in the first len positions, and the first such character is larger in buf1 than the character at the same position in buf2.

None. Compare 2 memory buffers DWord per DWord

CompareDWord compares two memory regions buf1,buf2 on a DWord-per-DWord basis for a total of len DWords. (A DWord is 4 bytes).

The function returns one of the following values:

-1: if buf1 and buf2 contain different DWords in the first len DWords, and the first such DWord is smaller in buf1 than the DWord at the same position in buf2.
0: if the first len DWords in buf1 and buf2 are equal.
1: if buf1 and buf2 contain different DWords in the first len DWords, and the first such DWord is larger in buf1 than the DWord at the same position in buf2.

None. , Compare 2 memory buffers word per word

CompareWord compares two memory regions buf1,buf2 on a Word-per-Word basis for a total of len Words. (A Word is 2 bytes).

The function returns one of the following values:

-1: if buf1 and buf2 contain different Words in the first len Words, and the first such Word is smaller in buf1 than the Word at the same position in buf2.
0: if the first len Words in buf1 and buf2 are equal.
1: if buf1 and buf2 contain different Words in the first len Words, and the first such Word is larger in buf1 than the Word at the same position in buf2.

None. , Append one string to another. Concat concatenates the strings S1,S2 etc. to one long string. The resulting string is truncated at a length of 255 bytes. The same operation can be performed with the + operation. None. Continue with next loop cycle.

Continue jumps to the end of the current repetitive statement. The code between the Continue call and the end of the repetitive statement is skipped. The condition of the repetitive statement is then checked again.

This can be used with For, var{repeat} and While statements.

Note that while this is a procedure, Continue is a reserved word and hence cannot be redefined.

None. Copy part of a string. Copy returns a string which is a copy if the Count characters in S, starting at position Index. If Count is larger than the length of the string S, the result is truncated. If Index is larger than the length of the string S, then an empty string is returned. None. Calculate cosine of angle Cos returns the cosine of X, where X is an angle, in radians. If the absolute value of the argument is larger than \var{2\^{}63}, then the result is undefined. None. Return code segment CSeg returns the Code segment register. In Free Pascal, it returns always a zero, since Free Pascal is a 32 bit compiler. None. Decrease value of variable Dec decreases the value of X with Decrement. If Decrement isn't specified, then 1 is taken as a default. A range check can occur, or an underflow error, if an attempt it made to decrease X below its minimum value. Delete part of a string. Delete removes Count characters from string S, starting at position Index. All characters after the delected characters are shifted Count positions to the left, and the length of the string is adjusted. None. Free dynamically allocated memory

The first form Dispose releases the memory allocated with a call to . The pointer P must be typed. The released memory is returned to the heap.

The second form of Dispose accepts as a first parameter a pointer to an object type, and as a second parameter the name of a destructor of this object. The destructor will be called, and the memory allocated for the object will be freed.

An runtime error will occur if the pointer doesn't point to a location in the heap. Return data segment DSeg returns the data segment register. In Free Pascal, it returns always a zero, since Free Pascal is a 32 bit compiler. None. Check for end of file Eof returns True if the file-pointer has reached the end of the file, or if the file is empty. In all other cases Eof returns False. If no file F is specified, standard input is assumed. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Check for end of line Eof returns True if the file pointer has reached the end of a line, which is demarcated by a line-feed character (ASCII value 10), or if the end of the file is reached. In all other cases Eof returns False. If no file F is specified, standard input is assumed. It can only be used on files of type Text. None. Delete a file from disk Erase removes an unopened file from disk. The file should be assigned with Assign, but not opened with Reset or Rewrite Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Exlude element from a set if it is present.

Exclude removes E from the set S if it is included inthe set. E should be of the same type as the base type of the set S.

Thus, the two following statements do the same thing:


S:=S-[E];
Exclude(S,E);

If the type of the element E is not equal to the base type of the set S, the compiler will generate an error. Exit current subroutine. Exit exits the current subroutine, and returns control to the calling routine. If invoked in the main program routine, exit stops the program. The optional argument X allows to specify a return value, in the case Exit is invoked in a function. The function result will then be equal to X. None. Exponentiate Exp returns the exponent of X, i.e. the number e to the power X. None. Get position in file Filepos returns the current record position of the file-pointer in file F. It cannot be invoked with a file of type Text. A compiler error will be generated if this is attempted. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Size of file Filesize returns the total number of records in file F. It cannot be invoked with a file of type Text. (under linux and unix, this also means that it cannot be invoked on pipes). If F is empty, 0 is returned. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Fill memory region with 8-bit pattern FillByte fills the memory starting at X with Count bytes with value equal to Value. This is useful for quickly zeroing out a memory location. When the size of the memory location to be filled out is a multiple of 2 bytes, it is better to use , and if it is a multiple of 4 bytes it is better to use , these routines are optimized for their respective sizes. No checking on the size of X is done. Fill memory region with certain character Fillchar fills the memory starting at X with Count bytes or characters with value equal to Value. No checking on the size of X is done. Fill memory region with 32-bit pattern Fillword fills the memory starting at X with Count DWords with value equal to Value. A DWord is 4 bytes in size. No checking on the size of X is done. Fill memory region with 16-bit pattern Fillword fills the memory starting at X with Count words with value equal to Value. A word is 2 bytes in size. No checking on the size of X is done. Write file buffers to disk Flush empties the internal buffer of an opened file F and writes the contents to disk. The file is \textit{not} closed as a result of this call. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Return fractional part of floating point value. Frac returns the non-integer part of X. None. Release allocated memory Freemem releases the memory occupied by the pointer P, of size Count (in bytes), and returns it to the heap. P should point to the memory allocated to a dynamic variable. An error will occur when P doesn't point to the heap. Return the current directory Getdir returns in dir the current directory on the drive drivenr, where {drivenr} is 1 for the first floppy drive, 3 for the first hard disk etc. A value of 0 returns the directory on the current disk. On linux and unix systems, drivenr is ignored, as there is only one directory tree. An error is returned under dos, if the drive requested isn't ready. Allocate new memory on the heap

Getmem reserves Size bytes memory on the heap, and returns a pointer to this memory in p. If no more memory is available, nil is returned.

For an example, see .

None. Return current memory manager

GetMemoryManager stores the current Memory Manager record in MemMgr.

For an example, see \progref.

None. . Stop program execution. Halt stops program execution and returns control to the calling program. The optional argument Errnum specifies an exit value. If omitted, zero is returned. None. Convert integer value to string with hexadecimal representation. HexStr returns a string with the hexadecimal representation of Value. The string has exactly cnt charaters. (i.e. only the cnt rightmost nibbles are taken into account) To have a complete representation of a Longint-type value, 8 nibbles are needed, i.e. cnt=8. None. Return high byte/word of value. Hi returns the high byte or word from X, depending on the size of X. If the size of X is 4, then the high word is returned. If the size is 2 then the high byte is returned. Hi cannot be invoked on types of size 1, such as byte or char. None Return highest index of open array or enumerated

The return value of High depends on it's argument:

If the argument is an ordinal type, High returns the highest value in the range of the given ordinal type.
If the argument is an array type or an array type variable then High returns the highest possible value of it's index.
If the argument is an open array identifier in a function or procedure, then High returns the highest index of the array, as if the array has a zero-based index.

The return type is always the same type as the type of the argument (This can lead to some nasty surprises !).

None. Increase value of integer variable Inc increases the value of X with Increment. If Increment isn't specified, then 1 is taken as a default. If range checking is on, then A range check can occur, or an overflow error, when an attempt is made to increase X over its maximum value. Include element in set if it was not yet present.

Include includes E in the set S if it is not yet part of the set. E should be of the same type as the base type of the set S.

Thus, the two following statements do the same thing:


S:=S+[E];
Include(S,E);

For an example, see

If the type of the element E is not equal to the base type of the set S, the compiler will generate an error. Search for a byte in a memory range. IndexByte searches the memory at buf for maximally len positions for the byte b and returns it's position if it found one. If b is not found then -1 is returned. The position is zero-based. Buf and Len are not checked to see if they are valid values. Search for a character in a memory range. IndexChar searches the memory at buf for maximally len positions for the character b and returns it's position if it found one. If b is not found then -1 is returned. The position is zero-based. The IndexChar0 variant stops looking if a null character is found, and returns -1 in that case. Buf and Len are not checked to see if they are valid values. Search for a DWord value in a memory range. IndexChar searches the memory at buf for maximally len positions for the DWord DW and returns it's position if it found one. If DW is not found then -1 is returned. The position is zero-based. Buf and Len are not checked to see if they are valid values. Search for a WORD value in a memory range. IndexChar searches the memory at buf for maximally len positions for the Word W and returns it's position if it found one. If W is not found then -1 is returned. Buf and Len are not checked to see if they are valid values. Insert one string in another. Insert inserts string Source in string S, at position Index, shifting all characters after Index to the right. The resulting string is truncated at 255 characters, if needed. (i.e. for shortstrings) None. Is the memory manager set IsMemoryManagerSet will return True if the memory manager has been set to another value than the system heap manager, it will return False otherwise. None. Calculate integer part of floating point value. Int returns the integer part of any Real X, as a Real. None. Return result of last file IO operation

IOresult contains the result of any input/output call, when the {\$i-} compiler directive is active, disabling IO checking. When the flag is read, it is reset to zero. If IOresult is zero, the operation completed successfully. If non-zero, an error occurred. The following errors can occur:

dos errors :

2: File not found.
3: Path not found.
4: Too many open files.
5: Access denied.
6: Invalid file handle.
12: Invalid file-access mode.
15: Invalid disk number.
16: Cannot remove current directory.
17: Cannot rename across volumes.

I/O errors :

100: Error when reading from disk.
101: Error when writing to disk.
102: File not assigned.
103: File not open.
104: File not opened for input.
105: File not opened for output.
106: Invalid number.

Fatal errors :

150: Disk is write protected.
151: Unknown device.
152: Drive not ready.
153: Unknown command.
154: CRC check failed.
155: Invalid drive specified..
156: Seek error on disk.
157: Invalid media type.
158: Sector not found.
159: Printer out of paper.
160: Error when writing to device.
161: Error when reading from device.
162: Hardware failure.

None. All I/O functions. Calculate length of a string. Length returns the length of the string S, which is limited to 255 for shortstrings. If the strings S is empty, 0 is returned. Note: The length of the string S is stored in S[0] for shortstrings only. The Length fuction should always be used on ansistrings and widestrings. None. Calculate logarithm Ln returns the natural logarithm of the Real parameter X. X must be positive. An run-time error will occur when X is negative. Return low byte/word of value. Lo returns the low byte of its argument if this is of type Integer or Word. It returns the low word of its argument if this is of type Longint or Cardinal. None. Jump to address.

LongJmp jumps to the adress in the env jmp_buf, and restores the registers that were stored in it at the corresponding call. In effect, program flow will continue at the SetJmp call, which will return value instead of 0. If a value equal to zero is passed, it will be converted to 1 before passing it on. The call will not return, so it must be used with extreme care. This can be used for error recovery, for instance when a segmentation fault occurred.

For an example, see

None. Return lowest index of open array or enumerated

The return value of Low depends on it's argument:

If the argument is an ordinal type, Low returns the lowest value in the range of the given ordinal type.
If the argument is an array type or an array type variable then Low returns the lowest possible value of it's index.

The return type is always the same type as the type of the argument.

for an example, see .

None. Return lowercase version of a string. Lowercase returns the lowercase version of its argument C. If its argument is a string, then the complete string is converted to lowercase. The type of the returned value is the same as the type of the argument. None. Mark current memory position This routine is here for compatibility with Turbo Pascal, but it is not implemented and currently does nothing. None. Return size of largest free memory block

Maxavail returns the size, in bytes, of the biggest free memory block in the heap.

The heap grows dynamically if more memory is needed than is available. None. Return total available memory

Memavail returns the size, in bytes, of the free heap memory.

The heap grows dynamically if more memory is needed than is available. The heap size is not equal to the size of the memory available to the operating system, it is internal to the programs created by Free Pascal. None. Create a new directory.

Mkdir creates a new directory S.

For an example, see .

Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Move data from one location in memory to another Move moves Count bytes from Source to Dest. If either Dest or Source is outside the accessible memory for the process, then a run-time error will be generated. Move data till first zero character MoveChar0 moves Count bytes from Src to Dest, and stops moving if a zero character is found. No checking is done to see if Count stays within the memory allocated to the process. Dynamically allocate memory for variable

New allocates a new instance of the type pointed to by P, and puts the address in P. If P is an object, then it is possible to specify the name of the constructor with which the instance will be created.

For an example, see .

If not enough memory is available, Nil will be returned. Is a value odd or even ? Odd returns True if X is odd, or False otherwise. None. Convert integer to a string with octal representation. OctStr returns a string with the octal representation of Value. The string has exactly cnt charaters. None. Return offset of a variable. Ofs returns the offset of the address of a variable. This function is only supported for compatibility. In Free Pascal, it returns always the complete address of the variable, since Free Pascal is a 32 bit compiler. None. Return ordinal value of an ordinal type. Ord returns the Ordinal value of a ordinal-type variable X. None. Return number of command-line parameters passed to the program. Paramcount returns the number of command-line arguments. If no arguments were given to the running program, 0 is returned. None. Return value of a command-line argument.

Paramstr returns the L-th command-line argument. L must be between 0 and Paramcount, these values included. The zeroth argument is the path and file name with which the program was started.

The command-line parameters will be truncated to a length of 255, even though the operating system may support bigger command-lines. The Objpas unit (used in objfpc or delphi mode) define versions of Paramstr which return the full-length command-line arguments.

When the complete command-line must be accessed, the argv pointer should be used to retrieve the real values of the command-line parameters.

For an example, see .

None. Return the value of PI. Pi returns the value of Pi (3.1415926535897932385). None. Search for substring in a string. Pos returns the index of Substr in S, if S contains Substr. In case Substr isn't found, 0 is returned. The search is case-sensitive. None Raise float to integer power

Power returns the value of base to the power expon. Base and expon can be of type Longint, in which case the result will also be a Longint.

The function actually returns Exp(expon*Ln(base))

None. Return previous element for an ordinal type.

Pred returns the element that precedes the element that was passed to it. If it is applied to the first value of the ordinal type, and the program was compiled with range checking on (\var{\{\$R+\}}, then a run-time error will be generated.

for an example, see

Run-time error 201 is generated when the result is out of range. Combine segment and offset to pointer

Ptr returns a pointer, pointing to the address specified by segment Sel and offset Off.

In the 32-bit flat-memory model supported by Free Pascal, this function is obsolete.
The returned address is simply the offset.

None. Generate random number Random returns a random number larger or equal to 0 and strictly less than L. If the argument L is omitted, a Real number between 0 and 1 is returned. (0 included, 1 excluded) None. Initialize random number generator

Randomize initializes the random number generator of Free Pascal, by giving a value to Randseed, calculated with the system clock.

For an example, see .

None. Read from a text file into variable Read reads one or more values from a file F, and stores the result in V1, V2, etc.; If no file F is specified, then standard input is read. If F is of type Text, then the variables V1, V2 etc. must be of type Char, Integer, Real, String or PChar. If F is a typed file, then each of the variables must be of the type specified in the declaration of F. Untyped files are not allowed as an argument. If no data is available, a run-time error is generated. This behavior can be controlled with the \var{\{\$i\}} compiler switch. Read from a text file into variable and goto next line

Read reads one or more values from a file F, and stores the result in V1, V2, etc. After that it goes to the next line in the file. The end of the line is marked by the LineEnding character sequence (which is platform dependent). The end-of-line marker is not considered part of the line and is ignored.

If no file F is specified, then standard input is read. The variables V1, V2 etc. must be of type Char, Integer, Real, String or PChar.

For an example, see .

If no data is available, a run-time error is generated. This behavior can be controlled with the \var{\{\$i\}} compiler switch. Convert Turbo Pascal style real to double.

The Real2Double function converts a Turbo Pascal style real (6 bytes long) to a native Free Pascal double type. It can be used e.g. to read old binary TP files with FPC and convert them to Free Pacal binary files.

Note that the assignment operator has been overloaded so a Real48 type can be assigned directly to a double or extended.

None. Release memory above mark point This routine is here for compatibility with Turbo Pascal, but it is not implemented and currently does nothing. None. Rename file on disk Rename changes the name of the assigned file F to S. F must be assigned, but not opened. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Open file for reading Reset opens a file F for reading. F can be any file type. If F is a text file, or refers to standard I/O (e.g : '') then it is opened read-only, otherwise it is opened using the mode specified in filemode. If F is an untyped file, the record size can be specified in the optional parameter L. A default value of 128 is used. File sharing is not taken into account when calling Reset. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Open file for writing Rewrite opens a file F for writing. F can be any file type. If F is an untyped or typed file, then it is opened for reading and writing. If F is an untyped file, the record size can be specified in the optional parameter L. Default a value of 128 is used. if Rewrite finds a file with the same name as F, this file is truncated to length 0. If it doesn't find such a file, a new file is created. Contrary to Turbo Pascal, Free Pascal opens the file with mode fmoutput. If it should be opened in fminout mode, an extra call to is needed. File sharing is not taken into account when calling Rewrite. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Remove directory when empty. Rmdir removes the directory S. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Round floating point value to nearest integer number. Round rounds X to the closest integer, which may be bigger or smaller than X. None. Generate a run-time error. Runerror stops the execution of the program, and generates a run-time error ErrorCode. None. Set file position Seek sets the file-pointer for file F to record Nr. Count. The first record in a file has Count=0. F can be any file type, except Text. If F is an untyped file, with no record size specified in or , 128 is assumed. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. Set file position to end of file SeekEof returns True is the file-pointer is at the end of the file. It ignores all whitespace. Calling this function has the effect that the file-position is advanced until the first non-whitespace character or the end-of-file marker is reached. If the end-of-file marker is reached, True is returned. Otherwise, False is returned. If the parameter F is omitted, standard Input is assumed. A run-time error is generated if the file F isn't opened. Set file position to end of line SeekEoln returns True is the file-pointer is at the end of the current line. It ignores all whitespace. Calling this function has the effect that the file-position is advanced until the first non-whitespace character or the end-of-line marker is reached. If the end-of-line marker is reached, True is returned. Otherwise, False is returned. The end-of-line marker is defined as #10, the LineFeed character. If the parameter F is omitted, standard Input is assumed. A run-time error is generated if the file F isn't opened. Return segment Seg returns the segment of the address of a variable. This function is only supported for compatibility. In Free Pascal, it returns always 0, since Free Pascal is a 32 bit compiler, segments have no meaning. None. Set a memory manager

SetMemoryManager sets the current memory manager record to MemMgr.

For an example, see \progref.

None. Save current execution point. SetJmp fills env with the necessary data for a jump back to the point where it was called. It returns zero if called in this way. If the function returns nonzero, then it means that a call to with env as an argument was made somewhere in the program. None. Set length of a string. SetLength sets the length of the string S to Len. S can be an ansistring, a short string or a widestring. For ShortStrings, Len can maximally be 255. For AnsiStrings it can have any value. For AnsiString strings, SetLength {\em must} be used to set the length of the string. None. Set length of a string and copy buffer. SetString sets the length of the string S to Len and if Buf is non-nil, copies Len characters from Buf into S. S can be an ansistring, a short string or a widestring. For ShortStrings, Len can maximally be 255. None. Set size of text file internal buffer

SetTextBuf assigns an I/O buffer to a text file. The new buffer is located at Buf and is Size bytes long. If Size is omitted, then SizeOf(Buf) is assumed. The standard buffer of any text file is 128 bytes long. For heavy I/O operations this may prove too slow. The SetTextBuf procedure allows to set a bigger buffer for the IO of the application, thus reducing the number of system calls, and thus reducing the load on the system resources. The maximum size of the newly assigned buffer is 65355 bytes.

Never assign a new buffer to an opened file. A new buffer can be assigned immediately after a call to or Append, but not after the file was read from/written to. This may cause loss of data. If a new buffer must be assigned after read/write operations have been performed, the file should be flushed first. This will ensure that the current buffer is emptied.
Take care that the assigned buffer is always valid. If a local variable is assigned as a buffer, then after the program exits the local program block, the buffer will no longer be valid, and stack problems may occur.

No checking on Size is done. Calculate sine of angle Sin returns the sine of its argument X, where X is an angle in radians. If the absolute value of the argument is larger than \var{2\^{}63}, then the result is undefined. None. Return size of a variable or type.

SizeOf returns the size, in bytes, of any variable or type-identifier.

This isn't really a RTL function. Its result is calculated at compile-time, and hard-coded in the executable. None. Return current stack pointer Sptr returns the current stack pointer. None. Calculate the square of a value. Sqr returns the square of its argument X. None. Calculate the square root of a value Sqrt returns the square root of its argument X, which must be positive. If X is negative, then a run-time error is generated. Return stack segment register value. SSeg returns the Stack Segment. This function is only supported for compatibility reasons, as Sptr returns the correct contents of the stackpointer. None. Convert a numerical value to a string. Str returns a string which represents the value of X. X can be any numerical type. The optional NumPLaces and Decimals specifiers control the formatting of the string. None. Return a string consisting of 1 character repeated N times.

StringOfChar creates a new String of length l and fills it with the character c.

It is equivalent to the following calls:


SetLength(StringOfChar,l);
FillChar(Pointer(StringOfChar)^,Length(StringOfChar),c);

None. Return next element of ordinal type.

Succ returns the element that succeeds the element that was passed to it. If it is applied to the last value of the ordinal type, and the program was compiled with range checking on (\var{\{\$R+\}}), then a run-time error will be generated.

for an example, see .

Run-time error 201 is generated when the result is out of range. Swap high and low bytes/words of a variable Swap swaps the high and low order bytes of X if X is of type Word or Integer, or swaps the high and low order words of X if X is of type Longint or Cardinal. The return type is the type of X None. Truncate a floating point value. Trunc returns the integer part of X, which is always smaller than (or equal to) X in absolute value. None. Truncate the file at position Truncate truncates the (opened) file F at the current file position. Depending on the state of the \var{\{\$I\}} switch, a runtime error can be generated if there is an error. In the \var{\{\$I-\}} state, use IOResult to check for errors. , Convert a string to all uppercase. Upcase returns the uppercase version of its argument C. If its argument is a string, then the complete string is converted to uppercase. The type of the returned value is the same as the type of the argument. None. Calculate numerical value of a string. Val converts the value represented in the string S to a numerical value, and stores this value in the variable V, which can be of type Longint, Real and Byte. If the conversion isn't succesfull, then the parameter Code contains the index of the character in S which prevented the conversion. The string S is allowed to contain spaces in the beginning. The string S can contain a number in decimal, hexadecimal, binary or octal format, as described in the language reference. If the conversion doesn't succeed, the value of Code indicates the position where the conversion went wrong. Write variable to a text file Write writes the contents of the variables V1, V2 etc. to the file F. F can be a typed file, or a Text file. If F is a typed file, then the variables V1, V2 etc. must be of the same type as the type in the declaration of F. Untyped files are not allowed. If the parameter F is omitted, standard output is assumed. If F is of type Text, then the necessary conversions are done such that the output of the variables is in human-readable format. This conversion is done for all numerical types. Strings are printed exactly as they are in memory, as well as PChar types. The format of the numerical conversions can be influenced through the following modifiers: OutputVariable : NumChars [: Decimals ] This will print the value of OutputVariable with a minimum of NumChars characters, from which Decimals are reserved for the decimals. If the number cannot be represented with NumChars characters, NumChars will be increased, until the representation fits. If the representation requires less than NumChars characters then the output is filled up with spaces, to the left of the generated string, thus resulting in a right-aligned representation. If no formatting is specified, then the number is written using its natural length, with nothing in front of it if it's positive, and a minus sign if it's negative. Real numbers are, by default, written in scientific notation. If an error occurs, a run-time error is generated. This behavior can be controlled with the \var{\{\$i\}} switch. Write variable to a text file and append newline

WriteLn does the same as for text files, and emits a Carriage Return - LineFeed character pair after that. If the parameter F is omitted, standard output is assumed. If no variables are specified, a Carriage Return - LineFeed character pair is emitted, resulting in a new line in the file F.

Under linux and unix, the Carriage Return character is omitted, as customary in Unix environments. If an error occurs, a run-time error is generated. This behavior can be controlled with the \var{\{\$i\}} switch. A signed 8-bits integer A signed 16-bits integer A signed 32-bits integer An unsigned 8-bits integer An unsigned 16-bits integer An unsigned 32-bits integer An unsigned 32-bits integer. A signed 16-bits integer The system unit defines Integer as a signed 16-bit integer. But when DELPHI or OBJFPC mode are active, then the objpas unit redefines Integer as a 16-bit integer. Pointer to null-terminated string. Or the same as a pointer to an array of char. See the reference manual for more information about this type. Pointer to an array of pointers to null-terminated strings. Alias for 1-byte sized char. Alias for 1-byte sized char. Alias for type. Alias for type. UCS unicode character (unsigned 32 bit word) Pointer to Array of characters. Pointer to array of characters. String of characters. UTF-8 unicode (ansi) string. Pointer to Currency type. 32-Bit signed integer. Encoded Date-Time type. 32-bit signed integer. Pointer to single-sized float value. Pointer to double-sized float value. Pointer to currency type. Pointer to extended-sized float value. Pointer to type Pointer to type Pointer to type Pointer to type Pointer to type Pointer to type Pointer to LongWord type Pointer to type Pointer to type Pointer to QWord type Pointer to Int64 type Pointer to type. Pointer to a type Pointer to a pointer type. Pointer to a type. Pointer to a Boolean type. Pointer to a WordBool type. Pointer to a LongBool type. Pointer to a shortstring type. Pointer to an ansistring type. Pointer to a type. Pointer to an type. Wide char (16-bit sized char) Text line break style. (end of line character) Line-feed only (#10, unix style) Carriage-return, line-feed (#13#30, Windows style) Carriage-return (#13, Mac-OS style) Simple procedural type. Maximum String-size value. Maximum unsigned integer value. Maximum longint value. Maximum smallint value. Maximum integer value. Generic array of integer. Pointer to type Generic pointer array. Pointer to type Dynamic array of integer. Array of PChar Pointer to type. Maximum number of frames to show in error frame dump. Exit procedure pointer. Address where the last error occurred. Last error code. File mode: File is closed. File mode: File is open for reading. File mode: File is open for writing. File mode: File is open for reading and writing. File mode: File is open for writing, appending to the end. Current process ID. Default file mode for untyped files. Current command-line. Indicates whether more than one thread is running in the application. Indicate whether there was a stack error. Exit code for the program, will be communicated to the OS on exit. Seed for function. True if the current module is a library. Otherwise module is an excutable True for console applications, False for GUI applications. Current Thread ID. Standard output text file. Standard input text file. Alias for . Standard diagnostic output text file. Result of last I/O operation. Read-Only. Current stack bottom. Maximum stack length. Return index of a character in null-terminated array of char. IndexChar0 returns the index of the character b in the null-terminated array Buf. At most len characters will be searched, or the null character if it is encountered first. If the character is not found, 0 is returned. On error, 0 is returned. Compare two buffers character by character till a null-character is reached.

CompareChar0 compares 2 buffers buf1 and buf2 for a maximum length of len or till a null character is reached in either buffer. The result depends on the contents of the buffers:

< 0: If buf1 contains a character less than the corresponding character in buf2.
0: If both buffers are equal
> 0: If buf1 contains a character greater than the corresponding character in buf2.

None. Prefetch a memory location Prefetch can be used to optimize the CPU behaviour by already loading a memory location. It is mainly used as a hint for those processors that support it. None. TP compatible real type (6 bytes) definition Convert a null-terminated string to a shortstring. Converts a null terminated string in P to a Pascal string, and returns this string. The string is truncated at 255 characters. None. Length of a null-terminated string. Returns the length of the null-terminated string P. None. Return a string of spaces Space returns a shortstring with length B, consisting of spaces. Make sure reference count of string is 1 UniqueString ensures that the ansistring S has reference count 1. It makes a copy of S if this is necesary, and returns the copy in S None. Set the end-of-line character for the given text file. SetTextLineEnding sets the end-of-line character for the text file F to Ending. By default, this is the string indicated by . None. Return the current frame get_frame returns a pointer to the current stack frame. Return the address of the caller. get_caller_frame returns a pointer to address ( the return address) of the caller of the routine which has as frame framebp. Return the frame pointer of the caller get_caller_frame returns a pointer to the frame of the caller of the routine which has as frame framebp. Dump stack to the given text file. Dump_Stack prints a stack dump to the file f, with base frame pointer bp The file f must be opened for writing or an error will occur. Add an exit procedure to the exit procedure chain. AddExitProc adds Proc to the exit procedure chain. At program exit, all procedures added in this way will be called in reverse order. None. Initialize exceptions. SysInitExceptions initializes the exception system. This procedure should never be called directly, it is taken care of by the RTL. Initialize standard input and output. SysInitStdIO initializes the standard input and output files: , and . This routine is called by the initialization code of the system unit, there should be no need to call it directly. Reset the floating point unit. SysResetFPU resets the floating point unit. There should normally be no need to call this unit; the compiler itself takes care of this. Generate an abstract error. AbstractError generates an abstract error (run-time error 211). If the constant is set, it will be called instead. This routine causes a run-time error 211. Format an address suitable for inclusion in a backtrace SysBackTraceStr will create a string representation of the address Addr, suitable for inclusion in a stack backtrace. None. Standard Assert failure implementation SysAssert is the standard implementation of the assertion failed code. It is the default value of the AssertErrorProc constant. It will print the assert message Msg together with the filename FName and linenumber LineNo to standard error output (StdErr) and will halt the program with exit code 227. The error address ErrorAddr is ignored. Type for formatting of backtrace dump. Standard error handler procedural type. Abstract error handler procedural type. Assert error handler procedural type. Standard backtrace formatting routine This handler is called to get a standard format for the backtrace routine. Custom error handling procedure.

If set, the ErrorProc constant is used when a run-time error occurs. If it is not set, then the standard error handling is done: a stack dump is performed, and the program exits with the indicated error code.

The SysUtils unit sets this procedure and raises an exception in its handler.

Custom abstract error handling procedure

If set, the AbstractErrorProc constant is used when an abstract error occurs. If it is not set, then the standard error handling is done: A stack dump is performed, and the program exits with error code 211.

The SysUtils unit sets this procedure and raises an exception in its handler.

Custom assert error handling procedure

If set, the AbstractErrorProc constant is used when an assert error occurs. If it is not set, then the standard error handling is done: The assertion error message is printed, together with the location of the assertion, and A stack dump is performed, and the program exits with error code 227.

The SysUtils unit sets this procedure and raises an exception in its handler.

Record type to store processor information. EBX register. ESI register EDI register BP register SP register PC register Pointer to record VMT Layout: Location of class instance size in VMT VMT Layout: location of pointer to parent VMT. VMT Layout: location of class name. VMT Layout: location of dynamic methods table. VMT Layout: Method table start. VMT Layout: Location of fields table. VMT Layout: Location of class type information. VMT Layout: ? VMT layout: ? VMT layout: Interface table VMT layout: message strings table. VMT layout: start of method table. VMT Layout: Location of destructor pointer. VMT Layout: location of NewInstance method. VMT Layout: location of FreeInstance method. VMT Layout: ? VMT Layout: ? VMT Layout: ? VMT Layout: ? VMT Layout: ? Alias for Text file type. Parent class for all classes. TObject is used as the parent class for all class definitions. It contains some standard methods that are available in all classes. Class of . Pointer to Record used in string message handler table. Message name Method to call Pointer to array of records. String message table container for class. Record used to describe the string messages handled by a class. It consists of a count, followed by an array of records. Number of messages in the string table. First record. Pointer to record. Pointer to type. Standard GUID representation type. Pointer to record. Interfaces table entry. tinterfaceentry is used to store the list of Interfaces of a class. This list is stored as an array of tinterfaceentry records. Unique GUID for this interface. Pointer to interface VTable. Offset Pointer to GUID string. Always assigned for COM. Pointer to record. Record to store list of interfaces of a class. Number of interfaces. Array of records. Base class of all classes. TObject is the parent root class for all classes in Object Pascal. If a class has no parent class explicitly declared, it is dependent on TObject. TObject introduces class methods that deal with the class' type information, and contains all necessary methods to create an instance at runtime, and to dispatch messages to the correct method (both string and integer messages). TObject Constructor Create creates a new instance of TObject. Currently it does nothing. It is also not virtual, so there is in principle no need to call it directly. Destroy TObject destructor.

Destroy is the destructor of TObject. It will clean up the memory assigned to the instance. Descendent classes should override destroy if they want to do additional clean-up. No other destructor should be implemented.

It is bad programming practice to call Destroy directly. It is better to call the Free method, because that one will check first if Self is different from Nil.

To clean up an instance and reset the refence to the instance, it is best to use the FreeAndNil function.

Create Free Allocate memory on the heap for a new instance NewInstance allocates memory on the heap for a new instance of the current class. If the memory was allocated, the class will be initialized by a call to InitInstance. The function returns the newly initialized instance. If not enough memory is available, a Nil pointer may be returned, or an exception may be raised. Create InitInstance InstanceSize FreeInstance Clean up instance and free the memory reserved for the instance. FreeInstance cleans up an instance of the current class, and releases the heap memory occupied by the class instance. Destroy InitInstance NewInstance Handle exception object SafeCallException should be overridden to handle exceptions in a method marked with the savecall directive. The implementation in TObject simply returns zero. Default handler for integer message handlers. DefaultHandler is the default handler for messages. If a message has an unknown message ID (i.e. does not appear in the table with integer message handlers), then it will be passed to DefaultHandler by the Dispatch method. Dispatch DefaultHandlerStr Check for Nil and call destructor. Free will check the Self pointer and calls Destroy if it is different from Nil. This is a safer method than calling Destroy directly. If a reference to the object must be reset as well (a recommended technque), then the function FreeAndNil should be called. None. Destroy FreeAndNil Initialize a new class instance. InitInstance initializes the memory pointer to by Instance. This means that the VMT is initialized, and the interface pointers are set up correctly. The function returns the newly initialized instance. NewInstance Create Finalize the class instance.

CleanUpinstance finalizes the instance, i.e. takes care of all reference counted objects, by decreasing their reference count by 1, and freeing them if their count reaches zero.

Normally, CleanupInstance should never be called, it is called automatically when the object is freed with it's constructor.

None. Destroy Free InitInstance Return a pointer to the type information for this class. ClassInfo returns a pointer to the type information for this class. This pointer can be used in the various type information routines. Return a "class of" pointer for the current class ClassType returns a class type reference for the current class. ClassInfo ClassName Return the current class name. ClassName returns the class name for the current class, in all-uppercase letters. To check for the class name, use the ClassNameIs class method. None. ClassInfo ClassType ClassNameIs Check whether the class name equals the given name. ClassNameIs checks whether Name equals the class name. It takes of case sensitivity, i.e. it converts both names to uppercase before comparing. ClassInfo ClassType ClassName Return the parent class. ClassParent returns the class of the parent class of the current class. This is always different from Nil, except for TObject. None. ClassInfo ClassType ClassNameIs Return the size of an instance. InstanceSize returns the number of bytes an instance takes in memory. This is Just the memory occupied by the class structure, and does not take into account any additional memory that might be allocated by the constructor of the class. None. InitInstance ClassName ClassInfo ClassType Chck wether class is an ancestor. InheritsFrom returns True if AClass is an ancestor class from the current class, and returns false if it is not. ClassName ClassInfo ClassType Return a pointer to the string message table. StringMessageTable returns a pointer to the string message table, which can be used to look up methods for dispatching a string message. It is used by the DispatchStr method. If there are no string message handlers, nil is returned. DispatchStr Dispatch Dispatch an integer message

Dispatch looks in the message handler table for a handler that handles message. The message is identified by the first dword (cardinal) in the message structure.

If no matching message handler is found, the message is passed to the DefaultHandler method, which can be overridden by descendent classes to add custom handling of messages.

DispatchStr DefaultHandler Dispatch a string message. DispatchStr extracts the message identifier from Message and checks the message handler table to see if a handler for the message is found, and calls the handler, passing along the message. If no handler is found, the default DefaultHandlerStr is called. None. DefaultHandlerStr Dispatch DefaultHandler Return the address of a method MethodAddress returns the address of a method, searching the method by its name. The Name parameter specifies which method should be taken. The search is conducted in a case-insensitive manner. If no matching method is found, Nil is returned. MethodName FieldAddress Return the name of a method. MethodName searches the VMT for a method with the specified address and returns the name of the method. If no method with the matching address is found, an empty string is returned. MethodAddress FieldAddress Return the address of a field. FieldAddress returns the address of the field with name name. The address is the address of the field in the current class instance. If no field with the specified name is found, Nil is returned. MethodAddress MethodName Method called after the constructor was called. AfterConstruction is a method called after the constructor was called. It does nothing in the implementation of TObject and must be overridden by descendent classes to provide specific behaviour that is executed after the constructor has finished executing. (for instance, call an event handler) None. BeforeDestruction Create Method called before the destructor is called. BeforeDestruction is a method called before the destructor is called. It does nothing in the implementation of TObject and must be overridden by descendent classes to provide specific behaviour that is executed before the destructor has finished executing. (for instance, call an event handler) None. AfterConstruction Destroy Free Default handler for string messages. DefaultHandlerStr is called for string messages which have no handler associated with them in the string message handler table. The implementation of DefaultHandlerStr in TObject does nothing and mut be overridden by descendent classes to provide specific message handling behaviour. DispatchStr Dispatch DefaultHandler Exception handler procedural type Pointer to Exception handler procedural type Exception object TExceptObject is the exception description record which is found on the exception stack. Exception instance. Address where exception occurred Exception frame where exception occurred Next exception object on the stack. Reference count for this exception object Current exception handling procedure.

This constant points to the current exception handling procedure. This routine is called when an unhandled exception occurs, i.e. an exception that is not stopped by a except block.

If the handler is not set, the RTL will emit a run-time error 217 when an unhandler exception occurs.

It is set by the sysutils unit.

Procedure to raise an exception. List of currently raised exceptions. RaiseList returns a pointer to the list of currently raised exceptions (i.e. a pointer to the first exception block. Obtain a reference to the current exception object

AcquireExceptionObject returns the current exception object. It raises the reference count of the exception object, so it will not be freed. Calling this method is only valid within an except block.

The effect of this function is countered by re-raising an exception via raise;

To make sure that the exception object is released when it is no longer needed, must be called when the reference is no longer needed.

If there is no current exception, a run-time error 231 will occur. Decrease the reference count of the current exception object.

ReleaseExceptionObject decreases the reference count of the current exception object. This should be called whenever a reference to the exception object was obtained via the call.

Calling this method is only valid within an except block.

If there is no current exception object, a run-time error 231 will occur. TVarRec type: Integer TVarRec type: Boolean TVarRec type: Char TVarRec type: Extended TVarRec type: String TVarRec type: pointer TVarRec type: PChar TVarRec type: Object instance TVarRec type: Class type TVarRec type: Widechar TVarRec type: PWideChar TVarRec type: Ansistring TVarRec type: Currency TVarRec type: Variant TVarRec type: Interface TVarRec type: WideString TVarRec type: Int64 (signed 64-bit integer) TVarRec type: QWord (unsigned 64-bit integer) Pointer to type. Record describing an element in an array of const TVarRec is a record generated by the compiler for each element in a array of const call. The procedure that receives the constant array receives an array of TVarRec elements, with lower bound zero and high bound equal to the number of elements in the array minus one (as returned by High(Args)) Type with the correct size for index into a dynamic array. A variable of type tdynarrayindex will always have the correct size, suitable for serving as an index in a dynamic array. Pointer to type. Array of char. Type with the size of a small set Type with the size of a normal set Pointer to record Record describing the current memory manager TMemoryManager describes the memory manager. For more information about the memory manager, see the programmer's reference. Does the memory manager require a lock Function called when memory must be allocated on the heap. Function called when previously allocated memory can be freed again. Function called when previously allocated memory with a known size can be freed again. Same as getmem. Handler called when an allocated memory block should be resized Return the size of a memory block. Handler called when the heap status must be reported. Return the memory manager heap status. Record describing the mutex manager for the heap. When the heapmanager needs a lock, then the mutex manager is used to handle the lock. Initialize the mutex Finalize (i.e. dispose of) the mutex. Lock the mutex Unlock the mutex. Procedure to set the mutex manager. SetMemoryMutexManager sets the mutex manager used by the memory manager to MutexMgr. The current mutex manager is returned in MutexMgr None. Fixed size small blocks grow rate Grow rate for block less than 256 Kb. Grow rate for block larger than 256 Kb. Describe behaviour if getmem fails. ReturnNilIfGrowHeapFails describes what happens if there is no more memory available from the operating system. if set to True the memory manager will return Nil. If set to False then a run-time error will occur. System memory manager memory allocator. SysGetmem is the system memory manager implementation for System memory manager free routine. SysFreeem is the system memory manager implementation for System memory manager free routine. SysFreemSize is the system memory manager implementation for System memory manager: free size. SysFreemSize is the system memory manager implementation for System memory manager: Allocate memory SysFreemSize is the system memory manager implementation for System memory manager: attempt to resize memory. SysTryResizeMem is a help routine for the system memory manager implementation for , System memory manager: Reallocate memory SysReallocMem is a help routine for the system memory manager implementation for . Alias for Getmemory is an alias for . Alias for FreeMemory is an alias for . Return the size of a memory block. MemSize returns the size of a memory block on the heap. Passing an invalid pointer may lead to run-time errors (access violations). Alias for AllocMem is an alias for . Re-allocate memory on the heap

ReAllocMem resizes the memory pointed to by P so it has size Size. The value of P may change during this operation. The contents of the memory pointed to by P (if any) will be copied to the new location, but may be truncated if the newly allocated memory block is smaller in size. If a larger block is allocated, only the used memory is initialized, extra memory will not be zeroed out.

Note that P may be nil, in that case the behaviour of ReAllocMem is equivalent to Getmem.

Alias for ReAllocMemory is an alias for . Routine that can be called from assembler routines to get memory. AsmGetmem is a routine that can be called from assembler code to get memory. The assembler reader cannot decide which overloaded call should be used. AsmGetMem provides a unique name that can be called from assembler. Other than that it is completely equivalent to GetMem. Routine that can be called from assembler routines to release memory. AsmFreemem is a routine that can be called from assembler code to release previously alocated memory. The assembler reader cannot decide which overloaded call should be used. AsmFreeMem provides a unique name that can be called from assembler. Other than that it is completely equivalent to FreeMem. Type alias. This type should be considered opaque. It is used to describe file and other handles. Constant describing the current line ending character.

LineEnding is a constant which contains the current line-ending character. This character is system dependent, and is initialized by the system. It should not be set.