[Back to MEMORY SWAG index]  [Back to Main SWAG index]  [Original]

Unit Oversize;

{  Author:  Trevor J Carlsen
            Algorithm Enterprises Pty Ltd
            PO Box 568
            Port Hedland  6721
            Western Australia
            Telephone:  (Voice)  +61 [0]91 73 2026
                        (Data )  +61 [0]91 73 2569
  Released into the Public Domain 1991.

  An Unit that will enable logical Arrays to be created using up to the amount 
  of heap memory available.

  The line marked (**) MUST be altered to reflect the Type of data in big 
  Array and the Unit MUST be reCompiled after this change.

  No provision is made in this Unit For recovering the memory used by the big 
  Array as the intention was to keep it appearing to the Programmer as close 
  as possible to static Type global Variables.

  Bear in mind that you do not declare your Array anywhere using this Unit.  
  That is all handled automatically.  All you have to do is give the global 
  Variable MaxElements a value With the number of elements you want in the 
  Array and then call the Procedure initialise.  From then on your Array is 
  called data^. (Actually it is called nothing as it is dynamic and is 
  referenced via the Pointer "data" but if you think of it as being called 
  "data^" you don't even need to know how Pointers work!)

  The Array, using this Unit, can only be singly dimensioned although there is 
  no reason why the Unit could not be hacked to allow multi-dimensions.


(**)  DataType = LongInt;   { change to whatever Type you want For the Array }
  bigArray = Array[0..0] of DataType;
  bigptr   = ^bigArray;
  data : bigptr;
  MaxElements : LongInt;    { this Variable must have the number of elements }

Function Element(l:LongInt):Byte;
  { Call by passing the element number you wish to reference.                }
  { Always returns zero.  It works by changing the value of the Pointer      }
  { data.  This means that you cannot ever reference your big Array by       }
  {   data^[100000] := whatever;                                             }
  { It MUST always be referenced by calling this Function eg.                }
  {   data^[Element(100000)] := whatever;                                    }

Function AllocateMem(Var b,l): Boolean;
  { Returns True if memory was allocated successfully For the big Array and  }
  { False if there was insufficient memory.                                  }

Procedure Initialise;  { Must be called beFore using any other Procedure     }



{ private declarations }

  max          = 65520 div sizeof(dataType);{ The number of elements/segment }
  initialised  : Boolean = False;
  address  =  Record                     { allows arithmetic on the Pointers }
                segment : Word;
  baseArray = Array[0..9] of address;    { For the addresses of the segments }

  base : baseArray;

Function Element(l:LongInt):Byte;

    theaddress : address Absolute data;
    bigaddress : baseArray Absolute base;

    { First make sure that initialisation has been done correctly            }
    if not initialised then begin 
      Writeln('Initialise Procedure has not been called');
    end;  { if not initialised }
    Element := 0; { It is Really irrelevent but any other value here would   }
                  { produce a range check error at runtime if R+             }
    { Now let us fool TP into thinking that the address of element zero is   }
    { address of the element we are looking For.                             }
    With theaddress do begin
      segment := bigaddress[l div max].segment;            { Get the segment }
      offset  := (l mod max) * sizeof(dataType);            { Get the offset }
    end;  { With theaddress }
  end;  { ElementNumber }

Function AllocateMem(Var b,l): Boolean;
    ptrArray = Array[0..9] of Pointer;
    bArray: ptrArray Absolute b;
    x     : Byte;
    count : LongInt;
    count := MaxElements;
    AllocateMem := True;
    For x := 0 to (count div max) do     { allocate in 64K contiguous chunks }
      if (count * sizeof(dataType)) > 65520 then begin
        if MaxAvail < (max * sizeof(dataType)) then begin { not enough memory} 
          AllocateMem := False;
          GetMem(bArray[x],max * sizeof(dataType));
        if MaxAvail < (count * sizeof(dataType)) then
           AllocateMem := False
           GetMem(bArray[x],count * sizeof(dataType)); 
  end;  { AllocateMem }
Procedure Initialise;
    if not AllocateMem(base,MaxElements) then begin
      Writeln('Insufficient memory');
    initialised := True;              { All Ok and memory has been allocated }
  end;  { Initialise }
end.  { Unit Oversize 

[Back to MEMORY SWAG index]  [Back to Main SWAG index]  [Original]