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.11 and 1.23

version 1.11, 2025/04/08 21:41:13	version 1.23, 2025/04/17 14:34:27
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.23 2025/04/17 14:34:27 snw
	* Further logging improvements
	*
	* Revision 1.22 2025/04/13 04:22:43 snw
	* Fix snprintf calls
	*
	* Revision 1.21 2025/04/11 20:55:49 snw
	* Disable -Wunused-result where possible
	*
	* Revision 1.20 2025/04/11 18:24:32 snw
	* Fix bug in memory cache
	*
	* Revision 1.19 2025/04/11 16:52:05 snw
	* Fix indentation in global handler
	*
	* Revision 1.18 2025/04/11 16:23:18 snw
	* Avoid re-reading the same block consecutively when possible
	*
	* Revision 1.17 2025/04/11 14:21:03 snw
	* Make all but one of the read/write calls in global_bltin use gbl_read_block or gbl_write_block
	*
	* Revision 1.16 2025/04/11 00:52:40 snw
	* Replace all lseek/read calls in global handler to use gbl_read_block function
	*
	* Revision 1.15 2025/04/10 01:24:38 snw
	* Remove C++ style comments
	*
	* Revision 1.14 2025/04/09 19:52:02 snw
	* Eliminate as many warnings as possible while building with -Wall
	*
	* Revision 1.13 2025/04/09 14:34:30 snw
	* Further work on global_bltin.c refactor
	*
	* Revision 1.12 2025/04/09 00:43:07 snw
	* Exit with fatal error if a header mismatch found
	*
* Revision 1.11 2025/04/08 21:41:13 snw	* Revision 1.11 2025/04/08 21:41:13 snw
* Make insert, update, and splitp global handler functions take a ptr to a global_handle instead of a file descriptor	* Make insert, update, and splitp global handler functions take a ptr to a global_handle instead of a file descriptor
*	*
Line 64	Line 100
#include "mpsdef.h"	#include "mpsdef.h"
#include "journal.h"	#include "journal.h"
#include "global_bltin.h"	#include "global_bltin.h"
	#include "log.h"

global_handle *global_handles_head;	global_handle *global_handles_head;
	unsigned long gbl_cache_misses = 0;
	unsigned long gbl_cache_hits = 0;

static void b_free (short filedes, unsigned long blknbr);	static void b_free (global_handle *g, unsigned long blknbr);
static void splitp (global_handle g, char block, long addr, long offs, unsigned long *blknbr);	static void splitp (global_handle g, char block, long addr, long offs, unsigned long *blknbr);
static void update (global_handle g, char ins_key, long keyl);	static void update (global_handle g, char ins_key, long keyl);
static void insert (global_handle g, char ins_key, long key_len, unsigned long blknbr);	static void insert (global_handle g, char ins_key, long key_len, unsigned long blknbr);
static void scanpblk (char block, long adr, long *fnd);	static void scanpblk (char block, long adr, long *fnd);
static void scandblk (char block, long adr, long *fnd);	static void scandblk (char block, long adr, long *fnd);
static void getnewblk (int filedes, unsigned long *blknbr);	static void getnewblk (global_handle g, unsigned long blknbr);
static short int g_collate (char *t);	static short int g_collate (char *t);
//static short int g_numeric (char *str);
short g_numeric (char *str);	short g_numeric (char *str);
void close_all_globals(void);	void close_all_globals(void);
static void panic (void);	static void panic (void);

#define ROOT 0L

/* end of line symbol in global module is 30, which is a code not */
/* otherwise used in subscripts */
#define g_EOL 30

#define EOL1 EOL

/* numerics (('.'<<1)&037)==28 ; (('-'<<1)&037)==26; */
#define POINT 28
#define MINUS 26

/* ALPHA and OMEGA are dummy subscripts in $order processing */
/* ALPHA sorts before all other subscripts */
/* OMEGA sorts after all other subscripts */
/* e.g. ("abc") -> "abc",OMEGA ; ("abc","") -> "abc",ALPHA */
#define OMEGA 29
#define ALPHA 31

/* length of blocks. status bytes defined as offset to blocklength */
/* BLOCKLEN 1024 is defined in mpsdef0 include file */
#define DATALIM (BLOCKLEN-11)
#define LLPTR (BLOCKLEN-10)
#define NRBLK LLPTR
#define COLLA (BLOCKLEN- 7)
#define RLPTR (BLOCKLEN- 6)
#define FREE RLPTR
#define BTYP (BLOCKLEN- 3)
#define OFFS (BLOCKLEN- 2)

/* length of blockpointers in bytes */
#define PLEN 3

#define EMPTY 0
#define FBLK 1
#define POINTER 2
#define BOTTOM 6
#define DATA 8

#if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__)	#if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__)
long time ();	long time ();
#endif	#endif

inline long gbl_path(char key, char buf)	inline long gbl_path(char key, char buf)
{	{
long savj;	long savj;
long savch; /* saved j and ch for multiple pathes */

register long int i;	register long int i;
register long int j;	register long int j;
register long int k;	register long int k;
register long int ch;	register long int ch;
long pathscan; /* flag for repeated scan of pathlist setting an undef global */

/* construct full UNIX filename */	/* construct full UNIX filename */
savj = 0;	savj = 0;
savch = ch = EOL;
pathscan = TRUE;
nextpath:
k = 0;	k = 0;
j = savj;	j = savj;

Line 162 nextpath:	Line 156 nextpath:
}	}

}	}

if (savj == 0 && ch == EOL) pathscan = FALSE; /* one path only: inhibit search */

if (k > 0) {	if (k > 0) {

Line 176 nextpath:	Line 168 nextpath:

}	}

savch = ch;
savj = j;	savj = j;
i = 0;	i = 0;
j = 0;	j = 0;
Line 209 nextpath:	Line 200 nextpath:
return i;	return i;
} /* gbl_path() */	} /* gbl_path() */

	void gbl_cache_hit(global_handle *g)
	{
	g->cache_hits++;
	gbl_cache_hits++;
	} /* gbl_cache_hit() */

	void gbl_cache_miss(global_handle *g)
	{
	g->fast_path = 0;
	g->cache_misses++;
	gbl_cache_misses++;
	} /* gbl_cache_miss() */

int gbl_lock(global_handle *g, int type)	int gbl_lock(global_handle *g, int type)
{	{
if (g->locked == TRUE \|\| lonelyflag == TRUE) {	if (g->locked == TRUE \|\| lonelyflag == TRUE) {
Line 217 int gbl_lock(global_handle *g, int type)	Line 221 int gbl_lock(global_handle *g, int type)

locking (g->fd, type, 0L);	locking (g->fd, type, 0L);
g->locked = TRUE;	g->locked = TRUE;

	return TRUE;
} /* gbl_lock() */	} /* gbl_lock() */

int gbl_unlock(global_handle *g)	int gbl_unlock(global_handle *g)
Line 227 int gbl_unlock(global_handle *g)	Line 233 int gbl_unlock(global_handle *g)

locking (g->fd, 0, 0L);	locking (g->fd, 0, 0L);
g->locked = FALSE;	g->locked = FALSE;

	return TRUE;
} /* gbl_unlock() */	} /* gbl_unlock() */

void gbl_close(global_handle *g)	void gbl_close(global_handle *g)
Line 275 int gbl_write_initial_header(global_hand	Line 283 int gbl_write_initial_header(global_hand
lseek (g->fd, 0, SEEK_SET);	lseek (g->fd, 0, SEEK_SET);

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

Line 300 int gbl_write_header(global_handle *g, g	Line 308 int gbl_write_header(global_handle *g, g
lseek (g->fd, 0, SEEK_SET);	lseek (g->fd, 0, SEEK_SET);

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

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

	gbl_read_header (g, &g->header);

return TRUE;	return TRUE;
} /* gbl_write_header() */	} /* gbl_write_header() */
Line 374 int gbl_create(global_handle *g)	Line 384 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;
	g->fast_path = 0;

gbl_write_initial_header (g);	gbl_write_initial_header (g);

return OK;	return OK;
Line 383 int gbl_create(global_handle *g)	Line 394 int gbl_create(global_handle *g)
short gbl_open(global_handle *g, short action)	short gbl_open(global_handle *g, short action)
{	{
int result;	int result;
global_header h;

if (g->opened == FALSE) {	if (g->opened == FALSE) {
	gbl_cache_miss (g);
while (1) {	while (1) {
errno = 0;	errno = 0;
g->fd = open (g->global_path, 2);	g->fd = open (g->global_path, 2);
Line 414 short gbl_open(global_handle *g, short a	Line 425 short gbl_open(global_handle *g, short a
}	}
else {	else {
g->opened = TRUE;	g->opened = TRUE;
result = gbl_read_header (g, &h);	result = gbl_read_header (g, &g->header);

if (result == GBL_HDR_OK) {	if (result == GBL_HDR_OK) {
	/* initialize last_block_accessed cache */
	g->last_block_accessed = (char *) calloc (g->header.block_size, sizeof (char));
	NULLPTRCHK(g->last_block_accessed,"gbl_open");

g->opened = TRUE;	g->opened = TRUE;
}	}
else {	else {
gbl_close (g);	gbl_close (g);
	set_io (UNIX);

	switch (result) {

	case GBL_HDR_BADMAGIC:
	logprintf (FM_LOG_FATAL, "gbl_open: bad magic value in %s", g->global_name);
	break;

	case GBL_HDR_BADVERSION:
	logprintf (FM_LOG_FATAL, "gbl_open: global version is %d in %s (must be %d)", g->header.format_version, g->global_name, GBL_FORMAT_VERSION);
	break;

	}

return FALSE;	return FALSE;
}	}
}	}
Line 430 short gbl_open(global_handle *g, short a	Line 459 short gbl_open(global_handle *g, short a

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

	int gbl_read_block(global_handle g, unsigned long blocknum, char block)
	{
	struct stat gstat;
	unsigned long hdr_offset;
	hdr_offset = sizeof (global_header);

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

	g->use_count++;

	if (!g->locked) gbl_lock (g, 1);
	fstat (g->fd, &gstat);

	if ((g->last_block == blocknum) &&
	(g->have_cached_block) &&
	(g->cached_block_num == blocknum) &&
	(gstat.st_mtime < g->last_read_time)) {
	/* the global has not been modified since the last read; grab from memory */
	g->memory_reads++;
	memcpy (block, g->last_block_accessed, g->header.block_size);
	}
	else {
	/* have to go out to disk */
	lseek (g->fd, hdr_offset + ((long) blocknum * (long) (g->header.block_size)), SEEK_SET);
	read (g->fd, block, g->header.block_size);

	/* update cache */
	memcpy (g->last_block_accessed, block, g->header.block_size);
	g->have_cached_block = TRUE;
	g->cached_block_num = blocknum;
	g->last_block = blocknum;
	g->read_ops++;
	}

	g->last_read_time = time (0L);
	g->use_count++;

	if (g->locked) gbl_unlock (g);

	return TRUE;
	} /* gbl_read_block() */

	int gbl_write_block(global_handle g, unsigned long blocknum, char block)
	{
	int errsav;
	unsigned long hdr_offset;
	hdr_offset = sizeof (global_header);

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

	gbl_lock (g, 1);

	for (;;) {

	errno = 0;

	lseek (g->fd, hdr_offset + (blocknum * g->header.block_size), SEEK_SET);
	write (g->fd, block, g->header.block_size);
	errsav = errno;
	g->last_block = blocknum;
	g->use_count++;
	g->write_ops++;

	if (errsav == 0) break;

	panic ();

	}

	gbl_update_tid (g);
	gbl_unlock (g);

	return TRUE;
	}

global_handle gbl_handle(char key)	global_handle gbl_handle(char key)
{	{
global_handle *g;	global_handle *g;
char global_name[256];	char global_name[256];
int i;	int i;
long path_len;
char block[BLOCKLEN];
struct stat dinf;	struct stat dinf;

i = 0;	i = 0;
Line 473 global_handle gbl_handle(char key)	Line 579 global_handle gbl_handle(char key)
g->use_count = 1;	g->use_count = 1;
g->locked = FALSE;	g->locked = FALSE;
g->age = time (0L);	g->age = time (0L);
	g->last_read_time = 0;
g->last_block = 0;	g->last_block = 0;
g->opened = FALSE;	g->opened = FALSE;
g->fd = 0;	g->fd = 0;
g->fast_path = -1;	g->fast_path = -1;
	g->cache_misses = 0;
	g->cache_hits = 0;
	g->read_ops = 0;
	g->write_ops = 0;
	g->memory_reads = 0;
	g->have_cached_block = FALSE;
	g->last_block_accessed = NULL;

strcpy (g->global_name, global_name);	strcpy (g->global_name, global_name);
gbl_path (key, g->global_path);	gbl_path (key, g->global_path);
Line 571 void global_bltin (short action, char *k	Line 685 void global_bltin (short action, char *k
unsigned long hdr_offset;	unsigned long hdr_offset;

/* these must be static variables */	/* these must be static variables */
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 */
Line 596 void global_bltin (short action, char *k	Line 709 void global_bltin (short action, char *k
static char block[BLOCKLEN];	static char block[BLOCKLEN];
static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */	static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */
static int tryfast; /* try fast access if get_sym on */	static int tryfast; /* try fast access if get_sym on */
/* previous global */	/* previous global */

int iresult;	int iresult;

struct stat dinf; /* get modification date */

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

	j = 0;
hdr_offset = sizeof (global_header);	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') {

if ((i = glvnflag.one[0])) { /* number of significant chars */	if ((i = glvnflag.one[0])) { /* number of significant chars */

j = 0;	j = 0;
while ((k = key[j]) != DELIM && k != EOL) {	while ((k = key[j]) != DELIM && k != EOL) {

if (j >= i) {	if (j >= i) {

while ((k = key[++j]) != DELIM && k != EOL);	while ((k = key[++j]) != DELIM && k != EOL);

stcpy (&key[i], &key[j]);	stcpy (&key[i], &key[j]);

break;	break;
}	}

j++;	j++;

}	}
}	}

if (glvnflag.one[1]) { /* upper/lower sensitivity */	if (glvnflag.one[1]) { /* upper/lower sensitivity */

j = 0;	j = 0;

while ((k = key[j]) != DELIM && k != EOL) {	while ((k = key[j]) != DELIM && k != EOL) {

if (k >= 'a' && k <= 'z') key[j] = k - 32;	if (k >= 'a' && k <= 'z') key[j] = k - 32;

j++;	j++;

}	}

}	}

if ((i = glvnflag.one[2])) {	if ((i = glvnflag.one[2])) {

if (stlen (key) > i) {	if (stlen (key) > i) {
merr_raise (M75);	merr_raise (M75);
return;	return;
} /* key length limit */	} /* key length limit */

}	}

if ((i = glvnflag.one[3])) { /* subscript length limit */	if ((i = glvnflag.one[3])) { /* subscript length limit */

j = 0;	j = 0;

while ((k = key[j++]) != DELIM && k != EOL);	while ((k = key[j++]) != DELIM && k != EOL);

if (k == DELIM) {	if (k == DELIM) {

k = 0;	k = 0;
for (;;) {	for (;;) {

k = key[j++];	k = key[j++];

if (k == DELIM \|\| k == EOL) {	if (k == DELIM \|\| k == EOL) {

if (k > i) {	if (k > i) {
merr_raise (M75);	merr_raise (M75);
return;	return;
}	}

k = 0;	k = 0;
}	}

if (k == EOL) break;	if (k == EOL) break;

k++;	k++;
}	}
}	}

}	}
}	}

Line 747 void global_bltin (short action, char *k	Line 836 void global_bltin (short action, char *k
}	}
}	}

if (v22ptr) {

procv22 (key);

if (key[0] != '^') {
char losav[256];

stcpy (losav, l_o_val);
symtab (action, key, data);
stcpy (g_o_val, l_o_val);
stcpy (l_o_val, losav);

return;
}
}

g = gbl_handle (key);	g = gbl_handle (key);
i = gbl_path (key, filnam);	i = gbl_path (key, filnam);

Line 827 void global_bltin (short action, char *k	Line 900 void global_bltin (short action, char *k
compactkey[k++] = ch << 1;	compactkey[k++] = ch << 1;

}	}
else if (ch < SP \|\| ch >= DEL) {	else if (ch < SP \|\| ch >= DEL) {
	/* no CTRLs */
/no CTRLs /

merr_raise (SBSCR);	merr_raise (SBSCR);
return;	return;
}	}
Line 903 void global_bltin (short action, char *k	Line 974 void global_bltin (short action, char *k

reopen:	reopen:

gbl_open (g, action);	if (!gbl_open (g, action)) {
if (g->fd == -1) {

/* file not found */	/* file not found */
if (action != set_sym) {	if (action != set_sym) {
Line 974 reopen:	Line 1044 reopen:
merr_raise (iresult);	merr_raise (iresult);
return;	return;
}	}

for (;;) {

errno = 0;

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

if (errno == 0) break;

panic ();
}

	gbl_write_block (g, ROOT, block);

block[NRBLK] = 0;	block[NRBLK] = 0;
block[NRBLK + 1] = 0;	block[NRBLK + 1] = 0;
block[NRBLK + 2] = ROOT; /* clear */	block[NRBLK + 2] = ROOT; /* clear */
Line 997 reopen:	Line 1057 reopen:
block[BTYP] = DATA; /* type */	block[BTYP] = DATA; /* type */
block[OFFS] = i / 256;	block[OFFS] = i / 256;
block[OFFS + 1] = i % 256;	block[OFFS + 1] = i % 256;

for (;;) {

errno = 0;
write (g->fd, block, BLOCKLEN);

if (errno == 0) break;

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

}

	gbl_write_block (g, ROOT + 1, block);

gbl_close (g);	gbl_close (g);
gbl_unlock (g);	gbl_unlock (g);
gbl_open (g, action);	gbl_open (g, action);
Line 1022 reopen:	Line 1072 reopen:
/* odd numbered actions get read access (get_sym,data,fra_order) 3 */	/* odd numbered actions get read access (get_sym,data,fra_order) 3 */
/* even ones read/write access (set_sym,kill_sym) 1 */	/* even ones read/write access (set_sym,kill_sym) 1 */

lock:	/* temporarily disabled
	lock:
	*/

if (action == get_sym) {	if (action == get_sym) {

tfast0:	tfast0:
gbl_lock (g, 3);	gbl_lock (g, 3);
if (tryfast) goto tfast1; /* try again last block */
	if (g->fast_path > 0) {
	goto tfast1; /* try again last block */
	}

blknbr = g->last_block = ROOT; /* start with ROOT block */	blknbr = g->last_block = ROOT; /* start with ROOT block */

for (;;) {	for (;;) {
	tfast1:
	gbl_read_block (g, blknbr, block);

	/* temporarily disabled
	tfast2:
	*/
	if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */
	offset = UNSIGN (block[OFFS]) * 256 +
	UNSIGN (block[OFFS + 1]);
	j = UNSIGN (block[0]);
	i = 0;

tfast1:	stcpy0 (key1, &block[2], j); /* get first key */

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


tfast2:

if ((typ = block[BTYP]) == DATA) { /* scan data block: here we test for equality only */

offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);
j = UNSIGN (block[0]);
i = 0;

stcpy0 (key1, &block[2], j); /* get first key */

ch = keyl; /* ch is a register! */

while (i < offset) {

j = UNSIGN (block[i++]); /* length of key - offset */
k = UNSIGN (block[i++]); /* offset into previous entry */

#ifdef VERSNEW

stcpy0 (&key0[k], &block[i], j);
i += j;
j += k;

#else

j += k;

while (k < j) key1[k++] = block[i++]; /* get key */	ch = keyl; /* ch is a register! */
	while (i < offset) {
#endif /* VERSNEW */	j = UNSIGN (block[i++]); /* length of key - offset */
	k = UNSIGN (block[i++]); /* offset into previous entry */
if (j != ch) { /* keys have different length */
	j += k;

	while (k < j) key1[k++] = block[i++]; /* get key */

	if (j != ch) { /* keys have different length */
	i += UNSIGN (block[i]);
	i++;

	continue;
	}

	j = ch;

	do {
	j--;
	} while (compactkey[j] == key1[j]); /* compare keys */

	if (j < 0) {
	k = UNSIGN (block[i++]);
	stcpy0 (data, &block[i], k); /* get value */
	data[k] = EOL1; /* append EOL */

	goto quit;
	}

i += UNSIGN (block[i]);	i += UNSIGN (block[i]);
i++;	i++; /* skip data */
	}
continue;
	/* fast access failed. try normal path */
	if (tryfast) {
	gbl_cache_miss (g);
	goto tfast0;
}	}

j = ch;	merr_raise (M7);
	data[0] = EOL;

do {	goto quit; /* variable not found */
j--;	}
} while (compactkey[j] == key1[j]); /* compare keys */	else {

	if (g->fast_path > 0) {
if (j < 0) {	gbl_cache_miss (g);
	goto tfast0;
	}

	if (typ == EMPTY) {

k = UNSIGN (block[i++]);	if (blknbr == ROOT) {
stcpy0 (data, &block[i], k); /* get value */	gbl_close (g);
data[k] = EOL1; /* append EOL */	goto reopen;
	}

	merr_raise (DBDGD);
goto quit;	goto quit;

}	}

i += UNSIGN (block[i]);
i++; /* skip data */

}

/* fast access failed. try normal path */
if (tryfast) {
tryfast = FALSE;
goto tfast0;
}	}

merr_raise (M7);
data[0] = EOL;

goto quit; /* variable not found */	scanpblk (block, &addr, &found);
}
else {	addr += UNSIGN (block[addr]) + 2; /* skip key */

if (tryfast) {	if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {
tryfast = FALSE;
goto tfast0;
}

if (typ == EMPTY) {

if (blknbr == ROOT) {
//close (filedes);
gbl_close (g);
goto reopen;
}

merr_raise (DBDGD);	merr_raise (DBDGD);
goto quit;	goto quit;

}	}

}	addr += PLEN; /* skip data */
	g->last_block = blknbr;
scanpblk (block, &addr, &found);	g->fast_path = 1;

addr += UNSIGN (block[addr]) + 2; /* skip key */

if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {
merr_raise (DBDGD);
goto quit;
}

addr += PLEN; /* skip data */
g->last_block = blknbr;

if (merr () == INRPT) goto quit;	if (merr () == INRPT) goto quit;

}	}
} /* end of get_sym */	} /* end of get_sym */
Line 1159 tfast2:	Line 1191 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, hdr_offset + ROOT, SEEK_SET);	/* note : UNIX does not tell other jobs that a file has been unlinked */

/* note : UNIX does not tell other */
block[BTYP] = EMPTY; /* jobs that a file has been unlinked */

/* as long as they keep it open. */	/* as long as they keep it open. */
/* so we mark this global as EMPTY */	/* so we mark this global as EMPTY */
write (g->fd, block, BLOCKLEN);	block[BTYP] = EMPTY;

	gbl_write_block (g, ROOT, block);

gbl_unlock (g);	gbl_unlock (g);
gbl_close (g);	gbl_close (g);
Line 1191 k_again: /* entry point for repeated	Line 1221 k_again: /* entry point for repeated

traceblk[trx] = blknbr;	traceblk[trx] = blknbr;
traceadr[trx] = 0;	traceadr[trx] = 0;

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

typ = block[BTYP];	typ = block[BTYP];

if (typ == DATA) {	if (typ == DATA) {
Line 1226 k_again: /* entry point for repeated	Line 1254 k_again: /* entry point for repeated

addr += PLEN; /* skip data */	addr += PLEN; /* skip data */
g->last_block = blknbr;	g->last_block = blknbr;
	g->fast_path = 1;
}	}

traceadr[trx] = addr;	traceadr[trx] = addr;
Line 1236 k_again: /* entry point for repeated	Line 1265 k_again: /* entry point for repeated

datal = stlen (data);	datal = stlen (data);
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (found != 2) { /* new entry */	if (found != 2) { /* new entry */

Line 1262 k_again: /* entry point for repeated	Line 1291 k_again: /* entry point for repeated
}	}


s10: {	s10:
	{
long len; /* insert key */	long len; /* insert key */
char key0[256];	char key0[256];

Line 1360 s10: {	Line 1390 s10: {

}	}

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

if (traceadr[trx] == 0) update (g, compactkey, keyl);	if (traceadr[trx] == 0) update (g, compactkey, keyl);

Line 1414 s10: {	Line 1443 s10: {
goto splitd;	goto splitd;
}	}

s20:	s20:

i = offset;	i = offset;
k = addr + olddatal;	k = addr + olddatal;
Line 1447 s20:	Line 1476 s20:
}	}

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

gbl_update_tid (g);	gbl_write_block (g, blknbr, block);

break;	break;

Line 1476 s20:	Line 1503 s20:

/* get following entry, eventually in the next blk */	/* get following entry, eventually in the next blk */
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (addr >= offset) {	if (addr >= offset) {

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, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, blknbr, block);
read (g->fd, block, BLOCKLEN);
j1 = UNSIGN (block[0]);	j1 = UNSIGN (block[0]);

i = 0;	i = 0;
Line 1564 s20:	Line 1590 s20:

goto quit;	goto quit;
} /* no next block */	} /* no next block */

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

}	}
Line 1613 s20:	Line 1638 s20:

while (i < keyl) if (compactkey[i++] & 01)	while (i < keyl) if (compactkey[i++] & 01)

j1++;	j1++;
i = 0;	i = 0;
j = 0;	j = 0;
k = 0;	k = 0;
Line 1646 s20:	Line 1671 s20:
while ((ch = UNSIGN (scratch[i++])) != g_EOL) {	while ((ch = UNSIGN (scratch[i++])) != g_EOL) {

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */


if (ch0 == DEL) {	if (ch0 == DEL) {
Line 1722 s20:	Line 1747 s20:
goto quit; /* no next block */	goto quit; /* no next block */
}	}

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

addr = 0;	addr = 0;
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
}	}

}	}
Line 1746 s20:	Line 1770 s20:
goto quit; /* no next block */	goto quit; /* no next block */
}	}

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

addr = 0;	addr = 0;
}	}
Line 1795 s20:	Line 1818 s20:
while ((ch = UNSIGN (key0[i++])) != g_EOL) {	while ((ch = UNSIGN (key0[i++])) != g_EOL) {

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */


if (ch0 == DEL) {	if (ch0 == DEL) {
Line 1872 s20:	Line 1895 s20:
}	}

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */

if (ch0 == DEL) {	if (ch0 == DEL) {

Line 1917 s20:	Line 1940 s20:

case kill_sym: /* search and destroy */	case kill_sym: /* search and destroy */

killo: /* entry from killone section */	killo: /* entry from killone section */
offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);	offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);

i = 0;	i = 0;
Line 1956 killo: /* entry from killone section	Line 1979 killo: /* entry from killone section

other = traceblk[--trx];	other = traceblk[--trx];
addr = traceadr[trx];	addr = traceadr[trx];

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

addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr += (2 + PLEN); /* skip previous entry */	addr += (2 + PLEN); /* skip previous entry */
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
traceadr[trx] = addr;	traceadr[trx] = addr;

if (addr < offset) break;	if (addr < offset) break;

traceadr[trx] = 0;	traceadr[trx] = 0;
traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +	traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);

}	}

trx = trxsav;	trx = trxsav;

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

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
addr = 0;	addr = 0;
k = UNSIGN (block[0]);	k = UNSIGN (block[0]);
stcpy0 (key0, &block[2], k);	stcpy0 (key0, &block[2], k);
Line 2070 killo: /* entry from killone section	Line 2091 killo: /* entry from killone section
if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */	if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */

long left,	long left,
right;	right;
char block0[BLOCKLEN];	char block0[BLOCKLEN];

p_empty: /* entry if pointer block goes empty */	p_empty: /* entry if pointer block goes empty */

left = UNSIGN (block[LLPTR]) * 65536 +	left = UNSIGN (block[LLPTR]) * 65536 +
UNSIGN (block[LLPTR + 1]) * 256 +	UNSIGN (block[LLPTR + 1]) * 256 +
UNSIGN (block[LLPTR + 2]);	UNSIGN (block[LLPTR + 2]);
right = UNSIGN (block[RLPTR]) * 65536 +	right = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);

if (left) {	if (left) {

lseek (g->fd, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, left, block0);
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, hdr_offset + ((long) left * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, left, block0);
write (g->fd, block0, BLOCKLEN);

}	}

if (right) {	if (right) {

lseek (g->fd, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, right, block0);
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, hdr_offset + ((long) right * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, right, block0);
write (g->fd, block0, BLOCKLEN);

}	}

b_free (g->fd, blknbr); /* modify free list */	b_free (g, blknbr); /* modify free list */

/* delete pointer */	/* delete pointer */
/**************************/	/**************************/
Line 2123 p_empty: /* entry if pointer block goes	Line 2140 p_empty: /* entry if pointer block goes
blknbr = traceblk[--trx];	blknbr = traceblk[--trx];
addr = traceadr[trx];	addr = traceadr[trx];

lseek (g->fd, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, blknbr, block);
read (g->fd, block, BLOCKLEN);
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);
freecnt = UNSIGN (block[addr]) + 2 + PLEN;	freecnt = UNSIGN (block[addr]) + 2 + PLEN;

/* delete key */	/* delete key */
Line 2136 p_empty: /* entry if pointer block goes	Line 2152 p_empty: /* entry if pointer block goes

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

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 */

/* as long as they keep it open. */	/* as long as they keep it open. */
/* so we mark this global as EMPTY */	/* so we mark this global as EMPTY */
write (g->fd, block, BLOCKLEN);	gbl_write_block (g, 0L, block);

gbl_close (g);	gbl_close (g);
unlink (filnam);	unlink (filnam);

Line 2168 p_empty: /* entry if pointer block goes	Line 2185 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, hdr_offset + ((long) (blknbr) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

if (addr == 0) { /* update of pointer */	if (addr == 0) { /* update of pointer */
traceadr[trx] = 0;	traceadr[trx] = 0;
Line 2199 p_empty: /* entry if pointer block goes	Line 2215 p_empty: /* entry if pointer block goes
j = block[begadr + 1];	j = block[begadr + 1];
k = 0;	k = 0;
if (begadr)	if (begadr)
while (key0[k] == key1[k])	while (key0[k] == key1[k])
k++; /* new key_offset */	k++; /* new key_offset */
if (k < j) {	if (k < j) {
ch = j - k; /* space requirement */	ch = j - k; /* space requirement */
block[begadr] = i + ch; /* new key_length */	block[begadr] = i + ch; /* new key_length */
block[begadr + 1] = k; /* new key_offset */	block[begadr + 1] = k; /* new key_offset */
i = offset;	i = offset;
j = i + ch;	j = i + ch;
offset = j;	offset = j;
begadr++;	begadr++;
while (i > begadr)	while (i > begadr)
block[j--] = block[i--];	block[j--] = block[i--];
stcpy0 (&block[begadr + 1], &key0[k], ch);	stcpy0 (&block[begadr + 1], &key0[k], ch);
}	}
}	}
block[OFFS] = offset / 256;	block[OFFS] = offset / 256;
block[OFFS + 1] = offset % 256;	block[OFFS + 1] = offset % 256;
lseek (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);
write (g->fd, block, BLOCKLEN);	gbl_write_block (g, blknbr, block);

if (addr < 3) { /* update of pointer */	if (addr < 3) { /* update of pointer */
traceadr[trx] = 0;	traceadr[trx] = 0;
update (g, &block[2], (long) UNSIGN (block[0]));	update (g, &block[2], (long) UNSIGN (block[0]));
}	}
}	}

Line 2228 p_empty: /* entry if pointer block goes	Line 2245 p_empty: /* entry if pointer block goes

break;	break;

zinv:	zinv:

{	{
long len;	long len;
Line 2242 zinv:	Line 2259 zinv:
data[0] = EOL1;	data[0] = EOL1;
goto quit;	goto quit;
} /* no previous block */	} /* no previous block */

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

addr = UNSIGN (block[OFFS]) * 256 +	addr = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

}	}

Line 2322 zinv:	Line 2338 zinv:
while ((ch = UNSIGN (scratch[i++])) != g_EOL) {	while ((ch = UNSIGN (scratch[i++])) != g_EOL) {

ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */	ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */
(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */	(ch < 20 ? (ch >> 1) + '0' : /* 0...9 */
(ch >> 1) + SP)); /* '.' or '-' */	(ch >> 1) + SP)); /* '.' or '-' */

if (ch0 == DEL) {	if (ch0 == DEL) {

Line 2368 zinv:	Line 2384 zinv:

case zdata: /* nonstandard data function */	case zdata: /* nonstandard data function */

{	{
long counties[128];	long counties[128];
char key0[256];	char key0[256];
int icnt, icnt0, len;	int icnt, icnt0, len;

i = 0;	i = 0;

while (i < 128) counties[i++] = 0L; /* init count; */	while (i < 128) counties[i++] = 0L; /* init count; */

if (found == 2) { /* ... advance to next entry */	if (found == 2) { /* ... advance to next entry */
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr += 2; /* skip key */	addr += 2; /* skip key */
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr++; /* skip data */	addr++; /* skip data */

counties[0] = 1L;	counties[0] = 1L;
}	}

offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);	offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
icnt = 0;	icnt = 0;
i = 0;	i = 0;

while ((ch = compactkey[i++]) != g_EOL) {	while ((ch = compactkey[i++]) != g_EOL) {

if (ch & 01) {
icnt++;
}

	if (ch & 01) {
	icnt++;
}	}

len = i - 1;	}
i = 0;

while (i < addr) { /* compute offset complete key */	len = i - 1;
	i = 0;

	while (i < addr) { /* compute offset complete key */

icnt0 = UNSIGN (block[i++]);	icnt0 = UNSIGN (block[i++]);
icnt0 += (j = UNSIGN (block[i++]));	icnt0 += (j = UNSIGN (block[i++]));

while (j < icnt0) key0[j++] = block[i++];	while (j < icnt0) key0[j++] = block[i++];

key0[j] = g_EOL;	key0[j] = g_EOL;
i += UNSIGN (block[i]);	i += UNSIGN (block[i]);

i++; /* skip data */	i++; /* skip data */

}	}

for (;;) { /* is it still a descendant ??? */	for (;;) { /* is it still a descendant ??? */

if (addr >= offset) { /* look in next block */	if (addr >= offset) { /* look in next block */

if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {	if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
break; /* no next block */	break; /* no next block */
}	}

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

addr = 0;	addr = 0;
offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

}	}

i = UNSIGN (block[addr++]);	i = UNSIGN (block[addr++]);
i += (j = UNSIGN (block[addr++]));	i += (j = UNSIGN (block[addr++]));

while (j < i) key0[j++] = block[addr++];	while (j < i) key0[j++] = block[addr++];

addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
addr++; /* skip data */	addr++; /* skip data */
icnt0 = 0;	icnt0 = 0;
i = 0;	i = 0;

while (i < j) if (key0[i++] & 01)	while (i < j) if (key0[i++] & 01)

icnt0++;	icnt0++;

if (icnt0 <= icnt) break;	if (icnt0 <= icnt) break;

i = 0;	i = 0;

while (i < len) {	while (i < len) {

if (key0[i] != compactkey[i]) break;	if (key0[i] != compactkey[i]) break;

i++;	i++;

}	}

if (i < len) break;	if (i < len) break;

counties[icnt0 - icnt]++;	counties[icnt0 - icnt]++;

}	}

i = 128;	i = 128;

while (counties[--i] == 0L);	while (counties[--i] == 0L);

lintstr (data, counties[0]);	lintstr (data, counties[0]);

j = 1;	j = 1;
tmp1[0] = ',';	tmp1[0] = ',';

while (j <= i) {	while (j <= i) {
lintstr (&tmp1[1], counties[j++]);	lintstr (&tmp1[1], counties[j++]);
stcat (data, tmp1);	stcat (data, tmp1);
}

}	}

	}

break;	break;

case getinc:	case getinc:

{	{
int setopsav;	int setopsav;

setopsav = setop;	setopsav = setop;
setop = '+';	setop = '+';
data[0] = '1';	data[0] = '1';
data[1] = EOL;	data[1] = EOL;

global (set_sym, key, data);	global (set_sym, key, data);

setop = setopsav;	setop = setopsav;

return;	return;
}	}

case killone:	case killone:
	{
{	if (found == 2) goto killo; /* entry found use normal kill routine */
if (found == 2) goto killo; /* entry found use normal kill routine */

goto quit;	goto quit;
}	}

case merge_sym:

printf("MERGE NOT IMPLEMENTED FOR GLOBALS\n");

#ifdef DEBUG_GBL

int loop;

printf ("DEBUG MERGE: ");
printf ("[key] is [");

for (loop = 0; key[loop] != EOL; loop++) printf ("%c", (key[loop] == DELIM) ? '!' : key[loop]);

printf ("]\r\n");
printf ("[data] is [");

for(loop = 0; data[loop] != EOL; loop++) printf ("%c", (data[loop] == DELIM) ? '!' : data[loop]);

printf("]\r\n");

#endif
return;

default:	default:

Line 2552 splitd: /* split data block in two se	Line 2543 splitd: /* split data block in two se
/* 'addr' there I would like to insert, if possible (which is not) */	/* 'addr' there I would like to insert, if possible (which is not) */
/* 'offset' filled up to this limit */	/* 'offset' filled up to this limit */

getnewblk (g->fd, &newblk); /* get a new block */	getnewblk (g, &newblk); /* get a new block */

/* if we have to insert at the begin or end of a block */	/* if we have to insert at the begin or end of a block */
/* we don't split - we just start a new block */	/* we don't split - we just start a new block */
Line 2560 splitd: /* split data block in two se	Line 2551 splitd: /* split data block in two se

if (addr >= offset) {	if (addr >= offset) {
long right,	long right,
right1,	right1,
right2;	right2;

right = UNSIGN (block[RLPTR]);	right = UNSIGN (block[RLPTR]);
right1 = UNSIGN (block[RLPTR + 1]);	right1 = UNSIGN (block[RLPTR + 1]);
Line 2570 splitd: /* split data block in two se	Line 2561 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, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

block[RLPTR] = right;	block[RLPTR] = right;
block[RLPTR + 1] = right1;	block[RLPTR + 1] = right1;
Line 2590 splitd: /* split data block in two se	Line 2580 splitd: /* split data block in two se

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

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

goto spltex;	goto spltex;
Line 2616 splitd: /* split data block in two se	Line 2604 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, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

block[LLPTR] = left;	block[LLPTR] = left;
block[LLPTR + 1] = left1;	block[LLPTR + 1] = left1;
block[LLPTR + 2] = left2;	block[LLPTR + 2] = left2;
Line 2638 splitd: /* split data block in two se	Line 2625 splitd: /* split data block in two se
}	}

/* other is *always* zero !!!	/* other is *always* zero !!!
* if (other=left65536+left1256+left2) up-date RL-PTR of LL-block	* if (other=left65536+left1256+left2) up-date RL-PTR of LL-block
* { char block0[BLOCKLEN];	* { char block0[BLOCKLEN];
* lseek(filedes,(long)other*(long)(BLOCKLEN),0);	* lseek(filedes,(long)other*(long)(BLOCKLEN),0);
* read(filedes,block0,BLOCKLEN);	* read(filedes,block0,BLOCKLEN);
* block0[RLPTR ]=blknbr/65536;	* block0[RLPTR ]=blknbr/65536;
* block0[RLPTR+1]=blknbr%65536/256;	* block0[RLPTR+1]=blknbr%65536/256;
* block0[RLPTR+2]=blknbr%256;	* block0[RLPTR+2]=blknbr%256;
* lseek(filedes,(long)other*(long)(BLOCKLEN),0);	* lseek(filedes,(long)other*(long)(BLOCKLEN),0);
* write(filedes,block0,BLOCKLEN);	* write(filedes,block0,BLOCKLEN);
* }	* }
*/	*/

goto spltex;	goto spltex;

Line 2730 splitd: /* split data block in two se	Line 2717 splitd: /* split data block in two se

/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);
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];
Line 2742 splitd: /* split data block in two se	Line 2729 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, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, newblk, block0);
write (g->fd, block0, BLOCKLEN);

offset = limit;	offset = limit;
/* insert new block in pointer structure */	/* insert new block in pointer structure */
Line 2753 splitd: /* split data block in two se	Line 2739 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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 2770 splitd: /* split data block in two se	Line 2754 splitd: /* split data block in two se
/* save old block away and make new block the current block */	/* save old block away and make new block the current block */
/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);
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];
Line 2782 splitd: /* split data block in two se	Line 2766 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, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);
stcpy0 (block, block0, (long) BLOCKLEN);	stcpy0 (block, block0, (long) BLOCKLEN);

traceadr[trx] = (addr -= limit);	traceadr[trx] = (addr -= limit);
Line 2795 splitd: /* split data block in two se	Line 2779 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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 2838 static void splitp (global_handle *g, ch	Line 2820 static void splitp (global_handle *g, ch
unsigned long newblk;	unsigned long newblk;
unsigned long other;	unsigned long other;
register int i, j;	register int i, j;

long hdr_offset;

hdr_offset = sizeof (global_header);

getnewblk (g->fd, &newblk); /* get a new block */	getnewblk (g, &newblk); /* get a new block */

if (blknbr == ROOT) { / ROOT overflow is special */	if (blknbr == ROOT) { / ROOT overflow is special */

Line 2870 static void splitp (global_handle *g, ch	Line 2848 static void splitp (global_handle *g, ch

/* update number of blocks ! */	/* update number of blocks ! */
i = UNSIGN (block0[NRBLK]) * 65536 +	i = UNSIGN (block0[NRBLK]) * 65536 +
UNSIGN (block0[NRBLK + 1]) * 256 +	UNSIGN (block0[NRBLK + 1]) * 256 +
UNSIGN (block0[NRBLK + 2]) + 1;	UNSIGN (block0[NRBLK + 2]) + 1;

block0[NRBLK] = i / 65536;	block0[NRBLK] = i / 65536;
block0[NRBLK + 1] = i % 65536 / 256;	block0[NRBLK + 1] = i % 65536 / 256;
block0[NRBLK + 2] = i % 256;	block0[NRBLK + 2] = i % 256;
block0[BTYP] = POINTER;	block0[BTYP] = POINTER;

lseek (g->fd, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, block0);
write (g->fd, block0, BLOCKLEN);

/* shift trace_stack */	/* shift trace_stack */
j = trx++;	j = trx++;
Line 2896 static void splitp (global_handle *g, ch	Line 2873 static void splitp (global_handle *g, ch
traceblk[1] = newblk;	traceblk[1] = newblk;
*blknbr = newblk;	*blknbr = newblk;

getnewblk (g->fd, &newblk); /* get a new block */	getnewblk (g, &newblk); /* get a new block */

}	}

Line 2938 static void splitp (global_handle *g, ch	Line 2915 static void splitp (global_handle *g, ch

/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);
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];
Line 2950 static void splitp (global_handle *g, ch	Line 2927 static void splitp (global_handle *g, ch
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, hdr_offset + ((long) (newblk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, newblk, block0);
write (g->fd, block0, BLOCKLEN);

(*offs) = limit;	(*offs) = limit;

Line 2960 static void splitp (global_handle *g, ch	Line 2936 static void splitp (global_handle *g, ch
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 2977 static void splitp (global_handle *g, ch	Line 2951 static void splitp (global_handle *g, ch

/* update rightlink and leftlink pointers */	/* update rightlink and leftlink pointers */
other = UNSIGN (block[RLPTR]) * 65536 +	other = UNSIGN (block[RLPTR]) * 65536 +
UNSIGN (block[RLPTR + 1]) * 256 +	UNSIGN (block[RLPTR + 1]) * 256 +
UNSIGN (block[RLPTR + 2]);	UNSIGN (block[RLPTR + 2]);

block0[RLPTR] = block[RLPTR];	block0[RLPTR] = block[RLPTR];
block0[RLPTR + 1] = block[RLPTR + 1];	block0[RLPTR + 1] = block[RLPTR + 1];
Line 2992 static void splitp (global_handle *g, ch	Line 2966 static void splitp (global_handle *g, ch

(*addr) -= limit;	(*addr) -= limit;
(*offs) -= limit;	(*offs) -= limit;

	gbl_write_block (g, *blknbr, block);

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

(*blknbr) = newblk;	(*blknbr) = newblk;
Line 3004 static void splitp (global_handle *g, ch	Line 2978 static void splitp (global_handle *g, ch
/* up-date LL-PTR of RL-block */	/* up-date LL-PTR of RL-block */
if (other != 0) {	if (other != 0) {

lseek (g->fd, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, other, block0);
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, hdr_offset + ((long) other * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, other, block0);
write (g->fd, block0, BLOCKLEN);

}	}

Line 3034 static void update (global_handle *g, ch	Line 3006 static void update (global_handle *g, ch
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 */

Line 3044 static void update (global_handle *g, ch	Line 3013 static void update (global_handle *g, ch

blknbr = traceblk[trx];	blknbr = traceblk[trx];
addr = traceadr[trx];	addr = traceadr[trx];

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

{	{
long oldkeyl;	long oldkeyl;
Line 3057 static void update (global_handle *g, ch	Line 3025 static void update (global_handle *g, ch
j = oldkeyl - keyl;	j = oldkeyl - keyl;

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (j > 0) { /* surplus space */	if (j > 0) { /* surplus space */

Line 3096 static void update (global_handle *g, ch	Line 3064 static void update (global_handle *g, ch
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 (g->fd, hdr_offset + ((long) blknbr * (long) (BLOCKLEN)), SEEK_SET);	gbl_write_block (g, blknbr, block);
write (g->fd, block, BLOCKLEN);

}	}

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

}	}

Line 3126 static void insert (global_handle *g, ch	Line 3091 static void insert (global_handle *g, ch
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 (g->fd, hdr_offset + ((long) (blk) * (long) (BLOCKLEN)), SEEK_SET);	gbl_read_block (g, blk, block);
read (g->fd, block, BLOCKLEN);

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

if (traceadr[trx + 1] != (-1)) {	if (traceadr[trx + 1] != (-1)) {
addr += UNSIGN (block[addr]);	addr += UNSIGN (block[addr]);
Line 3171 static void insert (global_handle *g, ch	Line 3132 static void insert (global_handle *g, ch
block[i++] = blknbr % 65536 / 256;	block[i++] = blknbr % 65536 / 256;
block[i] = blknbr % 256;	block[i] = blknbr % 256;

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

trx = trxsav;	trx = trxsav;

Line 3184 static void insert (global_handle *g, ch	Line 3144 static void insert (global_handle *g, ch
* filedes: global file descriptor	* filedes: global file descriptor
* blknbr: block to be freed	* blknbr: block to be freed
*/	*/
static void b_free (short filedes, unsigned long blknbr)	static void b_free (global_handle *g, unsigned long blknbr)
{	{
char block0[BLOCKLEN];	char block0[BLOCKLEN];
unsigned long free;	unsigned long free;
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, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET);	gbl_read_block (g, blknbr, block0);
read (filedes, block0, BLOCKLEN);

block0[BTYP] = EMPTY;

lseek (filedes, hdr_offset + ((long) (blknbr) * BLOCKLEN), SEEK_SET);	block0[BTYP] = EMPTY;
write (filedes, block0, BLOCKLEN);
	gbl_write_block (g, blknbr, block0);

/* do we have a list of free blocks? */	/* do we have a list of free blocks? */
lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_read_block (g, ROOT, block0);
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, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);	gbl_read_block (g, free, block0);
read (filedes, block0, BLOCKLEN);

other = UNSIGN (block0[RLPTR]) * 65536 +	other = UNSIGN (block0[RLPTR]) * 65536 +
UNSIGN (block0[RLPTR + 1]) * 256 +	UNSIGN (block0[RLPTR + 1]) * 256 +
UNSIGN (block0[RLPTR + 2]);	UNSIGN (block0[RLPTR + 2]);

if (other == 0) break;	if (other == 0) break;

Line 3233 static void b_free (short filedes, unsig	Line 3186 static void b_free (short filedes, unsig
offset -= PLEN;	offset -= PLEN;
other = UNSIGN (block0[offset]) * 65536 +	other = UNSIGN (block0[offset]) * 65536 +

UNSIGN (block0[offset + 1]) * 256 +	UNSIGN (block0[offset + 1]) * 256 +
UNSIGN (block0[offset + 2]);	UNSIGN (block0[offset + 2]);

block0[offset] = 0;	block0[offset] = 0;
block0[offset + 1] = 0;	block0[offset + 1] = 0;
Line 3244 static void b_free (short filedes, unsig	Line 3197 static void b_free (short filedes, unsig
block0[RLPTR] = other / 65536;	block0[RLPTR] = other / 65536;
block0[RLPTR + 1] = other % 65536 / 256;	block0[RLPTR + 1] = other % 65536 / 256;
block0[RLPTR + 2] = other % 256;	block0[RLPTR + 2] = other % 256;

lseek (filedes, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);	gbl_write_block (g, free, block0);
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 3262 static void b_free (short filedes, unsig	Line 3214 static void b_free (short filedes, unsig

}	}
else {	else {
	getnewblk (g, &free);
getnewblk (filedes, &free);

/* set FBLK free blocks pointer */	/* set FBLK free blocks pointer */
lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_read_block (g, ROOT, block0);
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, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, block0);
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 3289 static void b_free (short filedes, unsig	Line 3238 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, hdr_offset + ((long) free * (long) BLOCKLEN), SEEK_SET);	gbl_write_block (g, free, block0);
write (filedes, block0, BLOCKLEN);

return;	return;
} /* end of b_free() */	} /* end of b_free() */
Line 3363 static void scandblk (char *block, long	Line 3311 static void scandblk (char *block, long
char key0[256];	char key0[256];

offset = UNSIGN (block[OFFS]) * 256 +	offset = UNSIGN (block[OFFS]) * 256 +
UNSIGN (block[OFFS + 1]);	UNSIGN (block[OFFS + 1]);

while (i < offset) {	while (i < offset) {

Line 3410 static void scandblk (char *block, long	Line 3358 static void scandblk (char *block, long
* filedes: global file descriptor	* filedes: global file descriptor
* blknbr: number of new block	* blknbr: number of new block
*/	*/
static void getnewblk (int filedes, unsigned long *blknbr)	static void getnewblk (global_handle g, unsigned long blknbr)
{	{
char nblock[BLOCKLEN];	char nblock[BLOCKLEN];
unsigned long freeblks, no_of_blks;	unsigned long freeblks, no_of_blks;
long other;	long other;
long offset;	long offset;
long hdr_offset;

hdr_offset = sizeof (global_header);	gbl_read_block (g, ROOT, nblock);

lseek (filedes, hdr_offset + ROOT, SEEK_SET);
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]);
no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]);	no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]);

if (freeblks) {	if (freeblks) {

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

offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);	offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);

Line 3441 static void getnewblk (int filedes, unsi	Line 3384 static void getnewblk (int filedes, unsi
/* update RL-block, if any */	/* update RL-block, if any */
if (other) {	if (other) {

lseek (filedes, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET);	gbl_read_block (g, other, nblock);
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, hdr_offset + ((long) (other) * BLOCKLEN), SEEK_SET);	gbl_write_block (g, other, nblock);
write (filedes, nblock, BLOCKLEN);

}	}

/* update ROOT block */	/* update ROOT block */
lseek (filedes, hdr_offset + ROOT, SEEK_SET);	gbl_read_block (g, ROOT, nblock);
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, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, nblock);
write (filedes, nblock, BLOCKLEN);

return;	return;

Line 3474 static void getnewblk (int filedes, unsi	Line 3413 static void getnewblk (int filedes, unsi
nblock[offset + 1] = 0;	nblock[offset + 1] = 0;
nblock[OFFS] = offset / 256;	nblock[OFFS] = offset / 256;
nblock[OFFS + 1] = offset % 256;	nblock[OFFS + 1] = offset % 256;

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

return;	return;

Line 3487 static void getnewblk (int filedes, unsi	Line 3425 static void getnewblk (int filedes, unsi
nblock[NRBLK] = no_of_blks / 65536;	nblock[NRBLK] = no_of_blks / 65536;
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, hdr_offset + ROOT, SEEK_SET);	gbl_write_block (g, ROOT, nblock);
write (filedes, nblock, BLOCKLEN);

*blknbr = no_of_blks;	*blknbr = no_of_blks;

for (;;) {

errno = 0;

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

if (errno == 0) break;

panic ();

}	gbl_write_block (g, no_of_blks, nblock);

return;	return;

Line 3633 static short int g_collate (char *t)	Line 3559 static short int g_collate (char *t)
/*	/*
* test whether 'str' is canonical	* test whether 'str' is canonical
*/	*/
//static short int g_numeric (char *str)
short g_numeric (char *str)	short g_numeric (char *str)
{	{
register int ptr = 0, ch;	register int ptr = 0, ch;
Line 3683 void close_all_globals (void)	Line 3608 void close_all_globals (void)
gbl_close_all ();	gbl_close_all ();

return;	return;
} /* end close_all_globals() */	} /* close_all_globals() */

static void panic (void)	static void panic (void)
{	{
printf ("write failed\r\n");	logprintf (FM_LOG_ERROR, "global_bltin: could not write to full disk");

printf ("\033[s\033[25H\033[5;7mwrite needs more disk space immediately\007");
sleep (1);
printf ("\033[m\007\033[2K\033[u");

/* restore screen 'cause system messed up screen */

#ifdef NOWRITEM

write_m ("\033[4~\201");

#endif /* NOWRITEM */

return;	return;
	} /* panic() */
} /* end panic() */


void gbl_dump_stat(void)	void gbl_dump_stat(void)
{	{
global_handle *g;	global_handle *g;
	int ct;
printf ("FreeM Global Statistics [PID %d]\r\n", pid);	int miss_pct;
	int hit_pct;
	unsigned long access_total;
	unsigned long hit_total;
	unsigned long mem_reads_total;

printf ("%-20s%-10s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "AGE", "LAST BLK", "FILE");	mem_reads_total = 0;
printf ("%-20s%-10s%-20s%-10s%s\r\n", "======", "=====", "===", "========", "====");	printf ("\r\nFreeM Global Statistics [PID %d]\r\n\r\n", pid);

	printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "GLOBAL", "USECT", "READS", "WRITES", "MEMREADS", "SLOW PTHCT", "AGE", "LAST BLK", "FILE");
	printf ("%-20s%-10s%-10s%-10s%-10s%-12s%-20s%-10s%s\r\n", "======", "=====", "=====", "======", "========", "==========", "===", "========", "====");

	access_total = 0;
	ct = 0;
for (g = global_handles_head; g != NULL; g = g->next) {	for (g = global_handles_head; g != NULL; g = g->next) {
printf ("%-20s%-10d%-20d%-10d%s\r\n", g->global_name, g->use_count, g->age, g->last_block, g->global_path);	printf ("%-20s%-10ld%-10ld%-10ld%-10ld%-12ld%-20ld%-10ld%s\r\n",
}	g->global_name,
	g->use_count,
	g->read_ops,
	g->write_ops,
	g->memory_reads,
	g->cache_misses,
	g->age,
	g->last_block,
	g->global_path);
	ct++;
	mem_reads_total += g->memory_reads;
	access_total += g->use_count;
	}
	if (!ct) printf ("<no globals opened in this pid>\r\n");

	hit_total = access_total - gbl_cache_misses;
	miss_pct = (gbl_cache_misses * 100) / access_total;
	hit_pct = (hit_total * 100) / access_total;

	printf ("\r\nTotal accesses: %ld\r\n", access_total);
	printf ("Fast path hits %ld\t(%d%%)\r\n", hit_total, hit_pct);
	printf ("Fast path misses: %ld\t(%d%%)\r\n", gbl_cache_misses, miss_pct);
	printf ("Disk reads avoided: %ld\r\n", mem_reads_total);

}	}

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

Removed from v.1.11
changed lines
	Added in v.1.23