To compile sources you need Lazarus IDE (https://sourceforge.net/projects/lazarus).
Open .lpi project files and do "build all" to compile the executables.

Basically, you need to compile project_peach.lpi (PeaZip) and project_pea.lpi (Pea), on Windows you also need to compile dragdropfilesdll.lpi and copy dragdropfilesdll.dll in the same directory of PeaZip.

Please read the following documentation to understand what is contained in the source package and please see precompiled program's packages to know what third parts executables (7z, arc, paq...) are needed by PeaZip.


Source package content:


SOURCES:

- project_pea.lpi: PEA, the actual engine for PEA file format support;
- project_peach.lpi: originally PEACH, PEAlaunCHer, that compiles to the main executable
  PeaZip and act as GUI frontend for PEA, 7z and other utilities;
- project_demo_lib.lpi: a demo application using PEA source as a library.

dragdropfilesdll directory contains sources to build dragdropfilesdll.dll, which provides application-to-system files drag&drop functions under Windows systems, sources in this path requires installation of optional Lazarus package DragDropLazarus5.2 (or newer) to be compiled, which is based on work of Angus Johnson & Anders Melander (on Delphi), and Michael K�cher / six (on Lazarus).
The package is available in Lazarus Online Package Manager or from https://packages.lazarus-ide.org/DragDrop.zip

"installer" path contains InnoSetup script files creating Windows installers with file associations and menu integration for PeaZip.

"FreeDesktop_integration" path contain files for integration in desktop environments compliant with FreeDesktop standars (i.e. Gnome and KDE)

.res and resulting .rc files are used on Windows platform to give to the application's executables manifest and binaries information (author, version etc)


MEDIA AND DOCUMENTATION:

Readme_*.txt files contain some hints for the Windows and Linux users.

"copying.txt" is the license file for PeaZip project sources, released under LGPL.

"media" path contains graphic for PeaZip project.

"lang" path contains featured translations of application's text.

"lang-wincontext" path contains .reg files to localize app's context menus in Windows


THIRD PARTS:

Units from Wolfgang Ehrhardt's crypto and utilities library, are intellectual
property of Wolfgang Ehrhardt, released uner Zlib license.
The unit FCAES256.PAS is developed with the contribution of both me and, mainly,
of Wolfgang Ehrhardt.

Latest Wolfgang Ehrhardt's libraries used:
aes_2017-11-17.zip
crc_hash_2018-01-01.zip
fca_2017-11-17.zip
serpent_2017-11-17.zip
tf_2017-11-17.zip
util_2018-11-27.zip

7z (LGPL), 7-Zip-zstd codecs (LGPL), Brotli (MIT License), Zstandard (Dual license BSD / GPLv2), ARC (GPL), LPAQ/PAQ8* (GPL), UnACE (royalty free), QUAD (LGPL), BALZ (public domain), strip and UPX (GPL) binaries are needed to support mainstream file formats, they are not included in source package (but are included in the program's precompiled packages) and are intellectual property of respective Authors.

In PeaZip interface are used some icons inspired by Tango Desktop Project, Crystal/Crystal Clear, and NuoveXT, which are originally released under Creative Commons Attribution Share-Alike and LGPL licenses.

This archive contains AES (Advanced Encryption Standard) related Pascal /
Delphi sources: basic AES routines and recommended block cipher modes of
operation (with test programs that verify compilation and results).

The block level routines supply separate units for encryption and decryption.
The source code for basic encryption/decryption is split into several include
files. At the lowest level there are type definitions and common routines. Key
sizes of 128, 192, and 256 bits are supported.

The following recommended block cipher modes of operation are implemented:
CBC, CFB128, CFB8, CTR, ECB, OFB, OMAC, CMAC, CCM, EAX, GCM, and XTS. All
chaining modes allow plain and cipher text lengths that need not be multiples
of the block length (for ECB and CBC cipher text stealing is used for the
short block; only one short block is allowed and there must be at least one
full block). CTR mode can use 4 built-in incrementing functions or a user
supplied one, and provides seek functions for random access reads.

All routines have been included in the AES_DLL.DLL, there are two interface
units for this DLL (one for Virtual Pascal, the second for the other Win32
compilers).

Since the July 2006 release there are conditional defines to support
compressed tables: one 2K encryption table (calculated with t_mkctab) replaces
the four 1K tables (same for decryption, here the inverse SBox is no longer
needed). Besides using less static memory, compressed tables are considered as
a countermeasure against cache timing attacks.

W.Ehrhardt, Nov. 2017
http://wolfgang-ehrhardt.de

-------------------------------------------------------------------------------

Last changes:

Nov. 2017
- FPC/ARM and Delphi Tokyo adjustments

Sep. 2015
- Constant time verification/compare for the all-in-one packet
  functions (aes_eax, aes_gcm, aes_ccm)

Jan. 2013
- Adjustments (test programs) for D17 (XE3), {$J+} if needed

Dec. 2012
- Small 64-bit adjustments (separate BIT64 include statements in
  aes_decr and aes_encr; improved aes_gcm)

July 2012
- 64-bit adjustment for GCM

Oct. 2010
- Galois/Counter Mode (GCM)
- Fix PPP unit for TP5

Aug. 2010
- Message length ILen has now type longint
- New PPP unit (Perfect Paper Passwords)

June 2010
- AES_CTR_Seek functions

July 2009
- Delphi 2009 (D12) adjustments

May  2009
- Counter with CBC-MAC (CCM) mode

Nov. 2008
- Uses the BTypes unit for better portability

Aug. 2008
- All-in-one EAX functions for encrypt / authenticate and decrypt / verify:
  decryption is performed only if the verification was successful.
- Range check safe IncProcs for FPC -dDebug

Jan. 2008
New unit aes_cfb8 implementing the 8 bit CFB mode

Oct. 2007
- New unit aes_xts implementing the XTS mode from the IEEE P1619 Draft Standard
 for Cryptographic Protection of Data on Block-Oriented Storage Devices.

June 2007
- AES-CMAC-PRF-128 from RFC 4615
- New EAX context name

Nov. 2006
- Contributed AES256 file crypt/authenticate unit

July 2006
- CMAC mode, compressed tables as a countermeasure against cache timing attacks

Jul. 2004
- EAX mode, AES DLL, new demo programs

Jun. 2004
- OMAC mode on AES page

Mar. 2004
- Significant speedup of AES key generation

Jan. 2004
- New faster AES routines

Dec. 2003
- First version of AES archive released

The basic routines in the CRC/Hash archive can be compiled with most current
Pascal (TP 5/5.5/6, BP 7, VP 2.1, FPC 1.0/2.0-2.6/3.x) and Delphi versions
(tested with V1-7/9/10/12/17-18/25S).


--------------------------------------------------------------------------------
Last changes (Dec. 2017)

 * User-requested unit BJL3 which implements Bob Jenkins' non-cryptographic
   hash function lookup3, which is used in newer Delphi's system.hash unit;

 * Another user-request: The [hash]file functions take a string as file
   name parameter type (str255 was a relict from older versions which had
   DLL callable functions);

 * Updated Hash/HMAC/KDF introduction.


--------------------------------------------------------------------------------
Since Feb. 2006 there is a new Hash/HMAC architecture: Hash descriptor
records allow a simple and uniform HMAC implementation for all hash
algorithms; the key derivation functions can use all supported hash
algorithms.Since May 2008 the cryptographic hash and HMAC routines support
messages with arbitrary bit lengths and in Aug. 2015 the integration of SHA3
forces a change of THashContext. Since June 2017 there are minor changes in
the hash descriptor (Blake2 has OID vectors of length 11).


--------------------------------------------------------------------------------
The basic routines were slightly improved in the previous versions, but
optimizing seems to be black magic. The cycles/times are heavily dependent
on CPU, cache, compiler, code position, etc. For example: if the SHA256 loop
is unrolled, the calculation slows down for about 40% on one machine (1.8GHz
P4, D6, Win98), but is about 15% faster on another (AMD 2600+, D5, Win98).

With the test program T_SpeedA and the high resolution timer from hrtimer
you can measure the CPU cycles per byte (Cyc/B) and the processing rate in
MB/s (note that the CPU frequency is determined dynamically). Here are the
values for Delphi/FPC on Win98 with Pentium 4 / 1.7 GHz using a blocksize of
50000 bytes (Std: standard routines with BASM, PP or 64: Pure Pascal with
inline for D18 and FPC2.6.4 -O3, 64-bit on Win7/64 Core i3-2350M):

+-------------+--------+--------+--------+-------+--------+--------+--------+
|             | D3/Std | D3/Std | D6/Std | D6/PP | FPC/PP | FPC-64 | D18-64 |
|        Name |   MB/s |  Cyc/B |  Cyc/B | Cyc/B |  Cyc/B |  Cyc/B |  Cyc/B |
+-------------+--------+--------+--------+-------+--------+--------+--------+
|       CRC16 | 200.16 |    8.5 |    8.5 |  33.4 |   44.9 |   16.3 |   14.7 |
|       CRC24 | 180.17 |    9.4 |    9.4 |  29.9 |   35.1 |   15.3 |   14.2 |
|       CRC32 | 276.51 |    6.1 |    6.1 |  19.7 |   22.3 |   15.2 |   14.2 |
|      FCRC32 | 389.18 |    4.4 |    4.4 |  19.4 |   17.0 |    5.8 |    5.6 |
|     Adler32 | 350.85 |    4.8 |    4.5 |   4.6 |    7.2 |    2.2 |    2.0 |
|  BJ lookup3 | 412.23 |    4.1 |    4.1 |   4.1 |    9.0 |    3.5 |    2.8 |
|       CRC64 |  93.06 |   18.2 |   18.3 |  93.2 |   59.8 |   11.4 |   10.3 |
|     eDonkey | 208.88 |    8.1 |    8.1 |   8.1 |   23.9 |    7.0 |    8.2 |
|         MD4 | 206.74 |    8.2 |    8.1 |   8.1 |   23.2 |    7.0 |    8.2 |
|         MD5 | 151.30 |   11.2 |   11.2 |  11.2 |   44.5 |   10.5 |   10.5 |
|      RMD160 |  53.27 |   31.8 |   31.7 |  31.9 |   88.6 |   29.0 |   27.9 |
|        SHA1 |  51.27 |   33.1 |   38.1 |  41.7 |   52.6 |   25.8 |   18.7 |
|      SHA224 |  28.88 |   58.7 |   55.6 |  50.1 |   64.2 |   45.7 |   34.8 |
|      SHA256 |  28.91 |   58.6 |   55.4 |  50.2 |   64.6 |   45.8 |   34.6 |
|      SHA384 |   9.79 |  173.2 |  205.7 | 206.2 |  219.9 |   28.4 |   25.2 |
|      SHA512 |   9.77 |  173.4 |  205.7 | 206.4 |  227.6 |   28.5 |   25.1 |
|  SHA512/224 |   9.77 |  173.5 |  205.7 | 206.6 |  227.7 |   28.5 |   25.1 |
|  SHA512/256 |   9.79 |  173.1 |  205.8 | 206.2 |  219.2 |   28.5 |   25.2 |
|   Whirlpool |  17.14 |   98.9 |   98.9 |  99.1 |   98.7 |   66.1 |   58.3 |
|    SHA3-224 |  15.20 |  111.5 |  110.7 | 109.4 |  124.1 |   23.6 |   22.5 |
|    SHA3-256 |  14.60 |  116.1 |  116.7 | 115.9 |  132.5 |   24.9 |   23.8 |
|    SHA3-384 |  10.97 |  154.5 |  151.5 | 149.9 |  173.7 |   32.6 |   30.9 |
|    SHA3-512 |   7.87 |  215.5 |  216.1 | 215.3 |  234.6 |   46.7 |   44.6 |
| Blake2s-224 |  33.87 |   50.0 |   50.4 |  49.7 |   68.1 |   40.8 |   30.0 |
| Blake2s-256 |  33.76 |   50.2 |   49.2 |  49.2 |   62.0 |   40.7 |   30.0 |
| Blake2b-384 |  12.17 |  139.3 |  116.5 | 116.4 |  104.6 |   23.8 |   18.2 |
| Blake2b-512 |  12.17 |  139.2 |  116.4 | 116.3 |  104.6 |   23.7 |   18.2 |
+-------------+--------+--------+--------+-------+--------+--------+--------+


MD4, eDonkey/eMule: For files/messages with a multiple of 9728000 bytes
the eDonkey and eMule hashes are different; the ed2k unit always
calculates both digests. The demo programs and the FAR plugin display both
values if they are different.

Units SHA5_224 and SHA5_256: In March 2012 NIST released the new Secure
Hash Standard FIPS 180-4. It defines (among others) two additional secure
hash algorithms SHA-512/224 and SHA-512/256. These are designed like
SHA384, using the compression function of SHA512 but different IVs. NIST
quote: SHA-512/224 and SHA-512/256 may be more efficient alternatives to
SHA-224 and SHA-256, respectively, on platforms that are optimized for
64-bit operations, see the 64-bit columns in the table. My Pascal
implementations use the standard SHA512 and are now fully integrated in
CRC/Hash package; symbols for the new algorithms are defined in the
general hash unit, specific hash and HMAC units are available.

Keccak, SHA-3, and SHAKE: On Oct. 2, 2012 NIST announced Keccak, designed
by Guido Bertoni, Joan Daemen, Michael Peeters, and Gilles Van Assche, as
the winner of the SHA-3 Cryptographic Hash Algorithm Competition. My
original Pascal/Delphi Keccak implementation using the SHA-3 NIST API:
arbitrary length bit sequences are allowed for the messages to be hashed,
the supported digest lengths are 224, 256, 384, 512 bits, and arbitrary
length byte output.

Right now, there are two basic code variants of Keccak-f[1600]: The first
with 32-bit interleaving and rotate instructions coded inline in 32+ bit
PurePascal or inline functions for 16-bit compilers; the second uses
64-bit data types and rotations. However, the 64-bit code is faster than
32-bit only if compiled for a 64-bit CPU and executed on a 64-bit OS!
With {$define USE_MMXCODE} in unit sha3.pas newer 32-bit compilers can use
MMX code (the relative performance change depends on CPU and algorithm;
actually there are two include files, the one contributed by Eric Grange is
the default, it is faster than that from Anna Kaliszewicz and payl on all
tested systems).

In August 2015 NIST published the Standard SHA-3 / FIPS202, which describes
the hash functions SHA3-224/256/384/512 (related but not identical to the
Keccak functions) and the XOF (eXtendable Output) functions SHAKE128/256.
This archive contains the implementation of the new functions based on my
Keccak routines. Unfortunately NIST also changed the bit order in bytes;
therefore the SHA-3 unit has a separate function SHA3_FinalBit_LSB to
process the final trailing LSB bits. The included test programs verify my
implementation against the NIST test examples and the updated test vectors
from the Keccak team.

Int64 support for SHA384/512:  Unfortunately there are conflicting
processor specific results: on a P4 / 1.8GHz the speed decreases to 83% of
the longint speed (Cyc/B increase from 174 to 209). For a Celeron 500MHz
the speed increases more than 30%, the Cyc/B decrease from 146 (longint)
to 111 (Int64). In the source Int64 is default for D4+ and FPC
(conditional define UseInt64 in SHA512.PAS)

BASM16 table alignment: Because some BASM16 implementations use 32 bit
access to 32 bit tables, these tables should be dword aligned for optimal
speed. But the 16 bit compilers support byte or word alignment only!
Therefore the defines from the align.inc include file allow to generate
dummy words, which align the tables to 32 bit boundaries. This feature is
implemented for CRC24 ... CRC64; if more than one of these units are used,
it may be necessary to iterate the alignment procedure.

Pure Pascal versions: The source archive contains pure Pascal versions of
the basic routines without BASM (formerly published in a separate
archive). The main purpose is to supply sources for more portable code
(e.g. for Linux/ARM); consequently the code layout is for FPC with int64
and without asm, but it can be compiled with Delphi 4+. Pure Pascal
routines are invoked if the symbol PurePascal is defined: {$define
PurePascal}, forced for BIT64. For 32-bit systems the PP CRC routines are
significantly slower than the standard sources (see table), but the Hash
function speeds are not so uniform. The pure Pascal routines are 64-bit
compatible (tested with D17+ and FPC 2.6+ on Win64). Special thanks goes
to Nicola Lugato who asked for the pure Pascal units and tested the first
versions on his ARM/Linux machine.

RocksoftTM Model CRC Algorithm: The crcmodel unit is a Pascal
implementation of Ross William's parameterized model CRC algorithm
described in A Painless Guide to CRC Error Detection Algorithms (local
HTML version). Most of the usual CRC algorithms with polynomials up to
degree 32 can be modeled by this unit. The crcm_cat unit has predefined
parameter records for about 100 CRC algorithms, most of them adapted
from Greg Cook's Catalogue of Parameterised CRC Algorithms, more
references are listed in the unit header. The GUI demo programs
tcrc16/tcrc32 interactively calculate and display the results from all
crcm_cat CRC16/CRC32 algorithms for hex and string input, SRP16 searches
CRC16 Rocksoft parameters for given data; the archive
chksum_bin_2017-06-xx.zip includes the EXE files.


--------------------------------------------------------------------------------
Keccak, SHA-3, and SHAKE

On Oct. 2, 2012 NIST announced Keccak, designed by Guido Bertoni, Joan
Daemen, Michael Peeters, and Gilles Van Assche, as the winner of the
SHA-3 Cryptographic Hash Algorithm Competition. The archive
keccak_2013-01-07.zip contains my original Pascal/Delphi Keccak
implementation using the SHA-3 NIST API: arbitrary length bit sequences
are allowed for the messages to be hashed, the supported digest lengths
are 224, 256, 384, 512 bits, and arbitrary length byte output.

Right now, there are two basic code variants of Keccak-f[1600]: The
first with 32-bit interleaving and rotate instructions coded inline in
32+ bit PurePascal or inline functions for 16-bit compilers; the second
uses 64-bit data types and rotations. However, the 64-bit code is faster
than 32-bit only if compiled for a 64-bit CPU and executed on a 64-bit
OS! With {$define USE_MMXCODE} in unit sha3.pas newer 32-bit compilers
can use MMX code (the relative performance change depends on CPU and
algorithm; actually there are two include files, the one contributed by
Eric Grange is the default, it is faster than that from Anna Kaliszewicz
and payl on all tested systems).

In August 2015 NIST published the Standard SHA3 / FIPS202, which
describes the hash functions SHA3-224/256/384/512 (related but not
identical to the Keccak functions) and the XOF (eXtendable Output)
functions SHAKE128/256. The CRC/Hash archive crc_hash_2017-06-xx.zip
contains the implementation of the new functions based on my Keccak
routines. Unfortunately NIST also changed the bit order in bytes;
therefore the SHA-3 unit has a separate function SHA3_FinalBit_LSB to
process the final trailing LSB bits. The included test programs verify
my implementation against the NIST test examples and the updated test
vectors from the Keccak team.


--------------------------------------------------------------------------------
Blake2

The Blake2 cryptographic hash function was designed by J.-P. Aumasson,
S. Neves, Z. Wilcox-O'Hearn, and C. Winnerlein. It has been standardized
in RFC 7693. Blake has it's own mode for keyed message authentication,
making HMAC-Blake2 superfluous. Special thanks goes to EddyHawk for his
fast 32/64-bit compression routines.

My first implementation included in the CRC/Hash archive was Blake2s
which can be compiled by all supported Pascal compilers. Blake2s returns
hash digests of any size up to 32 bytes. Unit blake2s.pas implements the
general Blake2s functions including key support, units blaks224.pas and
blaks256.pas have the special code for unkeyed 224- and 256-bit digests.

There is another incompatible version called Blake2b, which is optimized
for 64-bit systems. It can be compiled with all compilers, but note that
for compilers older than Delphi 4 the int64 arithmetic is simulated (and
therefore slower).


--------------------------------------------------------------------------------
Bob Jenkins' lookup3

This hash function by Bob Jenkins is designed for hash table lookup, it is no
cryptographic hash. The purpose of the user-requested unit BJL3 is to make
available the non-cryptographic function from Delphi's system.hash unit (since
Delphi 22 / XE8 / VER290). BJL3 is a clean-room Pascal implementation of the
lookup3 C code for little endian, and does not use Delphi of FPC source codes.
Note: Lookup3 hashes all bytes of a message with a single call, including the
message length. A standard chaining / on-line algorithm (Init/Update/Final) can
be implemented, but it depends on the splitting of the message, and is
therefore virtually inappropriate for file check sums.


---------------------------------------------------------------------------
W.Ehrhardt, Dec. 2017
http://wolfgang-ehrhardt.de

The archive contains a collection of small units; in the past some of the
units were available separately. Online help is available as Windows .hlp file
or as a .tph for BP7 IDE.

* Base2N V0.38: General base 2**N conversion routines (N=1...6)
* Bitarray V0.17: Bit array context with max. 524160 bits (spin off from
  mpint 16 bit prime sieve)
* BTypes V0.12: Common basic type definitions
* Compvers V0.18: Compiler version as string or symbol
* Dates V0.33: Implements compiler and OS independent routines for the
  current date and time (including milliseconds since midnight) and functions
  for Julian day numbers.
* Fio V0.15: File IO with $I- and Err variable (without try/finally), simple
  wrapper calls for system routines.
* Hrtimer V0.23: Contains a high resolution timer for most Pascal/Delphi
  compilers using the comp data type. It uses the RDTSC instruction,
  therefore it will stop on machines that do not support RDTSC (this feature
  can be turned off via $ifdef). The timer is used by several optimizing test
  programs.
* Mem_util V0.94: Implements compiler independent routines for comparing
  memory blocks and converting memory blocks to HEX and Base64 strings.
* Ministat V0.43: Statistics unit with accurate "on the fly" statistics
  routines for one and two variables.
* Sort V1.18: General QuickSort, HeapSort (standard and bottom-up), CombSort
  routines using swap/compare functions. Additional pointer versions have a
  typeless data pointer that is carried through the functions and can be used
  to access local data etc by the caller.
* Tsc V0.35: This unit has a more low level access to the Time Stamp Counter
  than hrtimer and additionally defines a system dependent low resolution
  counter (GetTickCount, 18.2 Hz Systick, or milliseconds since midnight) if
  RDTSC support is not available.

Last changes:
 - FPC 2.2.2 in Compvers V0.18
 - Code for TP5-7 in Sort V1.18


http://home.netsurf.de/wolfgang.ehrhardt

AES (and Serpent/Twofish) demo applications  (c) 2003-2017 W.Ehrhardt

Simple demo programs for file encryption/authentication and
decryption/verification

Source code included/available

http://wolfgang-ehrhardt.de

The programs use two modes, first is 128 bit AES-CTR mode with HMAC-SHA1-128;
the second mode is EAX. The 96 bit salt is a truncated SHA1 hash, keys and
pass phrase verifier are derived from the pass phrase according to RFC 2898.

To compile the demo programs from the sources you need the base routines
aes_<yyyy-mm-dd>.zip, crc_hash_<yyyy-mm-dd>.zip, and util_<yyyy-mm-dd>.zip.

The FZCA program optionally compresses the data before encryption, the source
from zlibw114_<yyyy-mm-dd>.zip is required.

Since Nov. 2006 there is the contributed fcaes256 unit started by Giorgio
Tani using 256 bit AES-EAX mode or AES-CTR and HMAC-Whirlpool-128 (also used
in Giorgio's PeaZip project). fca256 is the 256 bit equivalent of FCA.

In Mar. 2016 Giorgio Tani contributed analogous units for the AES finalists
Serpent and Twofish, they are included in this archive together with four
test programs.

---------------------------------------------------------------------------
Last changes (Nov. 2017)
- FPC/ARM and Delphi Tokyo adjustments

FPC note: Use the source with std.inc V1.30 or newer which introduces a
helper definition for FPC's crazy handling of procedure variables. If you
need to compile in Turbo Pascal mode (-So or -Mtp) you should manually change
the single {$ifdef FPC} to {$ifdef FPC_ProcVar} in the hash descriptor
constants (sha1.pas and whirlpool.pas).

2 GB Note: the demo programs should only be applied to files with sizes less
than 3 GB if compiled with Delphi or 16 bit Pascal (Delphi eof bug and/or 32
bit filesize function). Newer FreePascal versions with 64 bit filesize
function may work for such big files.

This archive contains Pascal/Delphi sources for the Twofish cipher.
There is code for a DLL and the following modes of operation are
supported: CBC, CFB128, CTR, ECB,OFB, OMAC, and EAX. All modes allow
plain and cipher text lengths that need not be multiples of the block
length (for ECB and CBC cipher text stealing is used for the short
block). CTR mode can use 4 built-in incrementing functions or a user
supplied one, and provides seek functions for random access reads.

All modes of operation (except OMAC/EAX) support a reset function that
re-initializes the chaining variables without the (time consuming)
recalculation of the round keys.

Last changes (Nov. 2017)
- FPC/ARM and Delphi Tokyo adjustments

The archive contains a collection of small units; in the past some of the
units were available separately.

The units and basic test programs can be compiled with the usual Pascal
(TP5/5.5/6, BP7, VP 2.1, FPC 1.0/2.0/2.2/2.4/2.6/3+) and Delphi (1..7/9/
10/12/17/18/25/26) versions.

Online help is available as Windows .hlp file or as a .tph for BP7 IDE.

 * Base2N V0.42: General base 2**N conversion routines (N=1...6)

 * Bitarray V0.19: Bit array context with max. 524160 bits (spin off from
   MPArith 16 bit prime sieve)

 * BTypes V0.21: Portable common basic types

 * Compvers V0.41: Compiler version as string or symbol

 * Dates V0.38: Implements compiler and OS independent routines for the
   current date and time (including milliseconds since midnight) and functions
   for Julian day numbers.

 * Hrtimer V0.29: Contains a high resolution timer for most Pascal/Delphi
   compilers using the comp data type. It uses the RDTSC instruction,
   therefore it will stop on machines (except ARM) that do not support RDTSC
   (this feature can be turned off via $ifdef). The timer is used by several
   optimizing test programs.

 * memh V0.15: Implements portable heap memory allocation functions

 * Mem_util V0.99: Implements compiler independent routines for comparing
   memory blocks and converting memory blocks to HEX and Base64 strings.

 * Ministat V0.45: Statistics unit with accurate "on the fly" statistics
   routines for one and two variables.

 * Sort V1.18: General QuickSort, HeapSort (standard and bottom-up), CombSort
   routines using swap/compare functions. Additional pointer versions have a
   typeless data pointer that is carried through the functions and can be used
   to access local data etc. by the caller.

 * std.inc V1.75: Standard include file for compiler detection, standard
   definitions, options.

 * Tsc V0.44: This unit has a more low level access to the Time Stamp Counter
   than hrtimer and additionally defines a system dependent low resolution
   counter (GetTickCount, 18.2 Hz Systick, or milliseconds since midnight) if
   RDTSC support is not available.


---------------------------------------------------------------------------

Last changes (Nov. 2018)

  * Standard include file std.inc V1.75 and unit Compvers V0.41
    support Delphi 26 / 10.3 'Rio' / VER330.

http://wolfgang-ehrhardt.de