lz4cli.c File Reference

#include "platform.h"
#include "util.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bench.h"
#include "lz4io.h"
#include "lz4hc.h"
#include "lz4.h"

Go to the source code of this file.

Macros
#define	COMPRESSOR_NAME   "LZ4 command line interface"
#define	AUTHOR   "Yann Collet"
#define	WELCOME_MESSAGE   "*** %s %i-bits v%s, by %s ***\n", COMPRESSOR_NAME, (int)(sizeof(void*)*8), LZ4_versionString(), AUTHOR
#define	LZ4_EXTENSION   ".lz4"
#define	LZ4CAT   "lz4cat"
#define	UNLZ4   "unlz4"
#define	LZ4_LEGACY   "lz4c"
#define	KB   *(1U<<10)
#define	MB   *(1U<<20)
#define	GB   *(1U<<30)
#define	LZ4_BLOCKSIZEID_DEFAULT   7
#define	DISPLAYOUT(...)   fprintf(stdout, __VA_ARGS__)
#define	DISPLAY(...)   fprintf(stderr, __VA_ARGS__)
#define	DISPLAYLEVEL(l, ...)   if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
#define	DEBUG   0
#define	DEBUGOUTPUT(...)   if (DEBUG) DISPLAY(__VA_ARGS__);
#define	EXM_THROW(error, ...)
#define	DEFAULT_COMPRESSOR   LZ4IO_compressFilename
#define	DEFAULT_DECOMPRESSOR   LZ4IO_decompressFilename

Enumerations
enum	operationMode_e {   om_auto , om_compress , om_decompress , om_test ,   om_bench , om_list }

Functions
int	LZ4IO_compressFilename_Legacy (const char *input_filename, const char *output_filename, int compressionlevel, const LZ4IO_prefs_t *prefs)
int	LZ4IO_compressMultipleFilenames_Legacy (const char **inFileNamesTable, int ifntSize, const char *suffix, int compressionLevel, const LZ4IO_prefs_t *prefs)
static int	usage (const char *exeName)
static int	usage_advanced (const char *exeName)
static int	usage_longhelp (const char *exeName)
static int	badusage (const char *exeName)
static void	waitEnter (void)
static const char *	lastNameFromPath (const char *path)
static int	exeNameMatch (const char *exeName, const char *test)
static unsigned	readU32FromChar (const char **stringPtr)
static int	longCommandWArg (const char **stringPtr, const char *longCommand)
static operationMode_e	determineOpMode (const char *inputFilename)
int	main (int argc, const char **argv)

Variables
static int	g_lz4c_legacy_commands = 0
static unsigned	displayLevel = 2

Macro Definition Documentation

AUTHOR

#define AUTHOR   "Yann Collet"

Definition at line 52 of file lz4cli.c.

COMPRESSOR_NAME

#define COMPRESSOR_NAME   "LZ4 command line interface"

Definition at line 51 of file lz4cli.c.

DEBUG

#define DEBUG   0

Definition at line 79 of file lz4cli.c.

DEBUGOUTPUT

#define DEBUGOUTPUT

(

...

)

if (DEBUG) DISPLAY(__VA_ARGS__);

Definition at line 80 of file lz4cli.c.

DEFAULT_COMPRESSOR

#define DEFAULT_COMPRESSOR   LZ4IO_compressFilename

Definition at line 94 of file lz4cli.c.

DEFAULT_DECOMPRESSOR

#define DEFAULT_DECOMPRESSOR   LZ4IO_decompressFilename

Definition at line 95 of file lz4cli.c.

DISPLAY

#define DISPLAY

(

...

)

fprintf(stderr, __VA_ARGS__)

Definition at line 71 of file lz4cli.c.

DISPLAYLEVEL

#define DISPLAYLEVEL	(		l,
			...
	)		if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }

Definition at line 72 of file lz4cli.c.

DISPLAYOUT

#define DISPLAYOUT

(

...

)

fprintf(stdout, __VA_ARGS__)

Definition at line 70 of file lz4cli.c.

EXM_THROW

#define EXM_THROW	(		error,
			...
	)

Value:

{                                                                         \
    DEBUGOUTPUT("Error defined at %s, line %i : \n", __FILE__, __LINE__); \
    DISPLAYLEVEL(1, "Error %i : ", error);                                \
    DISPLAYLEVEL(1, __VA_ARGS__);                                         \
    DISPLAYLEVEL(1, "\n");                                                \
    exit(error);                                                          \
}

Definition at line 81 of file lz4cli.c.

GB

#define GB   *(1U<<30)

Definition at line 62 of file lz4cli.c.

KB

#define KB   *(1U<<10)

Definition at line 60 of file lz4cli.c.

LZ4_BLOCKSIZEID_DEFAULT

#define LZ4_BLOCKSIZEID_DEFAULT   7

Definition at line 64 of file lz4cli.c.

LZ4_EXTENSION

#define LZ4_EXTENSION   ".lz4"

Definition at line 54 of file lz4cli.c.

LZ4_LEGACY

#define LZ4_LEGACY   "lz4c"

Definition at line 57 of file lz4cli.c.

LZ4CAT

#define LZ4CAT   "lz4cat"

Definition at line 55 of file lz4cli.c.

MB

#define MB   *(1U<<20)

Definition at line 61 of file lz4cli.c.

UNLZ4

#define UNLZ4   "unlz4"

Definition at line 56 of file lz4cli.c.

WELCOME_MESSAGE

#define WELCOME_MESSAGE   "*** %s %i-bits v%s, by %s ***\n", COMPRESSOR_NAME, (int)(sizeof(void*)*8), LZ4_versionString(), AUTHOR

Definition at line 53 of file lz4cli.c.

Enumeration Type Documentation

operationMode_e

enum operationMode_e

Enumerator
om_auto
om_compress
om_decompress
om_test
om_bench
om_list

Definition at line 295 of file lz4cli.c.

{ om_auto, om_compress, om_decompress, om_test, om_bench, om_list } operationMode_e;

Function Documentation

badusage()

static int badusage ( const char *  exeName )

static

Definition at line 228 of file lz4cli.c.

{
    DISPLAYLEVEL(1, "Incorrect parameters\n");
    if (displayLevel >= 1) usage(exeName);
    exit(1);
}

References DISPLAYLEVEL, displayLevel, test-lz4-list::exit, and usage().

Referenced by main().

determineOpMode()

static operationMode_e determineOpMode ( const char *  inputFilename )

static

determineOpMode() : auto-determine operation mode, based on input filename extension

Returns

om_decompress if input filename has .lz4 extension and om_compress otherwise.

Definition at line 301 of file lz4cli.c.

{
    size_t const inSize  = strlen(inputFilename);
    size_t const extSize = strlen(LZ4_EXTENSION);
    size_t const extStart= (inSize > extSize) ? inSize-extSize : 0;
    if (!strcmp(inputFilename+extStart, LZ4_EXTENSION)) return om_decompress;
    else return om_compress;
}

References LZ4_EXTENSION, om_compress, and om_decompress.

Referenced by main().

exeNameMatch()

static int exeNameMatch ( const char *  exeName, const char *  test  )

static

exeNameMatch() :

Returns

: a non-zero value if exeName matches test, excluding the extension

Definition at line 253 of file lz4cli.c.

{
    return !strncmp(exeName, test, strlen(test)) &&
        (exeName[strlen(test)] == '\0' || exeName[strlen(test)] == '.');
}

Referenced by main().

lastNameFromPath()

static const char* lastNameFromPath ( const char *  path )

static

Definition at line 242 of file lz4cli.c.

{
    const char* name = path;
    if (strrchr(name, '/')) name = strrchr(name, '/') + 1;
    if (strrchr(name, '\\')) name = strrchr(name, '\\') + 1; /* windows */
    return name;
}

References name, and path.

Referenced by main().

longCommandWArg()

static int longCommandWArg ( const char **  stringPtr, const char *  longCommand  )

static

longCommandWArg() : check if *stringPtr is the same as longCommand. If yes,

Returns

1 and advances *stringPtr to the position which immediately follows longCommand.

0 and doesn't modify *stringPtr otherwise.

Definition at line 287 of file lz4cli.c.

{
    size_t const comSize = strlen(longCommand);
    int const result = !strncmp(*stringPtr, longCommand, comSize);
    if (result) *stringPtr += comSize;
    return result;
}

Referenced by main().

LZ4IO_compressFilename_Legacy()

int LZ4IO_compressFilename_Legacy	(	const char *	input_filename,
		const char *	output_filename,
		int	compressionlevel,
		const LZ4IO_prefs_t *	prefs
	)

Definition at line 399 of file lz4io.c.

{
    typedef int (*compress_f)(const char* src, char* dst, int srcSize, int dstSize, int cLevel);
    compress_f const compressionFunction = (compressionlevel < 3) ? LZ4IO_LZ4_compress : LZ4_compress_HC;
    unsigned long long filesize = 0;
    unsigned long long compressedfilesize = MAGICNUMBER_SIZE;
    char* in_buff;
    char* out_buff;
    const int outBuffSize = LZ4_compressBound(LEGACY_BLOCKSIZE);
    FILE* const finput = LZ4IO_openSrcFile(input_filename);
    FILE* foutput;
    clock_t clockEnd;
 
    /* Init */
    clock_t const clockStart = clock();
    if (finput == NULL)
        EXM_THROW(20, "%s : open file error ", input_filename);
 
    foutput = LZ4IO_openDstFile(output_filename, prefs);
    if (foutput == NULL) {
        fclose(finput);
        EXM_THROW(20, "%s : open file error ", input_filename);
    }
 
    /* Allocate Memory */
    in_buff = (char*)malloc(LEGACY_BLOCKSIZE);
    out_buff = (char*)malloc((size_t)outBuffSize + 4);
    if (!in_buff || !out_buff)
        EXM_THROW(21, "Allocation error : not enough memory");
 
    /* Write Archive Header */
    LZ4IO_writeLE32(out_buff, LEGACY_MAGICNUMBER);
    if (fwrite(out_buff, 1, MAGICNUMBER_SIZE, foutput) != MAGICNUMBER_SIZE)
        EXM_THROW(22, "Write error : cannot write header");
 
    /* Main Loop */
    while (1) {
        int outSize;
        /* Read Block */
        size_t const inSize = fread(in_buff, (size_t)1, (size_t)LEGACY_BLOCKSIZE, finput);
        if (inSize == 0) break;
        assert(inSize <= LEGACY_BLOCKSIZE);
        filesize += inSize;
 
        /* Compress Block */
        outSize = compressionFunction(in_buff, out_buff+4, (int)inSize, outBuffSize, compressionlevel);
        assert(outSize >= 0);
        compressedfilesize += (unsigned long long)outSize+4;
        DISPLAYUPDATE(2, "\rRead : %i MB  ==> %.2f%%   ",
                (int)(filesize>>20), (double)compressedfilesize/filesize*100);
 
        /* Write Block */
        assert(outSize > 0);
        assert(outSize < outBuffSize);
        LZ4IO_writeLE32(out_buff, (unsigned)outSize);
        if (fwrite(out_buff, 1, (size_t)outSize+4, foutput) != (size_t)(outSize+4)) {
            EXM_THROW(24, "Write error : cannot write compressed block");
    }   }
    if (ferror(finput)) EXM_THROW(25, "Error while reading %s ", input_filename);
 
    /* Status */
    clockEnd = clock();
    if (clockEnd==clockStart) clockEnd+=1;  /* avoid division by zero (speed) */
    filesize += !filesize;   /* avoid division by zero (ratio) */
    DISPLAYLEVEL(2, "\r%79s\r", "");   /* blank line */
    DISPLAYLEVEL(2,"Compressed %llu bytes into %llu bytes ==> %.2f%%\n",
        filesize, compressedfilesize, (double)compressedfilesize / filesize * 100);
    {   double const seconds = (double)(clockEnd - clockStart) / CLOCKS_PER_SEC;
        DISPLAYLEVEL(4,"Done in %.2f s ==> %.2f MB/s\n", seconds,
                        (double)filesize / seconds / 1024 / 1024);
    }
 
    /* Close & Free */
    free(in_buff);
    free(out_buff);
    fclose(finput);
    if (strcmp(output_filename,stdoutmark)) fclose(foutput);   /* do not close stdout */
 
    return 0;
}

References assert(), DISPLAYLEVEL, DISPLAYUPDATE, dst, EXM_THROW, benchmark::FILE, free(), int, LEGACY_BLOCKSIZE, LEGACY_MAGICNUMBER, long, LZ4_compress_HC(), LZ4_compressBound(), LZ4IO_LZ4_compress(), LZ4IO_openDstFile(), LZ4IO_openSrcFile(), LZ4IO_writeLE32(), MAGICNUMBER_SIZE, malloc(), NULL, src, srcSize, and stdoutmark.

Referenced by LZ4IO_compressMultipleFilenames_Legacy(), and main().

LZ4IO_compressMultipleFilenames_Legacy()

int LZ4IO_compressMultipleFilenames_Legacy	(	const char **	inFileNamesTable,
		int	ifntSize,
		const char *	suffix,
		int	compressionLevel,
		const LZ4IO_prefs_t *	prefs
	)

Definition at line 485 of file lz4io.c.

{
    int i;
    int missed_files = 0;
    char* dstFileName = (char*)malloc(FNSPACE);
    size_t ofnSize = FNSPACE;
    const size_t suffixSize = strlen(suffix);
 
    if (dstFileName == NULL) return ifntSize;   /* not enough memory */
 
    /* loop on each file */
    for (i=0; i<ifntSize; i++) {
        size_t const ifnSize = strlen(inFileNamesTable[i]);
        if (!strcmp(suffix, stdoutmark)) {
            missed_files += LZ4IO_compressFilename_Legacy(
                                    inFileNamesTable[i], stdoutmark,
                                    compressionLevel, prefs);
            continue;
        }
 
        if (ofnSize <= ifnSize+suffixSize+1) {
            free(dstFileName);
            ofnSize = ifnSize + 20;
            dstFileName = (char*)malloc(ofnSize);
            if (dstFileName==NULL) {
                return ifntSize;
        }   }
        strcpy(dstFileName, inFileNamesTable[i]);
        strcat(dstFileName, suffix);
 
        missed_files += LZ4IO_compressFilename_Legacy(
                                inFileNamesTable[i], dstFileName,
                                compressionLevel, prefs);
    }
 
    /* Close & Free */
    free(dstFileName);
 
    return missed_files;
}

References compressionLevel, FNSPACE, free(), i, LZ4IO_compressFilename_Legacy(), malloc(), NULL, stdoutmark, and suffix.

Referenced by main().

main()

int main	(	int	argc,
		const char **	argv
	)

Definition at line 310 of file lz4cli.c.

{
    int i,
        cLevel=1,
        cLevelLast=-10000,
        legacy_format=0,
        forceStdout=0,
        main_pause=0,
        multiple_inputs=0,
        all_arguments_are_files=0,
        operationResult=0;
    operationMode_e mode = om_auto;
    const char* input_filename = NULL;
    const char* output_filename= NULL;
    const char* dictionary_filename = NULL;
    char* dynNameSpace = NULL;
    const char** inFileNames = (const char**)calloc((size_t)argc, sizeof(char*));
    unsigned ifnIdx=0;
    LZ4IO_prefs_t* const prefs = LZ4IO_defaultPreferences();
    const char nullOutput[] = NULL_OUTPUT;
    const char extension[] = LZ4_EXTENSION;
    size_t blockSize = LZ4IO_setBlockSizeID(prefs, LZ4_BLOCKSIZEID_DEFAULT);
    const char* const exeName = lastNameFromPath(argv[0]);
#ifdef UTIL_HAS_CREATEFILELIST
    const char** extendedFileList = NULL;
    char* fileNamesBuf = NULL;
    unsigned fileNamesNb, recursive=0;
#endif
 
    /* Init */
    if (inFileNames==NULL) {
        DISPLAY("Allocation error : not enough memory \n");
        return 1;
    }
    inFileNames[0] = stdinmark;
    LZ4IO_setOverwrite(prefs, 0);
 
    /* predefined behaviors, based on binary/link name */
    if (exeNameMatch(exeName, LZ4CAT)) {
        mode = om_decompress;
        LZ4IO_setOverwrite(prefs, 1);
        LZ4IO_setPassThrough(prefs, 1);
        LZ4IO_setRemoveSrcFile(prefs, 0);
        forceStdout=1;
        output_filename=stdoutmark;
        displayLevel=1;
        multiple_inputs=1;
    }
    if (exeNameMatch(exeName, UNLZ4)) { mode = om_decompress; }
    if (exeNameMatch(exeName, LZ4_LEGACY)) { g_lz4c_legacy_commands=1; }
 
    /* command switches */
    for(i=1; i<argc; i++) {
        const char* argument = argv[i];
 
        if(!argument) continue;   /* Protection if argument empty */
 
        /* Short commands (note : aggregated short commands are allowed) */
        if (!all_arguments_are_files && argument[0]=='-') {
            /* '-' means stdin/stdout */
            if (argument[1]==0) {
                if (!input_filename) input_filename=stdinmark;
                else output_filename=stdoutmark;
                continue;
            }
 
            /* long commands (--long-word) */
            if (argument[1]=='-') {
                if (!strcmp(argument,  "--")) { all_arguments_are_files = 1; continue; }
                if (!strcmp(argument,  "--compress")) { mode = om_compress; continue; }
                if ((!strcmp(argument, "--decompress"))
                    || (!strcmp(argument, "--uncompress"))) { mode = om_decompress; continue; }
                if (!strcmp(argument,  "--multiple")) { multiple_inputs = 1; continue; }
                if (!strcmp(argument,  "--test")) { mode = om_test; continue; }
                if (!strcmp(argument,  "--force")) { LZ4IO_setOverwrite(prefs, 1); continue; }
                if (!strcmp(argument,  "--no-force")) { LZ4IO_setOverwrite(prefs, 0); continue; }
                if ((!strcmp(argument, "--stdout"))
                    || (!strcmp(argument, "--to-stdout"))) { forceStdout=1; output_filename=stdoutmark; continue; }
                if (!strcmp(argument,  "--frame-crc")) { LZ4IO_setStreamChecksumMode(prefs, 1); continue; }
                if (!strcmp(argument,  "--no-frame-crc")) { LZ4IO_setStreamChecksumMode(prefs, 0); continue; }
                if (!strcmp(argument,  "--content-size")) { LZ4IO_setContentSize(prefs, 1); continue; }
                if (!strcmp(argument,  "--no-content-size")) { LZ4IO_setContentSize(prefs, 0); continue; }
                if (!strcmp(argument,  "--list")) { mode = om_list; continue; }
                if (!strcmp(argument,  "--sparse")) { LZ4IO_setSparseFile(prefs, 2); continue; }
                if (!strcmp(argument,  "--no-sparse")) { LZ4IO_setSparseFile(prefs, 0); continue; }
                if (!strcmp(argument,  "--favor-decSpeed")) { LZ4IO_favorDecSpeed(prefs, 1); continue; }
                if (!strcmp(argument,  "--verbose")) { displayLevel++; continue; }
                if (!strcmp(argument,  "--quiet")) { if (displayLevel) displayLevel--; continue; }
                if (!strcmp(argument,  "--version")) { DISPLAYOUT(WELCOME_MESSAGE); goto _cleanup; }
                if (!strcmp(argument,  "--help")) { usage_advanced(exeName); goto _cleanup; }
                if (!strcmp(argument,  "--keep")) { LZ4IO_setRemoveSrcFile(prefs, 0); continue; }   /* keep source file (default) */
                if (!strcmp(argument,  "--rm")) { LZ4IO_setRemoveSrcFile(prefs, 1); continue; }
                if (longCommandWArg(&argument, "--fast")) {
                        /* Parse optional acceleration factor */
                        if (*argument == '=') {
                            U32 fastLevel;
                            ++argument;
                            fastLevel = readU32FromChar(&argument);
                            if (fastLevel) {
                              cLevel = -(int)fastLevel;
                            } else {
                              badusage(exeName);
                            }
                        } else if (*argument != 0) {
                            /* Invalid character following --fast */
                            badusage(exeName);
                        } else {
                            cLevel = -1;  /* default for --fast */
                        }
                        continue;
                    }
 
                /* For gzip(1) compatibility */
                if (!strcmp(argument,  "--best")) { cLevel=LZ4HC_CLEVEL_MAX; continue; }
            }
 
            while (argument[1]!=0) {
                argument ++;
 
                if (g_lz4c_legacy_commands) {
                    /* Legacy commands (-c0, -c1, -hc, -y) */
                    if (!strcmp(argument,  "c0")) { cLevel=0; argument++; continue; }  /* -c0 (fast compression) */
                    if (!strcmp(argument,  "c1")) { cLevel=9; argument++; continue; }  /* -c1 (high compression) */
                    if (!strcmp(argument,  "c2")) { cLevel=12; argument++; continue; } /* -c2 (very high compression) */
                    if (!strcmp(argument,  "hc")) { cLevel=12; argument++; continue; } /* -hc (very high compression) */
                    if (!strcmp(argument,  "y"))  { LZ4IO_setOverwrite(prefs, 1); continue; } /* -y (answer 'yes' to overwrite permission) */
                }
 
                if ((*argument>='0') && (*argument<='9')) {
                    cLevel = (int)readU32FromChar(&argument);
                    argument--;
                    continue;
                }
 
 
                switch(argument[0])
                {
                    /* Display help */
                case 'V': DISPLAYOUT(WELCOME_MESSAGE); goto _cleanup;   /* Version */
                case 'h': usage_advanced(exeName); goto _cleanup;
                case 'H': usage_longhelp(exeName); goto _cleanup;
 
                case 'e':
                    argument++;
                    cLevelLast = (int)readU32FromChar(&argument);
                    argument--;
                    break;
 
                    /* Compression (default) */
                case 'z': mode = om_compress; break;
 
                case 'D':
                    if (argument[1] == '\0') {
                        /* path is next arg */
                        if (i + 1 == argc) {
                            /* there is no next arg */
                            badusage(exeName);
                        }
                        dictionary_filename = argv[++i];
                    } else {
                        /* path follows immediately */
                        dictionary_filename = argument + 1;
                    }
                    /* skip to end of argument so that we jump to parsing next argument */
                    argument += strlen(argument) - 1;
                    break;
 
                    /* Use Legacy format (ex : Linux kernel compression) */
                case 'l': legacy_format = 1; blockSize = 8 MB; break;
 
                    /* Decoding */
                case 'd': mode = om_decompress; break;
 
                    /* Force stdout, even if stdout==console */
                case 'c':
                  forceStdout=1;
                  output_filename=stdoutmark;
                  LZ4IO_setPassThrough(prefs, 1);
                  break;
 
                    /* Test integrity */
                case 't': mode = om_test; break;
 
                    /* Overwrite */
                case 'f': LZ4IO_setOverwrite(prefs, 1); break;
 
                    /* Verbose mode */
                case 'v': displayLevel++; break;
 
                    /* Quiet mode */
                case 'q': if (displayLevel) displayLevel--; break;
 
                    /* keep source file (default anyway, so useless) (for xz/lzma compatibility) */
                case 'k': LZ4IO_setRemoveSrcFile(prefs, 0); break;
 
                    /* Modify Block Properties */
                case 'B':
                    while (argument[1]!=0) {
                        int exitBlockProperties=0;
                        switch(argument[1])
                        {
                        case 'D': LZ4IO_setBlockMode(prefs, LZ4IO_blockLinked); argument++; break;
                        case 'I': LZ4IO_setBlockMode(prefs, LZ4IO_blockIndependent); argument++; break;
                        case 'X': LZ4IO_setBlockChecksumMode(prefs, 1); argument ++; break;   /* disabled by default */
                        default :
                            if (argument[1] < '0' || argument[1] > '9') {
                                exitBlockProperties=1;
                                break;
                            } else {
                                unsigned B;
                                argument++;
                                B = readU32FromChar(&argument);
                                argument--;
                                if (B < 4) badusage(exeName);
                                if (B <= 7) {
                                    blockSize = LZ4IO_setBlockSizeID(prefs, B);
                                    BMK_setBlockSize(blockSize);
                                    DISPLAYLEVEL(2, "using blocks of size %u KB \n", (U32)(blockSize>>10));
                                } else {
                                    if (B < 32) badusage(exeName);
                                    blockSize = LZ4IO_setBlockSize(prefs, B);
                                    BMK_setBlockSize(blockSize);
                                    if (blockSize >= 1024) {
                                        DISPLAYLEVEL(2, "using blocks of size %u KB \n", (U32)(blockSize>>10));
                                    } else {
                                        DISPLAYLEVEL(2, "using blocks of size %u bytes \n", (U32)(blockSize));
                                    }
                                }
                                break;
                            }
                        }
                        if (exitBlockProperties) break;
                    }
                    break;
 
                    /* Benchmark */
                case 'b': mode = om_bench; multiple_inputs=1;
                    break;
 
                    /* hidden command : benchmark files, but do not fuse result */
                case 'S': BMK_setBenchSeparately(1);
                    break;
 
#ifdef UTIL_HAS_CREATEFILELIST
                    /* recursive */
                case 'r': recursive=1;
#endif
                    /* fall-through */
                    /* Treat non-option args as input files.  See https://code.google.com/p/lz4/issues/detail?id=151 */
                case 'm': multiple_inputs=1;
                    break;
 
                    /* Modify Nb Seconds (benchmark only) */
                case 'i':
                    {   unsigned iters;
                        argument++;
                        iters = readU32FromChar(&argument);
                        argument--;
                        BMK_setNotificationLevel(displayLevel);
                        BMK_setNbSeconds(iters);   /* notification if displayLevel >= 3 */
                    }
                    break;
 
                    /* Pause at the end (hidden option) */
                case 'p': main_pause=1; break;
 
                    /* Unrecognised command */
                default : badusage(exeName);
                }
            }
            continue;
        }
 
        /* Store in *inFileNames[] if -m is used. */
        if (multiple_inputs) { inFileNames[ifnIdx++]=argument; continue; }
 
        /* Store first non-option arg in input_filename to preserve original cli logic. */
        if (!input_filename) { input_filename=argument; continue; }
 
        /* Second non-option arg in output_filename to preserve original cli logic. */
        if (!output_filename) {
            output_filename=argument;
            if (!strcmp (output_filename, nullOutput)) output_filename = nulmark;
            continue;
        }
 
        /* 3rd non-option arg should not exist */
        DISPLAYLEVEL(1, "Warning : %s won't be used ! Do you want multiple input files (-m) ? \n", argument);
    }
 
    DISPLAYLEVEL(3, WELCOME_MESSAGE);
#ifdef _POSIX_C_SOURCE
    DISPLAYLEVEL(4, "_POSIX_C_SOURCE defined: %ldL\n", (long) _POSIX_C_SOURCE);
#endif
#ifdef _POSIX_VERSION
    DISPLAYLEVEL(4, "_POSIX_VERSION defined: %ldL\n", (long) _POSIX_VERSION);
#endif
#ifdef PLATFORM_POSIX_VERSION
    DISPLAYLEVEL(4, "PLATFORM_POSIX_VERSION defined: %ldL\n", (long) PLATFORM_POSIX_VERSION);
#endif
#ifdef _FILE_OFFSET_BITS
    DISPLAYLEVEL(4, "_FILE_OFFSET_BITS defined: %ldL\n", (long) _FILE_OFFSET_BITS);
#endif
    if ((mode == om_compress) || (mode == om_bench))
        DISPLAYLEVEL(4, "Blocks size : %u KB\n", (U32)(blockSize>>10));
 
    if (multiple_inputs) {
        input_filename = inFileNames[0];
#ifdef UTIL_HAS_CREATEFILELIST
        if (recursive) {  /* at this stage, filenameTable is a list of paths, which can contain both files and directories */
            extendedFileList = UTIL_createFileList(inFileNames, ifnIdx, &fileNamesBuf, &fileNamesNb);
            if (extendedFileList) {
                unsigned u;
                for (u=0; u<fileNamesNb; u++) DISPLAYLEVEL(4, "%u %s\n", u, extendedFileList[u]);
                free((void*)inFileNames);
                inFileNames = extendedFileList;
                ifnIdx = fileNamesNb;
        }   }
#endif
    }
 
    if (dictionary_filename) {
        if (!strcmp(dictionary_filename, stdinmark) && IS_CONSOLE(stdin)) {
            DISPLAYLEVEL(1, "refusing to read from a console\n");
            exit(1);
        }
        LZ4IO_setDictionaryFilename(prefs, dictionary_filename);
    }
 
    /* benchmark and test modes */
    if (mode == om_bench) {
        BMK_setNotificationLevel(displayLevel);
        operationResult = BMK_benchFiles(inFileNames, ifnIdx, cLevel, cLevelLast, dictionary_filename);
        goto _cleanup;
    }
 
    if (mode == om_test) {
        LZ4IO_setTestMode(prefs, 1);
        output_filename = nulmark;
        mode = om_decompress;   /* defer to decompress */
    }
 
    /* compress or decompress */
    if (!input_filename) input_filename = stdinmark;
    /* Check if input is defined as console; trigger an error in this case */
    if (!strcmp(input_filename, stdinmark) && IS_CONSOLE(stdin) ) {
        DISPLAYLEVEL(1, "refusing to read from a console\n");
        exit(1);
    }
    if (!strcmp(input_filename, stdinmark)) {
        /* if input==stdin and no output defined, stdout becomes default output */
        if (!output_filename) output_filename = stdoutmark;
    }
    else{
#ifdef UTIL_HAS_CREATEFILELIST
        if (!recursive && !UTIL_isRegFile(input_filename)) {
#else
        if (!UTIL_isRegFile(input_filename)) {
#endif
            DISPLAYLEVEL(1, "%s: is not a regular file \n", input_filename);
            exit(1);
        }
    }
 
    /* No output filename ==> try to select one automatically (when possible) */
    while ((!output_filename) && (multiple_inputs==0)) {
        if (!IS_CONSOLE(stdout) && mode != om_list) {
            /* Default to stdout whenever stdout is not the console.
             * Note : this policy may change in the future, therefore don't rely on it !
             * To ensure `stdout` is explicitly selected, use `-c` command flag.
             * Conversely, to ensure output will not become `stdout`, use `-m` command flag */
            DISPLAYLEVEL(1, "Warning : using stdout as default output. Do not rely on this behavior: use explicit `-c` instead ! \n");
            output_filename=stdoutmark;
            break;
        }
        if (mode == om_auto) {  /* auto-determine compression or decompression, based on file extension */
            mode = determineOpMode(input_filename);
        }
        if (mode == om_compress) {   /* compression to file */
            size_t const l = strlen(input_filename);
            dynNameSpace = (char*)calloc(1,l+5);
            if (dynNameSpace==NULL) { perror(exeName); exit(1); }
            strcpy(dynNameSpace, input_filename);
            strcat(dynNameSpace, LZ4_EXTENSION);
            output_filename = dynNameSpace;
            DISPLAYLEVEL(2, "Compressed filename will be : %s \n", output_filename);
            break;
        }
        if (mode == om_decompress) {/* decompression to file (automatic name will work only if input filename has correct format extension) */
            size_t outl;
            size_t const inl = strlen(input_filename);
            dynNameSpace = (char*)calloc(1,inl+1);
            if (dynNameSpace==NULL) { perror(exeName); exit(1); }
            strcpy(dynNameSpace, input_filename);
            outl = inl;
            if (inl>4)
                while ((outl >= inl-4) && (input_filename[outl] ==  extension[outl-inl+4])) dynNameSpace[outl--]=0;
            if (outl != inl-5) { DISPLAYLEVEL(1, "Cannot determine an output filename\n"); badusage(exeName); }
            output_filename = dynNameSpace;
            DISPLAYLEVEL(2, "Decoding file %s \n", output_filename);
        }
        break;
    }
 
    if (mode == om_list){
        /* Exit if trying to read from stdin as this isn't supported in this mode */
        if(!strcmp(input_filename, stdinmark)){
            DISPLAYLEVEL(1, "refusing to read from standard input in --list mode\n");
            exit(1);
        }
        if(!multiple_inputs){
            inFileNames[ifnIdx++] = input_filename;
        }
    }
    else{
        if (multiple_inputs==0) assert(output_filename);
    }
    /* when multiple_inputs==1, output_filename may simply be useless,
     * however, output_filename must be !NULL for next strcmp() tests */
    if (!output_filename) output_filename = "*\\dummy^!//";
 
    /* Check if output is defined as console; trigger an error in this case */
    if (!strcmp(output_filename,stdoutmark) && IS_CONSOLE(stdout) && !forceStdout) {
        DISPLAYLEVEL(1, "refusing to write to console without -c \n");
        exit(1);
    }
    /* Downgrade notification level in stdout and multiple file mode */
    if (!strcmp(output_filename,stdoutmark) && (displayLevel==2)) displayLevel=1;
    if ((multiple_inputs) && (displayLevel==2)) displayLevel=1;
 
    /* Auto-determine compression or decompression, based on file extension */
    if (mode == om_auto) {
        mode = determineOpMode(input_filename);
    }
 
    /* IO Stream/File */
    LZ4IO_setNotificationLevel((int)displayLevel);
    if (ifnIdx == 0) multiple_inputs = 0;
    if (mode == om_decompress) {
        if (multiple_inputs) {
            const char* const dec_extension = !strcmp(output_filename,stdoutmark) ? stdoutmark : LZ4_EXTENSION;
            assert(ifnIdx <= INT_MAX);
            operationResult = LZ4IO_decompressMultipleFilenames(inFileNames, (int)ifnIdx, dec_extension, prefs);
        } else {
            operationResult = DEFAULT_DECOMPRESSOR(input_filename, output_filename, prefs);
        }
    } else if (mode == om_list){
        operationResult = LZ4IO_displayCompressedFilesInfo(inFileNames, ifnIdx);
    } else {   /* compression is default action */
        if (legacy_format) {
            DISPLAYLEVEL(3, "! Generating LZ4 Legacy format (deprecated) ! \n");
            if(multiple_inputs){
                const char* const leg_extension = !strcmp(output_filename,stdoutmark) ? stdoutmark : LZ4_EXTENSION;
                LZ4IO_compressMultipleFilenames_Legacy(inFileNames, (int)ifnIdx, leg_extension, cLevel, prefs);
            } else {
                LZ4IO_compressFilename_Legacy(input_filename, output_filename, cLevel, prefs);
            }
        } else {
            if (multiple_inputs) {
                const char* const comp_extension = !strcmp(output_filename,stdoutmark) ? stdoutmark : LZ4_EXTENSION;
                assert(ifnIdx <= INT_MAX);
                operationResult = LZ4IO_compressMultipleFilenames(inFileNames, (int)ifnIdx, comp_extension, cLevel, prefs);
            } else {
                operationResult = DEFAULT_COMPRESSOR(input_filename, output_filename, cLevel, prefs);
    }   }   }
 
_cleanup:
    if (main_pause) waitEnter();
    free(dynNameSpace);
#ifdef UTIL_HAS_CREATEFILELIST
    if (extendedFileList) {
        UTIL_freeFileList(extendedFileList, fileNamesBuf);
        inFileNames = NULL;
    }
#endif
    LZ4IO_freePreferences(prefs);
    free((void*)inFileNames);
    return operationResult;
}

References _FILE_OFFSET_BITS, _POSIX_C_SOURCE, argv, assert(), B, badusage(), BMK_benchFiles(), BMK_setBenchSeparately(), BMK_setBlockSize(), BMK_setNbSeconds(), BMK_setNotificationLevel(), calloc(), test-lz4-speed::default, DEFAULT_COMPRESSOR, DEFAULT_DECOMPRESSOR, determineOpMode(), DISPLAY, DISPLAYLEVEL, displayLevel, DISPLAYOUT, exeNameMatch(), test-lz4-list::exit, free(), g_lz4c_legacy_commands, i, int, INT_MAX, IS_CONSOLE, lastNameFromPath(), longCommandWArg(), LZ4_BLOCKSIZEID_DEFAULT, LZ4_EXTENSION, LZ4_LEGACY, LZ4CAT, LZ4HC_CLEVEL_MAX, LZ4IO_blockIndependent, LZ4IO_blockLinked, LZ4IO_compressFilename_Legacy(), LZ4IO_compressMultipleFilenames(), LZ4IO_compressMultipleFilenames_Legacy(), LZ4IO_decompressMultipleFilenames(), LZ4IO_defaultPreferences(), LZ4IO_displayCompressedFilesInfo(), LZ4IO_favorDecSpeed(), LZ4IO_freePreferences(), LZ4IO_setBlockChecksumMode(), LZ4IO_setBlockMode(), LZ4IO_setBlockSize(), LZ4IO_setBlockSizeID(), LZ4IO_setContentSize(), LZ4IO_setDictionaryFilename(), LZ4IO_setNotificationLevel(), LZ4IO_setOverwrite(), LZ4IO_setPassThrough(), LZ4IO_setRemoveSrcFile(), LZ4IO_setSparseFile(), LZ4IO_setStreamChecksumMode(), LZ4IO_setTestMode(), MB, NULL, NULL_OUTPUT, nulmark, om_auto, om_bench, om_compress, om_decompress, om_list, om_test, PLATFORM_POSIX_VERSION, readU32FromChar(), stdinmark, stdoutmark, UNLZ4, usage_advanced(), usage_longhelp(), UTIL_createFileList(), UTIL_freeFileList(), UTIL_isRegFile(), waitEnter(), and WELCOME_MESSAGE.

readU32FromChar()

static unsigned readU32FromChar ( const char **  stringPtr )

static

readU32FromChar() :

Returns

: unsigned integer value read from input in char format allows and interprets K, KB, KiB, M, MB and MiB suffix. Will also modify *stringPtr, advancing it to position where it stopped reading. Note : function result can overflow if digit string > MAX_UINT

Definition at line 264 of file lz4cli.c.

{
    unsigned result = 0;
    while ((**stringPtr >='0') && (**stringPtr <='9')) {
        result *= 10;
        result += (unsigned)(**stringPtr - '0');
        (*stringPtr)++ ;
    }
    if ((**stringPtr=='K') || (**stringPtr=='M')) {
        result <<= 10;
        if (**stringPtr=='M') result <<= 10;
        (*stringPtr)++ ;
        if (**stringPtr=='i') (*stringPtr)++;
        if (**stringPtr=='B') (*stringPtr)++;
    }
    return result;
}

References unsigned.

Referenced by main().

usage()

static int usage ( const char *  exeName )

static

Definition at line 105 of file lz4cli.c.

{
    DISPLAY( "Usage : \n");
    DISPLAY( "      %s [arg] [input] [output] \n", exeName);
    DISPLAY( "\n");
    DISPLAY( "input   : a filename \n");
    DISPLAY( "          with no FILE, or when FILE is - or %s, read standard input\n", stdinmark);
    DISPLAY( "Arguments : \n");
    DISPLAY( " -1     : Fast compression (default) \n");
    DISPLAY( " -9     : High compression \n");
    DISPLAY( " -d     : decompression (default for %s extension)\n", LZ4_EXTENSION);
    DISPLAY( " -z     : force compression \n");
    DISPLAY( " -D FILE: use FILE as dictionary \n");
    DISPLAY( " -f     : overwrite output without prompting \n");
    DISPLAY( " -k     : preserve source files(s)  (default) \n");
    DISPLAY( "--rm    : remove source file(s) after successful de/compression \n");
    DISPLAY( " -h/-H  : display help/long help and exit \n");
    return 0;
}

References DISPLAY, LZ4_EXTENSION, and stdinmark.

Referenced by badusage(), and usage_advanced().

usage_advanced()

static int usage_advanced ( const char *  exeName )

static

Definition at line 125 of file lz4cli.c.

{
    DISPLAY(WELCOME_MESSAGE);
    usage(exeName);
    DISPLAY( "\n");
    DISPLAY( "Advanced arguments :\n");
    DISPLAY( " -V     : display Version number and exit \n");
    DISPLAY( " -v     : verbose mode \n");
    DISPLAY( " -q     : suppress warnings; specify twice to suppress errors too\n");
    DISPLAY( " -c     : force write to standard output, even if it is the console\n");
    DISPLAY( " -t     : test compressed file integrity\n");
    DISPLAY( " -m     : multiple input files (implies automatic output filenames)\n");
#ifdef UTIL_HAS_CREATEFILELIST
    DISPLAY( " -r     : operate recursively on directories (sets also -m) \n");
#endif
    DISPLAY( " -l     : compress using Legacy format (Linux kernel compression)\n");
    DISPLAY( " -B#    : cut file into blocks of size # bytes [32+] \n");
    DISPLAY( "                     or predefined block size [4-7] (default: 7) \n");
    DISPLAY( " -BI    : Block Independence (default) \n");
    DISPLAY( " -BD    : Block dependency (improves compression ratio) \n");
    DISPLAY( " -BX    : enable block checksum (default:disabled) \n");
    DISPLAY( "--no-frame-crc : disable stream checksum (default:enabled) \n");
    DISPLAY( "--content-size : compressed frame includes original size (default:not present)\n");
    DISPLAY( "--list FILE : lists information about .lz4 files (useful for files compressed with --content-size flag)\n");
    DISPLAY( "--[no-]sparse  : sparse mode (default:enabled on file, disabled on stdout)\n");
    DISPLAY( "--favor-decSpeed: compressed files decompress faster, but are less compressed \n");
    DISPLAY( "--fast[=#]: switch to ultra fast compression level (default: %i)\n", 1);
    DISPLAY( "--best  : same as -%d\n", LZ4HC_CLEVEL_MAX);
    DISPLAY( "Benchmark arguments : \n");
    DISPLAY( " -b#    : benchmark file(s), using # compression level (default : 1) \n");
    DISPLAY( " -e#    : test all compression levels from -bX to # (default : 1)\n");
    DISPLAY( " -i#    : minimum evaluation time in seconds (default : 3s) \n");
    if (g_lz4c_legacy_commands) {
        DISPLAY( "Legacy arguments : \n");
        DISPLAY( " -c0    : fast compression \n");
        DISPLAY( " -c1    : high compression \n");
        DISPLAY( " -c2,-hc: very high compression \n");
        DISPLAY( " -y     : overwrite output without prompting \n");
    }
    return 0;
}

References DISPLAY, g_lz4c_legacy_commands, LZ4HC_CLEVEL_MAX, usage(), and WELCOME_MESSAGE.

Referenced by main(), and usage_longhelp().

usage_longhelp()

static int usage_longhelp ( const char *  exeName )

static

Definition at line 167 of file lz4cli.c.

{
    usage_advanced(exeName);
    DISPLAY( "\n");
    DISPLAY( "****************************\n");
    DISPLAY( "***** Advanced comment *****\n");
    DISPLAY( "****************************\n");
    DISPLAY( "\n");
    DISPLAY( "Which values can [output] have ? \n");
    DISPLAY( "---------------------------------\n");
    DISPLAY( "[output] : a filename \n");
    DISPLAY( "          '%s', or '-' for standard output (pipe mode)\n", stdoutmark);
    DISPLAY( "          '%s' to discard output (test mode) \n", NULL_OUTPUT);
    DISPLAY( "[output] can be left empty. In this case, it receives the following value :\n");
    DISPLAY( "          - if stdout is not the console, then [output] = stdout \n");
    DISPLAY( "          - if stdout is console : \n");
    DISPLAY( "               + for compression, output to filename%s \n", LZ4_EXTENSION);
    DISPLAY( "               + for decompression, output to filename without '%s'\n", LZ4_EXTENSION);
    DISPLAY( "                    > if input filename has no '%s' extension : error \n", LZ4_EXTENSION);
    DISPLAY( "\n");
    DISPLAY( "Compression levels : \n");
    DISPLAY( "---------------------\n");
    DISPLAY( "-0 ... -2  => Fast compression, all identicals\n");
    DISPLAY( "-3 ... -%d => High compression; higher number == more compression but slower\n", LZ4HC_CLEVEL_MAX);
    DISPLAY( "\n");
    DISPLAY( "stdin, stdout and the console : \n");
    DISPLAY( "--------------------------------\n");
    DISPLAY( "To protect the console from binary flooding (bad argument mistake)\n");
    DISPLAY( "%s will refuse to read from console, or write to console \n", exeName);
    DISPLAY( "except if '-c' command is specified, to force output to console \n");
    DISPLAY( "\n");
    DISPLAY( "Simple example :\n");
    DISPLAY( "----------------\n");
    DISPLAY( "1 : compress 'filename' fast, using default output name 'filename.lz4'\n");
    DISPLAY( "          %s filename\n", exeName);
    DISPLAY( "\n");
    DISPLAY( "Short arguments can be aggregated. For example :\n");
    DISPLAY( "----------------------------------\n");
    DISPLAY( "2 : compress 'filename' in high compression mode, overwrite output if exists\n");
    DISPLAY( "          %s -9 -f filename \n", exeName);
    DISPLAY( "    is equivalent to :\n");
    DISPLAY( "          %s -9f filename \n", exeName);
    DISPLAY( "\n");
    DISPLAY( "%s can be used in 'pure pipe mode'. For example :\n", exeName);
    DISPLAY( "-------------------------------------\n");
    DISPLAY( "3 : compress data stream from 'generator', send result to 'consumer'\n");
    DISPLAY( "          generator | %s | consumer \n", exeName);
    if (g_lz4c_legacy_commands) {
        DISPLAY( "\n");
        DISPLAY( "***** Warning  ***** \n");
        DISPLAY( "Legacy arguments take precedence. Therefore : \n");
        DISPLAY( "--------------------------------- \n");
        DISPLAY( "          %s -hc filename \n", exeName);
        DISPLAY( "means 'compress filename in high compression mode' \n");
        DISPLAY( "It is not equivalent to : \n");
        DISPLAY( "          %s -h -c filename \n", exeName);
        DISPLAY( "which displays help text and exits \n");
    }
    return 0;
}

References DISPLAY, g_lz4c_legacy_commands, LZ4_EXTENSION, LZ4HC_CLEVEL_MAX, NULL_OUTPUT, stdoutmark, and usage_advanced().

Referenced by main().

waitEnter()

static void waitEnter ( void  )

static

Definition at line 236 of file lz4cli.c.

{
    DISPLAY("Press enter to continue...\n");
    (void)getchar();
}

References DISPLAY.

Referenced by main().

Variable Documentation

displayLevel

unsigned displayLevel = 2

static

Definition at line 73 of file lz4cli.c.

Referenced by badusage(), and main().

g_lz4c_legacy_commands

int g_lz4c_legacy_commands = 0

static

Definition at line 58 of file lz4cli.c.

Referenced by main(), usage_advanced(), and usage_longhelp().