Unit KambiUtils

Description

uses

Classes, Interfaces, Objects and Records

Functions and Procedures

Types

Constants

Variables

Description

Kambi (Michalis Kamburelis) various basic utilities.

Templates for classes that work like dynamic arrays. Base TDynArrayBase class and many TDyn*Array classes implementing TDynArrayBase descendants that can store base Pascal types, like TDynIntegerArray, TDynStringArray, TDynFloatArray etc.
New TDyn*Xxx classes may be created much like instantiating templates in C++, thanks to some tricks with include files and compiler defines, see comments at the beginning of dynarray.inc file.
Initially TDyn*Xxx classes were implemented because old FPC versions didn't implement dynamic arrays. But now TDyn*Xxx classes are just much more powerful and comfortable than using normal ObjectPascal dynamic arrays. E.g. they have methods for seeking and sorting and they can be cleanly extended by inheritance.
Implemented in kambiutils_dyn_arrays.inc.
Basic operations on numbers (see things in kambiutils_math.inc).
Some simple things that must be implemented differently on various OSes (i.e. they are implemented here to hide differences between some OSes).
Filenames operations (they somehow complement standard set of routines in SysUtils), see things in kambiutils_filenames.inc.
Things to process command-line options. See Parameters in kambiutils_params.inc.
They are also used in my unit to parse command-line options ParseParametersUnit.
Some basic algorithms, e.g. Sort in kambiutils_basic_algorithms.inc
Simple wrappers for OS specific things, like for Libc or BaseUnix/Unix units under UNIX (see also README.use_libc) or WinAPI under Windows. See windows/kambiutils_os_specific.inc and unix/kambiutils_os_specific.inc files.
Some others...

This unit is a bag for simple and generally useful things. As a rule (to not let myself put too much things here) this unit must not use any objects defined in Classes unit (i.e. this unit can't use Classes unit, directly or indirectly). So not only GUI libs like VCL, LCL or CLX can't be utilized in this unit, but also many other non-visual classes (e.g. streams, lists). The only classes that may be defined and used here are exceptions (the base Exception class comes from SysUtils unit) and TDyn*Array classes.

Initialization of this unit does some things that you should be aware of (for me, these things are just a must-have for my every program, reasoning is given below):

Call Randomize (so that you never forget about it)
Set DecimalSeparator to '.'.
Delphi (and, for compatibility, FPC) defines DecimalSeparator based on local settings (like configured user's country). But this makes things like StrToFloat and FloatToStr work unpredictably – they may give different results on different systems. E.g. FloatToStr(0.9) may output '0,9' on some system. But if you write '0,9' to a text file, it may not be understood by StrToFloat on some other system.
Moreover (this is rather my personal opinion), '.' as DecimalSeparator is really a standard convention on computers. There is no sense in localizing this. Instead, I would rather see all users using computers to understand that '.' is standard decimal separator. This is something that just eases communication – when everyone in the world would use the same DecimalSeparator, we would have less communication problems. Just like there is a standard ISO date format, also setting a universal standard for DecimalSeparator is a good idea.
Old value of DecimalSeparator is saved as LocaleDecimalSeparator, this was probably initialized by RTL to something specific for user's configured locale.
Installs my handler for ExceptProc, see comments at HaltCodeOnException

Things from Pascal RTL / FCL / etc. that you shouldn't use because I have better replacemenets here:

ChDir with $I+ => better use ChangeDir from this unit (because of Delphi bug — ChDir with $I+ works like with $I-)
ParamStr(0), Application.ExeName => better use ProgramName or ExeName from this unit. They are portable, eliminate the problems under Unixes when ParamStr(0) is not necessarily an exe name, unlike Application.ExeName they don't need whole VCL / CLX stuff, and eliminate Kylix 1 bug in Application.ExeName
Reset/Rewrite => it's often better to use SafeReset/SafeRewrite
FreeMem => it's often better to use FreeMemNiling
FindFirst/FindNext => it's often better to use EnumerateFiles unit

uses

BaseUnix
Unix
Dl
Variants
SysUtils
Math

Overview

Classes, Interfaces, Objects and Records

Name	Description
Class `TDynArrayBase`
Class `TDynArray_1`
Class `TDynArray_2`
Class `TDynArray_3`
Class `TDynArray_4`
Class `TDynArray_5`
Class `TDynArray_6`
Class `TDynArray_7`
Class `TDynArray_8`
Class `TDynArray_9`
Class `TDynArray_10`
Class `TDynArray_11`
Class `TDynArray_12`
Class `TDynArray_13`
Class `TDynArray_14`
Class `TDynArray_15`
Class `TDynArray_16`
Class `TDynFloatArray`
Class `TDynSingleArray`
Class `TDynCardinalArray`
Class `TDynBooleanArray`
Class `TCodeBreaker`	`TCodeBreaker` is a special class intended to be 1.
Class `EInternalError`	This exception should signal some internal error in program, i.e.
Class `ECheckFailed`	See Check
Class `EWithHiddenClassName`	wyjatki dziedziczace od `EWithHiddenClassName` sa normalnymi wyjatkami tyle ze beda w inny sposob formatowane funkcja ExceptMessage : ExceptMessage NIE bedzie zawieralo nazwy klasy tych wyjatkow.
Class `BreakProgram`	This class is specially handled in my exception handler.
Class `EInvalidParams`	Command-line parameters utilities
Class `TParametersArray`
Class `EKambiOSError`	I don't ever use RaiseLastOSError or OSCheck or EOSError, instead I'm using my own `EKambiOSError`, KambiOSCheck, RaiseLastKambiOSError.

Functions and Procedures

procedure Sort(Arr: pointer; ArrRecordSize: Cardinal; IsSmallerFunc: TIsSmallerFunc; IsSmallerFuncData: Pointer; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure Sort(Arr: pointer; ArrRecordSize: Cardinal; ArrStride: integer; IsSmallerFunc: TIsSmallerFunc; IsSmallerFuncData: Pointer; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure SortByObject(Arr: pointer; ArrRecordSize: Cardinal; IsSmallerFunc: TIsSmallerFuncByObject; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure SortByObject(Arr: pointer; ArrRecordSize: Cardinal; ArrStride: integer; IsSmallerFunc: TIsSmallerFuncByObject; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure Check(TrueValue: boolean; const ErrMessage: string);

function ArrayPosPointer(A: pointer; const Arr: array of pointer): Integer; overload;

function ArrayPosStr(const A: string; const Arr: array of string): Integer; overload;

function ArrayPosInt(A: Integer; const Arr: array of Integer): Integer; overload;

function ArrayPosCard(A: Cardinal; const Arr: array of Cardinal): Integer; overload;

function ArrayPosExt(A: Extended; const Arr: array of Extended): Integer; overload;

function ArrayPosText(const A: string; const Arr: array of string; IgnoreCase: boolean =true): Integer; overload;

function PArrayPosStr(const A: string; Arr: PString; ArrCount: Integer): Integer; overload;

function PArrayPosText(const A: string; Arr: PString; ArrCount: Integer; IgnoreCase: boolean =true): Integer; overload;

function Iff(boolval: boolean; trueval, falseval: string) : string; overload;

function Iff(boolval: boolean; trueval, falseval: Integer) : Integer; overload;

function Iff(boolval: boolean; trueval, falseval: Float) : Float; overload;

function Iff(boolval: boolean; trueval, falseval: Cardinal): Cardinal; overload;

function Iff(boolval: boolean; trueval, falseval: char) : char; overload;

function SFPCVersion: string;

function SCompilerDescription: string;

function SVrmlEngineProgramHelpSuffix(const DisplayProgramName: string; const Version: string; WrapLines: boolean): string;

function ExceptMessage(E: TObject; ExceptAddr: Pointer = nil ): string; overload;

procedure OutputException(E: TObject; ExceptAddr: Pointer = nil ); overload;

procedure HaltBool(Value: boolean);

procedure HaltOnException(proc: TProcedure); overload;

procedure HaltOnException(proc: TProcedure; HaltCode: integer); overload;

procedure ProgramBreak(AHaltCode: Integer =0 ); overload;

procedure ParamCountEqual(ParamValue: integer);

procedure ParamCountEqGreater(ParamValue: integer);

procedure ParamCountEqLesser(ParamValue: integer);

function IsPresentInPars(const sarr: array of string; IgnoreCase: boolean; FirstPar, LastPar: Cardinal): boolean; overload;

function IsPresentInPars(const sarr: array of string; IgnoreCase: boolean): boolean; overload;

function IsHelpPresentInPars: boolean;

function SetBit(bitnum:byte; bitset:byte; value:boolean):byte;

function SetBit1(bitnum:byte; bitset:byte):byte;

function SetBit0(bitnum:byte; bitset:byte):byte;

procedure SetBit_var(bitnum:byte; var bitset:byte; value:boolean);

procedure SetBit1_var(bitnum:byte; var bitset:byte);

procedure SetBit0_var(bitnum:byte; var bitset:byte);

function GetBit(bitnum:byte; bitset:byte):boolean;

function GetBitLongWord(bitnum:byte; bitset:LongWord):boolean;

function SetBit1LongWord(bitnum:byte; bitset:LongWord):LongWord;

function SetBit0LongWord(bitnum:byte; bitset:LongWord):LongWord;

function SetBitLongWord(bitnum:byte; bitset:LongWord; value:boolean):LongWord;

function RandomBitsByte(OneChance:Extended):byte;

function KamReadLink(const FileName: string): string;

procedure SwapValues(var a, b: Int64); overload;

procedure SwapValues(var a, b: Integer); overload;

procedure SwapValues(var a, b: Cardinal); overload;

procedure SwapValues(var a, b: Single); overload;

procedure SwapValues(var a, b: Double); overload;

procedure SwapValues(var a, b: char); overload;

procedure OrderUp(var mniejsza, wieksza: Int64 ); overload;

procedure OrderUp(var mniejsza, wieksza: Integer ); overload;

procedure OrderUp(var mniejsza, wieksza: Cardinal); overload;

procedure OrderUp(var mniejsza, wieksza: Single ); overload;

procedure OrderUp(var mniejsza, wieksza: Double ); overload;

procedure OrderUp(x, y: Integer; var mniejsza, wieksza: Integer ); overload;

procedure OrderUp(x, y: Cardinal; var mniejsza, wieksza: Cardinal); overload;

procedure OrderUp(x, y: Single; var mniejsza, wieksza: Single ); overload;

procedure OrderUp(x, y: Double; var mniejsza, wieksza: Double ); overload;

function min(const a, b: Int64): Int64; overload;

function min(const a, b: integer): integer; overload;

function min(const a, b: cardinal): cardinal; overload;

function min(const a, b: Single): Single; overload;

function min(const a, b: Double): Double; overload;

function min(const a, b, c: Int64): Int64; overload;

function min(const a, b, c: integer): integer; overload;

function min(const a, b, c: cardinal): cardinal; overload;

function min(const a, b, c: Single): Single; overload;

function min(const a, b, c: Double): Double; overload;

function max(const a, b: Int64): Int64; overload;

function max(const a, b: integer): integer; overload;

function max(const a, b: cardinal): cardinal; overload;

function max(const a, b: Single): Single; overload;

function max(const a, b: Double): Double; overload;

function max(const a, b, c: Int64): Int64; overload;

function max(const a, b, c: integer): integer; overload;

function max(const a, b, c: cardinal): cardinal; overload;

function max(const a, b, c: Single): Single; overload;

function max(const a, b, c: Double): Double; overload;

procedure MinTo1st(var a: Int64 ; const b: Int64 ); overload;

procedure MinTo1st(var a: Integer ; const b: Integer ); overload;

procedure MinTo1st(var a: Cardinal; const b: Cardinal); overload;

procedure MinTo1st(var a: Single ; const b: Single ); overload;

procedure MinTo1st(var a: Double ; const b: Double ); overload;

procedure MaxTo1st(var a: Int64 ; const b: Int64 ); overload;

procedure MaxTo1st(var a: Integer ; const b: Integer ); overload;

procedure MaxTo1st(var a: Cardinal; const b: Cardinal); overload;

procedure MaxTo1st(var a: Single ; const b: Single ); overload;

procedure MaxTo1st(var a: Double ; const b: Double ); overload;

function IndexMax(const a0, a1, a2: Double): Integer; overload;

function IndexMin(const a0, a1, a2: Double): Integer; overload;

function Between(const a, vBegin, vEnd: Int64): boolean; overload;

function Between(const a, vBegin, vEnd: integer): boolean; overload;

function Between(const a, vBegin, vEnd: cardinal): boolean; overload;

function Between(const a, vBegin, vEnd: Float): boolean; overload;

function Clamped(const a, vBegin, vEnd: Int64): Int64; overload;

function Clamped(const a, vBegin, vEnd: integer): integer; overload;

function Clamped(const a, vBegin, vEnd: cardinal): cardinal; overload;

function Clamped(const a, vBegin, vEnd: Single): Single; overload;

function Clamped(const a, vBegin, vEnd: Double): Double; overload;

procedure Clamp(var a: Int64; const vBegin, vEnd: Int64); overload;

procedure Clamp(var a: integer; const vBegin, vEnd: integer); overload;

procedure Clamp(var a: cardinal; const vBegin, vEnd: cardinal); overload;

procedure Clamp(var a: Single; const vBegin, vEnd: Single); overload;

procedure Clamp(var a: Double; const vBegin, vEnd: Double); overload;

procedure RestOf3dCoords(coord: integer; out first, second: integer);

function ChangeIntCycle(value, change, maxValue: integer): integer;

function Lerp(const a: Single; const l, h: Integer): Single; overload;

function Lerp(const a: Single; const l, h: Cardinal): Single; overload;

function Lerp(const a, l, h: Single): Single; overload;

function Lerp(const a: Double; const l, h: Integer): Double; overload;

function Lerp(const a: Double; const l, h: Cardinal): Double; overload;

function Lerp(const a, l, h: Double): Double; overload;

function RoundUpToMultiply(value, multiplicator: Integer): Integer;

function BiggestPowerOf2(Value: Cardinal): Cardinal;

function Biggest2Exponent(Value: Cardinal): integer;

function Smallest2Exponent(Value: Cardinal): Integer;

function Smallest2Power(Value: Cardinal): Cardinal;

function IsPowerOf2(Value: Cardinal): boolean;

function DivRoundUp(Value, Divider: Cardinal): Cardinal; overload;

function DivRoundUp(Value, Divider: Integer): Integer; overload;

function MapRange(sourceVal, sourceBegin, sourceEnd, destBegin, destEnd: integer): float; overload;

function MapRange(sourceVal, sourceBegin, sourceEnd, destBegin, destEnd: float ): float; overload;

function RandomFloatRange(const RangeBegin, RangeEnd: Float): Float;

function AngleRadPointToPoint(x1, y1, x2, y2: Single): Single;

function NatNatPower(Base, Exponent: Cardinal): Cardinal;

function RandomPlusMinus: integer;

function GeneralPower(const Base, Exponent: Float): Float;

function ArcCot(x: Float): Float;

function SmallFactorial(n: Integer): Int64;

procedure KamDivMod(Dividend: Integer; Divisor: Word; out Result, Remainder: SmallInt);

procedure DivUnsignedMod(Dividend: Integer; Divisor: Word; out Result: Smallint; out Remainder: Word);

function CeilDiv(const A, B: Cardinal): Cardinal;

procedure MinMax(const x0, x1, x2: Double; out min, max: Double); overload;

procedure MinMax(const x0, x1, x2: Single; out min, max: Single); overload;

function KamCoTan(const Value: Float): Float;

function DeleteFileExt(const filename:string):string;

function ExtractOnlyFilename(const filename:string):string;

function ChangeFilePath(const fname, NewPath:string):string;

function DuplicateSlash(const s:string):string;

function IsPathDelim(c:char):boolean;

function InclPathDelim(const s:string):string;

function ExclPathDelim(const s:string):string;

function RelativeFilename(const fname:string):string;

function NiceFileName(const fname:string):string;

function IsPathAbsolute(const path:string):boolean;

function IsPathAbsoluteOnDrive(const path:string):boolean;

function SpecialDirName(const dirname:string):boolean;

function AppendToFilename(const FileName, Suffix:string):string;

function ExpandFilePath(const FilePath:string):string;

function LastKambiOSError: LongWord;

procedure RaiseLastKambiOSError; overload;

procedure RaiseLastKambiOSError(const AdditionalDescription: string); overload;

procedure KambiOSCheck(TrueValue: boolean); overload;

procedure KambiOSCheck(TrueValue: boolean; const AdditionalDescription: string); overload;

function PointerAdd(p: pointer; add: integer): pointer;

function GetClearMem(Size: integer; ClearValue: byte =0): pointer; overload;

procedure FreeMemNiling(var p: pointer);

function CheckIsMemCharFilled(const Data; Size: Integer; AChar: Char): Integer;

function IsMemCharFilled(const Data; Size: Integer; AChar: Char): boolean;

function IsMemWordFilled(const Data; Size: Integer; Value: Word): boolean;

function IsMemDWordFilled(const Data; Size: Integer; Value: DWord): boolean;

function ReadlnInt(const Prompt: string): integer;

function ReadlnStr(const Prompt: string): string;

function ReadlnYesNo(Prompt: string; Default: TYesNoDefault): boolean;

function ReadlnChoice(Prompt: string; const Choices: array of string; Choice0Default, IgnoreCase: boolean): Integer;

procedure ErrorWrite(const s: string); overload;

procedure WarningWrite(const s: string); overload;

procedure InfoWrite(const s: string); overload;

procedure ErrorWrite(const s: string; const args: array of const); overload;

procedure WarningWrite(const s: string; const args: array of const); overload;

procedure InfoWrite(const s: string; const args: array of const); overload;

procedure InfoWriteParts(const TitleFormat: string; const Messages: array of string);

Types

TIsSmallerFunc = function (const A, B, Data: Pointer): boolean;

TIsSmallerFuncByObject = function (const A, B: Pointer): boolean of object;

Float = Math.Float ;

PFloat = Math.PFloat ;

PCardinal = ˆCardinal;

PLongWord = ˆLongWord;

PShortint = ˆShortint;

PBoolean = ˆBoolean;

TDynArrayItem_1 = Cardinal;

PDynArrayItem_1 = PCardinal;

TInfiniteArray_1 = array[0..MaxInt div SizeOf(TDynArrayItem_1)-1]of TDynArrayItem_1;

PInfiniteArray_1 = ˆTInfiniteArray_1;

TDynArrayItemIsSmallerFunc_1 = function (const a, b: TDynArrayItem_1): boolean;

TDynArrayItemIsSmallerFuncByObject_1 = function (const a, b: TDynArrayItem_1): boolean of object;

TArray_Cardinal = TInfiniteArray_1 ;

PArray_Cardinal = PInfiniteArray_1 ;

TDynArrayItem_2 = Integer ;

PDynArrayItem_2 = PInteger ;

TInfiniteArray_2 = array[0..MaxInt div SizeOf(TDynArrayItem_2)-1]of TDynArrayItem_2;

PInfiniteArray_2 = ˆTInfiniteArray_2;

TDynArrayItemIsSmallerFunc_2 = function (const a, b: TDynArrayItem_2): boolean;

TDynArrayItemIsSmallerFuncByObject_2 = function (const a, b: TDynArrayItem_2): boolean of object;

TDynIntegerArray = TDynArray_2 ;

TArray_Integer = TInfiniteArray_2 ;

PArray_Integer = PInfiniteArray_2 ;

TDynArrayItem_3 = Float ;

PDynArrayItem_3 = PFloat ;

TInfiniteArray_3 = array[0..MaxInt div SizeOf(TDynArrayItem_3)-1]of TDynArrayItem_3;

PInfiniteArray_3 = ˆTInfiniteArray_3;

TDynArrayItemIsSmallerFunc_3 = function (const a, b: TDynArrayItem_3): boolean;

TDynArrayItemIsSmallerFuncByObject_3 = function (const a, b: TDynArrayItem_3): boolean of object;

TArray_Float = TInfiniteArray_3 ;

PArray_Float = PInfiniteArray_3 ;

TDynArrayItem_4 = Byte ;

PDynArrayItem_4 = PByte ;

TInfiniteArray_4 = array[0..MaxInt div SizeOf(TDynArrayItem_4)-1]of TDynArrayItem_4;

PInfiniteArray_4 = ˆTInfiniteArray_4;

TDynArrayItemIsSmallerFunc_4 = function (const a, b: TDynArrayItem_4): boolean;

TDynArrayItemIsSmallerFuncByObject_4 = function (const a, b: TDynArrayItem_4): boolean of object;

TDynByteArray = TDynArray_4 ;

TArray_Byte = TInfiniteArray_4 ;

PArray_Byte = PInfiniteArray_4 ;

TDynArrayItem_5 = Shortint;

PDynArrayItem_5 = PShortint;

TInfiniteArray_5 = array[0..MaxInt div SizeOf(TDynArrayItem_5)-1]of TDynArrayItem_5;

PInfiniteArray_5 = ˆTInfiniteArray_5;

TDynArrayItemIsSmallerFunc_5 = function (const a, b: TDynArrayItem_5): boolean;

TDynArrayItemIsSmallerFuncByObject_5 = function (const a, b: TDynArrayItem_5): boolean of object;

TDynShortintArray = TDynArray_5 ;

TArray_Shortint = TInfiniteArray_5 ;

PArray_Shortint = PInfiniteArray_5 ;

TDynArrayItem_6 = Smallint;

PDynArrayItem_6 = PSmallint;

TInfiniteArray_6 = array[0..MaxInt div SizeOf(TDynArrayItem_6)-1]of TDynArrayItem_6;

PInfiniteArray_6 = ˆTInfiniteArray_6;

TDynArrayItemIsSmallerFunc_6 = function (const a, b: TDynArrayItem_6): boolean;

TDynArrayItemIsSmallerFuncByObject_6 = function (const a, b: TDynArrayItem_6): boolean of object;

TDynSmallintArray = TDynArray_6 ;

TArray_Smallint = TInfiniteArray_6 ;

PArray_Smallint = PInfiniteArray_6 ;

TDynArrayItem_7 = Word ;

PDynArrayItem_7 = PWord ;

TInfiniteArray_7 = array[0..MaxInt div SizeOf(TDynArrayItem_7)-1]of TDynArrayItem_7;

PInfiniteArray_7 = ˆTInfiniteArray_7;

TDynArrayItemIsSmallerFunc_7 = function (const a, b: TDynArrayItem_7): boolean;

TDynArrayItemIsSmallerFuncByObject_7 = function (const a, b: TDynArrayItem_7): boolean of object;

TDynWordArray = TDynArray_7 ;

TArray_Word = TInfiniteArray_7 ;

PArray_Word = PInfiniteArray_7 ;

TDynArrayItem_8 = Longint ;

PDynArrayItem_8 = PLongint ;

TInfiniteArray_8 = array[0..MaxInt div SizeOf(TDynArrayItem_8)-1]of TDynArrayItem_8;

PInfiniteArray_8 = ˆTInfiniteArray_8;

TDynArrayItemIsSmallerFunc_8 = function (const a, b: TDynArrayItem_8): boolean;

TDynArrayItemIsSmallerFuncByObject_8 = function (const a, b: TDynArrayItem_8): boolean of object;

TDynLongintArray = TDynArray_8 ;

TArray_Longint = TInfiniteArray_8 ;

PArray_Longint = PInfiniteArray_8 ;

TDynArrayItem_9 = Int64 ;

PDynArrayItem_9 = PInt64 ;

TInfiniteArray_9 = array[0..MaxInt div SizeOf(TDynArrayItem_9)-1]of TDynArrayItem_9;

PInfiniteArray_9 = ˆTInfiniteArray_9;

TDynArrayItemIsSmallerFunc_9 = function (const a, b: TDynArrayItem_9): boolean;

TDynArrayItemIsSmallerFuncByObject_9 = function (const a, b: TDynArrayItem_9): boolean of object;

TDynInt64Array = TDynArray_9 ;

TArray_Int64 = TInfiniteArray_9 ;

PArray_Int64 = PInfiniteArray_9 ;

TDynArrayItem_10 = Extended;

PDynArrayItem_10 = PExtended;

TInfiniteArray_10 = array[0..MaxInt div SizeOf(TDynArrayItem_10)-1]of TDynArrayItem_10;

PInfiniteArray_10 = ˆTInfiniteArray_10;

TDynArrayItemIsSmallerFunc_10 = function (const a, b: TDynArrayItem_10): boolean;

TDynArrayItemIsSmallerFuncByObject_10 = function (const a, b: TDynArrayItem_10): boolean of object;

TDynExtendedArray = TDynArray_10;

TArray_Extended = TInfiniteArray_10;

PArray_Extended = PInfiniteArray_10;

TDynArrayItem_11 = Double ;

PDynArrayItem_11 = PDouble ;

TInfiniteArray_11 = array[0..MaxInt div SizeOf(TDynArrayItem_11)-1]of TDynArrayItem_11;

PInfiniteArray_11 = ˆTInfiniteArray_11;

TDynArrayItemIsSmallerFunc_11 = function (const a, b: TDynArrayItem_11): boolean;

TDynArrayItemIsSmallerFuncByObject_11 = function (const a, b: TDynArrayItem_11): boolean of object;

TDynDoubleArray = TDynArray_11;

TArray_Double = TInfiniteArray_11;

PArray_Double = PInfiniteArray_11;

TDynArrayItem_12 = Single ;

PDynArrayItem_12 = PSingle ;

TInfiniteArray_12 = array[0..MaxInt div SizeOf(TDynArrayItem_12)-1]of TDynArrayItem_12;

PInfiniteArray_12 = ˆTInfiniteArray_12;

TDynArrayItemIsSmallerFunc_12 = function (const a, b: TDynArrayItem_12): boolean;

TDynArrayItemIsSmallerFuncByObject_12 = function (const a, b: TDynArrayItem_12): boolean of object;

TArray_Single = TInfiniteArray_12;

PArray_Single = PInfiniteArray_12;

TDynArrayItem_13 = Pointer ;

PDynArrayItem_13 = PPointer ;

TInfiniteArray_13 = array[0..MaxInt div SizeOf(TDynArrayItem_13)-1]of TDynArrayItem_13;

PInfiniteArray_13 = ˆTInfiniteArray_13;

TDynArrayItemIsSmallerFunc_13 = function (const a, b: TDynArrayItem_13): boolean;

TDynArrayItemIsSmallerFuncByObject_13 = function (const a, b: TDynArrayItem_13): boolean of object;

TDynPointerArray = TDynArray_13;

TArray_Pointer = TInfiniteArray_13;

PArray_Pointer = PInfiniteArray_13;

TDynArrayItem_14 = LongWord;

PDynArrayItem_14 = PLongWord;

TInfiniteArray_14 = array[0..MaxInt div SizeOf(TDynArrayItem_14)-1]of TDynArrayItem_14;

PInfiniteArray_14 = ˆTInfiniteArray_14;

TDynArrayItemIsSmallerFunc_14 = function (const a, b: TDynArrayItem_14): boolean;

TDynArrayItemIsSmallerFuncByObject_14 = function (const a, b: TDynArrayItem_14): boolean of object;

TDynLongWordArray = TDynArray_14;

TArray_LongWord = TInfiniteArray_14;

PArray_LongWord = PInfiniteArray_14;

TDynArrayItem_15 = String ;

PDynArrayItem_15 = PString ;

TInfiniteArray_15 = array[0..MaxInt div SizeOf(TDynArrayItem_15)-1]of TDynArrayItem_15;

PInfiniteArray_15 = ˆTInfiniteArray_15;

TDynArrayItemIsSmallerFunc_15 = function (const a, b: TDynArrayItem_15): boolean;

TDynArrayItemIsSmallerFuncByObject_15 = function (const a, b: TDynArrayItem_15): boolean of object;

TDynStringArray = TDynArray_15;

TArray_String = TInfiniteArray_15;

PArray_String = PInfiniteArray_15;

TDynArrayItem_16 = Boolean ;

PDynArrayItem_16 = PBoolean ;

TInfiniteArray_16 = array[0..MaxInt div SizeOf(TDynArrayItem_16)-1]of TDynArrayItem_16;

PInfiniteArray_16 = ˆTInfiniteArray_16;

TDynArrayItemIsSmallerFunc_16 = function (const a, b: TDynArrayItem_16): boolean;

TDynArrayItemIsSmallerFuncByObject_16 = function (const a, b: TDynArrayItem_16): boolean of object;

TArray_Boolean = TInfiniteArray_16;

PArray_Boolean = PInfiniteArray_16;

PByteArray = ˆTByteArray;

TByteArray = array[0..MaxInt div SizeOf(Byte)-1] of Byte;

TArray_PChar = array[0..MaxInt div SizeOf(PChar)-1]of PChar;

PArray_PChar=ˆTArray_PChar;

TArray_TObject = array[0..MaxInt div SizeOf(Pointer)-1]of TObject;

PArray_TObject=ˆTArray_TObject;

PString = ˆAnsiString;

PtrObject = ˆTObject;

TPointerUInt = PtrUInt;

TPointerSInt = PtrInt;

TYesNoDefault = (...);

Constants

DefaultCountToUseSimpleSort = 10;

nl = LineEnding;

RootDir =  '/' 
             ;

bit0=1;

bit1=2;

bit2=4;

bit3=8;

bit4=16;

bit5=32;

bit6=64;

bit7=128;

bit8=256;

enatural = 2.71828182845905;

sqrt2 = 1.4142135623730950488016887242097;

HalfPi = 1.57079632679489661923;

F8087_Except :Word = $3F;

F8087_InvalidOp_Except :Word = 1;

F8087_DenormalizedOperand_Except :Word = 1 shl 1;

F8087_DivZero_Except :Word = 1 shl 2;

F8087_Overflow_Except :Word = 1 shl 3;

F8087_Underflow_Except :Word = 1 shl 4;

F8087_PrecError_Except :Word = 1 shl 5;

F8087_Precision :Word = 3 shl 8;

F8087_Single_Precision :Word = 0;

F8087_Reserved_Precision :Word = 1 shl 8;

F8087_Double_Precision :Word = 2 shl 8;

F8087_Extended_Precision :Word = 3 shl 8;

F8087_Round :Word = 3 shl 10;

F8087_NearestOrEven_Round :Word = 0;

F8087_Down_Round :Word = 1 shl 10;

F8087_Up_Round :Word = 2 shl 10;

F8087_TowardZero_Round :Word = 3 shl 10;

F8087_Infinity :Word = 1 shl 12;

F8087_Projective_Infinity :Word = 0;

F8087_Affine_Infinity :Word = 1 shl 12;

Variables

BonusErrorMessg: string ='';

HaltCodeOnException: Integer = 1;

Parameters: TParametersArray;

LocaleDecimalSeparator: char;

Description

Functions and Procedures

procedure Sort(Arr: pointer; ArrRecordSize: Cardinal; IsSmallerFunc: TIsSmallerFunc; IsSmallerFuncData: Pointer; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

This Sorts table of any items.

You must give Arr — pointer to items array in memory, and ArrRecordSize — size (in bytes) of every item, IsSmaller – function that for two arguments should return is "a < b" true (i.e. I'm assuming here that IsSmaller works like mathematical "<" — it's not reflexive (not IsSmaller(a, a)), for a <> b either IsSmaller(a, b) or IsSmaller(b, a) (but not both), it's transitive.

Using parameters FirstIndex and LastIndex you can sort only part of the array, items outside given range will be be even read. (actually you could achieve effect of FirstIndex by simply shifting the pointer Arr, but using FirstIndex is more comfortable). If FirstIndex>LastIndex, this is NOP.

It sorts items ascending, i.e. Arr[FirstIndex] <= ... <= Arr[LastIndex]. (where meaning of "<=" is implicated by meaning of "<" which is given by IsSmaller).

TODO: Polish below.

Jeszcze slowo o wskaznikach jakie bedzie dostawac IsSmallerFunc : mianowicie te wskazniki niekoniecznie zawsze beda rowne PointerAdd(Arr, ArrStride*n) dla jakiegos n. Byc moze wybierajac np. element dzielacy dla quicksorta skopiujemy sobie jego wartosc na chwile i wtedy wskaznik bedzie wskazywal na lokalna kopie danej wartosci ? Kopiowanie bedziemy musieli robic metodami nisko-poziomowymi wiec i tak nie ma problemu z rzeczami ktore wymagaja Initialize/Finalize. Chociaz moze byc w zwiazku z tym problem jesli IsSmallerFunc bedzie moglo przy okazji zmodyfikowac jakos zawartosc danego rekordu - no coz, nie moze tego robic ! IsSmaller powinno byc ladna funkcja.

Ze wzgledu na to ze w srodku Sort samo wykonuje przestawianie elementow na liscie wiec argument ArrRecordSize nie moze byc oszukany - musi byc wiekszy od zera i musi rzeczywiscie obejmowac dokladnie zawartosc rekordu. Z drugiej strony mozesz zawsze uzyc wersji z ArrStride jezeli rekordy ktore chcesz przestawiac sa przeplecione z innymi danymi ktorych nie chcesz przestawiac razem z rekordami. ArrStride mowi co ile bajtow jest nastepny rekord. Domyslnie ArrStride to ArrRecordSize. Oczywiscie mozna sobie zrobic krzywde jezeli podasz np. ArrRecordSize>0 i ArrStride w zakresie [0..ArrRecordSize).

W klasach TDyn*Array zaimplementowalem wersje tej procedury bezpieczna ze wzgledu na typy - tam podajesz tylko funkcje typu function (const a,b:<typ>): boolean [of object]; gdzie <typ> to typ elementow tablicy.

TODO: chwilowo ArrStride nie moze byc ujemne (to moze czasem pozwolic na pewne sztuczki). TODO: zrobic tez wersje ktora zamiast ArrRecordSize pobiera SwapItemsFunc.

procedure Sort(Arr: pointer; ArrRecordSize: Cardinal; ArrStride: integer; IsSmallerFunc: TIsSmallerFunc; IsSmallerFuncData: Pointer; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure SortByObject(Arr: pointer; ArrRecordSize: Cardinal; IsSmallerFunc: TIsSmallerFuncByObject; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure SortByObject(Arr: pointer; ArrRecordSize: Cardinal; ArrStride: integer; IsSmallerFunc: TIsSmallerFuncByObject; FirstIndex, LastIndex: integer; CountToUseSimpleSort: Integer = DefaultCountToUseSimpleSort ); overload;

procedure Check(TrueValue: boolean; const ErrMessage: string);

if not TrueValue then raise ECheckFailed.Create(ErrMessage).

function ArrayPosPointer(A: pointer; const Arr: array of pointer): Integer; overload;

podstawowe zastosowanie ArrayPos jest do zapisywania instrukcji case variable of val1 : inst1; val2 : inst2; else instElse; end; (gdzie variable: Typ) w taki sposob aby Typ nie musial byc typem ordered (np. moze byc stringiem) a val1, val2 nie musialby byc stalymi. Zapisz case jako case ArrayPos(variable,[val1, val2]) of 0 : inst1; 1 : inst2; else instElse; end; ArrayPos(A: T; Arr: Array of T) zwraca pozycje A w Arr (liczac od zera), zwraca -1 jesli A nie wystepuje w Arr.