usr/src/cmd/fm/eversholt/common/ptree.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * ptree.c -- routines for printing the prop tree
  27  *
  28  * this module contains routines to print portions of the parse tree.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <ctype.h>
  37 #include "out.h"
  38 #include "stable.h"
  39 #include "literals.h"
  40 #include "lut.h"
  41 #include "tree.h"
  42 #include "ptree.h"
  43
  44 int Pchildgen;
  45
  46 #ifdef  FMAPLUGIN
  47
  48 #include "itree.h"
  49 #include "eval.h"
  50 #include "config.h"
  51
  52 static void
  53 cp2num(struct config *cp, int *num)
  54 {
  55         config_getcompname(cp, NULL, num);
  56 }
  57
  58 #else
  59
  60 /*ARGSUSED*/
  61 static void
  62 cp2num(struct config *cp, int *num)
  63 {
  64         out(O_DIE, "ptree: non-NULL cp");
  65 }
  66
  67 #endif  /* FMAPLUGIN */
  68
  69 static int
  70 is_stmt(struct node *np)
  71 {
  72         switch (np->t) {
  73         case T_FAULT:
  74         case T_UPSET:
  75         case T_DEFECT:
  76         case T_ERROR:
  77         case T_EREPORT:
  78         case T_SERD:
  79         case T_STAT:
  80         case T_PROP:
  81         case T_MASK:
  82         case T_ASRU:
  83         case T_FRU:
  84         case T_CONFIG:
  85                 return (1);
  86                 /*NOTREACHED*/
  87                 break;
  88         default:
  89                 break;
  90         }
  91
  92         return (0);
  93 }
  94
  95 void
  96 ptree(int flags, struct node *np, int no_iterators, int fileline)
  97 {
  98         if (np == NULL)
  99                 return;
 100
 101         switch (np->t) {
 102         case T_NOTHING:
 103                 break;
 104         case T_NAME:
 105                 out(flags|O_NONL, "%s", np->u.name.s);
 106                 if (!no_iterators) {
 107                         if (np->u.name.cp != NULL) {
 108                                 int num;
 109                                 cp2num(np->u.name.cp, &num);
 110                                 out(flags|O_NONL, "%d", num);
 111                         } else if (np->u.name.it == IT_HORIZONTAL) {
 112                                 if (np->u.name.child == NULL ||
 113                                     (np->u.name.childgen && !Pchildgen))
 114                                         out(flags|O_NONL, "<>");
 115                                 else {
 116                                         out(flags|O_NONL, "<");
 117                                         ptree(flags, np->u.name.child,
 118                                             no_iterators, fileline);
 119                                         out(flags|O_NONL, ">");
 120                                 }
 121                         } else if (np->u.name.child &&
 122                             (!np->u.name.childgen || Pchildgen)) {
 123                                 if (np->u.name.it != IT_NONE)
 124                                         out(flags|O_NONL, "[");
 125                                 ptree(flags, np->u.name.child, no_iterators,
 126                                     fileline);
 127                                 if (np->u.name.it != IT_NONE)
 128                                         out(flags|O_NONL, "]");
 129                         }
 130                 }
 131                 if (np->u.name.next) {
 132                         ASSERT(np->u.name.next->t == T_NAME);
 133                         if (np->u.name.it == IT_ENAME)
 134                                 out(flags|O_NONL, ".");
 135                         else
 136                                 out(flags|O_NONL, "/");
 137                         ptree(flags, np->u.name.next, no_iterators, fileline);
 138                 }
 139                 break;
 140         case T_TIMEVAL:
 141                 ptree_timeval(flags, &np->u.ull);
 142                 break;
 143         case T_NUM:
 144                 out(flags|O_NONL, "%llu", np->u.ull);
 145                 break;
 146         case T_QUOTE:
 147                 out(flags|O_NONL, "\"%s\"", np->u.quote.s);
 148                 break;
 149         case T_GLOBID:
 150                 out(flags|O_NONL, "$%s", np->u.globid.s);
 151                 break;
 152         case T_FUNC:
 153                 out(flags|O_NONL, "%s(", np->u.func.s);
 154                 ptree(flags, np->u.func.arglist, no_iterators, fileline);
 155                 out(flags|O_NONL, ")");
 156                 break;
 157         case T_NVPAIR:
 158                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 159                 out(flags|O_NONL, "=");
 160                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 161                 break;
 162         case T_EVENT:
 163                 ptree(flags, np->u.event.ename, no_iterators, fileline);
 164                 if (np->u.event.epname) {
 165                         out(flags|O_NONL, "@");
 166                         ptree(flags, np->u.event.epname,
 167                             no_iterators, fileline);
 168                 }
 169                 if (np->u.event.eexprlist) {
 170                         out(flags|O_NONL, "{");
 171                         ptree(flags, np->u.event.eexprlist,
 172                             no_iterators, fileline);
 173                         out(flags|O_NONL, "}");
 174                 }
 175                 break;
 176         case T_ASSIGN:
 177                 out(flags|O_NONL, "(");
 178                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 179                 out(flags|O_NONL, "=");
 180                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 181                 out(flags|O_NONL, ")");
 182                 break;
 183         case T_NOT:
 184                 out(flags|O_NONL, "(");
 185                 out(flags|O_NONL, "!");
 186                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 187                 out(flags|O_NONL, ")");
 188                 break;
 189         case T_AND:
 190                 out(flags|O_NONL, "(");
 191                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 192                 out(flags|O_NONL, "&&");
 193                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 194                 out(flags|O_NONL, ")");
 195                 break;
 196         case T_OR:
 197                 out(flags|O_NONL, "(");
 198                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 199                 out(flags|O_NONL, "||");
 200                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 201                 out(flags|O_NONL, ")");
 202                 break;
 203         case T_EQ:
 204                 out(flags|O_NONL, "(");
 205                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 206                 out(flags|O_NONL, "==");
 207                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 208                 out(flags|O_NONL, ")");
 209                 break;
 210         case T_NE:
 211                 out(flags|O_NONL, "(");
 212                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 213                 out(flags|O_NONL, "!=");
 214                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 215                 out(flags|O_NONL, ")");
 216                 break;
 217         case T_SUB:
 218                 out(flags|O_NONL, "(");
 219                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 220                 out(flags|O_NONL, "-");
 221                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 222                 out(flags|O_NONL, ")");
 223                 break;
 224         case T_ADD:
 225                 out(flags|O_NONL, "(");
 226                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 227                 out(flags|O_NONL, "+");
 228                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 229                 out(flags|O_NONL, ")");
 230                 break;
 231         case T_MUL:
 232                 out(flags|O_NONL, "(");
 233                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 234                 out(flags|O_NONL, "*");
 235                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 236                 out(flags|O_NONL, ")");
 237                 break;
 238         case T_DIV:
 239                 out(flags|O_NONL, "(");
 240                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 241                 out(flags|O_NONL, "/");
 242                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 243                 out(flags|O_NONL, ")");
 244                 break;
 245         case T_MOD:
 246                 out(flags|O_NONL, "(");
 247                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 248                 out(flags|O_NONL, "%%");
 249                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 250                 out(flags|O_NONL, ")");
 251                 break;
 252         case T_LT:
 253                 out(flags|O_NONL, "(");
 254                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 255                 out(flags|O_NONL, "<");
 256                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 257                 out(flags|O_NONL, ")");
 258                 break;
 259         case T_LE:
 260                 out(flags|O_NONL, "(");
 261                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 262                 out(flags|O_NONL, "<=");
 263                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 264                 out(flags|O_NONL, ")");
 265                 break;
 266         case T_GT:
 267                 out(flags|O_NONL, "(");
 268                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 269                 out(flags|O_NONL, ">");
 270                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 271                 out(flags|O_NONL, ")");
 272                 break;
 273         case T_GE:
 274                 out(flags|O_NONL, "(");
 275                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 276                 out(flags|O_NONL, ">=");
 277                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 278                 out(flags|O_NONL, ")");
 279                 break;
 280         case T_BITNOT:
 281                 out(flags|O_NONL, "(");
 282                 out(flags|O_NONL, "~");
 283                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 284                 out(flags|O_NONL, ")");
 285                 break;
 286         case T_BITAND:
 287                 out(flags|O_NONL, "(");
 288                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 289                 out(flags|O_NONL, "&");
 290                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 291                 out(flags|O_NONL, ")");
 292                 break;
 293         case T_BITOR:
 294                 out(flags|O_NONL, "(");
 295                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 296                 out(flags|O_NONL, "|");
 297                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 298                 out(flags|O_NONL, ")");
 299                 break;
 300         case T_BITXOR:
 301                 out(flags|O_NONL, "(");
 302                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 303                 out(flags|O_NONL, "^");
 304                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 305                 out(flags|O_NONL, ")");
 306                 break;
 307         case T_LSHIFT:
 308                 out(flags|O_NONL, "(");
 309                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 310                 out(flags|O_NONL, "<<");
 311                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 312                 out(flags|O_NONL, ")");
 313                 break;
 314         case T_RSHIFT:
 315                 out(flags|O_NONL, "(");
 316                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 317                 out(flags|O_NONL, ">>");
 318                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 319                 out(flags|O_NONL, ")");
 320                 break;
 321         case T_CONDIF:
 322                 out(flags|O_NONL, "(");
 323                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 324                 out(flags|O_NONL, "?");
 325                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 326                 out(flags|O_NONL, ")");
 327                 break;
 328         case T_CONDELSE:
 329                 out(flags|O_NONL, "(");
 330                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 331                 out(flags|O_NONL, ":");
 332                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 333                 out(flags|O_NONL, ")");
 334                 break;
 335         case T_ARROW:
 336                 ptree(flags, np->u.arrow.lhs, no_iterators, fileline);
 337                 if (np->u.arrow.nnp) {
 338                         out(flags|O_NONL, "(");
 339                         ptree(flags, np->u.arrow.nnp, no_iterators, fileline);
 340                         out(flags|O_NONL, ")");
 341                 }
 342                 out(flags|O_NONL, "->");
 343                 if (np->u.arrow.knp) {
 344                         out(flags|O_NONL, "(");
 345                         ptree(flags, np->u.arrow.knp, no_iterators, fileline);
 346                         out(flags|O_NONL, ")");
 347                 }
 348                 ptree(flags, np->u.arrow.rhs, no_iterators, fileline);
 349                 break;
 350         case T_LIST:
 351                 ptree(flags, np->u.expr.left, no_iterators, fileline);
 352                 if (np->u.expr.left && np->u.expr.right &&
 353                     (np->u.expr.left->t != T_LIST ||
 354                     ! is_stmt(np->u.expr.right)))
 355                         out(flags|O_NONL, ",");
 356                 ptree(flags, np->u.expr.right, no_iterators, fileline);
 357                 break;
 358         case T_FAULT:
 359         case T_UPSET:
 360         case T_DEFECT:
 361         case T_ERROR:
 362         case T_EREPORT:
 363                 if (fileline)
 364                         out(flags, "# %d \"%s\"", np->line, np->file);
 365                 out(flags|O_NONL, "event ");
 366                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 367                 if (np->u.stmt.nvpairs) {
 368                         out(flags|O_NONL, " ");
 369                         ptree(flags, np->u.stmt.nvpairs, no_iterators,
 370                             fileline);
 371                 }
 372                 out(flags, ";");
 373                 break;
 374         case T_SERD:
 375         case T_STAT:
 376                 if (fileline)
 377                         out(flags, "# %d \"%s\"", np->line, np->file);
 378                 out(flags|O_NONL, "engine ");
 379                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 380                 if (np->u.stmt.nvpairs) {
 381                         out(flags|O_NONL, " ");
 382                         ptree(flags, np->u.stmt.nvpairs, no_iterators,
 383                             fileline);
 384                 } else if (np->u.stmt.lutp) {
 385                         struct plut_wlk_data pd;
 386
 387                         pd.flags = flags;
 388                         pd.first = 0;
 389
 390                         lut_walk(np->u.stmt.lutp, ptree_plut, &pd);
 391                 }
 392                 out(flags, ";");
 393                 break;
 394         case T_ASRU:
 395                 if (fileline)
 396                         out(flags, "# %d \"%s\"", np->line, np->file);
 397                 out(flags|O_NONL, "asru ");
 398                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 399                 if (np->u.stmt.nvpairs) {
 400                         out(flags|O_NONL, " ");
 401                         ptree(flags, np->u.stmt.nvpairs, no_iterators,
 402                             fileline);
 403                 }
 404                 out(flags, ";");
 405                 break;
 406         case T_FRU:
 407                 if (fileline)
 408                         out(flags, "# %d \"%s\"", np->line, np->file);
 409                 out(flags|O_NONL, "fru ");
 410                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 411                 if (np->u.stmt.nvpairs) {
 412                         out(flags|O_NONL, " ");
 413                         ptree(flags, np->u.stmt.nvpairs, no_iterators,
 414                             fileline);
 415                 }
 416                 out(flags, ";");
 417                 break;
 418         case T_CONFIG:
 419                 if (fileline)
 420                         out(flags, "# %d \"%s\"", np->line, np->file);
 421                 out(flags|O_NONL, "config ");
 422                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 423                 if (np->u.stmt.nvpairs) {
 424                         out(flags|O_NONL, " ");
 425                         ptree(flags, np->u.stmt.nvpairs, no_iterators,
 426                                 fileline);
 427                 }
 428                 out(flags, ";");
 429                 break;
 430         case T_PROP:
 431                 if (fileline)
 432                         out(flags, "# %d \"%s\"", np->line, np->file);
 433                 out(flags|O_NONL, "prop ");
 434                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 435                 out(flags, ";");
 436                 break;
 437         case T_MASK:
 438                 if (fileline)
 439                         out(flags, "# %d \"%s\"", np->line, np->file);
 440                 out(flags|O_NONL, "mask ");
 441                 ptree(flags, np->u.stmt.np, no_iterators, fileline);
 442                 out(flags, ";");
 443                 break;
 444         default:
 445                 out(O_DIE,
 446                     "internal error: ptree unexpected nodetype: %d", np->t);
 447                 /*NOTREACHED*/
 448         }
 449 }
 450
 451 void
 452 ptree_plut(void *name, void *val, void *arg)
 453 {
 454         struct plut_wlk_data *pd = (struct plut_wlk_data *)arg;
 455         int c;
 456         static int indent;
 457
 458         indent++;
 459
 460         if (pd->first == 0)
 461                 out(pd->flags, ",");
 462         else
 463                 pd->first = 0;
 464
 465         for (c = indent; c > 0; c--)
 466                 out(pd->flags|O_NONL, "\t");
 467         out(pd->flags|O_NONL, "%s", (char *)name);
 468
 469         out(pd->flags|O_NONL, "=");
 470         ptree(pd->flags, val, 0, 0);
 471
 472         indent--;
 473 }
 474
 475 void
 476 ptree_name(int flags, struct node *np)
 477 {
 478         ptree(flags, np, 1, 0);
 479 }
 480
 481 void
 482 ptree_name_iter(int flags, struct node *np)
 483 {
 484         ptree(flags, np, 0, 0);
 485 }
 486
 487 const char *
 488 ptree_nodetype2str(enum nodetype t)
 489 {
 490         static char buf[100];
 491
 492         switch (t) {
 493         case T_NOTHING: return L_T_NOTHING;
 494         case T_NAME: return L_T_NAME;
 495         case T_GLOBID: return L_T_GLOBID;
 496         case T_EVENT: return L_T_EVENT;
 497         case T_ENGINE: return L_T_ENGINE;
 498         case T_ASRU: return L_asru;
 499         case T_FRU: return L_fru;
 500         case T_CONFIG: return L_config;
 501         case T_TIMEVAL: return L_T_TIMEVAL;
 502         case T_NUM: return L_T_NUM;
 503         case T_QUOTE: return L_T_QUOTE;
 504         case T_FUNC: return L_T_FUNC;
 505         case T_NVPAIR: return L_T_NVPAIR;
 506         case T_ASSIGN: return L_T_ASSIGN;
 507         case T_CONDIF: return L_T_CONDIF;
 508         case T_CONDELSE: return L_T_CONDELSE;
 509         case T_NOT: return L_T_NOT;
 510         case T_AND: return L_T_AND;
 511         case T_OR: return L_T_OR;
 512         case T_EQ: return L_T_EQ;
 513         case T_NE: return L_T_NE;
 514         case T_SUB: return L_T_SUB;
 515         case T_ADD: return L_T_ADD;
 516         case T_MUL: return L_T_MUL;
 517         case T_DIV: return L_T_DIV;
 518         case T_MOD: return L_T_MOD;
 519         case T_LT: return L_T_LT;
 520         case T_LE: return L_T_LE;
 521         case T_GT: return L_T_GT;
 522         case T_GE: return L_T_GE;
 523         case T_BITAND: return L_T_BITAND;
 524         case T_BITOR: return L_T_BITOR;
 525         case T_BITXOR: return L_T_BITXOR;
 526         case T_BITNOT: return L_T_BITNOT;
 527         case T_LSHIFT: return L_T_LSHIFT;
 528         case T_RSHIFT: return L_T_RSHIFT;
 529         case T_ARROW: return L_T_ARROW;
 530         case T_LIST: return L_T_LIST;
 531         case T_FAULT: return L_fault;
 532         case T_UPSET: return L_upset;
 533         case T_DEFECT: return L_defect;
 534         case T_ERROR: return L_error;
 535         case T_EREPORT: return L_ereport;
 536         case T_SERD: return L_serd;
 537         case T_STAT: return L_stat;
 538         case T_PROP: return L_prop;
 539         case T_MASK: return L_mask;
 540         default:
 541                 (void) sprintf(buf, "[unexpected nodetype: %d]", t);
 542                 return (buf);
 543         }
 544 }
 545
 546 const char *
 547 ptree_nametype2str(enum nametype t)
 548 {
 549         static char buf[100];
 550
 551         switch (t) {
 552         case N_UNSPEC: return L_N_UNSPEC;
 553         case N_FAULT: return L_fault;
 554         case N_DEFECT: return L_defect;
 555         case N_UPSET: return L_upset;
 556         case N_ERROR: return L_error;
 557         case N_EREPORT: return L_ereport;
 558         case N_SERD: return L_serd;
 559         case N_STAT: return L_stat;
 560         default:
 561                 (void) sprintf(buf, "[unexpected nametype: %d]", t);
 562                 return (buf);
 563         }
 564 }
 565
 566 struct printer_info {
 567         enum nodetype t;
 568         const char *pat;
 569         int flags;
 570 };
 571
 572 static int
 573 name_pattern_match(struct node *np, const char *pat)
 574 {
 575         const char *cend;       /* first character not in component in pat */
 576
 577         if (pat == NULL || *pat == '\0')
 578                 return (1);     /* either no pattern or we've matched it all */
 579
 580         if (np == NULL)
 581                 return (0);     /* there's more pattern and nothing to match */
 582
 583         ASSERTeq(np->t, T_NAME, ptree_nodetype2str);
 584
 585         cend = strchr(pat, '/');
 586         if (cend == NULL)
 587                 cend = strchr(pat, '.');
 588         if (cend == NULL)
 589                 cend = &pat[strlen(pat)];
 590
 591         while (np) {
 592                 const char *s = np->u.name.s;
 593
 594                 while (*s) {
 595                         const char *cstart = pat;
 596
 597                         while (*s && tolower(*s) == tolower(*cstart)) {
 598                                 cstart++;
 599                                 if (cstart == cend) {
 600                                         /* component matched */
 601                                         while (*cend == '/')
 602                                                 cend++;
 603                                         return
 604                                             name_pattern_match(np->u.name.next,
 605                                             cend);
 606                                 }
 607                                 s++;
 608                         }
 609                         if (*s)
 610                                 s++;
 611                 }
 612                 np = np->u.name.next;
 613         }
 614         return (0);
 615 }
 616
 617 static int
 618 name_pattern_match_in_subtree(struct node *np, const char *pat)
 619 {
 620         if (pat == NULL || *pat == '\0')
 621                 return (1);
 622
 623         if (np == NULL)
 624                 return (0);
 625
 626         if (np->t == T_NAME)
 627                 return (name_pattern_match(np, pat));
 628         else if (np->t == T_EVENT)
 629                 return (name_pattern_match_in_subtree(np->u.event.ename, pat) ||
 630                     name_pattern_match_in_subtree(np->u.event.epname, pat) ||
 631                     name_pattern_match_in_subtree(np->u.event.eexprlist, pat));
 632         else if (np->t == T_ARROW)
 633                 return (name_pattern_match_in_subtree(np->u.arrow.lhs, pat) ||
 634                     name_pattern_match_in_subtree(np->u.arrow.rhs, pat));
 635         else if (np->t == T_ASSIGN ||
 636                         np->t == T_CONDIF ||
 637                         np->t == T_CONDELSE ||
 638                         np->t == T_NOT ||
 639                         np->t == T_AND ||
 640                         np->t == T_OR ||
 641                         np->t == T_EQ ||
 642                         np->t == T_NE ||
 643                         np->t == T_SUB ||
 644                         np->t == T_ADD ||
 645                         np->t == T_MUL ||
 646                         np->t == T_DIV ||
 647                         np->t == T_MOD ||
 648                         np->t == T_LT ||
 649                         np->t == T_LE ||
 650                         np->t == T_GT ||
 651                         np->t == T_GE ||
 652                         np->t == T_BITAND ||
 653                         np->t == T_BITOR ||
 654                         np->t == T_BITXOR ||
 655                         np->t == T_BITNOT ||
 656                         np->t == T_LSHIFT ||
 657                         np->t == T_RSHIFT ||
 658                         np->t == T_LIST) {
 659                 return (name_pattern_match_in_subtree(np->u.expr.left, pat) ||
 660                     name_pattern_match_in_subtree(np->u.expr.right, pat));
 661         } else if (np->t == T_FUNC) {
 662                 return (name_pattern_match_in_subtree(np->u.func.arglist, pat));
 663         }
 664         return (0);
 665 }
 666
 667 static void
 668 byname_printer(struct node *lhs, struct node *rhs, void *arg)
 669 {
 670         struct printer_info *infop = (struct printer_info *)arg;
 671
 672         if (infop->t != T_NOTHING && rhs->t != infop->t)
 673                 return;
 674         if (!name_pattern_match(lhs, infop->pat))
 675                 return;
 676         ptree(infop->flags, rhs, 0, 0);
 677 }
 678
 679 static void
 680 ptree_type_pattern(int flags, enum nodetype t, const char *pat)
 681 {
 682         struct printer_info info;
 683         struct node *np;
 684
 685         info.flags = flags;
 686         info.pat = pat;
 687         info.t = t;
 688
 689         switch (t) {
 690         case T_FAULT:
 691                 lut_walk(Faults, (lut_cb)byname_printer, (void *)&info);
 692                 return;
 693         case T_UPSET:
 694                 lut_walk(Upsets, (lut_cb)byname_printer, (void *)&info);
 695                 return;
 696         case T_DEFECT:
 697                 lut_walk(Defects, (lut_cb)byname_printer, (void *)&info);
 698                 return;
 699         case T_ERROR:
 700                 lut_walk(Errors, (lut_cb)byname_printer, (void *)&info);
 701                 return;
 702         case T_EREPORT:
 703                 lut_walk(Ereports, (lut_cb)byname_printer, (void *)&info);
 704                 return;
 705         case T_SERD:
 706                 lut_walk(SERDs, (lut_cb)byname_printer, (void *)&info);
 707                 return;
 708         case T_STAT:
 709                 lut_walk(STATs, (lut_cb)byname_printer, (void *)&info);
 710                 return;
 711         case T_ASRU:
 712                 lut_walk(ASRUs, (lut_cb)byname_printer, (void *)&info);
 713                 return;
 714         case T_FRU:
 715                 lut_walk(FRUs, (lut_cb)byname_printer, (void *)&info);
 716                 return;
 717         case T_CONFIG:
 718                 lut_walk(Configs, (lut_cb)byname_printer, (void *)&info);
 719                 return;
 720         case T_PROP:
 721                 for (np = Props; np; np = np->u.stmt.next)
 722                         if (name_pattern_match_in_subtree(np->u.stmt.np, pat))
 723                                 ptree(flags, np, 0, 0);
 724                 return;
 725         case T_MASK:
 726                 for (np = Masks; np; np = np->u.stmt.next)
 727                         if (name_pattern_match_in_subtree(np->u.stmt.np, pat))
 728                                 ptree(flags, np, 0, 0);
 729                 return;
 730         default:
 731                 ptree(flags, tree_root(NULL), 0, 0);
 732         }
 733 }
 734
 735 void
 736 ptree_all(int flags, const char *pat)
 737 {
 738         ptree_type_pattern(flags, T_NOTHING, pat);
 739 }
 740
 741 void
 742 ptree_fault(int flags, const char *pat)
 743 {
 744         ptree_type_pattern(flags, T_FAULT, pat);
 745 }
 746
 747 void
 748 ptree_upset(int flags, const char *pat)
 749 {
 750         ptree_type_pattern(flags, T_UPSET, pat);
 751 }
 752
 753 void
 754 ptree_defect(int flags, const char *pat)
 755 {
 756         ptree_type_pattern(flags, T_DEFECT, pat);
 757 }
 758
 759 void
 760 ptree_error(int flags, const char *pat)
 761 {
 762         ptree_type_pattern(flags, T_ERROR, pat);
 763 }
 764
 765 void
 766 ptree_ereport(int flags, const char *pat)
 767 {
 768         ptree_type_pattern(flags, T_EREPORT, pat);
 769 }
 770
 771 void
 772 ptree_serd(int flags, const char *pat)
 773 {
 774         ptree_type_pattern(flags, T_SERD, pat);
 775 }
 776
 777 void
 778 ptree_stat(int flags, const char *pat)
 779 {
 780         ptree_type_pattern(flags, T_STAT, pat);
 781 }
 782
 783 void
 784 ptree_asru(int flags, const char *pat)
 785 {
 786         ptree_type_pattern(flags, T_ASRU, pat);
 787 }
 788
 789 void
 790 ptree_fru(int flags, const char *pat)
 791 {
 792         ptree_type_pattern(flags, T_FRU, pat);
 793 }
 794
 795 void
 796 ptree_prop(int flags, const char *pat)
 797 {
 798         ptree_type_pattern(flags, T_PROP, pat);
 799 }
 800
 801 void
 802 ptree_mask(int flags, const char *pat)
 803 {
 804         ptree_type_pattern(flags, T_MASK, pat);
 805 }
 806
 807 void
 808 ptree_timeval(int flags, unsigned long long *ullp)
 809 {
 810         unsigned long long val;
 811
 812 #define NOREMAINDER(den, num, val) (((val) = ((den) / (num))) * (num) == (den))
 813         if (*ullp == 0)
 814                 out(flags|O_NONL, "0us");
 815         else if (*ullp >= TIMEVAL_EVENTUALLY)
 816                 out(flags|O_NONL, "infinity");
 817         else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24*365, val))
 818                 out(flags|O_NONL, "%lluyear%s", val, (val == 1) ? "" : "s");
 819         else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24*30, val))
 820                 out(flags|O_NONL, "%llumonth%s", val, (val == 1) ? "" : "s");
 821         else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24*7, val))
 822                 out(flags|O_NONL, "%lluweek%s", val, (val == 1) ? "" : "s");
 823         else if (NOREMAINDER(*ullp, 1000000000ULL*60*60*24, val))
 824                 out(flags|O_NONL, "%lluday%s", val, (val == 1) ? "" : "s");
 825         else if (NOREMAINDER(*ullp, 1000000000ULL*60*60, val))
 826                 out(flags|O_NONL, "%lluhour%s", val, (val == 1) ? "" : "s");
 827         else if (NOREMAINDER(*ullp, 1000000000ULL*60, val))
 828                 out(flags|O_NONL, "%lluminute%s", val, (val == 1) ? "" : "s");
 829         else if (NOREMAINDER(*ullp, 1000000000ULL, val))
 830                 out(flags|O_NONL, "%llusecond%s", val, (val == 1) ? "" : "s");
 831         else if (NOREMAINDER(*ullp, 1000000ULL, val))
 832                 out(flags|O_NONL, "%llums", val);
 833         else if (NOREMAINDER(*ullp, 1000ULL, val))
 834                 out(flags|O_NONL, "%lluus", val);
 835         else
 836                 out(flags|O_NONL, "%lluns", *ullp);
 837 }