/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * After having been declared, events, FMRIs and authorities must be defined
 * (instantiated) before they can be used as the subjects of commands.
 */

#include <sys/sysmacros.h>
#include <libnvpair.h>
#include <string.h>
#include <assert.h>

#include <inj_event.h>
#include <inj_err.h>
#include <inj_lex.h>
#include <inj_string.h>
#include <inj.h>

static inj_hash_t inj_defns[3];
static int inj_defns_initialized;

/* Intrinsics (signed and unsigned integer integer constants) */
typedef struct intr {
        uchar_t ei_signed;
        uchar_t ei_width;
} intr_t;

static inj_hash_t *
item2hash(inj_itemtype_t item)
{
        int i;

        assert(item >= 0 && item < sizeof (inj_defns) / sizeof (inj_hash_t));

        if (!inj_defns_initialized) {
                for (i = 0; i < sizeof (inj_defns) / sizeof (inj_hash_t); i++)
                        inj_strhash_create(&inj_defns[i]);
                inj_defns_initialized = 1;
        }

        return (&inj_defns[item]);
}

inj_defn_t *
inj_defn_lookup(const char *name, inj_memtype_t type)
{
        inj_hash_t *hash = item2hash(inj_mem2item(type));
        inj_var_t *v;

        if ((v = inj_strhash_lookup(hash, name)) == NULL)
                return (NULL);

        return (inj_hash_get_cookie(v));
}

static void
inj_defn_destroy_memlist(inj_defnmem_t *m)
{
        inj_defnmem_t *n;

        for (/* */; m != NULL; m = n) {
                n = inj_list_next(m);

                switch (m->dfm_type) {
                case DEFNMEM_ARRAY:
                case DEFNMEM_LIST:
                        inj_defn_destroy_memlist(inj_list_next(&m->dfm_list));
                        break;
                default:
                        inj_strfree(m->dfm_str);
                }
        }
}

void
inj_defn_destroy(inj_defn_t *defn)
{
        if (defn->defn_name != NULL)
                inj_strfree(defn->defn_name);

        nvlist_free(defn->defn_nvl);

        inj_defn_destroy_memlist(inj_list_next(&defn->defn_members));
}

static inj_defnmem_t *
inj_defn_mem_create_common(inj_defnmemtype_t type)
{
        inj_defnmem_t *dfm = inj_zalloc(sizeof (inj_defnmem_t));

        dfm->dfm_type = type;
        dfm->dfm_lineno = yylineno;

        return (dfm);
}

inj_defnmem_t *
inj_defn_mem_create(const char *str, inj_defnmemtype_t type)
{
        inj_defnmem_t *dfm = inj_defn_mem_create_common(type);

        dfm->dfm_str = str;

        return (dfm);
}

inj_defnmem_t *
inj_defn_mem_create_list(inj_defn_t *list, inj_defnmemtype_t type)
{
        inj_defnmem_t *dfm = inj_defn_mem_create_common(type);

        dfm->dfm_list = list->defn_members;

        inj_free(list, sizeof (inj_defn_t));

        return (dfm);
}

inj_defn_t *
inj_defn_create(inj_defnmem_t *dfm)
{
        inj_defn_t *defn = inj_zalloc(sizeof (inj_defn_t));

        defn->defn_lineno = yylineno;

        inj_list_append(&defn->defn_members, dfm);

        return (defn);
}

void
inj_defn_addmem(inj_defn_t *defn, inj_defnmem_t *dfm)
{
        inj_list_append(&defn->defn_members, dfm);
}

/*
 * Validate the dimensions of an array.  If the declared array size was zero,
 * accept (and return) whatever the definition used.  If fewer cells were
 * defined than were declared, return the declared size - the calling code will
 * fill the remaining cells with zeros.  The definition of more than the
 * declared number of cells triggers an error.  We print and error message in
 * this case and return the declared number.  This will allow processing to
 * continue.  The act of emitting the error will guarantee that we never
 * pass from parsing to program execution.
 */
static size_t
array_dim_check(inj_declmem_t *dlm, inj_defnmem_t *dfm)
{
        inj_list_t *l;
        size_t dfnelems;

        for (dfnelems = 0, l = inj_list_next(&dfm->dfm_list); l != NULL;
            l = inj_list_next(l), dfnelems++);

        if (dlm->dlm_arrdim != 0 && dlm->dlm_arrdim != dfnelems) {
                yyerror(" %d: defined array has %d elements, expected %d\n",
                    dfm->dfm_lineno, dfnelems, dlm->dlm_arrdim);
                dfnelems = dlm->dlm_arrdim;
        }

        return (MAX(dfnelems, dlm->dlm_arrdim));
}

/*
 * The inj_defn_memcmp_* routines serve two purposes.  First, they compare a
 * given defined member with the corresponding declared member, signalling an
 * error if the two are incompatible.
 *
 * Assuming that validation succeeds, an entry is added to the passed nvlist
 * for the defined member.
 */

/* Used to ease signed and unsigned integer validation */
static const intr_t inj_intrinsics[] = {
        { 0, 0 }, /* MEMTYPE_UNKNOWN */
        { 1, 8 }, { 1, 16 }, { 1, 32 }, { 1, 64 },
        { 0, 8 }, { 0, 16 }, { 0, 32 }, { 0, 64 }
};

static int
inj_defn_memcmp_signed(const intr_t *intr, inj_declmem_t *dlm,
    inj_defnmem_t *dfm, nvlist_t *nvl)
{
        longlong_t val;

        if (dfm->dfm_type != DEFNMEM_IMM && dfm->dfm_type != DEFNMEM_IDENT)
                return (inj_set_errno(EINVAL));

        if (inj_strtoll(dfm->dfm_str, intr->ei_width, &val) < 0)
                return (-1); /* errno is set for us */

        switch (dlm->dlm_type) {
        case MEMTYPE_INT8:
                errno = nvlist_add_int8(nvl, (char *)dlm->dlm_name,
                    (int8_t)val);
                break;
        case MEMTYPE_INT16:
                errno = nvlist_add_int16(nvl, (char *)dlm->dlm_name,
                    (int16_t)val);
                break;
        case MEMTYPE_INT32:
                errno = nvlist_add_int32(nvl, (char *)dlm->dlm_name,
                    (int32_t)val);
                break;
        case MEMTYPE_INT64:
                errno = nvlist_add_int64(nvl, (char *)dlm->dlm_name,
                    (int64_t)val);
        }

        if (errno != 0)
                die("failed to add member %s\n", dlm->dlm_name);

        return (0);
}

static int
inj_defn_memcmp_unsigned(const intr_t *intr, inj_declmem_t *dlm,
    inj_defnmem_t *dfm, nvlist_t *nvl)
{
        u_longlong_t val;

        if (dfm->dfm_type != DEFNMEM_IMM && dfm->dfm_type != DEFNMEM_IDENT)
                return (inj_set_errno(EINVAL));

        if (inj_strtoull(dfm->dfm_str, intr->ei_width, &val) < 0)
                return (-1); /* errno is set for us */

        switch (dlm->dlm_type) {
        case MEMTYPE_UINT8:
                errno = nvlist_add_uint8(nvl, (char *)dlm->dlm_name,
                    (uint8_t)val);
                break;
        case MEMTYPE_UINT16:
                errno = nvlist_add_uint16(nvl, (char *)dlm->dlm_name,
                    (uint16_t)val);
                break;
        case MEMTYPE_UINT32:
                errno = nvlist_add_uint32(nvl, (char *)dlm->dlm_name,
                    (uint32_t)val);
                break;
        case MEMTYPE_UINT64:
                errno = nvlist_add_uint64(nvl, (char *)dlm->dlm_name,
                    (uint64_t)val);
        }

        if (errno != 0)
                die("failed to add member %s\n", dlm->dlm_name);

        return (0);
}

/* Validate an array of (un)signed integers. */
static int
inj_defn_memcmp_intr_array(const intr_t *cont, inj_declmem_t *dlm,
    inj_defnmem_t *dfm, nvlist_t *nvl)
{
        typedef int (*adder_t)();
        static const adder_t signed_adders[] = {
                NULL, nvlist_add_int8_array, nvlist_add_int16_array,
                NULL, nvlist_add_int32_array, NULL, NULL, NULL,
                nvlist_add_int64_array
        };
        static const adder_t unsigned_adders[] = {
                NULL,
                nvlist_add_uint8_array, nvlist_add_uint16_array,
                NULL, nvlist_add_uint32_array, NULL, NULL, NULL,
                nvlist_add_uint64_array
        };

        union {
                char *a;
                int8_t *a8; uint8_t *au8;
                int16_t *a16; uint16_t *au16;
                int32_t *a32; uint32_t *au32;
                int64_t *a64; uint64_t *au64;
        } a;

        int (*adder)(nvlist_t *, const char *, char *, uint_t);
        size_t nelems;
        inj_defnmem_t *elem;
        char *arrbase, *arr;
        size_t arrsz;
        int err = 0;
        int i;

        if (dfm->dfm_type != DEFNMEM_ARRAY)
                return (inj_set_errno(EINVAL));

        /*
         * Each nvlist array adder wants an array of its own type as input,
         * which is reasonable, but it complicates our general implementation.
         * We fight back with casting magic.
         */

        nelems = array_dim_check(dlm, dfm);
        arrsz = (nelems + 1) * (cont->ei_width / NBBY);
        arrbase = inj_zalloc(arrsz);
        a.a = arr = (char *)P2ROUNDUP((uintptr_t)arrbase,
            cont->ei_width / NBBY);

        adder = (cont->ei_signed ? signed_adders :
            unsigned_adders)[cont->ei_width / NBBY];
        assert(adder != NULL);

        for (i = 1, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
            elem = inj_list_next(elem), i++) {
                if (elem->dfm_type != DEFNMEM_IMM &&
                    elem->dfm_type != DEFNMEM_IDENT) {
                        yyerror(" %d: array cell %d is invalid\n",
                            dfm->dfm_lineno, i);
                        err++;
                        continue;
                }

                if (cont->ei_signed) {
                        longlong_t val;

                        if (inj_strtoll(elem->dfm_str, cont->ei_width,
                            &val) < 0) {
                                yyerror(" %d: array cell %d %s\n",
                                    dfm->dfm_lineno, i, (errno == ERANGE ?
                                    "out of range for type" : "invalid"));
                                err++;
                                continue;
                        }

                        switch (cont->ei_width) {
                        case 8:
                                *a.a8++ = (int8_t)val;
                                break;
                        case 16:
                                *a.a16++ = (int16_t)val;
                                break;
                        case 32:
                                *a.a32++ = (int32_t)val;
                                break;
                        default:
                                *a.a64++ = (int64_t)val;
                        }

                } else {
                        u_longlong_t val;

                        if (inj_strtoull(elem->dfm_str, cont->ei_width,
                            &val) < 0) {
                                yyerror(" %d: array cell %d %s\n",
                                    dfm->dfm_lineno, i, (errno == ERANGE ?
                                    "out of range for type" : "invalid"));
                                err++;
                                continue;
                        }

                        switch (cont->ei_width) {
                        case 8:
                                *a.au8++ = (uint8_t)val;
                                break;
                        case 16:
                                *a.au16++ = (uint16_t)val;
                                break;
                        case 32:
                                *a.au32++ = (uint32_t)val;
                                break;
                        default:
                                *a.au64++ = (uint64_t)val;
                        }
                }
        }

        if (err == 0 && (errno = adder(nvl, dlm->dlm_name, arr, nelems)) != 0)
                die("failed to add array member %s", dlm->dlm_name);

        inj_free(arrbase, arrsz);

        if (err != 0)
                return (inj_set_errno(EINVAL));

        return (0);
}

static int
bool2val(const char *str, boolean_t *valp)
{
        if (strcasecmp(str, "true") == 0)
                *valp = 1;
        else if (strcasecmp(str, "false") == 0)
                *valp = 0;
        else
                return (-1);

        return (0);
}

static int
inj_defn_memcmp_bool(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
{
        boolean_t val;

        if (dfm->dfm_type != DEFNMEM_IDENT)
                return (inj_set_errno(EINVAL));

        if (bool2val(dfm->dfm_str, &val) < 0)
                return (inj_set_errno(EINVAL));

        if ((errno = nvlist_add_boolean_value(nvl, (char *)dlm->dlm_name,
            val)) != 0)
                die("failed to add boolean member %s", dlm->dlm_name);

        return (0);
}

static int
inj_defn_memcmp_bool_array(inj_declmem_t *dlm, inj_defnmem_t *dfm,
    nvlist_t *nvl)
{
        inj_defnmem_t *elem;
        boolean_t *arr;
        size_t nelems, arrsz;
        int err = 0;
        int i;

        if (dfm->dfm_type != DEFNMEM_ARRAY)
                return (inj_set_errno(EINVAL));

        nelems = array_dim_check(dlm, dfm);
        arrsz = nelems * sizeof (boolean_t);
        arr = inj_zalloc(arrsz);

        for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
            elem = inj_list_next(elem), i++) {
                if (elem->dfm_type != DEFNMEM_IDENT) {
                        yyerror(" %d: array cell %d is invalid\n",
                            dfm->dfm_lineno, i + 1);
                        err++;
                        continue;
                }

                if (bool2val(elem->dfm_str, &arr[i]) < 0)
                        return (inj_set_errno(EINVAL));
        }

        if (err == 0 && (errno = nvlist_add_boolean_array(nvl,
            (char *)dlm->dlm_name, arr, nelems)) != 0)
                die("failed to add boolean array member %s", dlm->dlm_name);

        inj_free(arr, arrsz);

        return (0);
}

/* Used for both strings and enums */
static int
inj_defn_memcmp_strenum(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
{
        inj_defnmemtype_t defnmemtype = (dlm->dlm_type == MEMTYPE_ENUM ?
            DEFNMEM_IDENT : DEFNMEM_QSTRING);
        const char *strenum = (dlm->dlm_type == MEMTYPE_ENUM ? "enum" :
            "string");

        if (dfm->dfm_type != defnmemtype)
                return (inj_set_errno(EINVAL));

        if ((errno = nvlist_add_string(nvl, (char *)dlm->dlm_name,
            (char *)dfm->dfm_str)) != 0)
                die("failed to add %s member %s", strenum, dlm->dlm_name);

        return (0);
}

static int
inj_defn_memcmp_strenum_array(inj_declmem_t *dlm, inj_defnmem_t *dfm,
    nvlist_t *nvl)
{
        inj_defnmemtype_t defnmemtype = (dlm->dlm_type == MEMTYPE_ENUM ?
            DEFNMEM_IDENT : DEFNMEM_QSTRING);
        const char *strenum = (dlm->dlm_type == MEMTYPE_ENUM ? "enum" :
            "string");

        inj_defnmem_t *elem;
        size_t nelems, arrsz;
        const char **arr;
        int err = 0;
        int i;

        if (dfm->dfm_type != DEFNMEM_ARRAY)
                return (inj_set_errno(EINVAL));

        nelems = array_dim_check(dlm, dfm);
        arrsz = nelems * sizeof (char *);
        arr = inj_zalloc(arrsz);

        for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
            elem = inj_list_next(elem), i++) {
                if (elem->dfm_type != defnmemtype) {
                        yyerror(" %d: array cell %d is invalid\n",
                            dfm->dfm_lineno, i + 1);
                        err++;
                        continue;
                }

                if (dlm->dlm_type == MEMTYPE_ENUM &&
                    inj_strhash_lookup(dlm->dlm_enumvals, elem->dfm_str) ==
                    NULL) {
                        yyerror(" %d: invalid enum value %s\n",
                            dfm->dfm_lineno, elem->dfm_str);
                        err++;
                        continue;
                }

                arr[i] = elem->dfm_str;
        }

        if (err == 0 && (errno = nvlist_add_string_array(nvl,
            dlm->dlm_name, (char **)arr, nelems)) != 0)
                die("failed to add %s array member %s", strenum, dlm->dlm_name);

        inj_free(arr, arrsz);
        return (0);
}

/*
 * Validator for embedded lists (events, fmris, authorities, lists, etc.).
 * There are two cases to deal with here.  The user could either have provided
 * the name of a previously-defined list, in which case we just make a copy of
 * said list for insertion into ours.  Alternatively, the user could simply
 * define a new list here.  In that case, we recursively invoke the member
 * comparator, but against the list type for the member being defined.
 */
static nvlist_t *inj_defn_validate_memlist(inj_declmem_t *, inj_defnmem_t *);

/* Embedded definition */
static nvlist_t *
inj_defn_memcmp_sub_list(inj_declmem_t *dlm, inj_defnmem_t *dfm)
{
        inj_declmem_t *subdlm = inj_list_next(&dlm->dlm_decl->decl_members);
        inj_defnmem_t *subdfm = inj_list_next(&dfm->dfm_list);

        return (inj_defn_validate_memlist(subdlm, subdfm));
}

/* Reference to previously-defined thing */
static nvlist_t *
inj_defn_memcmp_sub_defined(inj_declmem_t *dlm, inj_defnmem_t *dfm)
{
        inj_defn_t *subdefn;
        nvlist_t *new;

        if ((subdefn = inj_defn_lookup(dfm->dfm_str, dlm->dlm_type)) == NULL) {
                yyerror(" %d: reference to undefined %s %s\n", dfm->dfm_lineno,
                    inj_mem2str(dlm->dlm_type), dfm->dfm_str);
                (void) inj_set_errno(EINVAL);
                return (NULL);
        }

        if (subdefn->defn_decl != dlm->dlm_decl) {
                yyerror(" %d: %s %s is not a(n) %s\n", dfm->dfm_lineno,
                    inj_mem2str(dlm->dlm_type), dfm->dfm_str,
                    subdefn->defn_decl->decl_name);
                (void) inj_set_errno(EINVAL);
                return (NULL);
        }

        assert(subdefn->defn_nvl != NULL);

        if ((errno = nvlist_dup(subdefn->defn_nvl, &new, 0)) != 0) {
                die("failed to duplicate %s list %s",
                    inj_item2str(subdefn->defn_decl->decl_type), dfm->dfm_str);
        }

        return (new);
}

static nvlist_t *
inj_defn_memcmp_sub_makenvl(inj_declmem_t *dlm, inj_defnmem_t *dfm)
{
        inj_defnmemtype_t dftype = dfm->dfm_type;
        inj_memtype_t dltype = dlm->dlm_type;
        nvlist_t *new = NULL;

        if (dftype == DEFNMEM_LIST)
                new = inj_defn_memcmp_sub_list(dlm, dfm);
        else if (dftype == DEFNMEM_IDENT && (dltype == MEMTYPE_EVENT ||
            dltype == MEMTYPE_FMRI || dltype == MEMTYPE_AUTH))
                new = inj_defn_memcmp_sub_defined(dlm, dfm);
        else
                (void) inj_set_errno(EINVAL);

        return (new);
}

/* A single sub-list */
static int
inj_defn_memcmp_sub(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
{
        nvlist_t *new;

        if ((new = inj_defn_memcmp_sub_makenvl(dlm, dfm)) == NULL)
                return (-1); /* errno is set for us */

        if ((errno = nvlist_add_nvlist(nvl, (char *)dlm->dlm_name,
            new)) != 0)
                die("failed to add list member %s", dlm->dlm_name);

        return (0);
}

/* An array of sub-lists (for example, an array of events of a given type) */
static int
inj_defn_memcmp_sub_array(inj_declmem_t *dlm, inj_defnmem_t *dfm, nvlist_t *nvl)
{
        size_t nelems, arrsz;
        inj_defnmem_t *elem;
        nvlist_t **arr;
        int err = 0;
        int i;

        if (dfm->dfm_type != DEFNMEM_ARRAY)
                return (inj_set_errno(EINVAL));

        nelems = array_dim_check(dlm, dfm);
        arrsz = nelems * sizeof (char *);
        arr = inj_zalloc(arrsz);

        for (i = 0, elem = inj_list_next(&dfm->dfm_list); elem != NULL;
            elem = inj_list_next(elem), i++) {
                if ((arr[i] = inj_defn_memcmp_sub_makenvl(dlm, elem)) == NULL) {
                        yyerror(" %d: array cell %d is invalid\n",
                            elem->dfm_lineno, i + 1);
                        err++;
                        continue;
                }
        }

        if (err == 0 && (errno = nvlist_add_nvlist_array(nvl,
            (char *)dlm->dlm_name, arr, nelems)) != 0)
                die("failed to add nvlist list member %s", dlm->dlm_name);

        inj_free(arr, arrsz);

        return (0);
}

/*
 * The declaration-definition member comparator.  Designed to recursive
 * invocation to allow for the validation of embedded/referenced lists.
 */
nvlist_t *
inj_defn_validate_memlist(inj_declmem_t *dlm, inj_defnmem_t *dfm)
{
        const intr_t *intr;
        nvlist_t *nvl;
        int rc, nmem, dlnmem, dfnmem;
        int err = 0;

        if ((errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0)
                die("failed to allocate nvl for event");

        for (nmem = 1; dlm != NULL && dfm != NULL;
            dlm = inj_list_next(dlm), dfm = inj_list_next(dfm), nmem++) {

                switch (dlm->dlm_type) {
                case MEMTYPE_INT8:
                case MEMTYPE_INT16:
                case MEMTYPE_INT32:
                case MEMTYPE_INT64:
                        intr = &inj_intrinsics[dlm->dlm_type];

                        if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
                                rc = inj_defn_memcmp_intr_array(intr, dlm, dfm,
                                    nvl);
                        } else {
                                rc = inj_defn_memcmp_signed(intr, dlm, dfm,
                                    nvl);
                        }
                        break;

                case MEMTYPE_UINT8:
                case MEMTYPE_UINT16:
                case MEMTYPE_UINT32:
                case MEMTYPE_UINT64:
                        intr = &inj_intrinsics[dlm->dlm_type];

                        if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
                                rc = inj_defn_memcmp_intr_array(intr, dlm, dfm,
                                    nvl);
                        } else {
                                rc = inj_defn_memcmp_unsigned(intr, dlm, dfm,
                                    nvl);
                        }
                        break;

                case MEMTYPE_BOOL:
                        if (dlm->dlm_flags & DECLMEM_F_ARRAY)
                                rc = inj_defn_memcmp_bool_array(dlm, dfm, nvl);
                        else
                                rc = inj_defn_memcmp_bool(dlm, dfm, nvl);
                        break;

                case MEMTYPE_STRING:
                        if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
                                rc = inj_defn_memcmp_strenum_array(dlm, dfm,
                                    nvl);
                        } else
                                rc = inj_defn_memcmp_strenum(dlm, dfm, nvl);
                        break;

                case MEMTYPE_ENUM:
                        if (dlm->dlm_flags & DECLMEM_F_ARRAY) {
                                rc = inj_defn_memcmp_strenum_array(dlm, dfm,
                                    nvl);
                        } else
                                rc = inj_defn_memcmp_strenum(dlm, dfm, nvl);
                        break;

                case MEMTYPE_EVENT:
                case MEMTYPE_FMRI:
                case MEMTYPE_AUTH:
                case MEMTYPE_LIST:
                        if (dlm->dlm_flags & DECLMEM_F_ARRAY)
                                rc = inj_defn_memcmp_sub_array(dlm, dfm, nvl);
                        else
                                rc = inj_defn_memcmp_sub(dlm, dfm, nvl);
                        break;

                default:
                        die("unknown decl member type %d on member %s\n",
                            dlm->dlm_type, dlm->dlm_name);
                }

                if (rc < 0) {
                        yyerror(" %d: %s for member %s\n", dfm->dfm_lineno,
                            (errno == ERANGE ? "value out of range" :
                            "invalid value"), dlm->dlm_name);
                        err++;
                }
        }

        dlnmem = dfnmem = nmem;

        while (dlm != NULL) {
                dlm = inj_list_next(dlm);
                dlnmem++;
        }

        while (dfm != NULL) {
                dfm = inj_list_next(dfm);
                dfnmem++;
        }

        if (dlnmem != dfnmem) {
                yyerror("%d members found, expected %d", dfnmem, dlnmem);
                err++;
        }

        if (err > 0) {
                nvlist_free(nvl);
                return (NULL);
        }

        return (nvl);
}

/*
 * The members have all been defined.  Validate the members against the
 * declaration, and add it to the appropriate "defined" list.
 */
void
inj_defn_finish(inj_defn_t *defn, const char *declnm, const char *name,
    inj_itemtype_t type)
{
        inj_decl_t *decl = inj_decl_lookup(declnm, type);
        inj_hash_t *hash = item2hash(type);
        inj_declmem_t *dlm;
        inj_defnmem_t *dfm;
        inj_var_t *v;

        defn->defn_name = name;
        defn->defn_decl = decl;

        if (decl == NULL) {
                yyerror("unknown %s type %s\n", inj_item2str(type), declnm);
                inj_defn_destroy(defn);
                return;
        }

        dlm = inj_list_next(&decl->decl_members);
        dfm = inj_list_next(&defn->defn_members);

        if ((defn->defn_nvl = inj_defn_validate_memlist(dlm, dfm)) == NULL) {
                inj_defn_destroy(defn);
                return;
        }

        if (type == ITEMTYPE_EVENT) {
                if ((errno = nvlist_add_string(defn->defn_nvl, "class",
                    (char *)defn->defn_decl->decl_name)) != 0)
                        die("failed to add class to %s", name);
        }

        if ((v = inj_strhash_lookup(hash, name)) != NULL) {
                inj_defn_t *other = inj_hash_get_cookie(v);

                yyerror("duplicate %s name %s (other on line %d)\n",
                    inj_item2str(type), name, other->defn_lineno);
                inj_defn_destroy(defn);
                return;
        }

        (void) inj_strhash_insert(hash, name, (uintptr_t)defn);
}