--- freem/src/global_bltin.c 2025/04/11 20:55:49 1.21 +++ freem/src/global_bltin.c 2025/04/28 14:52:54 1.24 @@ -1,5 +1,5 @@ /* - * $Id: global_bltin.c,v 1.21 2025/04/11 20:55:49 snw Exp $ + * $Id: global_bltin.c,v 1.24 2025/04/28 14:52:54 snw Exp $ * freem database engine * * @@ -24,47 +24,8 @@ * along with FreeM. If not, see . * * $Log: global_bltin.c,v $ - * 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 - * Make insert, update, and splitp global handler functions take a ptr to a global_handle instead of a file descriptor - * - * Revision 1.10 2025/04/08 20:00:56 snw - * Global handler now uses a header file and maintains the last journaling transaction ID - * - * 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 - * Initial work on global handler refactor + * Revision 1.24 2025/04/28 14:52:54 snw + * Temporarily revert global handler refactor and fix reference regression in xecline * * Revision 1.7 2025/03/24 04:13:11 snw * Replace action macro dat with fra_dat to avoid symbol conflict on OS/2 @@ -88,25 +49,21 @@ #include #include #include -#include + #include + #include "mpsdef.h" -#include "journal.h" -#include "global_bltin.h" -global_handle *global_handles_head; -unsigned long gbl_cache_misses = 0; -unsigned long gbl_cache_hits = 0; - -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 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 b_free (short filedes, unsigned long blknbr); +static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr); +static void update (short filedes, char *ins_key, long keyl); +static void insert (int filedes, char *ins_key, long key_len, unsigned long blknbr); static void scanpblk (char *block, long *adr, long *fnd); static void scandblk (char *block, long *adr, long *fnd); -static void getnewblk (global_handle *g, unsigned long *blknbr); +static void getnewblk (int filedes, unsigned long *blknbr); static short int g_collate (char *t); +//static short int g_numeric (char *str); short g_numeric (char *str); void close_all_globals(void); static void panic (void); @@ -151,491 +108,9 @@ static void panic (void); #define DATA 8 #if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__) -long time (); + long time (); #endif -inline long gbl_path(char *key, char *buf) -{ - long savj; - - register long int i; - register long int j; - register long int k; - register long int ch; - - /* construct full UNIX filename */ - savj = 0; - k = 0; - j = savj; - - if (key[1] == '%' || key[1] == '$') { /* %-globals and SSVN backing storage, no explicit path */ - - if (gloplib[0] != EOL) { - - /* append % global access path */ - while ((ch = buf[k++] = gloplib[j++]) != ':' && ch != EOL); - - } - - } - else if (key[1] != '/') { /* no explicit path specified */ - - if (glopath[0] != EOL) { - - /* append global access path */ - while ((ch = buf[k++] = glopath[j++]) != ':' && ch != EOL); - - } - - } - - if (k > 0) { - - if (k == 1 || (k == 2 && buf[0] == '.')) { - k = 0; - } - else { - buf[k - 1] = '/'; - } - - } - - savj = j; - i = 0; - j = 0; - - while (key[i] != EOL) { - - if ((buf[k] = key[i]) == DELIM) break; - - if (buf[k] == '/') { - - j = i; - - if (k > i) { - i = 0; - j = 0; - k = 0; - - continue; - } - - } - - i++; - k++; - - } - - buf[k] = NUL; /* NUL not EOL !!! */ - - return i; -} /* 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) -{ - if (g->locked == TRUE || lonelyflag == TRUE) { - return TRUE; - } - - locking (g->fd, type, 0L); - g->locked = TRUE; - - return TRUE; -} /* gbl_lock() */ - -int gbl_unlock(global_handle *g) -{ - if (g->locked == FALSE || lonelyflag == TRUE) { - return TRUE; - } - - locking (g->fd, 0, 0L); - g->locked = FALSE; - - return TRUE; -} /* gbl_unlock() */ - -void gbl_close(global_handle *g) -{ - if (g->opened == TRUE) { - close (g->fd); - - g->use_count = 0; - g->age = 0; - g->last_block = 0; - g->locked = FALSE; - g->opened = FALSE; - } -} /* gbl_close() */ - -void gbl_close_all(void) -{ - global_handle *g; - - for (g = global_handles_head; g != NULL; g = g->next) { - gbl_close (g); - } -} /* gbl_close_all() */ - -int gbl_write_initial_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, sizeof (msg), "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_initial_header() */ - - -int gbl_write_header(global_handle *g, global_header *hdr) -{ - unsigned long old_position; - char msg[256]; - - if (g->opened == FALSE) { - return FALSE; - } - - 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, sizeof (msg), "error %d writing global header for %s", errno, g->global_name); - m_fatal (msg); - } - - lseek (g->fd, old_position, SEEK_SET); - gbl_unlock (g); - - gbl_read_header (g, &g->header); - - return TRUE; -} /* gbl_write_header() */ - -int gbl_read_header(global_handle *g, global_header *h) -{ - unsigned long old_position; - char m[5] = GBL_MAGIC; - - - if (g->opened == FALSE) { - return GBL_HDR_NOTOPEN; - } - - gbl_lock (g, 1); - old_position = lseek (g->fd, 0, SEEK_CUR); - lseek (g->fd, 0, SEEK_SET); - - read (g->fd, h, sizeof (global_header)); - - lseek (g->fd, old_position, SEEK_SET); - gbl_unlock (g); - - if (strncmp (h->magic, m, 5) != 0) { - return GBL_HDR_BADMAGIC; - } - if (h->format_version != GBL_FORMAT_VERSION) { - return GBL_HDR_BADVERSION; - } - if (h->block_size != BLOCKLEN) { - return GBL_HDR_BADBLOCKSIZE; - } - - return GBL_HDR_OK; -} /* gbl_read_header() */ - -int gbl_update_tid(global_handle *g) -{ - global_header h; - - if (gbl_read_header (g, &h) != GBL_HDR_OK) { - return FALSE; - } - - h.last_transaction_id = jnl_tran_id; - - return gbl_write_header (g, &h); -} /* gbl_update_tid() */ - -int gbl_create(global_handle *g) -{ - while (1) { - errno = 0; - - if ((g->fd = creat (g->global_path, 0666)) != -1) break; - - if (errno == EMFILE || errno == ENFILE) { - gbl_close_all (); - continue; - } - - return PROTECT; - } - - g->opened = TRUE; - g->age = time (0L); - g->last_block = 0; - g->use_count = 1; - g->fast_path = 0; - - gbl_write_initial_header (g); - - return OK; -} /* gbl_create() */ - -short gbl_open(global_handle *g, short action) -{ - int result; - - if (g->opened == FALSE) { - gbl_cache_miss (g); - while (1) { - errno = 0; - g->fd = open (g->global_path, 2); - - if (g->fd != -1) break; - - switch (errno) { - case EINTR: - continue; - - case EMFILE: - case ENFILE: - gbl_close_all (); - continue; - } - - break; - } - - if (g->fd == -1) { - g->use_count = 0; - g->age = 0; - g->last_block = 0; - g->locked = FALSE; - g->opened = FALSE; - } - else { - g->opened = TRUE; - result = gbl_read_header (g, &g->header); - - 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; - } - else { - gbl_close (g); - set_io (UNIX); - - switch (result) { - - case GBL_HDR_BADMAGIC: - fprintf (stderr, "gbl_open: bad magic value in %s [FATAL]\n", g->global_name); - exit (1); - break; - - case GBL_HDR_BADVERSION: - fprintf (stderr, "gbl_open: global version is %d in %s (must be %d) [FATAL]\n", g->header.format_version, g->global_name, GBL_FORMAT_VERSION); - exit (1); - break; - - } - - return FALSE; - } - } - } - - return g->opened; - -} /* 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, BLOCKLEN); - 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 *g; - char global_name[256]; - int i; - struct stat dinf; - - i = 0; - while (key[i] != EOL) { - if ((global_name[i] = key[i]) == DELIM) break; - - i++; - } - global_name[i] = NUL; - - - for (g = global_handles_head; g != NULL; g = g->next) { - if (strncmp (g->global_name, global_name, 256) == 0) { - g->use_count++; - if (!lonelyflag) { - g->fast_path = 0; - } - - fstat (g->fd, &dinf); - if (g->age > dinf.st_mtime) { - g->fast_path = 2; - return g; - } - - g->age = time (0L); - g->fast_path = 0; - - return g; - } - } - g = (global_handle *) malloc (sizeof (global_handle)); - NULLPTRCHK(g,"gbl_open"); - - g->use_count = 1; - g->locked = FALSE; - g->age = time (0L); - g->last_read_time = 0; - g->last_block = 0; - g->opened = FALSE; - g->fd = 0; - 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); - gbl_path (key, g->global_path); - - g->next = global_handles_head; - global_handles_head = g; - - return g; -} /* gbl_handle() */ - - /* globals management */ /* 0 = set_sym 1 = get_sym */ @@ -710,109 +185,130 @@ global_handle *gbl_handle(char *key) * the file is *not* closed on return. since access is regulated by the * locking mechanism, that will not spell trouble. */ - + void global_bltin (short action, char *key, char *data) { - global_handle *g; - - unsigned long hdr_offset; - /* these must be static variables */ + + static short filedes; /* filedescr for global access */ static char filnam[256]; /* name of global/unix file */ /* the following vars may be */ /* static or dynamic */ + static unsigned long blknbr; /* block number */ + static unsigned long oldblk; static unsigned long newblk; static unsigned long other; static long j1; static long limit; static short typ; /* block type */ - static long keyl; /* length of compacted key */ - static long datal; /* length of data */ - static long olddatal; - static long offset; - static long found; - static long addr; /* address of key in 'block' */ - static long needed; /* new bytes needed to ins. stuff */ - static long ret_to; /* return code */ - static long kill_again; + static long keyl, /* length of compacted key */ + datal, /* length of data */ + olddatal, + offset, + found, + addr, /* address of key in 'block' */ + needed, /* new bytes needed to ins. stuff */ + ret_to, /* return code */ + kill_again; static char key1[256]; static char tmp1[256]; /* intermediate storage for op= */ static char block[BLOCKLEN]; static int getnflag; /* flag 1=$ZO-variable 0=$Q-function */ static int tryfast; /* try fast access if get_sym on */ - /* previous global */ + /* previous global */ + + struct stat dinf; /* get modification date */ + + long savj, + savch; /* saved j and ch for multiple pathes */ + register long int i, + j, + k, + ch; + long pathscan; /* flag for repeated scan of pathlist setting an undef global */ - int iresult; - - register long int i; - register long int j; - register long int k; - register long int ch; - j = 0; - hdr_offset = sizeof (global_header); - /* process optional limitations */ if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') { if ((i = glvnflag.one[0])) { /* number of significant chars */ + j = 0; while ((k = key[j]) != DELIM && k != EOL) { + if (j >= i) { + while ((k = key[++j]) != DELIM && k != EOL); + stcpy (&key[i], &key[j]); + break; } + j++; + } } if (glvnflag.one[1]) { /* upper/lower sensitivity */ + j = 0; + while ((k = key[j]) != DELIM && k != EOL) { + if (k >= 'a' && k <= 'z') key[j] = k - 32; + j++; + } } if ((i = glvnflag.one[2])) { + if (stlen (key) > i) { merr_raise (M75); return; } /* key length limit */ + } if ((i = glvnflag.one[3])) { /* subscript length limit */ - + j = 0; + while ((k = key[j++]) != DELIM && k != EOL); - + if (k == DELIM) { + k = 0; for (;;) { + k = key[j++]; + if (k == DELIM || k == EOL) { + if (k > i) { merr_raise (M75); return; } + k = 0; } + if (k == EOL) break; k++; } } - } } - if (action == getnext) { + getnflag = TRUE; varnam[0] = EOL; @@ -870,9 +366,106 @@ void global_bltin (short action, char *k } } - g = gbl_handle (key); - i = gbl_path (key, filnam); + 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; + } + } + + /* construct full UNIX filename */ + savj = 0; + savch = ch = EOL; + pathscan = TRUE; + nextpath: + k = 0; + j = savj; + + if (key[1] == '%' || key[1] == '$') { /* %-globals and SSVN backing storage, no explicit path */ + + if (gloplib[0] != EOL) { + + /* append % global access path */ + while ((ch = filnam[k++] = gloplib[j++]) != ':' && ch != EOL); + + } + + } + else if (key[1] != '/') { /* no explicit path specified */ + + if (glopath[0] != EOL) { + + /* append global access path */ + while ((ch = filnam[k++] = glopath[j++]) != ':' && ch != EOL); + + } + + } + + if (savj == 0 && ch == EOL) pathscan = FALSE; /* one path only: inhibit search */ + + if (k > 0) { + + if (k == 1 || (k == 2 && filnam[0] == '.')) { + k = 0; + } + else { + filnam[k - 1] = '/'; + } + + } + + savch = ch; + savj = j; + i = 0; + j = 0; + + while (key[i] != EOL) { + + if ((filnam[k] = key[i]) == DELIM) break; + + if (filnam[k] == '/') { + + j = i; + + if (k > i) { + i = 0; + j = 0; + k = 0; + + continue; + } + + } + + i++; + k++; + + } + + filnam[k] = NUL; /* NUL not EOL !!! */ + + /* if a unix directory is specified, reposition '^' */ + /* '^/usr/test' becomes '/usr/^test' */ + if (j > 0) { + + for (k = 0; k < j; k++) { + filnam[k] = filnam[k + 1]; + } + + filnam[j] = '^'; + + } + /* compact key to internal format: characters are shifted left */ /* delimiters become LSB of previous character */ /* test subscripts for being numeric or not */ @@ -934,8 +527,10 @@ void global_bltin (short action, char *k compactkey[k++] = ch << 1; } - else if (ch < SP || ch >= DEL) { - /* no CTRLs */ + else if (ch < SP || ch >= DEL) { + + /*no CTRLs */ + merr_raise (SBSCR); return; } @@ -1006,11 +601,93 @@ void global_bltin (short action, char *k compactkey[k] = g_EOL; + /* look whether file is already open */ + tryfast = FALSE; + ch = usage[i = j = inuse]; + + while (i < NO_GLOBLS) { + + k = 0; + + while (filnam[k] == oldfil[i][k]) { + + if (filnam[k++] == NUL) { + + filedes = olddes[i]; + + if (inuse == i && action == get_sym) { + + tryfast = TRUE; + + if (usage[i] != (-1)) usage[i]++; + if (lonelyflag) goto tfast2; + + fstat (filedes, &dinf); + + if (g_ages[i] > dinf.st_mtime) goto tfast2; + + g_ages[i] = time (0L); + + goto tfast0; + + } + + inuse = i; + + if (usage[i] != (-1)) usage[i]++; + + goto lock; + } + + } + + if (ch < 0 || (usage[i] >= 0 && usage[i] < ch)) ch = usage[j = i]; + + if (i++ == inuse) { + inuse = (-1); + i = 0; + } + + } + + inuse = j; + usage[j] = 1; + + /* close previous file */ + if ((filedes = olddes[j]) > 0) { + close (filedes); + olddes[j] = 0; + } + + strcpy (oldfil[j], filnam); /* save current filename */ + reopen: - gbl_open (g, action); - if (g->fd == -1) { + for (;;) { + + errno = 0; + + if ((filedes = open (filnam, 2)) != -1) break; + if (errno == EINTR) continue; + + if (errno == EMFILE || errno == ENFILE) { /* too many open files now */ + close_all_globals (); + + continue; + } + + break; + } + + if (filedes == -1) { + usage[inuse] = 0; + oldfil[inuse][0] = NUL; + olddes[inuse] = 0; + g_ages[inuse] = 0; + + if ((pathscan || errno != ENOENT) && (savch != EOL)) goto nextpath; /* try next access path */ + /* file not found */ if (action != set_sym) { @@ -1043,7 +720,15 @@ reopen: merr_raise (PROTECT); return; } - + + if (pathscan) { + savj = 0; + savch = ch = EOL; + pathscan = FALSE; + + goto nextpath; + } + if (setop) { tmp1[0] = EOL; @@ -1073,15 +758,35 @@ reopen: block[NRBLK + 2] = ROOT + 1; /* nr. of blocks */ /* create file, write_lock it and initialize root block */ - gbl_lock (g, 1); + for (;;) { + + errno = 0; + + if ((filedes = creat (filnam, 0666)) != -1) break; - if ((iresult = gbl_create (g)) != OK) { - merr_raise (iresult); + if (errno == EMFILE || errno == ENFILE) { + close_all_globals (); + continue; + } + + merr_raise (PROTECT); return; - } + } - gbl_write_block (g, ROOT, block); + if (lonelyflag == FALSE) locking (filedes, 1, 0L); + + for (;;) { + + errno = 0; + + lseek (filedes, ROOT * BLOCKLEN, 0); + write (filedes, block, BLOCKLEN); + + if (errno == 0) break; + panic (); + } + block[NRBLK] = 0; block[NRBLK + 1] = 0; block[NRBLK + 2] = ROOT; /* clear */ @@ -1096,164 +801,184 @@ reopen: for (;;) { errno = 0; - write (g->fd, block, BLOCKLEN); + write (filedes, block, BLOCKLEN); if (errno == 0) break; - lseek (g->fd, hdr_offset + ((ROOT + 1L) * BLOCKLEN), SEEK_SET); + lseek (filedes, (ROOT + 1L) * BLOCKLEN, 0); panic (); } - gbl_close (g); - gbl_unlock (g); - gbl_open (g, action); - + close (filedes); + + if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ + /* close new file, so other users can find it */ return; } + olddes[inuse] = filedes; /* save current filedescriptor */ + /* request global for exclusive use */ /* odd numbered actions get read access (get_sym,data,fra_order) 3 */ /* even ones read/write access (set_sym,kill_sym) 1 */ -/* temporarily disabled - lock: -*/ +lock: if (action == get_sym) { tfast0: - gbl_lock (g, 3); - - if (g->fast_path > 0) goto tfast1; /* try again last block */ + + if (lonelyflag == FALSE) locking (filedes, 3, 0L); + if (tryfast) goto tfast1; /* try again last block */ - blknbr = g->last_block = ROOT; /* start with ROOT block */ + blknbr = oldblk = ROOT; /* start with ROOT block */ 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 */ + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); - offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); - j = UNSIGN (block[0]); - i = 0; - stcpy0 (key1, &block[2], j); /* get first key */ +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 */ - - 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; - - } + 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 */ + +#endif /* VERSNEW */ + + if (j != ch) { /* keys have different length */ i += UNSIGN (block[i]); - i++; /* skip data */ - - } - - /* fast access failed. try normal path */ - if (tryfast) { - gbl_cache_miss (g); - goto tfast0; + i++; + + continue; + } - merr_raise (M7); - data[0] = EOL; + /* key1[j]=g_EOL; */ + j = ch; - goto quit; /* variable not found */ - } - else { - - if (g->fast_path > 0) { - gbl_cache_miss (g); - goto tfast0; - } + do { + j--; + } while (compactkey[j] == key1[j]); /* compare keys */ - if (typ == EMPTY) { - - if (blknbr == ROOT) { - gbl_close (g); - goto reopen; - } + + if (j < 0) { - merr_raise (DBDGD); + k = UNSIGN (block[i++]); + stcpy0 (data, &block[i], k); /* get value */ + data[k] = EOL1; /* append EOL */ + 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; - scanpblk (block, &addr, &found); - - 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) { + goto quit; /* variable not found */ + } + else { + + if (tryfast) { + tryfast = FALSE; + goto tfast0; + } + + if (typ == EMPTY) { + + if (blknbr == ROOT) { + close (filedes); + goto reopen; + } + merr_raise (DBDGD); goto quit; + } - addr += PLEN; /* skip data */ - g->last_block = blknbr; - g->fast_path = 1; + } + + scanpblk (block, &addr, &found); + + addr += UNSIGN (block[addr]) + 2; /* skip key */ + + if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == oldblk) { + merr_raise (DBDGD); + goto quit; + } + + addr += PLEN; /* skip data */ + oldblk = blknbr; - if (merr () == INRPT) goto quit; + if (merr () == INRPT) goto quit; } } /* end of get_sym */ - gbl_lock (g, action & 01 ? 3 : 1); - + + if (lonelyflag == FALSE) locking (filedes, (action & 01 ? 3 : 1), 0L); + /* a KILL on an unsubscripted global deletes the entire file */ if (action == kill_sym && compactkey[0] == g_EOL) { - /* note : UNIX does not tell other jobs that a file has been unlinked */ + lseek (filedes, ROOT, 0); + + /* note : UNIX does not tell other */ + block[BTYP] = EMPTY; /* jobs that a file has been unlinked */ + /* as long as they keep it open. */ /* so we mark this global as EMPTY */ - block[BTYP] = EMPTY; - - gbl_write_block (g, ROOT, block); - - gbl_unlock (g); - gbl_close (g); + write (filedes, block, BLOCKLEN); + + if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ + + close (filedes); + + olddes[inuse] = 0; + oldfil[inuse][0] = NUL; + usage[inuse] = 0; unlink (filnam); @@ -1263,7 +988,7 @@ tfast1: k_again: /* entry point for repeated kill operations */ /* scan tree for the proper position of key */ - blknbr = g->last_block = ROOT; /* start with ROOT block */ + blknbr = oldblk = ROOT; /* start with ROOT block */ trx = (-1); for (;;) { @@ -1275,8 +1000,10 @@ k_again: /* entry point for repeated traceblk[trx] = blknbr; traceadr[trx] = 0; - - gbl_read_block (g, blknbr, block); + + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); + typ = block[BTYP]; if (typ == DATA) { @@ -1287,7 +1014,7 @@ k_again: /* entry point for repeated if (typ == EMPTY) { if (blknbr == ROOT) { - gbl_close (g); + close (filedes); goto reopen; } @@ -1301,14 +1028,13 @@ k_again: /* entry point for repeated addr += UNSIGN (block[addr]); addr += 2; /* skip key */ - if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) { + if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == oldblk) { merr_raise (DBDGD); goto quit; } addr += PLEN; /* skip data */ - g->last_block = blknbr; - g->fast_path = 1; + oldblk = blknbr; } traceadr[trx] = addr; @@ -1319,7 +1045,7 @@ k_again: /* entry point for repeated datal = stlen (data); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (found != 2) { /* new entry */ @@ -1345,8 +1071,7 @@ k_again: /* entry point for repeated } -s10: - { +s10: { long len; /* insert key */ char key0[256]; @@ -1444,9 +1169,10 @@ s10: } - gbl_write_block (g, blknbr, block); + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); - if (traceadr[trx] == 0) update (g, compactkey, keyl); + if (traceadr[trx] == 0) update (filedes, compactkey, keyl); break; } @@ -1488,6 +1214,7 @@ s10: } else { + /* if (j1<0) */ /* we need more space */ if ((offset - j1) > DATALIM) { @@ -1497,7 +1224,7 @@ s10: goto splitd; } - s20: +s20: i = offset; k = addr + olddatal; @@ -1530,9 +1257,8 @@ s10: } stcpy0 (&block[++addr], data, (long) datal); - - gbl_write_block (g, blknbr, block); - + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); break; @@ -1557,13 +1283,14 @@ s10: /* get following entry, eventually in the next blk */ offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (addr >= offset) { if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) { - - gbl_read_block (g, blknbr, block); + + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); j1 = UNSIGN (block[0]); i = 0; @@ -1644,8 +1371,9 @@ s10: goto quit; } /* no next block */ - - gbl_read_block (g, blknbr, block); + + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); scandblk (block, &addr, &found); } @@ -1692,7 +1420,7 @@ s10: while (i < keyl) if (compactkey[i++] & 01) - j1++; + j1++; i = 0; j = 0; k = 0; @@ -1725,8 +1453,8 @@ s10: while ((ch = UNSIGN (scratch[i++])) != g_EOL) { ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -1801,11 +1529,12 @@ s10: goto quit; /* no next block */ } - gbl_read_block (g, blknbr, block); + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); addr = 0; offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); } } @@ -1824,7 +1553,8 @@ s10: goto quit; /* no next block */ } - gbl_read_block (g, blknbr, block); + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); addr = 0; } @@ -1872,8 +1602,8 @@ s10: while ((ch = UNSIGN (key0[i++])) != g_EOL) { ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -1949,8 +1679,8 @@ s10: } ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -1994,7 +1724,7 @@ s10: 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]); i = 0; @@ -2033,30 +1763,32 @@ s10: other = traceblk[--trx]; addr = traceadr[trx]; - - gbl_read_block (g, other, block); + + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); addr += UNSIGN (block[addr]); addr += (2 + PLEN); /* skip previous entry */ offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); traceadr[trx] = addr; if (addr < offset) break; traceadr[trx] = 0; traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); } trx = trxsav; - gbl_read_block (g, blknbr, block); + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); addr = 0; k = UNSIGN (block[0]); stcpy0 (key0, &block[2], k); @@ -2145,43 +1877,47 @@ s10: if ((begadr == 0) && (endadr == offset)) { /* block becomes empty */ long left, - right; + right; char block0[BLOCKLEN]; - p_empty: /* entry if pointer block goes empty */ +p_empty: /* entry if pointer block goes empty */ left = UNSIGN (block[LLPTR]) * 65536 + - UNSIGN (block[LLPTR + 1]) * 256 + - UNSIGN (block[LLPTR + 2]); + UNSIGN (block[LLPTR + 1]) * 256 + + UNSIGN (block[LLPTR + 2]); right = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); if (left) { - gbl_read_block (g, left, block0); + lseek (filedes, (long) left * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; - - gbl_write_block (g, left, block0); + + lseek (filedes, (long) left * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); } if (right) { - - gbl_read_block (g, right, block0); + + lseek (filedes, (long) right * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[LLPTR] = block[LLPTR]; block0[LLPTR + 1] = block[LLPTR + 1]; block0[LLPTR + 2] = block[LLPTR + 2]; - - gbl_write_block (g, right, block0); + + lseek (filedes, (long) right * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); } - b_free (g, blknbr); /* modify free list */ + b_free (filedes, blknbr); /* modify free list */ /* delete pointer */ /**************************/ @@ -2194,9 +1930,10 @@ s10: blknbr = traceblk[--trx]; addr = traceadr[trx]; - gbl_read_block (g, blknbr, block); + lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); freecnt = UNSIGN (block[addr]) + 2 + PLEN; /* delete key */ @@ -2206,19 +1943,18 @@ s10: if (blknbr == ROOT) { /* global went empty */ - + lseek (filedes, 0L, 0); /* note : UNIX does not tell other */ block[BTYP] = EMPTY; /* jobs that a file has been unlinked */ /* as long as they keep it open. */ /* so we mark this global as EMPTY */ - gbl_write_block (g, 0L, block); - - gbl_close (g); + write (filedes, block, BLOCKLEN); + close (filedes); unlink (filnam); - - gbl_unlock (g); + + if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ olddes[inuse] = 0; oldfil[inuse][0] = NUL; @@ -2239,12 +1975,13 @@ s10: for (i = offset; i < offset + freecnt; block[i++] = 0); - gbl_write_block (g, blknbr, block); + lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); if (addr == 0) { /* update of pointer */ traceadr[trx] = 0; - update (g, &block[2], (long) UNSIGN (block[0])); + update (filedes, &block[2], (long) UNSIGN (block[0])); } trx = trxsav; @@ -2269,29 +2006,28 @@ s10: j = block[begadr + 1]; k = 0; if (begadr) - while (key0[k] == key1[k]) - k++; /* new key_offset */ + while (key0[k] == key1[k]) + k++; /* new key_offset */ if (k < j) { - ch = j - k; /* space requirement */ - block[begadr] = i + ch; /* new key_length */ - block[begadr + 1] = k; /* new key_offset */ - i = offset; - j = i + ch; - offset = j; - begadr++; - while (i > begadr) - block[j--] = block[i--]; - stcpy0 (&block[begadr + 1], &key0[k], ch); + ch = j - k; /* space requirement */ + block[begadr] = i + ch; /* new key_length */ + block[begadr + 1] = k; /* new key_offset */ + i = offset; + j = i + ch; + offset = j; + begadr++; + while (i > begadr) + block[j--] = block[i--]; + stcpy0 (&block[begadr + 1], &key0[k], ch); } } block[OFFS] = offset / 256; block[OFFS + 1] = offset % 256; - - gbl_write_block (g, blknbr, block); - + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); if (addr < 3) { /* update of pointer */ - traceadr[trx] = 0; - update (g, &block[2], (long) UNSIGN (block[0])); + traceadr[trx] = 0; + update (filedes, &block[2], (long) UNSIGN (block[0])); } } @@ -2299,7 +2035,7 @@ s10: break; - zinv: +zinv: { long len; @@ -2313,11 +2049,12 @@ s10: data[0] = EOL1; goto quit; } /* no previous block */ - - gbl_read_block (g, blknbr, block); + + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); addr = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); } @@ -2392,8 +2129,8 @@ s10: while ((ch = UNSIGN (scratch[i++])) != g_EOL) { ch0 = (ch >= SP ? (ch >> 1) : /* 'string' chars */ - (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ - (ch >> 1) + SP)); /* '.' or '-' */ + (ch < 20 ? (ch >> 1) + '0' : /* 0...9 */ + (ch >> 1) + SP)); /* '.' or '-' */ if (ch0 == DEL) { @@ -2438,142 +2175,167 @@ s10: case zdata: /* nonstandard data function */ - { - long counties[128]; - char key0[256]; - int icnt, icnt0, len; + { + long counties[128]; + char key0[256]; + 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 */ - addr += UNSIGN (block[addr]); - addr += 2; /* skip key */ - addr += UNSIGN (block[addr]); - addr++; /* skip data */ + if (found == 2) { /* ... advance to next entry */ + addr += UNSIGN (block[addr]); + addr += 2; /* skip key */ + addr += UNSIGN (block[addr]); + addr++; /* skip data */ - counties[0] = 1L; - } + counties[0] = 1L; + } - offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); - icnt = 0; - i = 0; + offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); + icnt = 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; + len = i - 1; + i = 0; - while (i < addr) { /* compute offset complete key */ + while (i < addr) { /* compute offset complete key */ - icnt0 = UNSIGN (block[i++]); - icnt0 += (j = UNSIGN (block[i++])); + icnt0 = 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; - i += UNSIGN (block[i]); + key0[j] = g_EOL; + 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) { - break; /* no next block */ - } + if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) { + break; /* no next block */ + } - gbl_read_block (g, blknbr, block); + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); - addr = 0; - offset = UNSIGN (block[OFFS]) * 256 + + addr = 0; + offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]); - } + } - i = UNSIGN (block[addr++]); - i += (j = UNSIGN (block[addr++])); + i = 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++; /* skip data */ - icnt0 = 0; - i = 0; + addr += UNSIGN (block[addr]); + addr++; /* skip data */ + icnt0 = 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; - tmp1[0] = ','; + j = 1; + tmp1[0] = ','; - while (j <= i) { - lintstr (&tmp1[1], counties[j++]); - stcat (data, tmp1); - } + while (j <= i) { + lintstr (&tmp1[1], counties[j++]); + stcat (data, tmp1); + } - } + } - break; + break; case getinc: - { - int setopsav; + { + int setopsav; - setopsav = setop; - setop = '+'; - data[0] = '1'; - data[1] = EOL; + setopsav = setop; + setop = '+'; + data[0] = '1'; + data[1] = EOL; - global (set_sym, key, data); + global (set_sym, key, data); - setop = setopsav; + setop = setopsav; - return; - } + return; + } 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: @@ -2584,9 +2346,10 @@ quit: /* clean things up */ - lseek (g->fd, hdr_offset + ROOT, SEEK_SET); - gbl_unlock (g); - + lseek (filedes, ROOT, 0); + + if (lonelyflag == FALSE) locking (filedes, 0, 0L); /* unlock */ + return; @@ -2597,7 +2360,7 @@ splitd: /* split data block in two se /* 'addr' there I would like to insert, if possible (which is not) */ /* 'offset' filled up to this limit */ - getnewblk (g, &newblk); /* get a new block */ + getnewblk (filedes, &newblk); /* get a new block */ /* if we have to insert at the begin or end of a block */ /* we don't split - we just start a new block */ @@ -2605,8 +2368,8 @@ splitd: /* split data block in two se if (addr >= offset) { long right, - right1, - right2; + right1, + right2; right = UNSIGN (block[RLPTR]); right1 = UNSIGN (block[RLPTR + 1]); @@ -2615,7 +2378,8 @@ splitd: /* split data block in two se block[RLPTR + 1] = newblk % 65536 / 256; block[RLPTR + 2] = newblk % 256; - gbl_write_block (g, blknbr, block); + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); block[RLPTR] = right; block[RLPTR + 1] = right1; @@ -2627,21 +2391,23 @@ splitd: /* split data block in two se addr = 0; blknbr = newblk; - insert (g, compactkey, keyl, newblk); + insert (filedes, compactkey, keyl, newblk); /* up-date LL-PTR of RL-block */ if ((other = right * 65536 + right1 * 256 + right2)) { char block0[BLOCKLEN]; - gbl_read_block (g, other, block0); + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[LLPTR] = blknbr / 65536; block0[LLPTR + 1] = blknbr % 65536 / 256; block0[LLPTR + 2] = blknbr % 256; - gbl_write_block (g, other, block0); - + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); + } goto spltex; @@ -2658,8 +2424,9 @@ splitd: /* split data block in two se block[LLPTR + 1] = newblk % 65536 / 256; block[LLPTR + 2] = newblk % 256; - gbl_write_block (g, blknbr, block); - + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); + block[LLPTR] = left; block[LLPTR + 1] = left1; block[LLPTR + 2] = left2; @@ -2670,26 +2437,26 @@ splitd: /* split data block in two se blknbr = newblk; traceadr[trx] = (-1); /* inhibit second update of pointers */ - insert (g, compactkey, keyl, newblk); + insert (filedes, compactkey, keyl, newblk); if (addr < 3) { /* update of pointer */ traceadr[trx] = 0; - update (g, compactkey, keyl); + update (filedes, compactkey, keyl); } /* other is ***always*** zero !!! - * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block - * { char block0[BLOCKLEN]; - * lseek(filedes,(long)other*(long)(BLOCKLEN),0); - * read(filedes,block0,BLOCKLEN); - * block0[RLPTR ]=blknbr/65536; - * block0[RLPTR+1]=blknbr%65536/256; - * block0[RLPTR+2]=blknbr%256; - * lseek(filedes,(long)other*(long)(BLOCKLEN),0); - * write(filedes,block0,BLOCKLEN); - * } - */ + * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block + * { char block0[BLOCKLEN]; + * lseek(filedes,(long)other*(long)(BLOCKLEN),0); + * read(filedes,block0,BLOCKLEN); + * block0[RLPTR ]=blknbr/65536; + * block0[RLPTR+1]=blknbr%65536/256; + * block0[RLPTR+2]=blknbr%256; + * lseek(filedes,(long)other*(long)(BLOCKLEN),0); + * write(filedes,block0,BLOCKLEN); + * } + */ goto spltex; @@ -2771,8 +2538,8 @@ splitd: /* split data block in two se /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; @@ -2783,23 +2550,26 @@ splitd: /* split data block in two se block0[LLPTR + 1] = blknbr % 65536 / 256; block0[LLPTR + 2] = blknbr % 256; - gbl_write_block (g, newblk, block0); + lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); offset = limit; /* insert new block in pointer structure */ - insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - gbl_read_block (g, other, block0); + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - gbl_write_block (g, other, block0); + + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); } @@ -2808,8 +2578,8 @@ splitd: /* split data block in two se /* save old block away and make new block the current block */ /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; @@ -2820,26 +2590,28 @@ splitd: /* split data block in two se block0[LLPTR + 1] = blknbr % 65536 / 256; block0[LLPTR + 2] = blknbr % 256; - gbl_write_block (g, blknbr, block); - + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); stcpy0 (block, block0, (long) BLOCKLEN); traceadr[trx] = (addr -= limit); traceblk[trx] = (blknbr = newblk); /* insert new block in pointer structure */ - insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - gbl_read_block (g, other, block0); + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - gbl_write_block (g, other, block0); + + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); } @@ -2866,7 +2638,7 @@ spltex: * 'addr' there I would like to insert, if possible (which is not) * 'offset' filled up to this limit */ -static void splitp (global_handle *g, char *block, long *addr, long *offs, unsigned long *blknbr) +static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr) { char block0[BLOCKLEN]; @@ -2874,8 +2646,8 @@ static void splitp (global_handle *g, ch unsigned long newblk; unsigned long other; register int i, j; - - getnewblk (g, &newblk); /* get a new block */ + + getnewblk (filedes, &newblk); /* get a new block */ if (*blknbr == ROOT) { /* ROOT overflow is special */ @@ -2902,15 +2674,16 @@ static void splitp (global_handle *g, ch /* update number of blocks ! */ i = UNSIGN (block0[NRBLK]) * 65536 + - UNSIGN (block0[NRBLK + 1]) * 256 + - UNSIGN (block0[NRBLK + 2]) + 1; + UNSIGN (block0[NRBLK + 1]) * 256 + + UNSIGN (block0[NRBLK + 2]) + 1; block0[NRBLK] = i / 65536; block0[NRBLK + 1] = i % 65536 / 256; block0[NRBLK + 2] = i % 256; block0[BTYP] = POINTER; - gbl_write_block (g, ROOT, block0); + lseek (filedes, ROOT, 0); + write (filedes, block0, BLOCKLEN); /* shift trace_stack */ j = trx++; @@ -2927,7 +2700,7 @@ static void splitp (global_handle *g, ch traceblk[1] = newblk; *blknbr = newblk; - getnewblk (g, &newblk); /* get a new block */ + getnewblk (filedes, &newblk); /* get a new block */ } @@ -2969,8 +2742,8 @@ static void splitp (global_handle *g, ch /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; block0[RLPTR + 2] = block[RLPTR + 2]; @@ -2981,22 +2754,25 @@ static void splitp (global_handle *g, ch block0[LLPTR + 1] = (*blknbr) % 65536 / 256; block0[LLPTR + 2] = (*blknbr) % 256; - gbl_write_block (g, newblk, block0); + lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); (*offs) = limit; - insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - gbl_read_block (g, other, block0); + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - gbl_write_block (g, other, block0); + + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); } @@ -3005,8 +2781,8 @@ static void splitp (global_handle *g, ch /* update rightlink and leftlink pointers */ other = UNSIGN (block[RLPTR]) * 65536 + - UNSIGN (block[RLPTR + 1]) * 256 + - UNSIGN (block[RLPTR + 2]); + UNSIGN (block[RLPTR + 1]) * 256 + + UNSIGN (block[RLPTR + 2]); block0[RLPTR] = block[RLPTR]; block0[RLPTR + 1] = block[RLPTR + 1]; @@ -3020,25 +2796,27 @@ static void splitp (global_handle *g, ch (*addr) -= limit; (*offs) -= limit; - - gbl_write_block (g, *blknbr, block); + lseek (filedes, (long) (*blknbr) * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); stcpy0 (block, block0, (long) BLOCKLEN); (*blknbr) = newblk; - insert (g, &block0[2], (long) UNSIGN (block0[0]), newblk); + insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk); /* up-date LL-PTR of RL-block */ if (other != 0) { - gbl_read_block (g, other, block0); + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + read (filedes, block0, BLOCKLEN); block0[LLPTR] = newblk / 65536; block0[LLPTR + 1] = newblk % 65536 / 256; block0[LLPTR + 2] = newblk % 256; - - gbl_write_block (g, other, block0); + + lseek (filedes, (long) other * (long) (BLOCKLEN), 0); + write (filedes, block0, BLOCKLEN); } @@ -3053,22 +2831,23 @@ static void splitp (global_handle *g, ch * ins_key: key to be inserted * keyl: length of that key */ -static void update (global_handle *g, char *ins_key, long keyl) +static void update (short filedes, char *ins_key, long keyl) { long offset; long addr; unsigned long blknbr; char block[BLOCKLEN]; long i, j, k; - + while (traceadr[trx] == 0) { /* update of pointer blocks necessary */ if (--trx < 0) break; blknbr = traceblk[trx]; addr = traceadr[trx]; - - gbl_read_block (g, blknbr, block); + + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); { long oldkeyl; @@ -3079,7 +2858,7 @@ static void update (global_handle *g, ch j = oldkeyl - keyl; offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (j > 0) { /* surplus space */ @@ -3095,7 +2874,7 @@ static void update (global_handle *g, ch else if (j < 0) { /* we need more space */ /* block too small */ - if ((offset - j) > DATALIM) splitp (g, block, &addr, &offset, &blknbr); + if ((offset - j) > DATALIM) splitp (filedes, block, &addr, &offset, &blknbr); i = offset; offset -= j; @@ -3118,10 +2897,13 @@ static void update (global_handle *g, ch while (i < keyl) block[j++] = ins_key[i++]; /* block pointed to remains the same */ - gbl_write_block (g, blknbr, block); - } + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); - gbl_read_block (g, blknbr, block); + } + + lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); } @@ -3136,7 +2918,7 @@ static void update (global_handle *g, ch * key_len: length of that key * blknbr: key points to this block */ -static void insert (global_handle *g, char *ins_key, long key_len, unsigned long blknbr) /* insert pointer */ +static void insert (int filedes, char *ins_key, long key_len, unsigned long blknbr) /* insert pointer */ { unsigned long blk; char block[BLOCKLEN]; @@ -3145,15 +2927,16 @@ static void insert (global_handle *g, ch long needed; long addr; register int i, k; - + trxsav = trx--; blk = traceblk[trx]; addr = traceadr[trx]; - gbl_read_block (g, blk, block); + lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0); + read (filedes, block, BLOCKLEN); offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); if (traceadr[trx + 1] != (-1)) { addr += UNSIGN (block[addr]); @@ -3162,7 +2945,7 @@ static void insert (global_handle *g, ch needed = key_len + 2 + PLEN; - if ((offset + needed) > DATALIM) splitp (g, block, &addr, &offset, &blk); + if ((offset + needed) > DATALIM) splitp (filedes, block, &addr, &offset, &blk); /* insert key */ i = (offset += needed); @@ -3186,7 +2969,8 @@ static void insert (global_handle *g, ch block[i++] = blknbr % 65536 / 256; block[i] = blknbr % 256; - gbl_write_block (g, blk, block); + lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0); + write (filedes, block, BLOCKLEN); trx = trxsav; @@ -3198,33 +2982,37 @@ static void insert (global_handle *g, ch * filedes: global file descriptor * blknbr: block to be freed */ -static void b_free (global_handle *g, unsigned long blknbr) +static void b_free (short filedes, unsigned long blknbr) { char block0[BLOCKLEN]; unsigned long free; unsigned long other; long i; long offset; - + /* mark block as empty */ - gbl_read_block (g, blknbr, block0); - - block0[BTYP] = EMPTY; + lseek (filedes, (long) (blknbr) * BLOCKLEN, 0); + read (filedes, block0, BLOCKLEN); - gbl_write_block (g, blknbr, block0); + block0[BTYP] = EMPTY; + + lseek (filedes, (long) (blknbr) * BLOCKLEN, 0); + write (filedes, block0, BLOCKLEN); /* do we have a list of free blocks? */ - gbl_read_block (g, ROOT, block0); + lseek (filedes, ROOT, 0); + read (filedes, block0, BLOCKLEN); if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) { for (;;) { - - gbl_read_block (g, free, block0); + + lseek (filedes, (long) free * (long) BLOCKLEN, 0); + read (filedes, block0, BLOCKLEN); other = UNSIGN (block0[RLPTR]) * 65536 + - UNSIGN (block0[RLPTR + 1]) * 256 + - UNSIGN (block0[RLPTR + 2]); + UNSIGN (block0[RLPTR + 1]) * 256 + + UNSIGN (block0[RLPTR + 2]); if (other == 0) break; @@ -3240,8 +3028,8 @@ static void b_free (global_handle *g, un offset -= PLEN; other = UNSIGN (block0[offset]) * 65536 + - UNSIGN (block0[offset + 1]) * 256 + - UNSIGN (block0[offset + 2]); + UNSIGN (block0[offset + 1]) * 256 + + UNSIGN (block0[offset + 2]); block0[offset] = 0; block0[offset + 1] = 0; @@ -3251,8 +3039,9 @@ static void b_free (global_handle *g, un block0[RLPTR] = other / 65536; block0[RLPTR + 1] = other % 65536 / 256; block0[RLPTR + 2] = other % 256; - - gbl_write_block (g, free, block0); + + lseek (filedes, (long) free * (long) BLOCKLEN, 0); + write (filedes, block0, BLOCKLEN); for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */ @@ -3268,16 +3057,19 @@ static void b_free (global_handle *g, un } else { - getnewblk (g, &free); + + getnewblk (filedes, &free); /* set FBLK free blocks pointer */ - gbl_read_block (g, ROOT, block0); + lseek (filedes, ROOT, 0); + read (filedes, block0, BLOCKLEN); block0[FREE] = free / 65536; block0[FREE + 1] = free % 65536 / 256; block0[FREE + 2] = free % 256; - - gbl_write_block (g, ROOT, block0); + + lseek (filedes, ROOT, 0); + write (filedes, block0, BLOCKLEN); for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */ @@ -3292,7 +3084,8 @@ static void b_free (global_handle *g, un block0[OFFS] = offset / 256; block0[OFFS + 1] = offset % 256; - gbl_write_block (g, free, block0); + lseek (filedes, (long) free * (long) BLOCKLEN, 0); + write (filedes, block0, BLOCKLEN); return; } /* end of b_free() */ @@ -3365,7 +3158,7 @@ static void scandblk (char *block, long char key0[256]; offset = UNSIGN (block[OFFS]) * 256 + - UNSIGN (block[OFFS + 1]); + UNSIGN (block[OFFS + 1]); while (i < offset) { @@ -3412,21 +3205,23 @@ static void scandblk (char *block, long * filedes: global file descriptor * blknbr: number of new block */ -static void getnewblk (global_handle *g, unsigned long *blknbr) +static void getnewblk (int filedes, unsigned long *blknbr) { char nblock[BLOCKLEN]; unsigned long freeblks, no_of_blks; long other; long offset; - gbl_read_block (g, ROOT, nblock); + lseek (filedes, ROOT, 0); + read (filedes, nblock, BLOCKLEN); 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]); if (freeblks) { - - gbl_read_block (g, freeblks, nblock); + + lseek (filedes, (long) (freeblks) * BLOCKLEN, 0); + read (filedes, nblock, BLOCKLEN); offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]); @@ -3438,24 +3233,28 @@ static void getnewblk (global_handle *g, /* update RL-block, if any */ if (other) { - gbl_read_block (g, other, nblock); + lseek (filedes, (long) (other) * BLOCKLEN, 0); + read (filedes, nblock, BLOCKLEN); nblock[LLPTR] = 0; nblock[LLPTR + 1] = 0; nblock[LLPTR + 2] = 0; - - gbl_write_block (g, other, nblock); + + lseek (filedes, (long) (other) * BLOCKLEN, 0); + write (filedes, nblock, BLOCKLEN); } /* update ROOT block */ - gbl_read_block (g, ROOT, nblock); + lseek (filedes, ROOT, 0); + read (filedes, nblock, BLOCKLEN); nblock[FREE] = other / 65536; nblock[FREE + 1] = other % 65536 / 256; nblock[FREE + 2] = other % 256; - - gbl_write_block (g, ROOT, nblock); + + lseek (filedes, ROOT, 0); + write (filedes, nblock, BLOCKLEN); return; @@ -3467,8 +3266,9 @@ static void getnewblk (global_handle *g, nblock[offset + 1] = 0; nblock[OFFS] = offset / 256; nblock[OFFS + 1] = offset % 256; - - gbl_write_block (g, freeblks, nblock); + + lseek (filedes, (long) (freeblks) * BLOCKLEN, 0); + write (filedes, nblock, BLOCKLEN); return; @@ -3479,12 +3279,24 @@ static void getnewblk (global_handle *g, nblock[NRBLK] = no_of_blks / 65536; nblock[NRBLK + 1] = no_of_blks % 65536 / 256; nblock[NRBLK + 2] = no_of_blks % 256; - - gbl_write_block (g, ROOT, nblock); + + lseek (filedes, ROOT, 0); + write (filedes, nblock, BLOCKLEN); *blknbr = no_of_blks; + + for (;;) { - gbl_write_block (g, no_of_blks, nblock); + errno = 0; + + lseek (filedes, (long) (no_of_blks) * BLOCKLEN, 0); + write (filedes, nblock, BLOCKLEN); + + if (errno == 0) break; + + panic (); + + } return; @@ -3613,6 +3425,7 @@ static short int g_collate (char *t) /* * test whether 'str' is canonical */ +//static short int g_numeric (char *str) short g_numeric (char *str) { register int ptr = 0, ch; @@ -3655,19 +3468,30 @@ short g_numeric (char *str) } /* end g_numeric() */ - -/* DEPRECATED: use gbl_close_all() instead */ void close_all_globals (void) { - gbl_close_all (); - + register int i; + + for (i = 0; i < NO_GLOBLS; i++) { + + if (oldfil[i][0] != NUL) { + + close (olddes[i]); + + usage[i] = 0; + olddes[i] = 0; + oldfil[i][0] = NUL; + + } + + } + return; + } /* end close_all_globals() */ static void panic (void) -{ - printf ("write failed\r\n"); - +{ printf ("\033[s\033[25H\033[5;7mwrite needs more disk space immediately\007"); sleep (1); printf ("\033[m\007\033[2K\033[u"); @@ -3687,46 +3511,15 @@ static void panic (void) void gbl_dump_stat(void) { - global_handle *g; - int ct; - int miss_pct; - int hit_pct; - unsigned long access_total; - unsigned long hit_total; - unsigned long mem_reads_total; - - mem_reads_total = 0; - 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) { - 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 ("\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); + register int i; + + printf ("FreeM Global Statistics [PID %d]\r\n", pid); + + printf ("%-10s%-20s%s\r\n", "USECT", "AGE", "FILE"); + printf ("%-10s%-20s%s\r\n", "=====", "===", "===="); + + for (i = 0; i < NO_GLOBLS; i++) { + printf ("%-10d%-20ld%s\r\n", usage[i], g_ages[i], oldfil[i]); + } }