freem/src/global_bltin.c - diff

Return to global_bltin.c CVS log

Up to [Coherent Logic Development] / freem / src

Diff for /freem/src/global_bltin.c between versions 1.8 and 1.9

version 1.8, 2025/04/08 14:39:21	version 1.9, 2025/04/08 16:46:11
Line 24	Line 24
* along with FreeM. If not, see <https://www.gnu.org/licenses/>.	* along with FreeM. If not, see <https://www.gnu.org/licenses/>.
*	*
* $Log$	* $Log$
	* Revision 1.9 2025/04/08 16:46:11 snw
	* Add global file header and offsets
	*
* Revision 1.8 2025/04/08 14:39:21 snw	* Revision 1.8 2025/04/08 14:39:21 snw
* Initial work on global handler refactor	* Initial work on global handler refactor
*	*
Line 197 nextpath:	Line 200 nextpath:
buf[k] = NUL; /* NUL not EOL !!! */	buf[k] = NUL; /* NUL not EOL !!! */

return i;	return i;
} /* global_file */	} /* gbl_path() */

int gbl_lock(global_handle *g, int type)	int gbl_lock(global_handle *g, int type)
{	{
Line 207 int gbl_lock(global_handle *g, int type)	Line 210 int gbl_lock(global_handle *g, int type)

locking (g->fd, type, 0L);	locking (g->fd, type, 0L);
g->locked = TRUE;	g->locked = TRUE;
}	} /* gbl_lock() */

int gbl_unlock(global_handle *g)	int gbl_unlock(global_handle *g)
{	{
Line 217 int gbl_unlock(global_handle *g)	Line 220 int gbl_unlock(global_handle *g)

locking (g->fd, 0, 0L);	locking (g->fd, 0, 0L);
g->locked = FALSE;	g->locked = FALSE;
}	} /* gbl_unlock() */

void gbl_close(global_handle *g)	void gbl_close(global_handle *g)
{	{
Line 230 void gbl_close(global_handle *g)	Line 233 void gbl_close(global_handle *g)
g->locked = FALSE;	g->locked = FALSE;
g->opened = FALSE;	g->opened = FALSE;
}	}
}	} /* gbl_close() */

void gbl_close_all(void)	void gbl_close_all(void)
{	{
Line 239 void gbl_close_all(void)	Line 242 void gbl_close_all(void)
for (g = global_handles_head; g != NULL; g = g->next) {	for (g = global_handles_head; g != NULL; g = g->next) {
gbl_close (g);	gbl_close (g);
}	}
}	} /* gbl_close_all() */

	int gbl_write_header(global_handle *g)
	{
	global_header hdr;
	unsigned long old_position;
	char m[5] = GBL_MAGIC;
	char msg[256];

	if (g->opened == FALSE) {
	return FALSE;
	}

	memcpy (hdr.magic, m, 5);
	hdr.format_version = GBL_FORMAT_VERSION;
	strncpy (hdr.host_triplet, HOST, 40);
	hdr.block_size = BLOCKLEN;
	hdr.last_transaction_id = 0;
	hdr.created = time (0L);
	hdr.last_backup = -1;

	gbl_lock (g, 1);
	old_position = lseek (g->fd, 0, SEEK_CUR);
	lseek (g->fd, 0, SEEK_SET);

	if (write (g->fd, &hdr, sizeof (global_header)) == -1) {
	snprintf (msg, 256, "error %d writing global header for %s", errno, g->global_name);
	m_fatal (msg);
	}

	lseek (g->fd, old_position, SEEK_SET);
	gbl_unlock (g);

	return TRUE;
	} /* gbl_write_header() */

int gbl_create(global_handle *g)	int gbl_create(global_handle *g)
{	{
Line 260 int gbl_create(global_handle *g)	Line 297 int gbl_create(global_handle *g)
g->age = time (0L);	g->age = time (0L);
g->last_block = 0;	g->last_block = 0;
g->use_count = 1;	g->use_count = 1;

	gbl_write_header (g);

return OK;	return OK;
}	} /* gbl_create() */

short gbl_open(global_handle *g, short action)	short gbl_open(global_handle *g, short action)
{	{
Line 300 short gbl_open(global_handle *g, short a	Line 339 short gbl_open(global_handle *g, short a

return g->opened;	return g->opened;

} /* gbl_open */	} /* gbl_open() */

global_handle gbl_handle(char key)	global_handle gbl_handle(char key)
{	{
Line 357 global_handle gbl_handle(char key)	Line 396 global_handle gbl_handle(char key)
global_handles_head = g;	global_handles_head = g;

return g;	return g;
}	} /* gbl_handle() */


/* globals management */	/* globals management */
Line 439 void global_bltin (short action, char *k	Line 478 void global_bltin (short action, char *k
{	{

global_handle *g;	global_handle *g;

	unsigned long hdr_offset;

/* these must be static variables */	/* these must be static variables */

static short filedes; /* filedescr for global access */	static short filedes; /* filedescr for global access */
static char filnam[256]; /* name of global/unix file */	static char filnam[256]; /* name of global/unix file */

/* the following vars may be */	/* the following vars may be */
/* static or dynamic */	/* static or dynamic */

static unsigned long blknbr; /* block number */	static unsigned long blknbr; /* block number */
// static unsigned long oldblk;
static unsigned long newblk;	static unsigned long newblk;
static unsigned long other;	static unsigned long other;
static long j1;	static long j1;
static long limit;	static long limit;
static short typ; /* block type */	static short typ; /* block type */
static long keyl, /* length of compacted key */	static long keyl; /* length of compacted key */
datal, /* length of data */	static long datal; /* length of data */
olddatal,	static long olddatal;
offset,	static long offset;
found,	static long found;
addr, /* address of key in 'block' */	static long addr; /* address of key in 'block' */
needed, /* new bytes needed to ins. stuff */	static long needed; /* new bytes needed to ins. stuff */
ret_to, /* return code */	static long ret_to; /* return code */
kill_again;	static long kill_again;
static char key1[256];	static char key1[256];
static char tmp1[256]; /* intermediate storage for op= */	static char tmp1[256]; /* intermediate storage for op= */
static char block[BLOCKLEN];	static char block[BLOCKLEN];
Line 475 void global_bltin (short action, char *k	Line 513 void global_bltin (short action, char *k

struct stat dinf; /* get modification date */	struct stat dinf; /* get modification date */

long savj,	long savj;
savch; /* saved j and ch for multiple pathes */	long savch; /* saved j and ch for multiple pathes */
register long int i,	register long int i;
j,	register long int j;
k,	register long int k;
ch;	register long int ch;
long pathscan; /* flag for repeated scan of pathlist setting an undef global */	long pathscan; /* flag for repeated scan of pathlist setting an undef global */

	hdr_offset = sizeof (global_header);

/* process optional limitations */	/* process optional limitations */
if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {	if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {

Line 561 void global_bltin (short action, char *k	Line 601 void global_bltin (short action, char *k


if (action == getnext) {	if (action == getnext) {

getnflag = TRUE;	getnflag = TRUE;
varnam[0] = EOL;	varnam[0] = EOL;

Line 851 reopen:	Line 890 reopen:

errno = 0;	errno = 0;

lseek (g->fd, ROOT * BLOCKLEN, 0);	lseek (g->fd, hdr_offset + (ROOT * BLOCKLEN), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);

if (errno == 0) break;	if (errno == 0) break;
Line 877 reopen:	Line 916 reopen:

if (errno == 0) break;	if (errno == 0) break;

lseek (g->fd, (ROOT + 1L) * BLOCKLEN, 0);	lseek (g->fd, hdr_offset + ((ROOT + 1L) * BLOCKLEN), SEEK_SET);
panic ();	panic ();

}	}
Line 909 tfast0:	Line 948 tfast0:

tfast1:	tfast1:

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);


Line 1031 tfast2:	Line 1070 tfast2:
/* a KILL on an unsubscripted global deletes the entire file */	/* a KILL on an unsubscripted global deletes the entire file */
if (action == kill_sym && compactkey[0] == g_EOL) {	if (action == kill_sym && compactkey[0] == g_EOL) {

lseek (g->fd, ROOT, 0);	lseek (g->fd, hdr_offset + ROOT, SEEK_SET);

/* note : UNIX does not tell other */	/* note : UNIX does not tell other */
block[BTYP] = EMPTY; /* jobs that a file has been unlinked */	block[BTYP] = EMPTY; /* jobs that a file has been unlinked */
Line 1064 k_again: /* entry point for repeated	Line 1103 k_again: /* entry point for repeated
traceblk[trx] = blknbr;	traceblk[trx] = blknbr;
traceadr[trx] = 0;	traceadr[trx] = 0;

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

typ = block[BTYP];	typ = block[BTYP];
Line 1232 s10: {	Line 1271 s10: {

}	}

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);

if (traceadr[trx] == 0) update (g->fd, compactkey, keyl);	if (traceadr[trx] == 0) update (g->fd, compactkey, keyl);
Line 1319 s20:	Line 1358 s20:
}	}

stcpy0 (&block[++addr], data, (long) datal);	stcpy0 (&block[++addr], data, (long) datal);
lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);
break;	break;

Line 1351 s20:	Line 1390 s20:

if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) {	if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) {

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);
j1 = UNSIGN (block[0]);	j1 = UNSIGN (block[0]);

Line 1434 s20:	Line 1473 s20:
goto quit;	goto quit;
} /* no next block */	} /* no next block */

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);
scandblk (block, &addr, &found);	scandblk (block, &addr, &found);

Line 1591 s20:	Line 1630 s20:
goto quit; /* no next block */	goto quit; /* no next block */
}	}

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

addr = 0;	addr = 0;
Line 1615 s20:	Line 1654 s20:
goto quit; /* no next block */	goto quit; /* no next block */
}	}

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

addr = 0;	addr = 0;
Line 1826 killo: /* entry from killone section	Line 1865 killo: /* entry from killone section
other = traceblk[--trx];	other = traceblk[--trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
Line 1846 killo: /* entry from killone section	Line 1885 killo: /* entry from killone section

trx = trxsav;	trx = trxsav;

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
Line 1953 p_empty: /* entry if pointer block goes	Line 1992 p_empty: /* entry if pointer block goes

if (left) {	if (left) {

lseek (g->fd, (long) left * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block0, BLOCKLEN);	read (g->fd, block0, BLOCKLEN);

block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
block0[RLPTR + 2] = block[RLPTR + 2];	block0[RLPTR + 2] = block[RLPTR + 2];

lseek (g->fd, (long) left * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block0, BLOCKLEN);	write (g->fd, block0, BLOCKLEN);

}	}

if (right) {	if (right) {

lseek (g->fd, (long) right * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block0, BLOCKLEN);	read (g->fd, block0, BLOCKLEN);

block0[LLPTR] = block[LLPTR];	block0[LLPTR] = block[LLPTR];
block0[LLPTR + 1] = block[LLPTR + 1];	block0[LLPTR + 1] = block[LLPTR + 1];
block0[LLPTR + 2] = block[LLPTR + 2];	block0[LLPTR + 2] = block[LLPTR + 2];

lseek (g->fd, (long) right * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block0, BLOCKLEN);	write (g->fd, block0, BLOCKLEN);

}	}
Line 1992 p_empty: /* entry if pointer block goes	Line 2031 p_empty: /* entry if pointer block goes
blknbr = traceblk[--trx];	blknbr = traceblk[--trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (g->fd, (long) (blknbr) * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
Line 2005 p_empty: /* entry if pointer block goes	Line 2044 p_empty: /* entry if pointer block goes

if (blknbr == ROOT) { /* global went empty */	if (blknbr == ROOT) { /* global went empty */

lseek (g->fd, 0L, 0);	lseek (g->fd, hdr_offset + 0L, SEEK_SET);

/* note : UNIX does not tell other */	/* note : UNIX does not tell other */
block[BTYP] = EMPTY; /* jobs that a file has been unlinked */	block[BTYP] = EMPTY; /* jobs that a file has been unlinked */
Line 2037 p_empty: /* entry if pointer block goes	Line 2076 p_empty: /* entry if pointer block goes

for (i = offset; i < offset + freecnt; block[i++] = 0);	for (i = offset; i < offset + freecnt; block[i++] = 0);

lseek (g->fd, (long) (blknbr) * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);

if (addr == 0) { /* update of pointer */	if (addr == 0) { /* update of pointer */
Line 2085 p_empty: /* entry if pointer block goes	Line 2124 p_empty: /* entry if pointer block goes
}	}
block[OFFS] = offset / 256;	block[OFFS] = offset / 256;
block[OFFS + 1] = offset % 256;	block[OFFS + 1] = offset % 256;
lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);
if (addr < 3) { /* update of pointer */	if (addr < 3) { /* update of pointer */
traceadr[trx] = 0;	traceadr[trx] = 0;
Line 2112 zinv:	Line 2151 zinv:
goto quit;	goto quit;
} /* no previous block */	} /* no previous block */

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

addr = UNSIGN (block[OFFS]) * 256 +	addr = UNSIGN (block[OFFS]) * 256 +
Line 2292 zinv:	Line 2331 zinv:
break; /* no next block */	break; /* no next block */
}	}

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block, BLOCKLEN);	read (g->fd, block, BLOCKLEN);

addr = 0;	addr = 0;
Line 2408 quit:	Line 2447 quit:

/* clean things up */	/* clean things up */

lseek (g->fd, ROOT, 0);	lseek (g->fd, hdr_offset + ROOT, SEEK_SET);
gbl_unlock (g);	gbl_unlock (g);

return;	return;
Line 2439 splitd: /* split data block in two se	Line 2478 splitd: /* split data block in two se
block[RLPTR + 1] = newblk % 65536 / 256;	block[RLPTR + 1] = newblk % 65536 / 256;
block[RLPTR + 2] = newblk % 256;	block[RLPTR + 2] = newblk % 256;

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);

block[RLPTR] = right;	block[RLPTR] = right;
Line 2459 splitd: /* split data block in two se	Line 2498 splitd: /* split data block in two se

char block0[BLOCKLEN];	char block0[BLOCKLEN];

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block0, BLOCKLEN);	read (g->fd, block0, BLOCKLEN);

block0[LLPTR] = blknbr / 65536;	block0[LLPTR] = blknbr / 65536;
block0[LLPTR + 1] = blknbr % 65536 / 256;	block0[LLPTR + 1] = blknbr % 65536 / 256;
block0[LLPTR + 2] = blknbr % 256;	block0[LLPTR + 2] = blknbr % 256;

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block0, BLOCKLEN);	write (g->fd, block0, BLOCKLEN);

}	}
Line 2485 splitd: /* split data block in two se	Line 2524 splitd: /* split data block in two se
block[LLPTR + 1] = newblk % 65536 / 256;	block[LLPTR + 1] = newblk % 65536 / 256;
block[LLPTR + 2] = newblk % 256;	block[LLPTR + 2] = newblk % 256;

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);

block[LLPTR] = left;	block[LLPTR] = left;
Line 2611 splitd: /* split data block in two se	Line 2650 splitd: /* split data block in two se
block0[LLPTR + 1] = blknbr % 65536 / 256;	block0[LLPTR + 1] = blknbr % 65536 / 256;
block0[LLPTR + 2] = blknbr % 256;	block0[LLPTR + 2] = blknbr % 256;

lseek (g->fd, (long) (newblk) * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block0, BLOCKLEN);	write (g->fd, block0, BLOCKLEN);

offset = limit;	offset = limit;
Line 2622 splitd: /* split data block in two se	Line 2661 splitd: /* split data block in two se
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block0, BLOCKLEN);	read (g->fd, block0, BLOCKLEN);

block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block0, BLOCKLEN);	write (g->fd, block0, BLOCKLEN);

}	}
Line 2651 splitd: /* split data block in two se	Line 2690 splitd: /* split data block in two se
block0[LLPTR + 1] = blknbr % 65536 / 256;	block0[LLPTR + 1] = blknbr % 65536 / 256;
block0[LLPTR + 2] = blknbr % 256;	block0[LLPTR + 2] = blknbr % 256;

lseek (g->fd, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	write (g->fd, block, BLOCKLEN);
stcpy0 (block, block0, (long) BLOCKLEN);	stcpy0 (block, block0, (long) BLOCKLEN);

Line 2664 splitd: /* split data block in two se	Line 2703 splitd: /* split data block in two se
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
read (g->fd, block0, BLOCKLEN);	read (g->fd, block0, BLOCKLEN);

block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (g->fd, (long) other * (long) (BLOCKLEN), 0);	lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block0, BLOCKLEN);	write (g->fd, block0, BLOCKLEN);

}	}
Line 2708 static void splitp (short filedes, char	Line 2747 static void splitp (short filedes, char
unsigned long other;	unsigned long other;
register int i, j;	register int i, j;

	long hdr_offset;

	hdr_offset = sizeof (global_header);

getnewblk (filedes, &newblk); /* get a new block */	getnewblk (filedes, &newblk); /* get a new block */

if (blknbr == ROOT) { / ROOT overflow is special */	if (blknbr == ROOT) { / ROOT overflow is special */
Line 2743 static void splitp (short filedes, char	Line 2786 static void splitp (short filedes, char
block0[NRBLK + 2] = i % 256;	block0[NRBLK + 2] = i % 256;
block0[BTYP] = POINTER;	block0[BTYP] = POINTER;

lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

/* shift trace_stack */	/* shift trace_stack */
Line 2815 static void splitp (short filedes, char	Line 2858 static void splitp (short filedes, char
block0[LLPTR + 1] = (*blknbr) % 65536 / 256;	block0[LLPTR + 1] = (*blknbr) % 65536 / 256;
block0[LLPTR + 2] = (*blknbr) % 256;	block0[LLPTR + 2] = (*blknbr) % 256;

lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

(*offs) = limit;	(*offs) = limit;
Line 2825 static void splitp (short filedes, char	Line 2868 static void splitp (short filedes, char
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (filedes, (long) other * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
read (filedes, block0, BLOCKLEN);	read (filedes, block0, BLOCKLEN);

block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (filedes, (long) other * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

}	}
Line 2858 static void splitp (short filedes, char	Line 2901 static void splitp (short filedes, char
(*addr) -= limit;	(*addr) -= limit;
(*offs) -= limit;	(*offs) -= limit;

lseek (filedes, (long) (blknbr) (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) (blknbr) (long) (BLOCKLEN)), SEEK_SET);
write (filedes, block, BLOCKLEN);	write (filedes, block, BLOCKLEN);
stcpy0 (block, block0, (long) BLOCKLEN);	stcpy0 (block, block0, (long) BLOCKLEN);

Line 2869 static void splitp (short filedes, char	Line 2912 static void splitp (short filedes, char
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (filedes, (long) other * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
read (filedes, block0, BLOCKLEN);	read (filedes, block0, BLOCKLEN);

block0[LLPTR] = newblk / 65536;	block0[LLPTR] = newblk / 65536;
block0[LLPTR + 1] = newblk % 65536 / 256;	block0[LLPTR + 1] = newblk % 65536 / 256;
block0[LLPTR + 2] = newblk % 256;	block0[LLPTR + 2] = newblk % 256;

lseek (filedes, (long) other * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

}	}
Line 2899 static void update (short filedes, char	Line 2942 static void update (short filedes, char
unsigned long blknbr;	unsigned long blknbr;
char block[BLOCKLEN];	char block[BLOCKLEN];
long i, j, k;	long i, j, k;
	long hdr_offset;

	hdr_offset = sizeof (global_header);

while (traceadr[trx] == 0) { /* update of pointer blocks necessary */	while (traceadr[trx] == 0) { /* update of pointer blocks necessary */

if (--trx < 0) break;	if (--trx < 0) break;
Line 2907 static void update (short filedes, char	Line 2953 static void update (short filedes, char
blknbr = traceblk[trx];	blknbr = traceblk[trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (filedes, block, BLOCKLEN);	read (filedes, block, BLOCKLEN);

{	{
Line 2958 static void update (short filedes, char	Line 3004 static void update (short filedes, char
while (i < keyl) block[j++] = ins_key[i++];	while (i < keyl) block[j++] = ins_key[i++];

/* block pointed to remains the same */	/* block pointed to remains the same */
lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (filedes, block, BLOCKLEN);	write (filedes, block, BLOCKLEN);

}	}

lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
read (filedes, block, BLOCKLEN);	read (filedes, block, BLOCKLEN);

}	}
Line 2988 static void insert (int filedes, char *i	Line 3034 static void insert (int filedes, char *i
long needed;	long needed;
long addr;	long addr;
register int i, k;	register int i, k;
	long hdr_offset;

	hdr_offset = sizeof (global_header);

trxsav = trx--;	trxsav = trx--;
blk = traceblk[trx];	blk = traceblk[trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET);
read (filedes, block, BLOCKLEN);	read (filedes, block, BLOCKLEN);

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
Line 3030 static void insert (int filedes, char *i	Line 3079 static void insert (int filedes, char *i
block[i++] = blknbr % 65536 / 256;	block[i++] = blknbr % 65536 / 256;
block[i] = blknbr % 256;	block[i] = blknbr % 256;

lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);	lseek (filedes, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET);
write (filedes, block, BLOCKLEN);	write (filedes, block, BLOCKLEN);

trx = trxsav;	trx = trxsav;
Line 3050 static void b_free (short filedes, unsig	Line 3099 static void b_free (short filedes, unsig
unsigned long other;	unsigned long other;
long i;	long i;
long offset;	long offset;
	long hdr_offset;

	hdr_offset = sizeof (global_header);

/* mark block as empty */	/* mark block as empty */
lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET);
read (filedes, block0, BLOCKLEN);	read (filedes, block0, BLOCKLEN);

block0[BTYP] = EMPTY;	block0[BTYP] = EMPTY;

lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

/* do we have a list of free blocks? */	/* do we have a list of free blocks? */
lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
read (filedes, block0, BLOCKLEN);	read (filedes, block0, BLOCKLEN);

if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {	if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {

for (;;) {	for (;;) {

lseek (filedes, (long) free * (long) BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);
read (filedes, block0, BLOCKLEN);	read (filedes, block0, BLOCKLEN);

other = UNSIGN (block0[RLPTR]) * 65536 +	other = UNSIGN (block0[RLPTR]) * 65536 +
Line 3101 static void b_free (short filedes, unsig	Line 3153 static void b_free (short filedes, unsig
block0[RLPTR + 1] = other % 65536 / 256;	block0[RLPTR + 1] = other % 65536 / 256;
block0[RLPTR + 2] = other % 256;	block0[RLPTR + 2] = other % 256;

lseek (filedes, (long) free * (long) BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */	for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */
Line 3122 static void b_free (short filedes, unsig	Line 3174 static void b_free (short filedes, unsig
getnewblk (filedes, &free);	getnewblk (filedes, &free);

/* set FBLK free blocks pointer */	/* set FBLK free blocks pointer */
lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
read (filedes, block0, BLOCKLEN);	read (filedes, block0, BLOCKLEN);

block0[FREE] = free / 65536;	block0[FREE] = free / 65536;
block0[FREE + 1] = free % 65536 / 256;	block0[FREE + 1] = free % 65536 / 256;
block0[FREE + 2] = free % 256;	block0[FREE + 2] = free % 256;

lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */	for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */
Line 3145 static void b_free (short filedes, unsig	Line 3197 static void b_free (short filedes, unsig
block0[OFFS] = offset / 256;	block0[OFFS] = offset / 256;
block0[OFFS + 1] = offset % 256;	block0[OFFS + 1] = offset % 256;

lseek (filedes, (long) free * (long) BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);
write (filedes, block0, BLOCKLEN);	write (filedes, block0, BLOCKLEN);

return;	return;
Line 3272 static void getnewblk (int filedes, unsi	Line 3324 static void getnewblk (int filedes, unsi
unsigned long freeblks, no_of_blks;	unsigned long freeblks, no_of_blks;
long other;	long other;
long offset;	long offset;
	long hdr_offset;

lseek (filedes, ROOT, 0);	hdr_offset = sizeof (global_header);

	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
read (filedes, nblock, BLOCKLEN);	read (filedes, nblock, BLOCKLEN);

freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]);	freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]);
Line 3281 static void getnewblk (int filedes, unsi	Line 3336 static void getnewblk (int filedes, unsi

if (freeblks) {	if (freeblks) {

lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (freeblks) * BLOCKLEN), SEEK_SET);
read (filedes, nblock, BLOCKLEN);	read (filedes, nblock, BLOCKLEN);

offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);	offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);
Line 3294 static void getnewblk (int filedes, unsi	Line 3349 static void getnewblk (int filedes, unsi
/* update RL-block, if any */	/* update RL-block, if any */
if (other) {	if (other) {

lseek (filedes, (long) (other) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET);
read (filedes, nblock, BLOCKLEN);	read (filedes, nblock, BLOCKLEN);

nblock[LLPTR] = 0;	nblock[LLPTR] = 0;
nblock[LLPTR + 1] = 0;	nblock[LLPTR + 1] = 0;
nblock[LLPTR + 2] = 0;	nblock[LLPTR + 2] = 0;

lseek (filedes, (long) (other) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET);
write (filedes, nblock, BLOCKLEN);	write (filedes, nblock, BLOCKLEN);

}	}

/* update ROOT block */	/* update ROOT block */
lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
read (filedes, nblock, BLOCKLEN);	read (filedes, nblock, BLOCKLEN);

nblock[FREE] = other / 65536;	nblock[FREE] = other / 65536;
nblock[FREE + 1] = other % 65536 / 256;	nblock[FREE + 1] = other % 65536 / 256;
nblock[FREE + 2] = other % 256;	nblock[FREE + 2] = other % 256;

lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
write (filedes, nblock, BLOCKLEN);	write (filedes, nblock, BLOCKLEN);

return;	return;
Line 3328 static void getnewblk (int filedes, unsi	Line 3383 static void getnewblk (int filedes, unsi
nblock[OFFS] = offset / 256;	nblock[OFFS] = offset / 256;
nblock[OFFS + 1] = offset % 256;	nblock[OFFS + 1] = offset % 256;

lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (freeblks) * BLOCKLEN), SEEK_SET);
write (filedes, nblock, BLOCKLEN);	write (filedes, nblock, BLOCKLEN);

return;	return;
Line 3341 static void getnewblk (int filedes, unsi	Line 3396 static void getnewblk (int filedes, unsi
nblock[NRBLK + 1] = no_of_blks % 65536 / 256;	nblock[NRBLK + 1] = no_of_blks % 65536 / 256;
nblock[NRBLK + 2] = no_of_blks % 256;	nblock[NRBLK + 2] = no_of_blks % 256;

lseek (filedes, ROOT, 0);	lseek (filedes, hdr_offset + ROOT, SEEK_SET);
write (filedes, nblock, BLOCKLEN);	write (filedes, nblock, BLOCKLEN);

*blknbr = no_of_blks;	*blknbr = no_of_blks;
Line 3350 static void getnewblk (int filedes, unsi	Line 3405 static void getnewblk (int filedes, unsi

errno = 0;	errno = 0;

lseek (filedes, (long) (no_of_blks) * BLOCKLEN, 0);	lseek (filedes, hdr_offset + ((long) (no_of_blks) * BLOCKLEN), SEEK_SET);
write (filedes, nblock, BLOCKLEN);	write (filedes, nblock, BLOCKLEN);

if (errno == 0) break;	if (errno == 0) break;

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.8
changed lines
	Added in v.1.9