I think ummm.... You can solve it with 2 methods.... or more
============================================================
1) use pointer
2) use XMS or EMS
1) Pointer
***************************************
Type {**}
Data = Array[1..2000] of Real; { Data size must not exceed 64K }
DataPtr = ^Data;
Const
MaxVar = 20; { Value of MaxVar can be anything }
{ but you must have sufficient heap memory }
{ ^^^^^^^^^^^^^^^^^^^^^^ }
Var
Variable :Array[1..MaxVar] of DataPtr;
PROCEDURE AllocateVar;
Var
i :Word;
Begin
If MaxAvail >= MaxVar*6*2000 Then { Check Heap before allocate }
For i := 1 to MaxVar do
New (Variable[i])
Else Begin
Writeln ('This progam requir memory more ',MaxVar*6*2000-MaxAvail);
Halt (1)
End
End;
PROCEDURE ReleaseVar;
Var
i :Word;
Begin
For i := 1 to MaxVar do
Dispose (Variable[i])
End;
Begin
AllocateVar;
.
.
Usage Variable :-
Variable[Range1]^[Range2] := Real_Data;
/|\ /|\
1-MaxVar_______| |______ 1-2000 follow upper declaration {**}
Ex.
For i := 1 to MaxVar do
For j := 1 to 2000 do
Variable[i]^[j] := 0;
.
.
ReleaseVar;
End.
--------------------------------------------------
2) Use XMS
***********************************
( this is include file xms.inc )
^^^^^^^
Const
ERR_NOERR = $00; { No error }
ERR_NOTIMPLEMENTED = $80; { SpecIfied FUNCTION not known }
ERR_VDISKFOUND = $81; { VDISK-RAMDISK detected }
ERR_A20 = $82; { Error at handler A20 }
ERR_GENERAL = $8E; { General driver error }
ERR_UNRECOVERABLE = $8F; { Unrecoverable error }
ERR_HMANOTEXIST = $90; { HMA does not exist }
ERR_HMAINUSE = $91; { HMA already in use }
ERR_HMAMINSIZE = $92; { Not enough space in HMA }
ERR_HMANOTALLOCED = $93; { HMA not allocated }
ERR_A20STILLON = $94; { Handler A20 still on }
ERR_OUTOMEMORY = $A0; { Out of extEnded memory }
ERR_OUTOHANDLES = $A1; { All XMS handles in use }
ERR_INVALIDHANDLE = $A2; { Invalid handle }
ERR_SHINVALID = $A3; { Source handle invalid }
ERR_SOINVALID = $A4; { Source offset invalid }
ERR_DHINVALID = $A5; { Destination handle invalid }
ERR_DOINVALID = $A6; { Destination offset invalid }
ERR_LENINVALID = $A7; { Invalid length for move FUNCTION }
ERR_OVERLAP = $A8; { Illegal overlapping }
ERR_PARITY = $A9; { Parity error }
ERR_EMBUNLOCKED = $AA; { UMB is unlocked }
ERR_EMBLOCKED = $AB; { UMB is still locked }
ERR_LOCKOVERFLOW = $AC; { Overflow of UMB lock counter }
ERR_LOCKFAIL = $AD; { UMB cannot be locked }
ERR_UMBSIZETOOBIG = $B0; { Smaller UMB available }
ERR_NOUMBS = $B1; { No more UMB available }
ERR_INVALIDUMB = $B2; { Invalid UMB segment address }
Type
XMSRegs = record { Information for XMS call }
AX, { Only registers AX, BX, DX and SI }
BX, { required, depEnding on called }
DX, { FUNCTION along With a segment }
SI, { address }
Segment :Word
End;
Var
XMSPtr :Pointer; { Pointer to the extEnded memory manager (XMM) }
XMSErr :Byte; { Error code of the last operation }
{**********************************************************************
* XMSInitOk : Initializes the routines for calling the XMS FUNCTIONs *
**-------------------------------------------------------------------**
* Input : None *
* Output : TRUE, If an XMS driver was discovered, otherwise FALSE *
* Info : - The call of this FUNCTION must precede calls of all *
* all other PROCEDUREs and FUNCTIONs from this program. *
**********************************************************************}
FUNCTION XMSInitOk :Boolean;
Var
Regs :Registers;
XR :XMSRegs;
Begin
Regs.AX := $4300; { Determine availability of XMS manager }
Intr ($2F,Regs);
If (Regs.AL = $80) Then { XMS manager found? }
Begin { Yes }
Regs.AX := $4310; { Determine entry point of XMM }
Intr ($2F,Regs);
XMSPtr := ptr (Regs.ES,Regs.BX); { Store address in glob. Var. }
XMSErr := ERR_NOERR; { Still no error found }
XMSInitOk := true; { Handler found, module initialized }
End
Else { No XMS handler installed }
XMSInitOk := false
End;
{**********************************************************************
* XMSCall : General routine for calling an XMS FUNCTION *
**-------------------------------------------------------------------**
* Input : FctNo = Number of XMS FUNCTION to be called *
* XRegs = Structure With registers for FUNCTION call *
* Info : - Before calling this PROCEDURE, only those registers *
* can be loaded that are actually required for calling *
* the specIfied FUNCTION. *
* - After the XMS FUNCTION call, the contents of the *
* Various processor registers are copied to the *
* corresponding components of the passed structure. *
* - Before calling this PROCEDURE for the first time, the *
* XMSInit must be called successfully. *
**********************************************************************}
PROCEDURE XMSCall (FctNr :Byte; Var XRegs :XMSRegs);
Begin
inline ( $8C / $D9 / { mov cx,ds }
$51 / { push cx }
$C5 / $BE / $04 / $00 / { lds di,[bp+0004] }
$8A / $66 / $08 / { mov ah,[bp+0008] }
$8B / $9D / $02 / $00 / { mov bx,[di+0002] }
$8B / $95 / $04 / $00 / { mov dx,[di+0004] }
$8B / $B5 / $06 / $00 / { mov si,[di+0006] }
$8E / $5D / $08 / { mov ds,[di+08] }
$8E / $C1 / { mov es,cx }
$26 / $FF / $1E / XMSPtr / { call es:[XMSPTr] }
$8C / $D9 / { mov cx,ds }
$C5 / $7E / $04 / { lds di,[bp+04] }
$89 / $05 / { mov [di],ax }
$89 / $5D / $02 / { mov [di+02],bx }
$89 / $55 / $04 / { mov [di+04],dx }
$89 / $75 / $06 / { mov [di+06],si }
$89 / $4D / $08 / { mov [di+08],cx }
$1F { pop ds }
);
{-- Test for error code --------------------------------------------}
If (XRegs.AX = 0) and (XRegs.BX >= 128) Then
Begin
XMSErr := Lo(XRegs.BX) { Error, store error code }
{
.
.
.
Another error handling routine could follow here
.
.
.
}
End
Else
XMSErr := ERR_NOERR { No error, all ok }
End;
{**********************************************************************
* XMSQueryVer: Returns the XMS version number and other status *
* information *
**-------------------------------------------------------------------**
* Input : VerNr = Gets the version number after the FUNCTION call *
* (Format: 235 = 2.35) *
* RevNr = Gets the revision number after the FUNCTION call *
* Output : TRUE, If HMA is available, otherwise FALSE *
**********************************************************************}
PROCEDURE XMSQueryVerHMA (Var VerNr,RevNr :Integer; Var HMA :Boolean);
Var
XR :XMSRegs; { Registers for communication With XMS }
Begin
XmsCall (0,XR);
VerNr := Hi(XR.AX)*100 + (Lo(XR.AX) shr 4) * 10 + (Lo(XR.AX) and 15);
RevNr := Hi(XR.BX)*100 + (Lo(XR.BX) shr 4) * 10 + (Lo(XR.BX) and 15);
HMA := (XR.DX = 1)
End;
{**********************************************************************
* XMSGetHMA : Returns right to access the HMA to the caller. *
**-------------------------------------------------------------------**
* Input : LenB = Number of bytes to be allocated *
* Info : TSR programs should only request the memory size that *
* they actually require, while applications should specIfy *
* the value $FFFF.
...
