xref: /onnv-gate/usr/src/cmd/fm/eversholt/common/ptree.c (revision 1414:b4126407ac5b)

/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ptree.c -- routines for printing the prop tree
 *
 * this module contains routines to print portions of the parse tree.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "out.h"
#include "stable.h"
#include "literals.h"
#include "lut.h"
#include "tree.h"
#include "ptree.h"

int Pchildgen;

#ifdef	FMAPLUGIN

#include "itree.h"
#include "eval.h"
#include "config.h"

static void
cp2num(struct config *cp, int *num)
{
	config_getcompname(cp, NULL, num);
}

#else

/*ARGSUSED*/
static void
cp2num(struct config *cp, int *num)
{
	out(O_DIE, "ptree: non-NULL cp");
}

#endif	/* FMAPLUGIN */

static int
is_stmt(struct node *np)
{
	switch (np->t) {
	case T_FAULT:
	case T_UPSET:
	case T_DEFECT:
	case T_ERROR:
	case T_EREPORT:
	case T_SERD:
	case T_STAT:
	case T_PROP:
	case T_MASK:
	case T_ASRU:
	case T_FRU:
	case T_CONFIG:
		return (1);
		/*NOTREACHED*/
		break;
	default:
		break;
	}

	return (0);
}

void
ptree(int flags, struct node *np, int no_iterators, int fileline)
{
	if (np == NULL)
		return;

	switch (np->t) {
	case T_NOTHING:
		break;
	case T_NAME:
		out(flags|O_NONL, "%s", np->u.name.s);
		if (!no_iterators) {
			if (np->u.name.cp != NULL) {
				int num;
				cp2num(np->u.name.cp, &num);
				out(flags|O_NONL, "%d", num);
			} else if (np->u.name.it == IT_HORIZONTAL) {
				if (np->u.name.child == NULL ||
				    (np->u.name.childgen && !Pchildgen))
					out(flags|O_NONL, "<>");
				else {
					out(flags|O_NONL, "<");
					ptree(flags, np->u.name.child,
					    no_iterators, fileline);
					out(flags|O_NONL, ">");
				}
			} else if (np->u.name.child &&
			    (!np->u.name.childgen || Pchildgen)) {
				if (np->u.name.it != IT_NONE)
					out(flags|O_NONL, "[");
				ptree(flags, np->u.name.child, no_iterators,
				    fileline);
				if (np->u.name.it != IT_NONE)
					out(flags|O_NONL, "]");
			}
		}
		if (np->u.name.next) {
			ASSERT(np->u.name.next->t == T_NAME);
			if (np->u.name.it == IT_ENAME)
				out(flags|O_NONL, ".");
			else
				out(flags|O_NONL, "/");
			ptree(flags, np->u.name.next, no_iterators, fileline);
		}
		break;
	case T_TIMEVAL:
		ptree_timeval(flags, &np->u.ull);
		break;
	case T_NUM:
		out(flags|O_NONL, "%llu", np->u.ull);
		break;
	case T_QUOTE:
		out(flags|O_NONL, "\"%s\"", np->u.quote.s);
		break;
	case T_GLOBID:
		out(flags|O_NONL, "$%s", np->u.globid.s);
		break;
	case T_FUNC:
		out(flags|O_NONL, "%s(", np->u.func.s);
		ptree(flags, np->u.func.arglist, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_NVPAIR:
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "=");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		break;
	case T_EVENT:
		ptree(flags, np->u.event.ename, no_iterators, fileline);
		if (np->u.event.epname) {
			out(flags|O_NONL, "@");
			ptree(flags, np->u.event.epname,
			    no_iterators, fileline);
		}
		if (np->u.event.eexprlist) {
			out(flags|O_NONL, "{");
			ptree(flags, np->u.event.eexprlist,
			    no_iterators, fileline);
			out(flags|O_NONL, "}");
		}
		break;
	case T_ASSIGN:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "=");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_NOT:
		out(flags|O_NONL, "(");
		out(flags|O_NONL, "!");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_AND:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "&&");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_OR:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "||");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_EQ:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "==");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_NE:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "!=");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_SUB:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "-");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_ADD:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "+");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_MUL:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "*");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_DIV:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "/");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_MOD:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "%%");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_LT:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "<");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_LE:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "<=");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_GT:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, ">");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_GE:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, ">=");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_BITNOT:
		out(flags|O_NONL, "(");
		out(flags|O_NONL, "~");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_BITAND:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "&");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_BITOR:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "|");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_BITXOR:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "^");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_LSHIFT:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "<<");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_RSHIFT:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, ">>");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_CONDIF:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, "?");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_CONDELSE:
		out(flags|O_NONL, "(");
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		out(flags|O_NONL, ":");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		out(flags|O_NONL, ")");
		break;
	case T_ARROW:
		ptree(flags, np->u.arrow.lhs, no_iterators, fileline);
		if (np->u.arrow.nnp) {
			out(flags|O_NONL, "(");
			ptree(flags, np->u.arrow.nnp, no_iterators, fileline);
			out(flags|O_NONL, ")");
		}
		out(flags|O_NONL, "->");
		if (np->u.arrow.knp) {
			out(flags|O_NONL, "(");
			ptree(flags, np->u.arrow.knp, no_iterators, fileline);
			out(flags|O_NONL, ")");
		}
		ptree(flags, np->u.arrow.rhs, no_iterators, fileline);
		break;
	case T_LIST:
		ptree(flags, np->u.expr.left, no_iterators, fileline);
		if (np->u.expr.left && np->u.expr.right &&
		    (np->u.expr.left->t != T_LIST ||
		    ! is_stmt(np->u.expr.right)))
			out(flags|O_NONL, ",");
		ptree(flags, np->u.expr.right, no_iterators, fileline);
		break;
	case T_FAULT:
	case T_UPSET:
	case T_DEFECT:
	case T_ERROR:
	case T_EREPORT:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "event ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		if (np->u.stmt.nvpairs) {
			out(flags|O_NONL, " ");
			ptree(flags, np->u.stmt.nvpairs, no_iterators,
			    fileline);
		}
		out(flags, ";");
		break;
	case T_SERD:
	case T_STAT:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "engine ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		if (np->u.stmt.nvpairs) {
			out(flags|O_NONL, " ");
			ptree(flags, np->u.stmt.nvpairs, no_iterators,
			    fileline);
		} else if (np->u.stmt.lutp) {
			struct plut_wlk_data pd;

			pd.flags = flags;
			pd.first = 0;

			lut_walk(np->u.stmt.lutp, ptree_plut, &pd);
		}
		out(flags, ";");
		break;
	case T_ASRU:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "asru ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		if (np->u.stmt.nvpairs) {
			out(flags|O_NONL, " ");
			ptree(flags, np->u.stmt.nvpairs, no_iterators,
			    fileline);
		}
		out(flags, ";");
		break;
	case T_FRU:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "fru ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		if (np->u.stmt.nvpairs) {
			out(flags|O_NONL, " ");
			ptree(flags, np->u.stmt.nvpairs, no_iterators,
			    fileline);
		}
		out(flags, ";");
		break;
	case T_CONFIG:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "config ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		if (np->u.stmt.nvpairs) {
			out(flags|O_NONL, " ");
			ptree(flags, np->u.stmt.nvpairs, no_iterators,
				fileline);
		}
		out(flags, ";");
		break;
	case T_PROP:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "prop ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		out(flags, ";");
		break;
	case T_MASK:
		if (fileline)
			out(flags, "# %d \"%s\"", np->line, np->file);
		out(flags|O_NONL, "mask ");
		ptree(flags, np->u.stmt.np, no_iterators, fileline);
		out(flags, ";");
		break;
	default:
		out(O_DIE,
		    "internal error: ptree unexpected nodetype: %d", np->t);
		/*NOTREACHED*/
	}
}

void
ptree_plut(void *name, void *val, void *arg)
{
	struct plut_wlk_data *pd = (struct plut_wlk_data *)arg;
	int c;
	static int indent;

	indent++;

	if (pd->first == 0)
		out(pd->flags, ",");
	else
		pd->first = 0;

	for (c = indent; c > 0; c--)
		out(pd->flags|O_NONL, "\t");
	out(pd->flags|O_NONL, "%s", (char *)name);

	out(pd->flags|O_NONL, "=");
	ptree(pd->flags, val, 0, 0);

	indent--;
}

void
ptree_name(int flags, struct node *np)
{
	ptree(flags, np, 1, 0);
}

void
ptree_name_iter(int flags, struct node *np)
{
	ptree(flags, np, 0, 0);
}

const char *
ptree_nodetype2str(enum nodetype t)
{
	static char buf[100];

	switch (t) {
	case T_NOTHING: return L_T_NOTHING;
	case T_NAME: return L_T_NAME;
	case T_GLOBID: return L_T_GLOBID;
	case T_EVENT: return L_T_EVENT;
	case T_ENGINE: return L_T_ENGINE;
	case T_ASRU: return L_asru;
	case T_FRU: return L_fru;
	case T_CONFIG: return L_config;
	case T_TIMEVAL: return L_T_TIMEVAL;
	case T_NUM: return L_T_NUM;
	case T_QUOTE: return L_T_QUOTE;
	case T_FUNC: return L_T_FUNC;
	case T_NVPAIR: return L_T_NVPAIR;
	case T_ASSIGN: return L_T_ASSIGN;
	case T_CONDIF: return L_T_CONDIF;
	case T_CONDELSE: return L_T_CONDELSE;
	case T_NOT: return L_T_NOT;
	case T_AND: return L_T_AND;
	case T_OR: return L_T_OR;
	case T_EQ: return L_T_EQ;
	case T_NE: return L_T_NE;
	case T_SUB: return L_T_SUB;
	case T_ADD: return L_T_ADD;
	case T_MUL: return L_T_MUL;
	case T_DIV: return L_T_DIV;
	case T_MOD: return L_T_MOD;
	case T_LT: return L_T_LT;
	case T_LE: return L_T_LE;
	case T_GT: return L_T_GT;
	case T_GE: return L_T_GE;
	case T_BITAND: return L_T_BITAND;
	case T_BITOR: return L_T_BITOR;
	case T_BITXOR: return L_T_BITXOR;
	case T_BITNOT: return L_T_BITNOT;
	case T_LSHIFT: return L_T_LSHIFT;
	case T_RSHIFT: return L_T_RSHIFT;
	case T_ARROW: return L_T_ARROW;
	case T_LIST: return L_T_LIST;
	case T_FAULT: return L_fault;
	case T_UPSET: return L_upset;
	case T_DEFECT: return L_defect;
	case T_ERROR: return L_error;
	case T_EREPORT: return L_ereport;
	case T_SERD: return L_serd;
	case T_STAT: return L_stat;
	case T_PROP: return L_prop;
	case T_MASK: return L_mask;
	default:
		(void) sprintf(buf, "[unexpected nodetype: %d]", t);
		return (buf);
	}
}

const char *
ptree_nametype2str(enum nametype t)
{
	static char buf[100];

	switch (t) {
	case N_UNSPEC: return L_N_UNSPEC;
	case N_FAULT: return L_fault;
	case N_DEFECT: return L_defect;
	case N_UPSET: return L_upset;
	case N_ERROR: return L_error;
	case N_EREPORT: return L_ereport;
	case N_SERD: return L_serd;
	case N_STAT: return L_stat;
	default:
		(void) sprintf(buf, "[unexpected nametype: %d]", t);
		return (buf);
	}
}

struct printer_info {
	enum nodetype t;
	const char *pat;
	int flags;
};

static int
name_pattern_match(struct node *np, const char *pat)
{
	const char *cend;	/* first character not in component in pat */

	if (pat == NULL || *pat == '\0')
		return (1);	/* either no pattern or we've matched it all */

	if (np == NULL)
		return (0);	/* there's more pattern and nothing to match */

	ASSERTeq(np->t, T_NAME, ptree_nodetype2str);

	cend = strchr(pat, '/');
	if (cend == NULL)
		cend = strchr(pat, '.');
	if (cend == NULL)
		cend = &pat[strlen(pat)];

	while (np) {
		const char *s = np->u.name.s;

		while (*s) {
			const char *cstart = pat;

			while (*s && tolower(*s) == tolower(*cstart)) {
				cstart++;
				if (cstart == cend) {
					/* component matched */
					while (*cend == '/')
						cend++;
					return
					    name_pattern_match(np->u.name.next,
					    cend);
				}
				s++;
			}
			if (*s)
				s++;
		}
		np = np->u.name.next;
	}
	return (0);
}

static int
name_pattern_match_in_subtree(struct node *np, const char *pat)
{
	if (pat == NULL || *pat == '\0')
		return (1);

	if (np == NULL)
		return (0);

	if (np->t == T_NAME)
		return (name_pattern_match(np, pat));
	else if (np->t == T_EVENT)
		return (name_pattern_match_in_subtree(np->u.event.ename, pat) ||
		    name_pattern_match_in_subtree(np->u.event.epname, pat) ||
		    name_pattern_match_in_subtree(np->u.event.eexprlist, pat));
	else if (np->t == T_ARROW)
		return (name_pattern_match_in_subtree(np->u.arrow.lhs, pat) ||
		    name_pattern_match_in_subtree(np->u.arrow.rhs, pat));
	else if (np->t == T_ASSIGN ||
			np->t == T_CONDIF ||
			np->t == T_CONDELSE ||
			np->t == T_NOT ||
			np->t == T_AND ||
			np->t == T_OR ||
			np->t == T_EQ ||
			np->t == T_NE ||
			np->t == T_SUB ||
			np->t == T_ADD ||
			np->t == T_MUL ||
			np->t == T_DIV ||
			np->t == T_MOD ||
			np->t == T_LT ||
			np->t == T_LE ||
			np->t == T_GT ||
			np->t == T_GE ||
			np->t == T_BITAND ||
			np->t == T_BITOR ||
			np->t == T_BITXOR ||
			np->t == T_BITNOT ||
			np->t == T_LSHIFT ||
			np->t == T_RSHIFT ||
			np->t == T_LIST) {
		return (name_pattern_match_in_subtree(np->u.expr.left, pat) ||
		    name_pattern_match_in_subtree(np->u.expr.right, pat));
	} else if (np->t == T_FUNC) {
		return (name_pattern_match_in_subtree(np->u.func.arglist, pat));
	}
	return (0);
}

static void
byname_printer(struct node *lhs, struct node *rhs, void *arg)
{
	struct printer_info *infop = (struct printer_info *)arg;

	if (infop->t != T_NOTHING && rhs->t != infop->t)
		return;
	if (!name_pattern_match(lhs, infop->pat))
		return;
	ptree(infop->flags, rhs, 0, 0);
}

static void
ptree_type_pattern(int flags, enum nodetype t, const char *pat)
{
	struct printer_info info;
	struct node *np;

	info.flags = flags;
	info.pat = pat;
	info.t = t;

	switch (t) {
	case T_FAULT:
		lut_walk(Faults, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_UPSET:
		lut_walk(Upsets, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_DEFECT:
		lut_walk(Defects, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_ERROR:
		lut_walk(Errors, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_EREPORT:
		lut_walk(Ereports, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_SERD:
		lut_walk(SERDs, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_STAT:
		lut_walk(STATs, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_ASRU:
		lut_walk(ASRUs, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_FRU:
		lut_walk(FRUs, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_CONFIG:
		lut_walk(Configs, (lut_cb)byname_printer, (void *)&info);
		return;
	case T_PROP:
		for (np = Props; np; np = np->u.stmt.next)
			if (name_pattern_match_in_subtree(np->u.stmt.np, pat))
				ptree(flags, np, 0, 0);
		return;
	case T_MASK:
		for (np = Masks; np; np = np->u.stmt.next)
			if (name_pattern_match_in_subtree(np->u.stmt.np, pat))
				ptree(flags, np, 0, 0);
		return;
	default:
		ptree(flags, tree_root(NULL), 0, 0);
	}
}

void
ptree_all(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_NOTHING, pat);
}

void
ptree_fault(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_FAULT, pat);
}

void
ptree_upset(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_UPSET, pat);
}

void
ptree_defect(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_DEFECT, pat);
}

void
ptree_error(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_ERROR, pat);
}

void
ptree_ereport(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_EREPORT, pat);
}

void
ptree_serd(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_SERD, pat);
}

void
ptree_stat(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_STAT, pat);
}

void
ptree_asru(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_ASRU, pat);
}

void
ptree_fru(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_FRU, pat);
}

void
ptree_prop(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_PROP, pat);
}

void
ptree_mask(int flags, const char *pat)
{
	ptree_type_pattern(flags, T_MASK, pat);
}

void
ptree_timeval(int flags, unsigned long long *ullp)
{
	unsigned long long val;

#define	NOREMAINDER(den, num, val) (((val) = ((den) / (num))) * (num) == (den))
	if (*ullp == 0)
		out(flags|O_NONL, "0us");
	else if (*ullp >= TIMEVAL_EVENTUALLY)
		out(flags|O_NONL, "infinity");
	else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24*365, val))
		out(flags|O_NONL, "%lluyear%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24*30, val))
		out(flags|O_NONL, "%llumonth%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24*7, val))
		out(flags|O_NONL, "%lluweek%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24, val))
		out(flags|O_NONL, "%lluday%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000000ULL*60*60, val))
		out(flags|O_NONL, "%lluhour%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000000ULL*60, val))
		out(flags|O_NONL, "%lluminute%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000000ULL, val))
		out(flags|O_NONL, "%llusecond%s", val, (val == 1) ? "" : "s");
	else if (NOREMAINDER(*ullp, 1000000ULL, val))
		out(flags|O_NONL, "%llums", val);
	else if (NOREMAINDER(*ullp, 1000ULL, val))
		out(flags|O_NONL, "%lluus", val);
	else
		out(flags|O_NONL, "%lluns", *ullp);
}