parse_options.c

Go to the documentation of this file.

/*
 *  Copyright (c) KONINKLIJKE PHILIPS ELECTRONICS N.V. 2000-2006
 *  All rights reserved.
 *  For licensing and warranty information, see the file COPYING.LGPLv21.txt
 *  in the root directory of this package.
 *
 *  Philips Research Laboratories
 *  Eindhoven, The Netherlands
 *
 *  CVS id      :  $Id: parse_options.c,v 1.2 2006/02/06 12:57:49 kock Exp $
 *
 *  Origin      :  This file originates from package mtk at
 *                 http://sourceforge.net/projects/pfspd
 *
 */

#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <assert.h>

#include "parse_options.h"

#define MAX_LINE_LENGTH 4*1024
#define MAX_OPTIONS     256
#define MAX_FILENAME    256

#define OPTION            0
#define ENUM_OPTION       1
#define ARGUMENT          2

#define MIN_NAME_WIDTH    4
#define MIN_TYPE_WIDTH    4
#define MIN_DFLT_WIDTH    7

#define MAX_NAME_WIDTH   16
#define MAX_TYPE_WIDTH   16
#define MAX_DFLT_WIDTH   16

#define BUF_LEN        1024

#define MAX_LINE_WIDTH   70

#define MAX_ARGC        MAX_OPTIONS

#define MIN(a,b) ((a)<(b)?(a):(b))
#define MAX(a,b) ((a)>(b)?(a):(b))

static int option_class(char *name)
{
    int cl;

    switch(name[0]) {
    case '-':
        cl=OPTION;
        break;
    case '{':
        cl=ENUM_OPTION;
        break;
    default:
        cl=ARGUMENT;
        break;
    }

    return cl;
} /* end of option_class */


/*
 * Because parse_ini_file is called recursively,
 * we have to forward declare it here
 *
 */
static int parse_ini_file(char *ini_filename, option_t options[], int option_found[], int nr_options);

/*
 * Returns position of "s" in set "set"
 * Returns -1 if not found.
 */
static int string2int(char *s, char *set)
{
    char         *p;
    char         *p2;
    unsigned int len;
    int          pos;
    int          i;

    /* set = "{s1,s2,...,sn}" */
    p = set+1;

    pos = -1;
    i=0;
    do {
        p2 = strpbrk(p,",}");
        assert (p2 != NULL);

        len=p2-p;
        if ((strlen(s)==len) && !strncmp(s,p,len)) {
            pos = i;
        }
        p = p2+1;
        i++;
    } while( *p2 != '}' );

    return pos;
} /* end of string2int */

/*
 * Returns string at position "pos" in set "set"
 *
 */
static char *int2string(int pos, char *set)
{
    static char  tmp[128];
    char         *p;
    char         *p2;
    unsigned int len;
    int          i;

    /* set = "{s1,s2,...,sn}" */
    p = set+1;

    strcpy(tmp, "*ERROR*");
    i=0;
    do {
        p2 = strpbrk(p,",}");
        assert (p2 != NULL);

        len=p2-p;

        if (i==pos) {
            strncpy(tmp, p, len);
            tmp[len]='\0';
        }

        p = p2+1;
        i++;
    } while( *p2 != '}' );

    return tmp;
} /* end of int2string */

static int enum_index(char *list, char *name)
{
    int  nr;
    char *p;

    /* list="{s1,s2,..,sn}" */
    if (list[0] == '{') {
        p = list+1;
        for(nr=0; p!=NULL; nr++) {
            if (!strncmp(p, name, strlen(name))) {
                char c = p[strlen(name)];

                if ((c==',') || (c=='}')) {
                    return nr;
                }
            }

            p = strchr(p, ',');
            if (p!=NULL) {
                p++;
            }
        }
    }

    return -1;
} /* end of enum_index */

/*
 * Store string "s" is string list "list".
 * Memory is automatically reallocated if necessary.
 *
 */
static void add_string(char ***list, char *s)
{
    char **p;
    int  i;
    int  size;
    int  new_size;

    /* Find first free entry */
    p=(*list);
    size=0;
    while((*p!=NULL) && (**p!='\0')) {
        p++;
        size++;
    }

    if (*p==NULL) {
        /* List full, reallocate twice the memory */
        new_size=2*(size+1);
        *list=(char **)realloc(*list, new_size*sizeof(char *));
        for(i=size; i<new_size-1; i++) {
            (*list)[i] = ""; /* Empty string marks a free entry */
        }
        (*list)[new_size-1] = NULL; /* NULL marks end of list */
        p=(*list)+size;
    }

    *p=s;
} /* end of add_string */

/*
 * Interprete value for option and store it in the associated variable.
 *
 * option:   the option
 * value:    value to be interpreted
 * location: A string that is used in case of an error. It denoted
 *           the location of the value (file:line for ini-files,
 *           empty for the cmd-line).
 * Return:   success: > 0, failure <=0. The absolute value gives the number of strings used.
 *
 */

static int store_strlist(char ***var_p, char *value)
{
    /* type="strlist" or "[strlist]" */

    char *tmp;

    tmp = (char *)malloc(strlen(value)+1);
    if (tmp == NULL) {
        fprintf( stderr, "Cannot allocate memory for string...\n");
        exit(1);
    }

    strcpy(tmp, value);
    add_string(var_p, tmp);

    return 2;
} /* end of store_strlist */

static int store_str(option_t option, char **var_p, char *value, char *location)
{
    /* type="str" or "str{a,b,c}" */

    char *tmp;
    int  ret;
 
    if (value == NULL) {
        fprintf( stderr, "%sOption \"%s\" requires a string argument\n", location, option.name );
        return -1;
    }

    if (!strncmp(option.type, "str{", 4)) {
        ret = string2int(value, option.type+3);
        if (ret < 0) {
            fprintf( stderr, "%sOption \"%s\" does not expect argument \"%s\"\n",
                     location, option.name, value );
            return -2;
        }
    }

    tmp = (char *)malloc(strlen(value)+1);
    if (tmp == NULL) {
        fprintf( stderr, "Cannot allocate memory for string...\n");
        exit(1);
    }

    strcpy(tmp, value);
    *var_p = tmp;

    return 2;
} /* end of store_str */

static int store_enum(option_t option, int *var_p, char *value)
{
    int i;

    assert(value != NULL);

    i = enum_index(option.name, value);
    assert(i>=0);

    *var_p = i;

    return 2;
} /* end of store_enum */

static int store_int_enum(option_t option, int *var_p, char *value, char *location)
{
    /* type="int{a,b,c}" */

    int ret;

    if (value == NULL) {
        fprintf( stderr, "%sOption \"%s\" requires a string argument\n", location, option.name );
        return -1;
    }

    ret = string2int(value, option.type+3);
    if (ret < 0) {
        fprintf( stderr, "%sOption \"%s\" does not expect argument \"%s\"\n",
                 location, option.name, value );
        return -2;
    }

    *var_p = ret;

    return 2;
} /* end of store_int_enum */

static int store_int(option_t option, int *var_p, char *value, char *location)
{
    /* type="int" or "int[min,max]" */

    int      min, max;
    int      base;
    long          i;
    unsigned long u;
    char     *no1;
    char     *no2;
    char     *comma;
    char     *bracket;

    if (value == NULL) {
        base=10;
        i=0;
        u=0;
    }
    else {
        /* Prefix "0x" or "0X" indicates hexadecimal notation.
         * Otherwise, we assume decimal notation.
         */
        base=((value[0]=='0') && (toupper(value[1])=='X')) ? 16 : 10;
        if (base == 10) {
            i=strtol(value, NULL, base);
            u=0;
        }
        else {
            u=strtoul(value, NULL, base);
            i=(long)u; /* in case of range checking, it must fit in a signed */
        }
    }
    
    if (option.type[3]=='[') {
        /* expected format: "int[%d,%d]" -- sscanf is not used due to purify errors */
        no1     = &option.type[4];   assert(no1 != NULL);
        comma   = strchr(no1, ',');  assert(comma != NULL);
        no2     = comma+1;           assert(no2 != NULL);
        bracket = strchr(no2, ']');  assert(bracket != NULL);
        min = atoi(no1);
        max = atoi(no2);

        if ((value == NULL) || (i<min) || (i>max)) {
            fprintf( stderr, "%sOption \"%s\" requires an integer argument with range [%d,%d]\n",
                     location, option.name, min, max);
            return -2;
        }
    }
    else {
        if (value == NULL) {
            fprintf( stderr, "%sOption \"%s\" requires an integer argument\n",
                     location, option.name);
            return -1;
        }
    }
    
    if (base == 10) {
        *var_p = i;
    }
    else {
        *(unsigned int *)var_p = u;
    }

    return 2;
} /* end of store_int */

static int store_double(double *var_p, char *value)
{
    /* type="double" */

    double d;

    d = (value == NULL) ? (double)0.0 : atof(value);
    *var_p = d;

    return 2;
} /* end of store_double */

static int store_float(float *var_p, char *value)
{
    /* type="float" */

    float f;

    f = (value == NULL) ? (float)0.0 : (float)atof(value);
    *var_p = f;

    return 2;
} /* end of store_float */

static int store_char(char *var_p, char *value)
{
    /* type="char" */

    char c;

    c = (value == NULL) ? 0 : *value;
    *var_p = c;

    return 2;
} /* end of store_char */

static int store_bool(int *var_p, char *value)
{
    /* type="bool" or "cmd" */

    *var_p = ((value != NULL) && !strcmp(value, "true"));
    return 1;
} /* end of store_bool */

static int store_value(option_t option, char *value, char *location)
{
    int  ret;
    char *tmp;
    int  i;
    int  count;

    tmp   = strchr(option.type, '#');
    count = (tmp==NULL) ? 1 : atoi(tmp+1);

    if (strstr(option.type, "strlist")!=NULL) {
        assert(count==1);
        ret=store_strlist(option.var, value);
    }
    else if (!strncmp(option.type, "str", 3)) {
        assert(count==1);
        ret=store_str(option, option.var, value, location);
    }
    else if (!strcmp(option.type, "enum")) {
        assert(count==1);
        ret=store_enum(option, option.var, value);
    }
    else if (!strcmp(option.type, "char")) {
        assert(count==1);
        ret=store_char(option.var, value);
    }
    else if (!strcmp(option.type, "bool") || !strcmp(option.type, "cmd")) {
        assert(count==1);
        ret=store_bool(option.var, value);
    }
    else if (!strncmp(option.type, "int", 3) || !strncmp(option.type, "double", 6)  || !strncmp(option.type, "float", 5)) {
        tmp=value;
        ret=1;
        for(i=0; i<count; i++) {
            if (option.type[3] == '{') {
                ret=store_int_enum(option, ((int *)option.var)+i, tmp, location);
            }
            else if (option.type[0] == 'i') {
                ret=store_int(option, ((int *)option.var)+i, tmp, location);
            }
            else if (option.type[0] == 'd') {
                ret=store_double(((double *)option.var)+i, tmp);
            }
            else {
                ret=store_float(((float *)option.var)+i, tmp);
            }

            /* Error exit */
            if (ret < 0) {
                return ret;
            }

            /* Shift pointer to next item from option values next */
            tmp=strchr(tmp, ',');

            if (((i<count-1)&&(tmp==NULL)) || ((i==count-1)&&(tmp!=NULL))) {
                fprintf( stderr, "%sOption \"%s\" expects %d values\n",
                         location, option.name, count );
                ret=-2;
                break;
            }

            if (i<count-1) {
                tmp++;
            }
        }
    }
    else {
        /* Assign a value to ret to avoid compiler warnings */
        ret=0;

        fprintf( stderr, "%sOption \"%s\" has unknown type \"%s\"\n",
                 location, option.name, option.type );
        exit(1);
    }

    return ret;
} /* end of store_value */

static char *get_value(option_t *option)
{
    static char str[1024];
    int         i;
    char        *p;
    char        *p2;
    char        **q;
    void        *var;

    char *p3   = strchr(option->type, '#');
    int  count = (p3==NULL) ? 1 : atoi(p3+1);

    var = option->var;


    str[0]='\0';
    while(count--) {
        char *end = str+strlen(str);

        if (strstr(option->type, "strlist")) {
            /* String list */
            q=*(char ***)var;
            while(*q!=NULL) {
                strcpy(end+strlen(end), *q);
                q++;
                if (*q!=NULL) {
                    strcpy(end+strlen(end), " ");
                }
            }
        }
        else if (strstr(option->type, "str")) {
            /* String value */
            p = *((char **)var);
            if (strlen(p) == 0) {
                strcpy(end, "\"\"");
            } else if (strchr(p, ' ') == NULL) {
                strcpy(end, p);
            } else {
                strcpy(end, "\"");
                strcpy(end+1, p);
                strcpy(end+1+strlen(p), "\"");
            }
        }
        else if (!strcmp(option->type, "enum")) {
            /* Enumerator option */
            p = option->name+1;
            for(i=0; i<*(int *)var; i++) {
                p = strchr(p, ',')+1;
            }
            p2 = strchr(p, ',');
            if (p2==NULL) {
                p2 = strchr(p, '}');
            }
            strncpy(end, p, p2-p);
            end[p2-p]='\0';
        }
        else if (!strncmp(option->type, "int{", 4)) {
            strcpy(end, int2string(*(int *)var, option->type+3));
            var = ((int *)var)+1;
        }
        else if (!strncmp(option->type, "int", 3)) {
            sprintf(end, "%d", *(int *)var);
            var = ((int *)var)+1;
        }
        else if (!strncmp(option->type, "double", 6)) {
            sprintf(end, "%6.4f", *(double *)var);
            var = ((double *)var)+1;
        }
        else if (!strncmp(option->type, "float", 5)) {
            sprintf(end, "%6.4f", *(float *)var);
            var = ((float *)var)+1;
        }
        else if (!strncmp(option->type, "char", 4)) {
            sprintf(end, "%c", *(char *)var);
            var = ((char *)var)+1;
        }
        else if (!strcmp(option->type, "bool")) {
            sprintf(end, "%s%s", *(int *)var ? "" : "-no", option->name);
        }

        if (count!=0) {
            strcpy(end+strlen(end), ",");
        }
    }

    return str;
} /* end of get_value */

/*
 * Interpret (name,value) and store the value in the associated variable.
 *
 * name:         Option name (in case of an argument, this is the argument itself)
 * value:        Value of the option (for options: may be NULL, for arguments: always NULL)
 * location:     A string that is used in case of an error. It denoted
 *               the location of the value (file:line for ini-files,
 *               empty for the cmd-line).
 * options:      The list of possible options/arguments
 * option_found: A list of booleans telling which option was already found
 *
 * Return:       success: > 0, failure <=0. The absolute value gives the number of strings used.
 *
 */
static int parse_option(char *name, char *value, char *location, option_t options[], int option_found[],
                        int nr_options)
{
    int nr;
    int err;
    int i;

    if ((name[0] != '-') || (name[1] == '\0')) {
        /* This is a normal argument (i.e. no option) */
        for(i=0; i<nr_options; i++) {
            if ((option_class(options[i].name) == ARGUMENT) && !option_found[i]) {
                /* in case of an argument, the name itself is the value */
                nr=store_value(options[i],name,location);
                if (!strstr(options[i].type, "strlist")) {
                    option_found[i] = 1;
                }
                return 1;
            }
        }

        fprintf( stderr, "%sError: unexpected argument \"%s\"\n", location, name );
        return -1;
    }
    else if (!strcmp(name, "-ini")) {
        if (value != NULL) {
            err = parse_ini_file(value, options, option_found, nr_options);
            if (err) {
                fprintf(stderr, "Problem parsing ini-file \"%s\"\n", value);
                return -2;
            }
            else {
                return 2;
            }
        }
        else {
            fprintf( stderr, "%sOption \"%s\" requires a filename argument\n", location, name);
            return -1;
        }
    }
    else {
        /* Check enumeration options (i.e. options[i].name == "{-a,-b,-c}") */
        for(i=0; i != nr_options; i++) {
            if (enum_index(options[i].name, name)>=0) {
                /* in case of an enumerated options, the name itself is the value */
                nr = store_value(options[i], name, location);
                option_found[i] = 1;
                return 1;
            }
        }

        /* Check boolean options */
        for(i=0; i != nr_options; i++) {
            if (!strcmp(options[i].type, "bool") || !strcmp(options[i].type, "cmd")) {
                if (!strcmp(options[i].name, name)) {
                    value = "true";
                }
                else if (!strncmp(name, "-no-", 4) && !strcmp(options[i].name, name+3)) {
                    value = "false";
                }
                else {
                    /* Not a boolean option */
                    continue;
                }
                
                nr = store_value(options[i], value, location);
                option_found[i] = 1;
                return nr;
            }
        }

        /* Check normal options */
        for(i=0; i != nr_options; i++) {
            if (!strcmp(options[i].name, name)) {
                nr = store_value(options[i], value, location);
                if (nr != 0) {
                    if (nr>0) {
                        option_found[i] = 1;
                    }
                    return nr;
                }
            }
        }
    }

    fprintf( stderr, "%sError: unrecognized option \"%s\"\n", location, name );
    return -1;
} /* end of parse_option */

/*
 * Remove comment (starting with #); also remove \n
 *
 */
static void remove_comment(char *s)
{
    char *ch = s + strlen(s) - 1; /* skip \0 */

    /* remove trailing \n  */
    if (*ch == '\n')
        *ch = '\0';

    /* remove comment */
    ch = strchr(s, '#');
    if (ch != NULL)
        *ch = '\0';

} /* end of remove_comment */

/*
 * Remove tabs (turn into spaces)
 *
 */
static void remove_tabs(char *s)
{
    char *ch = s + strlen(s) - 1; /* skip \0 */

    /* turn each tab character into a single space */
    while (ch >= s) {
        if (*ch == '\t')
            *ch = ' ';
        ch--;
    }
} /* end of remove_tabs */

/*
 * Remove leading spaces (and tabs)
 *
 */
static void remove_leading_spaces(char *s)
{
    char *ch = s;

    /* find first non-space character */
    while (*ch == ' ')
        ch++;

    /* remove leading spaces */
    if (ch != s) {
        while (*ch != '\0')
            *s++ = *ch++;
        *s = '\0';
    }
} /* end of remove_leading_spaces */

/*
 * Remove trailing spaces
 *
 */
static void remove_trailing_spaces(char *s)
{
    char *end = s + strlen(s) - 1; /* skip \0 */

    /* remove trailing spaces */
    while ((end > s) && (*end == ' ')) {
        *end = '\0';
        end--;
    }
} /* end of remove_trailing_spaces */

/*
 * Remove spaces around equal sign
 *
 */
static void remove_eqsign_spaces(char *s)
{
    char *eqsign, *chleft, *chright;

    /* remove spaces before equal sign */
    eqsign = strchr(s, '=');
    if (eqsign != NULL) {
        /* find first non-space character after '=' */
        chright = eqsign + 1;
        while (*chright == ' ')
            chright++;

        /* find first non-space character before '=' */
        chleft = eqsign - 1;
        while ((*chleft == ' ') && (chleft >= s))
            chleft--;

        /* remove spaces */
        chleft++;
        *chleft++ = '=';
        while (*chright != '\0')
            *chleft++ = *chright++;
        *chleft = '\0';
    }
} /* end of remove_eqsign_spaces */

/*
 * Parse all lines of an ini-file.
 *
 * ini_filename: Name of the file
 * options :     The list of possible options/arguments
 * option_found: A list of booleans telling which option was already found
 * nr_options:   Length of the "options" array.
 *
 * Return:       success: zero, failure: non-zero
 *
 */
static int parse_ini_file(char *ini_filename, option_t options[], int option_found[],
                          int nr_options)
{
    char buf[MAX_LINE_LENGTH];
    char location[MAX_FILENAME];
    FILE *f;
    int  line;
    char *name, *value;
    char *p;
    char *name_ptr, *val_ptr;
    char name_val, val_val;
    int  nr;
    int  runin;         /* Still in runin; windows or standard not yet known */
    int  winfmt;        /* This is a windows format .ini file */
    int  arguments;     /* Windows parser working on arguments */
    char *eqsign;       /* Location of "=" in buf */
    char arg[MAX_FILENAME+40];  /* Standard option string from win .ini file */

    f = fopen(ini_filename, "r");
    if (f == NULL) {
        return -1;
    }

    line = 1;
    runin = 1;
    winfmt = 0;
    arguments = 0;
    while( fgets(buf, MAX_LINE_LENGTH-1, f), !feof(f) ) {
        sprintf(location, "%s:%d ", ini_filename, line++);

        remove_comment(buf);
        remove_tabs(buf);
        remove_leading_spaces(buf);
        remove_trailing_spaces(buf);

        if (runin) {
            /* Check whether this is a windows style .ini file */
            if (*buf != '\0') { /* skip empty lines */
                /* Windows format determined by first non-empty line "[xxx]" */
                if ((buf[0] == '[') && (buf[strlen(buf)-1] == ']')) {
                    winfmt = 1;
                }

                runin = 0;
            }
        }

        if (winfmt) {
            /*
             * Windows-style .ini file parser
             */
            remove_eqsign_spaces(buf);

            if (!strcmp(buf, "[arguments]")) {
                arguments = 1;  /* following lines are mandatory arguments */
            } else if (*buf == '[') {
                arguments = 0;  /* following lines are options */
                if (strchr(buf, ']') == NULL) {
                    fprintf(stderr, "%sError: missing closing bracket\n", location);
                    fclose(f);
                    return 1;
                }
                if (*(strchr(buf, ']') + 1) != '\0') {
                    fprintf(stderr, "%sError: illegal syntax\n", location);
                    fclose(f);
                    return 1;
                }            
            } else if (*buf != '\0') { /* skip empty lines */
                eqsign = strchr(buf, '=');
                if (eqsign == buf) {
                    fprintf(stderr, "%sError: missing option name\n", location);
                    fclose(f);
                    return 1;
                }
                if (eqsign == NULL) {
                    fprintf(stderr, "%sError: missing '='\n", location);
                    fclose(f);
                    return 1;
                }

                if (arguments) {
                    /* skip option name; use value as argument */
                    value = eqsign + 1; 
                    nr = parse_option(value, NULL, location, options, option_found, nr_options);
                    if (nr<=0) {
                        fclose(f);
                        return 1;
                    }
                } else {
                    /* separate name and value */
                    *eqsign = '\0';
                    name    = buf;
                    value   = eqsign + 1; 

                    /* add name only if value is defined */
                    if (*value != '\0') {
                        /* prefix name with '-' */
                        strcpy(arg, "-");

                        /* check if value is boolean */
                        if (!strcmp(value, "true") || !strcmp(value, "false")) {
                            /* prefix "no-" for false value */
                            if (!strcmp(value, "false"))
                                strcat(arg, "no-");

                            /* add name to arg */
                            strcat(arg, name);

                            /* add arg to Argv */
                            nr = parse_option(arg, NULL, location, options, option_found, nr_options);
                            if (nr<=0) {
                                fclose(f);
                                return 1;
                            }
                        }
                        else {
                            /* add name to arg */
                            strcat(arg, name);

                            if ((value[0] == '"') && (value[strlen(value)-1] == '"')) {
                                /* Strip quotes from value */
                                value++;
                                value[strlen(value)-1] = '\0';
                            }
                            nr = parse_option(arg, value, location, options, option_found, nr_options);
                            if (nr<=0) {
                                fclose(f);
                                return 1;
                            }
                        }
                    }
                }
            }

        } else {
            /*
             * Standard .ini file parser
             */
            name = buf;
            do {
                name_ptr = val_ptr = name;
                name_val = val_val = *name;

                value = NULL;
                while((*name) && isspace((int)*name))
                    name++;     /* Skip white space */

                p = name;
                while((*p) && !isspace((int)*p))
                    p++;

                if (*p) {
                    /* Space after name found */
                    name_ptr = p;
                    name_val = *p;
                    *p = '\0';   /* terminate name */

                    value = p+1;
                    while((*value) && isspace((int)*value))
                        value++;     /* Skip white space */

                    /* Handle quoted string */
                    if (*value == '"') {
                        value++;
                        p = value;
                        while((*p) && (*p != '"')) {
                            p++;
                        }
                        if (*p == '"') {
                            val_ptr = p;
                            val_val = *p;
                            *p = '\0';
                        }
                    } else {
                        p = value;
                        while((*p) && !isspace((int)*p))
                            p++;
                        if (*p) {
                            /* space after value found */
                            val_ptr = p;
                            val_val = *p;
                            *p = '\0';
                        }
                    }

                    if (*value == '\0') {
                        value = NULL;
                    }
                }

                if (name[0] == '\0') {
                    name = NULL;
                }

                if (name != NULL) {
                    nr = parse_option(name, value, location, options, option_found, nr_options);
                    if (nr<=0) {
                        fclose(f);
                        return 1;
                    }
                    switch (nr) {
                    case 1:
                        /* One argument processed, value holds start of next */
                        name = value;
                        break;
                    case 2:
                        /* Two arguments processed, start immediately after value */
                        name = value + strlen(value) + 1;
                        break;
                    default:
                        name = NULL;
                        break;
                    }
                }
                *name_ptr = name_val;
                *val_ptr = val_val;
            } while (name != NULL);
        }
    }

    fclose(f);
    return 0;
} /* end of parse_ini_file */

/*
 * Parse the complete command line.
 *
 * argc:         Length of the "argv" array.
 * argv[]:       List of strings.
 * options :     The list of possible options/arguments
 * option_found: A list of booleans telling which option was already found
 * nr_options:   Length of the "options" array.
 *
 * Return:       success: zero, failure: non-zero
 *
 */
static int parse_cmd_line(int argc, char *argv[], option_t options[], int option_found[],
                          int nr_options )
{
    int nr;

    argv++;
    argc--;
    while(argc>0) {
        nr = parse_option(argv[0], argc>0 ? argv[1] : NULL, "", options, option_found, nr_options);
        if (nr<=0) {
            return 1;
        }

        argv += nr;
        argc -= nr;
    }

    return 0;
} /* end of parse_cmd_line */

/*
 * Builds the name of the .ini file from the application name.
 * Caller must allocate sufficient space in ini_filename.
 */
static void build_ini_filename(char *ini_filename, char *appl_name)
{
    int i, j=0;

    /* appl name can contain white spaces ' ' --> replace them by underscore */
    /* appl name can contain hyphens '-' --> skip them */
    for (i=0; appl_name[i]!='\0'; i++) {
        if (appl_name[i] == ' ')
            ini_filename[j++] = '_';
        else
        if (appl_name[i] != '-')
            ini_filename[j++] = appl_name[i];
    }
    sprintf(&ini_filename[j], ".ini");

} /* end of build_ini_filename */

/*
 * Formatted printing to file or string.
 * If f != NULL: prints to file, s and len not used.
 * Otherwise: prints to string s, len limits output.
 */
static int print(FILE *f, char **s, int *len, char *fmt, ...)
{
    int  n;
    char buf[BUF_LEN];

    va_list ap;
    va_start(ap, fmt);
    n=vsprintf(buf, fmt, ap);
    va_end(ap);

    if (f != NULL) {
        fprintf(f, "%s", buf);
    }
    else {
        if (*len>n) {
            strcpy(*s, buf);
            *s+=n;
            *len-=n;
        }
        else {
            n=0;
        }
    }

    return n;
}  /* end of print */

/*
 * Print a list of all arguments and options.
 * If f != NULL: prints to file, s and len not used.
 * Otherwise: prints to string s, len limits output.
 */
static int gen_print_options(FILE *f, char *s, int len, char *appl_name, option_t options[])
{
    option_t     *option;
    unsigned int name_width=MIN_NAME_WIDTH;
    unsigned int type_width=MIN_TYPE_WIDTH;
    unsigned int dflt_width=MIN_DFLT_WIDTH;
    int          bools_present;
    char         ini_filename[MAX_FILENAME];

    bools_present=0;
    for(option=options;option->name!=NULL; option++) {
        if (strlen(option->name)<MAX_NAME_WIDTH) {
            name_width = MAX(name_width, strlen(option->name));
        }
        if (strlen(option->type)<MAX_TYPE_WIDTH) {
            type_width = MAX(type_width, strlen(option->type));
        }
        if ((option->default_value!=NULL) && (strlen(option->default_value)<MAX_DFLT_WIDTH)) {
            dflt_width = MAX(dflt_width, strlen(option->default_value));
        }
        if (!strcmp(option->type, "bool")) {
            bools_present=1;
        }
    }

    if (!print(f, &s, &len, "Usage: %s [options]", appl_name)) return 0;
    for(option=options;option->name!=NULL; option++) {
        if (option_class(option->name) == ARGUMENT) {
            if (!print(f, &s, &len, " %s", option->name)) return 0;
        }
    }
    if (!print(f, &s, &len, "\n\n")) return 0;

    if (!print(f, &s, &len, " %-*s  %-*s  %-*s  %s\n",
            name_width, "name",
            type_width, "type",
            dflt_width, "default",
            "help text")) return 0;

    if (!print(f, &s, &len, " %-*s  %-*s  %-*s  %s\n",
            name_width, "----",
            type_width, "----",
            dflt_width, "-------",
            "---------")) return 0;

    if (!print(f, &s, &len,  " %-*s  %-*s  %-*s  %s\n",
            name_width, "-ini",
            type_width, "str",
            dflt_width, "",
            "Parse options from an ini-file")) return 0;

    option=options;
    while(option->name != NULL) {
        if (!print(f, &s, &len, " ")) return 0;
        if (!print(f, &s, &len, "%-*s", name_width, option->name)) return 0;
        if (strlen(option->name)>name_width) {
            if (!print(f, &s, &len, "\n %-*s", name_width, "")) return 0;
        }

        if (!print(f, &s, &len, "  ")) return 0;
        if (!print(f, &s, &len, "%-*s", type_width, option->type)) return 0;
        if (strlen(option->type)>type_width) {
            if (!print(f, &s, &len, "\n %-*s  %-*s", name_width, "", type_width, "")) return 0;
        }

        if (!print(f, &s, &len, "  ")) return 0;
        if (option->default_value != NULL) {
            if (!print(f, &s, &len,  "%-*s", dflt_width, option->default_value)) return 0;
        }
        else {
            if (!print(f, &s, &len,  "%-*s", dflt_width, "")) return 0;
        }

        if (!print(f, &s, &len, "  ")) return 0;
        if (!print(f, &s, &len, "%s", option->help)) return 0;
        if (!print(f, &s, &len, "\n")) return 0;

        option++;
    }

    build_ini_filename(ini_filename, appl_name);
    if (!print(f, &s, &len, "Processing order: defaults, optional %s file, cmdline args\n", ini_filename)) return 0;

    if (bools_present) {
        if (!print(f, &s, &len, "Note: for boolean options you can specify \"-opt\" and \"-no-opt\"\n")) return 0;
    }

    return 1;
} /* end of gen_print_options */

/*
 * Option list (help text) printing.
 * See header file for parameter descriptions.
 */
int sprint_options(char *s, int len, char *appl_name, option_t options[])
{
    return gen_print_options(NULL, s, len, appl_name, options);
} /* end of sprint_options */

int fprint_options(FILE *f, char *appl_name, option_t options[])
{
    return gen_print_options(f, NULL, 0, appl_name, options);
} /* end of fprint_options */

int print_options(char *appl_name, option_t options[])
{
    return gen_print_options(stdout, NULL, 0, appl_name, options);
} /* end of print_options */

/*
 * Print a list of the values of all arguments and options.
 * If f != NULL: prints to file, s and len not used.
 * Otherwise: prints to string s, len limits output.
 */
static int gen_print_option_values(FILE *f, char *s, int len, char *prefix, option_t options[])
{
    option_t     *option;
    unsigned int name_width=MIN_NAME_WIDTH;
    unsigned int line_len=MAX_LINE_WIDTH;
    unsigned int n;
    char         buf[BUF_LEN];

    memset(buf, 0, BUF_LEN);

    for(option=options;option->name!=NULL; option++) {
        if (strlen(option->name)<MAX_NAME_WIDTH) {
            name_width = MAX(name_width, strlen(option->name));
        }
    }

    line_len -= print(f, &s, &len, "%s", prefix);

    for (option=options; option->name != NULL; option++) {
        if (!strcmp(option->type, "cmd")) {
            /* Don't print command options */
            continue;
        }

        strcpy(buf, " ");
        if ((option_class(option->name) == OPTION) && strcmp(option->type, "bool")) {
            sprintf(buf+strlen(buf), "%s ", option->name);
        }
        sprintf(buf+strlen(buf), "%s", get_value(option));
        n=strlen(buf);
        if ((s==NULL) && (line_len<n)) {
            line_len=MAX_LINE_WIDTH-n;
            if (!print(f, &s, &len, "\n")) return 0;
        } else {
            line_len-=n;
        }
        
        if (!print(f, &s, &len, "%s", buf)) return 0;
    }

    if (s==NULL) {
        if (!print(f, &s, &len, "\n")) return 0;
    }

    return 1;
} /* end of gen_print_option_values */

/*
 * Option value printing.
 * See header file for parameter descriptions.
 */
int sprint_option_values(char *s, int len, char *prefix, option_t options[])
{
    return gen_print_option_values(NULL, s, len, prefix, options);
} /* end of sprint_option_values */

int fprint_option_values(FILE *f, char *prefix, option_t options[])
{
    return gen_print_option_values(f, NULL, 0, prefix, options);
} /* end of fprint_option_values */

int print_option_values(char *prefix, option_t options[])
{
    return gen_print_option_values(stdout, NULL, 0, prefix, options);
} /* end of print_option_values */

/*
 * Parse ini-file and command line.
 * See header file for parameter descriptions.
 */
int parse_options(char *appl_name, int argc, char *argv[], option_t options[])
{
    int      i, j, n;
    int      err;
    int      nr_options;
    option_t *option;
    int      option_found[MAX_OPTIONS];
    char     ini_filename[MAX_FILENAME];
    char     **strlist;

    nr_options = 0;
    option=options;
    while(option->name != NULL) {
        nr_options++;
        option++;
    }


    /* For all options, store default value (if available) */
    for(i=0; i != nr_options; i++) {
        char *def = options[i].default_value;

        if (strstr(options[i].type, "strlist")) {
            char **list=(char **)malloc(2*sizeof(char *));
            list[0] = "";
            list[1] = NULL;

            *(char ***)options[i].var = list;
            option_found[i] = 0;
        }
        else if (!strcmp(options[i].type, "bool") || !strcmp(options[i].type, "cmd")) {
            /* "true" gives default value 1, otherwise 0. */
            *(int *)options[i].var = ((def != NULL) && !strcmp(def, "true"));
            option_found[i] = (def != NULL);
        }
        else if (options[i].default_value != NULL) {
            (void)store_value(options[i], def, "INTERNALPROBLEM: ");
            option_found[i] = (option_class(options[i].name) != ARGUMENT); /* arguments are never found by default */
        }
        else {
            /* Otherwise */
            option_found[i] = 0;
        }
    }

    build_ini_filename(ini_filename, appl_name);
    err = parse_ini_file(ini_filename, options, option_found, nr_options);
    if (err>0) {
        return 1;
    }

    err = parse_cmd_line(argc, argv, options, option_found, nr_options);
    if (err) {
        return 1;
    }

    /*
     * If one of the options is a string list, it now has consumed
     * not only its own arguments, but also the argument for options
     * below in the options[] array.
     * In this case, we move the string from the list to the variables
     * of the later arguments.
     */
    for(i=0; i<nr_options; i++) {
        if (strstr(options[i].type, "strlist")) {
            /* String list option found */
            strlist=*((char ***)options[i].var);
            for(n=0; strlist[n]!=NULL; n++) {
                /* Find last entry in string list */
                if (strlist[n][0]=='\0') {
                    strlist[n]=NULL;
                    break;
                }
            }

            for(j=nr_options-1; j>i; j--) {
                if (option_class(options[j].name)==ARGUMENT) {
                    /* Move last entry from string list to this argument value */
                    if (n>0) {
                        n--;
                        *((char **)options[j].var)=strlist[n];
                        strlist[n]=NULL;
                        option_found[j]=1;
                    }
                }
            }

            option_found[i]=(strcmp(options[i].type, "strlist") || (n>0));
            break;
        }
    }

    /* Check if a command was given */
    for(i=0; i != nr_options; i++) {
        if (option_found[i] && !strcmp(options[i].type, "cmd")) {
            err=0;
            for(j=i+1; j!=nr_options; j++) {
                if (option_found[j] && !strcmp(options[j].type, "cmd")) {
                    /* Two or more commands given */
                    fprintf(stderr, "Only one command option is allowed\n");
                    err=1;
                }
            }
            return err;
        }
    }

    /* Check if mandatory arguments/options are missing */
    err=0;
    for(i=0; i != nr_options; i++) {
        if (!option_found[i] && strcmp(options[i].type, "cmd") && options[i].default_value==NULL) {
            err = 1;
            switch(option_class(options[i].name)) {
            case ARGUMENT:
                fprintf( stderr, "Mandatory argument \"%s\" missing\n", options[i].name );
                break;
            case OPTION:
                fprintf( stderr, "Mandatory option \"%s\" missing\n", options[i].name );
                break;
            case ENUM_OPTION:
                fprintf( stderr, "Mandatory option from \"%s\" missing\n", options[i].name );
                break;
            default:
                fprintf( stderr, "Internal error, invalid option_class(\"%s\") return value\n", options[i].name );
                break;
            }
        }
    }
    return err;
} /* end of parse_options */

---