fg_argparser.c File Reference

Command line argument parser. More...

#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include "fg_definitions.h"
#include "fg_argparser.h"

Go to the source code of this file.

Functions
static bool	add_error (struct arg_parser *const ap, const char *const msg)
	Add an error message to the arg-parser ap. More...
const char *	ap_argument (const struct arg_parser *const ap, const int i)
	Returns the argument of a parsed option. More...
int	ap_arguments (const struct arg_parser *const ap)
	Number of arguments parsed (may be different from argc). More...
bool	ap_check_mutex (const struct arg_parser *const ap, const struct ap_Mutex_state *const ms, const int i, int *conflict)
	Check a new option record for mutex. More...
int	ap_code (const struct arg_parser *const ap, const int i)
	Returns the code of a parsed option with given index. More...
const char *	ap_error (const struct arg_parser *const ap)
	Get the string containing errors encountered during parsing. More...
void	ap_free (struct arg_parser *const ap)
	Free internal state of arg-parser. More...
void	ap_free_mutex_state (struct ap_Mutex_state *const ms)
	Free a mutex context. More...
bool	ap_init (struct arg_parser *const ap, const int argc, const char *const argv[], const struct ap_Option options[], const char in_order)
	Initialize the arg-parser given command line and user-defined options. More...
bool	ap_init_mutex_state (const struct arg_parser *const ap, struct ap_Mutex_state *const ms)
	Initialize a new mutex state table. More...
bool	ap_is_used (const struct arg_parser *const ap, int code)
	Returns true if the option specified by code was given at least once. More...
const char *	ap_opt_string (const struct arg_parser *const ap, const int i)
	Get the real command line option string (may be the short or long version). More...
const struct ap_Option *	ap_option (const struct arg_parser *const ap, const int i)
	Get the user-defined option for a given record position. More...
void	ap_reset_mutex (struct ap_Mutex_state *const ms)
	Reset a mutex context. More...
static void *	ap_resize_buffer (void *buf, const int min_size)
	Assure at least a minimum size for buffer buf. More...
bool	ap_set_check_mutex (const struct arg_parser *const ap, struct ap_Mutex_state *const ms, const int i, int *conflict)
	Check a new option record for mutex and register it at the same time. More...
bool	ap_set_mutex (const struct arg_parser *const ap, struct ap_Mutex_state *const ms, const int i)
	Register an option record in a mutex context. More...
static bool	copy_options (struct arg_parser *const ap, const struct ap_Option options[])
	Copy options into the arg-parser ap. More...
static void	free_data (struct arg_parser *const ap)
	Free all space required by the arg-parser ap. More...
static int	get_mutex_count (const struct ap_Option options[])
	Get the number of mutex in the option definitions. More...
static int	get_num_options (const struct ap_Option options[])
	Determines number of options in options. More...
static bool	parse_long_option (struct arg_parser *const ap, const char *const opt, const char *const arg, const struct ap_Option options[], int *const argindp)
	Parses a long option and adds it to the record of arg-parser ap. More...
static bool	parse_short_option (struct arg_parser *const ap, const char *const opt, const char *const arg, const struct ap_Option options[], int *const argindp)
	Parses a short option and adds it to the record of arg-parser ap. More...
static bool	push_back_record (struct arg_parser *const ap, const int option_index, bool long_opt, const char *const argument)
	Store a parsed option in the state of the arg-parser given by ap. More...

Detailed Description

Command line argument parser.

Definition in file fg_argparser.c.

Function Documentation

add_error()

static bool add_error ( struct arg_parser *const  ap, const char *const  msg  )

static

Add an error message to the arg-parser ap.

Parameters

[in]	ap	pointer to the arg-parser state
[in]	msg	error string

Returns

return true for success, or false for failure

Definition at line 104 of file fg_argparser.c.

{
        const int len = strlen(msg);
        void *tmp = ap_resize_buffer(ap->error, ap->error_size + len + 1);
        if (!tmp)
                return false;
        ap->error = (char *)tmp;
        strncpy(ap->error + ap->error_size, msg, len + 1);
        ap->error_size += len;
 
        return true;
}

ap_argument()

const char* ap_argument	(	const struct arg_parser *const	ap,
		const int	i
	)

Returns the argument of a parsed option.

Parameters

[in]	ap	pointer to arg-parser state
[in]	i	index of the parsed option

Returns

argument of parsed option at index i. If this option has code 0 (non-option), the non-option string is returned

Definition at line 478 of file fg_argparser.c.

{
        if (i >= 0 && i < ap_arguments(ap))
                return ap->data[i].argument;
        else
                return "";
}

ap_arguments()

int ap_arguments

(

const struct arg_parser *const

ap

)

Number of arguments parsed (may be different from argc).

Parameters

[in]

ap

pointer to arg-parser state

Returns

number of parsed arguments

Definition at line 463 of file fg_argparser.c.

{
        return ap->data_size;
}

ap_check_mutex()

bool ap_check_mutex	(	const struct arg_parser *const	ap,
		const struct ap_Mutex_state *const	ms,
		const int	i,
		int *	conflict
	)

Check a new option record for mutex.

Parameters

[in]	ap	pointer to arg-parser state
[in]	ms	pointer to an initialized mutex context
[in]	i	index of the option to check for previous occurrences of mutexed options
[in]	conflict	pointer to a single integer value. This will contain the conflicting record position, if a conflict has been found

Returns

retrun true if conflict according to the state given by ms has occurred, otherwise flase

Definition at line 527 of file fg_argparser.c.

{
        if(ap->num_mutex != ms->num_mutex)
                return false;
 
        *conflict = 0;
 
        if (i < 0 || i >= ap_arguments(ap) || !ap->num_mutex)
                return false;
 
        int index = ap->data[i].option_index;
        for (int *mutex = ap->options[index].mutex; mutex && *mutex; mutex++) {
                if (ms->seen_records[*mutex-1]) {
                        *conflict = ms->seen_records[*mutex-1]-1;
                        if (ap->data[*conflict].option_index != index)
                                return true;
                        else
                                *conflict = 0;
                }
        }
 
        return false;
}

ap_code()

int ap_code	(	const struct arg_parser *const	ap,
		const int	i
	)

Returns the code of a parsed option with given index.

Parameters

[in]	ap	pointer to arg-parser state
[in]	i	index of the parsed option

Returns

code of parsed option at index i. If this is a non-option, it returns 0

Definition at line 468 of file fg_argparser.c.

{
        if (i >= 0 && i < ap_arguments(ap)) {
                int index = ap->data[i].option_index;
                return ap->options[index].code;
        } else {
                return false;
        }
}

ap_error()

const char* ap_error

(

const struct arg_parser *const

ap

)

Get the string containing errors encountered during parsing.

Parameters

[in]

ap

pointer to arg-parser state

Returns

error string. If no errors occurred, this returns null

Definition at line 458 of file fg_argparser.c.

{
        return ap->error;
}

ap_free()

void ap_free

(

struct arg_parser *const

ap

)

Free internal state of arg-parser.

Parameters

[in]

ap

pointer to arg-parser state

Definition at line 448 of file fg_argparser.c.

{
        free_data(ap);
        if (ap->error) {
                free(ap->error);
                ap->error = 0;
        }
        ap->error_size = 0;
}

ap_free_mutex_state()

void ap_free_mutex_state

(

struct ap_Mutex_state *const

ms

)

Free a mutex context.

Parameters

[in]

ms

pointer to an initialized mutex context

Definition at line 583 of file fg_argparser.c.

{
        if (ms->seen_records) {
                free(ms->seen_records);
                ms->seen_records = 0;
                ms->num_mutex = 0;
        }
}

ap_init()

bool ap_init	(	struct arg_parser *const	ap,
		const int	argc,
		const char *const	argv[],
		const struct ap_Option	options[],
		const char	in_order
	)

Initialize the arg-parser given command line and user-defined options.

Parameters

[in]	ap	pointer to arg-parser state
[in]	argc	number of command line arguments
[in]	argv	array of command line argument strings
[in]	options	array of user-defined options to parse for. The last entry of the array needs to have '0' members. This array will be copied over to the arg-parser state ap.
[in]	in_order	if set to true, arguments are stored in the order in which they appear. If false, non-option arguments are stored after options

Returns

return true for success, or false for failure

Definition at line 374 of file fg_argparser.c.

{
        const char **non_options = 0;   /* skipped non-options */
        int non_options_size = 0;       /* number of skipped non-options */
        int argind = 1;                 /* index in argv */
 
        if (!copy_options(ap,options))
                return false;
 
        ap->num_mutex = get_mutex_count(options);
 
        ap->data = 0;
        ap->error = 0;
        ap->data_size = 0;
        ap->error_size = 0;
        if (argc < 2 || !argv || !options)
                return true;
 
        while (argind < argc) {
                const unsigned char ch1 = argv[argind][0];
                const unsigned char ch2 = (ch1 ? argv[argind][1] : 0);
 
                if (ch1 == '-' && ch2) {        /* we found an option */
                        const char *const opt = argv[argind];
                        const char *const arg =
                            (argind + 1 < argc) ? argv[argind + 1] : 0;
                        if (ch2 == '-') {
                                if (!argv[argind][2]) {
                                        ++argind;       /* we found "--" */
                                        break;
                                } else {
                                    if (!parse_long_option
                                        (ap, opt, arg, options, &argind))
                                        return false;
                                }
                        } else {
                            if (!parse_short_option
                                (ap, opt, arg, options, &argind))
                                return false;
                        }
                        if (ap->error)
                                break;
                } else {
                        if (!in_order) {
                                void *tmp = ap_resize_buffer(non_options, (non_options_size + 1) *
                                                             sizeof *non_options);
                                if (!tmp)
                                        return false;
                                non_options = (const char **)tmp;
                                non_options[non_options_size++] = argv[argind++];
                        } else if (!push_back_record(ap, ap->num_options, false, argv[argind++])) {
                                return false;
                        }
                }
        }
 
        if (ap->error) {
                free_data(ap);
        } else {
                for (int i = 0; i < non_options_size; ++i)
                        if (!push_back_record(ap, ap->num_options, false, non_options[i]))
                                return false;
                while (argind < argc)
                        if (!push_back_record(ap, ap->num_options, false, argv[argind++]))
                                return false;
        }
 
        if (non_options)
                free(non_options);
        return true;
}

ap_init_mutex_state()

bool ap_init_mutex_state	(	const struct arg_parser *const	ap,
		struct ap_Mutex_state *const	ms
	)

Initialize a new mutex state table.

This can be seen as a separate context for checking mutex. Thus, by initializing more than one mutex state, mutual exclusions of options may be evaluated in independent contexts.

Parameters

[in]	ap	pointer to arg-parser state
[in]	ms	pointer to a new mutex context. It can be used in the following to check and set mutual exclusions

Returns

return true for success, or false for failure

Definition at line 516 of file fg_argparser.c.

{
        ms->seen_records = malloc(sizeof(int)*ap->num_mutex);
        if(!ap->num_mutex || !ms->seen_records)
                return false;
        memset(ms->seen_records,0,sizeof(int)*ap->num_mutex);
        ms->num_mutex = ap->num_mutex;
        return true;
}

ap_is_used()

bool ap_is_used	(	const struct arg_parser *const	ap,
		int	code
	)

Returns true if the option specified by code was given at least once.

Parameters

[in]	ap	pointer to arg-parser state
[in]	code	code of the option to check return return true if the option specified by code has been parsed, otherwise false

Definition at line 503 of file fg_argparser.c.

{
        bool ret = false;
 
        for (int i=0; i < ap->data_size; i++)
                if (ap_code(ap, i) == code) {
                        ret = true;
                        break;
                }
 
        return ret;
}

ap_opt_string()

const char* ap_opt_string	(	const struct arg_parser *const	ap,
		const int	i
	)

Get the real command line option string (may be the short or long version).

Parameters

[in]	ap	pointer to arg-parser state
[in]	i	index of the parsed option

Returns

raw option string as seen on cmdline

Definition at line 486 of file fg_argparser.c.

{
        if (i >= 0 && i < ap_arguments(ap))
                return ap->data[i].opt_string;
        else
                return "";
}

ap_option()

const struct ap_Option* ap_option	(	const struct arg_parser *const	ap,
		const int	i
	)

Get the user-defined option for a given record position.

Parameters

[in]	ap	pointer to arg-parser state
[in]	i	index of the parsed option

Returns

pointer to the ap_Option struct of the parsed option at index i

Definition at line 494 of file fg_argparser.c.

{
        if (i >= 0 && i < ap_arguments(ap))
                return &ap->options[ap->data[i].option_index];
        else
                return false;
}

ap_reset_mutex()

void ap_reset_mutex

(

struct ap_Mutex_state *const

ms

)

Reset a mutex context.

Parameters

[in]

ms

pointer to an initialized mutex context

Definition at line 578 of file fg_argparser.c.

{
        memset(ms->seen_records,0,sizeof(int)*ms->num_mutex);
}

ap_resize_buffer()

static void* ap_resize_buffer ( void *  buf, const int  min_size  )

static

Assure at least a minimum size for buffer buf.

Parameters

[in]	buf	pointer to buffer
[in]	min_size	minimum size buf should hold in bytes

Returns

pointer to the newly allocated buffer

Definition at line 48 of file fg_argparser.c.

{
        if (buf)
                buf = realloc(buf, min_size);
        else
                buf = malloc(min_size);
        return buf;
}

ap_set_check_mutex()

bool ap_set_check_mutex	(	const struct arg_parser *const	ap,
		struct ap_Mutex_state *const	ms,
		const int	i,
		int *	conflict
	)

Check a new option record for mutex and register it at the same time.

Parameters

[in]	ap	pointer to arg-parser state
[in]	ms	pointer to an initialized mutex context
[in]	i	index of the option to register in the mutex state ms
[in]	conflict	pointer to a single integer value. This will contain the conflicting record position, if a conflict has been found

Returns

return true if conflict according to the state given by ms has occurred, otherwise false

Definition at line 569 of file fg_argparser.c.

{
        bool ret = ap_check_mutex(ap, ms, i, conflict);
        ap_set_mutex(ap, ms, i);
        return ret;
}

ap_set_mutex()

bool ap_set_mutex	(	const struct arg_parser *const	ap,
		struct ap_Mutex_state *const	ms,
		const int	i
	)

Register an option record in a mutex context.

Parameters

[in]	ap	pointer to arg-parser state
[in]	ms	pointer to an initialized mutex context
[in]	i	index of the option to register in the mutex state ms

Returns

return true for success, or false for failure

Definition at line 553 of file fg_argparser.c.

{
        if(ap->num_mutex != ms->num_mutex)
                return false;
 
        if (i < 0 || i >= ap_arguments(ap) || !ap->num_mutex)
                return false;
 
        int index = ap->data[i].option_index;
        for (int *mutex = ap->options[index].mutex; mutex && *mutex; mutex++)
                ms->seen_records[*mutex-1] = i+1;
 
        return true;
}

copy_options()

static bool copy_options ( struct arg_parser *const  ap, const struct ap_Option  options[]  )

static

Copy options into the arg-parser ap.

This is a deep copy including strings and arrays.

Parameters

[in]	ap	arg-parser
[in]	options	options struct to copy

Returns

return true for success, or false for failure

Definition at line 341 of file fg_argparser.c.

{
 
        ap->num_options = get_num_options(options);
        if (!ap->num_options)
                return false;
        ap->options = malloc(sizeof(struct ap_Option)*ap->num_options);
        if (!ap->options)
                return false;
 
        for (int i=0; i < ap->num_options; i++) {
                ap->options[i] = options[i];
                if (options[i].name)
                        ap->options[i].name = strdup(options[i].name);
 
                if (options[i].mutex) {
                        /* get number of mutex items */
                        int num;
                        for (num = 0; options[i].mutex[num]; num++);
 
                        /* now copy into new array */
                        ap->options[i].mutex = malloc(sizeof(int)*
                                                (num+1));
                        if (!ap->options[i].mutex)
                                return false;
                        for (int e=0; e<=num; e++)
                                ap->options[i].mutex[e] = options[i].mutex[e];
                }
        }
        return true;
}

free_data()

static void free_data ( struct arg_parser *const  ap )

static

Free all space required by the arg-parser ap.

Parameters

[in]

ap

pointer to the arg-parser state

Definition at line 122 of file fg_argparser.c.

{
        for (int i = 0; i < ap->data_size; ++i) {
                free(ap->data[i].argument);
                free(ap->data[i].opt_string);
        }
        if (ap->data) {
                free(ap->data);
                ap->data = 0;
        }
        ap->data_size = 0;
 
        for (int i = 0; i < ap->num_options; ++i) {
                free(ap->options[i].name);
                free(ap->options[i].mutex);
        }
        free(ap->options);
        ap->num_options = 0;
}

get_mutex_count()

static int get_mutex_count ( const struct ap_Option  options[] )

static

Get the number of mutex in the option definitions.

Searching for the greatest mutex ID in all options.

Parameters

[in]

options

array of user-defined options

Returns

number of mutex in the option definitions

Definition at line 321 of file fg_argparser.c.

{
        int num = 0;
 
        for (int i=0; options[i].code; i++)
                for (int *mutex = options[i].mutex; mutex && *mutex; mutex++)
                        ASSIGN_MAX(num, *mutex);
 
        return num;
}

get_num_options()

static int get_num_options ( const struct ap_Option  options[] )

static

Determines number of options in options.

Counting all options until an option with code 0 is found.

Parameters

[in]

options

array of user-defined options

Returns

number of options in options

Definition at line 306 of file fg_argparser.c.

{
        int i;
        for (i=0; options[i].code; i++){}
        return i;
}

parse_long_option()

static bool parse_long_option ( struct arg_parser *const  ap, const char *const  opt, const char *const  arg, const struct ap_Option  options[], int *const  argindp  )

static

Parses a long option and adds it to the record of arg-parser ap.

Parameters

[in]	ap	pointer to the arg-parser state
[in]	opt	long option string
[in]	arg	option argument string
[in]	options	array containing all defined options which may be parsed
[in]	argindp	pointer to the index in the command line argument array. The value will be automatically updated

Returns

return true for success, or false for failure

Definition at line 153 of file fg_argparser.c.

{
        unsigned len;
        int index = -1;
        char exact = 0, ambig = 0;
 
        for (len = 0; opt[len + 2] && opt[len + 2] != '='; ++len) ;
 
        /* Test all long options for either exact match or abbreviated matches */
        for (int i = 0; options[i].code != 0; ++i)
                if (options[i].name
                    && strncmp(options[i].name, &opt[2], len) == 0) {
                        /* Exact match found */
                        if (strlen(options[i].name) == len) {
                                index = i;
                                exact = 1;
                                break;
                        /* First nonexact match found */
                        } else if (index < 0) {
                                index = i;
                        /* Second or later nonexact match found */
                        } else if (options[index].code != options[i].code ||
                                 options[index].has_arg != options[i].has_arg) {
                                ambig = 1;
                        }
                }
 
        if (ambig && !exact) {
                add_error(ap, "option '");
                add_error(ap, opt);
                add_error(ap, "' is ambiguous");
                return true;
        }
 
        /* nothing found */
        if (index < 0) {
                add_error(ap, "unrecognized option '");
                add_error(ap, opt);
                add_error(ap, "'");
                return true;
        }
 
        ++*argindp;
 
        /* '--<long_option>=<argument>' syntax */
        if (opt[len + 2]) {
                if (options[index].has_arg == ap_no) {
                        add_error(ap, "option '--");
                        add_error(ap, options[index].name);
                        add_error(ap, "' doesn't allow an argument");
                        return true;
                }
                if (options[index].has_arg == ap_yes && !opt[len + 3]) {
                        add_error(ap, "option '--");
                        add_error(ap, options[index].name);
                        add_error(ap, "' requires an argument");
                        return true;
                }
                return push_back_record(ap, index, true, &opt[len + 3]);
        }
 
        if (options[index].has_arg == ap_yes) {
                if (!arg || !arg[0]) {
                        add_error(ap, "option '--");
                        add_error(ap, options[index].name);
                        add_error(ap, "' requires an argument");
                        return true;
                }
                ++*argindp;
                return push_back_record(ap, index, true, arg);
        }
 
        return push_back_record(ap, index, true, "");
}

parse_short_option()

static bool parse_short_option ( struct arg_parser *const  ap, const char *const  opt, const char *const  arg, const struct ap_Option  options[], int *const  argindp  )

static

Parses a short option and adds it to the record of arg-parser ap.

Parameters

[in]	ap	pointer to the arg-parser state
[in]	opt	long option string
[in]	arg	option argument string
[in]	options	array containing all defined options which may be parsed
[in]	argindp	pointer to the index in the command line argument array. The value will be automatically updated

Returns

return true for success, or false for failure

Definition at line 242 of file fg_argparser.c.

{
        int cind = 1;   /* character index in opt */
 
        while (cind > 0) {
                int index = -1;
                const unsigned char code = opt[cind];
                char code_str[2];
                code_str[0] = code;
                code_str[1] = 0;
 
                if (code != 0)
                        for (int i = 0; options[i].code; ++i)
                                if (code == options[i].code) {
                                        index = i;
                                        break;
                                }
 
                if (index < 0) {
                        add_error(ap, "invalid option -- ");
                        add_error(ap, code_str);
                        return true;
                }
 
                /* opt finished */
                if (opt[++cind] == 0) {
                        ++*argindp;
                        cind = 0;
                }
 
                if (options[index].has_arg != ap_no && cind > 0 && opt[cind]) {
                        if (!push_back_record(ap, index, false, &opt[cind]))
                                return false;
                        ++*argindp;
                        cind = 0;
                } else if (options[index].has_arg == ap_yes) {
                        if (!arg || !arg[0]) {
                                add_error(ap, "option requires an argument -- ");
                                add_error(ap, code_str);
                                return true;
                        }
                        ++*argindp;
                        cind = 0;
                        if (!push_back_record(ap, index, false, arg))
                                return false;
                } else if (!push_back_record(ap, index, false, "")) {
                        return false;
                }
        }
 
        return true;
}

push_back_record()

static bool push_back_record ( struct arg_parser *const  ap, const int  option_index, bool  long_opt, const char *const  argument  )

static

Store a parsed option in the state of the arg-parser given by ap.

Parameters

[in]	ap	pointer to the arg-parser state
[in]	option_index	index of the option to store
[in]	long_opt	true if this option was a long option
[in]	argument	argument string for this option (may be empty)

Returns

return true for success, or false for failure

Definition at line 66 of file fg_argparser.c.

{
        const int len = strlen(argument);
        struct ap_Record *p;
        void *tmp = ap_resize_buffer(ap->data,
                                     (ap->data_size + 1) * sizeof(struct ap_Record));
        if (!tmp)
                return false;
        ap->data = (struct ap_Record *)tmp;
        p = &(ap->data[ap->data_size]);
        p->option_index = option_index;
        p->argument = 0;
        tmp = ap_resize_buffer(p->argument, len + 1);
        if (!tmp)
                return false;
        p->argument = (char *)tmp;
        strncpy(p->argument, argument, len + 1);
 
        if (long_opt) {
                if (!asprintf(&p->opt_string, "--%s", ap->options[option_index].name))
                        return false;
        } else {
                if (!asprintf(&p->opt_string, "-%c", ap->options[option_index].code))
                        return false;
        }
 
        ++ap->data_size;
        return true;
}