[BACK]Return to global_bltin.c CVS log [TXT] [DIR] Up to [Coherent Logic Development] / freem / src

Diff for /freem/src/global_bltin.c between versions 1.18 and 1.25

version 1.18, 2025/04/11 16:23:18 version 1.25, 2025/05/02 16:30:16
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.18  2025/04/11 16:23:18  snw   *   Revision 1.25  2025/05/02 16:30:16  snw
  *   Avoid re-reading the same block consecutively when possible   *   Fix broken build due to time issues
  *   *
  *   Revision 1.17  2025/04/11 14:21:03  snw   *   Revision 1.24  2025/04/28 14:52:54  snw
  *   Make all but one of the read/write calls in global_bltin use gbl_read_block or gbl_write_block   *   Temporarily revert global handler refactor and fix reference regression in xecline
  *  
  *   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.7  2025/03/24 04:13:11  snw   *   Revision 1.7  2025/03/24 04:13:11  snw
  *   Replace action macro dat with fra_dat to avoid symbol conflict on OS/2   *   Replace action macro dat with fra_dat to avoid symbol conflict on OS/2
Line 79 Line 52
 #include <fcntl.h>  #include <fcntl.h>
 #include <unistd.h>  #include <unistd.h>
 #include <string.h>  #include <string.h>
 #include <stdlib.h>  #if defined(USE_SYS_TIME_H) && !defined(MSDOS) && !defined(__osf__)
   # include <sys/time.h>
   #else
   # include <time.h> 
   #endif
   
 #include <errno.h>  #include <errno.h>
   
   
 #include "mpsdef.h"  #include "mpsdef.h"
 #include "journal.h"  
 #include "global_bltin.h"  
   
 global_handle *global_handles_head;  static void b_free (short filedes, unsigned long blknbr);
 unsigned long gbl_cache_misses = 0;  static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr);
 unsigned long gbl_cache_hits = 0;  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 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 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 (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_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);
Line 141  static void panic (void); Line 115  static void panic (void);
 #define BOTTOM   6  #define BOTTOM   6
 #define DATA     8  #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__) && !defined(__linux__)
  long time ();   long time ();
 #endif  #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++;  
   
     fstat (g->fd, &gstat);      
     if (!g->locked) gbl_lock (g, 1);  
               
       
     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++;  
         g->last_read_time = time (0L);  
         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->last_read_time = time (0L);  
         g->cached_block_num = blocknum;  
           
         g->last_block = blocknum;  
         g->use_count++;  
         g->read_ops++;  
     }  
       
     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 */  /* globals management */
           
 /* 0 = set_sym      1 = get_sym */  /* 0 = set_sym      1 = get_sym */
Line 703  global_handle *gbl_handle(char *key) Line 193  global_handle *gbl_handle(char *key)
  * the file is *not* closed on return. since access is regulated by the   * the file is *not* closed on return. since access is regulated by the
  * locking mechanism, that will not spell trouble.   * locking mechanism, that will not spell trouble.
  */   */
    
 void global_bltin (short action, char *key, char *data)  void global_bltin (short action, char *key, char *data)
 {  {
   
     global_handle *g;  
   
     unsigned long hdr_offset;  
       
     /* these must be static variables */      /* these must be static variables */
   
       static short filedes;               /* filedescr for global access */
     static char filnam[256];            /* name of global/unix file */      static char filnam[256];            /* name of global/unix file */
   
     /* the following vars may be */      /* the following vars may be */
     /* static or dynamic */      /* static or dynamic */
   
     static unsigned long blknbr;        /* block number */      static unsigned long blknbr;        /* block number */
       static unsigned long oldblk;
     static unsigned long newblk;      static unsigned long newblk;
     static unsigned long other;      static unsigned long other;
     static long j1;      static long j1;
     static long limit;      static long limit;
     static short typ;                   /* block type */      static short typ;                   /* block type */
     static long keyl;                   /* length of compacted key */      static long keyl,                   /* length of compacted key */
     static long datal;                  /* length of data */                  datal,                  /* length of data */
     static long olddatal;                  olddatal,
     static long offset;                  offset,
     static long found;                  found,
     static long addr;                   /* address of key in 'block' */                  addr,                   /* address of key in 'block' */
     static long needed;                 /* new bytes needed to ins. stuff */                  needed,                 /* new bytes needed to ins. stuff */
     static long ret_to;                 /* return code */                  ret_to,                 /* return code */
     static long kill_again;                  kill_again;
     static char key1[256];      static char key1[256];
     static char tmp1[256];              /* intermediate storage for op= */      static char tmp1[256];              /* intermediate storage for op= */
     static char block[BLOCKLEN];      static char block[BLOCKLEN];
Line 738  void global_bltin (short action, char *k Line 228  void global_bltin (short action, char *k
     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;      struct stat dinf;                   /* get modification date */
       
     register long int i;      long    savj,
     register long int j;      savch;                      /* saved j and ch for multiple pathes */
     register long int k;      register long int i,
     register long int ch;      j,
       k,
       ch;
       long    pathscan;                   /* flag for repeated scan of pathlist setting an undef global */
   
   
     j = 0;  
       
     hdr_offset = sizeof (global_header);  
       
     /* process optional limitations */      /* process optional limitations */
     if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {      if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {
   
Line 825  void global_bltin (short action, char *k Line 315  void global_bltin (short action, char *k
         }          }
     }      }
   
   
     if (action == getnext) {      if (action == getnext) {
   
         getnflag = TRUE;          getnflag = TRUE;
         varnam[0] = EOL;          varnam[0] = EOL;
                   
Line 900  void global_bltin (short action, char *k Line 390  void global_bltin (short action, char *k
         }          }
     }      }
   
     g = gbl_handle (key);          /* construct full UNIX filename */
     i = gbl_path (key, filnam);      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 */      /* compact key to internal format: characters are shifted left */
     /* delimiters become LSB of previous character                 */      /* delimiters become LSB of previous character                 */
     /* test subscripts for being numeric or not                    */      /* test subscripts for being numeric or not                    */
Line 1038  void global_bltin (short action, char *k Line 609  void global_bltin (short action, char *k
   
     compactkey[k] = g_EOL;      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:  reopen:
   
     gbl_open (g, action);      for (;;) {
     if (g->fd == -1) {  
           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 */          /* file not found */
         if (action != set_sym) {          if (action != set_sym) {
                           
Line 1075  reopen: Line 728  reopen:
             merr_raise (PROTECT);              merr_raise (PROTECT);
             return;              return;
         }          }
           
           if (pathscan) {
               savj = 0;
               savch = ch = EOL;
               pathscan = FALSE;
   
               goto nextpath;
           }
   
         if (setop) {          if (setop) {
                           
             tmp1[0] = EOL;              tmp1[0] = EOL;
Line 1105  reopen: Line 766  reopen:
         block[NRBLK + 2] = ROOT + 1;    /* nr. of blocks */          block[NRBLK + 2] = ROOT + 1;    /* nr. of blocks */
   
         /* create file, write_lock it and initialize root block */          /* 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) {              if (errno == EMFILE || errno == ENFILE) {
             merr_raise (iresult);                  close_all_globals ();
                   continue;
               }
   
               merr_raise (PROTECT);
             return;              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] = 0;
         block[NRBLK + 1] = 0;          block[NRBLK + 1] = 0;
         block[NRBLK + 2] = ROOT;        /* clear */          block[NRBLK + 2] = ROOT;        /* clear */
Line 1128  reopen: Line 809  reopen:
         for (;;) {          for (;;) {
   
             errno = 0;              errno = 0;
             write (g->fd, block, BLOCKLEN);              write (filedes, block, BLOCKLEN);
                           
             if (errno == 0) break;              if (errno == 0) break;
                           
             lseek (g->fd, hdr_offset + ((ROOT + 1L) * BLOCKLEN), SEEK_SET);              lseek (filedes, (ROOT + 1L) * BLOCKLEN, 0);
             panic ();              panic ();
   
         }          }
   
         gbl_close (g);          close (filedes);
         gbl_unlock (g);          
         gbl_open (g, action);          if (lonelyflag == FALSE) locking (filedes, 0, 0L);      /* unlock */
           
         /* close new file, so other users can find it */          /* close new file, so other users can find it */
         return;          return;
     }      }
   
       olddes[inuse] = filedes;            /* save current filedescriptor */
   
     /* request global for exclusive use                            */      /* request global for exclusive use                            */
     /* 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 */
   
 /* temporarily disabled      lock:
    lock:  
 */  
   
     if (action == get_sym) {      if (action == get_sym) {
   
     tfast0:  tfast0:
         gbl_lock (g, 3);  
                   if (lonelyflag == FALSE) locking (filedes, 3, 0L);        
         if (g->fast_path > 0) goto tfast1;              /* try again last block */          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 (;;) {          for (;;) {
   
   
         tfast1:  tfast1:
             gbl_read_block (g, blknbr, block);  
   
 /* temporarily disabled              lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
    tfast2:              read (filedes, block, BLOCKLEN);
 */  
             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 */  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! */              ch = keyl;          /* ch is a register! */
                               
                 while (i < offset) {              while (i < offset) {
                                   
                     j = UNSIGN (block[i++]);    /* length of key - offset */                  j = UNSIGN (block[i++]);        /* length of key - offset */
                     k = UNSIGN (block[i++]);    /* offset into previous entry */                  k = UNSIGN (block[i++]);        /* offset into previous entry */
                       
                     j += k;  #ifdef VERSNEW
                       
                     while (k < j) key1[k++] = block[i++];               /* get key */                  stcpy0 (&key0[k], &block[i], j);
                                       i += j;
                     if (j != ch) {      /* keys have different length */                  j += k;
                           
                         i += UNSIGN (block[i]);  #else
                         i++;  
                                           j += k;
                         continue;              
                                           while (k < j) key1[k++] = block[i++];           /* get key */
                     }  
                       #endif /* VERSNEW */
                     j = ch;  
                                       if (j != ch) {  /* keys have different length */
                     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++;                /* skip data */                      i++;
                       
                 }                      continue;
                   
                 /* fast access failed. try normal path */  
                 if (tryfast) {  
                     gbl_cache_miss (g);  
                     goto tfast0;  
                 }                  }
   
                 merr_raise (M7);                  /* key1[j]=g_EOL; */
                 data[0] = EOL;                  j = ch;
                                   
                 goto quit;              /* variable not found */                  do {
             }                       j--;
             else {                  } while (compactkey[j] == key1[j]);             /* compare keys */
                                   
                 if (g->fast_path > 0) {  
                     gbl_cache_miss (g);                  if (j < 0) {
                     goto tfast0;  
                 }  
                   
                 if (typ == EMPTY) {  
                       
                     if (blknbr == ROOT) {  
                         gbl_close (g);  
                         goto reopen;  
                     }  
                                           
                     merr_raise (DBDGD);                      k = UNSIGN (block[i++]);
                       stcpy0 (data, &block[i], k);        /* get value */
                       data[k] = EOL1;     /* append EOL */
   
                     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;
                           
             scanpblk (block, &addr, &found);              goto quit;          /* variable not found */
                       } 
             addr += UNSIGN (block[addr]) + 2;   /* skip key */          else {
                       
             if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {              if (tryfast) {
                   tryfast = FALSE;
                   goto tfast0;
               }
   
               if (typ == EMPTY) {
                   
                   if (blknbr == ROOT) {
                       close (filedes);
                       goto reopen;
                   }
   
                   merr_raise (DBDGD);
                   goto quit;
   
               }
   
           }
   
           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);              merr_raise (DBDGD);
             goto quit;              goto quit;
         }          }
   
         addr += PLEN;           /* skip data */          addr += PLEN;           /* skip data */
         g->last_block = blknbr;          oldblk = blknbr;
         g->fast_path = 1;  
                   
         if (merr () == INRPT) goto quit;          if (merr () == INRPT) goto quit;
   
         }          }
     }                                   /* end of get_sym */      }                                   /* 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 */      /* 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) {
                   
         /* 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.      */          /* as long as they keep it open.      */
         /* so we mark this global as EMPTY    */          /* so we mark this global as EMPTY    */
         block[BTYP] = EMPTY;                      write (filedes, block, BLOCKLEN);
           
         gbl_write_block (g, ROOT, block);          if (lonelyflag == FALSE) locking (filedes, 0, 0L);      /* unlock */
           
         gbl_unlock (g);          close (filedes);
         gbl_close (g);          
           olddes[inuse] = 0;
           oldfil[inuse][0] = NUL;
           usage[inuse] = 0;
                   
         unlink (filnam);          unlink (filnam);
                   
Line 1295  reopen: Line 996  reopen:
 k_again:                                /* entry point for repeated kill operations */  k_again:                                /* entry point for repeated kill operations */
   
     /* scan tree for the proper position of key */      /* 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);      trx = (-1);
   
     for (;;) {      for (;;) {
Line 1307  k_again:    /* entry point for repeated Line 1008  k_again:    /* entry point for repeated
   
         traceblk[trx] = blknbr;          traceblk[trx] = blknbr;
         traceadr[trx] = 0;          traceadr[trx] = 0;
           
         gbl_read_block (g, blknbr, block);          lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
           read (filedes, block, BLOCKLEN);
           
         typ = block[BTYP];          typ = block[BTYP];
                   
         if (typ == DATA) {          if (typ == DATA) {
Line 1319  k_again:    /* entry point for repeated Line 1022  k_again:    /* entry point for repeated
         if (typ == EMPTY) {          if (typ == EMPTY) {
   
             if (blknbr == ROOT) {              if (blknbr == ROOT) {
                 gbl_close (g);                  close (filedes);
                 goto reopen;                  goto reopen;
             }              }
   
Line 1333  k_again:    /* entry point for repeated Line 1036  k_again:    /* entry point for repeated
         addr += UNSIGN (block[addr]);          addr += UNSIGN (block[addr]);
         addr += 2;                      /* skip key */          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);              merr_raise (DBDGD);
             goto quit;              goto quit;
         }          }
   
         addr += PLEN;                   /* skip data */          addr += PLEN;                   /* skip data */
         g->last_block = blknbr;          oldblk = blknbr;
         g->fast_path = 1;  
     }      }
   
     traceadr[trx] = addr;      traceadr[trx] = addr;
Line 1475  s10:            { Line 1177  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;                  break;
             }              }
Line 1519  s10:            { Line 1222  s10:            {
   
                 }                   } 
                 else {                                    else {                  
                       /* if (j1<0) */
                     /* we need more space */                       /* we need more space */ 
   
                     if ((offset - j1) > DATALIM) {                      if ((offset - j1) > DATALIM) {
Line 1561  s20: Line 1265  s20:
             }              }
           
             stcpy0 (&block[++addr], data, (long) datal);              stcpy0 (&block[++addr], data, (long) datal);
               lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
             gbl_write_block (g, blknbr, block);              write (filedes, block, BLOCKLEN);
               
             break;              break;
   
   
Line 1593  s20: Line 1296  s20:
                 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]))) {
                       
                         gbl_read_block (g, blknbr, block);                          lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                           read (filedes, block, BLOCKLEN);
                         j1 = UNSIGN (block[0]);                          j1 = UNSIGN (block[0]);
                                           
                         i = 0;                          i = 0;
Line 1675  s20: Line 1379  s20:
                                   
                     goto quit;                      goto quit;
                 }       /* no next block */                  }       /* no next block */
                   
                 gbl_read_block (g, blknbr, block);                  lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                   read (filedes, block, BLOCKLEN);
                 scandblk (block, &addr, &found);                  scandblk (block, &addr, &found);
   
             }               } 
Line 1832  s20: Line 1537  s20:
                         goto quit;              /* no next block */                          goto quit;              /* no next block */
                     }                      }
   
                     gbl_read_block (g, blknbr, block);                      lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                       read (filedes, block, BLOCKLEN);
   
                     addr = 0;                      addr = 0;
                     offset = UNSIGN (block[OFFS]) * 256 +                      offset = UNSIGN (block[OFFS]) * 256 +
Line 1855  s20: Line 1561  s20:
                     goto quit;          /* no next block */                      goto quit;          /* no next block */
                 }                  }
   
                 gbl_read_block (g, blknbr, block);                  lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                   read (filedes, block, BLOCKLEN);
                                   
                 addr = 0;                  addr = 0;
             }               } 
Line 2064  killo:    /* entry from killone section Line 1771  killo:    /* entry from killone section
   
                         other = traceblk[--trx];                          other = traceblk[--trx];
                         addr = traceadr[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 += UNSIGN (block[addr]);
                         addr += (2 + PLEN);     /* skip previous entry */                          addr += (2 + PLEN);     /* skip previous entry */
Line 2084  killo:    /* entry from killone section Line 1792  killo:    /* entry from killone section
   
                     trx = trxsav;                      trx = trxsav;
   
                     gbl_read_block (g, blknbr, block);                      lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                       read (filedes, block, BLOCKLEN);
   
                     offset = UNSIGN (block[OFFS]) * 256 +                      offset = UNSIGN (block[OFFS]) * 256 +
                     UNSIGN (block[OFFS + 1]);                      UNSIGN (block[OFFS + 1]);
Line 2190  p_empty:  /* entry if pointer block goes Line 1899  p_empty:  /* entry if pointer block goes
   
                     if (left) {                      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] = 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];
                           
                         gbl_write_block (g, left, block0);                          lseek (filedes, (long) left * (long) (BLOCKLEN), 0);
                           write (filedes, block0, BLOCKLEN);
   
                     }                      }
   
                     if (right) {                      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] = 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];
                           
                         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 */                      /* delete pointer */
                     /**************************/                      /**************************/
Line 2225  p_empty:  /* entry if pointer block goes Line 1938  p_empty:  /* entry if pointer block goes
                         blknbr = traceblk[--trx];                          blknbr = traceblk[--trx];
                         addr = traceadr[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 +                          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;
Line 2237  p_empty:  /* entry if pointer block goes Line 1951  p_empty:  /* entry if pointer block goes
   
                             if (blknbr == ROOT) {       /* global went empty */                              if (blknbr == ROOT) {       /* global went empty */
   
                                   lseek (filedes, 0L, 0);
                                                   
                                 /* 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    */
                                 gbl_write_block (g, 0L, block);                                  write (filedes, block, BLOCKLEN);
                                   close (filedes);
                                 gbl_close (g);  
                                 unlink (filnam);                                  unlink (filnam);
                           
                                 gbl_unlock (g);                                  if (lonelyflag == FALSE) locking (filedes, 0, 0L);      /* unlock */
   
                                 olddes[inuse] = 0;                                  olddes[inuse] = 0;
                                 oldfil[inuse][0] = NUL;                                  oldfil[inuse][0] = NUL;
Line 2270  p_empty:  /* entry if pointer block goes Line 1983  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);
   
                         gbl_write_block (g, blknbr, block);                          lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0);
                           write (filedes, block, BLOCKLEN);
   
                         if (addr == 0) {        /* update of pointer */                          if (addr == 0) {        /* update of pointer */
                             traceadr[trx] = 0;                              traceadr[trx] = 0;
                                                           
                             update (g, &block[2], (long) UNSIGN (block[0]));                              update (filedes, &block[2], (long) UNSIGN (block[0]));
                         }                          }
   
                         trx = trxsav;                          trx = trxsav;
Line 2317  p_empty:  /* entry if pointer block goes Line 2031  p_empty:  /* entry if pointer block goes
                 }                  }
                 block[OFFS] = offset / 256;                  block[OFFS] = offset / 256;
                 block[OFFS + 1] = offset % 256;                  block[OFFS + 1] = offset % 256;
                   lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                 gbl_write_block (g, blknbr, block);                  write (filedes, block, BLOCKLEN);
   
                 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 (filedes, &block[2], (long) UNSIGN (block[0]));
                 }                  }
             }              }
   
Line 2344  zinv: Line 2057  zinv:
                         data[0] = EOL1;                          data[0] = EOL1;
                         goto quit;                          goto quit;
                     }                   /* no previous block */                      }                   /* 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 +                      addr = UNSIGN (block[OFFS]) * 256 +
                     UNSIGN (block[OFFS + 1]);                      UNSIGN (block[OFFS + 1]);
Line 2524  zinv: Line 2238  zinv:
                             break;              /* no next block */                              break;              /* no next block */
                         }                          }
   
                         gbl_read_block (g, blknbr, block);                          lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                           read (filedes, block, BLOCKLEN);
                                                   
                         addr = 0;                          addr = 0;
                         offset = UNSIGN (block[OFFS]) * 256 +                          offset = UNSIGN (block[OFFS]) * 256 +
Line 2639  quit: Line 2354  quit:
           
     /* clean things up */      /* clean things up */
   
     lseek (g->fd, hdr_offset + ROOT, SEEK_SET);      lseek (filedes, ROOT, 0);
     gbl_unlock (g);  
           if (lonelyflag == FALSE) locking (filedes, 0, 0L);  /* unlock */
   
     return;      return;
   
   
Line 2652  splitd:    /* split data block in two se Line 2368  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, &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  */      /* 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 2670  splitd:    /* split data block in two se Line 2386  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;
   
         gbl_write_block (g, blknbr, block);          lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
           write (filedes, block, BLOCKLEN);
                   
         block[RLPTR] = right;          block[RLPTR] = right;
         block[RLPTR + 1] = right1;          block[RLPTR + 1] = right1;
Line 2682  splitd:    /* split data block in two se Line 2399  splitd:    /* split data block in two se
         addr = 0;          addr = 0;
         blknbr = newblk;          blknbr = newblk;
                   
         insert (g, compactkey, keyl, newblk);          insert (filedes, compactkey, keyl, newblk);
                   
         /* up-date LL-PTR of RL-block */          /* up-date LL-PTR of RL-block */
         if ((other = right * 65536 + right1 * 256 + right2)) {          if ((other = right * 65536 + right1 * 256 + right2)) {
                   
             char    block0[BLOCKLEN];              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] = blknbr / 65536;
             block0[LLPTR + 1] = blknbr % 65536 / 256;              block0[LLPTR + 1] = blknbr % 65536 / 256;
             block0[LLPTR + 2] = blknbr % 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;          goto spltex;
Line 2713  splitd:    /* split data block in two se Line 2432  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;
   
         gbl_write_block (g, blknbr, block);          lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
           write (filedes, 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 2725  splitd:    /* split data block in two se Line 2445  splitd:    /* split data block in two se
         blknbr = newblk;          blknbr = newblk;
         traceadr[trx] = (-1);           /* inhibit second update of pointers */          traceadr[trx] = (-1);           /* inhibit second update of pointers */
                   
         insert (g, compactkey, keyl, newblk);          insert (filedes, compactkey, keyl, newblk);
                   
         if (addr < 3) {                 /* update of pointer */          if (addr < 3) {                 /* update of pointer */
             traceadr[trx] = 0;              traceadr[trx] = 0;
                           
             update (g, compactkey, keyl);              update (filedes, compactkey, keyl);
         }          }
   
         /* other is ***always*** zero !!!          /* other is ***always*** zero !!!
Line 2838  splitd:    /* split data block in two se Line 2558  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;
   
             gbl_write_block (g, newblk, block0);              lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);
               write (filedes, block0, BLOCKLEN);
                   
             offset = limit;              offset = limit;
             /* insert new block in pointer structure */              /* 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 */              /* up-date LL-PTR of RL-block */
             if (other != 0) {              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] = newblk / 65536;
                 block0[LLPTR + 1] = newblk % 65536 / 256;                  block0[LLPTR + 1] = newblk % 65536 / 256;
                 block0[LLPTR + 2] = newblk % 256;                  block0[LLPTR + 2] = newblk % 256;
                   
                 gbl_write_block (g, other, block0);                  lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
                   write (filedes, block0, BLOCKLEN);
   
             }              }
   
Line 2875  splitd:    /* split data block in two se Line 2598  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;
   
             gbl_write_block (g, blknbr, block);              lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
                           write (filedes, block, BLOCKLEN);
             stcpy0 (block, block0, (long) BLOCKLEN);              stcpy0 (block, block0, (long) BLOCKLEN);
   
             traceadr[trx] = (addr -= limit);              traceadr[trx] = (addr -= limit);
             traceblk[trx] = (blknbr = newblk);              traceblk[trx] = (blknbr = newblk);
                           
             /* insert new block in pointer structure */              /* 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 */              /* up-date LL-PTR of RL-block */
             if (other != 0) {              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] = newblk / 65536;
                 block0[LLPTR + 1] = newblk % 65536 / 256;                  block0[LLPTR + 1] = newblk % 65536 / 256;
                 block0[LLPTR + 2] = newblk % 256;                  block0[LLPTR + 2] = newblk % 256;
                   
                 gbl_write_block (g, other, block0);                  lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
                   write (filedes, block0, BLOCKLEN);
   
             }              }
   
Line 2921  spltex: Line 2646  spltex:
  *   '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
  */   */
 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];      char block0[BLOCKLEN];
Line 2929  static void splitp (global_handle *g, ch Line 2654  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;
       
     getnewblk (g, &newblk);     /* get a new block */      getnewblk (filedes, &newblk);       /* get a new block */
           
     if (*blknbr == ROOT) {              /* ROOT overflow is special */      if (*blknbr == ROOT) {              /* ROOT overflow is special */
   
Line 2965  static void splitp (global_handle *g, ch Line 2690  static void splitp (global_handle *g, ch
         block0[NRBLK + 2] = i % 256;          block0[NRBLK + 2] = i % 256;
         block0[BTYP] = POINTER;          block0[BTYP] = POINTER;
                   
         gbl_write_block (g, ROOT, block0);          lseek (filedes, ROOT, 0);
           write (filedes, block0, BLOCKLEN);
                   
         /* shift trace_stack */          /* shift trace_stack */
         j = trx++;          j = trx++;
Line 2982  static void splitp (global_handle *g, ch Line 2708  static void splitp (global_handle *g, ch
         traceblk[1] = newblk;          traceblk[1] = newblk;
         *blknbr = newblk;          *blknbr = newblk;
                   
         getnewblk (g, &newblk); /* get a new block */          getnewblk (filedes, &newblk);   /* get a new block */
   
     }      }
   
Line 3036  static void splitp (global_handle *g, ch Line 2762  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;
   
         gbl_write_block (g, newblk, block0);          lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);
           write (filedes, block0, BLOCKLEN);
   
         (*offs) = limit;          (*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 */          /* up-date LL-PTR of RL-block */
         if (other != 0) {          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] = newblk / 65536;
             block0[LLPTR + 1] = newblk % 65536 / 256;              block0[LLPTR + 1] = newblk % 65536 / 256;
             block0[LLPTR + 2] = newblk % 256;              block0[LLPTR + 2] = newblk % 256;
               
             gbl_write_block (g, other, block0);              lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
               write (filedes, block0, BLOCKLEN);
   
         }          }
   
Line 3075  static void splitp (global_handle *g, ch Line 2804  static void splitp (global_handle *g, ch
   
         (*addr) -= limit;          (*addr) -= limit;
         (*offs) -= 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);          stcpy0 (block, block0, (long) BLOCKLEN);
                   
         (*blknbr) = newblk;          (*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 */          /* up-date LL-PTR of RL-block */
         if (other != 0) {          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] = newblk / 65536;
             block0[LLPTR + 1] = newblk % 65536 / 256;              block0[LLPTR + 1] = newblk % 65536 / 256;
             block0[LLPTR + 2] = newblk % 256;              block0[LLPTR + 2] = newblk % 256;
               
             gbl_write_block (g, other, block0);              lseek (filedes, (long) other * (long) (BLOCKLEN), 0);
               write (filedes, block0, BLOCKLEN);
   
         }          }
   
Line 3108  static void splitp (global_handle *g, ch Line 2839  static void splitp (global_handle *g, ch
  *  ins_key:    key to be inserted   *  ins_key:    key to be inserted
  *  keyl:       length of that key   *  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 offset;
     long addr;      long addr;
     unsigned long blknbr;      unsigned long blknbr;
     char block[BLOCKLEN];      char block[BLOCKLEN];
     long i, j, k;      long i, j, k;
       
     while (traceadr[trx] == 0) {        /* update of pointer blocks necessary */      while (traceadr[trx] == 0) {        /* update of pointer blocks necessary */
   
         if (--trx < 0) break;          if (--trx < 0) break;
                   
         blknbr = traceblk[trx];          blknbr = traceblk[trx];
         addr = traceadr[trx];          addr = traceadr[trx];
           
         gbl_read_block (g, blknbr, block);          lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);
           read (filedes, block, BLOCKLEN);
                   
         {          {
             long    oldkeyl;              long    oldkeyl;
Line 3150  static void update (global_handle *g, ch Line 2882  static void update (global_handle *g, ch
             else if (j < 0) {           /* we need more space */              else if (j < 0) {           /* we need more space */
                           
                 /* block too small */                  /* 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;                  i = offset;
                 offset -= j;                  offset -= j;
Line 3173  static void update (global_handle *g, ch Line 2905  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 */
             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);
   
     }      }
   
Line 3191  static void update (global_handle *g, ch Line 2926  static void update (global_handle *g, ch
  *  key_len:    length of that key   *  key_len:    length of that key
  *  blknbr:     key points to this block   *  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;      unsigned long blk;
     char block[BLOCKLEN];      char block[BLOCKLEN];
Line 3200  static void insert (global_handle *g, ch Line 2935  static void insert (global_handle *g, ch
     long needed;      long needed;
     long addr;      long addr;
     register int i, k;      register int i, k;
       
     trxsav = trx--;      trxsav = trx--;
     blk = traceblk[trx];      blk = traceblk[trx];
     addr = traceadr[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 +      offset = UNSIGN (block[OFFS]) * 256 +
     UNSIGN (block[OFFS + 1]);      UNSIGN (block[OFFS + 1]);
Line 3217  static void insert (global_handle *g, ch Line 2953  static void insert (global_handle *g, ch
   
     needed = key_len + 2 + PLEN;      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 */      /*  insert key */
     i = (offset += needed);      i = (offset += needed);
Line 3241  static void insert (global_handle *g, ch Line 2977  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;
   
     gbl_write_block (g, blk, block);      lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);
       write (filedes, block, BLOCKLEN);
           
     trx = trxsav;      trx = trxsav;
           
Line 3253  static void insert (global_handle *g, ch Line 2990  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 (global_handle *g, unsigned long blknbr)  static void b_free (short filedes, 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;
       
     /* mark block as empty */      /* mark block as empty */
     gbl_read_block (g, blknbr, block0);      lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);
           read (filedes, block0, BLOCKLEN);
     block0[BTYP] = EMPTY;  
   
     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? */      /* 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]))) {      if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {
                   
         for (;;) {          for (;;) {
           
             gbl_read_block (g, free, block0);              lseek (filedes, (long) free * (long) BLOCKLEN, 0);
               read (filedes, block0, BLOCKLEN);
   
             other = UNSIGN (block0[RLPTR]) * 65536 +              other = UNSIGN (block0[RLPTR]) * 65536 +
             UNSIGN (block0[RLPTR + 1]) * 256 +              UNSIGN (block0[RLPTR + 1]) * 256 +
Line 3306  static void b_free (global_handle *g, un Line 3047  static void b_free (global_handle *g, un
             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;
               
             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 */              for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */
                           
Line 3323  static void b_free (global_handle *g, un Line 3065  static void b_free (global_handle *g, un
   
     }       } 
     else {      else {
         getnewblk (g, &free);  
           getnewblk (filedes, &free);
   
         /* set FBLK free blocks pointer */          /* 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] = free / 65536;
         block0[FREE + 1] = free % 65536 / 256;          block0[FREE + 1] = free % 65536 / 256;
         block0[FREE + 2] = free % 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 */          for (i = 0; i < BLOCKLEN; block0[i++] = 0);     /* clear block */
   
Line 3347  static void b_free (global_handle *g, un Line 3092  static void b_free (global_handle *g, un
     block0[OFFS] = offset / 256;      block0[OFFS] = offset / 256;
     block0[OFFS + 1] = 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;      return;
 }                                       /* end of b_free() */  }                                       /* end of b_free() */
Line 3467  static void scandblk (char *block, long Line 3213  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 (global_handle *g, unsigned long *blknbr)  static void getnewblk (int filedes, 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;
   
     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]);      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) {
           
         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]);          offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);
   
Line 3493  static void getnewblk (global_handle *g, Line 3241  static void getnewblk (global_handle *g,
             /* update RL-block, if any */              /* update RL-block, if any */
             if (other) {              if (other) {
   
                 gbl_read_block (g, other, nblock);                  lseek (filedes, (long) (other) * BLOCKLEN, 0);
                   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;
                   
                 gbl_write_block (g, other, nblock);                  lseek (filedes, (long) (other) * BLOCKLEN, 0);
                   write (filedes, nblock, BLOCKLEN);
   
             }              }
   
             /* update ROOT block */              /* update ROOT block */
             gbl_read_block (g, ROOT, nblock);              lseek (filedes, ROOT, 0);
               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;
               
             gbl_write_block (g, ROOT, nblock);              lseek (filedes, ROOT, 0);
               write (filedes, nblock, BLOCKLEN);
                           
             return;              return;
   
Line 3522  static void getnewblk (global_handle *g, Line 3274  static void getnewblk (global_handle *g,
         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;
           
         gbl_write_block (g, freeblks, nblock);          lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);
           write (filedes, nblock, BLOCKLEN);
                   
         return;          return;
   
Line 3534  static void getnewblk (global_handle *g, Line 3287  static void getnewblk (global_handle *g,
     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;
       
     gbl_write_block (g, ROOT, nblock);      lseek (filedes, ROOT, 0);
       write (filedes, nblock, BLOCKLEN);
           
     *blknbr = no_of_blks;      *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;      return;
   
Line 3668  static short int g_collate (char *t) Line 3433  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 3710  short g_numeric (char *str) Line 3476  short g_numeric (char *str)
   
 }                                       /* end g_numeric() */  }                                       /* end g_numeric() */
   
   
 /* DEPRECATED: use gbl_close_all() instead */  
 void close_all_globals (void)  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;      return;
   
 }                                       /* end close_all_globals() */  }                                       /* end close_all_globals() */
   
 static void panic (void)  static void panic (void)
 {  {                                       
     printf ("write failed\r\n");  
       
     printf ("\033[s\033[25H\033[5;7mwrite needs more disk space immediately\007");      printf ("\033[s\033[25H\033[5;7mwrite needs more disk space immediately\007");
     sleep (1);      sleep (1);
     printf ("\033[m\007\033[2K\033[u");      printf ("\033[m\007\033[2K\033[u");
Line 3742  static void panic (void) Line 3519  static void panic (void)
   
 void gbl_dump_stat(void)  void gbl_dump_stat(void)
 {  {
     global_handle *g;      register int i;
     int ct;      
     int miss_pct;      printf ("FreeM Global Statistics [PID %d]\r\n", pid);
     int hit_pct;  
     unsigned long access_total;         printf ("%-10s%-20s%s\r\n", "USECT", "AGE", "FILE");
     unsigned long hit_total;      printf ("%-10s%-20s%s\r\n", "=====", "===", "====");
     unsigned long mem_reads_total;      
       for (i = 0; i < NO_GLOBLS; i++) {
     mem_reads_total = 0;          printf ("%-10d%-20ld%s\r\n", usage[i], g_ages[i], oldfil[i]);    
     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 ("<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);  
           
 }  }
Removed from v.1.18  
changed lines
  Added in v.1.25

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