Lines Matching refs:next
224 * If current node has a right child, next node is the left-most
235 * That parent is then the next node.
252 * If current node has a left child, next node is the right-most
263 * That parent is then the next node.
559 * reductions are possible with the new previous and next nodes. Note,
605 struct node *prev, *next, *tmp;
614 * for the next pass through the reduction loop,
617 * by first remembering the location of the next
620 * no other nodes between prev and next.
623 * both prev and next both check for an adjacent
626 * matter whether the nodep for the next pass
628 * prev or next node. Either way, on the next pass
630 * prev or next node.
743 * next nodes.
745 next = node_next(s, nodep);
746 if (next) {
748 if (next->mask == 0 && next->num_after == 0) {
749 node_rm(s, next);
755 * Is next node index adjacent to current node
758 if (next->idx == nodep->idx + MASK_BITS + nodep->num_after &&
759 next->mask == ~(mask_t) 0) {
761 next->mask = 0;
762 nodep->num_after += next->num_after;
763 next->num_after = 0;
765 node_rm(s, next);
766 next = NULL;
996 /* Find the next cleared bit */
1002 * there are enough set bits between idx and the next cleared bit.
1027 /* Find the next set bit */
1033 * there are enough cleared bits between idx and the next set bit.
1151 /* Returns index of next bit set within s after the index given by prev.
1233 * this, the next bit is the first bit in the next node, if
1234 * such a node exists. If a next node doesn't exist, then
1235 * there is no next set bit.
1244 /* Returns index of next bit cleared within s after the index given by prev.
1266 /* Does a mask bit in node 1 describe the next cleared bit. */
1273 * isn't a next node, then next cleared bit is described
1283 * of cleared bits between the nodes, and the next cleared bit
1373 struct node *nodep, *next;
1420 for (next = node_next(s, nodep);
1421 next && (next->idx < middle_end);
1422 next = node_next(s, nodep)) {
1423 assert(next->idx + MASK_BITS + next->num_after - 1 <= middle_end);
1424 node_rm(s, next);
1425 next = NULL;
1455 struct node *nodep, *next;
1483 for (next = node_next(s, nodep);
1484 next && (next->idx < middle_end);
1485 next = node_next(s, nodep)) {
1486 assert(next->idx + MASK_BITS + next->num_after - 1 <= middle_end);
1487 node_rm(s, next);
1488 next = NULL;
1506 * with the nodes prev or next of nodep.
1628 * a newline plus the indent of the next
1662 * a newline plus the indent of the next
1916 sparsebit_idx_t next;
1980 next = sparsebit_next_set(s, first);
1981 assert(next == 0 || next > first);
1982 assert(next == 0 || get_value(next));
1985 next = sparsebit_next_clear(s, first);
1986 assert(next == 0 || next > first);
1987 assert(next == 0 || !get_value(next));
1990 next = sparsebit_next_clear(s, first);
1992 assert(next == 0 || next > last);
1994 next = sparsebit_next_set(s, first - 1);
1996 next = sparsebit_first_set(s);
1999 assert(next == first);
2001 assert(sparsebit_is_clear(s, first) || next <= last);
2005 next = sparsebit_next_set(s, first);
2007 assert(next == 0 || next > last);
2009 next = sparsebit_next_clear(s, first - 1);
2011 next = sparsebit_first_clear(s);
2014 assert(next == first);
2016 assert(sparsebit_is_set(s, first) || next <= last);