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.
744 * next nodes.
746 next = node_next(s, nodep);
747 if (next) {
749 if (next->mask == 0 && next->num_after == 0) {
750 node_rm(s, next);
756 * Is next node index adjacent to current node
759 if (next->idx == nodep->idx + MASK_BITS + nodep->num_after &&
760 next->mask == ~(mask_t) 0) {
762 next->mask = 0;
763 nodep->num_after += next->num_after;
764 next->num_after = 0;
766 node_rm(s, next);
767 next = NULL;
997 /* Find the next cleared bit */
1003 * there are enough set bits between idx and the next cleared bit.
1028 /* Find the next set bit */
1034 * there are enough cleared bits between idx and the next set bit.
1152 /* Returns index of next bit set within s after the index given by prev.
1234 * this, the next bit is the first bit in the next node, if
1235 * such a node exists. If a next node doesn't exist, then
1236 * there is no next set bit.
1245 /* Returns index of next bit cleared within s after the index given by prev.
1267 /* Does a mask bit in node 1 describe the next cleared bit. */
1274 * isn't a next node, then next cleared bit is described
1284 * of cleared bits between the nodes, and the next cleared bit
1374 struct node *nodep, *next;
1421 for (next = node_next(s, nodep);
1422 next && (next->idx < middle_end);
1423 next = node_next(s, nodep)) {
1424 assert(next->idx + MASK_BITS + next->num_after - 1 <= middle_end);
1425 node_rm(s, next);
1426 next = NULL;
1456 struct node *nodep, *next;
1484 for (next = node_next(s, nodep);
1485 next && (next->idx < middle_end);
1486 next = node_next(s, nodep)) {
1487 assert(next->idx + MASK_BITS + next->num_after - 1 <= middle_end);
1488 node_rm(s, next);
1489 next = NULL;
1507 * with the nodes prev or next of nodep.
1629 * a newline plus the indent of the next
1663 * a newline plus the indent of the next
1918 sparsebit_idx_t next;
1982 next = sparsebit_next_set(s, first);
1983 assert(next == 0 || next > first);
1984 assert(next == 0 || get_value(next));
1987 next = sparsebit_next_clear(s, first);
1988 assert(next == 0 || next > first);
1989 assert(next == 0 || !get_value(next));
1992 next = sparsebit_next_clear(s, first);
1994 assert(next == 0 || next > last);
1996 next = sparsebit_next_set(s, first - 1);
1998 next = sparsebit_first_set(s);
2001 assert(next == first);
2003 assert(sparsebit_is_clear(s, first) || next <= last);
2007 next = sparsebit_next_set(s, first);
2009 assert(next == 0 || next > last);
2011 next = sparsebit_next_clear(s, first - 1);
2013 next = sparsebit_first_clear(s);
2016 assert(next == first);
2018 assert(sparsebit_is_set(s, first) || next <= last);