fminject/common/inj_decl.c

	inj_decl.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Events, FMRIs and authorities must be declared before they can be used.
 * Routines in this file, driven by the parser, create the data structures
 * associated with the declarations.
 */

#include <assert.h>
#include <string.h>

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

static inj_hash_t inj_decls[3];
static int inj_decls_initialized;

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

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

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

    return (&inj_decls[item]);
}

inj_decl_t *
inj_decl_lookup(const char *name, inj_itemtype_t type)
{
    inj_hash_t *hash = item2hash(type);
    inj_var_t *v;

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

    return (inj_hash_get_cookie(v));
}

void
inj_decl_mem_destroy(inj_declmem_t *dlm)
{
    inj_strfree(dlm->dlm_name);

    if (dlm->dlm_type == MEMTYPE_ENUM)
        inj_strhash_destroy(dlm->dlm_enumvals);
}

inj_declmem_t *
inj_decl_mem_create(const char *name, inj_memtype_t type)
{
    inj_declmem_t *dlm = inj_zalloc(sizeof (inj_declmem_t));

    dlm->dlm_name = name;
    dlm->dlm_type = type;

    return (dlm);
}

/* An embedded event, authority, or FMRI */
inj_declmem_t *
inj_decl_mem_create_defined(const char *name, const char *declnm,
    inj_itemtype_t type)
{
    inj_declmem_t *dlm = inj_zalloc(sizeof (inj_declmem_t));

    dlm->dlm_name = name;
    dlm->dlm_type = inj_item2mem(type);

    if ((dlm->dlm_decl = inj_decl_lookup(declnm, type)) == NULL) {
        yyerror("unknown %s %s", inj_item2str(type), declnm);
        return (NULL);
    }

    return (dlm);
}

inj_declmem_t *
inj_decl_mem_create_enum(const char *name, inj_hash_t *vals)
{
    inj_declmem_t *dlm = inj_zalloc(sizeof (inj_declmem_t));

    dlm->dlm_name = name;
    dlm->dlm_type = MEMTYPE_ENUM;
    dlm->dlm_enumvals = vals;

    return (dlm);
}

/* Turn a previously-declared member into an array */
void
inj_decl_mem_make_array(inj_declmem_t *dlm, uint_t dim)
{
    dlm->dlm_flags |= DECLMEM_F_ARRAY;
    dlm->dlm_arrdim = dim;
}

void
inj_decl_destroy(inj_decl_t *decl)
{
    inj_declmem_t *m, *n;

    inj_strfree(decl->decl_name);
    inj_strhash_destroy(&decl->decl_memhash);

    for (m = inj_list_next(&decl->decl_members); m != NULL; m = n) {
        n = inj_list_next(m);

        inj_decl_mem_destroy(m);
    }

    inj_free(decl, sizeof (inj_declmem_t));
}

inj_decl_t *
inj_decl_create(inj_declmem_t *dlm)
{
    inj_decl_t *decl = inj_zalloc(sizeof (inj_decl_t));

    decl->decl_lineno = yylineno;

    inj_strhash_create(&decl->decl_memhash);

    inj_list_append(&decl->decl_members, dlm);
    (void) inj_strhash_insert(&decl->decl_memhash, dlm->dlm_name,
        (uintmax_t)dlm);

    return (decl);
}

void
inj_decl_addmem(inj_decl_t *decl, inj_declmem_t *dlm)
{
    inj_var_t *v;

    if ((v = inj_strhash_lookup(&decl->decl_memhash, dlm->dlm_name)) !=
        NULL) {
        inj_decl_t *other = inj_hash_get_cookie(v);

        yyerror("duplicate member name %s (other on line %d)\n",
            dlm->dlm_name, other->decl_lineno);
        inj_decl_destroy(decl);
        return;
    }

    inj_list_append(&decl->decl_members, dlm);
    (void) inj_strhash_insert(&decl->decl_memhash, dlm->dlm_name,
        (uintmax_t)dlm);
}

/*
 * The various declaration types - events, FMRIs, and authorities - each have
 * their own semantic validation requirements.
 */

/* No user-defined class member.  If ena isn't present, we'll generate it */
static int
inj_decl_validate_event(inj_decl_t *decl)
{
    if (inj_strhash_lookup(&decl->decl_memhash, "class") != NULL) {
        yyerror("class may not be explicitly declared\n");
        return (0);
    }

    if (inj_strhash_lookup(&decl->decl_memhash, "ena") == NULL)
        decl->decl_flags |= DECL_F_AUTOENA;

    return (1);
}

/* FMRIs must have a string scheme member */
static int
inj_decl_validate_fmri(inj_decl_t *decl)
{
    inj_declmem_t *dlm;
    inj_var_t *v;

    if ((v = inj_strhash_lookup(&decl->decl_memhash, "scheme")) == NULL) {
        yyerror("fmri declared without scheme member\n");
        return (0);
    }

    dlm = inj_hash_get_cookie(v);
    if (dlm->dlm_type != MEMTYPE_STRING) {
        yyerror("scheme member must be a string\n");
        return (0);
    }

    return (1);
}

/* Authorities don't have any semantic requirements - yet */
/*ARGSUSED*/
static int
inj_decl_validate_auth(inj_decl_t *decl)
{
    return (1);
}

void
inj_decl_finish(inj_decl_t *decl, const char *name, inj_itemtype_t type)
{
    static int (*const validators[])(inj_decl_t *) = {
        inj_decl_validate_event,
        inj_decl_validate_fmri,
        inj_decl_validate_auth
    };

    inj_hash_t *hash = item2hash(type);
    inj_var_t *v;

    decl->decl_name = name;
    decl->decl_type = type;

    if (!validators[type](decl)) {
        inj_decl_destroy(decl);
        return;
    }

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

        yyerror("duplicate %s name %s (other on line %d)\n",
            inj_item2str(type), name, other->decl_lineno);
        inj_decl_destroy(decl);
        return;
    }

    (void) inj_strhash_insert(hash, name, (uintmax_t)decl);
}