#! /bin/sh
#  -*- Mode: Shell-script -*-
# str2m.test --- test str2enum and str2mask functionality
#
# Author:            Bruce Korb <bkorb@gnu.org>
##
## This file is part of AutoGen.
## AutoGen Copyright (C) 1992-2016 by Bruce Korb - all rights reserved
##
## AutoGen is free software: you can redistribute it and/or modify it
## under the terms of the GNU General Public License as published by the
## Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## AutoGen is distributed in the hope that it will be useful, but
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
## See the GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License along
## with this program.  If not, see <http://www.gnu.org/licenses/>.
##
#
# ----------------------------------------------------------------------

. ./defs
gperf=`command -v gperf`
test -x "$gperf" || {
    echo "$0 - cannot run without gperf installed" >&2
    exit 0
}

# # # # # # # # # # DEFINITIONS FILE # # # # # # # # #

echo creating $testname.def
cat > $testname.def <<'_EOF_'
AutoGen Definitions str2enum;

cmd[0]  = one;
cmd[3]  = three;
cmd[7]  = seven;
cmd[11] = eleven;
cmd[19] = ninteen;

type = kwd;
mask = { m-name = one-seven; m-bit = one, seven; };
mask = { m-name = not-one-seven; m-bit = three, eleven, ninteen; m-invert; };
_EOF_

cmd_list=`${SED} -n '/^cmd/{s/.*= *//;s/;//;p;}' $testname.def`
cmd_list=`echo $cmd_list`
# # # # # # # # # # EXPECTED OUTPUT FILES # # # # # # #

echo creating $testname-h.base
# this is the output we should expect to see
cat > $testname-h.base <<- _EOF_
	typedef enum {
	    STR2M_INVALID_KWD = 0,
	    STR2M_KWD_ONE      = 1,
	    STR2M_KWD_THREE    = 4,
	    STR2M_KWD_SEVEN    = 8,
	    STR2M_KWD_ELEVEN   = 12,
	    STR2M_KWD_NINTEEN  = 20,
	    STR2M_COUNT_KWD
	} str2m_enum_t;

	extern str2m_enum_t
	find_str2m_kwd(char const * str, size_t len);

	extern char const *
	str2m_name(str2m_enum_t id);

	#endif /* STR2ENUM_STR2M_H_GUARD */
	_EOF_

cat > $testname-c.base <<- _EOF_
	 * Convert a command (keyword) to a str2m_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 STR2M_INVALID_KWD.
	 */
	str2m_enum_t
	find_str2m_kwd(char const * str, size_t len)
	{
	    str2m_map_t const * map;

	    map = find_str2m_name(str, (unsigned int)len);
	    return (map == NULL) ? STR2M_INVALID_KWD : map->str2m_id;
	}

	/**
	 * Convert an str2m_enum_t value into a string.
	 *
	 * @param[in] id  the enumeration value
	 * @returns the associated string, or "* UNDEFINED *" if \a id
	 * is out of range.
	 */
	char const *
	str2m_name(str2m_enum_t id)
	{
	    static char const undef[] = "* UNDEFINED *";
	    static char const * const nm_table[] = {
	        [STR2M_KWD_ELEVEN  ] = "eleven",
	        [STR2M_KWD_NINTEEN ] = "ninteen",
	        [STR2M_KWD_ONE     ] = "one",
	        [STR2M_KWD_SEVEN   ] = "seven",
	        [STR2M_KWD_THREE   ] = "three" };
	    char const * res = undef;
	    if (id < STR2M_COUNT_KWD) {
	        res = nm_table[id];
	        if (res == NULL)
	            res = undef;
	    }
	    return res;
	}

	/* end of str2m.c */
	_EOF_

# # # # # # # # # # RUN THE TEST # # # # # # #

AGCMD="-L ${srcdir}/.. -L ${top_srcdir}/autoopts/tpl"
echo run_ag x ${AGCMD} $testname.def
run_ag x ${AGCMD} $testname.def || \
    failure ${AGCMD} failed

get_h_text="/^typedef enum/,/#endif.*GUARD/p"
${SED} -n "${get_h_text}" $testname.h > $testname-h.res
fpair="$testname-h.base $testname-h.res"
cmp -s $fpair || \
    failure "$testname $fpair failed`echo
        diff $fpair`"
get_c_text="/ Convert .*to a ${testname}_enum_t/,/end of $testname.c/p"
${SED} -n "${get_c_text}" $testname.c > $testname-c.res

fpair="$testname-c.base $testname-c.res"
cmp -s $fpair || \
    failure "$testname $fpair failed`echo
        diff $fpair`"

# # # # # # # # # # OUTPUT FILES PART 2 # # # # # # #

echo creating $testname-h2.base
TNAME=`echo $testname | tr '[a-z]' '[A-Z]'`
rep_name="s/${testname}/${testname}_2/g;s/${TNAME}/${TNAME}_2/g"
cat > $testname-h2.base <<- _EOF_
	#ifndef STR2ENUM_STR2M_2_H_GUARD
	#define STR2ENUM_STR2M_2_H_GUARD 1
	#include <sys/types.h>
	#include <inttypes.h>

	/** integral type for holding str2m_2 masks */
	typedef uint32_t str2m_2_mask_t;

	/** bits defined for str2m_2_mask_t */
	#define STR2M_2_KWD_ONE                0x00001U
	#define STR2M_2_KWD_THREE              0x00008U
	#define STR2M_2_KWD_SEVEN              0x00080U
	#define STR2M_2_KWD_ELEVEN             0x00800U
	#define STR2M_2_KWD_NINTEEN            0x80000U

	/** bits in ONE_SEVEN mask:
	 *  one   seven */
	#define STR2M_2_KWD_ONE_SEVEN_MASK     0x00081U

	/** bits omitted from NOT_ONE_SEVEN mask:
	 *  three   eleven  ninteen */
	#define STR2M_2_KWD_NOT_ONE_SEVEN_MASK 0x00081U

	/** all bits in str2m_2_mask_t masks */
	#define STR2M_2_KWD_MASK_ALL           0x80889U

	/** no bits in str2m_2_mask_t */
	#define STR2M_2_KWD_EMPTY              0x00000U

	/** buffer size needed to hold all bit names for str2m_2_mask_t masks */
	#define MAX_STR2M_2_NAME_SIZE 31

	extern str2m_2_mask_t
	str2m_2_str2mask(char const * str, str2m_2_mask_t old);

	extern size_t
	str2m_2_mask2str(str2m_2_mask_t mask, char * buf, size_t len);

	#endif /* STR2ENUM_STR2M_2_H_GUARD */
	_EOF_

mask_all=`
    sed -n '/KWD_MASK_ALL/{;s/.*0x/0x/;s/UL*$//;p;q;}' $testname-h2.base`

cat > $testname-c2.base <<- _EOF_
	 * Convert a command (keyword) to a str2m_2_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 STR2M_2_COUNT_KWDBNM.
	 */
	static str2m_2_enum_t
	find_str2m_2_kwdbnm(char const * str, size_t len)
	{
	    str2m_2_map_t const * map;

	    map = find_str2m_2_name(str, (unsigned int)len);
	    return (map == NULL) ? STR2M_2_COUNT_KWDBNM : map->str2m_2_id;
	}

	/**
	 * Convert an str2m_2_enum_t value into a string.
	 *
	 * @param[in] id  the enumeration value
	 * @returns the associated string, or "* UNDEFINED *" if \a id
	 * is out of range.
	 */
	static char const *
	str2m_2_name(str2m_2_enum_t id)
	{
	    static char const undef[] = "* UNDEFINED *";
	    static char const * const nm_table[] = {
	        [STR2M_2_KWDBNM_ELEVEN  ] = "eleven",
	        [STR2M_2_KWDBNM_NINTEEN ] = "ninteen",
	        [STR2M_2_KWDBNM_ONE     ] = "one",
	        [STR2M_2_KWDBNM_SEVEN   ] = "seven",
	        [STR2M_2_KWDBNM_THREE   ] = "three" };
	    char const * res = undef;
	    if (id < STR2M_2_COUNT_KWDBNM) {
	        res = nm_table[id];
	        if (res == NULL)
	            res = undef;
	    }
	    return res;
	}

	#include <sys/types.h>
	#include <string.h>
	#ifndef NUL
	#define NUL '\0'
	#endif

	/**
	 * Convert a string to a str2m_2_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.
	 */
	str2m_2_mask_t
	str2m_2_str2mask(char const * str, str2m_2_mask_t old)
	{
	    static char const white[] = " \t\f";
	    static char const name_chars[] =
	        "ehilnorstv"
	        "EHILNORSTV";

	    str2m_2_mask_t res = 0;
	    int have_data = 0;

	    for (;;) {
	        str2m_2_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_str2m_2_kwdbnm(str, val_len);
	        if (val == STR2M_2_COUNT_KWDBNM)
	            return 0;
	        if (invert)
	            res &= ~((str2m_2_mask_t)1 << val);
	        else
	            res |= (str2m_2_mask_t)1 << val;
	        have_data = 1;
	        str += val_len;
	    }
	}

	/**
	 * Convert a str2m_2_mask_t mask to a string.
	 *
	 * @param[in]  mask  the mask with the bits to be named
	 * @param[out] buf   where to store the result.  This may be NULL.
	 * @param[in]  len   size of the output buffer
	 * @results    The full length of the space needed for the result,
	 * including the terminating NUL byte.  The actual result will not
	 * overwrite \a len bytes at \a buf.  This value will also never
	 * exceed MAX_STR2M_2_NAME_SIZE.
	 */
	size_t
	str2m_2_mask2str(str2m_2_mask_t mask, char * buf, size_t len)
	{
	    str2m_2_enum_t val = (str2m_2_enum_t)0;
	    size_t res = 0;
	    if (buf == NULL) len = 0;

	    for (; mask != 0; val++, mask >>= 1) {
	        char const * p;
	        size_t l;

	        if (val >= STR2M_2_COUNT_KWDBNM)
	            break;

	        if ((mask & 1) == 0)
	            continue;

	        p = str2m_2_name(val);
	        if (*p == '*')
	            continue; /* ignore invalid bits */

	        l = strlen(p) + 1; /* includes NUL byte or spacer byte */
	        if (l <= len) {
	            if (res > 0)
	                *(buf++) = ' ';
	            memcpy(buf, p, l);
	            buf += l - 1;
	            len -= l;
	        }
	        res += l;
	    }
	    return (res == 0) ? 1 : res;
	}
	/* end of str2m-2.c */
	_EOF_

# # # # # # # # # # RUN THE TEST PART 2 # # # # # # #

echo run_ag x ${AGCMD} -T str2mask $testname.def
echo "base-name = '$testname-2'; prefix = '${testname}_2';" >> $testname.def
run_ag x ${AGCMD} -T str2mask $testname.def || \
    failure ${AGCMD} failed
get_h_text='/#ifndef .*_GUARD/,/#endif .*_GUARD/p'
${SED} -n "${get_h_text}" $testname-2.h > $testname-h2.res
get_c_text=`echo "$get_c_text" | ${SED} "$rep_name"`
${SED} -n "/_names+/d;${get_c_text}" $testname-2.c > $testname-c2.res

fpair="$testname-h2.base $testname-h2.res"
cmp -s $fpair || \
    failure "$testname-2 $fpair failed`echo
        diff $fpair`"

fpair="$testname-c2.base $testname-c2.res"
cmp -s $fpair || \
    failure "$testname-2 $fpair failed`echo
        diff $fpair`"

# # # # # # # # # # RUN THE TEST PART 3 # # # # # # #

echo running $testname-2.c program
chmod 666 $testname-2.c
cmd_sum=`echo $cmd_list | sed 's/ / + /g'`
cat > $testname-main.c <<- _EOF_
	#include <stdio.h>
	#include "$testname-2.c"
	int main(int argc, char ** argv) {
	    str2m_2_mask_t mask =
	        str2m_2_str2mask("${cmd_sum}", 0);
	    char buf[MAX_STR2M_2_NAME_SIZE];
	    size_t l = str2m_2_mask2str(mask, buf, MAX_STR2M_2_NAME_SIZE);

	    printf("0x%04X --> %u bytes: '%s'\n",
	           (unsigned int)mask, (unsigned int)l, buf);
	    if (l != MAX_STR2M_2_NAME_SIZE) {
	        fprintf(stderr, "expected len:  %u, actual:  %u\n",
	                MAX_STR2M_2_NAME_SIZE, (unsigned int)l);
	        return 1;
	    }
	    mask = str2m_2_str2mask("- three - eleven - ninteen", mask);
	    if (mask != STR2M_2_KWD_NOT_ONE_SEVEN_MASK) {
	        fprintf(stderr, "0x%04X != 0x%04X\n", mask,
	                STR2M_2_KWD_NOT_ONE_SEVEN_MASK);
	        return 1;
	    }
	    return 0;
	}
	_EOF_

${CC:-cc} -o ${testname} $testname-main.c || \
    failure "cannot compile $testname-2.c"
./${testname} > ${testname}-btest
echo "$mask_all --> $(( ${#cmd_list} + 1 )) bytes: '$cmd_list'" \
    > ${testname}-bbase
fpair="${testname}-bbase ${testname}-btest"
cmp -s $fpair || \
    failure "$testname $fpair run failed`echo
        diff $fpair`"

cleanup

## Local Variables:
## mode: shell-script
## indent-tabs-mode: nil
## sh-indentation: 4
## sh-basic-offset: 4
## End:

# end of str2m.test