TML Barrier
Volume Number: 3
Issue Number: 9
Column Tag: Mac Hack Forum
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
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);
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;
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.
Referenced by (2):