[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.5 and 1.22

version 1.5, 2025/03/22 22:52:24 version 1.22, 2025/04/13 04:22:43
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.22  2025/04/13 04:22:43  snw
    *   Fix snprintf calls
    *
    *   Revision 1.21  2025/04/11 20:55:49  snw
    *   Disable -Wunused-result where possible
    *
    *   Revision 1.20  2025/04/11 18:24:32  snw
    *   Fix bug in memory cache
    *
    *   Revision 1.19  2025/04/11 16:52:05  snw
    *   Fix indentation in global handler
    *
    *   Revision 1.18  2025/04/11 16:23:18  snw
    *   Avoid re-reading the same block consecutively when possible
    *
    *   Revision 1.17  2025/04/11 14:21:03  snw
    *   Make all but one of the read/write calls in global_bltin use gbl_read_block or gbl_write_block
    *
    *   Revision 1.16  2025/04/11 00:52:40  snw
    *   Replace all lseek/read calls in global handler to use gbl_read_block function
    *
    *   Revision 1.15  2025/04/10 01:24:38  snw
    *   Remove C++ style comments
    *
    *   Revision 1.14  2025/04/09 19:52:02  snw
    *   Eliminate as many warnings as possible while building with -Wall
    *
    *   Revision 1.13  2025/04/09 14:34:30  snw
    *   Further work on global_bltin.c refactor
    *
    *   Revision 1.12  2025/04/09 00:43:07  snw
    *   Exit with fatal error if a header mismatch found
    *
    *   Revision 1.11  2025/04/08 21:41:13  snw
    *   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
    *   Replace action macro dat with fra_dat to avoid symbol conflict on OS/2
    *
    *   Revision 1.6  2025/03/24 01:33:30  snw
    *   Guard declaration of time function in global_bltin.c for portability
    *
  *   Revision 1.5  2025/03/22 22:52:24  snw   *   Revision 1.5  2025/03/22 22:52:24  snw
  *   Add STRLEN_GBL macro to manage global string length   *   Add STRLEN_GBL macro to manage global string length
  *   *
Line 40 Line 91
 #include <fcntl.h>  #include <fcntl.h>
 #include <unistd.h>  #include <unistd.h>
 #include <string.h>  #include <string.h>
   #include <stdlib.h>
 #include <errno.h>  #include <errno.h>
   
   
 #include "mpsdef.h"  #include "mpsdef.h"
   #include "journal.h"
   #include "global_bltin.h"
   
 static void b_free (short filedes, unsigned long blknbr);  global_handle *global_handles_head;
 static void splitp (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr);  unsigned long gbl_cache_misses = 0;
 static void update (short filedes, char *ins_key, long keyl);  unsigned long gbl_cache_hits = 0;
 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 (int filedes, unsigned long *blknbr);  static void getnewblk (global_handle *g, unsigned long *blknbr);
 static short int g_collate (char *t);  static short int g_collate (char *t);
 //static short int g_numeric (char *str);  
 short g_numeric (char *str);  short g_numeric (char *str);
 void close_all_globals(void);  void close_all_globals(void);
 static void panic (void);  static void panic (void);
   
 #define ROOT 0L  #if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__) && !defined(__OS2__)
   long time ();
   #endif
   
 /* end of line symbol in global module is 30, which is a code not */  inline long gbl_path(char *key, char *buf)
 /* otherwise used in subscripts                                   */  {
 #define g_EOL 30      long savj;
   
 #define EOL1 EOL      register long int i;
       register long int j;
 /* numerics (('.'<<1)&037)==28 ; (('-'<<1)&037)==26; */      register long int k;
 #define POINT 28      register long int ch;
 #define MINUS 26     
       /* construct full UNIX filename */
 /* ALPHA and OMEGA are dummy subscripts in $order processing */      savj = 0;
 /* ALPHA sorts before all other subscripts                   */      k = 0;
 /* OMEGA sorts after all other subscripts                    */      j = savj;
 /* e.g. ("abc") -> "abc",OMEGA ; ("abc","") -> "abc",ALPHA   */  
 #define OMEGA 29      if (key[1] == '%' || key[1] == '$') {               /* %-globals and SSVN backing storage, no explicit path */
 #define ALPHA 31          
           if (gloplib[0] != EOL) {
 /* length of blocks. status bytes defined as offset to blocklength */              
 /*      BLOCKLEN 1024           is defined in mpsdef0 include file */              /* append % global access path */
 #define DATALIM (BLOCKLEN-11)              while ((ch = buf[k++] = gloplib[j++]) != ':' && ch != EOL); 
 #define LLPTR   (BLOCKLEN-10)  
 #define NRBLK    LLPTR          } 
 #define COLLA   (BLOCKLEN- 7)  
 #define RLPTR   (BLOCKLEN- 6)      }
 #define FREE     RLPTR      else if (key[1] != '/') {           /* no explicit path specified */
 #define BTYP    (BLOCKLEN- 3)          
 #define OFFS    (BLOCKLEN- 2)          if (glopath[0] != EOL) {
   
 /* length of blockpointers in bytes */              /* append global access path */
 #define PLEN     3              while ((ch = buf[k++] = glopath[j++]) != ':' && ch != EOL);
   
 #define EMPTY    0          }
 #define FBLK     1  
 #define POINTER  2      }
 #define BOTTOM   6      
 #define DATA     8      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) - 1, "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) - 1, "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, g->header.block_size);
           errsav = errno;
           g->last_block = blocknum;
           g->use_count++;
           g->write_ops++;
   
           if (errsav == 0) break;
   
           panic ();
           
       }
   
       gbl_update_tid (g);  
       gbl_unlock (g);
   
       return TRUE;    
   }
   
   global_handle *gbl_handle(char *key)
   {
       global_handle *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() */
   
 #if !defined(__OpenBSD__) && !defined(_AIX) && !defined(__osf__) && !defined(MSDOS) && !defined(__vax__)  
  long time ();  
 #endif  
   
 /* globals management */  /* globals management */
           
Line 176  static void panic (void); Line 674  static void panic (void);
  * 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)
 {  {
   
     /* these must be static variables */      global_handle *g;
   
     static short filedes;               /* filedescr for global access */      unsigned long hdr_offset;
       
       /* these must be static variables */
     static char filnam[256];            /* name of global/unix file */      static char filnam[256];            /* name of global/unix file */
   
     /* the following vars may be */      /* the following vars may be */
     /* static or dynamic */      /* static or dynamic */
   
     static unsigned long blknbr;        /* block number */      static unsigned long blknbr;        /* block number */
     static unsigned long oldblk;  
     static unsigned long newblk;      static unsigned long newblk;
     static unsigned long other;      static unsigned long other;
     static long j1;      static long j1;
     static long limit;      static long limit;
     static short typ;                   /* block type */      static short typ;                   /* block type */
     static long keyl,                   /* length of compacted key */      static long keyl;                   /* length of compacted key */
                 datal,                  /* length of data */      static long datal;                  /* length of data */
                 olddatal,      static long olddatal;
                 offset,      static long offset;
                 found,      static long found;
                 addr,                   /* address of key in 'block' */      static long addr;                   /* address of key in 'block' */
                 needed,                 /* new bytes needed to ins. stuff */      static long needed;                 /* new bytes needed to ins. stuff */
                 ret_to,                 /* return code */      static long ret_to;                 /* return code */
                 kill_again;      static long kill_again;
     static char key1[256];      static char key1[256];
     static char tmp1[256];              /* intermediate storage for op= */      static char tmp1[256];              /* intermediate storage for op= */
     static char block[BLOCKLEN];      static char block[BLOCKLEN];
     static int getnflag;                /* flag 1=$ZO-variable 0=$Q-function */      static int getnflag;                /* flag 1=$ZO-variable 0=$Q-function */
     static int tryfast;                 /* try fast access if get_sym on    */      static int tryfast;                 /* try fast access if get_sym on    */
                                 /* previous global */      /* previous global */
   
     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 */      /* process optional limitations */
     if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {      if (glvnflag.all && key[0] >= '%' && key[0] <= 'z') {
   
         if ((i = glvnflag.one[0])) {    /* number of significant chars */          if ((i = glvnflag.one[0])) {    /* number of significant chars */
   
             j = 0;              j = 0;
             while ((k = key[j]) != DELIM && k != EOL) {              while ((k = key[j]) != DELIM && k != EOL) {
   
                 if (j >= i) {                  if (j >= i) {
                       
                     while ((k = key[++j]) != DELIM && k != EOL);                      while ((k = key[++j]) != DELIM && k != EOL);
   
                     stcpy (&key[i], &key[j]);                      stcpy (&key[i], &key[j]);
                       
                     break;                      break;
                 }                  }
   
                 j++;                  j++;
   
             }              }
         }          }
   
         if (glvnflag.one[1]) {          /* upper/lower sensitivity */          if (glvnflag.one[1]) {          /* upper/lower sensitivity */
               
             j = 0;              j = 0;
               
             while ((k = key[j]) != DELIM && k != EOL) {              while ((k = key[j]) != DELIM && k != EOL) {
               
                 if (k >= 'a' && k <= 'z') key[j] = k - 32;                  if (k >= 'a' && k <= 'z') key[j] = k - 32;
               
                 j++;                  j++;
               
             }              }
   
         }          }
   
         if ((i = glvnflag.one[2])) {          if ((i = glvnflag.one[2])) {
   
             if (stlen (key) > i) {              if (stlen (key) > i) {
                 merr_raise (M75);                  merr_raise (M75);
                 return;                  return;
             }                           /* key length limit */              }                           /* key length limit */
   
         }          }
   
         if ((i = glvnflag.one[3])) {    /* subscript length limit */          if ((i = glvnflag.one[3])) {    /* subscript length limit */
               
             j = 0;              j = 0;
               
             while ((k = key[j++]) != DELIM && k != EOL);              while ((k = key[j++]) != DELIM && k != EOL);
               
             if (k == DELIM) {              if (k == DELIM) {
               
                 k = 0;                  k = 0;
                 for (;;) {                  for (;;) {
               
                     k = key[j++];                      k = key[j++];
               
                     if (k == DELIM || k == EOL) {                      if (k == DELIM || k == EOL) {
               
                         if (k > i) {                          if (k > i) {
                             merr_raise (M75);                              merr_raise (M75);
                             return;                              return;
                         }                          }
               
                         k = 0;                          k = 0;
                     }                      }
   
                     if (k == EOL) break;                      if (k == EOL) break;
                           
                     k++;                      k++;
                 }                  }
             }              }
               
         }          }
     }      }
   
     if (action == getnext) {  
   
       if (action == getnext) {
         getnflag = TRUE;          getnflag = TRUE;
         varnam[0] = EOL;          varnam[0] = EOL;
                   
Line 357  void global_bltin (short action, char *k Line 834  void global_bltin (short action, char *k
         }          }
     }      }
   
     if (v22ptr) {      g = gbl_handle (key);    
       i = gbl_path (key, filnam);
         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 */      /* 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 518  void global_bltin (short action, char *k Line 898  void global_bltin (short action, char *k
                 compactkey[k++] = ch << 1;                  compactkey[k++] = ch << 1;
   
             }               } 
             else if (ch < SP || ch >= DEL) {              else if (ch < SP || ch >= DEL) {                
                                   /* no CTRLs */
                 /*no CTRLs */  
   
                 merr_raise (SBSCR);                                  merr_raise (SBSCR);                
                 return;                  return;
             }              }
Line 592  void global_bltin (short action, char *k Line 970  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:
   
     for (;;) {      if (!gbl_open (g, action)) {
   
         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 687  reopen: Line 982  reopen:
                 return;                  return;
             }              }
   
             if (action == dat || action == zdata) {              if (action == fra_dat || action == zdata) {
                 data[0] = '0';                  data[0] = '0';
                 data[1] = EOL1;                  data[1] = EOL1;
                   
Line 711  reopen: Line 1006  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 749  reopen: Line 1036  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 */
         for (;;) {          gbl_lock (g, 1);
   
             errno = 0;          if ((iresult = gbl_create (g)) != OK) {
                           merr_raise (iresult);
             if ((filedes = creat (filnam, 0666)) != -1) break;  
   
             if (errno == EMFILE || errno == ENFILE) {  
                 close_all_globals ();  
                 continue;  
             }  
   
             merr_raise (PROTECT);  
             return;              return;
         }          }        
   
         if (lonelyflag == FALSE) locking (filedes, 1, 0L);          gbl_write_block (g, ROOT, block);
           
         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 788  reopen: Line 1055  reopen:
         block[BTYP] = DATA;             /* type */          block[BTYP] = DATA;             /* type */
         block[OFFS] = i / 256;          block[OFFS] = i / 256;
         block[OFFS + 1] = i % 256;          block[OFFS + 1] = i % 256;
           
         for (;;) {  
   
             errno = 0;  
             write (filedes, block, BLOCKLEN);  
               
             if (errno == 0) break;  
               
             lseek (filedes, (ROOT + 1L) * BLOCKLEN, 0);  
             panic ();  
   
         }  
   
         close (filedes);          gbl_write_block (g, ROOT + 1, block);
           
         if (lonelyflag == FALSE) locking (filedes, 0, 0L);      /* unlock */  
                   
           gbl_close (g);
           gbl_unlock (g);
           gbl_open (g, action);
   
         /* 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 */
   
 lock:  /* temporarily disabled    
      lock:
   */
   
     if (action == get_sym) {      if (action == get_sym) {
   
 tfast0:  tfast0:
           gbl_lock (g, 3);
         if (lonelyflag == FALSE) locking (filedes, 3, 0L);                  
         if (tryfast) goto tfast1;               /* try again last block */          if (g->fast_path > 0) {
               goto tfast1;                /* try again last block */
           }
                   
         blknbr = oldblk = ROOT;         /* start with ROOT block */          blknbr = g->last_block = ROOT;          /* start with ROOT block */
                   
         for (;;) {          for (;;) {
           tfast1:
               gbl_read_block (g, blknbr, block);
   
   /* temporarily disabled
      tfast2:
   */
               if ((typ = block[BTYP]) == DATA) {  /* scan data block: here we test for equality only */
                   offset = UNSIGN (block[OFFS]) * 256 +            
                       UNSIGN (block[OFFS + 1]);
                   j = UNSIGN (block[0]);
                   i = 0;
   
 tfast1:                  stcpy0 (key1, &block[2], j);    /* get first key */
   
             lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);  
             read (filedes, block, BLOCKLEN);  
   
   
 tfast2:  
   
         if ((typ = block[BTYP]) == DATA) {      /* scan data block: here we test for equality only */  
   
             offset = UNSIGN (block[OFFS]) * 256 +              
             UNSIGN (block[OFFS + 1]);  
             j = UNSIGN (block[0]);  
             i = 0;  
   
             stcpy0 (key1, &block[2], j);        /* get first key */  
               
             ch = keyl;          /* ch is a register! */  
               
             while (i < offset) {  
               
                 j = UNSIGN (block[i++]);        /* length of key - offset */  
                 k = UNSIGN (block[i++]);        /* offset into previous entry */  
   
 #ifdef VERSNEW  
   
                 stcpy0 (&key0[k], &block[i], j);  
                 i += j;  
                 j += k;  
   
 #else  
   
                 j += k;  
                           
                 while (k < j) key1[k++] = block[i++];           /* get key */                  ch = keyl;              /* ch is a register! */
                   while (i < offset) {                    
 #endif /* VERSNEW */                      j = UNSIGN (block[i++]);    /* length of key - offset */
                       k = UNSIGN (block[i++]);    /* offset into previous entry */
                 if (j != ch) {  /* keys have different length */                      
                       j += k;
                       
                       while (k < j) key1[k++] = block[i++];               /* get key */
                       
                       if (j != ch) {      /* keys have different length */                        
                           i += UNSIGN (block[i]);
                           i++;
                           
                           continue;                        
                       }
                       
                       j = ch;
                       
                       do {
                           j--;
                       } while (compactkey[j] == key1[j]);         /* compare keys */
                                           
                       if (j < 0) {                        
                           k = UNSIGN (block[i++]);
                           stcpy0 (data, &block[i], k);    /* get value */
                           data[k] = EOL1; /* append EOL */
                           
                           goto quit;                        
                       }
                                           
                     i += UNSIGN (block[i]);                      i += UNSIGN (block[i]);
                     i++;                      i++;                /* skip data */                    
                   }
                     continue;                  
                   /* fast access failed. try normal path */
                   if (tryfast) {
                       gbl_cache_miss (g);
                       goto tfast0;
                 }                  }
   
                 /* key1[j]=g_EOL; */                  merr_raise (M7);
                 j = ch;                  data[0] = EOL;
                                   
                 do {                  goto quit;              /* variable not found */
                     j--;              } 
                 } while (compactkey[j] == key1[j]);             /* compare keys */              else {
                                   
                   if (g->fast_path > 0) {
                 if (j < 0) {                      gbl_cache_miss (g);
                       goto tfast0;
                   }
                   
                   if (typ == EMPTY) {
                                           
                     k = UNSIGN (block[i++]);                      if (blknbr == ROOT) {
                     stcpy0 (data, &block[i], k);        /* get value */                          gbl_close (g);
                     data[k] = EOL1;     /* append EOL */                          goto reopen;
                       }
                       
                       merr_raise (DBDGD);
                     goto quit;                      goto quit;
                       
                 }                  }
                   
                 i += UNSIGN (block[i]);  
                 i++;            /* skip data */  
   
             }  
   
             /* fast access failed. try normal path */  
             if (tryfast) {  
                 tryfast = FALSE;  
                 goto tfast0;  
             }              }
   
             merr_raise (M7);  
             data[0] = EOL;  
                           
             goto quit;          /* variable not found */              scanpblk (block, &addr, &found);
         }               
         else {              addr += UNSIGN (block[addr]) + 2;   /* skip key */
                       
             if (tryfast) {              if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {
                 tryfast = FALSE;  
                 goto tfast0;  
             }  
   
             if (typ == EMPTY) {  
                   
                 if (blknbr == ROOT) {  
                     close (filedes);  
                     goto reopen;  
                 }  
   
                 merr_raise (DBDGD);                  merr_raise (DBDGD);
                 goto quit;                  goto quit;
   
             }              }
   
         }              addr += PLEN;               /* skip data */
               g->last_block = blknbr;
         scanpblk (block, &addr, &found);              g->fast_path = 1;
   
         addr += UNSIGN (block[addr]) + 2;       /* skip key */  
           
         if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == 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 */      }                                   /* 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) {
                   
         lseek (filedes, ROOT, 0);          /* note : UNIX does not tell other jobs that a file has been unlinked */    
   
         /* note : UNIX does not tell other    */  
         block[BTYP] = EMPTY;            /* jobs that a file has been unlinked */  
           
         /* as long as they keep it open.      */          /* as long as they keep it open.      */
         /* so we mark this global as EMPTY    */          /* so we mark this global as EMPTY    */
         write (filedes, block, BLOCKLEN);          block[BTYP] = EMPTY;            
           
         if (lonelyflag == FALSE) locking (filedes, 0, 0L);      /* unlock */          gbl_write_block (g, ROOT, block);
           
         close (filedes);          gbl_unlock (g);
                   gbl_close (g);
         olddes[inuse] = 0;  
         oldfil[inuse][0] = NUL;  
         usage[inuse] = 0;  
                   
         unlink (filnam);          unlink (filnam);
                   
Line 979  tfast2: Line 1207  tfast2:
 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 = oldblk = ROOT;             /* start with ROOT block */      blknbr = g->last_block = ROOT;              /* start with ROOT block */
     trx = (-1);      trx = (-1);
   
     for (;;) {      for (;;) {
Line 991  k_again:    /* entry point for repeated Line 1219  k_again:    /* entry point for repeated
   
         traceblk[trx] = blknbr;          traceblk[trx] = blknbr;
         traceadr[trx] = 0;          traceadr[trx] = 0;
           
         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);          gbl_read_block (g, blknbr, block);
         read (filedes, block, BLOCKLEN);  
           
         typ = block[BTYP];          typ = block[BTYP];
                   
         if (typ == DATA) {          if (typ == DATA) {
Line 1005  k_again:    /* entry point for repeated Line 1231  k_again:    /* entry point for repeated
         if (typ == EMPTY) {          if (typ == EMPTY) {
   
             if (blknbr == ROOT) {              if (blknbr == ROOT) {
                 close (filedes);                  gbl_close (g);
                 goto reopen;                  goto reopen;
             }              }
   
Line 1019  k_again:    /* entry point for repeated Line 1245  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])) == oldblk) {          if ((blknbr = UNSIGN (block[addr]) * 65536 + UNSIGN (block[addr + 1]) * 256 + UNSIGN (block[addr + 2])) == g->last_block) {
             merr_raise (DBDGD);              merr_raise (DBDGD);
             goto quit;              goto quit;
         }          }
   
         addr += PLEN;                   /* skip data */          addr += PLEN;                   /* skip data */
         oldblk = blknbr;          g->last_block = blknbr;
           g->fast_path = 1;
     }      }
   
     traceadr[trx] = addr;      traceadr[trx] = addr;
Line 1036  k_again:    /* entry point for repeated Line 1263  k_again:    /* entry point for repeated
   
             datal = stlen (data);              datal = stlen (data);
             offset = UNSIGN (block[OFFS]) * 256 +              offset = UNSIGN (block[OFFS]) * 256 +
             UNSIGN (block[OFFS + 1]);                  UNSIGN (block[OFFS + 1]);
   
             if (found != 2) {           /* new entry */              if (found != 2) {           /* new entry */
                                   
Line 1062  k_again:    /* entry point for repeated Line 1289  k_again:    /* entry point for repeated
                 }                  }
   
   
 s10:            {  s10:
                   {
                     long    len;                /*  insert key */                      long    len;                /*  insert key */
                     char    key0[256];                      char    key0[256];
   
Line 1160  s10:            { Line 1388  s10:            {
   
                 }                  }
   
                 lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                  gbl_write_block (g, blknbr, block);
                 write (filedes, block, BLOCKLEN);  
   
                 if (traceadr[trx] == 0) update (filedes, compactkey, keyl);                  if (traceadr[trx] == 0) update (g, compactkey, keyl);
   
                 break;                  break;
             }              }
Line 1205  s10:            { Line 1432  s10:            {
   
                 }                   } 
                 else {                                    else {                  
                     /* if (j1<0) */  
                     /* we need more space */                       /* we need more space */ 
   
                     if ((offset - j1) > DATALIM) {                      if ((offset - j1) > DATALIM) {
Line 1215  s10:            { Line 1441  s10:            {
                         goto splitd;                          goto splitd;
                     }                      }
   
 s20:                  s20:
                                           
                     i = offset;                      i = offset;
                     k = addr + olddatal;                      k = addr + olddatal;
Line 1248  s20: Line 1474  s20:
             }              }
           
             stcpy0 (&block[++addr], data, (long) datal);              stcpy0 (&block[++addr], data, (long) datal);
             lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);  
             write (filedes, block, BLOCKLEN);              gbl_write_block (g, blknbr, block);
               
             break;              break;
   
   
         case dat:          case fra_dat:
   
             data[0] = '0';              data[0] = '0';
             data[1] = EOL1;              data[1] = EOL1;
Line 1274  s20: Line 1501  s20:
   
                 /* get following entry, eventually in the next blk */                  /* get following entry, eventually in the next blk */
                 offset = UNSIGN (block[OFFS]) * 256 +                  offset = UNSIGN (block[OFFS]) * 256 +
                 UNSIGN (block[OFFS + 1]);                      UNSIGN (block[OFFS + 1]);
   
                 if (addr >= offset) {                  if (addr >= offset) {
   
                     if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) {                      if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2]))) {
                       
                         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                          gbl_read_block (g, blknbr, block);
                         read (filedes, block, BLOCKLEN);  
                         j1 = UNSIGN (block[0]);                          j1 = UNSIGN (block[0]);
                                           
                         i = 0;                          i = 0;
Line 1362  s20: Line 1588  s20:
                                   
                     goto quit;                      goto quit;
                 }       /* no next block */                  }       /* no next block */
                   
                 lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                  gbl_read_block (g, blknbr, block);
                 read (filedes, block, BLOCKLEN);  
                 scandblk (block, &addr, &found);                  scandblk (block, &addr, &found);
   
             }               } 
Line 1411  s20: Line 1636  s20:
                                   
                 while (i < keyl) if (compactkey[i++] & 01)                  while (i < keyl) if (compactkey[i++] & 01)
                                   
                 j1++;                                       j1++;
                 i = 0;                  i = 0;
                 j = 0;                  j = 0;
                 k = 0;                  k = 0;
Line 1444  s20: Line 1669  s20:
                 while ((ch = UNSIGN (scratch[i++])) != g_EOL) {                  while ((ch = UNSIGN (scratch[i++])) != g_EOL) {
   
                     ch0 = (ch >= SP ? (ch >> 1) :       /* 'string' chars */                      ch0 = (ch >= SP ? (ch >> 1) :       /* 'string' chars */
                     (ch < 20 ? (ch >> 1) + '0' :        /* 0...9          */                             (ch < 20 ? (ch >> 1) + '0' : /* 0...9          */
                     (ch >> 1) + SP));   /* '.' or '-'     */                              (ch >> 1) + SP));   /* '.' or '-'     */
   
   
                     if (ch0 == DEL) {                      if (ch0 == DEL) {
Line 1520  s20: Line 1745  s20:
                         goto quit;              /* no next block */                          goto quit;              /* no next block */
                     }                      }
   
                     lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                      gbl_read_block (g, blknbr, block);
                     read (filedes, block, BLOCKLEN);  
   
                     addr = 0;                      addr = 0;
                     offset = UNSIGN (block[OFFS]) * 256 +                      offset = UNSIGN (block[OFFS]) * 256 +
                     UNSIGN (block[OFFS + 1]);                          UNSIGN (block[OFFS + 1]);
                 }                  }
   
             }              }
Line 1544  s20: Line 1768  s20:
                     goto quit;          /* no next block */                      goto quit;          /* no next block */
                 }                  }
   
                 lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                  gbl_read_block (g, blknbr, block);
                 read (filedes, block, BLOCKLEN);  
                                   
                 addr = 0;                  addr = 0;
             }               } 
Line 1593  s20: Line 1816  s20:
                     while ((ch = UNSIGN (key0[i++])) != g_EOL) {                      while ((ch = UNSIGN (key0[i++])) != g_EOL) {
   
                         ch0 = (ch >= SP ? (ch >> 1) :   /* 'string' chars */                          ch0 = (ch >= SP ? (ch >> 1) :   /* 'string' chars */
                         (ch < 20 ? (ch >> 1) + '0' :            /* 0...9          */                                 (ch < 20 ? (ch >> 1) + '0' :             /* 0...9          */
                         (ch >> 1) + SP));       /* '.' or '-'     */                                  (ch >> 1) + SP));       /* '.' or '-'     */
   
   
                         if (ch0 == DEL) {                          if (ch0 == DEL) {
Line 1670  s20: Line 1893  s20:
                         }                          }
   
                         ch0 = (ch >= SP ? (ch >> 1) :   /* 'string' chars */                          ch0 = (ch >= SP ? (ch >> 1) :   /* 'string' chars */
                         (ch < 20 ? (ch >> 1) + '0' :            /* 0...9          */                                 (ch < 20 ? (ch >> 1) + '0' :             /* 0...9          */
                         (ch >> 1) + SP));       /* '.' or '-'     */                                  (ch >> 1) + SP));       /* '.' or '-'     */
                                                   
                         if (ch0 == DEL) {                          if (ch0 == DEL) {
   
Line 1715  s20: Line 1938  s20:
   
         case kill_sym:                  /* search and destroy */          case kill_sym:                  /* search and destroy */
           
 killo:                          /* entry from killone section */          killo:                          /* entry from killone section */
             offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);              offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
   
             i = 0;              i = 0;
Line 1754  killo:    /* entry from killone section Line 1977  killo:    /* entry from killone section
   
                         other = traceblk[--trx];                          other = traceblk[--trx];
                         addr = traceadr[trx];                          addr = traceadr[trx];
                           
                         lseek (filedes, (long) other * (long) (BLOCKLEN), 0);                          gbl_read_block (g, other, block);
                         read (filedes, block, BLOCKLEN);  
                                                   
                         addr += UNSIGN (block[addr]);                          addr += UNSIGN (block[addr]);
                         addr += (2 + PLEN);     /* skip previous entry */                          addr += (2 + PLEN);     /* skip previous entry */
                         offset = UNSIGN (block[OFFS]) * 256 +                          offset = UNSIGN (block[OFFS]) * 256 +
                         UNSIGN (block[OFFS + 1]);                              UNSIGN (block[OFFS + 1]);
                         traceadr[trx] = addr;                          traceadr[trx] = addr;
                                                   
                         if (addr < offset) break;                          if (addr < offset) break;
                                                   
                         traceadr[trx] = 0;                          traceadr[trx] = 0;
                         traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +                          traceblk[trx] = UNSIGN (block[RLPTR]) * 65536 +
                         UNSIGN (block[RLPTR + 1]) * 256 +                              UNSIGN (block[RLPTR + 1]) * 256 +
                         UNSIGN (block[RLPTR + 2]);                              UNSIGN (block[RLPTR + 2]);
   
                     }                      }
   
                     trx = trxsav;                      trx = trxsav;
   
                     lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                      gbl_read_block (g, blknbr, block);
                     read (filedes, block, BLOCKLEN);  
   
                     offset = UNSIGN (block[OFFS]) * 256 +                      offset = UNSIGN (block[OFFS]) * 256 +
                     UNSIGN (block[OFFS + 1]);                          UNSIGN (block[OFFS + 1]);
                     addr = 0;                      addr = 0;
                     k = UNSIGN (block[0]);                      k = UNSIGN (block[0]);
                     stcpy0 (key0, &block[2], k);                      stcpy0 (key0, &block[2], k);
Line 1868  killo:    /* entry from killone section Line 2089  killo:    /* entry from killone section
                 if ((begadr == 0) && (endadr == offset)) {      /* block becomes empty */                  if ((begadr == 0) && (endadr == offset)) {      /* block becomes empty */
   
                     long    left,                      long    left,
                     right;                          right;
                     char    block0[BLOCKLEN];                      char    block0[BLOCKLEN];
   
 p_empty:                /* entry if pointer block goes empty */                  p_empty:                /* entry if pointer block goes empty */
   
                     left = UNSIGN (block[LLPTR]) * 65536 +                      left = UNSIGN (block[LLPTR]) * 65536 +
                     UNSIGN (block[LLPTR + 1]) * 256 +                          UNSIGN (block[LLPTR + 1]) * 256 +
                     UNSIGN (block[LLPTR + 2]);                          UNSIGN (block[LLPTR + 2]);
                     right = UNSIGN (block[RLPTR]) * 65536 +                      right = UNSIGN (block[RLPTR]) * 65536 +
                     UNSIGN (block[RLPTR + 1]) * 256 +                          UNSIGN (block[RLPTR + 1]) * 256 +
                     UNSIGN (block[RLPTR + 2]);                          UNSIGN (block[RLPTR + 2]);
   
                     if (left) {                      if (left) {
   
                         lseek (filedes, (long) left * (long) (BLOCKLEN), 0);                          gbl_read_block (g, left, block0);
                         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];
                           
                         lseek (filedes, (long) left * (long) (BLOCKLEN), 0);                          gbl_write_block (g, left, block0);
                         write (filedes, block0, BLOCKLEN);  
   
                     }                      }
   
                     if (right) {                      if (right) {
                           
                         lseek (filedes, (long) right * (long) (BLOCKLEN), 0);                          gbl_read_block (g, right, block0);
                         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];
                           
                         lseek (filedes, (long) right * (long) (BLOCKLEN), 0);                          gbl_write_block (g, right, block0);
                         write (filedes, block0, BLOCKLEN);  
   
                     }                      }
   
                     b_free (filedes, blknbr);   /* modify free list */                      b_free (g, blknbr); /* modify free list */
                                           
                     /* delete pointer */                      /* delete pointer */
                     /**************************/                      /**************************/
Line 1921  p_empty:  /* entry if pointer block goes Line 2138  p_empty:  /* entry if pointer block goes
                         blknbr = traceblk[--trx];                          blknbr = traceblk[--trx];
                         addr = traceadr[trx];                          addr = traceadr[trx];
   
                         lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0);                          gbl_read_block (g, blknbr, block);
                         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;
   
                         /* delete key */                          /* delete key */
Line 1934  p_empty:  /* entry if pointer block goes Line 2150  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    */
                                 write (filedes, block, BLOCKLEN);                                  gbl_write_block (g, 0L, block);
                                 close (filedes);  
                                   gbl_close (g);
                                 unlink (filnam);                                  unlink (filnam);
                           
                                 if (lonelyflag == FALSE) locking (filedes, 0, 0L);      /* unlock */                                  gbl_unlock (g);
   
                                 olddes[inuse] = 0;                                  olddes[inuse] = 0;
                                 oldfil[inuse][0] = NUL;                                  oldfil[inuse][0] = NUL;
Line 1966  p_empty:  /* entry if pointer block goes Line 2183  p_empty:  /* entry if pointer block goes
                                                   
                         for (i = offset; i < offset + freecnt; block[i++] = 0);                          for (i = offset; i < offset + freecnt; block[i++] = 0);
   
                         lseek (filedes, (long) (blknbr) * (long) (BLOCKLEN), 0);                          gbl_write_block (g, blknbr, block);
                         write (filedes, block, BLOCKLEN);  
   
                         if (addr == 0) {        /* update of pointer */                          if (addr == 0) {        /* update of pointer */
                             traceadr[trx] = 0;                              traceadr[trx] = 0;
                                                           
                             update (filedes, &block[2], (long) UNSIGN (block[0]));                              update (g, &block[2], (long) UNSIGN (block[0]));
                         }                          }
   
                         trx = trxsav;                          trx = trxsav;
Line 1997  p_empty:  /* entry if pointer block goes Line 2213  p_empty:  /* entry if pointer block goes
                     j = block[begadr + 1];                      j = block[begadr + 1];
                     k = 0;                      k = 0;
                     if (begadr)                      if (begadr)
                     while (key0[k] == key1[k])                          while (key0[k] == key1[k])
                     k++;                /* new key_offset */                              k++;                /* new key_offset */
                     if (k < j) {                      if (k < j) {
                     ch = j - k;         /* space requirement */                          ch = j - k;             /* space requirement */
                     block[begadr] = i + ch;     /* new key_length */                          block[begadr] = i + ch; /* new key_length */
                     block[begadr + 1] = k;      /* new key_offset */                          block[begadr + 1] = k;  /* new key_offset */
                     i = offset;                          i = offset;
                     j = i + ch;                          j = i + ch;
                     offset = j;                          offset = j;
                     begadr++;                          begadr++;
                     while (i > begadr)                          while (i > begadr)
                     block[j--] = block[i--];                              block[j--] = block[i--];
                     stcpy0 (&block[begadr + 1], &key0[k], ch);                          stcpy0 (&block[begadr + 1], &key0[k], ch);
                     }                      }
                 }                  }
                 block[OFFS] = offset / 256;                  block[OFFS] = offset / 256;
                 block[OFFS + 1] = offset % 256;                  block[OFFS + 1] = offset % 256;
                 lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);  
                 write (filedes, block, BLOCKLEN);                  gbl_write_block (g, blknbr, block);
   
                 if (addr < 3) {         /* update of pointer */                  if (addr < 3) {         /* update of pointer */
                 traceadr[trx] = 0;                      traceadr[trx] = 0;
                 update (filedes, &block[2], (long) UNSIGN (block[0]));                      update (g, &block[2], (long) UNSIGN (block[0]));
                 }                  }
             }              }
   
Line 2026  p_empty:  /* entry if pointer block goes Line 2243  p_empty:  /* entry if pointer block goes
   
             break;              break;
   
 zinv:          zinv:
   
             {              {
                 long    len;                  long    len;
Line 2040  zinv: Line 2257  zinv:
                         data[0] = EOL1;                          data[0] = EOL1;
                         goto quit;                          goto quit;
                     }                   /* no previous block */                      }                   /* no previous block */
                       
                     lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                      gbl_read_block (g, blknbr, block);
                     read (filedes, block, BLOCKLEN);  
                                           
                     addr = UNSIGN (block[OFFS]) * 256 +                      addr = UNSIGN (block[OFFS]) * 256 +
                     UNSIGN (block[OFFS + 1]);                          UNSIGN (block[OFFS + 1]);
   
                 }                  }
   
Line 2120  zinv: Line 2336  zinv:
                 while ((ch = UNSIGN (scratch[i++])) != g_EOL) {                  while ((ch = UNSIGN (scratch[i++])) != g_EOL) {
   
                     ch0 = (ch >= SP ? (ch >> 1) :       /* 'string' chars */                      ch0 = (ch >= SP ? (ch >> 1) :       /* 'string' chars */
                     (ch < 20 ? (ch >> 1) + '0' :        /* 0...9          */                             (ch < 20 ? (ch >> 1) + '0' : /* 0...9          */
                     (ch >> 1) + SP));   /* '.' or '-'     */                              (ch >> 1) + SP));   /* '.' or '-'     */
                                           
                     if (ch0 == DEL) {                      if (ch0 == DEL) {
   
Line 2166  zinv: Line 2382  zinv:
   
         case zdata:                     /* nonstandard data function */          case zdata:                     /* nonstandard data function */
   
             {          {
                 long counties[128];              long counties[128];
                 char key0[256];              char key0[256];
                 int icnt, icnt0, len;              int icnt, icnt0, len;
   
                 i = 0;              i = 0;
   
                 while (i < 128) counties[i++] = 0L;     /* init count;  */              while (i < 128) counties[i++] = 0L; /* init count;  */
                                   
                 if (found == 2) {               /* ... advance to next entry */              if (found == 2) {           /* ... advance to next entry */
                     addr += UNSIGN (block[addr]);                  addr += UNSIGN (block[addr]);
                     addr += 2;          /* skip key */                  addr += 2;              /* skip key */
                     addr += UNSIGN (block[addr]);                  addr += UNSIGN (block[addr]);
                     addr++;                     /* skip data */                  addr++;                 /* skip data */
   
                     counties[0] = 1L;                  counties[0] = 1L;
                 }              }
   
                 offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);              offset = UNSIGN (block[OFFS]) * 256 + UNSIGN (block[OFFS + 1]);
                 icnt = 0;              icnt = 0;
                 i = 0;              i = 0;
   
                 while ((ch = compactkey[i++]) != g_EOL) {              while ((ch = compactkey[i++]) != g_EOL) {
                   
                     if (ch & 01) {  
                         icnt++;  
                     }  
                                   
                   if (ch & 01) {
                       icnt++;
                 }                  }
                                   
                 len = i - 1;              }
                 i = 0;  
                                   
                 while (i < addr) {              /* compute offset complete key */              len = i - 1;
               i = 0;
                   
               while (i < addr) {          /* compute offset complete key */
   
                     icnt0 = UNSIGN (block[i++]);                  icnt0 = UNSIGN (block[i++]);
                     icnt0 += (j = UNSIGN (block[i++]));                  icnt0 += (j = UNSIGN (block[i++]));
                                           
                     while (j < icnt0) key0[j++] = block[i++];                  while (j < icnt0) key0[j++] = block[i++];
                                           
                     key0[j] = g_EOL;                                      key0[j] = g_EOL;                    
                     i += UNSIGN (block[i]);                  i += UNSIGN (block[i]);
                                           
                     i++;                        /* skip data */                  i++;                    /* skip data */
   
                 }              }
   
                 for (;;) {                      /* is it still a descendant ??? */              for (;;) {                  /* is it still a descendant ??? */
                   
                     if (addr >= offset) {       /* look in next block */                  if (addr >= offset) {   /* look in next block */
   
                         if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {                      if ((blknbr = UNSIGN (block[RLPTR]) * 65536 + UNSIGN (block[RLPTR + 1]) * 256 + UNSIGN (block[RLPTR + 2])) == 0) {
                             break;              /* no next block */                          break;          /* no next block */
                         }                      }
   
                         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);                      gbl_read_block (g, blknbr, block);
                         read (filedes, block, BLOCKLEN);  
                                                   
                         addr = 0;                      addr = 0;
                         offset = UNSIGN (block[OFFS]) * 256 +                      offset = UNSIGN (block[OFFS]) * 256 +
                         UNSIGN (block[OFFS + 1]);                          UNSIGN (block[OFFS + 1]);
   
                     }                  }
   
                     i = UNSIGN (block[addr++]);                  i = UNSIGN (block[addr++]);
                     i += (j = UNSIGN (block[addr++]));                  i += (j = UNSIGN (block[addr++]));
                                           
                     while (j < i) key0[j++] = block[addr++];                  while (j < i) key0[j++] = block[addr++];
   
                     addr += UNSIGN (block[addr]);                  addr += UNSIGN (block[addr]);
                     addr++;                     /* skip data */                  addr++;                 /* skip data */
                     icnt0 = 0;                  icnt0 = 0;
                     i = 0;                  i = 0;
                                           
                     while (i < j) if (key0[i++] & 01)                  while (i < j) if (key0[i++] & 01)
                                           
                     icnt0++;                                    icnt0++;
                                           
                     if (icnt0 <= icnt) break;                  if (icnt0 <= icnt) break;
                                           
                     i = 0;                  i = 0;
                                           
                     while (i < len) {                  while (i < len) {
   
                         if (key0[i] != compactkey[i]) break;                      if (key0[i] != compactkey[i]) break;
                                           
                         i++;                      i++;
   
                     }                  }
   
                     if (i < len) break;                  if (i < len) break;
                                           
                     counties[icnt0 - icnt]++;                  counties[icnt0 - icnt]++;
   
                 }              }
   
                 i = 128;              i = 128;
   
                 while (counties[--i] == 0L);              while (counties[--i] == 0L);
   
                 lintstr (data, counties[0]);              lintstr (data, counties[0]);
                                   
                 j = 1;              j = 1;
                 tmp1[0] = ',';              tmp1[0] = ',';
                                   
                 while (j <= i) {              while (j <= i) {
                     lintstr (&tmp1[1], counties[j++]);                  lintstr (&tmp1[1], counties[j++]);
                     stcat (data, tmp1);                  stcat (data, tmp1);
                 }  
   
             }              }
   
           }
                           
             break;          break;
   
         case getinc:          case getinc:
                   
             {          {
                 int     setopsav;              int     setopsav;
   
                 setopsav = setop;              setopsav = setop;
                 setop = '+';              setop = '+';
                 data[0] = '1';              data[0] = '1';
                 data[1] = EOL;              data[1] = EOL;
   
                 global  (set_sym, key, data);              global  (set_sym, key, data);
   
                 setop = setopsav;              setop = setopsav;
                                   
                 return;              return;
             }          }
   
         case killone:          case killone:
           {
             {              if (found == 2) goto killo;         /* entry found use normal kill routine */
                 if (found == 2) goto killo;             /* entry found use normal kill routine */  
                                   
                 goto quit;              goto quit;
             }          }
   
         case merge_sym:  
   
             printf("MERGE NOT IMPLEMENTED FOR GLOBALS\n");  
   
 #ifdef DEBUG_GBL       
       
             int loop;  
       
             printf ("DEBUG MERGE: ");  
             printf ("[key] is [");  
       
             for (loop = 0; key[loop] != EOL; loop++) printf ("%c", (key[loop] == DELIM) ? '!' : key[loop]);  
       
             printf ("]\r\n");  
             printf ("[data] is [");  
       
             for(loop = 0; data[loop] != EOL; loop++) printf ("%c", (data[loop] == DELIM) ? '!' : data[loop]);  
       
             printf("]\r\n");      
   
 #endif  
             return;  
   
         default:          default:
           
Line 2337  quit: Line 2528  quit:
           
     /* clean things up */      /* clean things up */
   
     lseek (filedes, ROOT, 0);      lseek (g->fd, hdr_offset + ROOT, SEEK_SET);
       gbl_unlock (g);
     if (lonelyflag == FALSE) locking (filedes, 0, 0L);  /* unlock */      
   
     return;      return;
   
   
Line 2351  splitd:    /* split data block in two se Line 2541  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 (filedes, &newblk);       /* get a new block */      getnewblk (g, &newblk);     /* get a new block */
   
     /* if we have to insert at the begin or end of a block  */      /* if we have to insert at the begin or end of a block  */
     /* we don't split - we just start a new block           */      /* we don't split - we just start a new block           */
Line 2359  splitd:    /* split data block in two se Line 2549  splitd:    /* split data block in two se
   
     if (addr >= offset) {      if (addr >= offset) {
         long    right,          long    right,
         right1,              right1,
         right2;              right2;
   
         right = UNSIGN (block[RLPTR]);          right = UNSIGN (block[RLPTR]);
         right1 = UNSIGN (block[RLPTR + 1]);          right1 = UNSIGN (block[RLPTR + 1]);
Line 2369  splitd:    /* split data block in two se Line 2559  splitd:    /* split data block in two se
         block[RLPTR + 1] = newblk % 65536 / 256;          block[RLPTR + 1] = newblk % 65536 / 256;
         block[RLPTR + 2] = newblk % 256;          block[RLPTR + 2] = newblk % 256;
   
         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);          gbl_write_block (g, blknbr, block);
         write (filedes, block, BLOCKLEN);  
                   
         block[RLPTR] = right;          block[RLPTR] = right;
         block[RLPTR + 1] = right1;          block[RLPTR + 1] = right1;
Line 2382  splitd:    /* split data block in two se Line 2571  splitd:    /* split data block in two se
         addr = 0;          addr = 0;
         blknbr = newblk;          blknbr = newblk;
                   
         insert (filedes, compactkey, keyl, newblk);          insert (g, 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];
   
             lseek (filedes, (long) other * (long) (BLOCKLEN), 0);              gbl_read_block (g, other, block0);
             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;
                   
             lseek (filedes, (long) other * (long) (BLOCKLEN), 0);              gbl_write_block (g, other, block0);
             write (filedes, block0, BLOCKLEN);              
           
         }          }
                   
         goto spltex;          goto spltex;
Line 2415  splitd:    /* split data block in two se Line 2602  splitd:    /* split data block in two se
         block[LLPTR + 1] = newblk % 65536 / 256;          block[LLPTR + 1] = newblk % 65536 / 256;
         block[LLPTR + 2] = newblk % 256;          block[LLPTR + 2] = newblk % 256;
   
         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);          gbl_write_block (g, blknbr, block);
         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 2428  splitd:    /* split data block in two se Line 2614  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 (filedes, compactkey, keyl, newblk);          insert (g, compactkey, keyl, newblk);
                   
         if (addr < 3) {                 /* update of pointer */          if (addr < 3) {                 /* update of pointer */
             traceadr[trx] = 0;              traceadr[trx] = 0;
                           
             update (filedes, compactkey, keyl);              update (g, compactkey, keyl);
         }          }
   
         /* other is ***always*** zero !!!          /* other is ***always*** zero !!!
         * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block           * if (other=left*65536+left1*256+left2) up-date RL-PTR of LL-block
         * { char block0[BLOCKLEN];           * { char block0[BLOCKLEN];
         * lseek(filedes,(long)other*(long)(BLOCKLEN),0);           * lseek(filedes,(long)other*(long)(BLOCKLEN),0);
         * read(filedes,block0,BLOCKLEN);           * read(filedes,block0,BLOCKLEN);
         * block0[RLPTR  ]=blknbr/65536;           * block0[RLPTR  ]=blknbr/65536;
         * block0[RLPTR+1]=blknbr%65536/256;           * block0[RLPTR+1]=blknbr%65536/256;
         * block0[RLPTR+2]=blknbr%256;           * block0[RLPTR+2]=blknbr%256;
         * lseek(filedes,(long)other*(long)(BLOCKLEN),0);           * lseek(filedes,(long)other*(long)(BLOCKLEN),0);
         * write(filedes,block0,BLOCKLEN);           * write(filedes,block0,BLOCKLEN);
         * }           * }
         */           */
   
         goto spltex;          goto spltex;
   
Line 2529  splitd:    /* split data block in two se Line 2715  splitd:    /* split data block in two se
   
             /* update rightlink and leftlink pointers */              /* update rightlink and leftlink pointers */
             other = UNSIGN (block[RLPTR]) * 65536 +              other = UNSIGN (block[RLPTR]) * 65536 +
             UNSIGN (block[RLPTR + 1]) * 256 +                  UNSIGN (block[RLPTR + 1]) * 256 +
             UNSIGN (block[RLPTR + 2]);                  UNSIGN (block[RLPTR + 2]);
             block0[RLPTR] = block[RLPTR];              block0[RLPTR] = block[RLPTR];
             block0[RLPTR + 1] = block[RLPTR + 1];              block0[RLPTR + 1] = block[RLPTR + 1];
             block0[RLPTR + 2] = block[RLPTR + 2];              block0[RLPTR + 2] = block[RLPTR + 2];
Line 2541  splitd:    /* split data block in two se Line 2727  splitd:    /* split data block in two se
             block0[LLPTR + 1] = blknbr % 65536 / 256;              block0[LLPTR + 1] = blknbr % 65536 / 256;
             block0[LLPTR + 2] = blknbr % 256;              block0[LLPTR + 2] = blknbr % 256;
   
             lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);              gbl_write_block (g, newblk, block0);
             write (filedes, block0, BLOCKLEN);  
                   
             offset = limit;              offset = limit;
             /* insert new block in pointer structure */              /* insert new block in pointer structure */
                   
             insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);              insert (g, &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) {
   
                 lseek (filedes, (long) other * (long) (BLOCKLEN), 0);                  gbl_read_block (g, other, block0);
                 read (filedes, block0, BLOCKLEN);  
   
                 block0[LLPTR] = newblk / 65536;                  block0[LLPTR] = newblk / 65536;
                 block0[LLPTR + 1] = newblk % 65536 / 256;                  block0[LLPTR + 1] = newblk % 65536 / 256;
                 block0[LLPTR + 2] = newblk % 256;                  block0[LLPTR + 2] = newblk % 256;
                   
                 lseek (filedes, (long) other * (long) (BLOCKLEN), 0);                  gbl_write_block (g, other, block0);
                 write (filedes, block0, BLOCKLEN);  
   
             }              }
   
Line 2569  splitd:    /* split data block in two se Line 2752  splitd:    /* split data block in two se
             /* save old block away and make new block the current block */              /* save old block away and make new block the current block */
             /* update rightlink and leftlink pointers */              /* update rightlink and leftlink pointers */
             other = UNSIGN (block[RLPTR]) * 65536 +              other = UNSIGN (block[RLPTR]) * 65536 +
             UNSIGN (block[RLPTR + 1]) * 256 +                  UNSIGN (block[RLPTR + 1]) * 256 +
             UNSIGN (block[RLPTR + 2]);                  UNSIGN (block[RLPTR + 2]);
             block0[RLPTR] = block[RLPTR];              block0[RLPTR] = block[RLPTR];
             block0[RLPTR + 1] = block[RLPTR + 1];              block0[RLPTR + 1] = block[RLPTR + 1];
             block0[RLPTR + 2] = block[RLPTR + 2];              block0[RLPTR + 2] = block[RLPTR + 2];
Line 2581  splitd:    /* split data block in two se Line 2764  splitd:    /* split data block in two se
             block0[LLPTR + 1] = blknbr % 65536 / 256;              block0[LLPTR + 1] = blknbr % 65536 / 256;
             block0[LLPTR + 2] = blknbr % 256;              block0[LLPTR + 2] = blknbr % 256;
   
             lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);              gbl_write_block (g, blknbr, block);
             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 (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);              insert (g, &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) {
   
                 lseek (filedes, (long) other * (long) (BLOCKLEN), 0);                  gbl_read_block (g, other, block0);
                 read (filedes, block0, BLOCKLEN);  
                                   
                 block0[LLPTR] = newblk / 65536;                  block0[LLPTR] = newblk / 65536;
                 block0[LLPTR + 1] = newblk % 65536 / 256;                  block0[LLPTR + 1] = newblk % 65536 / 256;
                 block0[LLPTR + 2] = newblk % 256;                  block0[LLPTR + 2] = newblk % 256;
                   
                 lseek (filedes, (long) other * (long) (BLOCKLEN), 0);                  gbl_write_block (g, other, block0);
                 write (filedes, block0, BLOCKLEN);  
   
             }              }
   
Line 2629  spltex: Line 2810  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 (short filedes, char *block, long *addr, long *offs, unsigned long *blknbr)    static void splitp (global_handle *g, char *block, long *addr, long *offs, unsigned long *blknbr)       
 {  {
   
     char block0[BLOCKLEN];      char block0[BLOCKLEN];
Line 2637  static void splitp (short filedes, char Line 2818  static void splitp (short filedes, char
     unsigned long newblk;      unsigned long newblk;
     unsigned long other;      unsigned long other;
     register int i, j;      register int i, j;
       
     getnewblk (filedes, &newblk);       /* get a new block */      getnewblk (g, &newblk);     /* get a new block */
           
     if (*blknbr == ROOT) {              /* ROOT overflow is special */      if (*blknbr == ROOT) {              /* ROOT overflow is special */
   
Line 2665  static void splitp (short filedes, char Line 2846  static void splitp (short filedes, char
                   
         /* update number of blocks ! */          /* update number of blocks ! */
         i = UNSIGN (block0[NRBLK]) * 65536 +          i = UNSIGN (block0[NRBLK]) * 65536 +
         UNSIGN (block0[NRBLK + 1]) * 256 +              UNSIGN (block0[NRBLK + 1]) * 256 +
         UNSIGN (block0[NRBLK + 2]) + 1;              UNSIGN (block0[NRBLK + 2]) + 1;
   
         block0[NRBLK] = i / 65536;          block0[NRBLK] = i / 65536;
         block0[NRBLK + 1] = i % 65536 / 256;          block0[NRBLK + 1] = i % 65536 / 256;
         block0[NRBLK + 2] = i % 256;          block0[NRBLK + 2] = i % 256;
         block0[BTYP] = POINTER;          block0[BTYP] = POINTER;
                   
         lseek (filedes, ROOT, 0);          gbl_write_block (g, ROOT, block0);
         write (filedes, block0, BLOCKLEN);  
                   
         /* shift trace_stack */          /* shift trace_stack */
         j = trx++;          j = trx++;
Line 2691  static void splitp (short filedes, char Line 2871  static void splitp (short filedes, char
         traceblk[1] = newblk;          traceblk[1] = newblk;
         *blknbr = newblk;          *blknbr = newblk;
                   
         getnewblk (filedes, &newblk);   /* get a new block */          getnewblk (g, &newblk); /* get a new block */
   
     }      }
   
Line 2733  static void splitp (short filedes, char Line 2913  static void splitp (short filedes, char
   
         /* update rightlink and leftlink pointers */          /* update rightlink and leftlink pointers */
         other = UNSIGN (block[RLPTR]) * 65536 +          other = UNSIGN (block[RLPTR]) * 65536 +
         UNSIGN (block[RLPTR + 1]) * 256 +              UNSIGN (block[RLPTR + 1]) * 256 +
         UNSIGN (block[RLPTR + 2]);              UNSIGN (block[RLPTR + 2]);
         block0[RLPTR] = block[RLPTR];          block0[RLPTR] = block[RLPTR];
         block0[RLPTR + 1] = block[RLPTR + 1];          block0[RLPTR + 1] = block[RLPTR + 1];
         block0[RLPTR + 2] = block[RLPTR + 2];          block0[RLPTR + 2] = block[RLPTR + 2];
Line 2745  static void splitp (short filedes, char Line 2925  static void splitp (short filedes, char
         block0[LLPTR + 1] = (*blknbr) % 65536 / 256;          block0[LLPTR + 1] = (*blknbr) % 65536 / 256;
         block0[LLPTR + 2] = (*blknbr) % 256;          block0[LLPTR + 2] = (*blknbr) % 256;
   
         lseek (filedes, (long) (newblk) * (long) (BLOCKLEN), 0);          gbl_write_block (g, newblk, block0);
         write (filedes, block0, BLOCKLEN);  
   
         (*offs) = limit;          (*offs) = limit;
                   
         insert (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);          insert (g, &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) {
   
             lseek (filedes, (long) other * (long) (BLOCKLEN), 0);              gbl_read_block (g, other, block0);
             read (filedes, block0, BLOCKLEN);  
                           
             block0[LLPTR] = newblk / 65536;              block0[LLPTR] = newblk / 65536;
             block0[LLPTR + 1] = newblk % 65536 / 256;              block0[LLPTR + 1] = newblk % 65536 / 256;
             block0[LLPTR + 2] = newblk % 256;              block0[LLPTR + 2] = newblk % 256;
               
             lseek (filedes, (long) other * (long) (BLOCKLEN), 0);              gbl_write_block (g, other, block0);
             write (filedes, block0, BLOCKLEN);  
   
         }          }
   
Line 2772  static void splitp (short filedes, char Line 2949  static void splitp (short filedes, char
   
         /* update rightlink and leftlink pointers */          /* update rightlink and leftlink pointers */
         other = UNSIGN (block[RLPTR]) * 65536 +          other = UNSIGN (block[RLPTR]) * 65536 +
         UNSIGN (block[RLPTR + 1]) * 256 +              UNSIGN (block[RLPTR + 1]) * 256 +
         UNSIGN (block[RLPTR + 2]);              UNSIGN (block[RLPTR + 2]);
                   
         block0[RLPTR] = block[RLPTR];          block0[RLPTR] = block[RLPTR];
         block0[RLPTR + 1] = block[RLPTR + 1];          block0[RLPTR + 1] = block[RLPTR + 1];
Line 2787  static void splitp (short filedes, char Line 2964  static void splitp (short filedes, char
   
         (*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 (filedes, &block0[2], (long) UNSIGN (block0[0]), newblk);          insert (g, &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) {
   
             lseek (filedes, (long) other * (long) (BLOCKLEN), 0);              gbl_read_block (g, other, block0);
             read (filedes, block0, BLOCKLEN);  
                           
             block0[LLPTR] = newblk / 65536;              block0[LLPTR] = newblk / 65536;
             block0[LLPTR + 1] = newblk % 65536 / 256;              block0[LLPTR + 1] = newblk % 65536 / 256;
             block0[LLPTR + 2] = newblk % 256;              block0[LLPTR + 2] = newblk % 256;
               
             lseek (filedes, (long) other * (long) (BLOCKLEN), 0);              gbl_write_block (g, other, block0);
             write (filedes, block0, BLOCKLEN);  
   
         }          }
   
Line 2822  static void splitp (short filedes, char Line 2997  static void splitp (short filedes, char
  *  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 (short filedes, char *ins_key, long keyl)  static void update (global_handle *g, 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];
           
         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);          gbl_read_block (g, blknbr, block);
         read (filedes, block, BLOCKLEN);  
                   
         {          {
             long    oldkeyl;              long    oldkeyl;
Line 2849  static void update (short filedes, char Line 3023  static void update (short filedes, char
             j = oldkeyl - keyl;              j = oldkeyl - keyl;
                           
             offset = UNSIGN (block[OFFS]) * 256 +              offset = UNSIGN (block[OFFS]) * 256 +
             UNSIGN (block[OFFS + 1]);                  UNSIGN (block[OFFS + 1]);
                           
             if (j > 0) {                /* surplus space */              if (j > 0) {                /* surplus space */
                           
Line 2865  static void update (short filedes, char Line 3039  static void update (short filedes, char
             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 (filedes, block, &addr, &offset, &blknbr);                  if ((offset - j) > DATALIM) splitp (g, block, &addr, &offset, &blknbr);
                                   
                 i = offset;                  i = offset;
                 offset -= j;                  offset -= j;
Line 2888  static void update (short filedes, char Line 3062  static void update (short filedes, char
             while (i < keyl) block[j++] = ins_key[i++];              while (i < keyl) block[j++] = ins_key[i++];
                           
             /* block pointed to remains the same */              /* block pointed to remains the same */
             lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);              gbl_write_block (g, blknbr, block);
             write (filedes, block, BLOCKLEN);  
   
         }          }
           
         lseek (filedes, (long) blknbr * (long) (BLOCKLEN), 0);          gbl_read_block (g, blknbr, block);
         read (filedes, block, BLOCKLEN);  
   
     }      }
   
Line 2909  static void update (short filedes, char Line 3080  static void update (short filedes, char
  *  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 (int filedes, char *ins_key, long key_len, unsigned long blknbr)     /* insert pointer */  static void insert (global_handle *g, char *ins_key, long key_len, unsigned long blknbr)        /* insert pointer */
 {  {
     unsigned long blk;      unsigned long blk;
     char block[BLOCKLEN];      char block[BLOCKLEN];
Line 2918  static void insert (int filedes, char *i Line 3089  static void insert (int filedes, char *i
     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];
   
     lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);      gbl_read_block (g, blk, block);
     read (filedes, block, BLOCKLEN);  
           
     offset = UNSIGN (block[OFFS]) * 256 +      offset = UNSIGN (block[OFFS]) * 256 +
     UNSIGN (block[OFFS + 1]);          UNSIGN (block[OFFS + 1]);
           
     if (traceadr[trx + 1] != (-1)) {      if (traceadr[trx + 1] != (-1)) {
         addr += UNSIGN (block[addr]);          addr += UNSIGN (block[addr]);
Line 2936  static void insert (int filedes, char *i Line 3106  static void insert (int filedes, char *i
   
     needed = key_len + 2 + PLEN;      needed = key_len + 2 + PLEN;
           
     if ((offset + needed) > DATALIM) splitp (filedes, block, &addr, &offset, &blk);      if ((offset + needed) > DATALIM) splitp (g, block, &addr, &offset, &blk);
           
     /*  insert key */      /*  insert key */
     i = (offset += needed);      i = (offset += needed);
Line 2960  static void insert (int filedes, char *i Line 3130  static void insert (int filedes, char *i
     block[i++] = blknbr % 65536 / 256;      block[i++] = blknbr % 65536 / 256;
     block[i] = blknbr % 256;      block[i] = blknbr % 256;
   
     lseek (filedes, (long) (blk) * (long) (BLOCKLEN), 0);      gbl_write_block (g, blk, block);
     write (filedes, block, BLOCKLEN);  
           
     trx = trxsav;      trx = trxsav;
           
Line 2973  static void insert (int filedes, char *i Line 3142  static void insert (int filedes, char *i
  *  filedes:    global file descriptor   *  filedes:    global file descriptor
  *  blknbr:     block to be freed   *  blknbr:     block to be freed
  */   */
 static void b_free (short filedes, unsigned long blknbr)  static void b_free (global_handle *g, unsigned long blknbr)
 {  {
     char block0[BLOCKLEN];      char block0[BLOCKLEN];
     unsigned long free;      unsigned long free;
     unsigned long other;      unsigned long other;
     long i;      long i;
     long offset;      long offset;
       
     /* mark block as empty */      /* mark block as empty */
     lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);      gbl_read_block (g, blknbr, block0);
     read (filedes, block0, BLOCKLEN);  
   
     block0[BTYP] = EMPTY;  
           
     lseek (filedes, (long) (blknbr) * BLOCKLEN, 0);      block0[BTYP] = EMPTY;
     write (filedes, block0, BLOCKLEN);  
       gbl_write_block (g, blknbr, block0);
   
     /* do we have a list of free blocks? */      /* do we have a list of free blocks? */
     lseek (filedes, ROOT, 0);      gbl_read_block (g, ROOT, block0);
     read (filedes, block0, BLOCKLEN);  
           
     if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {      if ((free = UNSIGN (block0[FREE]) * 65536 + UNSIGN (block0[FREE + 1]) * 256 + UNSIGN (block0[FREE + 2]))) {
                   
         for (;;) {          for (;;) {
           
             lseek (filedes, (long) free * (long) BLOCKLEN, 0);              gbl_read_block (g, free, block0);
             read (filedes, block0, BLOCKLEN);  
   
             other = UNSIGN (block0[RLPTR]) * 65536 +              other = UNSIGN (block0[RLPTR]) * 65536 +
             UNSIGN (block0[RLPTR + 1]) * 256 +                  UNSIGN (block0[RLPTR + 1]) * 256 +
             UNSIGN (block0[RLPTR + 2]);                  UNSIGN (block0[RLPTR + 2]);
                           
             if (other == 0) break;              if (other == 0) break;
   
Line 3019  static void b_free (short filedes, unsig Line 3184  static void b_free (short filedes, unsig
             offset -= PLEN;              offset -= PLEN;
             other = UNSIGN (block0[offset]) * 65536 +              other = UNSIGN (block0[offset]) * 65536 +
                           
             UNSIGN (block0[offset + 1]) * 256 +                  UNSIGN (block0[offset + 1]) * 256 +
             UNSIGN (block0[offset + 2]);                  UNSIGN (block0[offset + 2]);
                           
             block0[offset] = 0;              block0[offset] = 0;
             block0[offset + 1] = 0;              block0[offset + 1] = 0;
Line 3030  static void b_free (short filedes, unsig Line 3195  static void b_free (short filedes, unsig
             block0[RLPTR] = other / 65536;              block0[RLPTR] = other / 65536;
             block0[RLPTR + 1] = other % 65536 / 256;              block0[RLPTR + 1] = other % 65536 / 256;
             block0[RLPTR + 2] = other % 256;              block0[RLPTR + 2] = other % 256;
               
             lseek (filedes, (long) free * (long) BLOCKLEN, 0);              gbl_write_block (g, free, block0);
             write (filedes, block0, BLOCKLEN);  
   
             for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */              for (i = 0; i < BLOCKLEN; block0[i++] = 0); /* clear block */
                           
Line 3048  static void b_free (short filedes, unsig Line 3212  static void b_free (short filedes, unsig
   
     }       } 
     else {      else {
           getnewblk (g, &free);
         getnewblk (filedes, &free);  
   
         /* set FBLK free blocks pointer */          /* set FBLK free blocks pointer */
         lseek (filedes, ROOT, 0);          gbl_read_block (g, ROOT, block0);
         read (filedes, block0, BLOCKLEN);  
                   
         block0[FREE] = free / 65536;          block0[FREE] = free / 65536;
         block0[FREE + 1] = free % 65536 / 256;          block0[FREE + 1] = free % 65536 / 256;
         block0[FREE + 2] = free % 256;          block0[FREE + 2] = free % 256;
           
         lseek (filedes, ROOT, 0);          gbl_write_block (g, ROOT, block0);
         write (filedes, block0, BLOCKLEN);  
   
         for (i = 0; i < BLOCKLEN; block0[i++] = 0);     /* clear block */          for (i = 0; i < BLOCKLEN; block0[i++] = 0);     /* clear block */
   
Line 3075  static void b_free (short filedes, unsig Line 3236  static void b_free (short filedes, unsig
     block0[OFFS] = offset / 256;      block0[OFFS] = offset / 256;
     block0[OFFS + 1] = offset % 256;      block0[OFFS + 1] = offset % 256;
   
     lseek (filedes, (long) free * (long) BLOCKLEN, 0);      gbl_write_block (g, free, block0);
     write (filedes, block0, BLOCKLEN);  
           
     return;      return;
 }                                       /* end of b_free() */  }                                       /* end of b_free() */
Line 3149  static void scandblk (char *block, long Line 3309  static void scandblk (char *block, long
     char key0[256];      char key0[256];
   
     offset = UNSIGN (block[OFFS]) * 256 +      offset = UNSIGN (block[OFFS]) * 256 +
     UNSIGN (block[OFFS + 1]);          UNSIGN (block[OFFS + 1]);
           
     while (i < offset) {      while (i < offset) {
           
Line 3196  static void scandblk (char *block, long Line 3356  static void scandblk (char *block, long
  *  filedes:    global file descriptor   *  filedes:    global file descriptor
  *  blknbr:     number of new block   *  blknbr:     number of new block
  */   */
 static void getnewblk (int filedes, unsigned long *blknbr)  static void getnewblk (global_handle *g, unsigned long *blknbr)
 {  {
     char nblock[BLOCKLEN];      char nblock[BLOCKLEN];
     unsigned long freeblks, no_of_blks;      unsigned long freeblks, no_of_blks;
     long other;      long other;
     long offset;      long offset;
   
     lseek (filedes, ROOT, 0);      gbl_read_block (g, ROOT, nblock);
     read (filedes, nblock, BLOCKLEN);  
   
     freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]);      freeblks = UNSIGN (nblock[FREE]) * 65536 + UNSIGN (nblock[FREE + 1]) * 256 + UNSIGN (nblock[FREE + 2]);
     no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]);      no_of_blks = UNSIGN (nblock[NRBLK]) * 65536 + UNSIGN (nblock[NRBLK + 1]) * 256 + UNSIGN (nblock[NRBLK + 2]);
           
     if (freeblks) {      if (freeblks) {
           
         lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);          gbl_read_block (g, freeblks, nblock);
         read (filedes, nblock, BLOCKLEN);  
                   
         offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);          offset = UNSIGN (nblock[OFFS]) * 256 + UNSIGN (nblock[OFFS + 1]);
   
Line 3224  static void getnewblk (int filedes, unsi Line 3382  static void getnewblk (int filedes, unsi
             /* update RL-block, if any */              /* update RL-block, if any */
             if (other) {              if (other) {
   
                 lseek (filedes, (long) (other) * BLOCKLEN, 0);                  gbl_read_block (g, other, nblock);
                 read (filedes, nblock, BLOCKLEN);  
                                   
                 nblock[LLPTR] = 0;                  nblock[LLPTR] = 0;
                 nblock[LLPTR + 1] = 0;                  nblock[LLPTR + 1] = 0;
                 nblock[LLPTR + 2] = 0;                  nblock[LLPTR + 2] = 0;
                   
                 lseek (filedes, (long) (other) * BLOCKLEN, 0);                  gbl_write_block (g, other, nblock);
                 write (filedes, nblock, BLOCKLEN);  
   
             }              }
   
             /* update ROOT block */              /* update ROOT block */
             lseek (filedes, ROOT, 0);              gbl_read_block (g, ROOT, nblock);
             read (filedes, nblock, BLOCKLEN);  
                           
             nblock[FREE] = other / 65536;              nblock[FREE] = other / 65536;
             nblock[FREE + 1] = other % 65536 / 256;              nblock[FREE + 1] = other % 65536 / 256;
             nblock[FREE + 2] = other % 256;              nblock[FREE + 2] = other % 256;
               
             lseek (filedes, ROOT, 0);              gbl_write_block (g, ROOT, nblock);
             write (filedes, nblock, BLOCKLEN);  
                           
             return;              return;
   
Line 3257  static void getnewblk (int filedes, unsi Line 3411  static void getnewblk (int filedes, unsi
         nblock[offset + 1] = 0;          nblock[offset + 1] = 0;
         nblock[OFFS] = offset / 256;          nblock[OFFS] = offset / 256;
         nblock[OFFS + 1] = offset % 256;          nblock[OFFS + 1] = offset % 256;
           
         lseek (filedes, (long) (freeblks) * BLOCKLEN, 0);          gbl_write_block (g, freeblks, nblock);
         write (filedes, nblock, BLOCKLEN);  
                   
         return;          return;
   
Line 3270  static void getnewblk (int filedes, unsi Line 3423  static void getnewblk (int filedes, unsi
     nblock[NRBLK] = no_of_blks / 65536;      nblock[NRBLK] = no_of_blks / 65536;
     nblock[NRBLK + 1] = no_of_blks % 65536 / 256;      nblock[NRBLK + 1] = no_of_blks % 65536 / 256;
     nblock[NRBLK + 2] = no_of_blks % 256;      nblock[NRBLK + 2] = no_of_blks % 256;
       
     lseek (filedes, ROOT, 0);      gbl_write_block (g, ROOT, nblock);
     write (filedes, nblock, BLOCKLEN);  
           
     *blknbr = no_of_blks;      *blknbr = no_of_blks;
       
     for (;;) {  
   
         errno = 0;      gbl_write_block (g, no_of_blks, nblock);
           
         lseek (filedes, (long) (no_of_blks) * BLOCKLEN, 0);  
         write (filedes, nblock, BLOCKLEN);  
           
         if (errno == 0) break;  
   
         panic ();  
   
     }  
   
     return;      return;
   
Line 3416  static short int g_collate (char *t) Line 3557  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 3459  short g_numeric (char *str) Line 3599  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)
 {                                         {                                       
     register int i;      gbl_close_all ();
       
     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 3502  static void panic (void) Line 3631  static void panic (void)
   
 void gbl_dump_stat(void)  void gbl_dump_stat(void)
 {  {
     register int i;      global_handle *g;
           int ct;
     printf ("FreeM Global Statistics [PID %d]\r\n", pid);      int miss_pct;
       int hit_pct;
     printf ("%-10s%-20s%s\r\n", "USECT", "AGE", "FILE");      unsigned long access_total;   
     printf ("%-10s%-20s%s\r\n", "=====", "===", "====");      unsigned long hit_total;
           unsigned long mem_reads_total;
     for (i = 0; i < NO_GLOBLS; i++) {  
         printf ("%-10d%-20ld%s\r\n", usage[i], g_ages[i], oldfil[i]);          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 ("<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.5  
changed lines
  Added in v.1.22

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