/**
* argparser – command line argument parser library
*
* Copyright © 2013 Mattias Andrée (maandree@member.fsf.org)
*
* This library is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This library 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "argparser.h"
/* Code style constants */
#define true 1
#define false 0
#define null 0
/* Constants */
#define ARGUMENTLESS 0
#define ARGUMENTED 1
#define OPTARGUMENTED 2
#define VARIADIC 3
/* Prototype for static functions */
static const char* args__abbreviations(const char* argument);
static void _sort(const char** list, size_t count, const char** temp);
static void sort(const char** list, size_t count);
static void _sort_ptr(void** list, size_t count, void** temp);
static void sort_ptr(void** list, size_t count);
static int cmp(const char* a, const char* b);
static void map_init(args_Map* map);
static void* map_get(args_Map* map, const char* key);
static void map_put(args_Map* map, const char* key, void* value);
static void _map_free(void** level, int has_value);
static void** map_free(args_Map* map);
static void noop_2(const char* used, const char* std);
static void noop_3(const char* used, const char* std, char* value);
static int default_stickless(const char* argument);
/**
* Whether the Linux VT is being used
*/
static int args_linuxvt;
/**
* Whether to use single dash/plus long options
*/
static int args_alternative;
/**
* Queue of objects that needs to be freed on dispose
*/
static void** args_freequeue;
/**
* The number of elements in `args_freequeue`
*/
static ssize_t args_freeptr;
/**
* Options, in order
*/
static args_Option* args_options;
/**
* Number of elements in `args_options`
*/
static size_t args_options_count;
/**
* Number of elements for which `args_options` is allocated
*/
static size_t args_options_size;
/**
* Option map
*/
static args_Map args_optmap;
/**
* Parsed arguments, a map from option to arguments, with one `null` element per argumentless use
*/
static args_Map args_opts;
/**
* Used in `map_free` and `_map_free` to store found values that can be freed
*/
static void** args_map_values;
/**
* The number of elements in `args_map_values`
*/
static size_t args_map_values_ptr;
/**
* The size of `args_map_values`
*/
static size_t args_map_values_size;
/**
* Initialiser.
* The short description is printed on same line as the program name
*
* @param description Short, single-line, description of the program
* @param usage Formated, multi-line, usage text, may be `null`
* @param longdescription Long, multi-line, description of the program, may be `null`
* @param program The name of the program, `null` for automatic
* @param usestderr Whether to use stderr instead of stdout
* @param alternative Whether to use single dash/plus long options
* @param abbreviations Abbreviated option expander, `null` for disabled
*/
void args_init(const char* description, const char* usage, const char* longdescription, const char* program, int usestderr, int alternative, const char* (*abbreviations)(const char*, const char**, size_t))
{
char* term = getenv("TERM");
args_linuxvt = 0;
if (term != null)
if (*(term + 0) == 'l')
if (*(term + 1) == 'i')
if (*(term + 2) == 'n')
if (*(term + 3) == 'u')
if (*(term + 4) == 'x')
if (*(term + 5) == 0)
args_linuxvt = 1;
args_program = program == null ? args_parent_name(0) : strdup(program);
if (args_program == null)
args_program = strdup("?");
args_description = description;
args_usage = usage;
args_longdescription = longdescription;
args_out_fd = usestderr ? 2 : 1;
args_out = usestderr ? stderr : stdout;
args_alternative = alternative;
args_arguments_count = args_unrecognised_count = args_files_count = 0;
args_files = args_arguments = null;
args_message = null;
args_freequeue = null;
args_freeptr = 0;
args_options_count = 0;
args_options_size = 64;
args_options = (args_Option*)malloc(args_options_size * sizeof(args_Option));
map_init(&args_optmap);
map_init(&args_opts);
args_abbreviations = abbreviations;
}
/**
* Disposes of all resources, run this when you are done
*/
void args_dispose(void)
{
if (args_files != null)
free(args_files);
if (args_message != null)
free(args_message);
if (args_program != null)
free(args_program);
if (args_options != null)
{
size_t i;
for (i = 0; i < args_options_count; i++)
free((*(args_options + i)).alternatives);
free(args_options);
}
args_files = null;
args_message = null;
args_program = null;
args_options = null;
if (args_freequeue != null)
{
for (args_freeptr -= 1; args_freeptr >= 0; args_freeptr--)
free(*(args_freequeue + args_freeptr));
free(args_freequeue);
args_freequeue = null;
}
free(map_free(&args_optmap));
{
void** freethis = map_free(&args_opts);
size_t i = 0, count = 0, last = 0, new, size = 128;
void** values = (void**)malloc(size * sizeof(void*));
for (; *(freethis + i); i++)
{
args_Array* value = *(freethis + i);
if (count == size)
values = (void**)realloc(values, (size <<= 1) * sizeof(void*));
*(values + count++) = value->values;
free(value);
}
sort_ptr(values, count);
for (i = 0; i < count; i++)
{
new = (size_t)(void*)*(values + i);
if (new != last)
{
last = new;
free(*(values + i));
}
}
free(values);
free(freethis);
}
}
/**
* The standard abbrevation expander
*
* @param argument The option that not recognised
* @param options All recognised options
* @param count The number of elements in `options`
* @return The only possible expansion, otherwise `null`
*/
const char* args_standard_abbreviations(const char* argument, const char** options, size_t count)
{
const char* rc = null;
size_t i;
for (i = 0; i < count; i++)
{
size_t match = 0;
const char* opt = *(options + i);
while (*(argument + match) && (*(opt + match) == *(argument + match)))
match++;
if (*(argument + match) == 0)
{
if (rc)
return null;
rc = opt;
}
}
return rc;
}
/**
* Abbreviated option expansion function
*
* @param argument The option that is not recognised
* @return The only alternative, or `null`
*/
const char* args__abbreviations(const char* argument)
{
if (args_abbreviations == null)
return null;
return args_abbreviations(argument, args_get_optmap(), args_get_optmap_count());
}
/**
* Creates, but does not add, a option that takes no arguments
*
* @param trigger Function to invoke when the option is used, with the used option and the standard option
* @param standard The index of the standard alternative name
* @param alternatives... The alternative names, end with `null`
* @return The created option
*/
args_Option args_new_argumentless(void (*trigger)(const char*, const char*), ssize_t standard, const char* alternatives, ...)
{
size_t count = 1;
args_Option rc;
va_list args, cp;
size_t i;
va_copy(cp, args); /* va_copy(dest, src) */
va_start(cp, alternatives);
while (va_arg(cp, char*) != null)
count++;
va_end(cp);
rc.type = ARGUMENTLESS;
rc.help = null;
rc.argument = "NOTHING";
rc.alternatives_count = count;
rc.trigger = trigger == null ? noop_2 : trigger;
rc.alternatives = (const char**)malloc(count * sizeof(const char*));
va_start(args, alternatives);
*(rc.alternatives) = alternatives;
for (i = 1; i < count; i++)
*(rc.alternatives + i) = va_arg(args, const char*);
va_end(args);
if (standard < 0)
standard += (ssize_t)(rc.alternatives_count);
rc.standard = *(rc.alternatives + standard);
return rc;
}
/**
* Creates, but does not add, a option that takes one argument per use
*
* @param trigger Function to invoke when the option is used, with the used option, the standard option and the used value
* @param argument The new of the argument
* @param standard The index of the standard alternative name
* @param alternatives... The alternative names, end with `null`
* @return The created option
*/
args_Option args_new_argumented(void (*trigger)(const char*, const char*, char*), const char* argument, ssize_t standard, const char* alternatives, ...)
{
size_t count = 1;
args_Option rc;
va_list args, cp;
size_t i;
va_copy(cp, args); /* va_copy(dest, src) */
va_start(cp, alternatives);
while (va_arg(cp, char*) != null)
count++;
va_end(cp);
rc.type = ARGUMENTED;
rc.help = null;
rc.argument = argument == null ? "ARG" : argument;
rc.alternatives_count = count;
rc.triggerv = trigger == null ? noop_3 : trigger;
rc.alternatives = (const char**)malloc(count * sizeof(const char*));
va_start(args, alternatives);
*(rc.alternatives) = alternatives;
for (i = 1; i < count; i++)
*(rc.alternatives + i) = va_arg(args, const char*);
va_end(args);
if (standard < 0)
standard += (ssize_t)(rc.alternatives_count);
rc.standard = *(rc.alternatives + standard);
return rc;
}
/**
* Creates, but does not add, a option that optionally takes one argument per use
*
* @param stickless Should return true if the (feed) next argument can used for the argument without being sticky
* @param trigger Function to invoke when the option is used, with the used option, the standard option and the used value
* @param argument The new of the argument
* @param standard The index of the standard alternative name
* @param alternatives... The alternative names, end with `null`
* @return The created option
*/
args_Option args_new_optargumented(int (*stickless)(const char*), void (*trigger)(const char*, const char*, char*), const char* argument, ssize_t standard, const char* alternatives, ...)
{
size_t count = 1;
args_Option rc;
va_list args, cp;
size_t i;
va_copy(cp, args); /* va_copy(dest, src) */
va_start(cp, alternatives);
while (va_arg(cp, char*) != null)
count++;
va_end(cp);
rc.type = OPTARGUMENTED;
rc.help = null;
rc.argument = argument == null ? "ARG" : argument;
rc.alternatives_count = count;
rc.triggerv = trigger == null ? noop_3 : trigger;
rc.stickless = stickless == null ? default_stickless : stickless;
rc.alternatives = (const char**)malloc(count * sizeof(const char*));
va_start(args, alternatives);
*(rc.alternatives) = alternatives;
for (i = 1; i < count; i++)
*(rc.alternatives + i) = va_arg(args, const char*);
va_end(args);
if (standard < 0)
standard += (ssize_t)(rc.alternatives_count);
rc.standard = *(rc.alternatives + standard);
return rc;
}
/**
* Creates, but does not add, a option that takes all following arguments
*
* @param trigger Function to invoke when the option is used, with the used option and the standard option
* @param argument The new of the argument
* @param standard The index of the standard alternative name
* @param alternatives... The alternative names, end with `null`
* @return The created option
*/
args_Option args_new_variadic(void (*trigger)(const char*, const char*), const char* argument, ssize_t standard, const char* alternatives, ...)
{
size_t count = 1;
args_Option rc;
va_list args, cp;
size_t i;
va_copy(cp, args); /* va_copy(dest, src) */
va_start(cp, alternatives);
while (va_arg(cp, char*) != null)
count++;
va_end(cp);
rc.type = VARIADIC;
rc.help = null;
rc.argument = argument == null ? "ARG" : argument;
rc.alternatives_count = count;
rc.trigger = trigger == null ? noop_2 : trigger;
rc.alternatives = (const char**)malloc(count * sizeof(const char*));
va_start(args, alternatives);
*(rc.alternatives) = alternatives;
for (i = 1; i < count; i++)
*(rc.alternatives + i) = va_arg(args, const char*);
va_end(args);
if (standard < 0)
standard += (ssize_t)(rc.alternatives_count);
rc.standard = *(rc.alternatives + standard);
return rc;
}
/**
* Gets an array of all options
*
* @return All options
*/
args_Option* args_get_options(void)
{
return args_options;
}
/**
* Gets the number of elements in the array returned by `args_get_options`
*
* @return The number of elements in the array returned by `args_get_options`
*/
size_t args_get_options_count(void)
{
return args_options_count;
}
/**
* Gets the option with a specific index
*
* @param index The option's index
* @return The option
*/
args_Option args_options_get(size_t index)
{
return *(args_options + index);
}
/**
* Gets the type of a option with a specific index
*
* @param index The option's index
* @return The option's type
*/
int args_options_get_type(size_t index)
{
return (*(args_options + index)).type;
}
/**
* Gets the number of alternative option names for a option with a specific index
*
* @param index The option's index
* @return The option's number of alternative option names
*/
size_t args_options_get_alternatives_count(size_t index)
{
return (*(args_options + index)).alternatives_count;
}
/**
* Gets the alternative option names for a option with a specific index
*
* @param index The option's index
* @return The option's alternative option names
*/
const char** args_options_get_alternatives(size_t index)
{
return (*(args_options + index)).alternatives;
}
/**
* Gets the argument name for a option with a specific index
*
* @param index The option's index
* @return The option's argument name
*/
const char* args_options_get_argument(size_t index)
{
return (*(args_options + index)).argument;
}
/**
* Gets the standard option name for a option with a specific index
*
* @param index The option's index
* @return The option's standard option name
*/
const char* args_options_get_standard(size_t index)
{
return (*(args_options + index)).standard;
}
/**
* Gets the help text for a option with a specific index
*
* @param index The option's index
* @return The option's help text
*/
const char* args_options_get_help(size_t index)
{
return (*(args_options + index)).help;
}
/**
* Gets the available options
*
* @return The available options
*/
const char** args_get_opts(void)
{
return args_opts.keys;
}
/**
* Gets the number of available options
*
* @return The number of available options
*/
size_t args_get_opts_count(void)
{
return args_opts.key_count;
}
/**
* Gets whether an option is available
*
* @param name The option
* @return Whether an option is available
*/
int args_opts_contains(const char* name)
{
return map_get(&args_opts, name) != null;
}
/**
* Initialise an option
*
* @param name The option
*/
void args_opts_new(const char* name)
{
args_opts_put(name, null);
args_opts_put_count(name, 0);
}
/**
* Appends a value to an option
*
* @param name The option
* @param value The new value
*/
void args_opts_append(const char* name, char* value)
{
size_t size = args_opts_get_count(name) + 1;
char** values = args_opts_get(name);
if (values == null)
{
char** array = (char**)malloc(sizeof(char*));
*array = value;
args_opts_put(name, array);
}
else
{
size_t address = (size_t)(void*)values;
values = (char**)realloc(values, size * sizeof(char*));
*(values + size - 1) = value;
if ((size_t)(void*)values != address)
args_opts_put(name, values);
}
args_opts_put_count(name, size);
}
/**
* Removes all values from an option
*
* @param name The option
*/
void args_opts_clear(const char* name)
{
char** value = args_opts_get(name);
if (value != null)
free(value);
args_opts_new(name);
}
/**
* Gets the values for an option
*
* @param name The option
* @return The values
*/
char** args_opts_get(const char* name)
{
args_Array* value = (args_Array*)map_get(&args_opts, name);
if (value == null)
return null;
return (char**)value->values;
}
/**
* Gets the number of values for an option
*
* @param name The option
* @return The number of values
*/
size_t args_opts_get_count(const char* name)
{
args_Array* value = (args_Array*)map_get(&args_opts, name);
if (value == null)
return 0;
return value->count;
}
/**
* Sets the values for an option
*
* @param name The option
* @param count The values
*/
void args_opts_put(const char* name, char** values)
{
args_Array* value = (args_Array*)map_get(&args_opts, name);
if (value == null)
{
value = (args_Array*)malloc(sizeof(args_Array));
value->values = (void**)values;
map_put(&args_opts, name, value);
value->used = false;
}
else
value->values = (void**)values;
}
/**
* Sets the number of values for an option
*
* @param name The option
* @param count The number of values
*/
void args_opts_put_count(const char* name, size_t count)
{
args_Array* value = (args_Array*)map_get(&args_opts, name);
if (value == null)
{
value = (args_Array*)malloc(sizeof(args_Array));
value->count = count;
map_put(&args_opts, name, value);
}
else
value->count = count;
}
/**
* Checks whether an option is used
*
* @param name The option
* @return Whether the option is used
*/
int args_opts_used(const char* name)
{
args_Array* value = (args_Array*)map_get(&args_opts, name);
if (value == null)
return false;
return value->used;
}
/**
* Gets all alternativ names that exists for all options combined
*
* @return All alternativ names that exists for all options
*/
const char** args_get_optmap(void)
{
return args_optmap.keys;
}
/**
* Gets the number of elements returned by `args_get_optmap`
*
* @return The number of elements returned by `args_get_optmap`
*/
size_t args_get_optmap_count(void)
{
return args_optmap.key_count;
}
/**
* Maps alternative name for a option
*
* @param name The option's alternative name
* @param index The option's index
*/
void args_optmap_put(const char* name, size_t index)
{
map_put(&args_optmap, name, (void*)(index + 1));
}
/**
* Gets the option with a specific alternative name
*
* @param name The option's alternative name
* @return The option
*/
args_Option args_optmap_get(const char* name)
{
return *(args_options + args_optmap_get_index(name));
}
/**
* Gets the index of a option with a specific alternative name
*
* @param name The option's alternative name
* @return The option's index, negative if not found
*/
ssize_t args_optmap_get_index(const char* name)
{
void* ret = map_get(&args_optmap, name);
return ((ssize_t)ret) - 1;
}
/**
* Checks whether an options with a specific alternative name exists
*
* @param name One of the names of the option
* @return Whether the option exists
*/
int args_optmap_contains(const char* name)
{
return args_optmap_get_index(name) >= 0;
}
/**
* Gets the type of a option with a specific alternative name
*
* @param name The option's alternative name
* @return The option's type
*/
int args_optmap_get_type(const char* name)
{
return (*(args_options + args_optmap_get_index(name))).type;
}
/**
* Gets the standard option name for a option with a specific alternative name
*
* @param name The option's alternative name
* @return The option's standard option name
*/
const char* args_optmap_get_standard(const char* name)
{
return (*(args_options + args_optmap_get_index(name))).standard;
}
/**
* Trigger an option
*
* @param name The option's alternative name
* @param value The use value, `null` if argumentless or variadic
*/
void args_optmap_trigger(const char* name, char* value)
{
args_Option* opt = args_options + args_optmap_get_index(name);
if (value == null)
opt->trigger(name, opt->standard);
else
opt->triggerv(name, opt->standard, value);
}
/**
* Trigger an option
*
* @param name The option's alternative name
* @param value The use value
*/
void args_optmap_triggerv(const char* name, char* value)
{
args_Option* opt = args_options + args_optmap_get_index(name);
opt->triggerv(name, opt->standard, value);
}
/**
* Evaluate if an argument can be used without being sticky for an optionally argument option
*
* @param name The option's alternative name
* @param argument The argument
* @return Whether the argument can be used wihout being sticky
*/
int args_optmap_stickless(const char* name, char* argument)
{
return (args_options + args_optmap_get_index(name))->stickless(argument);
}
/**
* Adds an option
*
* @param option The option
* @param help Help text, multi-line, `null` if hidden
*/
void args_add_option(args_Option option, const char* help)
{
if (args_options_count == args_options_size)
args_options = (args_Option*)realloc(args_options, (args_options_size <<= 1) * sizeof(args_Option));
{
size_t i = 0, n = option.alternatives_count;
for (; i < n; i++)
args_optmap_put(*(option.alternatives + i), args_options_count);
args_opts_put(option.standard, null);
args_opts_put_count(option.standard, 0);
*(args_options + args_options_count) = option;
(*(args_options + args_options_count++)).help = help;
}
}
/**
* Gets the name of the parent process
*
* @param levels The number of parents to walk, 0 for self, and 1 for direct parent
* @return The name of the parent process, `null` if not found
*/
char* args_parent_name(size_t levels)
{
char pid[22]; /* 6 should be enough, but we want to be future proof */
ssize_t pid_n = readlink("/proc/self", pid, 21);
size_t lvl = levels, i, j, cmdsize, off;
size_t n;
FILE* is;
char buf[35];
char* cmd;
char* data;
if (pid_n <= 0)
return null;
pid[pid_n] = 0;
data = (char*)malloc(2048 * sizeof(char));
while (lvl > 0)
{
int found = false;
i = 0;
for (j = 0; *("/proc/" + j); j++) *(buf + i++) = *("/proc/" + j);
for (j = 0; *(pid + j); j++) *(buf + i++) = *(pid + j);
for (j = 0; *("/status" + j); j++) *(buf + i++) = *("/status" + j);
*(buf + i++) = 0;
if ((is = fopen(buf, "r")) == null)
{
free(data);
return null;
}
n = fread(data, 1, 2048, is);
j = 0;
for (i = 0; i < (size_t)n; i++)
{
char c = *(data + i);
if (c == '\n')
{
if (j > 5)
if (*(buf + 0) == 'P')
if (*(buf + 1) == 'P')
if (*(buf + 2) == 'i')
if (*(buf + 3) == 'd')
if (*(buf + 4) == ':')
{
i = 5;
while ((*(buf + i) == '\t') || (*(buf + i) == ' '))
i++;
j -= n = i;
off = n;
for (i = 0; i < j; i++)
*(pid + i) = *(buf + off + i);
*(pid + j) = 0;
lvl--;
found = true;
break;
}
j = 0;
}
else if (j < 35)
*(buf + j++) = c;
}
fclose(is);
if (found == false)
{
free(data);
return null;
}
}
free(data);
i = 0;
for (j = 0; *("/proc/" + j); j++) *(buf + i++) = *("/proc/" + j);
for (j = 0; *(pid + j); j++) *(buf + i++) = *(pid + j);
for (j = 0; *("/cmdline" + j); j++) *(buf + i++) = *("/cmdline" + j);
*(buf + i++) = 0;
if ((is = fopen(buf, "r")) == null)
return null;
i = 0;
n = 0;
cmd = (char*)malloc((cmdsize = 128) * sizeof(char));
for (;;)
{
n += fread(cmd, 1, 128, is);
for (; i < (size_t)n; i++)
if (*(cmd + i) == 0)
break;
if (i == (size_t)n)
cmd = (char*)realloc(cmd, (cmdsize + 128) * sizeof(char));
else
break;
}
fclose(is);
if (*cmd == 0)
{
free(cmd);
cmd = 0;
}
return cmd;
}
/**
* Checks the correctness of the number of used non-option arguments
*
* @param min The minimum number of files
* @return Whether the usage was correct
*/
int args_test_files_min(size_t min)
{
return min <= args_files_count;
}
/**
* Checks the correctness of the number of used non-option arguments
*
* @param max The maximum number of files
* @return Whether the usage was correct
*/
int args_test_files_max(size_t max)
{
return args_files_count <= max;
}
/**
* Checks the correctness of the number of used non-option arguments
*
* @param min The minimum number of files
* @param max The maximum number of files
* @return Whether the usage was correct
*/
int args_test_files(size_t min, size_t max)
{
return (min <= args_files_count) && (args_files_count <= max);
}
/**
* Checks for out of context option usage
*
* @param allowed Allowed options, will be sorted
* @param allowed_count The number of elements in `allowed`
* @return Whether only allowed options was used
*/
int args_test_allowed(const char** allowed, size_t allowed_count)
{
const char** opts;
const char** a;
size_t _a, _o, i;
int rc = true;
sort(allowed, _a = allowed_count);
opts = args_get_opts();
sort(opts, _o = args_get_opts_count());
a = allowed + _a;
for (i = 0; i < _o; i++, opts++)
{
if ((allowed == a) || (cmp(*opts, *allowed) < 0))
if (args_opts_used(*opts))
{
const char* std = args_optmap_get_standard(*opts);
fprintf(args_out, "%s: option used out of context: %s", args_program, *opts);
if (cmp(std, *opts) != 0)
fprintf(args_out, "(%s)", std);
fprintf(args_out, "\n");
rc = false;
}
while ((allowed != a) && (cmp(*opts, *allowed) > 0))
allowed++;
}
return rc;
}
/**
* Checks for option conflicts
*
* @param exclusives Exclusive options, will be sorted
* @param exclusives_count The number of elements in `exclusives`
* @return Whether at most one exclusive option was used
*/
int args_test_exclusiveness(const char** exclusives, size_t exclusives_count)
{
size_t used_ptr = 0, i = 0;
const char** used = (const char**)malloc(args_get_opts_count() * sizeof(const char*));
const char** e;
const char** o;
const char** opts;
const char* std;
size_t _e, _o;
sort(exclusives, _e = exclusives_count);
opts = args_get_opts();
sort(opts, _o = args_get_opts_count());
e = exclusives + _e;
o = opts + _o;
while ((opts != o) && (exclusives != e))
{
while ((opts != o) && (cmp(*opts, *exclusives) > 0))
opts++;
while ((exclusives != e) && (cmp(*opts, *exclusives) > 0))
exclusives++;
if ((cmp(*opts, *exclusives) == 0) && (args_opts_used(*opts)))
*(used + used_ptr++) = *opts;
opts++;
}
if (used_ptr >= 1)
{
fprintf(args_out, "%s: conflicting options:", args_program);
for (; i < used_ptr; i++)
{
std = args_optmap_get_standard(*(used + i));
if (cmp(*(used + i), std) == 0)
fprintf(args_out, " %s", *(used + i));
else
fprintf(args_out, " %s(%s)", *(used + i), std);
}
fprintf(args_out, "\n");
free(used);
return false;
}
free(used);
return true;
}
/**
* Maps up options that are alternatives to the first alternative for each option
*/
void args_support_alternatives(void)
{
const char** opts = args_get_optmap();
size_t n = args_get_optmap_count();
size_t i;
for (i = 0; i < n; i++)
{
const char* alt = *(opts + i);
const char* std = args_optmap_get_standard(alt);
args_Array* value_std = (args_Array*)map_get(&args_opts, std);
args_Array* value_alt;
args_opts_put(alt, (char**)value_std->values);
value_alt = (args_Array*)map_get(&args_opts, alt);
value_alt->count = value_std->count;
value_alt->used = value_std->used;
}
}
/**
* Prints a colourful help message
*
* @param [use_colours] `0` for no colours, `1` for colours, and `-1` for if not piped
*/
void args_help(long use_colours)
{
size_t maxfirstlen = 0, count = 0, copts = args_get_options_count();
const char* dash = args_linuxvt ? "-" : "—";
char* empty;
char** lines;
size_t* lens;
if ((use_colours != 0) && (use_colours != 1))
use_colours = isatty(args_out_fd);
fprintf(args_out, use_colours ? "\033[01m%s\033[21m %s %s\n" : "%s %s %s\n", args_program, dash, args_description);
if (args_longdescription != null)
fprintf(args_out, "%s\n", args_longdescription);
fprintf(args_out, "\n");
if (args_usage != null)
{
size_t n = 0, lines_n = 0, i = 0;
char* buf;
fprintf(args_out, use_colours ? "\033[01mUSAGE:\033[21m\n" : "USAGE:\n");
while (*(args_usage + n))
if (*(args_usage + n++) == '\n')
lines_n++;
buf = (char*)malloc((n + 2 + lines_n * 7) * sizeof(char));
*buf++ = '\t';
while (i < n)
{
*buf++ = *(args_usage + i);
if (*(args_usage + i++) == '\n')
{
*buf++ = ' ';
*buf++ = ' ';
*buf++ = ' ';
*buf++ = ' ';
*buf++ = 'o';
*buf++ = 'r';
*buf++ = '\t';
}
}
*buf++ = 0;
buf -= n + 2 + lines_n * 7;
fprintf(args_out, "%s\n\n", buf);
free(buf);
}
{
size_t i = 0;
for (i = 0; i < copts; i++)
{
if (args_options_get_help(i) == null)
continue;
if (args_options_get_alternatives_count(i) > 1)
{
size_t n = 0;
const char* first = *(args_options_get_alternatives(i));
while (*(first + n))
n++;
if (maxfirstlen < n)
maxfirstlen = n;
}
}
}
empty = (char*)malloc((maxfirstlen + 1) * sizeof(char));
{
size_t i;
for (i = 0; i < maxfirstlen; i++)
*(empty + i) = ' ';
*(empty + maxfirstlen) = 0;
}
fprintf(args_out, use_colours ? "\033[01mSYNOPSIS:\033[21m\n" : "SYNOPSIS:\n");
lines = (char**)malloc(copts * sizeof(char*));
lens = (size_t*)malloc(copts * sizeof(size_t));
{
char* first_extra = null;
size_t index = 0, i = 0, n, m, l, j;
int type;
for (i = 0; i < copts; i++)
{
const char* first;
const char* last;
char* line;
const char* arg;
if (args_options_get_help(i) == null)
continue;
arg = args_options_get_argument(i);
first = *(args_options_get_alternatives(i));
last = *(args_options_get_alternatives(i) + args_options_get_alternatives_count(i) - 1);
type = args_options_get_type(i);
if (first == last)
{
first = empty;
first_extra = null;
}
else
{
n = 0;
while (*(first + n))
n++;
first_extra = empty + n;
}
n = m = 0;
while (*(last + n))
n++;
if (type != ARGUMENTLESS)
while (*(arg + m))
m++;
l = maxfirstlen + 6 + n + m;
*(lines + count) = line = (char*)malloc((9 + maxfirstlen + 7 + 15 + n + 9 + 6 + m + 5 + 1) * sizeof(char));
for (j = 0; *((use_colours ? " \033[02m" : " ") + j); j++)
*line++ = *((use_colours ? " \033[02m" : " ") + j);
for (j = 0; *(first + j); j++)
*line++ = *(first + j);
if (first_extra != null)
for (j = 0; *(first_extra + j); j++)
*line++ = *(first_extra + j);
for (j = 0; *((use_colours ? "\033[22m " : " ") + j); j++)
*line++ = *((use_colours ? "\033[22m " : " ") + j);
if (use_colours)
{
if ((index++ & 1) == 0)
for (j = 0; *("\033[36;01m" + j); j++)
*line++ = *("\033[36;01m" + j);
else
for (j = 0; *("\033[34;01m" + j); j++)
*line++ = *("\033[34;01m" + j);
}
for (j = 0; *(last + j); j++)
*line++ = *(last + j);
if (type == VARIADIC)
{
for (j = 0; *((use_colours ? " [\033[04m" : " [") + j); j++)
*line++ = *((use_colours ? " [\033[04m" : " [") + j);
for (j = 0; *(arg + j); j++)
*line++ = *(arg + j);
for (j = 0; *((use_colours ? "\033[24m...]" : "...]") + j); j++)
*line++ = *((use_colours ? "\033[24m...]" : "...]") + j);
l += 6;
}
else if (type == OPTARGUMENTED)
{
for (j = 0; *((use_colours ? " [\033[04m" : " [") + j); j++)
*line++ = *((use_colours ? " [\033[04m" : " [") + j);
for (j = 0; *(arg + j); j++)
*line++ = *(arg + j);
for (j = 0; *((use_colours ? "\033[24m]" : "]") + j); j++)
*line++ = *((use_colours ? "\033[24m]" : "]") + j);
l += 3;
}
else if (type == ARGUMENTED)
{
if (use_colours)
for (j = 0; *(" \033[04m" + j); j++)
*line++ = *(" \033[04m" + j);
else
*line++ = ' ';
for (j = 0; *(arg + j); j++)
*line++ = *(arg + j);
if (use_colours)
for (j = 0; *("\033[24m" + j); j++)
*line++ = *("\033[24m" + j);
l += 1;
}
*line = 0;
*(lens + count++) = l;
}
}
free(empty);
{
size_t col = 0, i = 0, index = 0;
for (; i < count; i++)
if (col < *(lens + i))
col = *(lens + i);
col += 8 - ((col - 4) & 7);
empty = (char*)malloc((col + 1) * sizeof(char));
for (i = 0; i < col; i++)
*(empty + i) = ' ';
*(empty + col) = 0;
for (i = 0; i < copts; i++)
{
int first = true;
size_t j = 0, jptr = 1;
const char* colour = (index & 1) == 0 ? "36" : "34";
const char* help = args_options_get_help(i);
char* line;
char* buf;
char** jumps;
char c;
if (help == null)
continue;
fprintf(args_out, "%s%s", line = *(lines + index), empty + *(lens + index));
free(*(lines + index++));
while ((c = *(help + j++)))
if (c == '\n')
jptr++;
jumps = (char**)malloc(jptr * sizeof(char*));
*jumps = buf = (char*)malloc(j * sizeof(char));
j = 0;
jptr = 1;
while ((c = *(help + j)))
if (c == '\n')
{
*(buf + j++) = 0;
*(jumps + jptr++) = buf + j;
}
else
*(buf + j++) = c;
*(buf + j) = 0;
for (j = 0; j < jptr; j++)
if (first)
{
first = false;
fprintf(args_out, "%s\033[00m\n", *(jumps + j));
}
else
if (use_colours)
fprintf(args_out, "%s\033[%sm%s\033[00m\n", empty, colour, *(jumps + j));
else
fprintf(args_out, "%s%s\n", empty, *(jumps + j));
free(buf);
free(jumps);
}
}
free(empty);
free(lines);
free(lens);
fprintf(args_out, "\n");
}
/**
* Parse arguments
*
* @param argc The number of elements in `argv`
* @param argv The command line arguments, it should include the execute file at index 0
* @return Whether no unrecognised option is used
*/
int args_parse(int argc, char** argv)
{
char** argend = argv + argc;
int dashed = false, tmpdashed = false, rc = true;
size_t get = 0, dontget = 0;
size_t argptr = 0, optptr = 0, queuesize = (size_t)argc - 1;
char* injection = null;
char** argqueue;
char** optqueue;
args_freeptr = 0;
args_unrecognised_count = 0;
args_arguments_count = (size_t)argc - 1;
args_arguments = ++argv;
args_files = (char**)malloc((size_t)(argc - 1) * sizeof(char*));
while (argv != argend)
{
char* arg = *argv++;
if (((*arg == '-') || (*arg == '+')) && (*(arg + 1) != 0))
if (*arg != *(arg + 1))
{
size_t i = 1;
while (*(arg + i))
i++;
queuesize += i - 1;
}
}
argv = args_arguments;
argqueue = (char**)malloc(queuesize * sizeof(char*));
optqueue = (char**)malloc(queuesize * sizeof(char*));
args_freequeue = (void**)malloc(queuesize * sizeof(void*) * 2);
while ((argv != argend) || injection)
{
char* arg = injection ? injection : *argv++;
injection = null;
if ((get > 0) && (dontget == 0))
{
char* arg_opt = *(optqueue + optptr - get--);
long passed = true;
if (args_optmap_get_type(arg_opt) == OPTARGUMENTED)
if (args_optmap_stickless(arg_opt, arg) == false)
{
passed = false;
args_optmap_triggerv(arg_opt, null);
*(argqueue + argptr++) = null;
}
if (passed)
{
args_optmap_trigger(arg_opt, arg);
*(argqueue + argptr++) = arg;
continue;
}
}
if (tmpdashed)
{
*(args_files + args_files_count++) = arg;
tmpdashed = 0;
}
else if (dashed)
*(args_files + args_files_count++) = arg;
else if ((*arg == '+') && (*(arg + 1) == '+') && (*(arg + 2) == 0))
tmpdashed = true;
else if ((*arg == '-') && (*(arg + 1) == '-') && (*(arg + 2) == 0))
dashed = true;
else if (((*arg == '-') || (*arg == '+')) && (*(arg + 1) != 0))
if (args_alternative || (*arg == *(arg + 1)))
{
size_t eq = 0;
int type = 100;
if (dontget <= 0)
{
if (args_optmap_contains(arg))
type = args_optmap_get_type(arg);
if (type != ARGUMENTLESS)
while (*(arg + eq) && (*(arg + eq) != '='))
eq++;
}
if (dontget > 0)
dontget--;
else if (type == ARGUMENTLESS)
{
*(optqueue + optptr++) = arg;
*(argqueue + argptr++) = null;
args_optmap_trigger(arg, null);
}
else if (*(arg + eq) == '=')
{
char* arg_opt = (char*)malloc((eq + 1) * sizeof(char));
size_t i;
for (i = 0; i < eq; i++)
*(arg_opt + i) = *(arg + i);
*(arg_opt + eq) = 0;
if (args_optmap_contains(arg_opt) && ((type = args_optmap_get_type(arg_opt)) >= ARGUMENTED))
{
*(optqueue + optptr++) = arg_opt;
*(argqueue + argptr++) = arg + eq + 1;
*(args_freequeue + args_freeptr++) = arg_opt;
if (type == VARIADIC)
{
dashed = true;
args_optmap_trigger(arg_opt, null);
}
else
args_optmap_trigger(arg_opt, arg + eq + 1);
}
else
{
if ((injection = args__abbreviations(arg_opt)))
{
size_t n = 1, j = 0;
char* _injection;
for (i = 0; *(injection + i); i++)
n++;
for (i = eq + 1; *(arg + i); i++)
n++;
_injection = (char*)malloc((n + 1) * sizeof(char));
*(args_freequeue + args_freeptr++) = _injection;
for (i = 0; *(injection + i); i++)
*(_injection + j++) = *(injection + i);
*((injection = _injection) + j++) = '=';
for (i = eq + 1; *(arg + i); i++)
*(injection + j++) = *(arg + i);
*(injection + j) = 0;
}
else
{
if (++args_unrecognised_count <= 5)
fprintf(args_out, "%s: warning: unrecognised option %s\n", args_program, arg_opt);
rc = false;
}
free(arg_opt);
}
}
else if (type <= OPTARGUMENTED)
{
*(optqueue + optptr++) = arg;
get++;
}
else if (type == VARIADIC)
{
dashed = true;
*(optqueue + optptr++) = arg;
*(argqueue + argptr++) = null;
args_optmap_trigger(arg, null);
}
else
if ((injection = args__abbreviations(arg)) == null)
{
if (++args_unrecognised_count <= 5)
fprintf(args_out, "%s: warning: unrecognised option %s\n", args_program, arg);
rc = false;
}
}
else
{
char sign = *arg;
size_t i = 1;
while (*(arg + i))
{
char* narg = (char*)malloc(3 * sizeof(char));
*(narg + 0) = sign;
*(narg + 1) = *(arg + i);
*(narg + 2) = 0;
i++;
if (args_optmap_contains(narg))
{
long type = args_optmap_get_type(narg);
*(args_freequeue + args_freeptr++) = narg;
*(optqueue + optptr++) = narg;
if (type == ARGUMENTLESS)
{
*(argqueue + argptr++) = null;
args_optmap_trigger(narg, null);
}
else if (type < VARIADIC)
{
if (*(arg + i))
{
*(argqueue + argptr++) = arg + i;
args_optmap_trigger(narg, arg + i);
}
else
get++;
break;
}
else
{
if (*(arg + i))
*(argqueue + argptr++) = arg + i;
dashed = true;
args_optmap_trigger(narg, null);
break;
}
}
else
{
if (++args_unrecognised_count <= 5)
fprintf(args_out, "%s: warning: unrecognised option %s\n", args_program, arg);
rc = false;
free(narg);
}
}
}
else
*(args_files + args_files_count++) = arg;
}
{
size_t i = 0;
while (i < optptr)
{
const char* opt = args_optmap_get_standard(*(optqueue + i));
char* arg = argptr > i ? *(argqueue + i) : null;
if (argptr <= i)
args_optmap_triggerv(*(optqueue + i), null);
i++;
if ((args_optmap_contains(opt) == false) || (args_opts_contains(opt) == false))
args_opts_new(opt);
args_opts_append(opt, arg);
((args_Array*)map_get(&args_opts, opt))->used = true;
}
}
{
size_t i = 0, j = 0, n = args_get_options_count();
for (; i < n; i++)
if (args_options_get_type(i) == VARIADIC)
{
const char* std = args_options_get_standard(i);
if (args_opts_used(std))
{
if (*(args_opts_get(std)) == null)
args_opts_clear(std);
for (j = 0; j < args_files_count; j++)
args_opts_append(std, *(args_files + j));
args_files_count = 0;
break;
}
}
}
free(argqueue);
free(optqueue);
args_message = null;
if (args_files_count > 0)
{
size_t n = args_files_count, i, j;
for (i = 0; i < args_files_count; i++)
{
char* file = *(args_files + i);
for (j = 0; *(file + j); j++)
;
n += j;
}
args_message = (char*)malloc(n * sizeof(char));
n = 0;
for (i = 0; i < args_files_count; i++)
{
char* file = *(args_files + i);
for (j = 0; *(file + j); j++)
*(args_message + n++) = *(file + j);
*(args_message + n++) = ' ';
}
*(args_message + --n) = 0;
}
if (args_unrecognised_count > 5)
{
size_t more = args_unrecognised_count - 5;
const char* option_s = more == 1 ? "option" : "options";
fprintf(args_out, "%s: warning: %li more unrecognised %s\n", args_program, more, option_s);
}
return rc;
}
/**
* Compare two strings
*
* @param a -1 if returned if this sting is the alphabetically lesser one
* @param b 1 if returned if this sting is the alphabetically lesser one
* @return 0 is returned if the two string are identical, other -1 or 1 is returned
*/
static int cmp(const char* a, const char* b)
{
char c;
while (*a && *b)
{
if ((c = (*a < *b ? -1 : (*a > *b ? 1 : 0))))
return c;
a++;
b++;
}
return *a < *b ? -1 : (*a > *b ? 1 : 0);
}
/**
* Naïve merge sort is best merge sort in C
*
* @param list The list to sort from the point that needs sorting
* @param count The number of elements to sort
* @param temp Auxiliary memory
*/
static void _sort(const char** list, size_t count, const char** temp)
{
if (count > 1)
{
size_t i = 0, a = count >> 1;
size_t j = a, b = count - a;
_sort(list + 0, a, temp + 0);
_sort(list + a, b, temp + a);
b += a;
while ((i < a) && (j < b))
{
int c = cmp(*(temp + i), *(temp + j));
if (c <= 0)
*list++ = *(temp + i++);
else
*list++ = *(temp + j++);
}
while (i < a)
*list++ = *(temp + i++);
while (j < b)
*list++ = *(temp + j++);
list -= count;
for (i = 0; i < count; i++)
*(temp + i) = *(list + i);
}
else if (count == 1)
*temp = *list;
}
/**
* Naïve merge sort is best merge sort in C
*
* @param list The list to sort
* @param count The number of elements to sort
*/
static void sort(const char** list, size_t count)
{
const char** temp = (const char**)malloc(count * sizeof(const char*));
_sort(list, count, temp);
free(temp);
}
/**
* Naïve merge sort is best merge sort in C
*
* @param list The list to sort from the point that needs sorting
* @param count The number of elements to sort
* @param temp Auxiliary memory
*/
static void _sort_ptr(void** list, size_t count, void** temp)
{
if (count > 1)
{
size_t i = 0, a = count >> 1;
size_t j = a, b = count - a;
_sort_ptr(list + 0, a, temp + 0);
_sort_ptr(list + a, b, temp + a);
b += a;
while ((i < a) && (j < b))
{
if (*(temp + i) <= *(temp + j))
*list++ = *(temp + i++);
else
*list++ = *(temp + j++);
}
while (i < a)
*list++ = *(temp + i++);
while (j < b)
*list++ = *(temp + j++);
list -= count;
for (i = 0; i < count; i++)
*(temp + i) = *(list + i);
}
else if (count == 1)
*temp = *list;
}
/**
* Naïve merge sort is best merge sort in C
*
* @param list The list to sort
* @param count The number of elements to sort
*/
static void sort_ptr(void** list, size_t count)
{
void** temp = (void**)malloc(count * sizeof(void*));
_sort_ptr(list, count, temp);
free(temp);
}
/**
* Initialises a map
*
* @param map The address of the map
*/
static void map_init(args_Map* map)
{
size_t i;
void** level;
map->keys = null;
map->key_count = 0;
map->data = level = (void**)malloc(17 * sizeof(void*));
for (i = 0; i < 17; i++)
*(level + i) = null;
}
/**
* Gets the value for a key in a map
*
* @param map The address of the map
* @param key The key
* @return The value, `null` if not found
*/
static void* map_get(args_Map* map, const char* key)
{
void** at = map->data;
while (*key)
{
size_t a = (size_t)((*key >> 4) & 15);
size_t b = (size_t)((*key >> 0) & 15);
if (*(at + a))
at = (void**)*(at + a);
else
return null;
if (*(at + b))
at = (void**)*(at + b);
else
return null;
key++;
}
return *(at + 16);
}
/**
* Sets the value for a key in a map
*
* @param map The address of the map
* @param key The key
* @param value The value, `null` to remove, however this does not unlist the key
*/
static void map_put(args_Map* map, const char* key, void* value)
{
const char* _key = key;
int new = false;
void** at = map->data;
size_t i;
while (*key)
{
size_t a = (size_t)((*key >> 4) & 15);
size_t b = (size_t)((*key >> 0) & 15);
if (*(at + a))
at = (void**)*(at + a);
else
{
at = (void**)(*(at + a) = (void*)malloc(16 * sizeof(void*)));
for (i = 0; i < 16; i++)
*(at + i) = null;
new = true;
}
if (*(at + b))
at = (void**)*(at + b);
else
{
at = (void**)(*(at + b) = (void*)malloc(17 * sizeof(void*)));
for (i = 0; i < 17; i++)
*(at + i) = null;
new = true;
}
key++;
}
*(at + 16) = value;
if (new)
{
map->keys = (const char**)realloc(map->keys, (map->key_count + 1) * sizeof(const char*));
*(map->keys + map->key_count++) = _key;
}
}
/**
* Frees a level and all sublevels in a map
*
* @param level The level
* @param has_value Whether the level can hold a value
*/
static void _map_free(void** level, int has_value)
{
int next_has_value = has_value ^ true;
size_t i;
void* value;
if (level == null)
return;
for (i = 0; i < 16; i++)
_map_free(*(level + i), next_has_value);
if (has_value)
if ((value = *(level + 16)))
{
if (args_map_values_ptr == args_map_values_size)
args_map_values = (void**)realloc(args_map_values, (args_map_values_size <<= 1) * sizeof(void*));
*(args_map_values + args_map_values_ptr++) = value;
}
free(level);
}
/**
* Frees the resources of a map
*
* @param map The address of the map
* @return `null`-terminated array of values that you may want to free, but do free this returend array before running this function again
*/
static void** map_free(args_Map* map)
{
if (map->keys != null)
free(map->keys);
map->keys = null;
args_map_values_ptr = 0;
args_map_values_size = 64;
args_map_values = (void**)malloc(64 * sizeof(void*));
_map_free(map->data, true);
if (args_map_values_ptr == args_map_values_size)
args_map_values = (void**)realloc(args_map_values, (args_map_values_size + 1) * sizeof(void*));
*(args_map_values + args_map_values_ptr) = null;
return args_map_values;
}
/**
* Dummy trigger
*
* @param used The used option alternative
* @param std The standard option alternative
*/
static void noop_2(const char* used, const char* std)
{
(void) used;
(void) std;
}
/**
* Dummy trigger
*
* @param used The used option alternative
* @param std The standard option alternative
* @param value The used value
*/
static void noop_3(const char* used, const char* std, char* value)
{
(void) used;
(void) std;
(void) value;
}
/**
* Default stickless evaluator
*
* @param The argument
* @return Whether the argument can be used without being sticky
*/
static int default_stickless(const char* argument)
{
return (*argument != '-') && (*argument != '+');
}
