isaddindex(int isfd, struct keydesc *keydesc)
{
int _amaddindex();
- register Fab *fab;
+ Fab *fab;
int ret;
/*
int
isaddprimary(int isfd, struct keydesc *keydesc)
{
- register Fab *fab;
+ Fab *fab;
int ret;
/*
return (ret); /* Successful write */
}
-Static int _am_addprimary(register Fab *fab, struct keydesc *keydesc)
+Static int _am_addprimary(Fab *fab, struct keydesc *keydesc)
{
return (_amaddprimary(&fab->isfhandle, keydesc, &fab->errcode));
}
char *_ismalloc(unsigned int nbytes)
{
- register char *p;
+ char *p;
if ((p = (char *) malloc (nbytes)) == NULL)
_isfatal_error("malloc() failed");
char *_isrealloc(char *oldaddr, unsigned int nbytes)
{
- register char *p;
+ char *p;
if ((p = (char *) realloc (oldaddr, nbytes)) == NULL)
_isfatal_error("realloc() failed");
char *
_isallocstring(char *str)
{
- register char *p;
+ char *p;
if ((p = strdup(str)) == NULL)
_isfatal_error("strdup() failed");
*/
void
-_delkeys(register Fcb *fcb, char *record, Recno recnum)
+_delkeys(Fcb *fcb, char *record, Recno recnum)
{
int nkeys = fcb->nkeys;
- register int i;
+ int i;
for (i = 0; i < nkeys; i++) {
_del1key(fcb, fcb->keys + i, record, recnum);
void
_amseterrcode(struct errcode *errcode, int is_errno)
{
- register struct errstattab *p;
+ struct errstattab *p;
errcode->iserrno = is_errno;
/*
* Returns ISOK, or EDUPS.
*/
-int _addkeys (register Fcb *fcb, char *record, Recno recnum)
+int _addkeys (Fcb *fcb, char *record, Recno recnum)
{
int nkeys = fcb->nkeys;
- register int i;
+ int i;
int err;
for (i = 0; i < nkeys; i++) {
_addkeys2 (Fcb *fcb, char *record, Recno recnum, Bytearray *curpos)
{
int nkeys = fcb->nkeys;
- register int i;
+ int i;
int err;
Crp *crp;
int keyid;
int
_isapplmr(int isfd, char *buffer)
{
- register Fab *fab;
+ Fab *fab;
Fcb *fcb = NULL;
char cntl_page[CP_NKEYS_OFF];
int
_isapplmw(int isfd, char *magicstring)
{
- register Fab *fab;
+ Fab *fab;
int ret;
Fcb *fcb;
char cntl_page[CP_NKEYS_OFF];
char *_isbsearch (char *key, char *table, int nelems, int keylen, int (*cmpf) ())
{
- register int len,l1,result; /* current length of array to search */
- register char *p,*low;
+ int len,l1,result; /* current length of array to search */
+ char *p,*low;
if (nelems <= 0) return (char *) 0;
Btree *
_isbtree_create(Fcb *fcb, Keydesc2 *pkeydesc2)
{
- register Btree *p;
+ Btree *p;
p = (Btree *) _ismalloc(sizeof(*p));
memset((char *)p, 0, sizeof(*p));
*/
void
-_isbtree_destroy(register Btree *btree)
+_isbtree_destroy(Btree *btree)
{
- register int i;
+ int i;
for (i = 0; i < btree->depth;i++) {
_isdisk_unfix(btree->bufhdr[i]);
*/
void
-_isbtree_search( register Btree *btree, char *key)
+_isbtree_search( Btree *btree, char *key)
{
Keydesc2 *pkeydesc2 = btree->keydesc2;
Blkno rootblkno = pkeydesc2->k2_rootnode;
int index; /* Index to tables in btree */
/* Has value of 1, next 2, etc. */
int elevation; /* Level - leaves have value 0 */
- register char *p; /* Pointer to key page */
+ char *p; /* Pointer to key page */
int nkeys; /* Number of keys in the page */
char *key2; /* Equal or next lower key */
int curpos; /* index of key2 in key page */
*/
char *
-_isbtree_current(register Btree *btree)
+_isbtree_current(Btree *btree)
{
int curpos;
*/
char *
-_isbtree_next(register Btree *btree)
+_isbtree_next(Btree *btree)
{
int curpos;
int depth = btree->depth;
- register char *p;
- register int level;
+ char *p;
+ int level;
Blkno blkno;
assert(depth > 0);
int nkeys; /* Number of keys in the page */
int capac;
char keybuf[MAXKEYSIZE];
- register int i;
+ int i;
Blkno blkno;
char *pkp, *pkp2, *pkp3;
Bufhdr *kp2bhdr, *kp3bhdr;
{
struct keydesc2 *pkeydesc2 = btree->keydesc2;
int nkeys; /* Number of keys in the page */
- register int i;
+ int i;
char *pkp, *pkp2, *pkp3;
struct bufhdr *kp2bhdr;
Blkno blkno2;
*/
void
-_bytearr_free(register Bytearray *barray)
+_bytearr_free(Bytearray *barray)
{
if (barray->data)
free(barray->data);
*/
int
-_bytearr_cmp(register Bytearray *l, register Bytearray *r)
+_bytearr_cmp(Bytearray *l, Bytearray *r)
{
if (l->length == r->length)
return (memcmp(l->data, r->data, (int)l->length));
/* ldlong() - Load a long integer from a potentially unaligned address */
long
-ldlong(register char *p)
+ldlong(char *p)
{
int i;
#if LONG_BIT == 64
- register unsigned long val;
+ unsigned long val;
#else
- register unsigned int val;
+ unsigned int val;
#endif
val = 0;
/* stlong() - Store a long integer at a potentially unaligned address */
int
-stlong(register long val, register char *p)
+stlong(long val, char *p)
{
int i;
p += LONGSIZE;
/* ldint() - Load a short integer from a potentially unaligned address */
short
-ldint(register char *p)
+ldint(char *p)
{
- register unsigned int val;
+ unsigned int val;
val = *((unsigned char *)p++);
val = (val << 8) + *((unsigned char *)p++);
/* ldunshort - load a unshort integer : for 64K record length */
u_short
-ldunshort(register char *p)
+ldunshort(char *p)
{
- register unsigned int val;
+ unsigned int val;
val = *((unsigned char *)p++);
val = (val << 8) + *((unsigned char *)p++);
/* stint() - Store a short integer at a potentially unaligned address */
int
-stint(register short val, register char *p)
+stint(short val, char *p)
{
p += SHORTSIZE;
*--p = val & 255;
/* ldchar() - Load character field */
int
-ldchar(char *src, int len, register char *dst)
+ldchar(char *src, int len, char *dst)
{
- register char *p;
+ char *p;
if (len <= 0)
return 0;
}
int
-stchar(register char *src, register char *dst, register int len)
+stchar(char *src, char *dst, int len)
{
- register char c;
+ char c;
if (len <= 0)
return 0;
/* ldchar2() - Load character field (C style, NULL padded) */
int
-ldchar2(char *src, int len, register char *dst)
+ldchar2(char *src, int len, char *dst)
{
- register char *p;
+ char *p;
if (len <= 0)
return 0;
}
int
-stchar2(register char *src, register char *dst, register int len)
+stchar2(char *src, char *dst, int len)
{
- register char c;
+ char c;
if (len <= 0)
return 0;
/* ldfloat() - Load a float number from a potentially unaligned address */
float
-ldfloat(register char *p)
+ldfloat(char *p)
{
union {
float fval;
int ival;
} uval;
- register unsigned int val;
+ unsigned int val;
val = *((unsigned char *)p++);
val = (val << 8) + *((unsigned char *)p++);
/* f, Bug - it is passed as double */
int
-stfloat(float f, register char *p)
+stfloat(float f, char *p)
{
- register unsigned val;
+ unsigned val;
union {
float fval;
int ival;
/* ldbld() - Load a double float number from a potentially unaligned address */
double
-lddbl(register char *p)
+lddbl(char *p)
{
double val;
/* stdbl() - Store a double float number at a potentially unaligned address */
int
-stdbl(double val, register char *p)
+stdbl(double val, char *p)
{
memcpy ( p,(char *)&val, DOUBLESIZE);
return 0;
/* ldbld() - Load a double float number from a potentially unaligned address */
double
-lddbl(register char *p)
+lddbl(char *p)
{
union {
double rval;
/* stdbl() - Store a double float number at a potentially unaligned address */
int
-stdbl(double val, register char *p)
+stdbl(double val, char *p)
{
union {
double rval;
isdelcurr(int isfd)
{
int _am_delcurr();
- register Fab *fab;
+ Fab *fab;
int ret;
int recnum;
isdelrec(int isfd, long recnum)
{
int _amdelrec();
- register Fab *fab;
+ Fab *fab;
int ret;
/*
Bufhdr *
_isdisk_fix(Fcb *fcb, int unixfd, Blkno blkno, int mode)
{
- register Bufhdr *p, *p2;
+ Bufhdr *p, *p2;
struct dlink *hashl;
/*
}
void
-_isdisk_unfix (register Bufhdr *p)
+_isdisk_unfix (Bufhdr *p)
{
if (!(p->isb_flags & ISB_FIXED))
assert(p->isb_flags & ISB_FIXED);
void
_isdisk_commit(void)
{
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *e;
while ((e = _isdln_first(pfixl)) != pfixl) {
void
_isdisk_rollback(void)
{
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *e;
while ((e = _isdln_first(pfixl)) != pfixl) {
_isdisk_sync(void)
{
extern time_t _istimeget();
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *e;
while ((e = _isdln_first(pchangl)) != pchangl) {
_isdisk_inval(void)
{
extern time_t _istimeget();
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *e;
/* ensure pavail is initialized before using it */
#if ISDEBUG
_isdisk_dumphd(void)
{
- register Bufhdr *p;
+ Bufhdr *p;
int i;
(void)printf("\nInd isfd blkno mode temp oldcopy\n");
aclistdump(struct dlink *lh)
{
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *e;
for (e = _isdln_first(lh); e != lh; e = _isdln_next(e)) {
flistdump(struct dlink *lh)
{
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *e;
for (e = _isdln_first(lh); e != lh; e = _isdln_next(e)) {
_disk_init(void)
{
static Bool initialized = FALSE;
- register int i;
+ int i;
if (initialized == TRUE)
return;
Static Bufhdr *
_getavail(void)
{
- register Bufhdr *p;
- register struct dlink *q;
+ Bufhdr *p;
+ struct dlink *q;
if ((q = _isdln_first(pavail)) == pavail) {
_isfatal_error("No buffer in pool available");
Static Bufhdr *
_findblock(Fcb *fcb, int unixfd, Blkno blkno)
{
- register Bufhdr *p;
+ Bufhdr *p;
struct dlink *lh, *e;
int hashval;
/* _commit1buffer() - Commit changes to buffer */
Static void
-_commit1buffer(register Bufhdr *p)
+_commit1buffer(Bufhdr *p)
{
assert(p->isb_flags & ISB_WFIXED); /* Fixed for read buffers should */
/* go through _isdisk_unfix() */
/* _rollback1buffer() - Rollback changes to buffer */
Static void
-_rollback1buffer(register Bufhdr *p)
+_rollback1buffer(Bufhdr *p)
{
- register Bufhdr *p2;
+ Bufhdr *p2;
assert(p->isb_flags & ISB_WFIXED); /* Fixed for read buffers should */
/* go through _isdisk_unfix() */
/* _makenodata() - make buffer available with no data in it*/
Static void
-_makenodata(register Bufhdr *p)
+_makenodata(Bufhdr *p)
{
assert(p->isb_flags & ISB_READ);
/* _flush1buffer() - flush buffer to disk */
Static void
-_flush1buffer(register Bufhdr *p)
+_flush1buffer(Bufhdr *p)
{
assert(p->isb_flags & ISB_CHANGE);
#include "isam_impl.h"
/* _isdln_base_insert () - Insert element into list (at the front) -----------*/
-void _isdln_base_insert (register char *base, register struct dlink *l,
- register struct dlink *e)
+void _isdln_base_insert (char *base, struct dlink *l,
+ struct dlink *e)
{
e->dln_forward = l->dln_forward;
l->dln_forward = (char *)e - base;
}
/* _isdln_base_append () - Append element to list (at the end) -------------*/
-void _isdln_base_append (register char *base, register struct dlink *l,
- register struct dlink *e)
+void _isdln_base_append (char *base, struct dlink *l,
+ struct dlink *e)
{
e->dln_backward = l->dln_backward;
l->dln_backward = (char *)e - base;
}
/* _isdln_base_remove () - Remove element from list -------------------------*/
-void _isdln_base_remove (register char *base, register struct dlink *e)
+void _isdln_base_remove (char *base, struct dlink *e)
{
((struct dlink *)(base + e->dln_backward))->dln_forward = e->dln_forward;
((struct dlink *)(base + e->dln_forward))->dln_backward = e->dln_backward;
}
/* _isdln_base_first () - Return first element of the list -------------------*/
-struct dlink * _isdln_base_first(register char *base, register struct dlink *l)
+struct dlink * _isdln_base_first(char *base, struct dlink *l)
{
struct dlink *val = (struct dlink *)(base + l->dln_forward);
}
/* _isdln_base_next () - Return next element in the list --------------------*/
-struct dlink * _isdln_base_next(register char *base, register struct dlink *l)
+struct dlink * _isdln_base_next(char *base, struct dlink *l)
{
return (((struct dlink *)(base + l->dln_forward)));
}
/* _isdln_base_prev () - Return previous element in the list ----------------*/
-struct dlink * _isdln_base_prev(register char *base, register struct dlink *l)
+struct dlink * _isdln_base_prev(char *base, struct dlink *l)
{
return (((struct dlink *)(base + l->dln_backward)));
}
/* _isdln_base_makeempty () - Make head of empty list -----------------------*/
-void _isdln_base_makeempty(register char *base, register struct dlink *l)
+void _isdln_base_makeempty(char *base, struct dlink *l)
{
l->dln_forward = l->dln_backward = (char *)l - base;
}
/* _isdln_base_isempty () - Test if list is empty---------------------------*/
-int _isdln_base_isempty(register char *base, register struct dlink *l)
+int _isdln_base_isempty(char *base, struct dlink *l)
{
return (l->dln_forward == (char *)l - base &&
l->dln_backward == (char *)l - base);
Fab *
_fab_new(char *isfname, enum openmode openmode, Bool varlen, int minreclen, int maxreclen)
{
- register Fab *fab;
+ Fab *fab;
/* Allocate memory for the fab object. */
fab = (Fab *) _ismalloc(sizeof(*fab));
}
void
-_fab_destroy(register Fab *fab)
+_fab_destroy(Fab *fab)
{
assert(fab != NULL);
assert(fab->isfname != NULL);
_isfcb_create(char *isfname, int crdat, int crind, int crvar,
int owner, int group, int u_mask, struct errcode *errcode)
{
- register Fcb *fcb;
+ Fcb *fcb;
int dat_fd = -1;
int ind_fd = -1;
int var_fd = -1;
*/
void
-_isfcb_setreclength(register Fcb *fcb, Bool varflag, int minreclen, int maxreclen)
+_isfcb_setreclength(Fcb *fcb, Bool varflag, int minreclen, int maxreclen)
{
fcb->varflag = varflag;
fcb->minreclen = minreclen;
Fcb *
_isfcb_open(char *isfname, struct errcode *errcode)
{
- register Fcb *fcb;
+ Fcb *fcb;
int dat_fd = -1;
int ind_fd = -1;
int var_fd = -1;
*/
int
-_isfcb_nfds(register Fcb *fcb)
+_isfcb_nfds(Fcb *fcb)
{
- register int count = 0;
+ int count = 0;
if (fcb->datfd != -1)
count++;
*/
void
-_isfcb_remove(register Fcb *fcb)
+_isfcb_remove(Fcb *fcb)
{
if (fcb->datfd)
_remove_datfile(fcb->isfname);
*/
void
-_isfcb_close(register Fcb *fcb)
+_isfcb_close(Fcb *fcb)
{
assert (fcb != NULL);
assert (fcb->isfname != NULL);
*/
int
-_isfcb_cntlpg_w(register Fcb *fcb)
+_isfcb_cntlpg_w(Fcb *fcb)
{
char cntl_page[ISCNTLSIZE];
int dat_fd = fcb->datfd;
*/
int
-_isfcb_cntlpg_w2(register Fcb *fcb)
+_isfcb_cntlpg_w2(Fcb *fcb)
{
char cntl_page[CP_VAREND_OFF+CP_VAREND_LEN];
int dat_fd = fcb->datfd;
*/
int
-_isfcb_cntlpg_r(register Fcb *fcb)
+_isfcb_cntlpg_r(Fcb *fcb)
{
char cntl_page[ISCNTLSIZE];
int dat_fd = fcb->datfd;
*/
int
-_isfcb_cntlpg_r2(register Fcb *fcb)
+_isfcb_cntlpg_r2(Fcb *fcb)
{
char cntl_page[CP_VAREND_OFF+CP_VAREND_LEN];
int dat_fd = fcb->datfd;
*/
Keydesc2 *
-_isfcb_findkey(register Fcb *fcb, Keydesc2 *keydesc2)
+_isfcb_findkey(Fcb *fcb, Keydesc2 *keydesc2)
{
int nkeys = fcb->nkeys;
- register Keydesc2 *kp2;
- register int j, i;
+ Keydesc2 *kp2;
+ int j, i;
int nparts;
for (i = 0; i < nkeys; i++) {
*/
int
-_isfcb_altkeydel(register Fcb *fcb, Keydesc2 *keydesc2)
+_isfcb_altkeydel(Fcb *fcb, Keydesc2 *keydesc2)
{
int nkeys = fcb->nkeys;
- register int i, j;
- register Keydesc2 *kp2;
+ int i, j;
+ Keydesc2 *kp2;
int nparts;
for (i = 0; i < nkeys; i++) {
/* compare key parts */
Static int
-_keypart2cmp(register struct keypart2 *l, register struct keypart2 *r)
+_keypart2cmp(struct keypart2 *l, struct keypart2 *r)
{
return !(l->kp2_type == r->kp2_type && l->kp2_start == r->kp2_start &&
l->kp2_leng == r->kp2_leng);
*/
Keydesc2 *
-_isfcb_indfindkey(register Fcb *fcb, int keyid)
+_isfcb_indfindkey(Fcb *fcb, int keyid)
{
int nkeys = fcb->nkeys;
- register Keydesc2 *keys = fcb->keys;
- register int i;
+ Keydesc2 *keys = fcb->keys;
+ int i;
for (i = 0; i < nkeys; i++) {
if (keys[i].k2_keyid == keyid)
Isfd
_isfd_insert(Fab *fab)
{
- register Isfd i;
+ Isfd i;
for (i = 0; i < MAXISFD; i++) {
if (isfdtab[i] == NULL) /* Empty entry found */
*/
Fab *
-_isfd_find(register Isfd isfd)
+_isfd_find(Isfd isfd)
{
if (isfd < 0 || isfd >= MAXISFD || isfdtab[isfd] == NULL)
return (NULL);
*/
void
-_isfd_delete(register Isfd isfd)
+_isfd_delete(Isfd isfd)
{
if (isfd >= 0 && isfd < MAXISFD)
isfdtab[isfd] = NULL;
/*ARGSUSED*/
int
-_flrec_write(register Fcb *fcb, char *record, Recno *recnum, int reclen)
+_flrec_write(Fcb *fcb, char *record, Recno *recnum, int reclen)
{
Recno recnum2;
long rec_position;
*/
int
-_flrec_read(register Fcb *fcb, char *record, Recno recnum, int *reclen)
+_flrec_read(Fcb *fcb, char *record, Recno recnum, int *reclen)
{
long rec_position;
char delflag;
/*ARGSUSED*/
int
-_flrec_rewrite(register Fcb *fcb, char *record, Recno recnum, int reclen)
+_flrec_rewrite(Fcb *fcb, char *record, Recno recnum, int reclen)
{
long rec_position;
char delflag;
*/
int
-_flrec_delete(register Fcb *fcb, Recno recnum)
+_flrec_delete(Fcb *fcb, Recno recnum)
{
long rec_position;
char delflag;
/*ARGSUSED*/
int
-_flrec_wrrec(register Fcb *fcb, char *record, Recno recnum, int reclen)
+_flrec_wrrec(Fcb *fcb, char *record, Recno recnum, int reclen)
{
long rec_position;
char delflag;
void
_removelast(char *path)
{
- register char *p;
+ char *p;
for (p = path + strlen(path); *--p != '/' && p >= path; )
*p = '\0';
stkey(Keydesc2 *pkeydesc2, char *p)
{
int i;
- register struct keypart2 *ppart;
- register char *pp;
+ struct keypart2 *ppart;
+ char *pp;
int nparts;
stshort(pkeydesc2->k2_flags, p + K2_FLAGS_OFF);
}
void
-ldkey(register struct keydesc2 *pkeydesc2, register char *p)
+ldkey(struct keydesc2 *pkeydesc2, char *p)
{
int i;
- register struct keypart2 *ppart;
- register char *pp;
+ struct keypart2 *ppart;
+ char *pp;
int nparts;
memset ((char *) pkeydesc2, 0, sizeof (*pkeydesc2));
int
isindexinfo(int isfd, struct keydesc *buffer, int number)
{
- register Fab *fab;
+ Fab *fab;
int ret;
Fcb *fcb = NULL;
void
_iskey_extract (Keydesc2 *pkeydesc2, char *recp, char *keyp)
{
- register int i;
- register struct keypart2 *ppart;
+ int i;
+ struct keypart2 *ppart;
int nparts;
nparts = pkeydesc2->k2_nparts;
_iskeycmp(char *lkey, char *rkey)
{
int i, ret;
- register struct keypart2 *p;
- register char *l, *r;
- register long llong, rlong;
+ struct keypart2 *p;
+ char *l, *r;
+ long llong, rlong;
double ldouble, rdouble;
ret = 0;
_iskey_itox(struct keydesc2 *pikdesc, struct keydesc *pxkdesc)
{
int nparts;
- register int i;
+ int i;
memset ((char *)pxkdesc, 0, sizeof (*pxkdesc));
_iskey_xtoi(struct keydesc2 *pikdesc, struct keydesc *pxkdesc)
{
int nparts;
- register int i;
+ int i;
int offset; /* Keep track of offset in key */
memset ((char *)pikdesc, 0, sizeof (*pikdesc));
*/
int
-_validate_keydesc(register struct keydesc *keydesc, int minreclen)
+_validate_keydesc(struct keydesc *keydesc, int minreclen)
{
int nparts;
- register int i;
+ int i;
int type, start, length;
int keylen = 0;
*/
void
-_iskey_fillmax(struct keydesc2 *pkeydesc2, register char *keybuf)
+_iskey_fillmax(struct keydesc2 *pkeydesc2, char *keybuf)
{
- register int i;
- register struct keypart2 *ppart;
+ int i;
+ struct keypart2 *ppart;
int nparts;
nparts = pkeydesc2->k2_nparts;
*/
void
-_iskey_fillmin(struct keydesc2 *pkeydesc2, register char *keybuf)
+_iskey_fillmin(struct keydesc2 *pkeydesc2, char *keybuf)
{
- register int i;
- register struct keypart2 *ppart;
+ int i;
+ struct keypart2 *ppart;
int nparts;
nparts = pkeydesc2->k2_nparts;
_mngfcb_insert(Fcb *fcb, Bytearray *isfhandle)
{
int hashval = _hashisfhandle(isfhandle);
- register int ind;
+ int ind;
int ntries;
/* Try to find an unused entry in the hash table. */
_mngfcb_find(Bytearray *isfhandle)
{
int hashval = _hashisfhandle(isfhandle);
- register int ind;
+ int ind;
int ntries;
/* Find the entry. */
_mngfcb_delete(Bytearray *isfhandle)
{
int hashval = _hashisfhandle(isfhandle);
- register int ind;
+ int ind;
int ntries;
/* Find the entry */
{
int victim_ind = -1;
long victim_time = 0; /* Assign to shut up lint */
- register int i;
+ int i;
for (i = 0; i < FCBHASHSIZE; i++) {
Static int
_hashisfhandle(Bytearray *isfhandle)
{
- register char *p;
- register unsigned h, g;
- register int len;
+ char *p;
+ unsigned h, g;
+ int len;
len = isfhandle->length;
p = isfhandle->data;
return ((int)isfd); /* Successful isopen() */
}
-Static int _am_open(register Fab *fab)
+Static int _am_open(Fab *fab)
{
return (_amopen(fab->isfname, fab->openmode, &fab->varlength,
&fab->minreclen, &fab->maxreclen, &fab->isfhandle,
int
isread(int isfd, char *record, int mode)
{
- register Fab *fab;
+ Fab *fab;
int reclen;
Recno recnum;
int ret;
Static void
_removelast2(char *path)
{
- register char *p;
+ char *p;
for (p = path + strlen(path); *--p != '/' && p >= path; )
*p = '\0';
int
isrewcurr(int isfd, char *record)
{
- register Fab *fab;
+ Fab *fab;
int reclen;
int ret;
int recnum;
Recno recnum, Bytearray *curpos)
{
int nkeys = fcb->nkeys;
- register int i;
+ int i;
int err;
Crp *crp;
int keyid;
int
isrewrec(int isfd, long recnum, char *record)
{
- register Fab *fab;
+ Fab *fab;
int reclen;
int ret;
_changekeys (Fcb *fcb, char *record, char *oldrecord, Recno recnum)
{
int nkeys = fcb->nkeys;
- register int i;
+ int i;
int err;
for (i = 0; i < nkeys; i++) {
*/
void
-_issort_insert(register Issort *srt, char *record)
+_issort_insert(Issort *srt, char *record)
{
assert(srt->ist_nrecs < srt->ist_allocrecs);
*/
char *
-_issort_read(register Issort *srt)
+_issort_read(Issort *srt)
{
return((srt->ist_currec < srt->ist_nrecs) ?
(srt->ist_array + srt->ist_currec++ * srt->ist_reclength) :
isstart(int isfd, struct keydesc *keydesc, int length, char *record,
int mode)
{
- register Fab *fab;
+ Fab *fab;
int reclen;
Recno recnum;
int ret;
int _isfsync(int isfd)
{
- register Fab *fab;
+ Fab *fab;
Fcb *fcb;
int ret;
/*ARGSUSED*/
int
-_vlrec_write(register Fcb *fcb, char *record, Recno *recnum, int reclen)
+_vlrec_write(Fcb *fcb, char *record, Recno *recnum, int reclen)
{
Recno recnum2;
long rec_position;
*/
int
-_vlrec_read(register Fcb *fcb, char *record, Recno recnum, int *reclen)
+_vlrec_read(Fcb *fcb, char *record, Recno recnum, int *reclen)
{
long rec_position;
long tailoff;
/*ARGSUSED*/
int
-_vlrec_rewrite(register Fcb *fcb, char *record, Recno recnum, int reclen)
+_vlrec_rewrite(Fcb *fcb, char *record, Recno recnum, int reclen)
{
long rec_position;
long tailoff;
*/
int
-_vlrec_delete(register Fcb *fcb, Recno recnum)
+_vlrec_delete(Fcb *fcb, Recno recnum)
{
long rec_position;
long tailoff;
/*ARGSUSED*/
int
-_vlrec_wrrec(register Fcb *fcb, char *record, Recno recnum, int reclen)
+_vlrec_wrrec(Fcb *fcb, char *record, Recno recnum, int reclen)
{
long rec_position;
long tailoff;
iswrite(int isfd, char *record)
{
int _am_write();
- register Fab *fab;
+ Fab *fab;
int reclen;
Recno recnum;
Bytearray curpos;
}
-Static int _am_write(register Fab *fab, char *record, int reclen,
+Static int _am_write(Fab *fab, char *record, int reclen,
Bytearray *curpos, Recno *recnum)
{
return (_amwrite(&fab->isfhandle, record, reclen,
int
iswrrec(int isfd, long recnum, char *record)
{
- register Fab *fab;
+ Fab *fab;
int reclen;
int ret;
projects / oweals / cde.git / commitdiff