home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD1.img / d2xx / d240 / memlib / mwalcfre.c < prev    next >
C/C++ Source or Header  |  1989-08-28  |  3KB  |  126 lines
  1. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
  2. * |_o_o|\\ Copyright (c) 1989 The Software Distillery.                    *
  3. * |. o.| ||          All Rights Reserved                                  *
  4. * | .  | ||          Written by Doug Walker                               *
  5. * | o  | ||          The Software Distillery                              *
  6. * |  . |//           235 Trillingham Lane                                 *
  7. * ======             Cary, NC 27513                                       *
  8. *                    BBS:(919)-471-6436                                   *
  9. \* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  10.  
  11. #include "mempriv.h"
  12.  
  13. extern struct MWGlobal mwg;
  14.  
  15. void *MWAllocMem(size, flags, file, line)
  16. long size, flags;
  17. char *file;
  18. long line;
  19. {
  20.    struct MWAlc *hd;
  21.    char *tmpchar;
  22.    int memtype;
  23.  
  24.    if(!(mwg.flags & MWF_ACTIVE)) return(NULL);
  25.    if(!(mwg.flags & MWF_NOCHECK)) MWCheck();
  26.  
  27.    memtype = (flags & MEMF_CHIP ? MWT_CHIP : MWT_FAST);
  28.    if(mwg.sum[memtype] + size > mwg.lim[memtype])
  29.    {
  30.       /* Over the limit, fail it */
  31.       if(mwg.dbfh)
  32.       {
  33.          MSG(mwg.dbfh, "MemWatch: ");
  34.          if(memtype == MWT_CHIP)
  35.             MSG(mwg.dbfh, "CHIP ");
  36.          else
  37.             MSG(mwg.dbfh, "FAST ");
  38.          MSG(mwg.dbfh, "memory allocation exceeds MWLimit amount\n");
  39.       }
  40.       return(NULL);
  41.    }
  42.  
  43.    while(!(tmpchar = (char *)AllocMem(sizeof(struct MWAlc)+size, flags)))
  44.    {
  45.       if(mwg.freed) MWPurge();
  46.       else return(NULL);
  47.    }
  48.    
  49.    hd = (struct MWAlc *)tmpchar;
  50.    hd->size = size;
  51.    hd->flags = flags;
  52.    hd->myflags = 0L;
  53.    hd->file = file;
  54.    hd->line = line;
  55.    memcpy((char *)&hd->header, MWHEADER, 4);
  56.    tmpchar += (sizeof(struct MWAlc)+size-4);
  57.    memcpy(tmpchar, MWTRAILER, 4);
  58.    if(!(flags & MEMF_CLEAR) && !(mwg.flags & MWF_NOATRASH))
  59.       memset(hd->memory, MWATRASH, size);   /* Trash the memory */
  60.  
  61.    hd->next = mwg.first;
  62.    mwg.first = hd;
  63.  
  64.    if((mwg.sum[memtype] += size) > mwg.max[memtype]) 
  65.       mwg.max[memtype] = mwg.sum[memtype];
  66.    ++(mwg.num[memtype]);
  67.  
  68.    return((char *)hd->memory);
  69. }
  70.  
  71. void MWFreeMem(mem, size, internal)
  72. void *mem;
  73. long size;
  74. int internal;
  75. {
  76.    struct MWAlc *mwa, *prev;
  77.    int memtype;
  78.    int error = 0;
  79.  
  80.    if(!(mwg.flags & MWF_ACTIVE)) return;
  81.    if(!(mwg.flags & MWF_NOCHECK)) MWCheck();
  82.  
  83.    for(prev = NULL, mwa = mwg.first; 
  84.        mwa && mwa->memory != mem; 
  85.        prev = mwa, mwa = mwa->next);
  86.  
  87.    if(!mwa)
  88.    {
  89.       if(mwg.dbfh)
  90.          MWPrint(NULL, 1, (LONG)mem, size);
  91.       error = 1;
  92.    }
  93.    else if(!internal && mwa->size != size)
  94.    {
  95.       if(mwg.dbfh) 
  96.       {
  97.          MWPrint(NULL, 2, size, 0);
  98.          MWPrint(mwa,  0,    0, 0);
  99.       }
  100.       error = 1;
  101.    }
  102.  
  103.    if(error)
  104.    {
  105.       MWHold();
  106.       return;
  107.    }
  108.  
  109.    memtype = (mwa->flags & MEMF_CHIP ? MWT_CHIP : MWT_FAST);
  110.    mwg.sum[memtype] -= mwa->size;
  111.    --mwg.num[memtype];
  112.  
  113.    if(prev) prev->next = mwa->next;
  114.    else     mwg.first = mwa->next;
  115.  
  116.    if(!(mwg.flags & MWF_NOFTRASH))
  117.       memset(mwa->memory, MWFTRASH, mwa->size);  /* Trash it */
  118.  
  119.    if(mwg.flags & MWF_NOFKEEP)
  120.      FreeMem((char *)mwa, size + sizeof(struct MWAlc));
  121.    else
  122.    {
  123.       mwa->next = mwg.freed;
  124.       mwg.freed = mwa;
  125.    }
  126. }