tesseract_bin 1.0.0

data/vendor/tesseract-2.04/ccutil/memblk.cpp

@@ -0,0 +1,1106 @@
+/**********************************************************************
+ * File:        memblk.c  (Formerly memblock.c)
+ * Description: Enhanced instrumented memory allocator implemented as a class.
+ * Author:					Ray Smith
+ * Created:					Tue Jan 21 17:13:39 GMT 1992
+ *
+ * (C) Copyright 1992, Hewlett-Packard Ltd.
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ *
+ **********************************************************************/
+
+#include          "mfcpch.h"     //precompiled headers
+#include          <stdlib.h>
+#include          <string.h>
+#include          "stderr.h"
+#include          "memryerr.h"
+#include          "hashfn.h"
+#include          "tprintf.h"
+#include          "memry.h"
+#include          "memblk.h"
+#ifdef __UNIX__
+#include          <signal.h>
+#endif
+
+class UWREC
+{
+  public:
+    unsigned cur_frsize;         //frame size
+    unsigned cursp;              //stack
+    unsigned currls;             //pc space
+    unsigned currlo;             //pc offset
+    unsigned curdp;              //data pointer
+    unsigned toprp;              //rp
+    unsigned topmrp;             //mrp
+    unsigned topsr0;             //sr0
+    unsigned topsr4;             //sr4
+    unsigned r3;                 //gr3
+    unsigned cur_r19;            //gr19
+};
+
+MEMUNION *free_block = NULL;     //head of freelist
+
+#define EXTERN
+
+EXTERN MEM_ALLOCATOR big_mem;
+EXTERN MEM_ALLOCATOR main_mem;
+                                 //heads of freelists
+EXTERN MEMUNION *free_structs[MAX_STRUCTS];
+                                 //number issued
+EXTERN inT32 structs_in_use[MAX_STRUCTS];
+                                 //number issued
+EXTERN inT32 blocks_in_use[MAX_STRUCTS];
+                                 //head of block lists
+EXTERN MEMUNION *struct_blocks[MAX_STRUCTS];
+EXTERN const char *owner_names[MAX_STRUCTS][MAX_CLASSES];
+EXTERN inT32 owner_counts[MAX_STRUCTS][MAX_CLASSES];
+                                 //no of names
+EXTERN inT16 name_counts[MAX_STRUCTS];
+EXTERN inT32 free_struct_blocks; //no of free blocks
+
+EXTERN INT_VAR (mem_mallocdepth, 0, "Malloc stack depth to trace");
+EXTERN INT_VAR (mem_mallocbits, 8, "Log 2 of hash table size");
+EXTERN INT_VAR (mem_freedepth, 0, "Free stack dpeth to trace");
+EXTERN INT_VAR (mem_freebits, 8, "Log 2 of hash table size");
+EXTERN INT_VAR (mem_countbuckets, 16, "No of buckets for histogram");
+EXTERN INT_VAR (mem_checkfreq, 0, "Calls to alloc_mem between owner counts");
+
+/**********************************************************************
+ * MEM_ALLOCATOR::MEM_ALLOCATOR
+ *
+ * Constructor for a memory allocator.
+ **********************************************************************/
+
+void
+MEM_ALLOCATOR::init (            //initialize
+void *(*ext_malloc) (inT32),     //external source
+void (*ext_free) (void *),       //external free
+inT32 firstsize,                 //size of first block
+inT32 lastsize,                  //size of last block
+inT32 maxchunk                   //biggest request
+) {
+  blockcount = 0;
+  malloc_serial = 0;
+  topblock = NULL;
+  currblock = NULL;
+  callers = NULL;
+  malloc = ext_malloc;
+  free = ext_free;
+  maxsize = lastsize;
+  biggestblock = maxchunk;
+  totalmem = 0;
+  memsize = firstsize;
+  malloc_div_ratio = 1;
+  malloc_minor_serial = 0;
+  malloc_auto_count = 0;
+  call_bits = 0;
+  entries = 0;
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::hash_caller
+ *
+ * Generate a hash code for a caller, setup the tables if necessary.
+ **********************************************************************/
+
+uinT16 MEM_ALLOCATOR::hash_caller(            //get hash code
+                                  void *addr  //return address
+                                 ) {
+  inT32 index;                   //index to table
+  inT32 initial_hash;            //initial index
+
+  if (callers == NULL)
+    init_callers();  //setup table
+                                 //get hash code
+  initial_hash = hash (call_bits, &addr, sizeof (addr));
+  if (initial_hash == 0)
+    initial_hash = 1;
+  index = initial_hash;
+  if (callers[index].caller != NULL && callers[index].caller != addr) {
+    do {
+      index++;
+      if (index >= entries)
+        index = 1;
+    }
+    while (callers[index].caller != NULL
+      && callers[index].caller != addr && index != initial_hash);
+    if (index == initial_hash)
+      index = 0;
+  }
+  if (callers[index].caller == NULL) {
+    if (index != 0)
+      callers[index].caller = addr;
+    if (callers[index].free_list == NULL)
+                                 //setup free table
+      callers[index].init_freeers ();
+  }
+  return (uinT16) index;
+}
+
+
+/**********************************************************************
+ * MALLOC_CALL::count_freeer
+ *
+ * Generate a hash code for a freeer, setup the tables if necessary.
+ * Then count the call.
+ **********************************************************************/
+
+void MALLOC_CALL::count_freeer(            //count calls to free
+                               void *addr  //return address
+                              ) {
+  inT32 entries;                 //entries in table
+  inT32 index;                   //index to table
+  inT32 initial_hash;            //initial index
+
+  if (free_list == NULL)
+    init_freeers();  //setup table
+  entries = 1 << free_bits;
+                                 //get hash code
+  initial_hash = hash (free_bits, &addr, sizeof (addr));
+  if (initial_hash == 0)
+    initial_hash = 1;
+  index = initial_hash;
+  if (free_list[index].freeer != NULL && free_list[index].freeer != addr) {
+    do {
+      index++;
+      if (index >= entries)
+        index = 1;
+    }
+    while (free_list[index].freeer != NULL
+      && free_list[index].freeer != addr && index != initial_hash);
+    if (index == initial_hash)
+      index = 0;
+  }
+  if (free_list[index].freeer == NULL && index != 0) {
+    free_list[index].freeer = addr;
+  }
+  free_list[index].count++;      //count them
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::init_callers
+ *
+ * Initialize the callers hash table.
+ **********************************************************************/
+
+void MEM_ALLOCATOR::init_callers() {  //setup hash table
+  inT32 depth = mem_mallocdepth;
+
+  mem_mallocdepth.set_value (0); //can't register it
+  call_bits = mem_mallocbits;
+  entries = 1 << call_bits;
+                                 //make an array
+  callers = new MALLOC_CALL[entries];
+  mem_mallocdepth.set_value (depth);
+}
+
+
+/**********************************************************************
+ * MALLOC_CALL::init_freeers
+ *
+ * Initialize the freeers hash table.
+ **********************************************************************/
+
+void MALLOC_CALL::init_freeers() {  //setup hash table
+  inT32 entries;                 //entries in table
+  inT32 depth = mem_mallocdepth;
+
+  mem_mallocdepth.set_value (0); //can't register it
+  free_bits = mem_freebits;
+  entries = 1 << free_bits;
+                                 //make an array
+  free_list = new FREE_CALL[entries];
+  mem_mallocdepth.set_value (depth);
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::reduce_counts
+ *
+ * Divide all ages by 2 to get a log use of counts.
+ **********************************************************************/
+
+void MEM_ALLOCATOR::reduce_counts() {  //divide by 2
+  MEMBLOCK *block;               //current block
+  MEMUNION *chunk;               //current chunk
+  inT32 chunksize;               //size of chunk
+  inT32 blockindex;              //index of block
+
+  check_mem ("Reducing counts", JUSTCHECKS);
+  for (blockindex = 0; blockindex < blockcount; blockindex++) {
+                                 //current block
+    block = &memblocks[blockindex];
+                                 //scan all chunks
+    for (chunk = block->blockstart; chunk != block->blockend; chunk += chunksize) {
+      chunksize = chunk->size;   //size of chunk
+      if (chunksize < 0)
+        chunksize = -chunksize;  //absolute size
+      chunk->age /= 2;           //divide ages
+    }
+  }
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::display_counts
+ *
+ * Send counts of outstanding blocks to stderr.
+ **********************************************************************/
+
+void MEM_ALLOCATOR::display_counts() {  //count up
+  MEMBLOCK *block;               //current block
+  MEMUNION *chunk;               //current chunk
+  inT32 chunksize;               //size of chunk
+  inT32 blockindex;              //index of block
+  inT32 buckets;                 //required buckets
+  inT32 bucketsize;              //no in each bucket
+  inT32 callindex;               //index to callers
+  inT32 freeindex;               //index to freeers
+  inT32 freeentries;             //table size
+  inT32 totalchunks;             //total chunk counts
+  inT32 totalspace;              //total mem space
+  inT32 totalpchunks;            //permanent chunks
+  inT32 totalpspace;             //permanent space
+  inT32 totalfrees;              //total free calls
+
+  if (callers == NULL)
+    return;                      //can't do anything
+  check_mem ("Displaying counts", JUSTCHECKS);
+  buckets = mem_countbuckets;
+  bucketsize = (malloc_serial - 1) / buckets + 1;
+  tprintf ("\nEach bucket covers %g counts.\n",
+    (double) bucketsize * malloc_div_ratio);
+  for (callindex = 0; callindex < entries; callindex++) {
+    if (callers[callindex].free_list != NULL) {
+      callers[callindex].counts =
+        (inT32 *) malloc (buckets * 4 * sizeof (inT32));
+      memset (callers[callindex].counts, 0,
+        (size_t) (buckets * 4 * sizeof (inT32)));
+    }
+  }
+  for (blockindex = 0; blockindex < blockcount; blockindex++) {
+                                 //current block
+    block = &memblocks[blockindex];
+                                 //scan all chunks
+    for (chunk = block->blockstart; chunk != block->topchunk; chunk += chunksize) {
+      chunksize = chunk->size;   //size of chunk
+      if (chunksize < 0) {
+        chunksize = -chunksize;  //absolute size
+        callindex = chunk->owner;
+        if (callers[callindex].counts != NULL) {
+          callers[callindex].counts[chunk->age / bucketsize * 4]++;
+          callers[callindex].counts[chunk->age / bucketsize * 4 +
+            1] += chunksize;
+        }
+      }
+    }
+                                 //scan all chunks
+    for (; chunk != block->blockend; chunk += chunksize) {
+      chunksize = chunk->size;   //size of chunk
+      if (chunksize < 0) {
+        chunksize = -chunksize;  //absolute size
+        callindex = chunk->owner;
+        if (callers[callindex].counts != NULL) {
+          callers[callindex].counts[chunk->age / bucketsize * 4 +
+            2]++;
+          callers[callindex].counts[chunk->age / bucketsize * 4 +
+            3] += chunksize;
+        }
+      }
+    }
+  }
+  for (callindex = 0; callindex < entries; callindex++) {
+    if (callers[callindex].counts != NULL) {
+      for (totalspace = 0, totalchunks = 0, totalpspace =
+        0, totalpchunks = 0, freeindex = 0; freeindex < buckets;
+      freeindex++) {
+        totalchunks += callers[callindex].counts[freeindex * 4];
+        totalspace += callers[callindex].counts[freeindex * 4 + 1];
+        totalpchunks += callers[callindex].counts[freeindex * 4 + 2];
+        totalpspace += callers[callindex].counts[freeindex * 4 + 3];
+      }
+      freeentries = 1 << callers[callindex].free_bits;
+      for (totalfrees = 0, freeindex = 0; freeindex < freeentries;
+        freeindex++)
+      totalfrees += callers[callindex].free_list[freeindex].count;
+      if (totalspace != 0 || totalfrees != 0) {
+        tprintf ("alloc_mem at %d : total held=%d(%d), frees=%d.\n",
+          callers[callindex].caller,
+          totalchunks, totalspace * sizeof (MEMUNION),
+          totalfrees);
+      }
+      if (totalspace > 0) {
+        for (freeindex = 0; freeindex < buckets; freeindex++) {
+          tprintf ("%d(%d) ",
+            callers[callindex].counts[freeindex * 4],
+            callers[callindex].counts[freeindex * 4 +
+            1] * sizeof (MEMUNION));
+        }
+        tprintf ("\n");
+      }
+      if (totalfrees != 0) {
+        tprintf ("Calls to free : ");
+        for (freeindex = 0; freeindex < freeentries; freeindex++) {
+          if (callers[callindex].free_list[freeindex].count != 0)
+            tprintf ("%d : %d ",
+              callers[callindex].free_list[freeindex].freeer,
+              callers[callindex].free_list[freeindex].count);
+        }
+        tprintf ("\n");
+      }
+      if (totalpspace != 0) {
+        tprintf ("alloc_mem_p at %d : total held=%d(%d).\n",
+          callers[callindex].caller,
+          totalpchunks, totalpspace * sizeof (MEMUNION));
+        for (freeindex = 0; freeindex < buckets; freeindex++) {
+          tprintf ("%d(%d) ",
+            callers[callindex].counts[freeindex * 4 + 2],
+            callers[callindex].counts[freeindex * 4 +
+            3] * sizeof (MEMUNION));
+        }
+        tprintf ("\n");
+      }
+      free (callers[callindex].counts);
+      callers[callindex].counts = NULL;
+    }
+  }
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::check
+ *
+ * Check consistency of all memory controlled by this allocator.
+ **********************************************************************/
+
+void MEM_ALLOCATOR::check(                     //check consistency
+                          const char *string,  //context message
+                          inT8 level           //level of check
+                         ) {
+  MEMBLOCK *block;               //current block
+  MEMUNION *chunk;               //current chunk
+  MEMUNION *prevchunk;           //previous chunk
+  inT32 chunksize;               //size of chunk
+  inT32 usedcount;               //no of used chunks
+  inT32 usedsize;                //size of used chunks
+  inT32 freecount;               //no of free chunks
+  inT32 freesize;                //size of free chunks
+  inT32 biggest;                 //biggest free chunk
+  inT32 totusedcount;            //no of used chunks
+  inT32 totusedsize;             //size of used chunks
+  inT32 totfreecount;            //no of free chunks
+  inT32 totfreesize;             //size of free chunks
+  inT32 totbiggest;              //biggest free chunk
+  inT32 totblocksize;            //total size of blocks
+  inT32 chunkindex;              //index of chunk
+  inT32 blockindex;              //index of block
+
+  if (level >= MEMCHECKS)
+    tprintf ("\nMEM_ALLOCATOR::check:at '%s'\n", string);
+  totusedcount = 0;              //grand totals
+  totusedsize = 0;
+  totfreecount = 0;
+  totfreesize = 0;
+  totbiggest = 0;
+  totblocksize = 0;
+  for (blockindex = 0; blockindex < blockcount; blockindex++) {
+                                 //current block
+    block = &memblocks[blockindex];
+    if (level >= MEMCHECKS)
+      tprintf ("Block %d:0x%x-0x%x, size=%d, top=0x%x, l=%d, u=%d\n",
+        blockindex, block->blockstart, block->blockend,
+        (block->blockend - block->blockstart) * sizeof (MEMUNION),
+        block->topchunk, block->lowerspace, block->upperspace);
+    usedcount = usedsize = 0;    //zero counters
+    freecount = freesize = 0;    //zero counters
+    biggest = 0;
+                                 //scan all chunks
+    for (chunkindex = 0, prevchunk = NULL, chunk = block->blockstart; chunk != block->blockend; chunkindex++, chunk += chunksize) {
+      chunksize = chunk->size;   //size of chunk
+      if (chunksize < 0)
+        chunksize = -chunksize;  //absolute size
+      if (level >= FULLMEMCHECKS) {
+        tprintf ("%5d=%8d%c caller=%d, age=%d ", (int) chunkindex,
+          chunksize * sizeof (MEMUNION),
+          chunk->size < 0 ? 'U' : 'F', chunk->owner, chunk->age);
+        if (chunkindex % 5 == 4)
+          tprintf ("\n");
+      }
+                                 //illegal sizes
+      if (chunksize == 0 || chunk->size == -1
+                                 //out of bounds
+        || chunk + chunksize - block->blockstart <= 0 || block->blockend - (chunk + chunksize) < 0)
+        BADMEMCHUNKS.error ("check_mem", ABORT,
+          "Block=%p, Prev chunk=%p, Chunk=%p, Size=%x",
+          block, prevchunk, chunk,
+          (int) chunk->size);
+
+      else if (chunk->size < 0) {
+        usedcount++;             //used block
+        usedsize += chunksize;
+      }
+      else {
+        freecount++;             //free block
+        freesize += chunksize;
+        if (chunksize > biggest)
+          biggest = chunksize;
+      }
+      prevchunk = chunk;
+    }
+    if (level >= MEMCHECKS) {
+      if (level >= FULLMEMCHECKS)
+        tprintf ("\n");
+      tprintf ("%d chunks in use, total size=%d bytes\n",
+        (int) usedcount, usedsize * sizeof (MEMUNION));
+      tprintf ("%d chunks free, total size=%d bytes\n",
+        (int) freecount, freesize * sizeof (MEMUNION));
+      tprintf ("Largest free fragment=%d bytes\n",
+        biggest * sizeof (MEMUNION));
+    }
+    totusedcount += usedcount;   //grand totals
+    totusedsize += usedsize;
+    totfreecount += freecount;
+    totfreesize += freesize;
+    if (biggest > totbiggest)
+      totbiggest = biggest;
+    totblocksize += block->blockend - block->blockstart;
+  }
+  if (level >= MEMCHECKS) {
+    tprintf ("%d total blocks in use, total size=%d bytes\n",
+      blockcount, totblocksize * sizeof (MEMUNION));
+    tprintf ("%d total chunks in use, total size=%d bytes\n",
+      (int) totusedcount, totusedsize * sizeof (MEMUNION));
+    tprintf ("%d total chunks free, total size=%d bytes\n",
+      (int) totfreecount, totfreesize * sizeof (MEMUNION));
+    tprintf ("Largest free fragment=%d bytes\n",
+      totbiggest * sizeof (MEMUNION));
+  }
+  if (level >= MEMCHECKS)
+    display_counts();
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::alloc_p
+ *
+ * Allocate permanent space which will never be returned.
+ * This space is allocated from the top end of a memory block to
+ * avoid the fragmentation which would result from alternate use
+ * of alloc_mem for permanent and temporary blocks.
+ **********************************************************************/
+
+void *MEM_ALLOCATOR::alloc_p(              //permanent space
+                             inT32 count,  //block size to allocate
+                             void *caller  //ptr to caller
+                            ) {
+  MEMBLOCK *block;               //current block
+  MEMUNION *chunk;               //current chunk
+
+  if (count < 1 || count > biggestblock)
+                                 //request too big
+    MEMTOOBIG.error ("alloc_mem_p", ABORT, "%d", (int) count);
+
+  count += sizeof (MEMUNION) - 1;//round up to word
+  count /= sizeof (MEMUNION);
+  count++;                       //and add one
+  if (topblock == NULL) {
+    topblock = new_block (count);//get first block
+    currblock = topblock;
+    if (topblock == NULL) {
+      check_mem ("alloc_mem_p returning NULL", MEMCHECKS);
+      return NULL;
+    }
+  }
+  block = topblock;              //current block
+  do {
+    chunk = block->topchunk;
+    if (chunk->size < count)
+      block = block->next;       //try next block
+  }
+                                 //until all tried
+  while (chunk->size < count && block != topblock);
+  if (chunk->size < count) {     //still no good
+    chunk = (MEMUNION *) alloc ((count - 1) * sizeof (MEMUNION), caller);
+    //try last resort
+    if (chunk != NULL)
+      return chunk;
+    check_mem ("alloc_mem_p returning NULL", MEMCHECKS);
+    return NULL;
+  }
+  block->upperspace -= count;    //less above freechunk
+  if (chunk->size > count) {
+    chunk->size -= count;
+    chunk += chunk->size;
+  }
+  chunk->size = -count;          //mark as in use
+  if (mem_mallocdepth > 0) {
+    set_owner(chunk, caller);
+  }
+  else {
+    chunk->owner = 0;
+    chunk->age = 0;
+  }
+  return chunk + 1;              //created chunk
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::alloc
+ *
+ * Return a pointer to a buffer of count bytes aligned for any type.
+ **********************************************************************/
+
+void *MEM_ALLOCATOR::alloc(              //get memory
+                           inT32 count,  //no of bytes to get
+                           void *caller  //ptr to caller
+                          ) {
+  MEMBLOCK *block;               //current block
+  MEMUNION *chunk;               //current chunk
+  inT32 chunksize;               //size of free chunk
+  MEMUNION *chunkstart;          //start of free chunk
+
+  if (count < 1 || count > biggestblock)
+    MEMTOOBIG.error ("alloc_mem", ABORT, "%d", (int) count);
+  //request too big
+
+  count += sizeof (MEMUNION) - 1;//round up to word
+  count /= sizeof (MEMUNION);
+  count++;                       //and add one
+  if (currblock == NULL) {
+                                 //get first block
+    currblock = new_block (count);
+    topblock = currblock;
+    if (currblock == NULL) {
+      check_mem ("alloc_mem returning NULL", MEMCHECKS);
+      return NULL;
+    }
+  }
+  block = currblock;             //current block
+  if (block->upperspace <= block->lowerspace) {
+                                 //restart chunklist
+    block->freechunk = block->blockstart;
+    block->upperspace += block->lowerspace;
+    block->lowerspace = 0;       //correct space counts
+  }
+  chunk = block->freechunk;      //current free chunk
+  if (chunk->size < count) {     //big enough?
+    do {
+                                 //search for free chunk
+      chunk = block->find_chunk (count);
+      if (chunk->size < count)
+        block = block->next;     //try next block
+    }
+                                 //until all tried
+    while (chunk->size < count && block != currblock);
+    if (chunk->size < count) {   //still no good
+                                 //get a new block
+      currblock = new_block (count);
+      topblock = currblock;      //set perms here too
+      if (currblock == NULL) {
+        check_mem ("alloc_mem returning NULL", MEMCHECKS);
+        return NULL;
+      }
+      block = currblock;
+      chunk = block->freechunk;  //bound to be big enough
+    }
+  }
+  chunkstart = chunk;            //start of chunk
+  if (chunk == block->topchunk && chunk + count != block->blockend)
+    block->topchunk += count;    //top has moved
+  block->upperspace -= count;    //upper part used
+  chunksize = chunk->size;       //size of free chunk
+  chunk->size = -count;          //mark as used
+  chunk += count;                //next free space
+  totalmem -= count;             //no of free elements
+  if (chunksize > count)         //bigger than exact?
+                                 //remaining space
+    chunk->size = chunksize - count;
+  else if (chunk == block->blockend) {
+    chunk = block->blockstart;   //restart block
+    block->upperspace = block->lowerspace;
+    block->lowerspace = 0;       //fix space counts
+  }
+  block->freechunk = chunk;      //next free block
+  if (mem_mallocdepth > 0) {
+    set_owner(chunkstart, caller);
+  }
+  else {
+    chunkstart->owner = 0;
+    chunkstart->age = 0;
+  }
+  chunkstart++;                  //start of block
+  return chunkstart;             //pointer to block
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::set_owner
+ *
+ * Set the owner and time stamp of the block and check if needed.
+ **********************************************************************/
+
+void MEM_ALLOCATOR::set_owner(                       //get memory
+                              MEMUNION *chunkstart,  //chunk to set
+                              void *caller           //ptr to caller
+                             ) {
+  uinT16 callindex;              //hash code
+
+  callindex = hash_caller (caller);
+  chunkstart->owner = callindex;
+                                 //store evidence
+  chunkstart->age = malloc_serial;
+  malloc_minor_serial++;
+  if (malloc_minor_serial >= malloc_div_ratio) {
+    malloc_minor_serial = 0;
+    malloc_serial++;             //count calls
+    if (malloc_serial == 0) {
+                                 //wrap around
+      reduce_counts();  //fix serial numbers
+      malloc_serial = MAX_INT16 + 1;
+                                 //all worth double
+      malloc_div_ratio += malloc_div_ratio;
+    }
+  }
+  malloc_auto_count++;
+  if (mem_checkfreq > 0 && malloc_auto_count >= (uinT32) mem_checkfreq) {
+    malloc_auto_count = 0;
+    check_mem ("Auto check", MEMCHECKS);
+  }
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::dealloc
+ *
+ * Free a block allocated by alloc (or alloc_p).
+ * It checks that the pointer is legal and maintains counts of the
+ * amount of free memory above and below the current free pointer.
+ **********************************************************************/
+
+void MEM_ALLOCATOR::dealloc(                 //free memory
+                            void *oldchunk,  //chunk to free
+                            void *caller     //ptr to caller
+                           ) {
+  MEMUNION *chunk;               //current chunk
+  MEMBLOCK *block;               //current block
+
+  if (oldchunk == NULL)
+    FREENULLPTR.error ("free_mem", ABORT, NULL);
+  chunk = (MEMUNION *) oldchunk;
+  block = currblock;             //current block
+  if (block == NULL)
+    NOTMALLOCMEM.error ("free_mem", ABORT, NULL);
+  do {
+    block = block->next;
+  }
+                                 //outside the block
+  while ((chunk - block->blockstart < 0 || block->blockend - chunk <= 0)
+    && block != currblock);
+
+  if (chunk - block->blockstart < 0 || block->blockend - chunk <= 0)
+                                 //in no block
+    NOTMALLOCMEM.error ("free_mem", ABORT, NULL);
+
+  chunk--;                       //point to size
+  if (chunk->size == 0)
+                                 //zero size
+    FREEILLEGALPTR.error ("free_mem", ABORT, NULL);
+  else if (chunk->size > 0)
+                                 //already free
+    FREEFREEDBLOCK.error ("free_mem", ABORT, NULL);
+  chunk->size = -chunk->size;    //mark it free
+  if (mem_freedepth > 0 && callers != NULL) {
+                                 //count calls
+    callers[chunk->owner].count_freeer (caller);
+  }
+  totalmem += chunk->size;       //total free memory
+  if (chunk - block->freechunk < 0)
+                                 //extra below
+    block->lowerspace += chunk->size;
+  else
+                                 //extra above
+    block->upperspace += chunk->size;
+}
+
+
+/**********************************************************************
+ * MEM_ALLOCATOR::new_block
+ *
+ * Gets a new big block of memory from malloc for use by alloc_mem.
+ **********************************************************************/
+
+MEMBLOCK *MEM_ALLOCATOR::new_block(               //get new big block
+                                   inT32 minsize  //minimum size
+                                  ) {
+  MEMBLOCK *newblock;            //new block
+
+  if (blockcount >= MAXBLOCKS) {
+                                 //can't have another
+    NOMOREBLOCKS.error ("mem_new_block", TESSLOG, NULL);
+    return NULL;
+  }
+  if (mem_checkfreq != 0) {
+    tprintf ("\nGetting new block due to request size of %d",
+      minsize * sizeof (MEMUNION));
+    tprintf (" from %d from %d from %d from %d from %d\n",
+      trace_caller (3), trace_caller (4), trace_caller (5),
+      trace_caller (6), trace_caller (7));
+    check_mem ("Getting new block", MEMCHECKS);
+  }
+                                 //get a new one
+  newblock = &memblocks[blockcount++];
+  while (memsize < minsize)
+    memsize *= 4;                //go up in sizes
+                                 //get a big block
+  newblock->blockstart = (MEMUNION *)
+    malloc (memsize * sizeof (MEMUNION));
+  if (newblock->blockstart == NULL) {
+    NOMOREMEM.error ("mem_new_block", TESSLOG, NULL);
+
+    #ifdef __UNIX__
+    raise(SIGTTOU);  //hangup for js
+    #endif
+    return NULL;
+  }
+                                 //end of block
+  newblock->blockend = newblock->blockstart + memsize;
+                                 //first free chunk
+  newblock->freechunk = newblock->blockstart;
+  newblock->topchunk = newblock->blockstart;
+  newblock->lowerspace = 0;
+  newblock->upperspace = memsize;//amount available
+                                 //set pointer
+  newblock->freechunk->size = memsize;
+  newblock->freechunk->owner = 0;
+  newblock->freechunk->age = 0;
+
+  totalmem += memsize;           //total assigned mem
+
+  if (memsize < maxsize)
+    memsize *= 4;                //successively bigger
+  if (currblock == NULL) {
+    newblock->next = newblock;   //first block
+  }
+  else {
+                                 //insert in list
+    newblock->next = currblock->next;
+    currblock->next = newblock;
+  }
+  return newblock;               //new block
+}
+
+
+/**********************************************************************
+ * MEMBLOCK::find_chunk
+ *
+ * Find a chunk within the block which is big enough for the given request
+ **********************************************************************/
+
+MEMUNION *MEMBLOCK::find_chunk(             //find free chunk
+                               inT32 count  //size required
+                              ) {
+  MEMUNION *chunk;               //current chunk
+  inT32 chunksize;               //size of free chunk
+  MEMUNION *chunkstart;          //start of free chunk
+  inT32 spaceshift;              //shift in lowerspace
+
+  if (upperspace <= lowerspace) {
+    freechunk = blockstart;      //restart chunklist
+    upperspace += lowerspace;
+    lowerspace = 0;              //correct space counts
+  }
+  chunk = freechunk;             //current free chunk
+  if (chunk->size < count) {     //big enough?
+    spaceshift = 0;
+    do {
+      while (chunk->size < 0) {  //find free chunk
+        chunk -= chunk->size;    //skip forward
+        if (chunk == blockend) {
+          chunk = blockstart;    //restart block
+                                 //gone back to start
+          spaceshift = -lowerspace;
+        }
+        if (chunk == freechunk)
+          return chunk;          //gone all round & failed
+      }
+      chunkstart = chunk;        //start of chunk
+      chunksize = chunk->size;;
+      chunk += chunk->size;
+      while (chunk != blockend   //until end
+      && chunk->size > 0) {      //or used
+        chunksize += chunk->size;//coalesce free blocks
+                                 //gone all round
+        if (chunk == freechunk) {
+                                 //ensure it is at end
+          freechunk += chunk->size;
+          upperspace -= chunk->size;
+          lowerspace += chunk->size;
+          spaceshift -= chunk->size;
+        }
+        if (chunk == topchunk)   //got back to end one
+          topchunk = chunkstart; //end one bigger
+        chunk += chunk->size;    //get next block
+      }
+                                 //new big block
+      chunkstart->size = chunksize;
+      if (chunksize < count)
+        spaceshift += chunksize; //skipping free block
+      if (chunk == blockend) {
+        chunk = blockstart;      //back to start
+        if (freechunk == blockend) {
+          freechunk = blockstart;//so is freechunk
+          upperspace += lowerspace;
+          lowerspace = 0;
+          spaceshift = 0;
+        }
+        else
+                                 //so is shift
+            spaceshift = -lowerspace;
+      }
+    }
+    while (chunksize < count && chunk != freechunk);
+    if (chunksize < count)
+      return chunk;              //failed
+    lowerspace += spaceshift;    //get space counts right
+    upperspace -= spaceshift;
+    freechunk = chunkstart;
+    return chunkstart;           //success
+  }
+  return chunk;                  //easy
+}
+
+
+#ifdef __UNIX__
+/**********************************************************************
+ * trace_caller
+ *
+ * Return the return address of the caller at a given depth back.
+ * 0 gives the return address of the caller to trace_caller.
+ * S300 ONLY!!
+ **********************************************************************/
+//#pragma OPTIMIZE OFF                                                                                                  /*force link*/
+
+void *trace_caller(             //trace stack
+                   inT32 depth  //depth to trace
+                  ) {
+  #ifdef hp9000s800
+
+  unsigned sp, pc, rp;           //registers
+  UWREC rec1;                    //for unwinder
+  UWREC rec2;
+
+  sp = (unsigned) (&depth + 9);
+  pc = *(int *) (sp - 20);
+  rp = 0;
+  get_pcspace(&rec1, pc);
+  rec1.cur_frsize = 0xc0;
+  rec1.currlo = pc & ~3;
+  rec1.curdp = 0;
+  rec1.toprp = rp;
+
+  while (depth > 0) {
+    if (U_get_previous_frame (&rec1, &rec2))
+      return NULL;
+    rec1.currlo = rec2.currlo;
+    rec1.cur_frsize = rec2.cur_frsize;
+    rec1.cursp = rec2.cursp;
+    rec1.currls = rec2.currls;
+    rec1.curdp = rec2.curdp;
+    depth--;
+  }
+  return (void *) rec1.currlo;
+  #else
+  void *a6;                      //address register
+
+  a6 = &depth - 2;
+  while (depth > 0) {
+    a6 = *(void **) a6;          //follow chain
+    depth--;
+  }
+  return *((void **) a6 + 1);
+  #endif
+}
+
+
+//#pragma OPTIMIZE ON
+
+#else
+
+// Fake procedure for non-UNIX
+void *trace_caller(             //trace stack
+                   inT32 depth  //depth to trace
+                  ) {
+  return NULL;
+}
+#endif
+
+/**********************************************************************
+ * identify_struct_owner
+ *
+ * Get an index into the table of owners of structures.
+ * Implemented very inefficiently, but only a debug tool!
+ **********************************************************************/
+
+inT32 identify_struct_owner(                     //get table index
+                            inT32 struct_count,  //cell size
+                            const char *name     //name of type
+                           ) {
+  inT32 index;                   //index to structure
+
+  for (index = 0; index < name_counts[struct_count]
+    && strcmp (name, owner_names[struct_count][index]); index++);
+  if (index < MAX_CLASSES) {
+    if (index == name_counts[struct_count]) {
+      name_counts[struct_count]++;
+      owner_names[struct_count][index] = name;
+      owner_counts[struct_count][index] = 0;
+    }
+  }
+  return index;
+}
+
+
+/**********************************************************************
+ * check_struct
+ *
+ * Check a particular structure size for consistency.
+ **********************************************************************/
+
+void check_struct(             //check a structure
+                  inT8 level,  //print control
+                  inT32 count  //no of bytes
+                 ) {
+  MEMUNION *element;             //current element
+  MEMUNION *block;               //current block
+  inT32 struct_count;            //no of required structs
+  inT32 block_count;             //no of structure blocks
+  inT32 free_count;              //size of freelist*/
+  inT32 name_index;              //named holder
+  inT32 named_total;             //total held by names
+
+                                 //no of MEMUNIONS-1
+  struct_count = (count - 1) / sizeof (MEMUNION);
+  if (struct_count < 0 || struct_count >= MAX_STRUCTS)
+                                 //request too big
+    MEMTOOBIG.error ("check_struct", ABORT, "%d", (int) count);
+
+  free_count = 0;                //size of freelist
+                                 //count blocks
+  for (block_count = 0, block = struct_blocks[struct_count]; block != NULL; block = block->ptr, block_count++);
+  if (block_count > 0) {
+                                 //scan freelist
+    for (element = free_structs[struct_count]; element != NULL; element = element->ptr)
+      free_count++;
+    if (level >= MEMCHECKS) {
+      tprintf ("No of structs of size %d in use=%d,",
+        (int) count, (int) structs_in_use[struct_count]);
+      tprintf (" %d free", free_count);
+      tprintf (" in %d blocks, total space=%d\n",
+        (int) block_count,
+        block_count * STRUCT_BLOCK_SIZE * sizeof (MEMUNION));
+      for (named_total = 0, name_index = 0;
+      name_index < name_counts[struct_count]; name_index++) {
+        tprintf ("No held by %s=%d\n",
+          owner_names[struct_count][name_index],
+          owner_counts[struct_count][name_index]);
+        named_total += owner_counts[struct_count][name_index];
+      }
+      tprintf ("Total held by names=%d\n", named_total);
+    }
+  }
+  if (structs_in_use[struct_count] + free_count
+    != block_count * (STRUCT_BLOCK_SIZE / (struct_count + 1) - 1))
+    BADSTRUCTCOUNT.error ("check_struct", ABORT, "%d+%d=%d",
+      structs_in_use[struct_count], free_count,
+      block_count * (STRUCT_BLOCK_SIZE /
+      (struct_count + 1) - 1));
+}
+
+
+/**********************************************************************
+ * check_structs
+ *
+ * Reports statistics on each maintained structure type by calling
+ * free_struct(NULL) on each.  Only active structure types are reported.
+ **********************************************************************/
+
+void check_structs(            //count in use on structs
+                   inT8 level  //print control
+                  ) {
+  inT8 index;                    //index to structs
+
+  for (index = 1; index <= MAX_STRUCTS; index++)
+                                 //check number allocated
+    check_struct (level, index * sizeof (MEMUNION));
+}
+
+
+/**********************************************************************
+ * new_struct_block
+ *
+ * Allocate space for a new block of structures.  The space is obtained
+ * from alloc_mem, and a freelist of such blocks is maintained for when
+ * the individual structure types get completely freed.
+ **********************************************************************/
+
+void *new_struct_block() {  //allocate memory
+  MEMUNION *element;             //current element
+  MEMUNION *returnelement;       //return value
+
+  returnelement = free_block;
+  if (returnelement == NULL) {
+                                 //need a new block
+    element =
+      (MEMUNION *) alloc_mem_p (STRUCT_BLOCK_SIZE * sizeof (MEMUNION));
+    if (element == NULL)
+      return NULL;               //can't get more
+    returnelement = element;     //going to return 1st
+  }
+  else {
+                                 //new free one
+    free_block = returnelement->ptr;
+  }
+  return returnelement;          //free cell
+}
+
+
+/**********************************************************************
+ * old_struct_block
+ *
+ * Free memory allocated by new_struct_block.  The block is returned
+ * to a freelist ready for a new call to new_struct_block.
+ * This saves confusion over freeing "permanent" blocks, yet
+ * allows them to be recycled for different structures.
+ **********************************************************************/
+
+void old_struct_block(                     //free a structure block
+                      MEMUNION *deadblock  //block to free
+                     ) {
+  if (deadblock != NULL) {
+    deadblock->ptr = free_block; //add to freelist
+    free_block = deadblock;
+    free_struct_blocks++;
+  }
+  if (free_struct_blocks > MAX_FREE_S_BLOCKS) {
+    MEMUNION *next_block;        //next in list
+    deadblock = free_block;
+    do {
+      next_block = deadblock->ptr;
+      free_mem(deadblock);  //really free it
+      deadblock = next_block;
+    }
+    while (deadblock != NULL);
+    free_struct_blocks = 0;
+    free_block = NULL;
+  }
+}