option.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <jwsc/config.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <assert.h>

#include "jwsc/base/option.h"
#include "jwsc/base/error.h"
#include "jwsc/base/file_io.h"

#ifdef JWSC_HAVE_DMALLOC
#include <dmalloc.h>
#endif


static int is_option(const char* arg)
{
    int c;

    if (strlen(arg) == 2 && arg[0] == '-' 
            && !((c=arg[1]) < 48 || (57 < c && c < 65) || (90 < c && c < 97)))
    {
        return 1;
    }

    if (strlen(arg) < 3 || arg[0] != '-' || arg[1] != '-')
    {
        return 0;
    }
                                                           
    c = arg[2];
                                                           
    if (c < 48 || (57 < c && c < 65) || (90 < c && c < 97))
    {
        return 0;
    }
                                                           
    return 1;
}


static int is_option_string(const char* arg, Option_string str)
{
    int arg_len;
    int str_len;
    const char* c;

    arg_len = 0;
    c = arg;
    while (*c != '\0' && *c != '=')
    {
        c++;
        arg_len++;
    }

    str_len = strlen(str);

    if (arg_len < str_len)
    {
        return (strncmp(arg, str, str_len) == 0);
    }

    return (strncmp(arg, str, arg_len) == 0);
}


static int is_cmd_line_option_string(const char* arg, Option_string str)
{
    int arg_len;

    arg_len = strlen(arg);

    if (arg_len < 3 || arg[0] != '-' || arg[1] != '-')
    {
        return 0;
    }

    return is_option_string((arg+2), str);
}


static int is_option_flag(const char* arg, Option_flag flag)
{
    if (strlen(arg) != 2 || arg[0] != '-')
    {
        return 0;
    }

    return (arg[1] == flag);
}


static Option_arg get_option_string_arg(const char* str)
{
    int len;
    int i;
    Option_arg arg = NULL;

    len = strlen(str);

    for (i = 0; i < len; i++)
    {
        if (str[ i ] == '=' && i+1 < len)
        {
            arg = &(str[ i+1 ]);
            break;
        }
    }

    return arg;
}


static Option_arg get_option_flag_arg
(
    int          argc, 
    const char** argv, 
    int          index
)
{
    if (argc == index)
    {
        return NULL;
    }

    return argv[ index ];
}


void init_option_with_arg
(
    Option_with_arg*     opt,
    Option_string        str, 
    Option_flag          flag, 
    Option_desc          desc,
    Option_func_with_arg func
)
{
    assert(opt != NULL);
    assert(str != NULL || flag != '\0');
    assert(func != NULL);

    opt->string = str;
    opt->flag   = flag;
    opt->desc   = desc;
    opt->func   = func;
}


void init_option_no_arg
(
    Option_no_arg*     opt,
    Option_string      str, 
    Option_flag        flag, 
    Option_desc        desc,
    Option_func_no_arg func
)
{
    assert(opt != NULL);
    assert(str != NULL || flag != '\0');
    assert(func != NULL);

    opt->string = str;
    opt->flag   = flag;
    opt->desc   = desc;
    opt->func   = func;
}


Error* process_option_with_arg
(
    int              argc, 
    const char**     argv, 
    int*             argi,
    Option_with_arg* opt
)
{
    int i;
    Option_arg arg = NULL;
    Error* e;

    *argi = 1;
    for (i = 1; i < argc; i++)
    {
        if (!is_option(argv[ i ]))
        {
            (*argi)++; continue;
        }

        if (is_cmd_line_option_string(argv[ i ], opt->string))
        {
            arg = get_option_string_arg(argv[ i ]);
            if ((e = opt->func(arg)) != NULL)
            {
                return e;
            }
            break;
        }
        else if (is_option_flag(argv[ i ], opt->flag))
        {
            arg = get_option_flag_arg(argc, argv, i+1);
            if ((e = opt->func(arg)) != NULL)
            {
                return e;
            }
            (*argi)++; i++;
            break;
        }

        (*argi)++;
    }

    return NULL;
}


Error* process_option_no_arg
(
    int            argc, 
    const char**   argv, 
    int*           argi,
    Option_no_arg* opt
)
{
    int i;
    Error* e;

    *argi = 1;
    for (i = 1; i < argc; i++)
    {
        if (!is_option(argv[ i ]))
        {
            (*argi)++; continue;
        }

        if (is_cmd_line_option_string(argv[ i ], opt->string) || 
            is_option_flag(argv[ i ], opt->flag))
        {
            if ((e = opt->func()) != NULL)
            {
                return e;
            }
            break;
        }

        (*argi)++;
    }

    return NULL;
}


Error* process_options
(
    int              argc, 
    const char**     argv, 
    int*             argi,
    int              num_opts_no_arg,
    Option_no_arg*   opts_no_arg,
    int              num_opts_with_arg,
    Option_with_arg* opts_with_arg
)
{
    int i;
    int opt;
    int found;

    Option_with_arg* opt_with_arg;
    Option_no_arg*   opt_no_arg;
    Option_arg       arg = NULL;
    Error*           e;

    *argi = 1;
    for (i = 1; i < argc; i++)
    {
        if (!is_option(argv[ i ]))
        {
            return NULL;
        }

        found = 0;

        for (opt = 0; opt < num_opts_with_arg; opt++)
        {
            opt_with_arg = &(opts_with_arg[ opt ]);

            if (is_cmd_line_option_string(argv[ i ], opt_with_arg->string))
            {
                arg = get_option_string_arg(argv[ i ]);
                if ((e = opt_with_arg->func(arg)) != NULL)
                {
                    return e;
                }
                found = 1;
                break;
            }
            else if (is_option_flag(argv[ i ], opt_with_arg->flag))
            {
                arg = get_option_flag_arg(argc, argv, i+1);
                if ((e = opt_with_arg->func(arg)) != NULL)
                {
                    return e;
                }
                found = 1;
                (*argi)++; i++;
                break;
            }
        }
        for (opt = 0; opt < num_opts_no_arg; opt++)
        {
            opt_no_arg = &(opts_no_arg[ opt ]);

            if (is_cmd_line_option_string(argv[ i ], opt_no_arg->string) || 
                    is_option_flag(argv[ i ], opt_no_arg->flag))
            {
                if ((e = opt_no_arg->func()) != NULL)
                {
                    return e;
                }
                found = 1;
                break;
            }
        }

        if (!found)
        {
            const char* fmt = "Invalid option '%s'";
            int len = strlen(argv[ i ]) + strlen(fmt);
            char* msg = calloc(len+1,sizeof(char));
            sprintf(msg, fmt, argv[ i ]);
            e = JWSC_EARG(msg);
            free(msg);
            return e;
        }

        (*argi)++;
    }

    return NULL;
}


static void terminate_option_string(char* str)
{
    char* c;

    c = str;

    while (*c != ' ' && *c != '\t' && *c != '\0')  c++;

    *c = '\0';
}


Error* process_options_from_file
(
    const char*      fname,
    int              num_opts_no_arg,
    Option_no_arg*   opts_no_arg,
    int              num_opts_with_arg,
    Option_with_arg* opts_with_arg
)
{
    int opt;
    int found;
    int opt_str_len;

    char line[256] = {0};
    char* opt_str;

    FILE* fp;

    Option_with_arg* opt_with_arg;
    Option_no_arg*   opt_no_arg;
    Option_arg       arg = NULL;
    Error*           e;


    if ((fp = fopen(fname, "r")) == NULL)
    {
        return JWSC_EIO(strerror(errno));
    }

    while (skip_fp_spaces_and_comments(fp))
    {
        assert(fscanf(fp, "%255s", line) == 1);
        terminate_option_string(line);
        opt_str_len = strlen(line);
        assert((opt_str = malloc((opt_str_len+1)*sizeof(char))) != NULL);
        strcpy(opt_str, line);
        opt_str[opt_str_len] = '\0';

        found = 0;

        for (opt = 0; opt < num_opts_with_arg; opt++)
        {
            opt_with_arg = &(opts_with_arg[ opt ]);

            if (is_option_string(opt_str, opt_with_arg->string))
            {
                arg = get_option_string_arg(opt_str);
                if ((e = opt_with_arg->func(arg)) != NULL)
                {
                    return e;
                }
                found = 1;
                break;
            }
        }
        for (opt = 0; opt < num_opts_no_arg; opt++)
        {
            opt_no_arg = &(opts_no_arg[ opt ]);

            if (is_option_string(opt_str, opt_no_arg->string))
            {
                if ((e = opt_no_arg->func()) != NULL)
                {
                    return e;
                }
                found = 1;
                break;
            }
        }

        if (!found)
        {
            const char* fmt = "Invalid option '%s'";
            int len = opt_str_len + strlen(fmt);
            char* msg = calloc(len+1,sizeof(char));
            sprintf(msg, fmt, opt_str);
            e = JWSC_EARG(msg);
            free(msg);
            return e;
        }
    }

    if (fclose(fp) != 0)
    {
        return JWSC_EIO(strerror(errno));
    }

    return NULL;
}


void print_option_with_arg
(
    FILE*            fp,
    int              opt_width,
    Option_with_arg* opt
)
{
    int flag_width;
    int comma_width;
    int string_width;
    int min_width;

    int opt_padding;
    int desc_max_len;
    int num_lines;
    int len;
    int orig_opt_width;
    int opt_too_long;

    char  desc_buff[81] = {0};
    char* desc_buff_word_ptr;
    char* desc_buff_ptr;
    const char* desc_char_word_ptr;
    const char* desc_char_ptr;

    flag_width   = 3;
    string_width = (opt->string != NULL) ? 3 + strlen(opt->string) + 4 : 0;
    comma_width  = 1;
    min_width    = flag_width + comma_width + string_width + 2;

    orig_opt_width = (opt_width >= 0) ? opt_width : 0;

    if (opt_width <= 0 || opt_width < min_width)
    {
        opt_width = min_width;
    }

    assert(opt_width <= 60);
    len = 0;

    opt_padding  = opt_width - min_width;

    if (opt->flag != '\0')
        len += fprintf(fp, " -%c", opt->flag);
    else
        len += fprintf(fp, "   ");

    if (opt->flag != '\0' && string_width > 0)
        len += fprintf(fp, ",");
    else
        len += fprintf(fp, " ");

    if (string_width > 0)
        len += fprintf(fp, " --%s=ARG", opt->string);
    if (opt_padding > 0)
        len += fprintf(fp, "%*s", opt_padding, "");
    len += fprintf(fp, "  ");

    opt_too_long = len > orig_opt_width;

    desc_max_len  = 80 - opt_width;

    num_lines = 1;

    if (opt->desc == NULL || strlen(opt->desc) == 0)
    {
        fprintf(fp, "\n");
        return;
    }

    if (opt_too_long)
    {
        fprintf(fp, "\n");
        num_lines++;
    }

    desc_buff_word_ptr = desc_buff;
    desc_buff_ptr      = desc_buff;
    desc_char_word_ptr = opt->desc;
    desc_char_ptr      = opt->desc;

    len = 0;

    while (*desc_char_ptr != '\0')
    {
        if (len == desc_max_len)
        {
            if (desc_buff == desc_buff_word_ptr)
            {
                desc_char_word_ptr = desc_char_ptr;
            }
            else
            {
                desc_char_ptr = desc_char_word_ptr;
                *desc_buff_word_ptr = '\0';
            }

            if (num_lines > 1)
            {
                fprintf(fp, "%*s", orig_opt_width, "");
            }

            desc_buff_ptr = desc_buff;
            while (*desc_buff_ptr == ' ')
                desc_buff_ptr++;
            fprintf(fp, "%s\n", desc_buff_ptr);

            desc_buff_word_ptr = desc_buff;
            desc_buff_ptr      = desc_buff;

            len = 0;
            num_lines++;
        }

        *desc_buff_ptr = *desc_char_ptr;
        desc_char_ptr++;
        desc_buff_ptr++;
        len++;

        if (*desc_char_ptr == ' ')
        {
            desc_buff_word_ptr = desc_buff_ptr;
            desc_char_word_ptr = desc_char_ptr;
        }
    }

    *desc_buff_ptr = *desc_char_ptr;

    if (*desc_buff != '\0')
    {
        if (num_lines > 1)
        {
            fprintf(fp, "%*s", orig_opt_width, "");
        }

        desc_buff_ptr = desc_buff;
        while (*desc_buff_ptr == ' ')
            desc_buff_ptr++;
        fprintf(fp, "%s\n", desc_buff_ptr);
    }
}


void print_option_no_arg
(
    FILE*          fp,
    int            opt_width,
    Option_no_arg* opt
)
{
    int flag_width;
    int comma_width;
    int string_width;
    int min_width;

    int opt_padding;
    int desc_max_len;
    int num_lines;
    int len;
    int orig_opt_width;

    char  desc_buff[81] = {0};
    char* desc_buff_word_ptr;
    char* desc_buff_ptr;
    const char* desc_char_word_ptr;
    const char* desc_char_ptr;

    flag_width   = 3;
    string_width = (opt->string != NULL) ? 3 + strlen(opt->string) : 0;
    comma_width  = 1;
    min_width    = flag_width + comma_width + string_width + 2;

    orig_opt_width = (opt_width >= 0) ? opt_width : 0;

    if (opt_width <= 0 || opt_width < min_width)
    {
        opt_width = min_width;
    }

    assert(opt_width <= 60);

    opt_padding  = opt_width - min_width;

    if (opt->flag != '\0')
        fprintf(fp, " -%c", opt->flag);
    else
        fprintf(fp, "   ");

    if (opt->flag != '\0' && string_width > 0)
        fprintf(fp, ",");
    else
        fprintf(fp, " ");

    if (string_width > 0)
        fprintf(fp, " --%s", opt->string);
    if (opt_padding > 0)
        fprintf(fp, "%*s", opt_padding, "");
    fprintf(fp, "  ");

    desc_max_len  = 80 - opt_width;

    num_lines = 1;

    if (opt->desc == NULL || strlen(opt->desc) == 0)
    {
        fprintf(fp, "\n");
        return;
    }

    desc_buff_word_ptr = desc_buff;
    desc_buff_ptr      = desc_buff;
    desc_char_word_ptr = opt->desc;
    desc_char_ptr      = opt->desc;

    len = 0;

    while (*desc_char_ptr != '\0')
    {
        if (len == desc_max_len)
        {
            if (desc_buff == desc_buff_word_ptr)
            {
                desc_char_word_ptr = desc_char_ptr;
            }
            else
            {
                desc_char_ptr = desc_char_word_ptr;
                *desc_buff_word_ptr = '\0';
            }

            if (num_lines > 1)
            {
                fprintf(fp, "%*s", orig_opt_width, "");
            }

            desc_buff_ptr = desc_buff;
            while (*desc_buff_ptr == ' ')
                desc_buff_ptr++;
            fprintf(fp, "%s\n", desc_buff_ptr);

            desc_buff_word_ptr = desc_buff;
            desc_buff_ptr      = desc_buff;

            len = 0;
            num_lines++;
        }

        *desc_buff_ptr = *desc_char_ptr;
        desc_char_ptr++;
        desc_buff_ptr++;
        len++;

        if (*desc_char_ptr == ' ')
        {
            desc_buff_word_ptr = desc_buff_ptr;
            desc_char_word_ptr = desc_char_ptr;
        }
    }

    *desc_buff_ptr = *desc_char_ptr;

    if (*desc_buff != '\0')
    {
        if (num_lines > 1)
        {
            fprintf(fp, "%*s", orig_opt_width, "");
        }

        desc_buff_ptr = desc_buff;
        while (*desc_buff_ptr == ' ')
            desc_buff_ptr++;
        fprintf(fp, "%s\n", desc_buff_ptr);
    }
}


void print_options
(
    FILE*            fp,
    int              opt_width,
    int              num_opts_no_arg,
    Option_no_arg*   opts_no_arg,
    int              num_opts_with_arg,
    Option_with_arg* opts_with_arg
)
{
    int i;
    
    for (i = 0; i < num_opts_no_arg; i++)
    {
        print_option_no_arg(fp, opt_width, &(opts_no_arg[ i ]));
    }
    for (i = 0; i < num_opts_with_arg; i++)
    {
        print_option_with_arg(fp, opt_width, &(opts_with_arg[ i ]));
    }
}