/*
 * 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);
}