Taking TML Around the 32K Barrier

By Darryl Lavoto, TML Systems, Inc., Contributing Editor

It has been a while since I have had a chance to write something for my favorate Magazine! MacTutor! A lot of Technical Support Questions I get at TML Systems are about the 32k data limitation that exists on most compilers. I have written a work-around that will allow most people to get around this problem.

Most Compilers for the Macintosh have a 32k limitation on the sum of all global variables. This is because global variables are stored in a area of memory WORD indexed off of A5. This is a significant limitation if your program needs large arrays of data. There is a workaround, however, to allow any size of array to be created. The only size limitation for our array is available memory.

The alternitive way to create large arrays is to call NewHandle to get a handle to a block of memory large enough to hold the array. Accessing the individual elements of the new array is done by calculating offsets into the block. The Array unit below includes routines for Creating and Disposing arrays, and for accessing the array elements.

The unit could be improved by adding support for multi-dimentional arrays, dynamic sizing of the array, or even variable length data sizes. The speed of the routines could be improved substantially by re-coding the unit in 680x0 assembler. Note that these routines assume that the lower bound of the array is always 0. Also, error checking needs to be added to the create array routine in case there is not enough memory to create the block.

{#################################################}
{#  File: Arrays.Pas      #}
{#  Author: Darryl Lovato.#}
{#  Description: #}
{# This module provides a set of routines to       #}
{#  create & use large arrays      #}
{#################################################}

unit Arrays;

interface

uses MacIntf;

function  CreateNewArray(elemSize, upperBound : Longint) : Handle;
procedure DisposeArray(ary : Handle);
procedure SetElement(ary : Handle; elemNum : Longint; elemPtr : Ptr);
function  GetElement(ary : Handle; elemNum : Longint) : Ptr;

implementation

type
   ArrayHdl = ^ArrayPtr;
   ArrayPtr = ^ArrayRec;
   ArrayRec = record
       hiBound : integer;
       cellSize : Longint;
       dataStuff : integer;
   end;

{#################################################}
{#        #}
{#  function CreateNewArray(elemSize, lowerBound,  #} 
{#      upperBound : Longint) : Handle;#}
{# #}
{#################################################}

function CreateNewArray(elemSize, upperBound : Longint) : Handle;
  var
    tempHdl : ArrayHdl;
  begin
    tempHdl := ArrayHdl(NewHandle(Ord4(SizeOf(ArrayRec)) - 2
 + ((upperbound + 1) * elemSize)));
    with tempHdl^^ do
      begin
        hiBound := upperBound;
        cellSize := elemSize;
      end;
    CreateNewArray := Handle(tempHdl);
  end;

{#################################################}
{#        #}
{#  procedure DisposeArray(ary : Handle);          #} 
{#      #}
{# #}
{#################################################}

procedure DisposeArray(ary : Handle);
  begin
    DisposHandle(ary);
  end;

{#################################################}
{#        #}
{#        #}
{# procedure SetElement(ary : Handle; elemNum :    #}
{# Longint; elemPtr : Ptr); #} 
{#      #}
{# #}
{#################################################}

procedure SetElement(ary : Handle; elemNum : Longint; elemPtr : Ptr);
  type
    fakeary = packed array[1..10000] of signedbyte;
    fakeptr = ^fakeary;
  var
    cellAddr : fakePtr;
    i : integer;
  begin
    with ArrayHdl(ary)^^ do
      if (elemNum > 0) and (elemNum < hibound) then
        begin
          cellAddr := fakePtr(Ord4(@dataStuff) + (elemNum * cellSize));
          for i := 0 to cellSize - 1 do
            cellAddr^[i] := fakePtr(elemPtr)^[i];
        end;
  end;

{#################################################}
{#        #}
{#        #}
{# procedure GetElement(ary : Handle; elemNum :    #}
{# Longint) : Ptr);  #} 
{#      #}
{# #}
{#################################################}

function GetElement(ary : Handle; elemNum : Longint) : Ptr;
  begin
    with ArrayHdl(ary)^^ do
      if (elemNum > 0) and (elemNum < hibound) then
        GetElement := Pointer(Ord4(@dataStuff) + (elemNum * cellSize));
  end;
end.

{#################################################}
{#        #}
{# This program tests the Array Package#}
{# #} 
{# #}
{#################################################}

program AryTest(input, output);

uses Macintf, Arrays;
type
  BigPtr = ^BigRec;
  BigRec = record
             r : real;
             r2 : real;
             other : array[1..20] of Longint;
           end;
var
  myArray : handle;
  i : longint;
  Big : BigRec;
  x : integer;
  StackMark : integer;
begin
  SetApplLimit(Pointer(Ord4(@StackMark) - Ord4(16000))); {16k stack}
  MaxApplZone;

  myArray := CreateNewArray(SizeOf(BigRec), 2000);

  writeln(‘Total Size of Record = ‘,SizeOf(BigRec));
  writeln(‘Total Size of the array = ‘,GetHandleSize(myArray));
  writeln;
  writeln(‘press mouse to start’);
  repeat until button;

  for i := 0 to 2000 do
    begin
      Big.r := i / 1.0;
      SetElement(myArray, i, @Big);
      writeln(BigPtr(GetElement(myArray, i))^.r:7:2);
    end;

  DisposeArray(myArray);
end.