eversholt/common/check.c

/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * check.c -- routines for checking the prop tree
 *
 * this module provides semantic checks on the parse tree.  most of
 * these checks happen during the construction of the parse tree,
 * when the various tree_X() routines call the various check_X()
 * routines.  in a couple of special cases, a check function will
 * process the parse tree after it has been fully constructed.  these
 * cases are noted in the comments above the check function.
 */

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

#include <stdio.h>
#include "out.h"
#include "stable.h"
#include "literals.h"
#include "lut.h"
#include "tree.h"
#include "ptree.h"
#include "check.h"

static int check_reportlist(enum nodetype t, const char *s, struct node *np);
static int check_num(enum nodetype t, const char *s, struct node *np);
static int check_quote(enum nodetype t, const char *s, struct node *np);
static int check_num_func(enum nodetype t, const char *s, struct node *np);
static int check_fru_asru(enum nodetype t, const char *s, struct node *np);
static int check_engine(enum nodetype t, const char *s, struct node *np);
static int check_timeval(enum nodetype t, const char *s, struct node *np);
static int check_id(enum nodetype t, const char *s, struct node *np);
static int check_serd_method(enum nodetype t, const char *s, struct node *np);
static int check_nork(struct node *np);
static void check_cycle_lhs(struct node *stmtnp, struct node *arrow);
static void check_cycle_lhs_try(struct node *stmtnp, struct node *lhs,
    struct node *rhs);
static void check_cycle_rhs(struct node *rhs);
static void check_proplists_lhs(enum nodetype t, struct node *lhs);

static struct {
	enum nodetype t;
	const char *name;
	int required;
	int (*checker)(enum nodetype t, const char *s, struct node *np);
	int outflags;
} Allowednames[] = {
	{ T_FAULT, "FITrate", 1, check_num_func, O_ERR },
	{ T_FAULT, "FRU", 0, check_fru_asru, O_ERR },
	{ T_FAULT, "ASRU", 0, check_fru_asru, O_ERR },
	{ T_UPSET, "engine", 0, check_engine, O_ERR },
	{ T_DEFECT, "FRU", 0, check_fru_asru, O_ERR },
	{ T_DEFECT, "ASRU", 0, check_fru_asru, O_ERR },
	{ T_EREPORT, "poller", 0, check_id, O_ERR },
	{ T_EREPORT, "delivery", 0, check_timeval, O_ERR },
	{ T_SERD, "N", 1, check_num, O_ERR },
	{ T_SERD, "T", 1, check_timeval, O_ERR },
	{ T_SERD, "method", 1, check_serd_method, O_ERR },
	{ T_SERD, "trip", 1, check_reportlist, O_ERR },
	{ T_SERD, "FRU", 0, check_fru_asru, O_ERR },
	{ T_ERROR, "ASRU", 0, check_fru_asru, O_ERR },
	{ T_CONFIG, NULL, 0, check_quote, O_ERR },
	{ 0, NULL, 0 },
};

void
check_init(void)
{
	int i;

	for (i = 0; Allowednames[i].t; i++)
		if (Allowednames[i].name != NULL)
			Allowednames[i].name = stable(Allowednames[i].name);
}

void
check_fini(void)
{
}

/*ARGSUSED*/
void
check_report_combination(struct node *np)
{
	/* nothing to check for here.  poller is only prop and it is optional */
}

/*
 * check_path_iterators -- verify all iterators are explicit
 */
static void
check_path_iterators(struct node *np)
{
	if (np == NULL)
		return;

	switch (np->t) {
		case T_ARROW:
			check_path_iterators(np->u.arrow.lhs);
			check_path_iterators(np->u.arrow.rhs);
			break;

		case T_LIST:
			check_path_iterators(np->u.expr.left);
			check_path_iterators(np->u.expr.right);
			break;

		case T_EVENT:
			check_path_iterators(np->u.event.epname);
			break;

		case T_NAME:
			if (np->u.name.child == NULL)
				outfl(O_DIE, np->file, np->line,
				    "internal error: check_path_iterators: "
				    "unexpected implicit iterator: %s",
				    np->u.name.s);
			check_path_iterators(np->u.name.next);
			break;

		default:
			outfl(O_DIE, np->file, np->line,
			    "internal error: check_path_iterators: "
			    "unexpected type: %s",
			    ptree_nodetype2str(np->t));
	}
}

void
check_arrow(struct node *np)
{
	ASSERTinfo(np->t == T_ARROW, ptree_nodetype2str(np->t));

	if (np->u.arrow.lhs->t != T_ARROW &&
	    np->u.arrow.lhs->t != T_LIST &&
	    np->u.arrow.lhs->t != T_EVENT) {
		outfl(O_ERR,
		    np->u.arrow.lhs->file, np->u.arrow.lhs->line,
		    "%s not allowed on left-hand side of arrow",
		    ptree_nodetype2str(np->u.arrow.lhs->t));
	}

	if (!check_nork(np->u.arrow.nnp) ||
		!check_nork(np->u.arrow.knp))
			outfl(O_ERR, np->file, np->line,
			    "counts associated with propagation arrows "
			    "must be integers");

	check_path_iterators(np);
}

/*
 * make sure the nork values are valid.
 * Nork values must be "A" for all(T_NAME),
 * a number(T_NUM), or a simple
 * expression(T_SUB, T_ADD, T_MUL, T_DIV)
 */
static int
check_nork(struct node *np)
{
	int rval = 0;

	/* NULL means no nork value which is allowed */
	if (np == NULL) {
		rval = 1;
	}
	else
	{
		/* if the nork is a name it must be A for "All" */
		if (np->t == T_NAME)
			if (*np->u.name.s == 'A')
				return (1);

		/*  T_NUM allowed */
		if (np->t == T_NUM)
			rval = 1;

		/*  simple expressions allowed */
		if (np->t == T_SUB ||
			np->t == T_ADD ||
			np->t == T_MUL ||
			np->t == T_DIV)
			rval = 1;
	}

	return (rval);
}

static int
check_reportlist(enum nodetype t, const char *s, struct node *np)
{
	if (np == NULL)
		return (1);
	else if (np->t == T_EVENT) {
		if (np->u.event.ename->u.name.t != N_EREPORT) {
			outfl(O_ERR, np->file, np->line,
			    "%s %s property must begin with \"ereport.\"",
			    ptree_nodetype2str(t), s);
		} else if (tree_event2np_lut_lookup(Ereports, np) == NULL) {
			outfl(O_ERR, np->file, np->line,
			    "%s %s property contains undeclared name",
			    ptree_nodetype2str(t), s);
		}
		check_type_iterator(np);
	} else if (np->t == T_LIST) {
		(void) check_reportlist(t, s, np->u.expr.left);
		(void) check_reportlist(t, s, np->u.expr.right);
	}
	return (1);
}

static int
check_num(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_NUM)
		outfl(O_ERR, np->file, np->line,
		    "%s %s property must be a single number",
		    ptree_nodetype2str(t), s);
	return (1);
}

/*ARGSUSED1*/
static int
check_quote(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_QUOTE)
		outfl(O_ERR, np->file, np->line,
		    "%s properties must be quoted strings",
		    ptree_nodetype2str(t));
	return (1);
}

static int
check_num_func(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_NUM && np->t != T_FUNC)
		outfl(O_ERR, np->file, np->line,
		    "%s %s property must be a number or function",
		    ptree_nodetype2str(t), s);
	return (1);
}

static int
check_fru_asru(enum nodetype t, const char *s, struct node *np)
{
	ASSERT(s != NULL);

	/* make sure it is a node type T_NAME? */
	if (np->t == T_NAME) {
	    if (s == L_ASRU) {
		if (tree_name2np_lut_lookup_name(ASRUs, np) == NULL)
			outfl(O_ERR, np->file, np->line,
			    "ASRU property contains undeclared asru");
	    } else if (s == L_FRU) {
		if (tree_name2np_lut_lookup_name(FRUs, np) == NULL)
			outfl(O_ERR, np->file, np->line,
			    "FRU property contains undeclared fru");
	    } else {
		    outfl(O_ERR, np->file, np->line,
			"illegal property name in %s declaration: %s",
			ptree_nodetype2str(t), s);
	    }
	    check_type_iterator(np);
	} else
		outfl(O_ERR, np->file, np->line,
		    "illegal type used for %s property: %s",
		    s, ptree_nodetype2str(np->t));
	return (1);
}

static int
check_engine(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_EVENT)
		outfl(O_ERR, np->file, np->line,
		    "%s %s property must be an engine name "
		    "(i.e. serd.x or serd.x@a/b)",
		    ptree_nodetype2str(t), s);

	return (1);
}

static int
check_timeval(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_TIMEVAL)
		outfl(O_ERR, np->file, np->line,
		    "%s %s property must be a number with time units",
		    ptree_nodetype2str(t), s);
	return (1);
}

static int
check_id(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_NAME || np->u.name.next || np->u.name.child)
		outfl(O_ERR, np->file, np->line,
		    "%s %s property must be simple name",
		    ptree_nodetype2str(t), s);
	return (1);
}

static int
check_serd_method(enum nodetype t, const char *s, struct node *np)
{
	ASSERTinfo(np != NULL, ptree_nodetype2str(t));
	if (np->t != T_NAME || np->u.name.next || np->u.name.child ||
	    (np->u.name.s != L_volatile &&
	    np->u.name.s != L_persistent))
		outfl(O_ERR, np->file, np->line,
		    "%s %s property must be \"volatile\" or \"persistent\"",
		    ptree_nodetype2str(t), s);
	return (1);
}

void
check_stmt_required_properties(struct node *stmtnp)
{
	struct lut *lutp = stmtnp->u.stmt.lutp;
	struct node *np = stmtnp->u.stmt.np;
	int i;

	for (i = 0; Allowednames[i].t; i++)
		if (stmtnp->t == Allowednames[i].t &&
		    Allowednames[i].required &&
		    tree_s2np_lut_lookup(lutp, Allowednames[i].name) == NULL)
			outfl(Allowednames[i].outflags,
			    np->file, np->line,
			    "%s statement missing property: %s",
			    ptree_nodetype2str(stmtnp->t),
			    Allowednames[i].name);
}

void
check_stmt_allowed_properties(enum nodetype t,
    struct node *nvpairnp, struct lut *lutp)
{
	int i;
	const char *s = nvpairnp->u.expr.left->u.name.s;
	struct node *np;

	for (i = 0; Allowednames[i].t; i++)
		if (t == Allowednames[i].t && Allowednames[i].name == NULL) {
			/* NULL name means just call checker */
			(*Allowednames[i].checker)(t, s,
			    nvpairnp->u.expr.right);
			return;
		} else if (t == Allowednames[i].t && s == Allowednames[i].name)
			break;
	if (Allowednames[i].name == NULL)
		outfl(O_ERR, nvpairnp->file, nvpairnp->line,
		    "illegal property name in %s declaration: %s",
		    ptree_nodetype2str(t), s);
	else if ((np = tree_s2np_lut_lookup(lutp, s)) != NULL) {
		/*
		 * redeclaring prop is allowed if value is the same
		 */
		if (np->t != nvpairnp->u.expr.right->t)
			outfl(O_ERR, nvpairnp->file, nvpairnp->line,
			    "property redeclared (with differnt type) "
			    "in %s declaration: %s",
			    ptree_nodetype2str(t), s);
		switch (np->t) {
			case T_NUM:
			case T_TIMEVAL:
				if (np->u.ull == nvpairnp->u.expr.right->u.ull)
					return;
				break;

			case T_NAME:
				if (tree_namecmp(np,
				    nvpairnp->u.expr.right) == 0)
					return;
				break;

			case T_EVENT:
				if (tree_eventcmp(np,
				    nvpairnp->u.expr.right) == 0)
					return;
				break;

			default:
				outfl(O_ERR, nvpairnp->file, nvpairnp->line,
				    "value for property \"%s\" is an "
				    "invalid type: %s",
				    nvpairnp->u.expr.left->u.name.s,
				    ptree_nodetype2str(np->t));
				return;
		}
		outfl(O_ERR, nvpairnp->file, nvpairnp->line,
		    "property redeclared in %s declaration: %s",
		    ptree_nodetype2str(t), s);
	} else
		(*Allowednames[i].checker)(t, s, nvpairnp->u.expr.right);
}

void
check_propnames(enum nodetype t, struct node *np, int from, int to)
{
	struct node *dnp;
	struct lut *lutp;

	ASSERT(np != NULL);
	ASSERTinfo(np->t == T_EVENT || np->t == T_LIST || np->t == T_ARROW,
				ptree_nodetype2str(np->t));

	if (np->t == T_EVENT) {
		switch (np->u.event.ename->u.name.t) {
		case N_UNSPEC:
			outfl(O_ERR, np->file, np->line,
			    "name in %s statement must begin with "
			    "type (example: \"error.\")",
			    ptree_nodetype2str(t));
			return;
		case N_FAULT:
			lutp = Faults;
			if (to) {
				outfl(O_ERR, np->file, np->line,
				    "%s has fault on right side of \"->\"",
				    ptree_nodetype2str(t));
				return;
			}
			if (!from) {
				outfl(O_DIE, np->file, np->line,
				    "internal error: %s has fault without "
				    "from flag",
				    ptree_nodetype2str(t));
			}
			break;
		case N_UPSET:
			lutp = Upsets;
			if (to) {
				outfl(O_ERR, np->file, np->line,
				    "%s has upset on right side of \"->\"",
				    ptree_nodetype2str(t));
				return;
			}
			if (!from)
				outfl(O_DIE, np->file, np->line,
				    "internal error: %s has upset without "
				    "from flag",
				    ptree_nodetype2str(t));
			break;
		case N_DEFECT:
			lutp = Defects;
			if (to) {
				outfl(O_ERR, np->file, np->line,
				    "%s has defect on right side of \"->\"",
				    ptree_nodetype2str(t));
				return;
			}
			if (!from) {
				outfl(O_DIE, np->file, np->line,
				    "internal error: %s has defect without "
				    "from flag",
				    ptree_nodetype2str(t));
			}
			break;
		case N_ERROR:
			lutp = Errors;
			if (!from && !to)
				outfl(O_DIE, np->file, np->line,
				    "%s has error without from or to flags",
				    ptree_nodetype2str(t));
			break;
		case N_EREPORT:
			lutp = Ereports;
			if (from) {
				outfl(O_ERR, np->file, np->line,
				    "%s has report on left side of \"->\"",
				    ptree_nodetype2str(t));
				return;
			}
			if (!to)
				outfl(O_DIE, np->file, np->line,
				    "internal error: %s has report without "
				    "to flag",
				    ptree_nodetype2str(t));
			break;
		default:
			outfl(O_DIE, np->file, np->line,
			    "internal error: check_propnames: "
			    "unexpected type: %d", np->u.name.t);
		}

		if ((dnp = tree_event2np_lut_lookup(lutp, np)) == NULL) {
			outfl(O_ERR, np->file, np->line,
			    "%s statement contains undeclared event",
			    ptree_nodetype2str(t));
		} else
			dnp->u.stmt.flags |= STMT_REF;
		np->u.event.declp = dnp;
	} else if (np->t == T_LIST) {
		check_propnames(t, np->u.expr.left, from, to);
		check_propnames(t, np->u.expr.right, from, to);
	} else if (np->t == T_ARROW) {
		check_propnames(t, np->u.arrow.lhs, 1, to);
		check_propnames(t, np->u.arrow.rhs, from, 1);
	}
}

static struct lut *
record_iterators(struct node *np, struct lut *ex)
{
	if (np == NULL)
		return (ex);

	switch (np->t) {
	case T_ARROW:
		ex = record_iterators(np->u.arrow.lhs, ex);
		ex = record_iterators(np->u.arrow.rhs, ex);
		break;

	case T_LIST:
		ex = record_iterators(np->u.expr.left, ex);
		ex = record_iterators(np->u.expr.right, ex);
		break;

	case T_EVENT:
		ex = record_iterators(np->u.event.epname, ex);
		break;

	case T_NAME:
		if (np->u.name.child && np->u.name.child->t == T_NAME)
			ex = lut_add(ex, (void *) np->u.name.child->u.name.s,
			    (void *) np, NULL);
		ex = record_iterators(np->u.name.next, ex);
		break;

	default:
		outfl(O_DIE, np->file, np->line,
		    "record_iterators: internal error: unexpected type: %s",
		    ptree_nodetype2str(np->t));
	}

	return (ex);
}

void
check_exprscope(struct node *np, struct lut *ex)
{
	if (np == NULL)
		return;

	switch (np->t) {
	case T_EVENT:
		check_exprscope(np->u.event.eexprlist, ex);
		break;

	case T_ARROW:
		check_exprscope(np->u.arrow.lhs, ex);
		check_exprscope(np->u.arrow.rhs, ex);
		break;

	case T_NAME:
		if (np->u.name.child && np->u.name.child->t == T_NAME) {
			if (lut_lookup(ex,
					(void *) np->u.name.child->u.name.s,
					NULL) == NULL)
				outfl(O_ERR, np->file, np->line,
					"constraint contains undefined"
					" iterator: %s",
					np->u.name.child->u.name.s);
		}
		check_exprscope(np->u.name.next, ex);
		break;

	case T_QUOTE:
	case T_GLOBID:
		break;

	case T_ASSIGN:
	case T_NE:
	case T_EQ:
	case T_LIST:
	case T_AND:
	case T_OR:
	case T_NOT:
	case T_ADD:
	case T_SUB:
	case T_MUL:
	case T_DIV:
	case T_MOD:
	case T_LT:
	case T_LE:
	case T_GT:
	case T_GE:
	case T_BITAND:
	case T_BITOR:
	case T_BITXOR:
	case T_BITNOT:
	case T_LSHIFT:
	case T_RSHIFT:
	case T_CONDIF:
	case T_CONDELSE:
		check_exprscope(np->u.expr.left, ex);
		check_exprscope(np->u.expr.right, ex);
		break;

	case T_FUNC:
		check_exprscope(np->u.func.arglist, ex);
		break;

	case T_NUM:
	case T_TIMEVAL:
		break;

	default:
		outfl(O_DIE, np->file, np->line,
		    "check_exprscope: internal error: unexpected type: %s",
		    ptree_nodetype2str(np->t));
	}
}

/*
 * check_propscope -- check constraints for out of scope variable refs
 */
void
check_propscope(struct node *np)
{
	struct lut *ex;

	ex = record_iterators(np, NULL);
	check_exprscope(np, ex);
	lut_free(ex, NULL, NULL);
}

/*
 * check_upset_engine -- validate the engine property in an upset statement
 *
 * we do this after the full parse tree has been constructed rather than while
 * building the parse tree because it is inconvenient for the user if we
 * require SERD engines to be declared before used in an upset "engine"
 * property.
 */

/*ARGSUSED*/
void
check_upset_engine(struct node *lhs, struct node *rhs, void *arg)
{
	enum nodetype t = (enum nodetype)arg;
	struct node *engnp;
	struct node *declp;

	ASSERTeq(rhs->t, t, ptree_nodetype2str);

	if ((engnp = tree_s2np_lut_lookup(rhs->u.stmt.lutp, L_engine)) == NULL)
		return;

	ASSERT(engnp->t == T_EVENT);

	if ((declp = tree_event2np_lut_lookup(SERDs, engnp)) == NULL) {
		outfl(O_ERR, engnp->file, engnp->line,
		    "%s %s property contains undeclared name",
		    ptree_nodetype2str(t), L_engine);
		return;
	}
	engnp->u.event.declp = declp;
}

/*
 * check_refcount -- see if declared names are used
 *
 * this is run after the entire parse tree is constructed, so a refcount
 * of zero means the name has been declared but otherwise not used.
 */

void
check_refcount(struct node *lhs, struct node *rhs, void *arg)
{
	enum nodetype t = (enum nodetype)arg;

	ASSERTeq(rhs->t, t, ptree_nodetype2str);

	if (rhs->u.stmt.flags & STMT_REF)
		return;

	outfl(O_WARN|O_NONL, rhs->file, rhs->line,
	    "%s name declared but not used: ", ptree_nodetype2str(t));
	ptree_name(O_WARN|O_NONL, lhs);
	out(O_WARN, NULL);
}

/*
 * set check_cycle_warninglevel only for val >= 0
 */
int
check_cycle_level(long long val)
{
	static int check_cycle_warninglevel = -1;

	if (val == 0)
		check_cycle_warninglevel = 0;
	else if (val > 0)
		check_cycle_warninglevel = 1;

	return (check_cycle_warninglevel);
}

/*
 * check_cycle -- see props from an error have cycles
 *
 * this is run after the entire parse tree is constructed, for
 * each error that has been declared.
 */

/*ARGSUSED*/
void
check_cycle(struct node *lhs, struct node *rhs, void *arg)
{
	struct node *np;

	ASSERTeq(rhs->t, T_ERROR, ptree_nodetype2str);

	if (rhs->u.stmt.flags & STMT_CYCLE)
		return;		/* already reported this cycle */

	if (rhs->u.stmt.flags & STMT_CYMARK) {
#ifdef ESC
		int warninglevel;

		warninglevel = check_cycle_level(-1);
		if (warninglevel <= 0) {
			int olevel = O_ERR;

			if (warninglevel == 0)
				olevel = O_WARN;

			out(olevel|O_NONL, "cycle in propagation tree: ");
			ptree_name(olevel|O_NONL, rhs->u.stmt.np);
			out(olevel, NULL);
		}
#endif /* ESC */

		rhs->u.stmt.flags |= STMT_CYCLE;
	}

	rhs->u.stmt.flags |= STMT_CYMARK;

	/* for each propagation */
	for (np = Props; np; np = np->u.stmt.next)
		check_cycle_lhs(rhs, np->u.stmt.np);

	rhs->u.stmt.flags &= ~STMT_CYMARK;
}

/*
 * check_cycle_lhs -- find the lhs of an arrow for cycle checking
 */

static void
check_cycle_lhs(struct node *stmtnp, struct node *arrow)
{
	struct node *trylhs;
	struct node *tryrhs;

	/* handle cascaded arrows */
	switch (arrow->u.arrow.lhs->t) {
	case T_ARROW:
		/* first recurse left */
		check_cycle_lhs(stmtnp, arrow->u.arrow.lhs);

		/*
		 * return if there's a list of events internal to
		 * cascaded props (which is not allowed)
		*/
		if (arrow->u.arrow.lhs->u.arrow.rhs->t != T_EVENT)
			return;

		/* then try this arrow (thing cascaded *to*) */
		trylhs = arrow->u.arrow.lhs->u.arrow.rhs;
		tryrhs = arrow->u.arrow.rhs;
		break;

	case T_EVENT:
	case T_LIST:
		trylhs = arrow->u.arrow.lhs;
		tryrhs = arrow->u.arrow.rhs;
		break;

	default:
		out(O_DIE, "lhs: unexpected type: %s",
		    ptree_nodetype2str(arrow->u.arrow.lhs->t));
		/*NOTREACHED*/
	}

	check_cycle_lhs_try(stmtnp, trylhs, tryrhs);
}

/*
 * check_cycle_lhs_try -- try matching an event name on lhs of an arrow
 */

static void
check_cycle_lhs_try(struct node *stmtnp, struct node *lhs, struct node *rhs)
{
	if (lhs->t == T_LIST) {
		check_cycle_lhs_try(stmtnp, lhs->u.expr.left, rhs);
		check_cycle_lhs_try(stmtnp, lhs->u.expr.right, rhs);
		return;
	}

	ASSERT(lhs->t == T_EVENT);

	if (tree_eventcmp(stmtnp->u.stmt.np, lhs) != 0)
		return;		/* no match */

	check_cycle_rhs(rhs);
}

/*
 * check_cycle_rhs -- foreach error on rhs, see if we cycle to a marked error
 */

static void
check_cycle_rhs(struct node *rhs)
{
	struct node *dnp;

	if (rhs->t == T_LIST) {
		check_cycle_rhs(rhs->u.expr.left);
		check_cycle_rhs(rhs->u.expr.right);
		return;
	}

	ASSERT(rhs->t == T_EVENT);

	if (rhs->u.event.ename->u.name.t != N_ERROR)
		return;

	if ((dnp = tree_event2np_lut_lookup(Errors, rhs)) == NULL) {
		outfl(O_ERR|O_NONL,
		    rhs->file, rhs->line,
		    "unexpected undeclared event during cycle check");
		ptree_name(O_ERR|O_NONL, rhs);
		out(O_ERR, NULL);
		return;
	}
	check_cycle(NULL, dnp, 0);
}

/*
 * Force iterators to be simple names, expressions, or numbers
 */
void
check_name_iterator(struct node *np)
{
	if (np->u.name.child->t != T_NUM &&
	    np->u.name.child->t != T_NAME &&
	    np->u.name.child->t != T_CONDIF &&
	    np->u.name.child->t != T_SUB &&
	    np->u.name.child->t != T_ADD &&
	    np->u.name.child->t != T_MUL &&
	    np->u.name.child->t != T_DIV &&
	    np->u.name.child->t != T_MOD &&
	    np->u.name.child->t != T_LSHIFT &&
	    np->u.name.child->t != T_RSHIFT) {
		outfl(O_ERR|O_NONL, np->file, np->line,
		"invalid iterator: ");
		ptree_name_iter(O_ERR|O_NONL, np);
		out(O_ERR, NULL);
	}
}

/*
 * Iterators on a declaration may only be implicit
 */
void
check_type_iterator(struct node *np)
{
	while (np != NULL) {
		if (np->t == T_EVENT) {
			np = np->u.event.epname;
		} else if (np->t == T_NAME) {
			if (np->u.name.child != NULL &&
			    np->u.name.child->t != T_NUM) {
				outfl(O_ERR|O_NONL, np->file, np->line,
				    "explicit iterators disallowed "
				    "in declarations: ");
				ptree_name_iter(O_ERR|O_NONL, np);
				out(O_ERR, NULL);
			}
			np = np->u.name.next;
		} else {
			break;
		}
	}
}

void
check_func(struct node *np)
{
	ASSERTinfo(np->t == T_FUNC, ptree_nodetype2str(np->t));

	if (np->u.func.s == L_within) {
		struct node *arglist = np->u.func.arglist;
		switch (arglist->t) {
			case T_NUM:
				if (arglist->u.ull != 0ULL)
				    outfl(O_ERR, arglist->file, arglist->line,
					"parameter of within must be 0"
					", \"infinity\" or a time value.");
				break;
			case T_NAME:
				if (arglist->u.name.s != L_infinity)
				    outfl(O_ERR, arglist->file, arglist->line,
					"parameter of within must be 0"
					", \"infinity\" or a time value.");
				break;
			case T_LIST:
				/*
				 * if two parameters, the left or min must be
				 * either T_NUM or T_TIMEVAL
				 */
				if (arglist->u.expr.left->t != T_NUM &&
				    arglist->u.expr.left->t != T_TIMEVAL)
					outfl(O_ERR,
					    arglist->file, arglist->line,
					    "first parameter of within must be"
					    " either a time value or zero.");

				/*
				 * if two parameters, the right or max must
				 * be either T_NUM, T_NAME or T_TIMEVAL
				 */
				if (arglist->u.expr.right->t != T_NUM &&
				    arglist->u.expr.right->t != T_TIMEVAL &&
				    arglist->u.expr.right->t != T_NAME)
					outfl(O_ERR,
					    arglist->file, arglist->line,
					    "second parameter of within must "
					    "be 0, \"infinity\" "
					    "or time value.");

				/*
				 * if right or left is a T_NUM it must
				 * be zero
				 */
				if (arglist->u.expr.left->t == T_NUM)
					if (arglist->u.expr.left->u.ull != 0ULL)
					    outfl(O_ERR,
						arglist->file, arglist->line,
						"within parameter must be 0 or"
						" a time value.");
				if (arglist->u.expr.right->t == T_NUM)
					if (arglist->u.expr.right->u.ull
					    != 0ULL)
					    outfl(O_ERR,
						arglist->file, arglist->line,
						"within parameter must be 0 or"
						" a time value.");

				/* if right is a T_NAME it must be "infinity" */
				if (arglist->u.expr.right->t == T_NAME)
					if (arglist->u.expr.right->u.name.s
					    != L_infinity)
					    outfl(O_ERR,
						arglist->file, arglist->line,
						"\"infinity\" is the only valid"
						" name for within parameter.");

				/*
				 * the first parameter [min] must not be greater
				 * than the second parameter [max].
				 */
				if (arglist->u.expr.left->u.ull >
				    arglist->u.expr.right->u.ull)
					outfl(O_ERR,
					    arglist->file, arglist->line,
					    "the first value (min) of"
					    " within must be less than"
					    " the second (max) value");
				break;
			case T_TIMEVAL:
				break; /* no restrictions on T_TIMEVAL */
			default:
				outfl(O_ERR, arglist->file, arglist->line,
					"parameter of within must be 0"
					", \"infinity\" or a time value.");
		}
	} else if (np->u.func.s == L_call) {
		if (np->u.func.arglist->t != T_QUOTE &&
		    np->u.func.arglist->t != T_LIST &&
		    np->u.func.arglist->t != T_GLOBID &&
		    np->u.func.arglist->t != T_CONDIF &&
		    np->u.func.arglist->t != T_LIST &&
		    np->u.func.arglist->t != T_FUNC)
			outfl(O_ERR, np->u.func.arglist->file,
				np->u.func.arglist->line,
				"invalid first argument to call()");
	} else if (np->u.func.s == L_fru) {
		if (np->u.func.arglist->t != T_NAME)
			outfl(O_ERR, np->u.func.arglist->file,
				np->u.func.arglist->line,
				"argument to fru() must be a path");
	} else if (np->u.func.s == L_asru) {
		if (np->u.func.arglist->t != T_NAME)
			outfl(O_ERR, np->u.func.arglist->file,
				np->u.func.arglist->line,
				"argument to asru() must be a path");
	} else if (np->u.func.s == L_is_connected ||
	    np->u.func.s == L_is_under) {
		if (np->u.func.arglist->t == T_LIST &&
		    (np->u.func.arglist->u.expr.left->t == T_NAME ||
		    (np->u.func.arglist->u.expr.left->t == T_FUNC &&
		    (np->u.func.arglist->u.expr.left->u.func.s == L_fru ||
		    np->u.func.arglist->u.expr.left->u.func.s == L_asru))) &&
		    (np->u.func.arglist->u.expr.right->t == T_NAME ||
		    (np->u.func.arglist->u.expr.right->t == T_FUNC &&
		    (np->u.func.arglist->u.expr.right->u.func.s == L_fru ||
		    np->u.func.arglist->u.expr.right->u.func.s == L_asru)))) {
			if (np->u.func.arglist->u.expr.left->t == T_FUNC)
				check_func(np->u.func.arglist->u.expr.left);
			if (np->u.func.arglist->u.expr.right->t == T_FUNC)
				check_func(np->u.func.arglist->u.expr.right);
		} else {
			outfl(O_ERR, np->u.func.arglist->file,
			    np->u.func.arglist->line,
			    "%s() must have paths or calls to "
			    "fru() and/or asru() as arguments",
			    np->u.func.s);
		}
	} else if (np->u.func.s == L_is_on) {
		if (np->u.func.arglist->t == T_FUNC &&
		    (np->u.func.arglist->u.func.s == L_fru ||
		    np->u.func.arglist->u.func.s == L_asru)) {
			check_func(np->u.func.arglist);
		} else {
			outfl(O_ERR, np->u.func.arglist->file,
			    np->u.func.arglist->line,
			    "argument to is_on() must be a call to "
			    "fru() or asru()");
		}
	} else if (np->u.func.s == L_is_present) {
		if (np->u.func.arglist->t == T_FUNC &&
		    (np->u.func.arglist->u.func.s == L_fru ||
		    np->u.func.arglist->u.func.s == L_asru)) {
			check_func(np->u.func.arglist);
		} else {
			outfl(O_ERR, np->u.func.arglist->file,
			    np->u.func.arglist->line,
			    "argument to is_present() must be a call to "
			    "fru() or asru()");
		}
	} else if (np->u.func.s == L_is_type) {
		if (np->u.func.arglist->t == T_FUNC &&
		    (np->u.func.arglist->u.func.s == L_fru ||
		    np->u.func.arglist->u.func.s == L_asru)) {
			check_func(np->u.func.arglist);
		} else {
			outfl(O_ERR, np->u.func.arglist->file,
			    np->u.func.arglist->line,
			    "argument to is_type() must be a call to "
			    "fru() or asru()");
		}
	} else if (np->u.func.s == L_confprop) {
		if (np->u.func.arglist->t == T_LIST &&
		    (np->u.func.arglist->u.expr.left->t == T_FUNC &&
		    (np->u.func.arglist->u.expr.left->u.func.s == L_fru ||
		    np->u.func.arglist->u.expr.left->u.func.s == L_asru)) &&
		    np->u.func.arglist->u.expr.right->t == T_QUOTE) {
			check_func(np->u.func.arglist->u.expr.left);
		} else {
			outfl(O_ERR, np->u.func.arglist->file,
			    np->u.func.arglist->line,
			    "confprop(): first argument must be a call to "
			    "fru() or asru(); "
			    "second argument must be a string");
		}
	} else if (np->u.func.s == L_payloadprop) {
		if (np->u.func.arglist->t != T_QUOTE)
			outfl(O_ERR, np->u.func.arglist->file,
				np->u.func.arglist->line,
				"argument to payloadprop() must be a string");
	} else if (np->u.func.s == L_envprop) {
		if (np->u.func.arglist->t != T_QUOTE)
			outfl(O_ERR, np->u.func.arglist->file,
				np->u.func.arglist->line,
				"argument to envprop() must be a string");
	} else
		outfl(O_WARN, np->file, np->line,
			"possible platform-specific function: %s",
			np->u.func.s);
}

void
check_expr(struct node *np)
{
	ASSERT(np != NULL);

	switch (np->t) {
	case T_ASSIGN:
		ASSERT(np->u.expr.left != NULL);
		if (np->u.expr.left->t != T_GLOBID)
			outfl(O_ERR, np->file, np->line,
			    "assignment only allowed to globals (e.g. $a)");
		break;
	}
}

void
check_event(struct node *np)
{
	ASSERT(np != NULL);
	ASSERT(np->t == T_EVENT);

	if (np->u.event.epname == NULL) {
		outfl(O_ERR|O_NONL, np->file, np->line,
		    "pathless events not allowed: ");
		ptree_name(O_ERR|O_NONL, np->u.event.ename);
		out(O_ERR, NULL);
	}
}

/*
 * check for properties that are required on declarations. This
 * should be done after all declarations since they can be
 * redeclared with a different set of properties.
 */
/*ARGSUSED*/
void
check_required_props(struct node *lhs, struct node *rhs, void *arg)
{
	enum nodetype t = (enum nodetype)arg;

	ASSERTeq(rhs->t, t, ptree_nodetype2str);

	check_stmt_required_properties(rhs);
}

/*
 * check that cascading prop statements do not contain lists internally.
 * the first and last event lists in the cascading prop may be single
 * events or lists of events.
 */
/*ARGSUSED*/
void
check_proplists(enum nodetype t, struct node *np)
{
	ASSERT(np->t == T_ARROW);
	/*
	 * not checking the right hand side of the top level prop
	 * since it is the last part of the propagation and can be
	 * an event or list of events
	 */
	check_proplists_lhs(t, np->u.arrow.lhs);
}

/*ARGSUSED*/
static void
check_proplists_lhs(enum nodetype t, struct node *lhs)
{
	if (lhs->t == T_ARROW) {
		if (lhs->u.arrow.rhs->t == T_LIST) {
			outfl(O_ERR, lhs->file, lhs->line,
				"lists are not allowed internally on"
				" cascading %s",
				(t == T_PROP) ? "propagations" : "masks");
		}
		check_proplists_lhs(t, lhs->u.arrow.lhs);
	}
}