Initial import of the CDE 2.1.30 sources from the Open Group.

cde/lib/tt/mini_isam/isread.c

@@ -0,0 +1,796 @@
+/*%%  (c) Copyright 1993, 1994 Hewlett-Packard Company			 */
+/*%%  (c) Copyright 1993, 1994 International Business Machines Corp.	 */
+/*%%  (c) Copyright 1993, 1994 Sun Microsystems, Inc.			 */
+/*%%  (c) Copyright 1993, 1994 Novell, Inc. 				 */
+/*%%  $XConsortium: isread.c /main/3 1995/10/23 11:43:35 rswiston $ 			 				 */
+#ifndef lint
+static char sccsid[] = "@(#)isread.c 1.9 89/07/17 Copyr 1988 Sun Micro";
+#endif
+/*
+ * Copyright (c) 1988 by Sun Microsystems, Inc.
+ */
+
+/*
+ * isread.c
+ *
+ * Description:
+ *	Read a record from ISAM file. 
+ */
+
+
+#include "isam_impl.h"
+#include <sys/time.h>
+
+static int _amread();
+
+/*
+ * err =  isread(isfd, record, mode)
+ *
+ * Isread() reads a new record from an ISAM file. 
+ *
+ * Current record position is set.
+ * isrecnum is set to indicate the read record.
+ *
+ * If the ISAM file is for variable length records, the isreclen variable
+ * is set to indicate the actual length of the record.
+ *
+ * Returns 0 if successful, or -1 of any error.
+ *
+ * Errors:
+ *	ELOCKED The record or the entire file is locked by another process.
+ *	ENOTOPEN isfd does not correspond to an open ISAM file, or the
+ *		ISAM file was opened with ISOUTPUT mode.
+ *	EBADARG Bad mode parameter.
+ *	ENOCURR Mode is ISCURR and the current record position is not set.
+ *	ENOREC	Specified record cannot be found (random access read)
+ *	EENDFILE The end file of is reached (sequential read).
+ *	EBADKEY Index was deleted by other process (can happen only
+ *		when lock file is purged).
+ */
+
+int 
+isread(isfd, record, mode)
+    int			isfd;
+    char		*record;
+    int			mode;
+{
+    register Fab	*fab;
+    int			reclen;
+    Recno		recnum;
+    int			ret;
+    enum readmode	readmode;
+
+    /*
+     * Get File Access Block.
+     */
+    if ((fab = _isfd_find(isfd)) == NULL) {
+	_setiserrno2(ENOTOPEN, '9', '0');
+	return (ISERROR);
+    }
+
+    /*
+     * Check that the open mode was ISINPUT, or ISINOUT.
+     */
+    if (fab->openmode != OM_INPUT && fab->openmode != OM_INOUT) {
+	_setiserrno2(ENOTOPEN, '9', '0');
+	return (ISERROR);
+    }
+
+    /*
+     * Extract read mode.
+     */
+    if ((readmode = _getreadmode(mode)) == RM_BADMODE) {
+	_setiserrno2(EBADARG, '9', '0');
+	return (ISERROR);
+    }
+
+    /*
+     * All keys must be in the minimum record length.
+     * So send just the minimum length part of the record.
+     */
+    reclen = fab->minreclen;
+
+    /*
+     * Call the Access Method
+     */
+    recnum = isrecnum;
+
+    if ((ret = _amread(&fab->isfhandle, record, &reclen,
+			readmode, &fab->curpos, &recnum,
+			&fab->errcode)) == ISOK) {
+	isrecnum = recnum;		     /* Set isrecnum */
+    }
+
+    isreclen = reclen;
+    _seterr_errcode(&fab->errcode);
+
+    return (ret);			     /* Successful read */
+}
+
+/*
+ * _amread(isfhandle, record, reclen, readmode, curpos, recnum, errcode)
+ *
+ * _amread() reads a record from ISAM file
+ *
+ * Input params:
+ *	isfhandle	Handle of ISAM file
+ *	readmode	Specifies access mode (random or sequential)
+ *	curpos		current record position
+ *	recnum		copy if isrecnum
+ *
+ * Output params:
+ *	curpos		new current position
+ *	recnum		record number
+ *	errcode		error status of the operation
+ *	reclen		actual length of the record
+ *	record		filled with data
+ *
+ */
+
+static int
+_amread(isfhandle, record, reclen, readmode, curpos, recnum, errcode)
+    Bytearray		*isfhandle;
+    enum readmode      	readmode;
+    char		*record;
+    int			*reclen;
+    Bytearray		*curpos;
+    Recno		*recnum;
+    struct errcode	*errcode;
+{
+    Fcb			*fcb = NULL;
+    Recno		recnum2;
+    int			err;
+    Crp			*crp;
+    Btree		*btree = NULL;
+    Keydesc2		*pkeydesc2;
+    char		keybuf1[MAXKEYSIZE], keybuf2[MAXKEYSIZE];
+    char		*pkey, *pkeynext;
+    int			skipbytes;
+    int			ret;
+    Bytearray		oldcurpos;
+    int			(*rec_read)();
+
+    _isam_entryhook();
+
+    /*
+     * Get FCB corresponding to the isfhandle handle.
+     */
+    if ((fcb = _openfcb(isfhandle, errcode)) == NULL) {
+	_isam_exithook();
+	return (ISERROR);
+    }
+
+    rec_read = (fcb->varflag?_vlrec_read:_flrec_read);
+
+    /*
+     * Update information in FCB from CNTL page on the disk
+     */
+    (void)_isfcb_cntlpg_r2(fcb);
+
+    /*
+     * Save the old record position.
+     */
+    oldcurpos = _bytearr_dup(curpos);
+
+    /*
+     * Get info from current record position structure.
+     */
+    crp = (Crp *) curpos->data;
+
+    if (crp->keyid == PHYS_ORDER) {
+	/*
+	 * Physical order in use.
+	 */
+	
+	switch (readmode) {
+	case RM_EQUAL:
+	    recnum2 = *recnum;		     /* passed from isrecnum */
+	    if ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+	    break;
+
+	case RM_GREAT:
+	    recnum2 = *recnum + 1;
+	    if (recnum2 < 1) recnum2 = 1;
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2++;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+	    break;
+
+	case RM_GTEQ:
+	    recnum2 = *recnum;
+	    if (recnum2 < 1) recnum2 = 1;
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2++;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+	    break;
+
+	case RM_LESS:
+	    recnum2 = *recnum - 1;
+	    if (recnum2 > fcb->lastrecno) recnum2 = fcb->lastrecno;
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2--;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+	    break;
+
+	case RM_LTEQ:
+	    recnum2 = *recnum;
+	    if (recnum2 > fcb->lastrecno) recnum2 = fcb->lastrecno;
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2--;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+	    break;
+
+	case RM_FIRST:
+	    recnum2 = 1;
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2++;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+	    break;
+	case RM_CURR:
+	    switch (crp->flag) {
+	    case CRP_ON:
+	    case CRP_BEFORE:
+	    case CRP_AFTER:
+		recnum2 = crp->recno;
+		break;
+	    case CRP_BEFOREANY:
+		recnum2 = 1;
+		break;
+	    default:
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+		
+	    if( rec_read(fcb, record, recnum2, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    break;
+	case RM_NEXT:
+	    switch (crp->flag) {
+	    case CRP_ON:
+	    case CRP_AFTER:
+		recnum2 = crp->recno + 1;
+		break;
+	    case CRP_BEFOREANY:
+		recnum2 = 1;
+		break;
+	    case CRP_BEFORE:
+		recnum2 = crp->recno;
+		break;
+	    case CRP_AFTERANY:
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    default:
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+		
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2++;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+	    break;
+	case RM_PREV:
+	    switch (crp->flag) {
+	    case CRP_ON:
+	    case CRP_BEFORE:
+		recnum2 = crp->recno - 1;
+		break;
+	    case CRP_AFTER:
+		recnum2 = crp->recno;
+		break;
+	    case CRP_BEFOREANY:
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    default:
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+		
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2--;
+ 
+	    if (err != ISOK) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+	    break;
+	case RM_LAST:
+	    recnum2 = fcb->lastrecno;
+	    /*
+	     * Skip deleted records.
+	     */
+	    while ((err = rec_read(fcb, record, recnum2, reclen)) != ISOK &&
+		   err == ENOREC) 
+		recnum2--;
+
+	    if (err != ISOK) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+	    break;
+	default:
+	    _isfatal_error("Invalid readmode");
+	}
+
+	*recnum = recnum2;
+
+	/*
+	 * Set new current record position.
+	 */
+	 crp->recno = recnum2;
+	 crp->flag = CRP_ON;
+
+    } /* physical order */
+    else {
+	/*
+	 * Find key descriptor in FCB
+	 */
+	if ((pkeydesc2 = _isfcb_indfindkey(fcb, crp->keyid)) == NULL) {
+	    _amseterrcode(errcode, EBADKEY);
+	    goto ERROR;
+	}
+
+	/*
+	 * skipkeybytes is set to the number of bytes in the beginning
+	 * of the key:
+	 *  RECNOSIZE for ISNODUPS keys to skip recno part
+	 *  RECNOSIZE + DUPIDSIZE to skip recno and duplicate serial number
+	 */
+	skipbytes = RECNOSIZE;
+	if (ALLOWS_DUPS2(pkeydesc2))
+	    skipbytes += DUPIDSIZE;
+		
+	/*
+	 * Create B tree object.
+	 */
+	btree = _isbtree_create(fcb, pkeydesc2);
+
+	switch (readmode) {
+	case RM_EQUAL:
+	case RM_GTEQ:
+            /* 
+	     * Make sure that you will read the first duplicate. 
+	     */
+            _iskey_fillmin(pkeydesc2, keybuf1);
+ 
+            /* 
+	     * Extract key fields from record. 
+	     */
+            _iskey_extract(pkeydesc2, record, keybuf2);
+            memcpy((void *)(keybuf1 + skipbytes),
+		   (const void *)(keybuf2 + skipbytes), crp->matchkeylen);
+
+            /*
+	     * Position pointer in the B-tree in before the searched value. 
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+            if ((pkey = _isbtree_next(btree)) == NULL) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+            
+            if (readmode == RM_EQUAL &&
+                memcmp(keybuf1 + skipbytes, pkey + skipbytes, 
+		       crp->matchkeylen) != 0) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_GREAT:
+            /* 
+	     * Make sure that you will read past all matching records.
+	     */
+            _iskey_fillmax(pkeydesc2, keybuf1);
+ 
+            /* 
+	     * Extract key fields from record. 
+	     */
+            _iskey_extract(pkeydesc2, record, keybuf2);
+            memcpy((void *)(keybuf1 + skipbytes),
+		   (const void *)(keybuf2 + skipbytes), crp->matchkeylen);
+
+            /*
+	     * Position pointer in the B-tree in before the searched value. 
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+            if ((pkey = _isbtree_next(btree)) == NULL) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+            
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_LESS:
+            /* 
+	     * Make sure that you will read before all matching records.
+	     */
+            _iskey_fillmin(pkeydesc2, keybuf1);
+ 
+            /* 
+	     * Extract key fields from record. 
+	     */
+            _iskey_extract(pkeydesc2, record, keybuf2);
+            memcpy((void *)(keybuf1 + skipbytes),
+		   (const void *)(keybuf2 + skipbytes), crp->matchkeylen);
+
+            /*
+	     * Position pointer in the B-tree in before the searched value. 
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+            if ((pkey = _isbtree_current(btree)) == NULL) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+            
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_LTEQ:
+            /* 
+	     * Make sure that you will read the last duplicate.
+	     */
+            _iskey_fillmax(pkeydesc2, keybuf1);
+ 
+            /* 
+	     * Extract key fields from record. 
+	     */
+            _iskey_extract(pkeydesc2, record, keybuf2);
+            memcpy((void *)(keybuf1 + skipbytes),
+		   (const void *)(keybuf2 + skipbytes), crp->matchkeylen);
+
+            /*
+	     * Position pointer in the B-tree in before the searched value. 
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+            if ((pkey = _isbtree_current(btree)) == NULL) {
+		_amseterrcode(errcode, ENOREC);
+		goto ERROR;
+	    }
+            
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_CURR:
+	    switch (crp->flag) {
+	    case CRP_ON:
+	    case CRP_BEFORE:
+	    case CRP_AFTER:
+		/*
+		 * We have check if the record has not been deleted
+		 * since the current record position was set up.
+		 */
+		_isbtree_search(btree, crp->key);
+		pkey = _isbtree_current(btree);
+
+		if (pkey == NULL || 
+		    ldrecno(pkey + KEY_RECNO_OFF) != crp->recno) {
+		    _amseterrcode(errcode, ENOCURR);
+		    goto ERROR;
+		}
+		break;
+	    case CRP_BEFOREANY:
+		_isbtree_search(btree, crp->key);
+		pkey = _isbtree_next(btree);
+
+		if (pkey == NULL) {
+		    _amseterrcode(errcode, EENDFILE);
+		    goto ERROR;
+		}
+           
+		crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+		memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		break;
+	    default:
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_NEXT:
+
+	    /*
+	     * Validate that current position has been set.
+	     */
+	    switch (crp->flag) {
+	    case CRP_ON:
+	    case CRP_BEFORE:
+	    case CRP_BEFOREANY:
+		break;
+	    case CRP_AFTERANY:
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    default:
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+ 
+            /*
+	     * Position pointer to current position.
+	     */
+            _isbtree_search(btree, crp->key);
+        
+	    if (crp->flag == CRP_BEFORE) 
+		pkey = _isbtree_current(btree);
+	    else 			   
+		/* crp->flag == CRP_ON || crp->flag == CRP_BEFOREANY */
+		pkey = _isbtree_next(btree);
+
+	    if (pkey == NULL) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+           
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_PREV:
+
+	    /*
+	     * Validate that current position has been set.
+	     */
+	    switch (crp->flag) {
+	    case CRP_ON:
+	    case CRP_BEFORE:
+		/*
+		 * To get to the previous record, we must decrement
+		 * the TID part for unique keys, or duplicate serial number 
+		 * for non-unique keys.
+		 */
+		memcpy((void *)keybuf1,
+		       (const void *)crp->key, pkeydesc2->k2_len);
+		if (ALLOWS_DUPS2(pkeydesc2)) {
+		    stlong(ldlong(keybuf1 + KEY_DUPS_OFF) - 1, 
+			    keybuf1 + KEY_DUPS_OFF);
+		}
+		else {
+		    strecno(ldrecno(keybuf1 + KEY_RECNO_OFF) - 1, 
+			    keybuf1 + KEY_RECNO_OFF);
+		}
+		break;
+	    case CRP_AFTER:
+		memcpy((void *)keybuf1, (const void *)crp->key, pkeydesc2->k2_len);
+		break;
+	    case CRP_BEFOREANY:
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    default:
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+ 
+            /*
+	     * Position pointer to current position.
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+	    pkey = _isbtree_current(btree);
+
+	    if (pkey == NULL) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+           
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, ENOCURR);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_FIRST:
+            /* 
+	     * Fill key buffer with -infinity.
+	     */
+            _iskey_fillmin(pkeydesc2, keybuf1);
+ 
+            /*
+	     * Position pointer in the B-tree before any key entry.
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+            if ((pkey = _isbtree_next(btree)) == NULL) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+            
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	case RM_LAST:
+            /* 
+	     * Fill key buffer with +infinity.
+	     */
+            _iskey_fillmax(pkeydesc2, keybuf1);
+ 
+            /*
+	     * Position pointer in the B-tree before any key entry.
+	     */
+            _isbtree_search(btree, keybuf1);
+        
+            if ((pkey = _isbtree_current(btree)) == NULL) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+            
+	    crp->recno = ldrecno(pkey + KEY_RECNO_OFF);
+	    memcpy((void *)crp->key, (const void *)pkey, pkeydesc2->k2_len);
+		
+	    if( rec_read(fcb, record, crp->recno, reclen) != ISOK) {
+		_amseterrcode(errcode, EENDFILE);
+		goto ERROR;
+	    }
+	    recnum2 = crp->recno;
+	    break;
+
+	default:
+	    _isfatal_error("Invalid readmode");
+	}
+
+	*recnum = recnum2;
+	 crp->flag = CRP_ON;
+
+	/*
+	 * Set up isdupl to handle isstat2 value for keys that allow
+	 * duplicate values.
+	 */
+	if (ALLOWS_DUPS2(pkeydesc2) && (pkeynext = _isbtree_next(btree)) &&
+	    memcmp(pkey + skipbytes, pkeynext + skipbytes, 
+		   crp->matchkeylen) == 0) {
+	    isdupl = 1;
+	}
+
+
+	_isbtree_destroy(btree);
+    }
+
+    _amseterrcode(errcode, ISOK);
+    ret = ISOK;
+
+    /* Clean-up work. */
+    _isdisk_commit();			     /* This will only check
+					      * that we unfixed all fixed
+					      * buffers */
+    _isdisk_inval();
+    _bytearr_free(&oldcurpos);
+
+    _isam_exithook();
+    return (ret);
+
+ ERROR:
+
+    *reclen = 0;
+
+    _isdisk_inval();
+
+    _bytearr_free(&oldcurpos);
+
+    /*
+     * If error is ENOREC,  set the current record position undefined.
+     */
+    if (errcode->iserrno == ENOREC || errcode->iserrno == EENDFILE) {
+	((Crp *)curpos->data)->flag = CRP_UNDEF;
+    }
+
+    if (btree != NULL)
+	_isbtree_destroy(btree);
+
+    _isam_exithook();
+    return (ISERROR);
+}
+
+