home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / adaptor.zip / adapt.zip / adaptor / src / stringme.c < prev    next >
Text File  |  1994-01-03  |  5KB  |  176 lines
  1. /* $Id: StringMem.c,v 1.11 1992/05/05 13:19:05 grosch rel $ */
  2.  
  3. /* $Log: StringMem.c,v $
  4.  * Revision 1.11  1992/05/05  13:19:05  grosch
  5.  * added rcsid
  6.  *
  7.  * Revision 1.10  1992/02/18  12:52:30  grosch
  8.  * changed tString from unsigned char * to char *
  9.  *
  10.  * Revision 1.9  1992/01/31  16:31:44  grosch
  11.  * adaption to ANSI C
  12.  *
  13.  * Revision 1.8  1992/01/30  13:12:51  grosch
  14.  * complete redesign: pointer instead of array index
  15.  *
  16.  * Revision 1.7  1992/01/14  15:24:35  grosch
  17.  * introduced automatic initialization
  18.  *
  19.  * Revision 1.6  1991/11/21  14:28:16  grosch
  20.  * new version of RCS on SPARC
  21.  *
  22.  * Revision 1.5  91/07/17  17:23:46  grosch
  23.  * introduced ARGS trick for ANSI compatibility
  24.  *
  25.  * Revision 1.4  91/01/21  12:13:25  grosch
  26.  * some performance improvements
  27.  *
  28.  * Revision 1.3  90/09/20  09:12:28  grosch
  29.  * calmed down lint
  30.  *
  31.  * Revision 1.2  90/07/04  14:34:07  grosch
  32.  * introduced conditional include
  33.  *
  34.  * Revision 1.1  89/08/23  16:04:27  grosch
  35.  * bug fix in PutString: stringReg initialized later
  36.  *
  37.  * Revision 1.0  88/10/04  11:44:47  grosch
  38.  * Initial revision
  39.  *
  40.  */
  41.  
  42. /* Ich, Doktor Josef Grosch, Informatiker, Sept. 1987 */
  43.  
  44. static char rcsid [] = "$Id: StringMem.c,v 1.11 1992/05/05 13:19:05 grosch rel $";
  45.  
  46. # include "ratc.h"
  47. # include "StringMe.h"
  48. # include "General.h"
  49. # include "Memory.h"
  50.  
  51. # define MemorySize    1024 * 20
  52.  
  53. typedef struct sBlock {
  54.    struct sBlock *    Next;
  55.    tStringRef        Last;
  56.    char            Memory [MemorySize];
  57. } tBlock;
  58.  
  59. struct lBlock {
  60.    struct lBlock *    Next;
  61.    tStringRef        Last;
  62. };
  63.  
  64. static    tBlock *    BlockList    = NULL;
  65. static    unsigned long    MemorySpaceLeft    = 0;
  66. static    tStringRef    MemoryFreePtr;
  67.  
  68. tStringRef PutString
  69. # ifdef __STDC__
  70.    (register char * string, register cardinal length)
  71. # else
  72.    (string, length)
  73.    register char *    string;
  74.    register cardinal    length;
  75. # endif
  76.    {
  77.       register char *    stringReg;
  78.       register long    NeededSpace    = (length + 3) & 0xfffffffe;
  79.       register tStringRef StartPtr;
  80.  
  81.       if (MemorySpaceLeft < NeededSpace) {
  82.      tBlock * BlockPtr;
  83.      if (BlockList != NULL) {
  84.  
  85.         char * FreePtr = (char *) (((long) MemoryFreePtr + yyMaxAlign - 1) & yyAlignMasks [yyMaxAlign]);
  86.         unsigned long Rest = MemorySpaceLeft - (FreePtr - (char *) MemoryFreePtr);
  87.         if (Rest >= yyMaxAlign) Free (Rest, FreePtr);
  88.         BlockList->Last = MemoryFreePtr;
  89.      }
  90.      MemorySpaceLeft = Max (NeededSpace, MemorySize);
  91.      BlockPtr = (tBlock *) Alloc (MemorySpaceLeft + sizeof (struct lBlock));
  92.  
  93.      BlockPtr->Next = BlockList;
  94.      BlockList = BlockPtr;
  95.      MemoryFreePtr = (tStringRef) BlockPtr->Memory;
  96.       }
  97.       StartPtr = MemoryFreePtr;
  98.       * StartPtr = length;
  99.       stringReg = (char *) MemoryFreePtr + 2;
  100.       while (length -- > 0) * stringReg ++ = * string ++;
  101.       MemorySpaceLeft -= NeededSpace;
  102.       MemoryFreePtr   += NeededSpace >> 1;
  103.       return StartPtr;
  104.    }
  105.  
  106. void StGetString (stringref, string)
  107.    register tStringRef    stringref;
  108.    register char *    string;
  109.    {
  110.       register cardinal    length      = LengthSt (stringref);
  111.       register char *    stringReg = (char *) stringref + 2;
  112.  
  113.       while (length -- > 0) * string ++ = * stringReg ++;
  114.       * string = '\0';
  115.    }
  116.  
  117. bool IsEqualSt (stringref, string)
  118.    tStringRef    stringref;
  119.    register char *    string;
  120.    {
  121.       register cardinal    length      = LengthSt (stringref);
  122.       register char *    stringReg = (char *) stringref + 2;
  123.  
  124.       while (length -- > 0)
  125.      if (* stringReg ++ != * string ++)
  126.         return false;
  127.       return true;
  128.    }
  129.  
  130. void WriteString (file, stringref)
  131.    FILE *    file;
  132.    tStringRef    stringref;
  133.    {
  134.       register cardinal    length = LengthSt (stringref);
  135.  
  136.       if (length < 256) {
  137.      char string [256];
  138.      StGetString (stringref, string);
  139.      (void) fputs (string, file);
  140.       } else {
  141.      char * string = (char *) Alloc ((unsigned long) ++ length);
  142.      StGetString (stringref, string);
  143.      (void) fputs ((char *) string, file);
  144.      Free ((unsigned long) length, (char *) string);
  145.       }
  146.    }
  147.  
  148. void WriteStringMemory ()
  149.    {
  150.       tBlock *    BlockPtr = BlockList;
  151.       int    Size     = 0;
  152.  
  153.       if (BlockPtr != NULL) BlockPtr->Last = MemoryFreePtr;
  154.       while (BlockPtr != NULL) {
  155.      tStringRef StringPtr = (tStringRef) BlockPtr->Memory;
  156.          Size += (char *) BlockPtr->Last - (char *) StringPtr;
  157.  
  158.      while (StringPtr < BlockPtr->Last) {
  159.         int length = LengthSt (StringPtr) + 2;
  160.         (void) printf ("%8x ", StringPtr);
  161.         WriteString (stdout, StringPtr);
  162.         (void) fputc ('\n', stdout);
  163.         if (length & 1) length ++;
  164.         StringPtr += length >> 1;
  165.      }
  166.      BlockPtr = BlockPtr->Next;
  167.       }
  168.       (void) printf ("\n%5ld Bytes\n", Size);
  169.    }
  170.  
  171. void InitStringMemory ()
  172.    {
  173.       BlockList        = NULL;
  174.       MemorySpaceLeft    = 0;
  175.    }
  176.