/*   -*- buffer-read-only: t -*- vi: set ro:

 *

 *  DO NOT EDIT THIS FILE   (save-flags.c)

 *

 *  It has been AutoGen-ed

 *  From the definitions    /tmp/.ag-ufBbQe/save-flags.def

 *  and the template file   str2enum

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name ``Bruce Korb'' nor the name of any other

 *    contributor may be used to endorse or promote products derived

 *    from this software without specific prior written permission.

 *

 * str2enum IS PROVIDED BY Bruce Korb ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL Bruce Korb OR ANY OTHER CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "save-flags.h"

#include <sys/types.h>

#ifndef MISSING_INTTYPES_H

# include <inttypes.h>

#endif

typedef enum {

    SVFL_BNM_DEFAULT  = 0,

    SVFL_BNM_USAGE    = 1,

    SVFL_BNM_UPDATE   = 2,

    SVFL_COUNT_BNM

} save_flags_enum_t;

static save_flags_enum_t

find_save_flags_bnm(char const * str, size_t len);

#include <sys/types.h>

#include <string.h>

#ifndef NUL

#define NUL '\0'

#endif

/* ANSI-C code produced by gperf version 3.1 */

/* Command-line: gperf save-flags.gp  */

/* Computed positions: -k'' */

# if 0 /* gperf build options: */

// %struct-type

// %language=ANSI-C

// %includes

// %global-table

// %omit-struct-type

// %readonly-tables

// %compare-strncmp

//

// %define slot-name               svfl_name

// %define hash-function-name      save_flags_hash

// %define lookup-function-name    find_save_flags_name

// %define word-array-name         save_flags_table

// %define initializer-suffix      ,SVFL_COUNT_BNM

//

# endif

#include "save-flags.h"

typedef struct {

    char const *    svfl_name;

    save_flags_enum_t svfl_id;

} save_flags_map_t;

#include <string.h>

/* maximum key range = 3, duplicates = 0 */

static unsigned int

save_flags_hash (register const char *str, register size_t len)

{

  (void)str;

  (void)len;

  return len;

}

static const save_flags_map_t save_flags_table[] =

  {

    {"",SVFL_COUNT_BNM}, {"",SVFL_COUNT_BNM},

    {"",SVFL_COUNT_BNM}, {"",SVFL_COUNT_BNM},

    {"",SVFL_COUNT_BNM},

    {"usage",    SVFL_BNM_USAGE},

    {"update",   SVFL_BNM_UPDATE},

    {"default",  SVFL_BNM_DEFAULT}

  };

static inline const save_flags_map_t *

find_save_flags_name (register const char *str, register size_t len)

{

  if (len <= 7 && len >= 5)

    {

      register unsigned int key = (int)save_flags_hash (str, len);

      if (key <= 7)

        {

          register const char *s = save_flags_table[key].svfl_name;

          if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')

            return &save_flags_table[key];

        }

    }

  return 0;

}

/**

 * Convert a command (keyword) to a save_flags_enum_t enumeration value.

 *

 * @param[in] str   a string that should start with a known key word.

 * @param[in] len   the provided length of the keyword at \a str.

 * @returns the enumeration value.

 * If not found, that value is SVFL_COUNT_BNM.

 */

static save_flags_enum_t

find_save_flags_bnm(char const * str, size_t len)

{

    save_flags_map_t const * map;

    map = find_save_flags_name(str, (unsigned int)len);

    if (map != NULL)

        return map->svfl_id;

    /* Check for a partial match */

    {

        /*

         * Indexes of valid save_flags_table entries in sorted order:

         */

        static unsigned int const ix_map[] = {

            7, 6, 5 };

        save_flags_enum_t res = SVFL_COUNT_BNM;

        static int const HI = (sizeof(ix_map) / sizeof(ix_map[0])) - 1;

        int lo = 0;

        int hi = HI;

        int av;

        int cmp;

        for (;;) {

            av  = (hi + lo) / 2;

            map = save_flags_table + ix_map[av];

            cmp = strncmp(map->svfl_name, str, len);

            if (cmp == 0) break;

            if (cmp > 0)

                 hi = av - 1;

            else lo = av + 1;

            if (lo > hi)

                return SVFL_COUNT_BNM;

        }

        res = map->svfl_id;

        /*

         * If we have an exact match, accept it.

         */

        if (map->svfl_name[len] == NUL)

            return res;

        /*

         * Check for a duplicate partial match (a partial match

         * with a higher or lower index than "av".

         */

        if (av < HI) {

            map = save_flags_table + ix_map[av + 1];

            if (strncmp(map->svfl_name, str, len) == 0)

                return SVFL_COUNT_BNM;

        }

        if (av > 0) {

            map = save_flags_table + ix_map[av - 1];

            if (strncmp(map->svfl_name, str, len) == 0)

                return SVFL_COUNT_BNM;

        }

        return res;

    }

}

/**

 * Convert a string to a save_flags_mask_t mask.

 * Bit names prefixed with a hyphen have the bit removed from the mask.

 * If the string starts with a '-', '+' or '|' character, then

 * the old value is used as a base, otherwise the result mask

 * is initialized to zero.  Separating bit names with '+' or '|'

 * characters is optional.  By default, the bits are "or"-ed into the

 * result.

 *

 * @param[in] str string with a list of bit names

 * @param[in] old previous value, used if \a str starts with a '+' or '-'.

 *

 * @returns an unsigned integer with the bits set.

 */

save_flags_mask_t

save_flags_str2mask(char const * str, save_flags_mask_t old)

{

    static char const white[] = ", \t\f";

    static char const name_chars[] =

        "adefglpstu"

        "ADEFGLPSTU";

    save_flags_mask_t res = 0;

    int have_data = 0;

    for (;;) {

        save_flags_enum_t val;

        unsigned int val_len;

        unsigned int invert = 0;

        str += strspn(str, white);

        switch (*str) {

        case NUL: return res;

        case '-': case '~':

            invert = 1;

            /* FALLTHROUGH */

        case '+': case '|':

            if (have_data == 0)

                res = old;

            str += 1 + strspn(str + 1, white);

            if (*str == NUL)

                return 0;

        }

        val_len = strspn(str, name_chars);

        if (val_len == 0)

            return 0;

        val = find_save_flags_bnm(str, val_len);

        if (val == SVFL_COUNT_BNM)

            return 0;

        if (invert)

            res &= ~((save_flags_mask_t)1 << val);

        else

            res |= (save_flags_mask_t)1 << val;

        have_data = 1;

        str += val_len;

    }

}

/* end of save-flags.c */