bo->pgno, &t->bt_rdata.data, &t->bt_rdata.ulen) != 0) abort();
bo->pgno, &t->bt_rdata.data, &t->bt_rdata.ulen) != 0) { (void)__db_panic(dbp); return (0); }
__bam_cmp(dbp, k1, e)	DB *dbp;	const DBT *k1;	EPG *e;{	BINTERNAL *bi;	BKEYDATA *bk;	BOVERFLOW *bo;	BTREE *t;	DBT k2;	PAGE *h;	t = dbp->internal;	/*	 * Returns:	 *	< 0 if k1 is < record	 *	= 0 if k1 is = record	 *	> 0 if k1 is > record	 *	 * The left-most key on internal pages, at any level of the tree, is	 * guaranteed, by the following code, to be less than any user key.	 * This saves us from having to update the leftmost key on an internal	 * page when the user inserts a new key in the tree smaller than	 * anything we've yet seen.	 */	h = e->page;	if (e->indx == 0 &&	    h->prev_pgno == PGNO_INVALID && TYPE(h) != P_LBTREE)		return (1);	bo = NULL;	if (TYPE(h) == P_LBTREE) {		bk = GET_BKEYDATA(h, e->indx);		if (B_TYPE(bk->type) == B_OVERFLOW)			bo = (BOVERFLOW *)bk;		else {			memset(&k2, 0, sizeof(k2));			k2.data = bk->data;			k2.size = bk->len;		}	} else {		bi = GET_BINTERNAL(h, e->indx);		if (B_TYPE(bi->type) == B_OVERFLOW)			bo = (BOVERFLOW *)(bi->data);		else {			memset(&k2, 0, sizeof(k2));			k2.data = bi->data;			k2.size = bi->len;		}	}	/*	 * XXX	 * We ignore system errors; the only recoverable one is ENOMEM, and we	 * don't want to require that comparison routines handle random errors.	 * We don't want to return a valid comparison, either, so we stop.	 */	if (bo != NULL) {		/*		 * If using the default comparison routine, use __db_moff(),		 * which compares the overflow key a page at a time.		 */		if (t->bt_compare == __bam_defcmp)			return (__db_moff(dbp, k1, bo->pgno));		/*		 * Otherwise, we need a contiguous record so we can hand it		 * to the user's routine.		 */		if (__db_goff(dbp, &k2, bo->tlen,		    bo->pgno, &t->bt_rdata.data, &t->bt_rdata.ulen) != 0)			abort();	}	return ((*t->bt_compare)(k1, &k2));}