Meer geheugen voor Turbo Pascal

[TheLunatic]

Ik kan in Turbo Pascal niet eens een array creeeren van 2000 strings met 45 tekens. Ook als ik de instellingen zo hoog mogelijk zet gaat het niet... is er een andere omweg zodat dit wel kan?

[Wierdo_NL]

Misschien met pointers werken ofzo ?
Of met een temp-bestand werken ?

Ik weet het niet meer, is al 3 jaar terug..
C++ is misschien wel wat beter met zulke dingen..

[jelmervos]

Met pointers zou je dit kunnen verhelpen

[Primal]

Op maandag 10 september 2001 16:01 schreef TheLunatic het volgende:
Ik kan in Turbo Pascal niet eens een array creeeren van 2000 strings met 45 tekens. Ook als ik de instellingen zo hoog mogelijk zet gaat het niet... is er een andere omweg zodat dit wel kan?

Als ik het goed begrijp wil je dus in totaal statische geheugenruimte alloceren voor 2000 * (maal dus) 45 characters. Dit komt dan op 90.000 bytes. Dit kan dus niet statisch, aangezien Turbo Pascal werkt met een maximale datasegment voor een programma van 64k (ofwel +/- 64.000 bytes). Eigenlijk zeg ik het verkeerd. Dit is dus een tekortkoming van DOS (ga ervan uit dat je onder DOS werkt). De enige oplossing voor jou is het geheugen dynamisch te alloceren. Dan moet je gaan werken met far- pointers. Je moet dit ook aangeven bij je project-settings, anders kun je nog geen far-pointers gebruiken. Een far-pointer is een pointer die wijst naar geheugenruimte buiten je eigen 64k datasegment. Een near-pointer is een pointer die wijst naar geheugenruimte binnen je eigen 64k datasegment. Een pointer moet je dan ook als 'far pointer' declareren voor zover ik het nog weet.

Ik hoop dat je begrijpt wat pointers zijn, anders krijg je het niet voor elkaar!


P.s.: Voor mij is het inderdaad ook al een jaar of 4 geleden dat ik voor het laatst iets in Pascal had gedaan, dus als ik iets verkeerd zeg dan kan dat. Maar zover ik het nog weet is het zo zoals ik zeg dat het is.

[BdR]

ik heb ook een probleempje met Turbo Pascal. Ik ben al een tijdje bezig met het schrijven van een arcade schiet spelletje. Het ontwikkelen ging allemaal aardig, ik heb nu een virtueel scherm (screen flipping enzo), sprites, soundblaster geluid, ALLES!

Maar nu loop ik tegen een "heap overflow error" probleem aan. Tijdens het inlezen van de 20kb aan graphics, mijn GRAPHICS.DAT is dus een ongecomprimeerd bestand dat rechtstreeks wordt ingelezen. Er wordt ook 40kb aan geluid (ook ongecomprimeerd) ingelezen. 60kb in totaal dus, en de .EXE is 30kb.. dat is bij elkaar toch niet zo heel veel dacht ik

Waarom kan dit dan toch niet ingelezen worden!? Heeft emand een idee want ik baal als een stekker, kheb er best veel tijd in gestoken, en om nu op zoiets stoms vast te lopen..

ik ga nu nog wel even die "far pointers" proberen (ik maak nu gebruik van "gewone" pointers dus zonder "far"), wie weet helpt dat wat, maar ik vrees van niet

[JayTaph]

Er zijn genoeg XMS/EMS libraries te vinden voor turbo pascal. Maar er is een ander truukje:

je kunt je systeem in een speciale mode zetten: unreal mode. Dit is een soort van real-mode, maar zonder beperkingen van 64k segmenten. Niet helemaal netjes, maar helpt je wel zonder al te veel om te gooien geloof ik.

[Gerco]

Op donderdag 08 november 2001 23:44 schreef JayTaph het volgende:
unreal mode. Dit is een soort van real-mode, maar zonder beperkingen van 64k segmenten.

Unreal mode is de mode waar een persoon in staat als hij Unreal (Tournament) aan het spelen is. Wat jij bedoelt heet protected mode

(Maar dat wist je al, de topicstarter misschien niet).

[Knutselsmurf]

Op donderdag 08 november 2001 22:55 schreef BdR het volgende:
ik heb ook een probleempje met Turbo Pascal. Ik ben al een tijdje bezig met het schrijven van een arcade schiet spelletje. Het ontwikkelen ging allemaal aardig, ik heb nu een virtueel scherm (screen flipping enzo), sprites, soundblaster geluid, ALLES!

Maar nu loop ik tegen een "heap overflow error" probleem aan. Tijdens het inlezen van de 20kb aan graphics, mijn GRAPHICS.DAT is dus een ongecomprimeerd bestand dat rechtstreeks wordt ingelezen. Er wordt ook 40kb aan geluid (ook ongecomprimeerd) ingelezen. 60kb in totaal dus, en de .EXE is 30kb.. dat is bij elkaar toch niet zo heel veel dacht ik

Waarom kan dit dan toch niet ingelezen worden!? Heeft emand een idee want ik baal als een stekker, kheb er best veel tijd in gestoken, en om nu op zoiets stoms vast te lopen..

ik ga nu nog wel even die "far pointers" proberen (ik maak nu gebruik van "gewone" pointers dus zonder "far"), wie weet helpt dat wat, maar ik vrees van niet

Volgens mij kun je de compilerinstellingen ook nog veranderen. Daarin kun je bijvoorbeeld de stack- en heapsize veranderen. Het is in Pascal geen probleem om al je geheugen (640 K ) te gebruiken. Wat al eerder genoemd is , is dat een enkele datastructuur (array bijvoorbeeld) in een enkel datablock van 64 K moet passen. In 1 programma kun je dus gerust 2 array's van ieder 60 K gebruiken.

[Verwijderd]

Even praktisch: schakel over op Borland Pascal 7.0, daarmee kun je dus (unreal) protected modus doen. Helaas staat die versie nog niet in het Borland Museum (registratie verplicht doch gratis )

[Verwijderd]

Tevens: een standaard string onder Pascal neemt altijd iets van 256 bytes in (geloof ik)

[Olaf van der Spek]

Op vrijdag 09 november 2001 01:00 schreef Gerco het volgende:

[..]

Unreal mode is de mode waar een persoon in staat als hij Unreal (Tournament) aan het spelen is. Wat jij bedoelt heet protected mode

(Maar dat wist je al, de topicstarter misschien niet).

Nee, hij bedoelt real mode zonder de 16-bit adres restrictie.

[chaozz]

de grootte van de heap kun je instellen in de eerste regel van je programma. in de {$M regel.. zoek maar op in de help.

ook ik ben een spel aan het maken in good old Turbo Pascal 7.0

http://come.to/worldwidewenners

[Olaf van der Spek]

Op maandag 10 september 2001 16:40 schreef Primal het volgende:

[..]

Als ik het goed begrijp wil je dus in totaal statische geheugenruimte alloceren voor 2000 * (maal dus) 45 characters. Dit komt dan op 90.000 bytes. Dit kan dus niet statisch, aangezien Turbo Pascal werkt met een maximale datasegment voor een programma van 64k (ofwel +/- 64.000 bytes). Eigenlijk zeg ik het verkeerd. Dit is dus een tekortkoming van DOS (ga ervan uit dat je onder DOS werkt). De enige oplossing voor jou is het geheugen dynamisch te alloceren. Dan moet je gaan werken met far- pointers. Je moet dit ook aangeven bij je project-settings, anders kun je nog geen far-pointers gebruiken. Een far-pointer is een pointer die wijst naar geheugenruimte buiten je eigen 64k datasegment. Een near-pointer is een pointer die wijst naar geheugenruimte binnen je eigen 64k datasegment. Een pointer moet je dan ook als 'far pointer' declareren voor zover ik het nog weet.

Ik hoop dat je begrijpt wat pointers zijn, anders krijg je het niet voor elkaar!


P.s.: Voor mij is het inderdaad ook al een jaar of 4 geleden dat ik voor het laatst iets in Pascal had gedaan, dus als ik iets verkeerd zeg dan kan dat. Maar zover ik het nog weet is het zo zoals ik zeg dat het is.

Ik dacht dat near en far alleen in C++ zat en dat in Pascal een pointer gewoon met ^ werd aangegeven.

[JayTaph]

Op vrijdag 09 november 2001 13:03 schreef OlafvdSpek het volgende:

[..]

Nee, hij bedoelt real mode zonder de 16-bit adres restrictie.

Inderdaad.. de "mode" tussen real en protected in dus. Het heeft geen echte benaming, maar veel mensen houden het op unreal (het spel is van veeeeeel later in ieder geval). Het zet de normale 64k-begrensing op de selectoren uit zodat je 4gig vanuit real-mode kunt adresseren (weliswaar met truukjes).

[BdR]

als eerste maar even antwoord geven voor TheLunatic, over die array van 2000 strings van 45 characters. Je moet dan niet met een array van string werken maar met een array van pointers, en die pointers wijzen dan weer naar die strings. Een string opgeslagen met behulp van een pointer kan je aanspreken/manipuleren door een dakje ^ erachter te plaatsen. Zie voorbeeld hieronder.. overigens als je het ECHT correct wil doen moet je volgens mij ook nog typcasten dus ipv StringArray(i)^ eigenlijk LimitedString(StringArray(i)^) doen maar ja, is niet verplicht

De reden voor dit alles is dus dat de inhoud van een array (ongeacht WAT je er in opslaat) niet groter mag worden dan 64kb, en een string van 45 characters is dus 45bytes groot. Dus gaan er max. 64000/45= ong 1422 strings in. Een pointer is 4 bytes groot (probeer maar -> Writeln(SizeOf(pointer)); ) dus kan je 16000 pointers opslaan.. hier een uitgeschreven Turbo Pascal voorbeeld programma:

code:

Program Test123;

type
  LimitedString = String[45];  { een string van 45 characters }
  TStringPtr = ^LimitedString; { een pointer naar deze LimitedString }

var
  StringArray : Array [1..2000] of TStringPtr; { array bevat pointers }

Procedure FillArray;
{ Vul de array met 2000 pointers naar strings }
var
  i : Word;
  tmpString : LimitedString;
Begin
  For i := 1 to 2000 do
  Begin
    { reserveer geheugen ter grootte van 1 string van 45 characters }
    GetMem(StringArray[i], SizeOf(LimitedString));
    { om het te testen, vul de tmpString met zet 'Test.. <i>'}
    Str(i, tmpString);
    tmpString := 'Test.. ' + tmpString;
    { plaats de string in de array in het gereserveerde geheugen }
    StringArray[i]^ := tmpString;
  End;
End;

Procedure TestArray;
{ Test de array door de 2000 string te tonen }
var
  i : Word;
  tmpString : LimitedString;
Begin
  For i := 1 to 2000 do
  Begin
    tmpString := StringArray[i]^;
    Writeln(tmpString);
  End;
End;

Begin
  Writeln('Vul de array met strings..');
  FillArray;

  Writeln('Test de array door het op beeld te tonen..');
  TestArray;

  Writeln('.. klaar');
End.

[BdR]

Op vrijdag 09 november 2001 12:32 schreef Doekman het volgende:
Even praktisch: schakel over op Borland Pascal 7.0, daarmee kun je dus (unreal) protected modus doen.

Borland Pascal 7.0 heb ik net gisteren terug gevonden (ik zet em ook wel even op kazaa enzo), maar ik wist niet af van die "protected mode" optie, een collega wees mij daar vanochtend ook al op, maar bedankt voor de tips. Ik probeer het vanavond nog eens en hoop maar dat het dan werkt! *keeping fingers crossed*

Op vrijdag 09 november 2001 13:03 schreef OlafvdSpek het volgende:
Nee, hij bedoelt real mode zonder de 16-bit adres restrictie.

wat houd dat "unreal mode" precies in, ik bedoel hoe krijg ik dit? en wat zijn de gevolgen voor assembler code en geheugen adressering?

Op vrijdag 09 november 2001 13:03 schreef chaozz het volgende:
ook ik ben een spel aan het maken in good old Turbo Pascal 7.0

http://come.to/worldwidewenners

hee cool! hm.. die link doet het niet, maar bedoel je Lemmings at war? die ziet er ERG goed uit!!

[Olaf van der Spek]

Unreal mode houdt in dat je switched naar protected mode, de limits van 64k naar 4g verzet en weer terug switchted naar real mode. In assembler kun je dan via 32-bit addressering het hele geheugen benaderen.

Dit werkt niet als je processor in virtual mode draait (emm386, qemm, windows). Dan moet je het met emm386 (of een andere API) uitvechten.

[whoami]

Kan je in TPAS ook niet specifieren met welk memory model je wilt compileren? Small, Normal of Huge?

[Olaf van der Spek]

Nee (AFAIK).

[whoami]

AFAIK

[[ti]]

Ram es 2x ctrl-o achter elkaar in in je IDE, dan krijg je:

code:

{$A+,B-,D+,E-,F-,G+,I+,L+,N-,O-,P-,Q-,R-,S-,T-,V-,X+,Y+}
{$M 16384,0,655360}

Die $M switch is voor je stack/heap size. als je daar wat mee klungelt kom je er vast wel

[Olaf van der Spek]

Op vrijdag 09 november 2001 17:33 schreef whoami het volgende:
AFAIK

As far as I know.

[Verwijderd]

Ach, weemoed. Schone Turbo Pascal. Ik kreeg even de kriebels toen ik die TP listing zag. Wellicht toch maar weer eens Pascal oppakken (werk=alleen microsoft ).

Over far en near. Volgens mij kun je in TP een functie forceren far te zijn door:

Procedure doeIets(); far;

Maar ik weet het niet meer zeker. Heb je nodig, als je een interrupt procedure wilt maken.

[Olaf van der Spek]

Op vrijdag 09 november 2001 22:15 schreef Doekman het volgende:
Ach, weemoed. Schone Turbo Pascal. Ik kreeg even de kriebels toen ik die TP listing zag. Wellicht toch maar weer eens Pascal oppakken (werk=alleen microsoft ).

Over far en near. Volgens mij kun je in TP een functie forceren far te zijn door:
[..]

Maar ik weet het niet meer zeker. Heb je nodig, als je een interrupt procedure wilt maken.

Ja, maar we hebben het hier over pointers (naar data).

[BdR]

Ik heb mijn spel met Borland Pascal geprobeerd en het werkt allemaal weer er is duidelijk meer geheugen beschikbaar want alles wordt probleemloos ingelezen (ik had even 2 MB aan test graphics gemaakt).

Maarrr, protected mode is wat 'strenger' in vergelijking met real-mode voor wat betreft het geheugen aanspreken. Nu had ik het DMAmix van Steven Don gebruikt maar die geeft nu dus een probleem (loopt gewoon keihard vast..) heeft te maken dat er een page en offset aan de DMA wordt doorgegeven, dit moet dus op een andere manier in protected mode

Dus mijn vraag: heeft iemand een soundblaster DMAmix voorbeeld source die ook werkt in protected mode? Is een erg specifiek probleem dus moeilijk zoeken..

[Olaf van der Spek]

Ik denk dat je de pages die je voor DMA gaat gebruiken moet locken. Dan krijg je het fysieke adres en dat kun je dan voor DMA gebruiken.

[BdR]

pages locken..? uhm.. hoe doe ik dat?

[Olaf van der Spek]

Geen idee, heb nooit BP gebruikt.

[TheLunatic]

Met Borland Pascal kun je wel grote kingsize arrays maken mag ik opmaken uit een aantal vorige posts ?

[Olaf van der Spek]

Nee (IIRC).
De totale hoeveelheid geheugen is groter dan in TP, maar het is nog steeds 16-bits.