/* * not_squish -- * compresses "!" expressions in our search plan. */ PLAN * not_squish(PLAN *plan) { PLAN *next; /* next node being processed */ PLAN *node; /* temporary node used in f_not processing */ PLAN *tail; /* pointer to tail of result plan */ PLAN *result; /* pointer to head of result plan */ tail = result = NULL; while ((next = yanknode(&plan))) { /* * if we encounter a ( expression ) then look for nots in * the expr subplan. */ if (next->execute == f_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 (next->execute == f_not) { int notlevel = 1; node = yanknode(&plan); while (node != NULL && node->execute == f_not) { ++notlevel; node = yanknode(&plan); } if (node == NULL) errx(1, "!: no following expression"); if (node->execute == f_or) errx(1, "!: nothing between ! and -o"); /* * If we encounter ! ( expr ) then look for nots in * the expr subplan. */ if (node->execute == f_expr) node->p_data[0] = not_squish(node->p_data[0]); if (notlevel % 2 != 1) next = node; else next->p_data[0] = node; } /* add the node to our result plan */ if (result == NULL) tail = result = next; else { tail->next = next; tail = next; } tail->next = NULL; } return (result); }
/* * yankexpr -- * Removes one expression from the plan. This is used mainly by * paren_squish. In comments below, an expression is either a * simple node or a N_EXPR node containing a list of simple nodes. */ static PLAN * yankexpr(PLAN **planp) /* pointer to top of plan (modified) */ { PLAN *next; /* temp node holding subexpression results */ PLAN *node; /* pointer to returned node or expression */ PLAN *tail; /* pointer to tail of subplan */ PLAN *subplan; /* pointer to head of ( ) expression */ /* first pull the top node from the plan */ if ((node = yanknode(planp)) == NULL) return (NULL); /* * If the node is an '(' then we recursively slurp up expressions * until we find its associated ')'. If it's a closing paren we * just return it and unwind our recursion; all other nodes are * complete expressions, so just return them. */ if (node->type == N_OPENPAREN) for (tail = subplan = NULL;;) { if ((next = yankexpr(planp)) == NULL) err(1, "(: missing closing ')'"); /* * If we find a closing ')' we store the collected * subplan in our '(' node and convert the node to * a N_EXPR. The ')' we found is ignored. Otherwise, * we just continue to add whatever we get to our * subplan. */ if (next->type == N_CLOSEPAREN) { if (subplan == NULL) errx(1, "(): empty inner expression"); node->p_data[0] = subplan; node->type = N_EXPR; node->eval = f_expr; break; } else { if (subplan == NULL) tail = subplan = next; else { tail->next = next; tail = next; } tail->next = NULL; } } return (node); }
/* * or_squish -- * compresses -o expressions in our search plan. */ PLAN * or_squish(PLAN *plan) { PLAN *next; /* next node being processed */ PLAN *tail; /* pointer to tail of result plan */ PLAN *result; /* pointer to head of result plan */ tail = result = next = NULL; while ((next = yanknode(&plan)) != NULL) { /* * if we encounter a ( expression ) then look for or's in * the expr subplan. */ if (next->execute == f_expr) next->p_data[0] = or_squish(next->p_data[0]); /* if we encounter a not then look for or's in the subplan */ if (next->execute == f_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 (next->execute == f_or) { if (result == NULL) errx(1, "-o: no expression before -o"); next->p_data[0] = result; next->p_data[1] = or_squish(plan); if (next->p_data[1] == NULL) errx(1, "-o: no expression after -o"); return (next); } /* add the node to our result plan */ if (result == NULL) tail = result = next; else { tail->next = next; tail = next; } tail->next = NULL; } return (result); }