|
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 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.
- SPREAD THE WORD:
- Slashdot
- Digg
- Del.icio.us
- Newsvine