home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / msdos / c / adlibmsc / lowlevel / memory.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-10-12  |  6.7 KB  |  322 lines
  1. /*
  2.    MEMORY.C
  3.  
  4.     Memory Manager, Ad Lib Inc.
  5.  
  6.    Functions BLDMEM(), GETMEM() & RLSMEM() of Lattice C are used.
  7.  
  8.     Each function sets a global variable, 'memErr', for indicating
  9.     the error code.
  10.     The function 'MemErr()' returns this code.
  11.  
  12.     The maximum allocatable block is 64K.
  13.  
  14.     If compiling with Lattice, 'LATTICE' must be defined for MEMORY.C.
  15.     For Microsoft, 'MICROSOFT', must be defined.
  16.     Refer to convert.c as well.
  17.  
  18. */
  19.  
  20. #include "mem.h"
  21.  
  22. Handle _hfstfree;       /* master pointer free list */
  23. int    _moremast;       /* # of master pointers to be allocated each time
  24.                             the free list is empty. */
  25. int    memErr;
  26.  
  27. #ifdef LATTICE
  28. #include <stdio.h>
  29.  
  30. #ifdef LPTR         /* LARGE DATA PTR ... */
  31. #define MyGetMem(a) getml(a)
  32. #define MyRlsMem(a, b) rlsml(a, b)
  33. #else
  34. #define MyGetMem(a) getmem(a)
  35. #define MyRlsMem(a, b) rlsmem(a, b)
  36. #endif
  37.  
  38. extern char * getmem();
  39. extern char * getml();
  40. extern int        rlsmem();
  41. extern int        rlsml();
  42. extern int        bldmem();
  43.        
  44. extern char * getmem();
  45. extern long lseek();
  46. #endif
  47.  
  48. #ifdef MICROSOFT
  49. #include  <malloc.h>
  50. #include  <string.h>
  51. #include  <io.h>
  52. #include  <stdio.h>
  53.  
  54. #define  MyGetMem(a)    malloc(a)
  55. #define  rlsmem(x,y)    free(x)
  56. #define  rlsml(x,y)     free(x)
  57. #define  getmem(x)      malloc(x)
  58. #define  getml(x)       malloc(x)
  59. #define  setmem(x,y,z)  memset(x,z,y)
  60. #define  movmem(x,y,z)  memmove(y,x,z)
  61. #define  min(x,y)       ((x < y) ? x:y)
  62. #endif
  63.  
  64.  
  65.  
  66. /*---------------------------- InitMemory() ----------------------------
  67.     Initialize the memory manager. 'mastercount' is the number of
  68.     master pointers to be allocated when needed.
  69. */
  70. InitMemory( mastercount)
  71.    int mastercount;
  72. {
  73.    memErr = NoErr;
  74.    _hfstfree = NULL;
  75.    _moremast = mastercount;
  76. #ifdef LATTICE
  77.    if ( 0 != bldmem( 0))        /* allocate remaining space */
  78.        {
  79.        memErr = MemInitErr;
  80.        }
  81. #endif
  82. }  /* InitMemory()   */
  83.  
  84.  
  85. /* ----------------------------- Moremasters() ------------------------
  86.     Allocate '_moremast' master pointers and add them to the free list.
  87. */
  88. MoreMasters()
  89. {
  90.    Ptr    blockptr;
  91.    Handle debut,
  92.           premier;
  93.    Size size;
  94.    int    j;
  95.  
  96.    memErr = NoErr;
  97.    size = _moremast * sizeof( Ptr) + sizeof ( Size);
  98.    if( NULL == ( blockptr = MyGetMem( size)))
  99.        {
  100.        memErr = MemFullErr;
  101.        return;
  102.        }
  103.    *( Size *) blockptr = size;
  104.    premier = debut = (Handle) (blockptr + sizeof ( Size));
  105.    for ( j = 1; j < _moremast; j++)
  106.        {
  107.        *debut = ( Ptr)( debut +1);
  108.        debut++;
  109.        }
  110.    *debut = (Ptr)_hfstfree;
  111.    _hfstfree = premier;
  112. }  /* Moremasters() */
  113.  
  114.  
  115.    
  116. /* ---------------------------- Getmaster() --------------------------
  117.    INTERNAL USE ONLY.
  118.     Return the first free master pointer, NULL if none.
  119. */
  120. static Handle Getmaster()
  121. {
  122.    Handle tmp;
  123.  
  124.    if ( NULL == _hfstfree)
  125.        MoreMasters();
  126.    tmp = _hfstfree;
  127.    if ( tmp != NULL)
  128.        _hfstfree = ( Handle)* _hfstfree;
  129.    return tmp;
  130. }  /* Getmaster()  */
  131.  
  132.  
  133.  
  134. /* ---------------------------- Putmaster() --------------------------
  135.    INTERNAL USE ONLY.
  136.     Add the master pointer to the free list.
  137. */
  138. static Putmaster( hndl)
  139.    Handle hndl;
  140. {
  141.    *hndl = (Ptr)_hfstfree;
  142.    _hfstfree = hndl;
  143. }  /* Putmaster()  */
  144.  
  145.  
  146. /* ---------------------------- NewPtr() -----------------------------
  147.     Allocate a block of 'dim' + sizeof( Size) bytes. The first bytes
  148.     (sizeof( Size)) are used to hold the total block size.
  149.    Return NULL if error.
  150. */
  151. Ptr NewPtr( dim)
  152.    Size dim;
  153. {
  154.    Size  size;
  155.    Ptr     tmp;
  156.  
  157.    memErr = NoErr;
  158.    size = dim +sizeof( Size);
  159. #ifdef LPTR
  160.  
  161. #else
  162.     if( (long)size >= 65536L) {
  163.         memErr = MemBlocTooBigErr;
  164.         return NULL;
  165.         }
  166. #endif
  167.    tmp = MyGetMem( size);
  168.    if (tmp != NULL)
  169.        {
  170.        *( Size *) tmp = size;
  171.        tmp = tmp + sizeof( Size);
  172.        }
  173.    else
  174.        memErr = MemFullErr;
  175.    return tmp;
  176. }  /* Newptr() */
  177.  
  178.  
  179.  
  180. /* ---------------------------- DisposPtr() -----------------------
  181.     Recover the block pointed to by 'pointer'.
  182. */
  183. DisposPtr( pointer)
  184.    Ptr pointer;
  185. {
  186.    Ptr     debut;
  187.  
  188.    memErr = NoErr;
  189.    debut = pointer - sizeof ( Size);
  190.    if ( NULL == pointer)
  191.        {
  192.        memErr = NilPtrErr;
  193.        }
  194. #ifdef MICROSOFT
  195.    free ((void *) debut);
  196. #else
  197.    if( 0 != MyRlsMem (debut, (*(Size *)debut)))
  198.        {
  199.        memErr = MemBlockErr;
  200.        }
  201. #endif
  202. }  /* DisposePtr() */
  203.  
  204.  
  205.  
  206. /* ---------------------------- GetPtrSize() ---------------------------
  207.     Return the size of the block pointed to by 'pointer'.
  208. */
  209. Size GetPtrSize( pointer)
  210.    Ptr pointer;
  211. {
  212.    memErr = NoErr;
  213.    if ( pointer == NULL)
  214.        {
  215.        memErr = NilPtrErr;
  216.        }
  217.    return ( Size)*( Size *) (pointer - sizeof ( Size)) - sizeof ( Size);
  218. }  /* GetPtrSize() */
  219.  
  220.  
  221.  
  222.  
  223. /* ------------------------------ SetHandleSize() ---------------------
  224.     Change the size of the handle 'hndl'.
  225. */
  226. SetHandleSize( hndl, newsize)
  227.     Handle hndl;
  228.     Size newsize;
  229. {
  230.     Size    size;
  231.     Ptr        theNewPtr;
  232.  
  233.     size = GetHandleSize( hndl);
  234.     if ( memErr != NoErr)
  235.         return;
  236.     theNewPtr = NewPtr( newsize);
  237.     if ( memErr != NoErr)
  238.         return;
  239.     movmem( *hndl, theNewPtr, (unsigned)min( size, newsize));
  240.     DisposPtr( *hndl);
  241.     *hndl = theNewPtr;
  242. }    /* SEtHandleSize()    */
  243.  
  244.  
  245.  
  246.  
  247. /* ------------------------------ NewHandle() -------------------------
  248.     Return a pointer to a pointer ( Handle) to a block of 'dim'
  249.     bytes.
  250.     Return NULL if error.
  251. */
  252. Handle NewHandle( dim)
  253.    Size dim;
  254. {
  255.    Ptr      blockptr;
  256.    Handle   hndl;
  257.  
  258.     if( !(blockptr = NewPtr( dim)))
  259.         return NULL;
  260.    if( !(hndl = Getmaster()))
  261.         {
  262.        memErr = MemFullErr;
  263.        return NULL;
  264.        }
  265.    *hndl = blockptr;
  266.    return hndl;
  267. }  /* NewHandle()  */
  268.  
  269.  
  270. /* ----------------------------- DisposHandle() -----------------------
  271.     Recover the block pointed by 'hndl'.
  272.     The master pointer is added to the free list.
  273. */
  274. DisposHandle( hndl)
  275.    Handle  hndl;
  276. {
  277.    Ptr     block;
  278.  
  279.    memErr = NoErr;
  280.    if ( NULL != hndl && NULL != * hndl)
  281.        {
  282.        block = * hndl - sizeof ( Size);
  283. #ifdef MICROSOFT
  284.        free ((void *) block);
  285.        Putmaster( hndl);
  286.        return;
  287. #else
  288.        if ( 0 == MyRlsMem( block, (*(Size *) block)))
  289.            {
  290.            Putmaster( hndl);
  291.            return;
  292.            }
  293.        else
  294.            memErr = MemBlockErr;
  295. #endif
  296.        }
  297.    else
  298.        memErr = NilHandleErr;
  299. }  /* DisposHandle()  */
  300.  
  301.  
  302. /* ----------------------------- GetHandleSize() -----------------------
  303.     Return the block size of 'hndl'.
  304. */
  305. Size GetHandleSize( hndl)
  306.    Handle  hndl;
  307. {
  308.    memErr = NoErr;
  309.    if ( hndl != NULL)
  310.        return GetPtrSize( *hndl);
  311.    memErr = NilHandleErr;
  312. }  /* GetHandleSize()  */
  313.  
  314.  
  315.  
  316. int MemError()
  317.     {
  318.     return memErr;
  319.     }
  320.  
  321.  
  322.