+FpMMap maps or unmaps files or devices into memory. The different +arguments determine what and how the file is mapped: +
+Protection of mapped memory. This is a OR-ed combination of the +following constants:
+Contains some options for the mmap call. It is an OR-ed +combination of the following constants:
++One of the options MAP_SHARED and MAP_PRIVATE must be present, +but not both at the same time. +
++The function returns a pointer to the mapped memory, or a -1 in case of en +error. +
++On error, -1 is returned and extended error information is returned by the FpGetErrno function. +
++FpMUnMap unmaps the memory block of size Len, pointed to by +Adr, which was previously allocated with . +
++The function returns True if successful, False otherwise. +
++For an example, see . +
++Extended error information is returned by the FpGetErrno +function. +
++Nice adds -N to the priority of the running process. The lower the +priority numerically, the less the process is favored. +Only the superuser can specify a negative N, i.e. increase the rate at +which the process is run. +
++If the function is succesful, zero is returned. On error, a nonzero value is returned. +
++Extended error information is returned by the FpGetErrno function. +
++GetPriority returns the priority with which a process is running. +Which process(es) is determined by the Which and Who variables. +Which can be one of the pre-defined Prio_Process, +Prio_PGrp, Prio_User, in which case Who is the process ID, Process group ID or +User ID, respectively. +
++For an example, see . +
++Error information is returned solely by the FpGetErrno +function: a priority can be a positive or negative value. +
++fpSetPriority sets the priority with which a process is running. +Which process(es) is determined by the Which and Who variables. +Which can be one of the pre-defined constants: +
++Prio is a value in the range -20 to 20. +
++For an example, see . +
++The function returns zero on success, -1 on failure +
++Extended error information is returned by the FpGetErrno +function. +
++SymLink makes NewName point to the file in +OldName, which doesn't necessarily exist. The two files +DO NOT have the same inode number. This is known as a 'soft' link. +
+The permissions of the link are irrelevant, as they are not used when +following the link. Ownership of the file is only checked in case of removal +or renaming of the link. +
++The function returns zero if the call was succesful, a nonzero value if the call +failed. +
++Extended error information is returned by the FpGetErrno +function. +
++FpReadLink returns the file the symbolic link name is pointing +to. The first form of this function accepts a buffer linkname of +length maxlen where the filename will be stored. It returns the +actual number of characters stored in the buffer. +
++The second form of the function returns simply the name of the file. +
++On error, the first form of the function returns -1; the second one returns +an empty string. +Extended error information is returned by the FpGetErrno +function. +
+MaxIntValue returns the largest integer out of the Data array. - +
+This function is provided for Delphi compatibility, use the function instead. +
Maxvalue returns the largest value in the data array with integer or float values. The return value has the same type as the elements of the array. - +
+The third and fourth forms accept a pointer to an array of N integer or float values. +
MinIntvalue returns the smallest value in the Data array. - +
+This function is provided for Delphi compatibility, use minvalue instead. +
Minvalue returns the smallest value in the data array with integer or float values. The return value has the same type as the elements of the array. - +
+The third and fourth forms accept a pointer to an array of N integer or float values. +
Norm calculates the Euclidian norm of the array of data. This equals sqrt(sumofsquares(data)). - +
+The second form accepts a pointer to an array of N values. +
Popnstddev returns the square root of the population variance of the values in the Data array. It returns zero if there is only one value. - +
+The second form of this function accepts a pointer to an array of N values. +
Popnvariance returns the square root of the population variance of the values in the Data array. It returns zero if there is only one value. - +
+The second form of this function accepts a pointer to an array of N values. +
Radtocycle converts its argument rad (an angle expressed in radians) to an angle in cycles. - -(1 cycle equals 2 pi radians) +
++(1 cycle equals 2 pi radians) +
Radtodeg converts its argument rad (an angle expressed in radians) to an angle in grads. - +
+(200 grads equals pi radians) +
Sincos calculates the sine and cosine of the angle theta, and returns the result in sinus and cosinus. - +
+On Intel hardware, This calculation will be faster than making 2 calls -to clculatet he sine and cosine separately. +to calculate the sine and cosine separately. +
Stddev returns the standard deviation of the values in Data. It returns zero if there is only one value. - +
+The second form of the function accepts a pointer to an array of N values. +
Sum returns the sum of the values in the data array. - +
+The second form of the function accepts a pointer to an array of N values. +
Sumofsquares returns the sum of the squares of the values in the data array. - +
+The second form of the function accepts a pointer to an array of N values. +
sumsandsquares calculates the sum of the values and the sum of the squares of the values in the data array and returns the results in sum and sumofsquares. - +
+The second form of the function accepts a pointer to an array of N values. +
TotalVariance returns the total variance of the values in the data array. It returns zero if there is only one value. - +
+The second form of the function accepts a pointer to an array of N values. +
Variance returns the variance of the values in the data array. It returns zero if there is only one value. - +
+The second form of the function accepts a pointer to an array of N values. +
+IsZero checks whether the float value A is zero, up to a +precision of Epsilon. It returns True if Abs(A) is +less than Epsilon. +
++The default value for Epsilon is dependent on the type of the +arguments, but is for the float type. +
++SameValue returns True if the floating-point values +A and B are the same, i.e. whether the absolute value +of their their difference is smaller than Epsilon. If their +difference is larger, then False is returned. +
++The default value for Epsilon is dependent on the type of the +arguments, but is for the float type. +
++arccosh returns the inverse hyperbolic cosine of it's argument +x. +
++This function is an alias for , provided for Delphi +compatibility. +
++arcsinh returns the inverse hyperbolic sine of it's argument +x. +
++This function is an alias for , provided for Delphi +compatibility. +
++arcsinh returns the inverse hyperbolic tangent of it's argument +x. +
++This function is an alias for , provided for Delphi +compatibility. +
++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. +
++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. +
++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: +
++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;
+
++
++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
+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: +
++When programming cross-platform, use these constants instead of hard-coded +characters. This will enhance portability of an application. +
++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. +
+
+Under
+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. +
++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 |
+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 | |
| Return size of largest free memory block | |
| Return total available memory | |
| 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 |
+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 |
+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 |
+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 |
+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 |
+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. +
++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: +
++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: +
++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: +
++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: +
++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. +
++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. +
++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);
+
++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 . +
++GetMemoryManager stores the current Memory Manager record in +MemMgr. +
++For an example, see \progref. +
++The return value of High depends on it's argument: +
++The return type is always the same type as the type of the argument +(This can lead to some nasty surprises !). +
++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 +
++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 : +
++I/O errors : +
++Fatal errors : +
++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 +
++ The return value of Low depends on it's argument: +
++The return type is always the same type as the type of the argument. +
++for an example, see . +
++Maxavail returns the size, in bytes, of the biggest free memory block in +the heap. +
++Memavail returns the size, in bytes, of the free heap memory. +
++Mkdir creates a new directory S. +
++For an example, see . +
++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 . +
++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 . +
++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)) +
++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 +
++Ptr returns a pointer, pointing to the address specified by +segment Sel and offset Off. +
++Randomize initializes the random number generator of Free Pascal, by giving +a value to Randseed, calculated with the system clock. +
++For an example, see . +
++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 . +
++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. +
++SetMemoryManager sets the current memory manager record to +MemMgr. +
++For an example, see \progref. +
++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. +
++SizeOf returns the size, in bytes, of any variable or type-identifier. +
++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);
+
++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 . +
++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. +
++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: +
++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
+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
+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
+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. +
++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. +
++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. +
++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. +
++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. +
++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. +
++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. +
++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. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++LFNSupport determines whether the current OS supports long file +names, i.e. filenames that are not of the form 8.3 as on ancient DOS +systems. If the value of this constant is True then long +filenames are supported. If it is false, then not. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++DirectorySeparator is the character used by the current operating +system to separate directory parts in a pathname. This constant is system +dependent, and should not be set. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++On systems that support driveletters, the DriveSeparator constant +denotes the character that separates the drive indicator from the directory +part in a filename path. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++PathSeparator is the character used commonly on the current +operating system to separate paths in a list of paths, such as the +PATH environment variable. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++FileNameCaseSensitive is True if case is important +when using filenames on the current OS. In this case, the OS will treat +files with different cased names as different files. Note that this may +depend on the filesystem: Unix operating systems that access a DOS or +Windows partition will have this constant set to true, but when writing to +the DOS partition, the casing is ignored. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++sLineBreak is an alias for and is +supplied for Delphi compatibility. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++DefaultTextLineBreakStyle contains the default OS setting for the + type. It is initizliaed by the system unit, +and is used to determine the default line ending when writing to text files. +
++This constant is part of a set of constants that describe the OS +characteristics. These constants should be used instead of hardcoding +OS characteristics. +
++ArrayStringToPPchar creates an array of null-terminated strings +that point to strings which are the same as the strings in the array +S. The function returns a pointer to this array. The array and +the strings it contains must be disposed of after being used, because it +they are allocated on the heap. +
++The ReserveEntries parameter tells ArrayStringToPPchar +to allocate room at the end of the array for another ReserveEntries +entries. +
++StringToPPChar splits the string S in words, replacing any +whitespace with zero characters. It returns a pointer to an array of pchars +that point to the first letters of the words in S. This array is terminated +by a Nil pointer. +
++The function does not add a zero character to the end of the string +unless it ends on whitespace. +
++The function reserves memory on the heap to store the array of PChar; +The caller is responsible for freeing this memory. +
++This function is only available on certain platforms. +
++IsVariantManagerSet determines whether the variant manager was +set to a correct variant manager. It returns True if it is, +or False if it is not. +
++The routine checks all variant operation handlers, they should all be set correctly. +
++VarDispProc is called by the compiler if it needs to perform an +interface call from a variant. For instance, the following call: +
+
+Var
+ V : OleVariant;
+begin
+ V.OpenDocument('c:\temp\mydoc.doc');
+end;
+
++is encoded by the compiler and passed to VarDispProc. +
++This pointer must be set by a routine that calls the OS COM handling +routines. +
++VarDispProc is called by the compiler if it needs to perform an +interface call from a variant which contains a dispatch interface. +For instance, the following call: +
+
+Var
+ V : OleVariant;
+begin
+ (V as IWord).OpenDocument('c:\temp\mydoc.doc');
+end;
+
++where IWord is a dispatch interface is encoded by the compiler and +passed to DispCallByIDProc. +
++This pointer must be set by a routine that calls the OS COM handling +routines. +
+-FpMMap maps or unmaps files or devices into memory. The different -arguments determine what and how the file is mapped: -
-Protection of mapped memory. This is a OR-ed combination of the -following constants:
-Contains some options for the mmap call. It is an OR-ed -combination of the following constants:
--One of the options MAP_SHARED and MAP_PRIVATE must be present, -but not both at the same time. -
--The function returns a pointer to the mapped memory, or a -1 in case of en -error. -
--On error, -1 is returned and extended error information is returned by the FpGetErrno function. -
--FpMUnMap unmaps the memory block of size Len, pointed to by -Adr, which was previously allocated with . -
--The function returns True if successful, False otherwise. -
--For an example, see . -
--It is simply a wrapper to the kernel system call. To get the local time, -. +It is simply a wrapper to the kernel system call.
-Nice adds -N to the priority of the running process. The lower the -priority numerically, the less the process is favored. -Only the superuser can specify a negative N, i.e. increase the rate at -which the process is run. -
--If the function is succesful, zero is returned. On error, a nonzero value is returned. -
--Extended error information is returned by the FpGetErrno function. -
--GetPriority returns the priority with which a process is running. -Which process(es) is determined by the Which and Who variables. -Which can be one of the pre-defined Prio_Process, -Prio_PGrp, Prio_User, in which case Who is the process ID, Process group ID or -User ID, respectively. -
--For an example, see . -
--Error information is returned solely by the FpGetErrno -function: a priority can be a positive or negative value. -
--fpSetPriority sets the priority with which a process is running. -Which process(es) is determined by the Which and Who variables. -Which can be one of the pre-defined constants: -
--Prio is a value in the range -20 to 20. -
--For an example, see . -
--The function returns zero on success, -1 on failure -
--Extended error information is returned by the FpGetErrno -function. -
--Extended error information is returned by the FpGetErrno -function. -
--SymLink makes NewName point to the file in -OldName, which doesn't necessarily exist. The two files -DO NOT have the same inode number. This is known as a 'soft' link. -
-The permissions of the link are irrelevant, as they are not used when -following the link. Ownership of the file is only checked in case of removal -or renaming of the link. -
--The function returns zero if the call was succesful, a nonzero value if the call -failed. -
--Extended error information is returned by the FpGetErrno -function. -
--FpReadLink returns the file the symbolic link name is pointing -to. The first form of this function accepts a buffer linkname of -length maxlen where the filename will be stored. It returns the -actual number of characters stored in the buffer. -
--The second form of the function returns simply the name of the file. -
--On error, the first form of the function returns -1; the second one returns -an empty string. -Extended error information is returned by the FpGetErrno -function. -
-