Distended Arc - Based on FreeArc

DArc is a command-line (and optional GUI) archiver based on FreeArc. It supports solid compression, strong encryption, recovery records, SFX archives, and a wide variety of compression algorithms.

The console binary is named arc (Unix) or Arc.exe (Windows).
The optional GUI binary is named freearc (Unix) or FreeArc.exe (Windows).

Archives produced by DArc are format-compatible with DArc86.

Note: The main Haskell source files are stored in Git LFS. Install git-lfs before cloning, or run git lfs pull after cloning, otherwise source files will be empty LFS pointer stubs.

Build System Overview: DArc uses MicroHs (a lightweight Haskell compiler) for the Haskell code and Clang for C/C++ components (compiled with C++17 standard). The build process automatically compiles all compression libraries, HsLua bindings, and links everything into the final executable.

1. Install MSYS2 with the UCRT64 environment and ensure the MSYS2 binaries are in your PATH (specifically sh.exe, clang, make, curl, and tar should be available).
   • The build scripts require sh.exe from MSYS2 or Git Bash to be accessible from the Windows command prompt.
2. Install MicroHs (mhs) and add %USERPROFILE%\.mcabal\bin to your PATH.
   • MicroHs is the Haskell compiler used for building DArc. No GHC installation is needed.
3. Compile the console version (Arc.exe):

   compile-O2
   

   This will automatically build all necessary C/C++ components, HsLua, and the main executable.
4. Compile the GUI version (FreeArc.exe):

   compile-GUI-O2
   

5. The compiled binaries are placed in the Tests/ subdirectory.
6. To compile SFX modules and Unarc (optional):

   cd Unarc
   make windows
   

   This creates unarc.exe and various SFX modules (arc.sfx, freearc.sfx, etc.).

1. Install MicroHs (mhs) for Haskell compilation. Also install clang, make, and the following development libraries:
   • Required: liblua5.1-dev, libncurses-dev (or ncurses on macOS via Homebrew)
   • Optional: libcurl-dev (or curl on macOS) for URL/network archive support (auto-detected; the build succeeds without it)
   • MicroHs is required by the build script; no GHC installation is needed.
2. Make compile scripts executable (if needed):

   chmod +x compile*

3. Compile the console version (arc):

   ./compile-O2

   This will automatically build all necessary C/C++ components, HsLua, and the main executable.
4. Compile the GUI version (freearc):

   ./compile-GUI-O2

5. The compiled binaries are placed in the Tests/ subdirectory.
6. To compile SFX modules and Unarc (optional):

   cd Unarc
   make linux

   This creates unarc and various SFX modules (arc.linux.sfx, etc.).

Windows:

• "sh.exe not found": Ensure MSYS2 is installed and its bin directory (e.g., C:\msys64\usr\bin) is in your system PATH.
• "mhs not found": Verify MicroHs is installed and %USERPROFILE%\.mcabal\bin is in your PATH. Run mhs --version to test.
• "clang not found": Install the UCRT64 toolchain in MSYS2: pacman -S mingw-w64-ucrt-x86_64-clang mingw-w64-ucrt-x86_64-make
• Compilation errors in C++ files: Ensure you're using C++17 standard. The build scripts automatically set this via the makefiles.

Linux/macOS:

• "mhs not found": Install MicroHs from the official repository and ensure it's in your PATH.
• "lua5.1 not found": Install Lua development libraries:
  • Ubuntu/Debian: sudo apt-get install liblua5.1-0-dev libncurses-dev
  • Fedora/RHEL: sudo dnf install lua-devel ncurses-devel
  • macOS: brew install lua@5.1 ncurses
• "curl not found" (optional): Install libcurl development package or build without URL support (automatic).
• Permission errors: Make sure compile scripts are executable: chmod +x compile*

All Platforms:

• Empty Haskell source files: The Haskell sources use Git LFS. Run git lfs pull to download them.
• "No such file or directory" during compilation: Verify all git submodules are initialized: git submodule update --init --recursive

arc <command> [options...] <archive> [files... @listfiles...]

• <command> — one of the commands listed below.
• [options...] — zero or more options (each prefixed with -).
• <archive> — path to the archive file. The default extension .arc is added automatically unless --noarcext is used.
• [files...] — files or directories to process. Wildcards are supported. If omitted, all files are processed (*).
• [@listfiles...] — text files containing lists of filenames to process, one per line.

Multiple commands can be chained with ; as a separator, for example:

arc "a archive -r ; t archive ; x archive"

# Add all files in the current directory recursively
arc a archive.arc -r .

# Extract all files from an archive
arc x archive.arc

# Extract, ignoring directory paths
arc e archive.arc

# Test archive integrity
arc t archive.arc

# List archive contents
arc l archive.arc

# Delete a file from an archive
arc d archive.arc unwanted.txt

# Add a recovery record (5% of archive size)
arc rr archive.arc -rr5%

# Recover a damaged archive
arc r archive.arc

# Convert to self-extracting archive
arc s archive.arc

# Join multiple archives
arc j output.arc part1.arc part2.arc

# Lock archive (prevent modifications)
arc k archive.arc

Options use the short form -<opt> or long form --<option>.
Options that take a parameter use -<opt><value> or --<option>=<value>.

By default, DArc reads options from arc.ini in standard search paths. You can override the config file with -cfg <file> or disable it with -cfg-.

Default options can be set per-command in the [Default options] section:

[Default options]
a = --display
ch = -m4x -ms

Compression methods can be defined in the [Compression methods] section.

The FREEARC environment variable is also read for default options (override with -env <VAR> or disable with -env-).

You can pass a file containing a list of filenames (one per line) to any command by prefixing the filename with @:

arc a archive.arc @myfiles.txt

# Create archive with maximum compression
arc a -mx myarchive.arc documents/

# Create encrypted archive
arc a -p"my secret" secure.arc private/

# Extract archive to a specific directory
arc x archive.arc -dp /home/user/extracted/

# Add recovery record (10% of archive size)
arc ch myarchive.arc -rr10%

# List archive contents verbosely
arc v myarchive.arc

# Update archive with changed files
arc u myarchive.arc documents/

# Create self-extracting archive
arc s myarchive.arc

# Freshen archive, then test it
arc a archive.arc -r src/ -t

# Compress with specific algorithm and dictionary size
arc a -m4 -md128m myarchive.arc bigfiles/

# Exclude certain file types
arc a myarchive.arc docs/ -x"*.tmp" -x"*.log"

See LICENSE for details.