cmdapp.h File Reference

#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>

Go to the source code of this file.

Data Structures
struct	cmdopt_t
struct	cmdapp_info_t
struct	cmdargs_t
struct	cmdapp_t

Macros
#define	EXIT_FAILURE   1
#define	EXIT_SUCCESS   0
#define	CMDOPT_EXISTS   0b00000001
#define	CMDOPT_OPTIONAL   0b00000010
#define	CMDOPT_TAKESARG   0b00000100
#define	CMDOPT_MAYTAKEARG   0b00001000
#define	CMDAPP_MODE_MULTIFLAG   0b00000000
#define	CMDAPP_MODE_SHORTARG   0b00000001
#define	CMDAPP_MODE_SILENT   0b00000000
#define	CMDAPP_MODE_PRINT   0b00000010
#define	_CMDAPP_MODE_EXIT   0b10000000
#define	cmdopt_exists(opt)   ((opt).flags & CMDOPT_EXISTS)
#define	cmdopt_is_optional(opt)   ((opt).flags | CMDOPT_OPTIONAL)
#define	cmdapp_should_exit(app)   ((app)->_mode & _CMDAPP_MODE_EXIT)

Typedefs
typedef uint8_t	cmdopt_flags_t
typedef uint8_t	cmdapp_mode_t
typedef struct _cmdopt_internal_t	cmdopt_internal_t
typedef void(*	cmdapp_procedure_t) (void *data, cmdopt_t *option, const char *arg)

Functions
void	cmdapp_init (cmdapp_t *app, int argc, char **argv, cmdapp_mode_t mode, const cmdapp_info_t *info)
void	cmdapp_destroy (cmdapp_t *app)
void	cmdapp_set (cmdapp_t *app, char shorto, const char *longo, uint8_t flags, cmdopt_t **conflicts, const char *description, const char *argtype, cmdopt_t *option)
void	cmdapp_print_help (cmdapp_t *app)
void	cmdapp_print_version (cmdapp_t *app)
void	cmdapp_enable_procedure (cmdapp_t *app, cmdapp_procedure_t proc, void *user_data)
int	cmdapp_run (cmdapp_t *app)
cmdargs_t *	cmdapp_getargs (cmdapp_t *app)
void	cmdapp_error (cmdapp_t *app, const char *fmt,...)

Macro Definition Documentation

_CMDAPP_MODE_EXIT

#define _CMDAPP_MODE_EXIT   0b10000000

Definition at line 53 of file cmdapp.h.

CMDAPP_MODE_MULTIFLAG

#define CMDAPP_MODE_MULTIFLAG   0b00000000

Definition at line 49 of file cmdapp.h.

CMDAPP_MODE_PRINT

#define CMDAPP_MODE_PRINT   0b00000010

Definition at line 52 of file cmdapp.h.

CMDAPP_MODE_SHORTARG

#define CMDAPP_MODE_SHORTARG   0b00000001

Definition at line 50 of file cmdapp.h.

CMDAPP_MODE_SILENT

#define CMDAPP_MODE_SILENT   0b00000000

Definition at line 51 of file cmdapp.h.

cmdapp_should_exit

#define cmdapp_should_exit

(

app

)

((app)->_mode & _CMDAPP_MODE_EXIT)

Definition at line 96 of file cmdapp.h.

CMDOPT_EXISTS

#define CMDOPT_EXISTS   0b00000001

Definition at line 44 of file cmdapp.h.

cmdopt_exists

#define cmdopt_exists

(

opt

)

((opt).flags & CMDOPT_EXISTS)

Definition at line 56 of file cmdapp.h.

cmdopt_is_optional

#define cmdopt_is_optional

(

opt

)

((opt).flags | CMDOPT_OPTIONAL)

Definition at line 58 of file cmdapp.h.

CMDOPT_MAYTAKEARG

#define CMDOPT_MAYTAKEARG   0b00001000

Definition at line 47 of file cmdapp.h.

CMDOPT_OPTIONAL

#define CMDOPT_OPTIONAL   0b00000010

Definition at line 45 of file cmdapp.h.

CMDOPT_TAKESARG

#define CMDOPT_TAKESARG   0b00000100

Definition at line 46 of file cmdapp.h.

EXIT_FAILURE

#define EXIT_FAILURE   1

Definition at line 27 of file cmdapp.h.

EXIT_SUCCESS

#define EXIT_SUCCESS   0

Definition at line 30 of file cmdapp.h.

Typedef Documentation

cmdapp_mode_t

typedef uint8_t cmdapp_mode_t

Definition at line 34 of file cmdapp.h.

cmdapp_procedure_t

typedef void(* cmdapp_procedure_t) (void *data, cmdopt_t *option, const char *arg)

Definition at line 78 of file cmdapp.h.

cmdopt_flags_t

typedef uint8_t cmdopt_flags_t

Definition at line 33 of file cmdapp.h.

cmdopt_internal_t

typedef struct _cmdopt_internal_t cmdopt_internal_t

Definition at line 60 of file cmdapp.h.

Function Documentation

cmdapp_destroy()

void cmdapp_destroy

(

cmdapp_t *

app

)

Definition at line 59 of file cmdapp.c.

                                   {
    for (size_t i = 0; i < app->_length; i++) {
        free(app->_start[i]);
    }
    free(app->_start);
    free(app->_args.contents);
    app->_args.contents = NULL;
}

cmdapp_enable_procedure()

void cmdapp_enable_procedure	(	cmdapp_t *	app,
		cmdapp_procedure_t	proc,
		void *	user_data )

Definition at line 111 of file cmdapp.c.

                                                                                      {
    app->_proc = proc;
    app->_user_data = user_data;
}

cmdapp_error()

void cmdapp_error	(	cmdapp_t *	app,
		const char *	fmt,
			... )

Definition at line 364 of file cmdapp.c.

                                                       {
    #ifdef _POSIX_VERSION
    if (isatty(STDERR_FILENO) || (getenv("CMDAPP_COLOR_ALWAYS") != NULL)) {
        fprintf(stderr, "%s: {R+}error:{0} ", app->_info.program);
    } else {
        fprintf(stderr, "%s: error: ", app->_info.program);
    }
    #else
    fprintf(stderr, "%s: error: ", app->_info.program);
    #endif /* _POSIX_VERSION */
    va_list valist;
    va_start(valist, fmt);
    vfprintf(stderr, fmt, valist);
    va_end(valist);
}

cmdapp_getargs()

cmdargs_t * cmdapp_getargs

(

cmdapp_t *

app

)

Definition at line 352 of file cmdapp.c.

                                         {
    if (app->_args.contents == NULL) {
        return NULL;
    }
    return &app->_args;
}

cmdapp_init()

void cmdapp_init	(	cmdapp_t *	app,
		int	argc,
		char **	argv,
		cmdapp_mode_t	mode,
		const cmdapp_info_t *	info )

Definition at line 43 of file cmdapp.c.

                                            {
    app->_argc = argc;
    app->_argv = argv;
    app->_mode = mode;
    app->_custom_help = 0;
    app->_custom_ver = 0;
    app->_length = 0;
    app->_capacity = 4;
    app->_start = malloc(sizeof(cmdarg_internal_t*) * app->_capacity);
    app->_args.length = 0;
    app->_args.contents = NULL;
    app->_info = *info;
    app->_proc = NULL;
}

cmdapp_print_help()

void cmdapp_print_help

(

cmdapp_t *

app

)

Definition at line 116 of file cmdapp.c.

                                      {
    if (app->_info.synopses && *app->_info.synopses) {
        tcol_printf("{Y}Usage:{0} {+}%s{0} %s\n", app->_argv[0], *app->_info.synopses);
        for (size_t i = 1; app->_info.synopses[i]; i++) {
            printf("   or: {+}%s{0} %s\n", app->_argv[0], app->_info.synopses[i]);
        }
    } else {
        tcol_printf("{Y}Usage:{0} {+}%s{0} {G}[OPTION]{-}...{0} {M}ARG {-}...{0}\n", app->_argv[0]);
    }
    printf("\n");
    tcol_printf("{-}%s{0}\n", app->_info.description);
    if (!app->_length)
        return;
    printf("\n");
    tcol_printf("{Y}Options:{0}\n");
    for (size_t i = 0; i < app->_length; i++) {
        cmdarg_internal_t* arg_int = app->_start[i];
        tcol_printf("%*s", app->_info.help_des_offset, "");
        tcol_printf(arg_int->description);
        tcol_printf("\r");
        if(arg_int->result->shorto) {
          tcol_printf("  {G}-%c{0}", arg_int->result->shorto);
        } else {
          tcol_printf("   {G}-{0}");
        }
        if (arg_int->result->longo) {
            tcol_printf(", {G}--%s{0}", arg_int->result->longo);
        }
        if (arg_int->result->flags & CMDOPT_TAKESARG) {
          tcol_printf("{M}=");
          if (!arg_int->result->argtype)
            tcol_printf("ARG");
          else
            tcol_printf(arg_int->result->argtype);
          tcol_printf("{0}");
        }
        else if (arg_int->result->flags & CMDOPT_MAYTAKEARG) {
          tcol_printf("{M}(=");
          if (!arg_int->result->argtype)
            tcol_printf("ARG");
          else
            tcol_printf(arg_int->result->argtype);
          tcol_printf("){0}");
        }
        fputc('\n', stdout);
    }
    if (!app->_custom_help) {
        tcol_printf("%*s%s\r  {+G}--help{0}\n", app->_info.help_des_offset, "",
               "Display this information");
    }
    if (!app->_custom_ver) {
        tcol_printf("%*s%s\r  {+G}--version{0}\n", app->_info.help_des_offset, "",
               "Display program version information");
    }
}

cmdapp_print_version()

void cmdapp_print_version

(

cmdapp_t *

app

)

Definition at line 172 of file cmdapp.c.

                                         {
    printf("%s %s\n", app->_info.program, app->_info.version);
    printf("Copyright (C) %d %s\n", app->_info.year, app->_info.author);
    printf("%s", app->_info.ver_extra);
}

cmdapp_run()

int cmdapp_run

(

cmdapp_t *

app

)

Definition at line 222 of file cmdapp.c.

                              {
    if (app->_args.contents != NULL) {
        app->_args.contents = realloc(app->_args.contents, sizeof(char*) * 4);
        app->_args.length = 0;
    } else {
        app->_args.contents = malloc(sizeof(char*) * 4);
    }
    size_t args_cap = 4;
    #define APPEND_ARG(arg) if (app->_args.length + 1 > args_cap) { \
        args_cap += (args_cap / 2); \
        app->_args.contents = realloc(app->_args.contents, \
                                      sizeof(char*) * args_cap); \
    } \
    if (app->_proc) { \
        app->_proc(app->_user_data, NULL, arg); \
    } \
    app->_args.contents[app->_args.length++] = arg;
 
    bool only_args = false;
    for (int i = 0; i < app->_argc; i++) {
        char* current = app->_argv[i];
        if (only_args) {
            APPEND_ARG(current);
            continue;
        }
        const char* next = app->_argv[i + 1];
        if (IS_END_OF_FLAGS(current)) {
            only_args = true;
            continue;
        }
        cmdarg_internal_t* arg_int;
        if (IS_LONG_FLAG(current)) {
            // Find the `=` for longopt args.
            char* arg = strchr(current, '=');
            // Move the pointer to the start of the longopt's args
            if (arg) {
                *arg = 0;
                arg++;
            }
            if ((arg_int = cmdapp_search(app, 0, current + 2))) {
                if (arg_int->result->flags & CMDOPT_TAKESARG) {
                    if (arg == NULL || *arg == 0) {
                        eprintf("%s expects an argument\n", current);
                        return EXIT_FAILURE;
                    }
                    arg_int->result->value = arg;
                } else if (arg_int->result->flags & CMDOPT_MAYTAKEARG) {
                    arg_int->result->value = arg;
                } else {
                    if (arg != NULL) {
                        eprintf("%s does not take arguments\n", current);
                        return EXIT_FAILURE;
                    }
                }
            } else {
                if (strncmp(current, "--help", 7) == 0) {
                    cmdapp_print_help(app);
                    app->_mode |= _CMDAPP_MODE_EXIT;
                    return EXIT_SUCCESS;
                } else if (strncmp(current, "--version", 10) == 0) {
                    cmdapp_print_version(app);
                    app->_mode |= _CMDAPP_MODE_EXIT;
                    return EXIT_SUCCESS;
                }
                eprintf("Unrecognized command line option %s, try --help\n", current);
                return EXIT_FAILURE;
            }
            arg_int->result->flags |= CMDOPT_EXISTS;
            if (app->_proc) {
                app->_proc(app->_user_data, arg_int->result, NULL);
            }
        } else if (IS_SHORT_FLAG(current)) {
            if (app->_mode & CMDAPP_MODE_SHORTARG) {
                if ((arg_int = cmdapp_search(app, current[1], NULL))) {
                    arg_int->result->value = NULL;
                    if (arg_int->result->flags | CMDOPT_TAKESARG) {
                        arg_int->result->value = current + 2;
                        if (!current[2] && next && next[0] != '-') {
                            arg_int->result->value = next;
                            i++;
                        } else if (current[2] == 0) {
                            eprintf("-%c expects an argument\n", current[1]);
                            return EXIT_FAILURE;
                        }
                    } else if ((current[2] != 0) || (next && next[0] != '-')) {
                        eprintf("-%c does not take arguments\n", current[1]);
                        return EXIT_FAILURE;
                    }
                } else {
                    eprintf("Unrecognized command line option -%c, try --help\n",
                            current[1]);
                    return EXIT_FAILURE;
                }
                arg_int->result->flags |= CMDOPT_EXISTS;
                if (app->_proc) {
                    app->_proc(app->_user_data, arg_int->result, NULL);
                }
            } else /* app->_mode | CMDAPP_MODE_MULTIFLAG */ {
                for (size_t j = 1; current[j]; j++) {
                    if ((arg_int = cmdapp_search(app, current[1], NULL))) {
                        arg_int->result->value = current + 2;
                        if (arg_int->result->value[2] == 0) {
                            if (next && next[0] != '-') {
                                arg_int->result->value = next;
                                i++;
                            } else {
                                eprintf("-%c expects an argument\n", current[1]);
                                return EXIT_FAILURE;
                            }
                        }
                    } else {
                        eprintf("Unrecognized command line option -%c\n",
                                current[1]);
                        return EXIT_FAILURE;
                    }
                }
            }
        } else {
            APPEND_ARG(current);
        }
    }
    #undef APPEND_ARG
 
    if (cmdapp_resolve_options(app) != EXIT_SUCCESS) {
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}

cmdapp_set()

void cmdapp_set	(	cmdapp_t *	app,
		char	shorto,
		const char *	longo,
		uint8_t	flags,
		cmdopt_t **	conflicts,
		const char *	description,
		const char *	argtype,
		cmdopt_t *	option )

Definition at line 77 of file cmdapp.c.

{
 
     if (strncmp(longo, "help", 5) == 0) {
        app->_custom_help = 1;
    } else if (strncmp(longo, "version", 8) == 0) {
        app->_custom_ver = 1;
    }
 
    option->shorto = shorto;
    option->longo = longo;
    option->argtype = argtype;
    option->flags = flags;
    option->value = NULL;
    const size_t conflict_count = (conflicts == NULL)
                                      ? 1
                                      : _argvlen((void**)conflicts) + 1;
    const size_t size = sizeof(cmdarg_internal_t)
                        + conflict_count * sizeof(cmdopt_t*);
    cmdarg_internal_t* arg_int = malloc(size);
    arg_int->result = option;
    arg_int->description = description;
    if (conflicts == NULL) {
        arg_int->conflicts[0] = NULL;
    } else {
        memcpy(arg_int->conflicts, conflicts, conflict_count
                                              * sizeof(cmdopt_t*));
    }
    cmdapp_append(app, arg_int);
}