usr.bin/find/operator.c

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Cimarron D. Taylor of the University of California, Berkeley.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * $FreeBSD: src/usr.bin/find/operator.c,v 1.5.6.1 2001/05/06 09:53:22 phk Exp $
  37  */
  38
  39 #ifndef lint
  40 static char sccsid[] = "@(#)operator.c  8.1 (Berkeley) 6/6/93";
  41 #endif /* not lint */
  42
  43 #include <sys/types.h>
  44
  45 #include <err.h>
  46 #include <fts.h>
  47 #include <stdio.h>
  48
  49 #include "find.h"
  50
  51 /*
  52  * yanknode --
  53  *      destructively removes the top from the plan
  54  */
  55 static PLAN *
  56 yanknode(planp)
  57         PLAN **planp;           /* pointer to top of plan (modified) */
  58 {
  59         PLAN *node;             /* top node removed from the plan */
  60
  61         if ((node = (*planp)) == NULL)
  62                 return (NULL);
  63         (*planp) = (*planp)->next;
  64         node->next = NULL;
  65         return (node);
  66 }
  67
  68 /*
  69  * yankexpr --
  70  *      Removes one expression from the plan.  This is used mainly by
  71  *      paren_squish.  In comments below, an expression is either a
  72  *      simple node or a f_expr node containing a list of simple nodes.
  73  */
  74 static PLAN *
  75 yankexpr(planp)
  76         PLAN **planp;           /* pointer to top of plan (modified) */
  77 {
  78         register PLAN *next;    /* temp node holding subexpression results */
  79         PLAN *node;             /* pointer to returned node or expression */
  80         PLAN *tail;             /* pointer to tail of subplan */
  81         PLAN *subplan;          /* pointer to head of ( ) expression */
  82
  83         /* first pull the top node from the plan */
  84         if ((node = yanknode(planp)) == NULL)
  85                 return (NULL);
  86
  87         /*
  88          * If the node is an '(' then we recursively slurp up expressions
  89          * until we find its associated ')'.  If it's a closing paren we
  90          * just return it and unwind our recursion; all other nodes are
  91          * complete expressions, so just return them.
  92          */
  93         if (node->execute == f_openparen)
  94                 for (tail = subplan = NULL;;) {
  95                         if ((next = yankexpr(planp)) == NULL)
  96                                 err(1, "(: missing closing ')'");
  97                         /*
  98                          * If we find a closing ')' we store the collected
  99                          * subplan in our '(' node and convert the node to
 100                          * a f_expr.  The ')' we found is ignored.  Otherwise,
 101                          * we just continue to add whatever we get to our
 102                          * subplan.
 103                          */
 104                         if (next->execute == f_closeparen) {
 105                                 if (subplan == NULL)
 106                                         errx(1, "(): empty inner expression");
 107                                 node->p_data[0] = subplan;
 108                                 node->execute = f_expr;
 109                                 break;
 110                         } else {
 111                                 if (subplan == NULL)
 112                                         tail = subplan = next;
 113                                 else {
 114                                         tail->next = next;
 115                                         tail = next;
 116                                 }
 117                                 tail->next = NULL;
 118                         }
 119                 }
 120         return (node);
 121 }
 122
 123 /*
 124  * paren_squish --
 125  *      replaces "parentheisized" plans in our search plan with "expr" nodes.
 126  */
 127 PLAN *
 128 paren_squish(plan)
 129         PLAN *plan;             /* plan with ( ) nodes */
 130 {
 131         register PLAN *expr;    /* pointer to next expression */
 132         register PLAN *tail;    /* pointer to tail of result plan */
 133         PLAN *result;           /* pointer to head of result plan */
 134
 135         result = tail = NULL;
 136
 137         /*
 138          * the basic idea is to have yankexpr do all our work and just
 139          * collect its results together.
 140          */
 141         while ((expr = yankexpr(&plan)) != NULL) {
 142                 /*
 143                  * if we find an unclaimed ')' it means there is a missing
 144                  * '(' someplace.
 145                  */
 146                 if (expr->execute == f_closeparen)
 147                         errx(1, "): no beginning '('");
 148
 149                 /* add the expression to our result plan */
 150                 if (result == NULL)
 151                         tail = result = expr;
 152                 else {
 153                         tail->next = expr;
 154                         tail = expr;
 155                 }
 156                 tail->next = NULL;
 157         }
 158         return (result);
 159 }
 160
 161 /*
 162  * not_squish --
 163  *      compresses "!" expressions in our search plan.
 164  */
 165 PLAN *
 166 not_squish(plan)
 167         PLAN *plan;             /* plan to process */
 168 {
 169         register PLAN *next;    /* next node being processed */
 170         register PLAN *node;    /* temporary node used in f_not processing */
 171         register PLAN *tail;    /* pointer to tail of result plan */
 172         PLAN *result;           /* pointer to head of result plan */
 173
 174         tail = result = NULL;
 175
 176         while (next = yanknode(&plan)) {
 177                 /*
 178                  * if we encounter a ( expression ) then look for nots in
 179                  * the expr subplan.
 180                  */
 181                 if (next->execute == f_expr)
 182                         next->p_data[0] = not_squish(next->p_data[0]);
 183
 184                 /*
 185                  * if we encounter a not, then snag the next node and place
 186                  * it in the not's subplan.  As an optimization we compress
 187                  * several not's to zero or one not.
 188                  */
 189                 if (next->execute == f_not) {
 190                         int notlevel = 1;
 191
 192                         node = yanknode(&plan);
 193                         while (node != NULL && node->execute == f_not) {
 194                                 ++notlevel;
 195                                 node = yanknode(&plan);
 196                         }
 197                         if (node == NULL)
 198                                 errx(1, "!: no following expression");
 199                         if (node->execute == f_or)
 200                                 errx(1, "!: nothing between ! and -o");
 201                         /*
 202                          * If we encounter ! ( expr ) then look for nots in
 203                          * the expr subplan.
 204                          */
 205                         if (node->execute == f_expr)
 206                                 node->p_data[0] = not_squish(node->p_data[0]);
 207                         if (notlevel % 2 != 1)
 208                                 next = node;
 209                         else
 210                                 next->p_data[0] = node;
 211                 }
 212
 213                 /* add the node to our result plan */
 214                 if (result == NULL)
 215                         tail = result = next;
 216                 else {
 217                         tail->next = next;
 218                         tail = next;
 219                 }
 220                 tail->next = NULL;
 221         }
 222         return (result);
 223 }
 224
 225 /*
 226  * or_squish --
 227  *      compresses -o expressions in our search plan.
 228  */
 229 PLAN *
 230 or_squish(plan)
 231         PLAN *plan;             /* plan with ors to be squished */
 232 {
 233         register PLAN *next;    /* next node being processed */
 234         register PLAN *tail;    /* pointer to tail of result plan */
 235         PLAN *result;           /* pointer to head of result plan */
 236
 237         tail = result = next = NULL;
 238
 239         while ((next = yanknode(&plan)) != NULL) {
 240                 /*
 241                  * if we encounter a ( expression ) then look for or's in
 242                  * the expr subplan.
 243                  */
 244                 if (next->execute == f_expr)
 245                         next->p_data[0] = or_squish(next->p_data[0]);
 246
 247                 /* if we encounter a not then look for or's in the subplan */
 248                 if (next->execute == f_not)
 249                         next->p_data[0] = or_squish(next->p_data[0]);
 250
 251                 /*
 252                  * if we encounter an or, then place our collected plan in the
 253                  * or's first subplan and then recursively collect the
 254                  * remaining stuff into the second subplan and return the or.
 255                  */
 256                 if (next->execute == f_or) {
 257                         if (result == NULL)
 258                                 errx(1, "-o: no expression before -o");
 259                         next->p_data[0] = result;
 260                         next->p_data[1] = or_squish(plan);
 261                         if (next->p_data[1] == NULL)
 262                                 errx(1, "-o: no expression after -o");
 263                         return (next);
 264                 }
 265
 266                 /* add the node to our result plan */
 267                 if (result == NULL)
 268                         tail = result = next;
 269                 else {
 270                         tail->next = next;
 271                         tail = next;
 272                 }
 273                 tail->next = NULL;
 274         }
 275         return (result);
 276 }