projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
BSD 4_3_Net_2 release
[unix-history] / usr / src / usr.bin / find / operator.c
diff --git a/usr/src/usr.bin/find/operator.c b/usr/src/usr.bin/find/operator.c
index 2734f82..b62add6 100644 (file)
--- a/usr/src/usr.bin/find/operator.c
+++ b/usr/src/usr.bin/find/operator.c
@@ -5,23 +5,37 @@
  * This code is derived from software contributed to Berkeley by
  * Cimarron D. Taylor of the University of California, Berkeley.
  *
  * This code is derived from software contributed to Berkeley by
  * Cimarron D. Taylor of the University of California, Berkeley.
  *
- * Redistribution and use in source and binary forms are permitted provided
- * that: (1) source distributions retain this entire copyright notice and
- * comment, and (2) distributions including binaries display the following
- * acknowledgement:  ``This product includes software developed by the
- * University of California, Berkeley and its contributors'' in the
- * documentation or other materials provided with the distribution and in
- * all advertising materials mentioning features or use of this software.
- * Neither the name of the University nor the names of its contributors may
- * be used to endorse or promote products derived from this software without
- * specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  */
 
 #ifndef lint
  */
 
 #ifndef lint
-static char sccsid[] = "@(#)operator.c 5.1 (Berkeley) 4/16/90";
+static char sccsid[] = "@(#)operator.c 5.4 (Berkeley) 5/24/91";
 #endif /* not lint */
 
 #include <sys/types.h>
 #endif /* not lint */
 
 #include <sys/types.h>
@@ -29,11 +43,11 @@ static char sccsid[] = "@(#)operator.c      5.1 (Berkeley) 4/16/90";
 #include "find.h"
     
 /*
 #include "find.h"
     
 /*
- * find_yanknode --
+ * yanknode --
  *     destructively removes the top from the plan
  */
  *     destructively removes the top from the plan
  */
-PLAN *
-find_yanknode(planp)    
+static PLAN *
+yanknode(planp)    
        PLAN **planp;           /* pointer to top of plan (modified) */
 {
        PLAN *node;             /* top node removed from the plan */
        PLAN **planp;           /* pointer to top of plan (modified) */
 {
        PLAN *node;             /* top node removed from the plan */
@@ -46,13 +60,13 @@ find_yanknode(planp)
 }
  
 /*
 }
  
 /*
- * find_yankexpr --
+ * yankexpr --
  *     Removes one expression from the plan.  This is used mainly by
  *     Removes one expression from the plan.  This is used mainly by
- *     find_squish_paren.  In comments below, an expression is either
- *     a simple node or a T_EXPR node containing a list of simple nodes.
+ *     paren_squish.  In comments below, an expression is either a
+ *     simple node or a N_EXPR node containing a list of simple nodes.
  */
  */
-PLAN *
-find_yankexpr(planp)    
+static PLAN *
+yankexpr(planp)    
        PLAN **planp;           /* pointer to top of plan (modified) */
 {
        register PLAN *next;    /* temp node holding subexpression results */
        PLAN **planp;           /* pointer to top of plan (modified) */
 {
        register PLAN *next;    /* temp node holding subexpression results */
@@ -62,7 +76,7 @@ find_yankexpr(planp)
        int f_expr();
     
        /* first pull the top node from the plan */
        int f_expr();
     
        /* first pull the top node from the plan */
-       if ((node = find_yanknode(planp)) == NULL)
+       if ((node = yanknode(planp)) == NULL)
                return(NULL);
     
        /*
                return(NULL);
     
        /*
@@ -71,22 +85,23 @@ find_yankexpr(planp)
         * just return it and unwind our recursion; all other nodes are
         * complete expressions, so just return them.
         */
         * just return it and unwind our recursion; all other nodes are
         * complete expressions, so just return them.
         */
-       if (node->type == T_OPENPAREN)
+       if (node->type == N_OPENPAREN)
                for (tail = subplan = NULL;;) {
                for (tail = subplan = NULL;;) {
-                       if ((next = find_yankexpr(planp)) == NULL)
-                               bad_arg("(", "missing closing ')'");
+                       if ((next = yankexpr(planp)) == NULL)
+                               err("%s: %s", "(", "missing closing ')'");
                        /*
                         * If we find a closing ')' we store the collected
                         * subplan in our '(' node and convert the node to
                        /*
                         * If we find a closing ')' we store the collected
                         * subplan in our '(' node and convert the node to
-                        * a T_EXPR.  The ')' we found is ignored.  Otherwise,
+                        * a N_EXPR.  The ')' we found is ignored.  Otherwise,
                         * we just continue to add whatever we get to our
                         * subplan.
                         */
                         * we just continue to add whatever we get to our
                         * subplan.
                         */
-                       if (next->type == T_CLOSEPAREN) {
+                       if (next->type == N_CLOSEPAREN) {
                                if (subplan == NULL)
                                if (subplan == NULL)
-                                       bad_arg("()", "empty inner expression");
+                                       err("%s: %s",
+                                           "()", "empty inner expression");
                                node->p_data[0] = subplan;
                                node->p_data[0] = subplan;
-                               node->type = T_EXPR;
+                               node->type = N_EXPR;
                                node->eval = f_expr;
                                break;
                        } else {
                                node->eval = f_expr;
                                break;
                        } else {
@@ -103,11 +118,11 @@ find_yankexpr(planp)
 }
  
 /*
 }
  
 /*
- * find_squish_paren --
+ * paren_squish --
  *     replaces "parentheisized" plans in our search plan with "expr" nodes.
  */
 PLAN *
  *     replaces "parentheisized" plans in our search plan with "expr" nodes.
  */
 PLAN *
-find_squish_paren(plan)
+paren_squish(plan)
        PLAN *plan;             /* plan with ( ) nodes */
 {
        register PLAN *expr;    /* pointer to next expression */
        PLAN *plan;             /* plan with ( ) nodes */
 {
        register PLAN *expr;    /* pointer to next expression */
@@ -117,16 +132,16 @@ find_squish_paren(plan)
        result = tail = NULL;
 
        /*
        result = tail = NULL;
 
        /*
-        * the basic idea is to have find_yankexpr do all our work and just
+        * the basic idea is to have yankexpr do all our work and just
         * collect it's results together.
         */
         * collect it's results together.
         */
-       while ((expr = find_yankexpr(&plan)) != NULL) {
+       while ((expr = yankexpr(&plan)) != NULL) {
                /*
                 * if we find an unclaimed ')' it means there is a missing
                 * '(' someplace.
                 */
                /*
                 * if we find an unclaimed ')' it means there is a missing
                 * '(' someplace.
                 */
-               if (expr->type == T_CLOSEPAREN)
-                       bad_arg(")", "no beginning '('");
+               if (expr->type == N_CLOSEPAREN)
+                       err("%s: %s", ")", "no beginning '('");
 
                /* add the expression to our result plan */
                if (result == NULL)
 
                /* add the expression to our result plan */
                if (result == NULL)
@@ -141,45 +156,45 @@ find_squish_paren(plan)
 }
  
 /*
 }
  
 /*
- * find_squish_not --
+ * not_squish --
  *     compresses "!" expressions in our search plan.
  */
 PLAN *
  *     compresses "!" expressions in our search plan.
  */
 PLAN *
-find_squish_not(plan)
+not_squish(plan)
        PLAN *plan;             /* plan to process */
 {
        register PLAN *next;    /* next node being processed */
        PLAN *plan;             /* plan to process */
 {
        register PLAN *next;    /* next node being processed */
-       register PLAN *node;    /* temporary node used in T_NOT processing */
+       register PLAN *node;    /* temporary node used in N_NOT processing */
        register PLAN *tail;    /* pointer to tail of result plan */
        PLAN *result;           /* pointer to head of result plan */
     
        tail = result = next = NULL;
     
        register PLAN *tail;    /* pointer to tail of result plan */
        PLAN *result;           /* pointer to head of result plan */
     
        tail = result = next = NULL;
     
-       while ((next = find_yanknode(&plan)) != NULL) {
+       while ((next = yanknode(&plan)) != NULL) {
                /*
                 * if we encounter a ( expression ) then look for nots in
                 * the expr subplan.
                 */
                /*
                 * if we encounter a ( expression ) then look for nots in
                 * the expr subplan.
                 */
-               if (next->type == T_EXPR)
-                       next->p_data[0] = find_squish_not(next->p_data[0]);
+               if (next->type == N_EXPR)
+                       next->p_data[0] = not_squish(next->p_data[0]);
 
                /*
                 * if we encounter a not, then snag the next node and place
                 * it in the not's subplan.  As an optimization we compress
                 * several not's to zero or one not.
                 */
 
                /*
                 * if we encounter a not, then snag the next node and place
                 * it in the not's subplan.  As an optimization we compress
                 * several not's to zero or one not.
                 */
-               if (next->type == T_NOT) {
+               if (next->type == N_NOT) {
                        int notlevel = 1;
 
                        int notlevel = 1;
 
-                       node = find_yanknode(&plan);
-                       while (node->type == T_NOT) {
+                       node = yanknode(&plan);
+                       while (node->type == N_NOT) {
                                ++notlevel;
                                ++notlevel;
-                               node = find_yanknode(&plan);
+                               node = yanknode(&plan);
                        }
                        if (node == NULL)
                        }
                        if (node == NULL)
-                               bad_arg("!", "no following expression");
-                       if (node->type == T_OR)
-                               bad_arg("!", "nothing between ! and -o");
+                               err("%s: %s", "!", "no following expression");
+                       if (node->type == N_OR)
+                               err("%s: %s", "!", "nothing between ! and -o");
                        if (notlevel % 2 != 1)
                                next = node;
                        else
                        if (notlevel % 2 != 1)
                                next = node;
                        else
@@ -199,11 +214,11 @@ find_squish_not(plan)
 }
  
 /*
 }
  
 /*
- * find_squish_or --
+ * or_squish --
  *     compresses -o expressions in our search plan.
  */
 PLAN *
  *     compresses -o expressions in our search plan.
  */
 PLAN *
-find_squish_or(plan)
+or_squish(plan)
        PLAN *plan;             /* plan with ors to be squished */
 {
        register PLAN *next;    /* next node being processed */
        PLAN *plan;             /* plan with ors to be squished */
 {
        register PLAN *next;    /* next node being processed */
@@ -212,30 +227,30 @@ find_squish_or(plan)
     
        tail = result = next = NULL;
     
     
        tail = result = next = NULL;
     
-       while ((next = find_yanknode(&plan)) != NULL) {
+       while ((next = yanknode(&plan)) != NULL) {
                /*
                 * if we encounter a ( expression ) then look for or's in
                 * the expr subplan.
                 */
                /*
                 * if we encounter a ( expression ) then look for or's in
                 * the expr subplan.
                 */
-               if (next->type == T_EXPR)
-                       next->p_data[0] = find_squish_or(next->p_data[0]);
+               if (next->type == N_EXPR)
+                       next->p_data[0] = or_squish(next->p_data[0]);
 
                /* if we encounter a not then look for not's in the subplan */
 
                /* if we encounter a not then look for not's in the subplan */
-               if (next->type == T_NOT)
-                       next->p_data[0] = find_squish_or(next->p_data[0]);
+               if (next->type == N_NOT)
+                       next->p_data[0] = or_squish(next->p_data[0]);
 
                /*
                 * if we encounter an or, then place our collected plan in the
                 * or's first subplan and then recursively collect the
                 * remaining stuff into the second subplan and return the or.
                 */
 
                /*
                 * if we encounter an or, then place our collected plan in the
                 * or's first subplan and then recursively collect the
                 * remaining stuff into the second subplan and return the or.
                 */
-               if (next->type == T_OR) {
+               if (next->type == N_OR) {
                        if (result == NULL)
                        if (result == NULL)
-                               bad_arg("-o", "no expression before -o");
+                               err("%s: %s", "-o", "no expression before -o");
                        next->p_data[0] = result;
                        next->p_data[0] = result;
-                       next->p_data[1] = find_squish_or(plan);
+                       next->p_data[1] = or_squish(plan);
                        if (next->p_data[1] == NULL)
                        if (next->p_data[1] == NULL)
-                               bad_arg("-o", "no expression after -o");
+                               err("%s: %s", "-o", "no expression after -o");
                        return(next);
                }
 
                        return(next);
                }
 
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.