options.c File Reference

Parser for filter-specific options. More...

#include "private.h"

Go to the source code of this file.

Classes
struct	name_id_map
struct	option_map

Enumerations
enum	{ OPT_DIST }
enum	{ OPT_START_OFFSET }
enum	{   OPT_PRESET , OPT_DICT , OPT_LC , OPT_LP ,   OPT_PB , OPT_MODE , OPT_NICE , OPT_MF ,   OPT_DEPTH }

Functions
static void	parse_options (const char *str, const option_map *opts, void(*set)(void *filter_options, unsigned key, uint64_t value, const char *valuestr), void *filter_options)
static void	set_delta (void *options, unsigned key, uint64_t value, const char *valuestr lzma_attribute((__unused__)))
lzma_options_delta *	options_delta (const char *str)
	Parser for Delta options. More...
static void	set_bcj (void *options, unsigned key, uint64_t value, const char *valuestr lzma_attribute((__unused__)))
lzma_options_bcj *	options_bcj (const char *str)
	Parser for BCJ options. More...
static void	lzma_attribute ((__noreturn__))
static void	set_lzma (void *options, unsigned key, uint64_t value, const char *valuestr)
lzma_options_lzma *	options_lzma (const char *str)
	Parser for LZMA options. More...

Detailed Description

Parser for filter-specific options.

Definition in file options.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
OPT_DIST

Definition at line 146 of file options.c.

     {
    OPT_DIST,
};

anonymous enum

anonymous enum

Enumerator
OPT_START_OFFSET

Definition at line 190 of file options.c.

     {
    OPT_START_OFFSET,
};

anonymous enum

anonymous enum

Enumerator
OPT_PRESET
OPT_DICT
OPT_LC
OPT_LP
OPT_PB
OPT_MODE
OPT_NICE
OPT_MF
OPT_DEPTH

Definition at line 231 of file options.c.

     {
    OPT_PRESET,
    OPT_DICT,
    OPT_LC,
    OPT_LP,
    OPT_PB,
    OPT_MODE,
    OPT_NICE,
    OPT_MF,
    OPT_DEPTH,
};

Function Documentation

lzma_attribute()

static void lzma_attribute ( (__noreturn__)  )

static

Definition at line 244 of file options.c.

{
    message_fatal(_("Unsupported LZMA1/LZMA2 preset: %s"), valuestr);
}

References _, and message_fatal().

options_bcj()

lzma_options_bcj* options_bcj

(

const char *

str

)

Parser for BCJ options.

Returns

Pointer to allocated options structure. Doesn't return on error.

Definition at line 209 of file options.c.

{
    static const option_map opts[] = {
        { "start",    NULL,  0, UINT32_MAX },
        { NULL,       NULL,  0, 0 }
    };
 
    lzma_options_bcj *options = xmalloc(sizeof(lzma_options_bcj));
    *options = (lzma_options_bcj){
        .start_offset = 0,
    };
 
    parse_options(str, opts, &set_bcj, options);
 
    return options;
}

References NULL, options, parse_options(), set_bcj(), cmd_descs_generate::str, UINT32_MAX, and xmalloc.

Referenced by parse_real().

options_delta()

lzma_options_delta* options_delta

(

const char *

str

)

Parser for Delta options.

Returns

Pointer to allocated options structure. Doesn't return on error.

Definition at line 165 of file options.c.

{
    static const option_map opts[] = {
        { "dist",     NULL,  LZMA_DELTA_DIST_MIN,
                             LZMA_DELTA_DIST_MAX },
        { NULL,       NULL,  0, 0 }
    };
 
    lzma_options_delta *options = xmalloc(sizeof(lzma_options_delta));
    *options = (lzma_options_delta){
        // It's hard to give a useful default for this.
        .type = LZMA_DELTA_TYPE_BYTE,
        .dist = LZMA_DELTA_DIST_MIN,
    };
 
    parse_options(str, opts, &set_delta, options);
 
    return options;
}

References LZMA_DELTA_DIST_MAX, LZMA_DELTA_DIST_MIN, LZMA_DELTA_TYPE_BYTE, NULL, options, parse_options(), set_delta(), cmd_descs_generate::str, and xmalloc.

Referenced by parse_real().

options_lzma()

lzma_options_lzma* options_lzma

(

const char *

str

)

Parser for LZMA options.

Returns

Pointer to allocated options structure. Doesn't return on error.

Definition at line 317 of file options.c.

{
    static const name_id_map modes[] = {
        { "fast",   LZMA_MODE_FAST },
        { "normal", LZMA_MODE_NORMAL },
        { NULL,     0 }
    };
 
    static const name_id_map mfs[] = {
        { "hc3", LZMA_MF_HC3 },
        { "hc4", LZMA_MF_HC4 },
        { "bt2", LZMA_MF_BT2 },
        { "bt3", LZMA_MF_BT3 },
        { "bt4", LZMA_MF_BT4 },
        { NULL,  0 }
    };
 
    static const option_map opts[] = {
        { "preset", NULL,   UINT64_MAX, 0 },
        { "dict",   NULL,   LZMA_DICT_SIZE_MIN,
                (UINT32_C(1) << 30) + (UINT32_C(1) << 29) },
        { "lc",     NULL,   LZMA_LCLP_MIN, LZMA_LCLP_MAX },
        { "lp",     NULL,   LZMA_LCLP_MIN, LZMA_LCLP_MAX },
        { "pb",     NULL,   LZMA_PB_MIN, LZMA_PB_MAX },
        { "mode",   modes,  0, 0 },
        { "nice",   NULL,   2, 273 },
        { "mf",     mfs,    0, 0 },
        { "depth",  NULL,   0, UINT32_MAX },
        { NULL,     NULL,   0, 0 }
    };
 
    lzma_options_lzma *options = xmalloc(sizeof(lzma_options_lzma));
    if (lzma_lzma_preset(options, LZMA_PRESET_DEFAULT))
        message_bug();
 
    parse_options(str, opts, &set_lzma, options);
 
    if (options->lc + options->lp > LZMA_LCLP_MAX)
        message_fatal(_("The sum of lc and lp must not exceed 4"));
 
    const uint32_t nice_len_min = options->mf & 0x0F;
    if (options->nice_len < nice_len_min)
        message_fatal(_("The selected match finder requires at "
                "least nice=%" PRIu32), nice_len_min);
 
    return options;
}

References _, LZMA_DICT_SIZE_MIN, LZMA_LCLP_MAX, LZMA_LCLP_MIN, LZMA_MF_BT2, LZMA_MF_BT3, LZMA_MF_BT4, LZMA_MF_HC3, LZMA_MF_HC4, LZMA_MODE_FAST, LZMA_MODE_NORMAL, LZMA_PB_MAX, LZMA_PB_MIN, LZMA_PRESET_DEFAULT, message_bug(), message_fatal(), NULL, options, parse_options(), PRIu32, set_lzma(), cmd_descs_generate::str, UINT32_C, UINT32_MAX, UINT64_MAX, and xmalloc.

Referenced by parse_real().

parse_options()

static void parse_options ( const char *  str, const option_map *  opts, void(*)(void *filter_options, unsigned key, uint64_t value, const char *valuestr)  set, void *  filter_options  )

static

Parses option=value pairs that are separated with commas: opt=val,opt=val,opt=val

Each option is a string, that is converted to an integer using the index where the option string is in the array.

Value can be

• a string-id map mapping a list of possible string values to integers (opts[i].map != NULL, opts[i].min and opts[i].max are ignored);
• a number with minimum and maximum value limit (opts[i].map == NULL && opts[i].min != UINT64_MAX);
• a string that will be parsed by the filter-specific code (opts[i].map == NULL && opts[i].min == UINT64_MAX, opts[i].max ignored)

When parsing both option and value succeed, a filter-specific function is called, which should update the given value to filter-specific options structure.

Parameters

str	String containing the options from the command line
opts	Filter-specific option map
set	Filter-specific function to update filter_options
filter_options	Pointer to filter-specific options structure

Returns

Returns only if no errors occur.

Definition at line 60 of file options.c.

{
    if (str == NULL || str[0] == '\0')
        return;
 
    char *s = xstrdup(str);
    char *name = s;
 
    while (*name != '\0') {
        if (*name == ',') {
            ++name;
            continue;
        }
 
        char *split = strchr(name, ',');
        if (split != NULL)
            *split = '\0';
 
        char *value = strchr(name, '=');
        if (value != NULL)
            *value++ = '\0';
 
        if (value == NULL || value[0] == '\0')
            message_fatal(_("%s: Options must be `name=value' "
                    "pairs separated with commas"), str);
 
        // Look for the option name from the option map.
        unsigned i = 0;
        while (true) {
            if (opts[i].name == NULL)
                message_fatal(_("%s: Invalid option name"),
                        name);
 
            if (strcmp(name, opts[i].name) == 0)
                break;
 
            ++i;
        }
 
        // Option was found from the map. See how we should handle it.
        if (opts[i].map != NULL) {
            // value is a string which we should map
            // to an integer.
            unsigned j;
            for (j = 0; opts[i].map[j].name != NULL; ++j) {
                if (strcmp(opts[i].map[j].name, value) == 0)
                    break;
            }
 
            if (opts[i].map[j].name == NULL)
                message_fatal(_("%s: Invalid option value"),
                        value);
 
            set(filter_options, i, opts[i].map[j].id, value);
 
        } else if (opts[i].min == UINT64_MAX) {
            // value is a special string that will be
            // parsed by set().
            set(filter_options, i, 0, value);
 
        } else {
            // value is an integer.
            const uint64_t v = str_to_uint64(name, value,
                    opts[i].min, opts[i].max);
            set(filter_options, i, v, value);
        }
 
        // Check if it was the last option.
        if (split == NULL)
            break;
 
        name = split + 1;
    }
 
    free(s);
    return;
}

References _, free(), i, option_map::map, map(), max, message_fatal(), min, name, name_id_map::name, NULL, s, cmd_descs_generate::str, str_to_uint64(), UINT64_MAX, v, value, and xstrdup().

Referenced by options_bcj(), options_delta(), and options_lzma().

set_bcj()

static void set_bcj ( void *  options, unsigned  key, uint64_t  value, const char *valuestr   lzma_attribute(__unused__)  )

static

Definition at line 196 of file options.c.

{
    lzma_options_bcj *opt = options;
    switch (key) {
    case OPT_START_OFFSET:
        opt->start_offset = value;
        break;
    }
}

References key, OPT_START_OFFSET, options, lzma_options_bcj::start_offset, and value.

Referenced by options_bcj().

set_delta()

static void set_delta ( void *  options, unsigned  key, uint64_t  value, const char *valuestr   lzma_attribute(__unused__)  )

static

Definition at line 152 of file options.c.

{
    lzma_options_delta *opt = options;
    switch (key) {
    case OPT_DIST:
        opt->dist = value;
        break;
    }
}

References lzma_options_delta::dist, key, OPT_DIST, options, and value.

Referenced by options_delta().

set_lzma()

static void set_lzma ( void *  options, unsigned  key, uint64_t  value, const char *  valuestr  )

static

Definition at line 252 of file options.c.

{
    lzma_options_lzma *opt = options;
 
    switch (key) {
    case OPT_PRESET: {
        if (valuestr[0] < '0' || valuestr[0] > '9')
            error_lzma_preset(valuestr);
 
        uint32_t preset = (uint32_t)(valuestr[0] - '0');
 
        // Currently only "e" is supported as a modifier,
        // so keep this simple for now.
        if (valuestr[1] != '\0') {
            if (valuestr[1] == 'e')
                preset |= LZMA_PRESET_EXTREME;
            else
                error_lzma_preset(valuestr);
 
            if (valuestr[2] != '\0')
                error_lzma_preset(valuestr);
        }
 
        if (lzma_lzma_preset(options, preset))
            error_lzma_preset(valuestr);
 
        break;
    }
 
    case OPT_DICT:
        opt->dict_size = value;
        break;
 
    case OPT_LC:
        opt->lc = value;
        break;
 
    case OPT_LP:
        opt->lp = value;
        break;
 
    case OPT_PB:
        opt->pb = value;
        break;
 
    case OPT_MODE:
        opt->mode = value;
        break;
 
    case OPT_NICE:
        opt->nice_len = value;
        break;
 
    case OPT_MF:
        opt->mf = value;
        break;
 
    case OPT_DEPTH:
        opt->depth = value;
        break;
    }
}

References lzma_options_lzma::depth, lzma_options_lzma::dict_size, key, lzma_options_lzma::lc, lzma_options_lzma::lp, LZMA_PRESET_EXTREME, lzma_options_lzma::mf, lzma_options_lzma::mode, lzma_options_lzma::nice_len, OPT_DEPTH, OPT_DICT, OPT_LC, OPT_LP, OPT_MF, OPT_MODE, OPT_NICE, OPT_PB, OPT_PRESET, options, lzma_options_lzma::pb, preset, and value.

Referenced by options_lzma().