src/lzma/options.c - jrn/xz - Git at Google

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       options.c
 /// \brief      Parser for filter-specific options
 //
 //  Copyright (C) 2007 Lasse Collin
 //
 //  This program is free software; you can redistribute it and/or
 //  modify it under the terms of the GNU Lesser General Public
 //  License as published by the Free Software Foundation; either
 //  version 2.1 of the License, or (at your option) any later version.
 //
 //  This program is distributed in the hope that it will be useful,
 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 //  Lesser General Public License for more details.
 //
 ///////////////////////////////////////////////////////////////////////////////

 #include "private.h"


 ///////////////////
 // Generic stuff //
 ///////////////////

 typedef struct {
 	const char *name;
 	uint64_t id;
 } name_id_map;


 typedef struct {
 	const char *name;
 	const name_id_map *map;
 	uint64_t min;
 	uint64_t max;
 } option_map;


 /// Parses option=value pairs that are separated with colons, semicolons,
 /// or commas: opt=val: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 either a number with minimum and maximum value limit, or
 /// a string-id map mapping a list of possible string values to integers.
 ///
 /// When parsing both option and value succeed, a filter-specific function
 /// is called, which should update the given value to filter-specific
 /// options structure.
 ///
 /// \param      str     String containing the options from the command line
 /// \param      opts    Filter-specific option map
 /// \param      set     Filter-specific function to update filter_options
 /// \param      filter_options  Pointer to filter-specific options structure
 ///
 /// \return     Returns only if no errors occur.
 ///
 static void
 parse_options(const char *str, const option_map *opts,
 		void (*set)(void *filter_options,
 			uint32_t key, uint64_t value),
 		void *filter_options)
 {
 	if (str == NULL || str[0] == '\0')
 		return;

 	char *s = xstrdup(str);
 	char *name = s;

 	while (true) {
 		char *split = strchr(name, ',');
 		if (split != NULL)
 			*split = '\0';

 		char *value = strchr(name, '=');
 		if (value != NULL)
 			*value++ = '\0';

 		if (value == NULL || value[0] == '\0') {
 			errmsg(V_ERROR, _("%s: Options must be `name=value' "
 					"pairs separated with commas"),
 					str);
 			my_exit(ERROR);
 		}

 		// Look for the option name from the option map.
 		bool found = false;
 		for (size_t i = 0; opts[i].name != NULL; ++i) {
 			if (strcmp(name, opts[i].name) != 0)
 				continue;

 			if (opts[i].map == NULL) {
 				// value is an integer.
 				const uint64_t v = str_to_uint64(name, value,
 						opts[i].min, opts[i].max);
 				set(filter_options, i, v);
 			} else {
 				// value is a string which we should map
 				// to an integer.
 				size_t 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) {
 					errmsg(V_ERROR, _("%s: Invalid option "
 							"value"), value);
 					my_exit(ERROR);
 				}

 				set(filter_options, i, j);
 			}

 			found = true;
 			break;
 		}

 		if (!found) {
 			errmsg(V_ERROR, _("%s: Invalid option name"), name);
 			my_exit(ERROR);
 		}

 		if (split == NULL)
 			break;

 		name = split + 1;
 	}

 	free(s);
 	return;
 }


 //////////////
 // Subblock //
 //////////////

 enum {
 	OPT_SIZE,
 	OPT_RLE,
 	OPT_ALIGN,
 };


 static void
 set_subblock(void *options, uint32_t key, uint64_t value)
 {
 	lzma_options_subblock *opt = options;

 	switch (key) {
 	case OPT_SIZE:
 		opt->subblock_data_size = value;
 		break;

 	case OPT_RLE:
 		opt->rle = value;
 		break;

 	case OPT_ALIGN:
 		opt->alignment = value;
 		break;
 	}
 }


 extern lzma_options_subblock *
 parse_options_subblock(const char *str)
 {
 	static const option_map opts[] = {
 		{ "size", NULL,   LZMA_SUBBLOCK_DATA_SIZE_MIN,
 		                  LZMA_SUBBLOCK_DATA_SIZE_MAX },
 		{ "rle",  NULL,   LZMA_SUBBLOCK_RLE_OFF,
 		                  LZMA_SUBBLOCK_RLE_MAX },
 		{ "align",NULL,   LZMA_SUBBLOCK_ALIGNMENT_MIN,
 		                  LZMA_SUBBLOCK_ALIGNMENT_MAX },
 		{ NULL,   NULL,   0, 0 }
 	};

 	lzma_options_subblock *options
 			= xmalloc(sizeof(lzma_options_subblock));
 	*options = (lzma_options_subblock){
 		.allow_subfilters = false,
 		.alignment = LZMA_SUBBLOCK_ALIGNMENT_DEFAULT,
 		.subblock_data_size = LZMA_SUBBLOCK_DATA_SIZE_DEFAULT,
 		.rle = LZMA_SUBBLOCK_RLE_OFF,
 	};

 	parse_options(str, opts, &set_subblock, options);

 	return options;
 }


 ///////////
 // Delta //
 ///////////

 enum {
 	OPT_DISTANCE,
 };


 static void
 set_delta(void *options, uint32_t key, uint64_t value)
 {
 	lzma_options_delta *opt = options;
 	switch (key) {
 	case OPT_DISTANCE:
 		opt->distance = value;
 		break;
 	}
 }


 extern lzma_options_delta *
 parse_options_delta(const char *str)
 {
 	static const option_map opts[] = {
 		{ "distance", NULL,  LZMA_DELTA_DISTANCE_MIN,
 		                     LZMA_DELTA_DISTANCE_MAX },
 		{ NULL,       NULL,  0, 0 }
 	};

 	lzma_options_delta *options = xmalloc(sizeof(lzma_options_subblock));
 	*options = (lzma_options_delta){
 		// It's hard to give a useful default for this.
 		.distance = LZMA_DELTA_DISTANCE_MIN,
 	};

 	parse_options(str, opts, &set_delta, options);

 	return options;
 }


 //////////
 // LZMA //
 //////////

 enum {
 	OPT_DICT,
 	OPT_LC,
 	OPT_LP,
 	OPT_PB,
 	OPT_MODE,
 	OPT_FB,
 	OPT_MF,
 	OPT_MC
 };


 static void
 set_lzma(void *options, uint32_t key, uint64_t value)
 {
 	lzma_options_lzma *opt = options;

 	switch (key) {
 	case OPT_DICT:
 		opt->dictionary_size = value;
 		break;

 	case OPT_LC:
 		opt->literal_context_bits = value;
 		break;

 	case OPT_LP:
 		opt->literal_pos_bits = value;
 		break;

 	case OPT_PB:
 		opt->pos_bits = value;
 		break;

 	case OPT_MODE:
 		opt->mode = value;
 		break;

 	case OPT_FB:
 		opt->fast_bytes = value;
 		break;

 	case OPT_MF:
 		opt->match_finder = value;
 		break;

 	case OPT_MC:
 		opt->match_finder_cycles = value;
 		break;
 	}
 }


 extern lzma_options_lzma *
 parse_options_lzma(const char *str)
 {
 	static const name_id_map modes[] = {
 		{ "fast", LZMA_MODE_FAST },
 		{ "best", LZMA_MODE_BEST },
 		{ 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[] = {
 		{ "dict", NULL,   LZMA_DICTIONARY_SIZE_MIN,
 				LZMA_DICTIONARY_SIZE_MAX },
 		{ "lc",   NULL,   LZMA_LITERAL_CONTEXT_BITS_MIN,
 				  LZMA_LITERAL_CONTEXT_BITS_MAX },
 		{ "lp",   NULL,   LZMA_LITERAL_POS_BITS_MIN,
 				  LZMA_LITERAL_POS_BITS_MAX },
 		{ "pb",   NULL,   LZMA_POS_BITS_MIN, LZMA_POS_BITS_MAX },
 		{ "mode", modes,  0, 0 },
 		{ "fb",   NULL,   LZMA_FAST_BYTES_MIN, LZMA_FAST_BYTES_MAX },
 		{ "mf",   mfs,    0, 0 },
 		{ "mc",   NULL,   0, UINT32_MAX },
 		{ NULL,   NULL,   0, 0 }
 	};

 	lzma_options_lzma *options = xmalloc(sizeof(lzma_options_lzma));
 	*options = (lzma_options_lzma){
 		.dictionary_size = LZMA_DICTIONARY_SIZE_DEFAULT,
 		.literal_context_bits = LZMA_LITERAL_CONTEXT_BITS_DEFAULT,
 		.literal_pos_bits = LZMA_LITERAL_POS_BITS_DEFAULT,
 		.pos_bits = LZMA_POS_BITS_DEFAULT,
 		.mode = LZMA_MODE_BEST,
 		.fast_bytes = LZMA_FAST_BYTES_DEFAULT,
 		.match_finder = LZMA_MF_BT4,
 		.match_finder_cycles = 0,
 	};

 	parse_options(str, opts, &set_lzma, options);

 	return options;
 }
	///////////////////////////////////////////////////////////////////////////////
	//
	/// \file options.c
	/// \brief Parser for filter-specific options
	//
	// Copyright (C) 2007 Lasse Collin
	//
	// This program is free software; you can redistribute it and/or
	// modify it under the terms of the GNU Lesser General Public
	// License as published by the Free Software Foundation; either
	// version 2.1 of the License, or (at your option) any later version.
	//
	// This program is distributed in the hope that it will be useful,
	// but WITHOUT ANY WARRANTY; without even the implied warranty of
	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	// Lesser General Public License for more details.
	//
	///////////////////////////////////////////////////////////////////////////////

	#include "private.h"


	///////////////////
	// Generic stuff //
	///////////////////

	typedef struct {
	const char *name;
	uint64_t id;
	} name_id_map;


	typedef struct {
	const char *name;
	const name_id_map *map;
	uint64_t min;
	uint64_t max;
	} option_map;


	/// Parses option=value pairs that are separated with colons, semicolons,
	/// or commas: opt=val: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 either a number with minimum and maximum value limit, or
	/// a string-id map mapping a list of possible string values to integers.
	///
	/// When parsing both option and value succeed, a filter-specific function
	/// is called, which should update the given value to filter-specific
	/// options structure.
	///
	/// \param str String containing the options from the command line
	/// \param opts Filter-specific option map
	/// \param set Filter-specific function to update filter_options
	/// \param filter_options Pointer to filter-specific options structure
	///
	/// \return Returns only if no errors occur.
	///
	static void
	parse_options(const char str, const option_map opts,
	void (set)(void filter_options,
	uint32_t key, uint64_t value),
	void *filter_options)
	{
	if (str == NULL \|\| str[0] == '\0')
	return;

	char *s = xstrdup(str);
	char *name = s;

	while (true) {
	char *split = strchr(name, ',');
	if (split != NULL)
	*split = '\0';

	char *value = strchr(name, '=');
	if (value != NULL)
	*value++ = '\0';

	if (value == NULL \|\| value[0] == '\0') {
	errmsg(V_ERROR, _("%s: Options must be `name=value' "
	"pairs separated with commas"),
	str);
	my_exit(ERROR);
	}

	// Look for the option name from the option map.
	bool found = false;
	for (size_t i = 0; opts[i].name != NULL; ++i) {
	if (strcmp(name, opts[i].name) != 0)
	continue;

	if (opts[i].map == NULL) {
	// value is an integer.
	const uint64_t v = str_to_uint64(name, value,
	opts[i].min, opts[i].max);
	set(filter_options, i, v);
	} else {
	// value is a string which we should map
	// to an integer.
	size_t 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) {
	errmsg(V_ERROR, _("%s: Invalid option "
	"value"), value);
	my_exit(ERROR);
	}

	set(filter_options, i, j);
	}

	found = true;
	break;
	}

	if (!found) {
	errmsg(V_ERROR, _("%s: Invalid option name"), name);
	my_exit(ERROR);
	}

	if (split == NULL)
	break;

	name = split + 1;
	}

	free(s);
	return;
	}


	//////////////
	// Subblock //
	//////////////

	enum {
	OPT_SIZE,
	OPT_RLE,
	OPT_ALIGN,
	};


	static void
	set_subblock(void *options, uint32_t key, uint64_t value)
	{
	lzma_options_subblock *opt = options;

	switch (key) {
	case OPT_SIZE:
	opt->subblock_data_size = value;
	break;

	case OPT_RLE:
	opt->rle = value;
	break;

	case OPT_ALIGN:
	opt->alignment = value;
	break;
	}
	}


	extern lzma_options_subblock *
	parse_options_subblock(const char *str)
	{
	static const option_map opts[] = {
	{ "size", NULL, LZMA_SUBBLOCK_DATA_SIZE_MIN,
	LZMA_SUBBLOCK_DATA_SIZE_MAX },
	{ "rle", NULL, LZMA_SUBBLOCK_RLE_OFF,
	LZMA_SUBBLOCK_RLE_MAX },
	{ "align",NULL, LZMA_SUBBLOCK_ALIGNMENT_MIN,
	LZMA_SUBBLOCK_ALIGNMENT_MAX },
	{ NULL, NULL, 0, 0 }
	};

	lzma_options_subblock *options
	= xmalloc(sizeof(lzma_options_subblock));
	*options = (lzma_options_subblock){
	.allow_subfilters = false,
	.alignment = LZMA_SUBBLOCK_ALIGNMENT_DEFAULT,
	.subblock_data_size = LZMA_SUBBLOCK_DATA_SIZE_DEFAULT,
	.rle = LZMA_SUBBLOCK_RLE_OFF,
	};

	parse_options(str, opts, &set_subblock, options);

	return options;
	}


	///////////
	// Delta //
	///////////

	enum {
	OPT_DISTANCE,
	};


	static void
	set_delta(void *options, uint32_t key, uint64_t value)
	{
	lzma_options_delta *opt = options;
	switch (key) {
	case OPT_DISTANCE:
	opt->distance = value;
	break;
	}
	}


	extern lzma_options_delta *
	parse_options_delta(const char *str)
	{
	static const option_map opts[] = {
	{ "distance", NULL, LZMA_DELTA_DISTANCE_MIN,
	LZMA_DELTA_DISTANCE_MAX },
	{ NULL, NULL, 0, 0 }
	};

	lzma_options_delta *options = xmalloc(sizeof(lzma_options_subblock));
	*options = (lzma_options_delta){
	// It's hard to give a useful default for this.
	.distance = LZMA_DELTA_DISTANCE_MIN,
	};

	parse_options(str, opts, &set_delta, options);

	return options;
	}


	//////////
	// LZMA //
	//////////

	enum {
	OPT_DICT,
	OPT_LC,
	OPT_LP,
	OPT_PB,
	OPT_MODE,
	OPT_FB,
	OPT_MF,
	OPT_MC
	};


	static void
	set_lzma(void *options, uint32_t key, uint64_t value)
	{
	lzma_options_lzma *opt = options;

	switch (key) {
	case OPT_DICT:
	opt->dictionary_size = value;
	break;

	case OPT_LC:
	opt->literal_context_bits = value;
	break;

	case OPT_LP:
	opt->literal_pos_bits = value;
	break;

	case OPT_PB:
	opt->pos_bits = value;
	break;

	case OPT_MODE:
	opt->mode = value;
	break;

	case OPT_FB:
	opt->fast_bytes = value;
	break;

	case OPT_MF:
	opt->match_finder = value;
	break;

	case OPT_MC:
	opt->match_finder_cycles = value;
	break;
	}
	}


	extern lzma_options_lzma *
	parse_options_lzma(const char *str)
	{
	static const name_id_map modes[] = {
	{ "fast", LZMA_MODE_FAST },
	{ "best", LZMA_MODE_BEST },
	{ 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[] = {
	{ "dict", NULL, LZMA_DICTIONARY_SIZE_MIN,
	LZMA_DICTIONARY_SIZE_MAX },
	{ "lc", NULL, LZMA_LITERAL_CONTEXT_BITS_MIN,
	LZMA_LITERAL_CONTEXT_BITS_MAX },
	{ "lp", NULL, LZMA_LITERAL_POS_BITS_MIN,
	LZMA_LITERAL_POS_BITS_MAX },
	{ "pb", NULL, LZMA_POS_BITS_MIN, LZMA_POS_BITS_MAX },
	{ "mode", modes, 0, 0 },
	{ "fb", NULL, LZMA_FAST_BYTES_MIN, LZMA_FAST_BYTES_MAX },
	{ "mf", mfs, 0, 0 },
	{ "mc", NULL, 0, UINT32_MAX },
	{ NULL, NULL, 0, 0 }
	};

	lzma_options_lzma *options = xmalloc(sizeof(lzma_options_lzma));
	*options = (lzma_options_lzma){
	.dictionary_size = LZMA_DICTIONARY_SIZE_DEFAULT,
	.literal_context_bits = LZMA_LITERAL_CONTEXT_BITS_DEFAULT,
	.literal_pos_bits = LZMA_LITERAL_POS_BITS_DEFAULT,
	.pos_bits = LZMA_POS_BITS_DEFAULT,
	.mode = LZMA_MODE_BEST,
	.fast_bytes = LZMA_FAST_BYTES_DEFAULT,
	.match_finder = LZMA_MF_BT4,
	.match_finder_cycles = 0,
	};

	parse_options(str, opts, &set_lzma, options);

	return options;
	}