Lines Matching defs:ptn
107 #define NODETOITEM(pt, ptn) \
108 ((void *)((uintptr_t)(ptn) - (pt)->pt_node_offset))
109 #define NODETOKEY(pt, ptn) \
110 ((void *)((uintptr_t)(ptn) - (pt)->pt_node_offset + pt->pt_key_offset))
111 #define ITEMTONODE(pt, ptn) \
112 ((pt_node_t *)((uintptr_t)(ptn) + (pt)->pt_node_offset))
122 const pt_node_t *ptn, pt_bitoff_t max_bitoff,
126 (ptn != NULL ? NODETOKEY(pt, ptn) : NULL),
132 const pt_node_t *ptn)
134 const pt_bitlen_t bitlen = PTN_BRANCH_BITLEN(ptn);
138 PTN_BRANCH_BITOFF(ptn), bitlen, pt->pt_context);
143 const pt_node_t *ptn, pt_bitoff_t bitoff, pt_bitlen_t bitlen)
145 return (*pt->pt_ops->ptto_matchkey)(key, NODETOKEY(pt, ptn),
150 ptree_testkey(const pt_tree_t *pt, const void *key, const pt_node_t *ptn)
152 const pt_bitlen_t bitlen = PTN_BRANCH_BITLEN(ptn);
155 return (*pt->pt_ops->ptto_testkey)(key, PTN_BRANCH_BITOFF(ptn),
156 PTN_BRANCH_BITLEN(ptn), pt->pt_context);
297 pt_node_t * const ptn = PT_NODE(node);
299 const pt_bitlen_t node_mask_len = PTN_MASK_BITLEN(ptn);
301 KASSERT(PT_LEAF_P(node) || id->id_parent_slot == PTN_BRANCH_POSITION(ptn));
302 KASSERT(PT_BRANCH_P(node) || id->id_parent_slot == PTN_LEAF_POSITION(ptn));
309 if (PTN_ISMASK_P(ptn) && node_mask_len == mask_len)
484 pt_node_t * const ptn = PT_NODE(*id.id_insertp);
490 if (target == ptn)
500 ptn) == id.id_parent_slot);
510 KASSERT(PTN_BRANCH_POSITION(ptn) == id.id_parent_slot);
515 branch_bitoff = PTN_BRANCH_BITOFF(ptn);
522 KASSERT(!(PTN_ISMASK_P(ptn) && PTN_BRANCH_BITLEN(ptn) == 0) || PTN_MASK_BITLEN(ptn) == branch_bitoff);
544 || ptree_matchnode(pt, target, ptn, target_masklen,
570 && !ptree_matchnode(pt, target, ptn, branch_bitoff,
586 id.id_parent = ptn;
637 pt_node_t *ptn, *parent;
650 ptn = PT_NODE(node);
654 at_mask = PTN_ISMASK_P(ptn);
660 if (!ptree_matchkey(pt, key, ptn, bitoff, branch_bitoff - bitoff)) {
671 if (PTN_ISMASK_P(ptn) && PTN_BRANCH_BITLEN(ptn) == 0
673 || (*filter)(filter_arg, NODETOITEM(pt, ptn),
675 mask = ptn;
678 parent = ptn;
684 if (!filter || (*filter)(filter_arg, NODETOITEM(pt, ptn), at_mask ? PT_FILTER_MASK : 0)) {
686 if (PTN_ISMASK_P(ptn)) {
687 const pt_bitlen_t mask_len = PTN_MASK_BITLEN(ptn);
688 if (bitoff == PTN_MASK_BITLEN(ptn))
689 return NODETOITEM(pt, ptn);
690 if (ptree_matchkey(pt, key, ptn, bitoff, mask_len - bitoff))
691 return NODETOITEM(pt, ptn);
694 if (ptree_matchkey(pt, key, ptn, bitoff, UINT_MAX))
695 return NODETOITEM(pt, ptn);
731 pt_node_t * const ptn = PT_NODE(node);
733 && PTN_ISMASK_P(ptn) && PTN_BRANCH_BITLEN(ptn) == 0)
734 return NODETOITEM(pt, ptn);
742 pt_node_t * const ptn = PT_NODE(node);
745 if (PTN_ISMASK_P(ptn) && PTN_BRANCH_BITLEN(ptn) == 0) {
746 if (ptn == target)
754 slot = ptree_testnode(pt, target, ptn);
755 node = PTN_BRANCH_SLOT(ptn, slot);
757 if (slot != (pt_slot_t)((1 << PTN_BRANCH_BITLEN(ptn)) - 1))
758 next_node = PTN_BRANCH_SLOT(ptn, slot + 1);
764 next_node = PTN_BRANCH_SLOT(ptn, slot - 1);
772 pt_node_t *ptn = PT_NODE(node);
775 next_node = PTN_BRANCH_ROOT_SLOT(ptn);
776 ptn = PT_NODE(next_node);
795 pt_node_t * const ptn = PT_NODE(node);
800 && PTN_ISMASK_P(ptn)
801 && PTN_BRANCH_BITLEN(ptn) == 0)
802 return NODETOITEM(pt, ptn);
806 slot = (1 << PTN_BRANCH_BITLEN(ptn)) - 1;
808 node = PTN_BRANCH_SLOT(ptn, slot);
819 pt_node_t *ptn, *parent;
841 ptn = PT_NODE(node);
843 at_mask = PTN_ISMASK_P(ptn);
854 if (__predict_false(ptn == target)) {
860 if (at_mask && PTN_BRANCH_BITLEN(ptn) == 0) {
862 PTN_BRANCH_ROOT_SLOT(ptn);
863 KASSERT(PT_NULL_P(PTN_BRANCH_ODDMAN_SLOT(ptn)));
882 parent = ptn;
890 if (target != ptn) {
891 KASSERT(target == ptn);
1094 const pt_node_t *ptn)
1096 const pt_bitoff_t leaf_position = PTN_LEAF_POSITION(ptn);
1097 const pt_bitlen_t bitlen = PTN_BRANCH_BITLEN(ptn);
1098 const pt_bitlen_t mask_len = PTN_MASK_BITLEN(ptn);
1099 const uintptr_t leaf_node = PTN_LEAF(ptn);
1101 const bool is_mask = PTN_ISMASK_P(ptn);
1118 ok = ok && leaf_position == ptree_testnode(pt, ptn, parent);
1123 ok = ok && ptn == ptree_check_find_node2(pt, ptn, PTN_LEAF(ptn));
1131 const pt_node_t *ptn)
1134 const pt_slot_t branch_slot = PTN_BRANCH_POSITION(ptn);
1135 const pt_bitoff_t bitoff = PTN_BRANCH_BITOFF(ptn);
1136 const pt_bitoff_t bitlen = PTN_BRANCH_BITLEN(ptn);
1140 const bool is_mask = PTN_ISMASK_P(ptn) && bitlen == 0;
1142 const pt_bitoff_t mask_len = PTN_MASK_BITLEN(ptn);
1147 ok = ok && PTN_BRANCH_SLOT(parent, branch_slot) == PTN_BRANCH(ptn);
1149 ok = ok && branch_slot == ptree_testnode(pt, ptn, parent);
1171 const uintptr_t node = PTN_BRANCH_SLOT(ptn, slot);
1174 ok = ok && node != PTN_BRANCH(ptn);
1177 ok = ok && ptree_matchnode(pt, PT_NODE(node), ptn, bitoff, &tmp_bitoff, &tmp_slot);
1179 tmp_slot = ptree_testnode(pt, PT_NODE(node), ptn);
1184 ok = ok && ptree_check_leaf(pt, ptn, PT_NODE(node));
1186 ok = ok && ptree_check_branch(pt, ptn, PT_NODE(node));
1201 const pt_node_t * const ptn = PT_NODE(node);
1210 ok = ok && ptree_check_leaf(pt, parent, ptn);
1212 ok = ok && ptree_check_branch(pt, parent, ptn);
Indexes created Tue Sep 30 11:09:46 GMT 2025