Лабораторная работа №21 / H

#include <stdio.h>
#include <stdlib.h>
#include "H.H"

typedef struct
{
  void* pBlockStart;
  unsigned long nBlockSize;
}                             FreeBlock;

typedef struct
{
  FreeBlock Data;
  void* pNext;
}                             ListElement;

unsigned long USED_MEMORY = 1024;
void        *pFreeMemoryStart;
ListElement *pFreeMemory;


extern void INIT()
{
  pFreeMemoryStart = malloc(USED_MEMORY);
  pFreeMemory = malloc(sizeof(ListElement));
  (pFreeMemory->Data.pBlockStart) = pFreeMemoryStart;
  pFreeMemory->Data.nBlockSize = USED_MEMORY;
  pFreeMemory->pNext = NULL;
};

void concatenateBlocks()
{
  ListElement *ptr2,*ptr=pFreeMemory;
  while ((ptr!=NULL)&&(ptr->pNext!=NULL))
  {
    if ((int) (ptr->Data.pBlockStart) + (ptr->Data.nBlockSize) ==
        (int)((ListElement*)(ptr->pNext))->Data.pBlockStart)
      {
        ptr->Data.nBlockSize+=((ListElement*)(ptr->pNext))->Data.nBlockSize;
        ptr2=(ListElement*) ptr->pNext;
        ptr->pNext = ptr2->pNext;
        free(ptr2);
      }
    else
      ptr=(ListElement*)ptr->pNext;
  }
}

extern int newFREE(void *from, int Size)
{
  int nSize=Size;
  ListElement *ptr=pFreeMemory,
              *ptr2;
  if (Size == NULL) nSize=1;

  if ((ptr == NULL)&&
      (from>=pFreeMemoryStart)&&
      ((int)from+nSize<=(int)pFreeMemoryStart+USED_MEMORY))
  {
    pFreeMemory = malloc(sizeof(ListElement));
    pFreeMemory->pNext = NULL;
    pFreeMemory->Data.pBlockStart = from;
    pFreeMemory->Data.nBlockSize  = nSize;
    return 0;
  };
  if ((from>=pFreeMemoryStart) &&
     ((int)from+nSize-1 < (int)ptr->Data.pBlockStart))
  {
    ptr2 = malloc(sizeof(ListElement));
    ptr2->pNext = pFreeMemory;
    ptr2->Data.pBlockStart = from;
    ptr2->Data.nBlockSize  = nSize;
    pFreeMemory=ptr2;
    concatenateBlocks();
    return 0;
  };
  while ((ptr!=NULL)&&(ptr->pNext!=NULL))
  {
    if ((((int)from >= (int)(ptr->Data.pBlockStart)+(ptr->Data.nBlockSize)))&&
        (((int)from + nSize-1 <  ((ListElement*)(ptr->pNext))->Data.pBlockStart)))
    {
      ptr2 = malloc(sizeof(ListElement));
      ptr2->pNext = ptr->pNext;
      ptr2->Data.pBlockStart = from;
      ptr2->Data.nBlockSize  = nSize;
      ptr->pNext=ptr2;
      concatenateBlocks();
      return 0;
    };
    ptr = ptr->pNext;
  };
  if (((int)from >= (int)(ptr->Data.pBlockStart) + (ptr->Data.nBlockSize))  &&
      ((int)from+nSize<=(int)pFreeMemoryStart+USED_MEMORY))
  {
      ptr2 = malloc(sizeof(ListElement));
      ptr2->pNext = NULL;
      ptr2->Data.pBlockStart = from;
      ptr2->Data.nBlockSize  = nSize;
      ptr->pNext=ptr2;
      concatenateBlocks();
      return 0;
  };
  return 1;
}

extern void newFREEALL()
{
  free(pFreeMemory->pNext);
  (pFreeMemory->Data.pBlockStart) = pFreeMemoryStart;
  pFreeMemory->Data.nBlockSize = USED_MEMORY;
  pFreeMemory->pNext = NULL;
}



extern void* newALLOC(int nSize)
{
  ListElement *ptr=pFreeMemory,
              *max=ptr,
              *oldptr;
  void *ret;
  concatenateBlocks();
  if (pFreeMemory == NULL)
    return NULL;
  if (ptr->Data.nBlockSize == nSize)
  {
    ret=ptr->Data.pBlockStart;
    pFreeMemory=(ListElement*) ptr->pNext;
    free(ptr);
    return ret;
  };
  oldptr = ptr;
  ptr = (ListElement*) ptr->pNext;
  while (ptr!=NULL)
  {
    if (ptr->Data.nBlockSize == nSize)
    {
      ret=ptr->Data.pBlockStart;
      oldptr->pNext = ptr->pNext;
      free(ptr);
      return ret;
    }
    else if ((ptr->Data.nBlockSize > nSize)&&
             (ptr->Data.nBlockSize > max->Data.nBlockSize))
    {
      max = ptr;
    };
    oldptr=ptr;
    ptr = ptr->pNext;
  };
  if (max->Data.nBlockSize < nSize)
    return NULL;
  ret = max->Data.pBlockStart;
  max->Data.pBlockStart=(int)(max->Data.pBlockStart) + nSize;
  max->Data.nBlockSize-=nSize;
  return ret;
};

void printList()
{
  ListElement *ptr=pFreeMemory;
  printf("\r\n");
  while (ptr!=NULL)
  {
    printf("%d", ptr->Data.pBlockStart);
    printf("  ");
    printf("%u", ptr->Data.nBlockSize);
    printf("\r\n");
    ptr=(ListElement*) ptr->pNext;
  }
}