File : MM2SPECS.TXT
Datum: 21 Mar 1991
Door : Ries Vriend, Ramon van der Winkel - (c) MST
--------------------------------------------------

MEMMAN versie 2.0 specificaties
===============================

Voorlopige specificaties  <-------------> Deze Handleiding NIET verspreiden!!


Gebruikte terminologie
----------------------

Segment - Geheugenblok van  16kB. Segmenten  komen voor  in Pagina specifieke 
	  segmenten  (PSEG) en	Flexibele segmenten (FSEG). De Flexibele seg 
	  menten kunnen  op de	pagina's 0,1  en 2  worden aangeschakeld.  De 
	  Pagina  specifieke segmenten	alleen op  hun eigen  pagina. Er zijn 
	  drie	soorten  pagina  specifieke  segment:  PSEG0000,  PSEG4000 en 
	  PSEG8000. Ze	zijn op  respectievelijk pagina  0,1 en 2 aanschakel 
	  baar.

	  Indien DOS2 aktief is tijdens de installatie van MemMan, zal MemMan 
	  de  segmenten die niet meer vrij zijn bij DOS2 niet in de segmenten 
	  tabel opnemen. Het geheugen dat door een voor MemMan genstalleerde 
	  RAMdisk in gebruik is, zal dus niet meer door MemMan beheerd kunnen 
	  worden.
	  Wanneer een  (Dos2-) RAMdisk	na MemMan genstalleerd wordt, kunnen 
	  de  segmenten die  door de  RAMdisk gebruikt	werden wel  weer door 
	  MemMan gebruikt worden, nadat de RAMdisk verwijderd is.

Heap	- Blok geheugen  in pagina 3 (ergens tussen &HC000 en &HFFFF) waarvan 
	  MemMan  toepassingsprogramma's een stuk aan kunnen vragen en daarna 
	  vrij mogen gebruiken.

FastUse - Zelfde als  Use, maar dan het adres waarop de routine direct aan te 
	  roepen is in pagina 3.

unCrash - Om  te voorkomen  dat segmenten  aangevraagd zijn en door een crash 
	  van een  programma nooit  meer vrij zouden worden gegeven, voert de 
	  IniChk  routine een unCrash uit. Hierbij worden alle segmenten weer 
	  vrijgegeven. Het unCrashen van een segment is te voorkomen door een 
	  segment de  Reserved status te geven. Dit kan met de funktie SetRes 
	  (11).  Normaal gesproken  hoeft een segment niet de Reserved status 
	  gegeven te worden.


De principes

  MemMan verdeelt  het aanwezige geheugen in segmenten van 16 kB. Voordat een 
segment gebruikt mag worden moet het worden aangevraagd. Na gebruik dient het 
weer  te worden  vrijgegeven. Er  zijn twee  soorten segmenten: de zogenaamde 
pagina-specifieke ofwel PSEG's en de flexibele FSEG's.
  PSEG's  zijn  segmenten  die  aangevraagd worden  voor het  gebruik op  een 
bepaalde pagina, bijvoorbeeld van &h4000-&h7FFF of van &h8000-&hBFFF. Wanneer 
er  een  PSEG  aangevraagd  wordt  zal	MemMan zo  mogelijk geheugensegmenten 
toewijzen die niet in een memory-mapper zitten.
  FSEG's  zijn segmenten  die op elke willekeurige pagina kunnen worden inge 
schakeld. Deze	segmenten komen altijd uit memory mappers. Welk soort segment 
er  ook aangevraagd  wordt, MemMan  zal een 16-bits 'segmentcode' teruggeven. 
Deze segmentcode  is weer nodig bij het inschakelen of het weer vrijgeven van 
het  segment. Wie  alleen maar	geheugen nodig heeft in het gebied van &h8000 
tot &hBFFF  kan dus  het beste	PSEG's aanvragen.  MemMan gebruikt  dan eerst 
zoveel	mogelijk geheugen  uit de  'oude' 16- en 64 Kb modules en gaat dan de 
mapper gebruiken.

  Met behulp  van MemMan  hoeft er  dus nooit  meer naar  geheugen gezocht te 
worden.  Simpelweg een pagina aanvragen, gebruiken en uiteindelijk weer vrij 
geven. Zo eenvoudig is dat.
  Overigens  is er een pagina die zich met MemMan niet laat schakelen. Pagina 
3 bevat  behalve de MemMan code zelf ook de stack (meestal) en een grote hoe 
veelheid  systeemvariabelen. Er  zitten nogal  wat haken en ogen aan het weg 
schakelen van dat alles.


Funktie omschrijving
--------------------

Naam   : Use0
Nummer : 0
Funktie: Aanschakelen van een segment op pagina 0 (adres gebied 0000..3FFF)
In     : HL = Segmentcode
Uit    : A  = Resultaatcode (-1 = Mislukt, 0 = Gelukt)

Het inschakelen  van een  segment in  pagina 0	is alleen mogelijk indien het 
segment de MSX-standaard slot-schakel entry points bevat.


Naam   : Use1
Nummer : 1
Funktie: Aanschakelen van een segment op pagina 1 (adres gebied 4000..7FFF)
In     : HL = Segmentcode
Uit    : A  = Resultaatcode (-1 = Mislukt, 0 = Gelukt)


Naam   : Use2
Nummer : 2
Funktie: Aanschakelen van een segment op pagina 2 (adres gebied 8000..BFFF)
In     : HL = Segmentcode
Uit    : A  = Resultaatcode (-1 = Mislukt, 0 = Gelukt)


Naam   : Alloc
Nummer : 10
Funktie: Aanvragen van een segment
In     : B  = Segment voorkeuze code
Uit    : HL = Segmentcode. (0000 = Geen segment meer vrij)
         B  = Segmentsoort code (-1 = FSeg, 0 = PSeg)

Segment voorkeuze code overzicht:

Register B: Bit 7 6 5 4 3 2 1 0
		^ ^ ^ ^ ^ ^ ^ ^
		| | | | | | | |
		| | | | | | +-+--> Segment Type. 00 = PSEG0000
		| | 0 0 0 0			 01 = PSEG4000
		| |				 10 = PSEG8000
		| |				 11 = FSEG
		| +--------------> 1=Prefereer TPA (=Standaard DOS) RAM slot
		+----------------> 1=Prefereer ongexpandeerd (dus snel) slot

De bits 5 tot en met 2 zijn niet gebruikt en moeten 0 zijn.

Mocht  een PSEG  type aangevraagd,  maar niet beschikbaar zijn wordt - indien 
mogelijk - een FSEG ter beschikking gesteld die dan het PSEG kan vervangen.


Naam   : SetRes
Nummer : 11
Funktie: Segment de Reserved status geven
In     : HL = Segmentcode

Geeft  een segment  de `Reserved-status';  zodat het segment niet automatisch 
wordt vrij gegeven na aanroep van de IniChk routine. Normaal gesproken hoeven 
programma's de  reserved status  niet te  zetten, behalve als een programma - 
bijvoorbeeld een Ramdisk - een segment voor eigen gebruik zeker wil stellen.


Naam   : DeAlloc
Nummer : 20
Funktie: Teruggeven van een segment
In     : HL = Segmentcode

Bij  het verlaten  van een programma dient deze funktie gebruikt te worden om 
alle aangevraagde  segmenten weer  terug te  geven aan	MemMan. De  eventuele 
reserved status van het terug te geven segment wordt door DeAlloc automatisch 
opgeheven.
Segmenten  die ook  door DOS2  beheerd worden, worden door de DeAlloc funktie 
weer ter beschikking gesteld van DOS2.


Naam   : ClrRes
Nummer : 21
Funktie: Reserved status van het segment opheffen
In     : HL = Segmentcode

Het is	niet nodig deze funktie vlak voor DeAlloc aan te roepen. DeAlloc heft 
zelf de Reserved status van het segment op.


Naam   : IniChk
Nummer : 30
Funktie: Initialisatie MemMan voor een programma
In     : A  = Controle code
Uit    : A  = Controle code + "M"
         DE = Versie nummer (format: Versie #D.E)

Deze  routine telt  de ascii-waarde  van de  letter "M"  op bij de inhoud van 
register  A.  Hierdoor kan  er een  MemMan aanwezigheids  controle uitgevoerd 
worden. Verder	wordt er een unCrash uitgevoerd en worden de segmentcodes van 
de actief aangeschakelde sloten berekend en opgeslagen voor CurSeg.


Naam   : Status
Nummer : 31
Funktie: Status gegevens van MemMan ophalen
Uit    : HL = Aantal aanwezige segmenten
         BC = Aantal nog vrije segmenten
	 DE = Aantal segmenten in dubbel beheer bij DOS2 en MemMan
	 A  = Connected Status van de aangesloten hardware.
	      Bit   Funktie
	       0    Dos2 Mapper Support Routines aanwezig
	      1-7   Gereserveerd, altijd 0

Als  bit 0  van de Connected status gezet is, zijn de geheugenbeheer funkties 
van dos2.20 aanwezig.
Het aantal  nog vrije  segmenten kan lager zijn dan is aangegeven in register 
BC,  omdat sommige  segmenten na de installatie van MemMan door DOS2 gebruikt 
zijn - om bijvoorbeeld een ramdisk te installeren.


Naam   : CurSeg
Nummer : 32
Funktie: Segmentcode van een aangeschakeld segment opvragen.
In     : B  = Paginanummer (0,1,2,3)
Uit    : HL = Segmentcode
         A  = Segmentsoort code (-1 = FSeg, 0 = Pseg)

Deze routine geeft de huidige segentcode terug van een van de vier pagina's.

TSR programma's  mogen deze  funktie niet  gebruiken om  de aktieve segmenten 
stand van pagina 0 te bepalen. Wegens snelheids redenen en laag gebruik wordt 
deze stand niet automatisch bepaald en opgeslagen bij de aanroep van een TSR. 
Voor pagina 1 en 2 gebeurt dit wel, pagina 3 veranderd niet.

Om  de uitvoer	te versnellen kan ook de FastCurSeg worden gebruikt. Het aan 
roep adres hiervan is via de Info funktie (50) op te vragen.


Naam   : StoSeg
Nummer : 40
Funktie: Huidige segmenten stand opslaan
In     : HL = Buffer adres (9 bytes groot)

De voor  MemMan bekende segmentcodes van de actief aangeschakelde sloten wor 
den  opgeslagen in het buffer. Deze segmentcodes zijn in beginsel door IniChk 
berekend en  later door de Use funkties geupdate. De opgeslagen stand is niet 
de  huidige stand,  maar de voor MemMan bekende stand. TSR kunnen hiermee dus 
niet de actieve stand opslaan.


Naam   : RstSeg
Nummer : 41
Funktie: Opgeslagen segmenten stand actief maken
In     : HL = Buffer adres

De in  het buffer  opgeslagen segmenten  stand wordt  weer actief  gemaakt en 
wordt opgeslagen voor CurSeg.


Naam   : Info
Nummer : 50
Funktie: Geeft aanroep-adressen van snelle memman funkties
In     : B  = Informatie nummer (0..5)
Uit    : HL = Start adres van de funktie

Informatie  nummer overzicht. Tussen haakjes staan de equivalente MemMan fun 
ktie codes:

0 - FastUse0 adres (funktie 0)
1 - FastUse1 adres (funktie 1)
2 - FastUse2 adres (funktie 2)
3 - TsrCall adres (funktie 61)
4 - BasicCall adres
5 - FastCurSeg adres (funktie 32)


De bovengenoemde funktie-adressen mogen door een toepassings-programma of TSR 
rechtstreeks  aangeroepen worden.  Alle entry adressen liggen gegarandeerd in 
pagina 3.
De funkties  worden snel  uitgevoerd omdat de MemMan CALL naar de EXTBIO hook 
vervalt  en de funktie-codes in registers D en E niet uitgeplozen hoeven wor 
den. Een ander voordeel is dat parameters ook via het register DE doorgegeven 
kunnen worden, dit is vooral van belang bij de TsrCall en BasicCall funkties.

Bijvoorbeeld, de  initialisatie routine van een TSR kan de benodigde funktie 
adressen  via de  INFO funktie	opvragen en  deze vervolgens ergens in de TSR 
programmacode invullen, wat de snelheid van de TSR zeer ten goede kan komen.

Een  exacte beschrijving van de bovenstaande funkties kan gevonden worden bij 
de MemMan funktie waarvan het nummer tussen haakjes is aangegeven.
Houd echter  onder de aandacht dat de `snelle' funkties op de volgende punten 
van de gewone MemMan funkties verschillen:

fastUse0-2: Exact dezelfde werking als als een memMan Use aanroep.

tsrCall   : Register [DE]  wordt ongewijzigd  aan de  TSR doorgegeven. Dit in 
	    tegenstelling  tot funktie	61 (TsrCall),  register DE  is dan al 
	    bezet om het MemMan funktienummer in op te slaan.

fastCurSeg: In register  [A] komt geen zinnige waarde terug. De MemMan CurSeg 
	    funktie (32) geeft aan of het een FSEG/PSEG betreft.

basicCall : Heeft geen MemMan funktie nummer.
	    Funktie: Aanroepen van een routine in de BASIC ROM.
	    In:      IX=Call address in pagina 0 of 1
		     AF, HL, BC, DE = dataregisters voor de BASIC-ROM
	    Uit:     AF, HL, BC, DE = dataregisters van de BASIC-ROM
		     Interrupts disabled

	    Via  deze funktie  kunnen TSR's een routine aanroepen die zich in 
	    pagina 0  en/of pagina  1 van het BASIC-ROM bevindt. De bios moet 
	    al in pagina 0 aangeschakeld zijn. In pagina 1 wordt de BASIC ROM 
	    door MemMan aangeschakeld.
	    Dit  is bijvoorbeeld noodzakelijk om de math-pack routines aan te 
	    kunnen roepen  die in pagina 0 van de BASIC ROM zitten, maar tus 
	    sendoor ook een aantal routines in pagina 1 aanroepen.
	    De	H.STKE (stack error) hook wordt afgebogen, zodat na een even 
	    tueel  op  getreden  BASIC	error  de  interne stacks  van MemMan 
	    gereset kunnen worden.


Naam   : GetTsrID
Nummer : 60
Funktie: Bepaal TSR ID code
In     : HL = Pointer naar de TsrNaam (12 tekens).   Ongebruikte posities op 
	 vullen met spaties.
Uit    : Gevonden: Carry clear (NC)
		   IX = TSR ID code
	 Anders  : Carry set (C)


Naam   : TsrCall
Nummer : 61
Funktie: Roep het driver-entry van een TSR aan
In     : IX = ID code van de aan te roepen TSR
	 AF, HL, BC, DE worden ongewijzigd doorgeven aan de TSR.
Uit    : AF, HL, BC, DE komen ongewijzigd terug van de TSR.

	 Merk  op dat  alhoewel het  DE register ongewijzigd aan de TSR wordt 
	 doorgegeven, het  niet voor  parameter-invoer benut  kan worden.  De 
	 Extended  BIOS funktiecode  van MemMan (D='M' E=61) moet namelijk in 
	 dat register geplaatst worden.
	 Bij  de Fast-TsrCall  routine treedt  deze complicatie  niet op; het 
	 adres van  deze routine  kan middels de info funktie opgevraagd wor 
	 den.


Naam   : HeapAlloc
Nummer : 70
Funktie: Alloceer ruimte in de heap
In     : HL = Gewenste grootte van de ruimte (in bytes)
Uit    : Genoeg ruimte: HL = Startadres van de ruimte
	 Anders       : HL = 0000 -> Niet genoeg ruimte beschikbaar

	 Doormiddel van  deze funktie  kan een stuk geheugen gealloceerd wor 
	 den. Het geheugenblok zal zich gegarandeerd in pagina 3 bevinden.
	 De  heap is vooral nuttig voor TSR programma's, die hem bijvoorbeeld 
	 als tijdelijke of permanente diskbuffer kunnen gebruiken. Ook andere 
	 buffers - waarvan het absoluut noodzakelijk is dat ze zich in pagina 
	 3 bevinden - kunnen op de heap worden geplaatst.
	 Aangevraagde blokken  geheugen uit de heap  blijven onbruikbaar voor 
	 andere  programma's totdat  een `HeapDeAlloc' is uitgevoerd (funktie 
	 71).


Naam   : HeapDeAlloc
Nummer : 71
Funktie: Geef geAlloceerde ruimte van de heap weer vrij
In     : HL = Startadres van de ruimte


Naam   : HeapMax
Nummer : 72
Funktie: Geef de lengte van het grootste vrije blok geheugen in de heap terug
Uit    : HL = Lengte van het grootste vrije blok


Opbouw van een TSR programma
----------------------------

  TSR's kunnen  geprogrammeerd worden  met iedere assembler die `relocatable' 
bestanden  kan	maken,	kortweg  `.REL'  bestanden. Voorbeelden  hiervan zijn 
DEVPAC2 van HiSoft en M80 van Microsoft. Van n of meerdere van deze bestan 
den maakt het TsrLink programma het definitieve TSR bestand.

  Ieder TSR  programma bestaat uit onderdelen die elk op een vaste positie in 
het bronbestand moeten staan. Deze programma onderdelen zijn:

- Header tabel
- TSR programmacode
- TSR initialisatiecode
- Hook tabel


De  Header tabel bevindt zich bovenaan iedere TSR listing en bevat informatie 
over de TSR. De indeling van deze tabel is als volgt:


- MSR TSR file ID, 9 bytes.

	DEFB 'MST TSR',13,10


- TSR naam, 12 bytes. Een zo uniek mogelijke ID-tekst gekozen door de progra 
  mmeur. Toepassingen  kunnen door  middel van	deze naam met de TSR communi 
  ceren. Ongebruikte posities opvullen met spaties.

	DEFB 'MSTs TSRname'


- Einde tekst markering, 1 byte. Afsluitend staat altijd Control-Z (^Z), voor 
  het geval TYPE commando losgelaten wordt op de TSR programmacode.

	DEFB 26


- Vereiste  versie nummer  van de  TSR-Loader, 2 bytes. De loader controleert 
  dit nummer, om te voorkomen dat een `verouderde' loader een TSR file in wil 
  lezen die een niet-compatible struktuur heeft. De TSR-loader is upward-com 
  patible,  zodat  ook eventuele  TSR's van  een vorige  versie genstalleerd 
  kunnen worden. Gebruikers kunnen dan volstaan met het updaten van de loader 
  en kunnen dezelfde TSR's blijven gebruiken.

	DEFW 0000


- Base-adres van  de TSR  programmacode, 2  bytes. Dit	is het	adres van het 
  eerste  byte van  de TSR  programma code.  Deze waarde wordt door de loader 
  gebruikt om de programma relatieve adressen aan te passen.

	DEFW TSR		;Eerste byte van de tsr-code


- Initialisatie  adres, 2 bytes. Wordt aangeroepen tijdens de installatie van 
  de TSR.  De Init-routine  MOET helemaal  achteraan het TSR-programma staan, 
  zodat  de loader de ruimte van de INIT routine weer eenvoudig kan vrijgeven 
  nadat de TSR genstalleerd is.

	DEFW INIT		;Start van de initialisatie routine

  Na de aanroep moet de initroutine in register A een vlag teruggeven.
  De definitie van dit vlaggenregister is als volgt:

		 reg   bit | functie
	       ------------+------------------------------
	 uit:	  A	0  | 0 = Initialisatie gelukt
			   | 1 = Initialisatie mislukt
			1  | 0 = Geen intro-tekst
			   | 1 = Pointer naar intro-tekst in [DE]
		       2-7 | Altijd nul in deze versie

  Indien de  TSR initialisatie	routine met bit 0 van het A register aangeeft 
  dat  de installatie  niet gelukt is, verwijdert de TSR-Loader de gehele TSR 
  weer. Als  de TSR  met bit  1 aangeeft dat er een intro tekst afgedrukt is, 
  dan wordt deze door de TSR-Loader afgedrukt. TSR's mogen NOOIT zelf teksten 
  op  het scherm  afdrukken. Hierdoor  is mogelijk  om in  de toekomst ook in 
  grafische omgevingen	de intro  tekst af  te kunnen drukken. Ook het onder 
  drukken van de intro teksten is dan eenvoudiger.

  De  hooks worden  pas NA  de aanroep van de initialisatie routine genstal 
  leerd.


- Destruktie adres, 2 bytes. Wordt aangeroepen bij verwijderen van de TSR.

	DEFW KILL


- Driver entry	adres, 2 bytes. Wordt aangeroepen via driver-entry van de TSR 
  manager.

	DEFW TALK


- Lengte  van de  TSR-code, 2  bytes. Deze  lengte is zonder de initialisatie 
  routine.

	DEFW TsrLen


- Lengte  van  de Initialisatie  routine, 2  bytes. De	initialisatie routine 
  staat helemaal  achteraan de	TSR, en wordt bij de initialisatie van de TSR 
  in hetzelfde segment gezet als de TSR code zelf. De ruimte die de initiali 
  satie routine in beslag neemt wordt na de aanroep ervan weer vrij gegeven.

	DEFW IniLen



Mogelijkheden van TsrLink:
- Externals
- Publics
- Library search (nog) niet mogelijk


Algemene opmerkingen omtrend TSR's
----------------------------------

  Alle TSR's worden in gegarandeerd in pagina 1 (4000h..7fffh) geplaatst.

  Tijdens een TSR aanroep - via een hook of het driver-entry - laat MemMan de 
geheugen segmenten  in pagina  0, 2 en 3 ongemoeid. Alleen pagina 1 wordt ge 
schakeld, om de TSR te kunnen activeren.

  Een  TSR mag	de IniChk functie (30) nooit aanroepen. Dit zou nare gevolgen 
hebben voor  een toepassings  programma, dat  te gelijker tijd ook van MemMan 
gebruik  maakt. Alle  door dat programma aangevraagde segmenten zouden dan in 
een keer weer vrij gegeven worden door de unCrash funktie die in IniChk zit.

  Wees	er zeker  van dat  de door een TSR aangevraagde segmenten de Reserved 
status hebben,	anders zou  bij het  opstarten van een MemMan applicatie pro 
gramma	het segment  weer vrij	worden gegeven, omdat deze programma's altijd 
eerst IniChk aanroepen en deze meteen met het unCrashen van segmenten begint.

  Voordat vanuit een TSR een segment geschakeld wordt, moet eerst het actieve 
segment bepaald worden via de CurSeg of FastCurSeg routines. Bij het verlaten 
van  de TSR dient het originele segment weer teruggeschakeld te worden. TSR's 
mogen alleen  alleen gebruik  maken van  de use1 en use2 funkties van MemMan; 
use0  en ook  (fast-) CurSeg0 zijn niet toegestaan. Voordat use2 gebruikt mag 
worden, dient de stack in pagina 3 geplaatst te zijn - ga er niet van uit dat 
de stack  zich altijd  in pagina  3 zal  bevinden! Aktiveer  bij voorkeur een 
tijdelijke stack op de heap, deze bevindt zich gegarandeerd in pagina 3.

  De omvang  van deze  tijdelijke stack hangt af van het feit of de interrupt 
mode  aan of  uit geschakeld  wordt. Indien  de TSR interrupts toestaat (door 
middel van  een EI-instruktie),  dient de  stack ongeveer  150 bytes groot te 
zijn.  Indien de  TSR de  interrupt mode uit schakelt (door middel van een DI 
instruktie) hoeft  deze stack niet groter te zijn dan voor het draaien van de 
TSR noodzakelijk is. In de meeste gevallen zal een stack van 32 bytes al ruim 
voldoende zijn.
  Het  verdient dus  de voorkeur om de interrupts uit te schakelen wanneer de 
tijdelijke stack aktief is, omdat er dan weinig ruimte op de heap nodig is.

  Als  een TSR verwijderd wordt, wordt het KILL adres van de TSR aangeroepen. 
Op dat	moment moeten  alle eventueel door de TSR aangevraagde segmenten weer 
terug  worden gegeven (DeAlloc), en het op de heap gealloceerde geheugen weer 
vrij worden  gegeven (HeapDeAlloc). Gebeurt dit niet, dan zullen er niet meer 
terug te vinden stukken geheugen op de heap ontstaan en segmenten onbruikbaar 
worden.


Gebruik van de stack onder MemMan
---------------------------------

  MemMan toepassings programma's dienen de stack pointer (SP) bij voorkeur in 
pagina	2 of  3 (tussen &h8000 en &HFFFF) te plaatsen. Indien MemMan door een 
hook-aanroep geactiveerd wordt, wordt het huidige segment in pagina 1 (&h4000 
tot &h8000)  namelijk weggeschakeld om plaats te maken voor de TSR-Manager en 
de  eventuele TSR's.  Indien de  stack zich op dat moment in pagina 1 bevindt 
zal de computer vastlopen.

  Indien  TSR's na een BDOS call of interrupt via een BIOS-hook worden aange 
roepen treden  geen stackproblemen  op; ook niet indien de stack van het toe 
passings programma in pagina 1 staat. De BDOS en interrupt funkties gebruiken 
namelijk  hun eigen  stack in  pagina 3.  De stack bevindt zich dan alsnog in 
pagina 3 op het moment dat de hook aangeroepen wordt.

  Bestaande  CP/M  en  MSX-DOS	programmatuur  is  dus	zonder	problemen  in 
combinatie met	MemMan 2  te gebruiken - maar alleen indien de standaard BDOS 
calls gebruikt worden. Wanneer echter via een interslot call een BIOS routine 
rechtstreeks  aangeroepen wordt,  dient de  stack in  pagina 2 of 3 te staan. 
Reserveer minimaal 160 bytes voor de stack.


Appendix 1: BIOS aanroepen onder Turbo Pascal

  Indien in  een Turbo Pascal programma interslot-calls naar de BIOS gebruikt 
worden,  is het belangrijk dat de stack in pagina 2 of 3 staat. Op het moment 
dat de	BIOS dan  een hook  aanroept kan MemMan veilig de TSR's aktiveren. De 
positie  van de stack is afhankelijk van het maximum programma adres dat tij 
dens de  compilatie in	Turbo Pascal  is ingesteld.  De stack bevindt zich in 
Turbo  Pascal direkt  onder het  variabelen geheugen. Het variabelen geheugen 
dient bij  programma's die  de BIOS aanroepen dus ruim boven adres &h8000 ge 
plaatst te worden.

  Is  geen source  voorhanden, dan  is het  mogelijk om  met een debugger het 
stack adres van Turbo Pascal programma's aan te passen. De initialisatie code 
van een TP programma ziet er als volgt uit:

  start: jp init
	 ...
	 ...
  init:  ld sp,100h
	 ld hl,nn
	 ld de,nn
	 ld bc,nn
	 call yy
	 ld hl,nn
	 ld de,stack	;DE bevat het stack adres, hoeft alleen
	 ld bc,nn	; aangepast te worden als het lager is
	 call zz	; dan &h80A0
	 ...

  Het stackadres in register DE kan bijvoorbeeld op &hC100 gezet 
  worden. Eventueel kan ook adres &hFAF0 (play-buffer) als stacktop 
  ingevuld worden.

** Einde **
