LANGE: Geheugenbeheer in QuickBasic & Basic Compiler

Disclaimer voor KB-inhoud ingetrokken

Dit artikel gaat over producten waarvoor Microsoft niet langer ondersteuning biedt. Daarom wordt dit artikel aangeboden 'as is' en wordt het niet langer bijgewerkt.

Samenvatting

Programmeurs kunnen begrijpen hoe Microsoft QuickBasic en Microsoft Basic Compiler geheugen rangschikken schrijven van programma's die efficiënt gebruik van systeembronnen wilt. De taal QuickBasic biedt een verscheidenheid aan gegevenstypen en modulaire codeconstructies waarop u de gegevens beheren en de code van uw programma's.

Meer informatie

In dit artikel komen de volgende onderwerpen aan bod:


  1. Codebeheer


    1. Modulair programmeren
    2. Wat gaat op moduleniveau in een module ondersteuning
    3. GEMEENSCHAPPELIJKE, GEMEENSCHAPPELIJKE GEDEELD, GEDEELD, GEDEELDE DIM
  2. Gegevensbeheer


    1. $DYNAMIC en $STATIC metacommands
    2. Grote arrays
Bijlage A bevat een voorbeeld ter illustratie van de onderwerpen in dit artikel.


Bijlage B verklaart het. TOEWIJZEN van bestand gemaakt wanneer u het programma bijlage A voorbeeld is gekoppeld. U kunt de kaart koppelen bepalen hoe sluiten elke module nadert de limiet van 64K code en hoe sluit het. Statische variabelen EXE-programma krijgen om de limiet van 64K in de DGROUP te.


In de bijlagen C en D beschrijven in detail de toewijzing van geheugen voor het uitvoeren van programma's in de volgende drie verschillende omgevingen: de QB. EXE-editor een gecompileerde. Met behulp van de module runtime-programma en een. EXE gecompileerd met de optie zelfstandig.

Definities

Een "module" wordt gedefinieerd als een afzonderlijk bestand met elementaire procedures.


"Code op moduleniveau" wordt gedefinieerd als de instructies in een module die buiten een SUB... END SUB FUNCTIE... END FUNCTION of DEF FN... EINDE DEF definitie blokkeren.


Een module' ondersteuning' is een bestand los van de belangrijkste module met extra SUB of FUNCTION-procedures.

CODEBEHEER

Modulair programmeren

Modulaire programmering behandelt programma's splitsen in afzonderlijke modules (dat wil zeggen: afzonderlijke bestanden met SUB of FUNCTION-procedures). De redenen hiervoor zijn de volgende:


  1. U hebt een blok code eenmaal geschreven als een module, kan gemakkelijk worden opgenomen in toekomstige projecten.
  2. Foutopsporing is gemakkelijker. Problemen kunnen zich veel sneller en kunnen worden opgenomen in een bepaald gebied van het programma.
  3. De compiler (BC. EXE) en het milieu (QB. EXE) een beperking van de code 64 kB per module. Een modulaire stijl van programmeren kunt u programma's groter zijn dan 64 kB, nadat alle modules, zelfs als het deel van een programma uitmaakt kan maximaal 64 kB groot zijn.
Als een programma groot is, kan het zijn nodig om op te delen in verschillende modules. Dit is gemakkelijk doen door SUB of FUNCTION-procedures van de belangrijkste module verbreken en brengen ze in ondersteunende modules. Deze modules worden vervolgens apart gecompileerd met BC. EXE en gekoppeld met de belangrijkste module zoals in het volgende voorbeeld.


Houd rekening met een programma Main.BAS die is onderverdeeld in drie modules:


  1. MAIN. BAS (die externe procedures aanroepen)
  2. MODULE2. BAS (die bevat procedures voor SUB en/of functie)
  3. MODULE3. BAS (die bevat procedures voor SUB en/of functie)
De drie modules worden vervolgens elk afzonderlijk produceren de volgende Objectbestanden gecompileerd:


  1. BC-MAIN. BAS; MAIN--->. OBJ
  2. BC MODULE2. BAS; ---> MODULE2. OBJ
  3. MODULE3, BC. BAS; MODULE3--->. OBJ
Voor de productie van het uitvoerbare bestand (. EXE) wordt, de volgende opdrachtregel gebruikt:
    LINK Main.OBJ+Module2.OBJ+Module3.OBJ; ---->  Main.EXE
Main.EXE is het uitvoerbare programma dat klaar. Wanneer u nu compileert in de omgeving van QuickBasic (QB. EXE), de omgeving automatisch elke module gecompileerd en worden deze samen om dezelfde produceren. OBJ bestanden en uitvoerbaar programma is voltooid.


Om een. EXE-programma van de QB. EXE-omgeving, het volgende doen:


  1. Kies in het menu uitvoeren.
  2. Het EXE bestand maken... Kies optie.
  3. Kies de optie zelfstandige EXE-bestand om een zelfstandig bestand te maken. Als deze optie niet is geselecteerd, wordt vereist dat de BRUN4x.EXE runtime-module aanwezig tijdens runtime.
  4. Druk op ENTER.
De QuickBasic omgeving biedt een eenvoudige manier om de volgende bewerkingen die verder hieronder beschreven:


  1. Maak een nieuwe Module voor resources
  2. Subroutines en Modules bewerken
  3. Resources verwijderen
  4. Resources verplaatsen van de ene Module naar een andere Module
In de QB. EXE, een afzonderlijke module (bronbestand) maken van subroutines, dit doen:


  1. Kies in het menu bestand.
  2. Kies het bestand maken... optie.
  3. Voer de naam voor de module.
  4. Druk op ENTER.
Een bestand wordt vervolgens gemaakt met de naam die u hebt opgegeven, en worden in het geheugen met de andere voorkomend. Sla alle geladen modules kunt u het volgende doen:


  1. Kies in het menu bestand.
  2. Kies de optie Alles opslaan.
Wanneer de modules samen opgeslagen worden, maakt QuickBasic een bestand (met de extensie. MAK) die houdt van de belangrijkste module en de andere modules die worden gebruikt door de belangrijkste. Als u wilt laden in een keer alle modules in, het volgende doen:


  1. Kies in het menu bestand.
  2. Kies het programma... optie.
  3. Selecteer de belangrijkste module van het programma als het bestand moet worden geopend.
Bekijken en resources selecteren voor bewerken door het volgende te doen:


  1. Kies in het menu Beeld.
  2. Kies de subroutines... optie.
  3. Markeer de module of SUB die u wilt bewerken.
  4. Klik op bewerken in het actieve tabblad of bewerken in een gesplitste.
  5. Druk op ENTER.
U verwijdert een SUB, het volgende doen:


  1. Kies in het menu Beeld.
  2. Kies de subroutines... optie.
  3. Markeer de SUB die u wilt verwijderen.
  4. Met de tab naar de optie verwijderen.
  5. Druk op ENTER.
Als u wilt een SUB verplaatsen naar een andere module, het volgende doen:


  1. Kies in het menu Beeld.
  2. Kies de SUBROUTINES... optie.
  3. Markeer de SUB die u wilt verplaatsen.
  4. Met de tab naar de optie verplaatsen.
  5. Druk op ENTER.
  6. Selecteer de module die u wilt dat de SUB in.
  7. Druk op ENTER.
Voor meer informatie over het gebruik van de QB. EXE-omgeving, Raadpleeg de handleiding 'Microsoft QuickBasic: leren te gebruiken' voor 4,50 versie of Raadpleeg de handleiding 'Microsoft QuickBasic 4.0: leren en werken met' versie 4.00 en 4.00b en de Basic compiler versies 6,00 en 6.00b.

Wat gaat op moduleniveau in een Module ondersteuning

Een module ondersteuning tijdens het compileren, produceert een object (. OBJ)-bestand dat is gekoppeld aan een hoofd module een uitvoerbaar bestand te maken. De code op moduleniveau van de belangrijkste module is de enige code rechtstreeks uitgevoerd door QuickBasic. De code op moduleniveau van de modules ondersteuning kan niet CALLed, uitvoeren of CHAINed. Deze code op moduleniveau support modules wordt alleen gebruikt voor:


  1. De handlers gebeurtenis of fouten onderscheppen
  2. Metacommands
  3. Definities, DIM en gemeenschappelijk gedeelde instructies typen
U kunt plaatsen op gebeurtenis GOSUB en ON ERROR GOTO overlapping overzichten in subprogramma procedures [waar op gebeurtenis betekent ON KEY(n), ON COM(n), ON-TIMER(n), enz.]. De lijn of een lijn-label, dat het doel van de val gebeurtenis of fout GOTO of GOSUB moet wel de code op moduleniveau in dezelfde module bevinden als die subprogramma. Dit komt doordat QuickBasic niet mogelijk GOSUBs of GOTOs van een subprogramma aan andere modules of subprogramma's en QuickBasic kan alleen op gebeurtenis GOSUB en ON ERROR GOTO-instructies om te gaan met de code op moduleniveau een subprogramma.


De compiler metacommands (REM $INCLUDE $STATIC REM en REM $DYNAMIC) kan ook worden gebruikt op het moduleniveau. REM $INCLUDE wordt extra bron in de module geplakt tijdens het compileren. $DYNAMIC REM en REM $STATIC declareren volgende arrays als $DYNAMIC (toegewezen tijdens het uitvoeren) of $STATIC (toegewezen tijdens het compileren).


U kunt TYPE... END TYPE, DIM en gemeenschappelijk gedeelde instructies in de code op moduleniveau. Variabelen en matrices kunnen worden gedeeld tussen modules met de gemeenschappelijke gedeelde instructie op moduleniveau.

Algemeen, gemeenschappelijk gedeelde gedeeld en DIM gedeeld

De instructie gedeelde beschikt een SUB of FUNCTION procedure variabelen die worden gedeclareerd op moduleniveau belangrijkste van die module (zonder deze als parameters doorgeven). Het geeft toegang tot variabelen die worden gedeclareerd in ondersteunende modules.


De algemene instructie worden variabelen op moduleniveau tussen modules beschikbaar. Het kenmerk gedeeld voor de algemene instructie (dat wil zeggen, gemeenschappelijke gedeeld) is vereist voor het delen van de variabelen met subprogramma's of functies. De lijst van variabelen in de gemeenschappelijke en gemeenschappelijk gedeelde instructies moet van hetzelfde type in de gemeenschappelijke en gemeenschappelijk gedeelde instructies in elke module.


Wanneer u de instructie gemeenschappelijke (of in een gemeenschappelijke gedeelde), worden statische en dynamische arrays anders gedimensioneerd. Statische matrices moeten gemeen gedimensioneerd voordat de gemeenschappelijke verklaring in alle modules met deze gemeenschappelijke verklaring. Dynamische matrices moeten gemeenschappelijk gedimensioneerd na de algemene instructie in alleen de belangrijkste module en niet in alle modules die ondersteuning moeten worden opgezet.


Er zijn twee verschillen tussen het gebruik van de instructie gedeeld en de instructie DIM gedeeld:


  1. Een variabele om toegankelijk te maken door het subprogramma's in een module, gebruikt u DIM gedeeld op moduleniveau.
  2. Om een Moduleniveauvariable met een specifieke subprogramma delen, de variabele te plaatsen in een gedeelde-instructie in het subprogramma. De instructie gedeeld gaat direct na de eerste regel van het subprogramma.

GEGEVENSBEHEER

Matrices $DYNAMIC en $STATIC

De standaardinstelling voor het opslaan van matrices is REM $STATIC, waarin alle arrays worden opgeslagen in de DGROUP (de standaard gegevenssegment). Voor alle Basic. EXE-programma, DGROUP is beperkt tot 64 kB. Als u statische arrays gebruikt, krijgt u meer geheugen in de DGROUP door de matrices dynamisch, die ze verplaatst naar de verste heap. Als u een matrix dynamische, de matrix dimensie na de metacommand REM $DYNAMIC of dimensie van de matrix met een variabele in het subscript.


Alle dynamische arrays worden opgeslagen op de ver-heap, met uitzondering van matrices van tekenreeksen met variabele lengte. Tekenreeksen, een tekenreeks met variabele lengte, matrices en eenvoudige variabelen worden altijd opgeslagen in DGROUP. Voor het opslaan van tekenreeksen in de ver-heap, moet u een dynamische matrix van tekenreeksen met vaste lengte dimensie. Tekenreeksen met vaste lengte in dynamische matrices afmetingen helpt bij het vrijmaken van ruimte die zij anders kunnen hebben genomen in de DGROUP, die is beperkt tot 64 kB.

Grote Arrays

Grote arrays zijn arrays die groter dan 64 kB zijn. Wanneer u grote arrays gebruikt, moet u de QB aanroepen. EXE-editor en BC. Met de optie /AH EXE-compiler. De enorme matrix moet worden opgezet als een dynamische matrix met een variabele in de subscript van de matrix of het vorige metacommand REM $DYNAMIC. De optie /AH kunt dynamische matrices van door de gebruiker gedefinieerde typen, tekenreeksen met vaste lengte en numerieke gegevens al beschikbaar geheugen in beslag nemen.


Het aantal bytes in een enkel element van een matrix enorme moet bij voorkeur een macht van 2, om te voorkomen dat overbodige geheugen inschakelen arrays groter zijn dan 128 K, zoals hieronder uitgelegd.


Ruimte is voor een breed scala aansluitend in de ver-heap, met de beperking dat geen enkele array-element (of record) mag worden gesplitst bij een grens van 64 kB toegewezen. Als een record niet een macht van 2 is, wordt de array toegewezen op een offset hoog genoeg, ten opzichte van de matrix basis segmentadres (die wordt geretourneerd door de functie VARSEG), dat geen element van de matrix is verdeeld over de grens bij exact 64 K boven het basis-segment. De waarde die wordt geretourneerd door de functie VARPTR voor het eerste element van de array vervolgens geeft zowel de verschuiving van de matrix, en ook de grootte van een opening in ver-heap wordt gemaakt. Lege ruimte fragmenten van de ver-heap en verspilde, ongebruikte geheugen is. De grootte van de ruimte is gelijk aan (65.536) MOD (record matrixgrootte). [In het ergste geval de kloof kan zijn (record matrixgrootte) min 1 grootte.]


Een 'Subscript buiten bereik'-fout treedt op bij het toewijzen van een zeer grote matrix groter is dan 128 K als de matrixelementen een formaat dat niet een even macht van 2. Matrices die groter zijn dan 128K moet de grootte van een element dat een macht van 2 (2, 4, 8, 16, 32, 64, enz.), aangezien matrices aaneengesloten worden opgeslagen en mag geen enkele array-element moet worden verdeeld over een grens van 64 kB.


De laatste belangrijke aspect QuickBasic geheugenbeheer is dat QuickBasic probeert om efficiënt gebruik van het geheugen, dat ervoor zorgen dat kan tekenreeksen van variabele lengte, matrices tekenreeks met variabele lengte en dynamische matrices om te navigeren in het geheugen instructie instructie tijdens runtime. (Andere variabelen hebben een vaste locatie bepaald tijdens het laden EXE.) Ook als u een overzicht van de KETEN, kan vervolgens alle gegevens doorgegeven in een gemeenschappelijk blok verplaatsen. Dit betekent dat de resultaten van de VARPTR, VARSEG, VARPTR$, of de functie SADD moet altijd worden gebruikt direct na dat de functie wordt aangeroepen.

BIJLAGE A: VOORBEELD PROGRAMMA

In dit voorbeeldprogramma wordt beschreven in de onderwerpen die in dit artikel. Dit programma geeft een voorbeeld van de volgende manieren dimensie arrays en variabelen doorgeven tussen modules en subprogramma's. Het programma bestaat uit twee modules, elk waarin een subprogramma.

Belangrijkste Module (EXAMPL1. BAS)

DECLARE SUB OtherModSub ()DECLARE SUB Subdemo ()

TYPE PowerOfTwo
I AS INTEGER ' 2 Bytes
L AS LONG ' 4 Bytes
S AS SINGLE ' 4 Bytes
D AS DOUBLE ' 8 Bytes
St AS STRING * 14 ' 14 Bytes

END TYPE ' 32 Bytes Total, a power of 2, 2^5

REM $STATIC
DIM A(100) AS INTEGER ' Static array, stored in DGROUP.

COMMON SHARED A() AS INTEGER ' Share the variables with the other
COMMON SHARED B AS STRING * 20 ' module and its SUBprograms.
COMMON SHARED X() AS INTEGER

REM $DYNAMIC
DIM X(100) AS INTEGER ' Dynamic array, stored in far heap.
DIM PTwo(4000) AS PowerOfTwo ' Dynamic huge array, stored in far heap
' Each element is a power of two, 2^5.

DIM NonFixedLen(10) AS STRING ' Dynamic array, but since it is not
' fixed length it is stored in DGROUP.

REM $STATIC
DIM SHARED M(100) AS LONG ' These variables are shared with all
DIM SHARED Equals AS STRING * 10 ' the SUBprograms in this module,
' and are stored in the DGROUP.

Num = 40

DIM DynArray(Num) AS SINGLE ' The array is dynamic since it is
' DIMensioned with a variable, so
' it is stored in far heap.

Plus$ = " + "
Equals = " = "
M(1) = 7
A(1) = 4

CALL Subdemo ' CALLs the SUBprogram of this module.
CALL OtherModSub ' CALLs the SUBprogram of the support module.
END

'SUBprogram of the Main Module:

SUB Subdemo

SHARED Plus$, NonFixedLen() AS STRING, Num

PRINT STR$(Num) + Plus$;
PRINT STR$(M(1))+ Equals + STR$(A(1));
A(1) = M(1)


END SUB

Module Support (EXAMPL2. BAS)

REM $STATIC
DIM A(100) AS INTEGER ' Only the static array is DIMensioned
COMMON SHARED A() AS INTEGER ' before the COMMON SHARED statement.
COMMON SHARED B AS STRING * 20
COMMON SHARED X() AS INTEGER ' The dynamic array is only DIMensioned
' in the main module.

Panic: ' The label for ON ERROR has to be at
resume next ' the module level.


' SUBprogram of the Support Module:

SUB OtherModSub
PRINT A(1)
ON ERROR GOTO Panic
END SUB

BIJLAGE B: KOPPELING. MAP BESTAND UITLEG

Hieronder vindt u een. MAP-bestand gemaakt wanneer u het programma voorbeeld in bijlage A is gekoppeld. De. MAP-bestand van een succesvolle koppeling ziet u hoe dicht codesegment van de module nadert de limiet van 64K code en hoe dicht de statische variabelen voor de gehele. EXE-programma worden nadert de limiet van 64K in de DGROUP. Voor het genereren van een kaart met vermelding van een programma bevatten een bestandsnaam in het derde argument van de opdracht koppeling, zoals in het volgende voorbeeld:
   LINK EXAMPL1.OBJ+EXAMPL2.OBJ,,EXAMPLE.MAP;
Opmerkingen voor de koppeling. KAART weergegeven verder hieronder zijn als volgt:


  1. EXAMPL1_CODE is het codesegment voor EXAMPL1. BAS.
  2. EXAMPL2_CODE is het codesegment voor EXAMPL2. BAS.
  3. Het codesegment van elke module is minder dan 64 kB. Wanneer het codesegment is bijna van 64 kB, moet u de module opsplitsen in twee of meer modules. Voor de lengte van een codesegment, zoekt u in de kolom lengte. De lengte van het codesegment voor EXAMPL1. BAS is 15A hexadecimale bytes, 346 in decimale notatie met punten.
  4. FAR_MSG is de verste management groep waarin de tekst van foutberichten. Dit is niet de ver-heap. De ver-heap wordt toegewezen tijdens het uitvoeren.
  5. Volgens de afdeling oorsprong onder aan het overzicht van de koppeling begint DGROUP 06DC:0, namelijk de hex lid adres 06DC, met een marge van 0. Dit is hetzelfde als de hexadecimale byte adres 06DC0 (Aangezien een alinea 16 bytes bevat). Dus in dit voorbeeld, DGROUP begint waar de BR_DATA begint.
  6. DGROUP eindigt bij de Stop-adres van de STAPEL.
  7. Als u wilt weten hoe groot de DGROUP van het programma, het adres van de Stop van de stapel en aftrekken van het adres van de Start van het eerste element in de DGROUP. De grootte van de DGROUP van het programma is bijvoorbeeld hex 7F9F min 6DC0 hex, wat gelijk is aan 11DF (4575) aantal hexadecimale bytes.
  8. Alle adressen in de. Toewijzing zijn alleen ten opzichte van het begin van de. EXE-programma. De absolute adres wordt bepaald door DOS alleen tijdens runtime. De instructies VARSEG en VARPTR kunnen worden gebruikt in uw programma tijdens het uitvoeren om de absolute adressen van de variabelen weer te geven.

EXAMPLE.MAP

 Start  Stop   Length Name                   Class
00000H 00159H 0015AH EXAMPL1_CODE BC_CODE
00160H 001C1H 00062H EXAMPL2_CODE BC_CODE
001C2H 03931H 03770H CODE CODE
03932H 03A0CH 000DBH INIT_CODE CODE
03A10H 041B2H 007A3H _TEXT CODE
041C0H 065EFH 02430H EMULATOR_TEXT CODE
065F0H 065F0H 00000H C_ETEXT ENDCODE
065F0H 065F7H 00008H FAR_HDR FAR_MSG
065F8H 06C44H 0064DH FAR_MSG FAR_MSG
06C45H 06C46H 00002H FAR_PAD FAR_MSG
06C47H 06C47H 00001H FAR_EPAD FAR_MSG
06C50H 06DBFH 00170H EMULATOR_DATA FAR_DATA

06DC0H 06DC0H 00000H BR_DATA BLANK
06DC0H 06DEFH 00030H BR_SKYS BLANK
06DF0H 06EFBH 0010CH COMMON BLANK
06EFCH 070E3H 001E8H BC_DATA BC_VARS
070E4H 070E9H 00006H NMALLOC BC_VARS
070EAH 070EAH 00000H ENMALLOC BC_VARS
070EAH 070EAH 00000H BC_FT BC_SEGS
070F0H 0710FH 00020H BC_CN BC_SEGS
07110H 07122H 00013H BC_DS BC_SEGS
07124H 07124H 00000H BC_SAB BC_SEGS
07124H 0712BH 00008H BC_SA BC_SEGS
0712CH 0712FH 00004H BC_SAE BC_SEGS
07130H 07345H 00216H _DATA DATA
07346H 0761FH 002DAH _BSS DATA
07620H 0771CH 000FDH BR_DATA DATA
0771EH 0771EH 00000H XIB DATA
0771EH 07741H 00024H XI DATA
07742H 07742H 00000H XIE DATA
07742H 0774DH 0000CH DBDATA DATA
0774EH 0775BH 0000EH CDATA DATA
0775CH 0775CH 00000H XIFB DATA
0775CH 0775CH 00000H XIF DATA
0775CH 0775CH 00000H XIFE DATA
0775CH 0775CH 00000H XPB DATA
0775CH 0775CH 00000H XP DATA
0775CH 0775CH 00000H XPE DATA
0775CH 0775CH 00000H XCB DATA
0775CH 0775FH 00004H XC DATA
07760H 07760H 00000H XCE DATA
07760H 07760H 00000H XCFB DATA
07760H 07760H 00000H XCF DATA
07760H 07760H 00000H XCFE DATA
07760H 0779FH 00040H CONST DATA
077A0H 077A0H 00000H BC_DATA BC_DATA
077A0H 077A0H 00000H XOB BSS
077A0H 077A0H 00000H XO BSS
077A0H 077A0H 00000H XOE BSS
077A0H 07F9FH 00800H STACK STACK

Origin Group
06DC:0 DGROUP
065F:0 FMGROUP
Program entry point at 03A1:00C8

BIJLAGE C: Waar QuickBasic 4,00, 4.00b, en 4,50 slaan hun ARRAYS

Er is een verschil in de array-opslag tussen programma's uitvoeren, zoals gecompileerd. EXE-bestanden en programma's uitvoeren in de omgeving van QuickBasic versie 4.00, 4.00b en 4,50 (QB. EXE). In de QB. EXE-omgeving, een matrix die statisch is, is niet gemeen en niet bestaan uit tekenreeksen van variabele lengte, wordt opgeslagen in de heap ver (in plaats van DGROUP, zoals in. EXE-programma's).


Hiermee wijzigt u het geheugenbeheer in uw programma, afhankelijk van waar u het programma uitvoeren.


Dus in programma's die worden uitgevoerd binnen de omgeving QuickBasic 4,00, 4.00b of 4,50 (QB. EXE) matrices worden als volgt opgeslagen:


  1. Alle $STATIC arrays worden opgeslagen in DGROUP in algemene en met korte adressen kunnen worden verwezen.
  2. Alle matrices met tekenreeksen van variabele lengte worden ook opgeslagen in DGROUP en kunnen ook worden verwezen met korte adressen.
  3. Alle andere matrices worden als objecten opgeslagen, ver en ver-adressen vereisen. Dit omvat $STATIC arrays die niet in een gemeenschappelijke verklaring en deze arrays kunnen verplaatsen in het geheugen als matrices $DYNAMIC.
In QuickBasic 4,00, 4.00b en 4,50 programma's die worden uitgevoerd via gecompileerd. EXE-bestanden, matrices worden als volgt opgeslagen:


  1. Alle $STATIC arrays worden opgeslagen in DGROUP en met korte adressen kunnen worden verwezen.
  2. Alle $DYNAMIC matrices met tekenreeksen van variabele lengte worden ook opgeslagen in DGROUP en kunnen ook worden verwezen met korte adressen.
  3. Alle andere $DYNAMIC arrays worden opgeslagen als ver-objecten.

BIJLAGE D: GEHEUGEN KAARTEN

Deze bijlage bevat een algemeen geheugen kaart en drie gedetailleerde runtime-geheugen kaarten.

Algemene geheugen Diagram

In het volgende diagram bevat een overzicht van hoe QuickBasic gecompileerde programma's in het geheugen zijn geladen tijdens runtime:
          High Memory (640K maximum)
+-----------+
| | The far heap stores dynamic arrays. The far
| (Far) | heap consists of the rest of high memory
| Heap | available after MS-DOS and the Basic
| | program's DGROUP segment and code
--- +-----------+ segment(s) are allocated.

| | | The stack is used to store temporary data,
| | Stack | such as variables that are passed to a
DGROUP | | subprogram procedure. The default stack
Up to |- - - - - -| size is 2K.
64K | | The DGROUP (default data segment) is used
| | (Near) | to store all static arrays, strings,
| | Data | simple variables, and the stack. DGROUP
--- +-----------+ can be up to 64K in size.
:
+-----------+
| Code | The code segments store the executable code.
| Segments | Each module can have up to 64K for its
+-----------+ code segment.
Low Memory

De volgende figuren 1, 2 en 3 worden de rangschikking van code en gegevens in het geheugen tijdens de uitvoering nader beschreven.

Figuur 1

De eerste afbeelding (hieronder) ziet u de runtime-geheugen kaart wanneer het programma wordt uitgevoerd binnen de QB. EXE versie 4.x-omgeving:
                   +-------------+
| Quick |
| Library |
+-------------+
|Communication| User-specified size
| buffers |
+-------------+
| | This area contains items, such as
| FAR heap | large/huge arrays and user code,
| | dynamic arrays.
+-------------+

User Data ------->Run-time heap| Files buffers, etc.
End DS:xxxx +-------------+
| String heap |
+-------------+
| User Program|
DGROUP | Data |
+-------------+
UP to | User Stack |
64K +-------------+
| Quick Lib |
| Data |
+-------------+
| QuickBasic |
User Data | Static |
Start DS:0 ------->| Data |
+-------------+
| QuickBasic | QB.EXE
Low Memory ------->| Code |
+-------------+
| MS-DOS | MS-DOS Operating System
+-------------+
0000:0000 ------->

Afbeelding 1 (hierboven): de toewijzing van geheugen voor QB. EXE 4.x-omgeving

Figuur 2

Deze tweede afbeelding (hieronder) ziet u de runtime-geheugen kaart zoals deze wordt weergegeven wanneer de runtime-module BRUN4x.EXE wordt gebruikt met de methode afzonderlijke compilatie (EXE bestand maken...):
                   +-------------+
| BRUN4x.EXE | Separately loaded run-time code
+-------------+
|Communication| User-specified size
| buffers |
+-------------+
| | This area holds less-frequently-
| | used items, such as dynamic
| FAR heap | arrays, the user environment
| | table.
| |
| |
+-------------+
User Data ------->Run-time heap|
End DS:xxxx +-------------+
| String heap |
+-------------+
| User Stack | Preset to 2K
+-------------+
| Named | Named COMMON areas
| COMMON |
DGROUP +-------------+

| BC_DATA | User program variables
Up to +-------------+
64K | BC_CONST | User program constants
+-------------+
| Blank COMMON|
+-------------+
| _DATA | QuickBasic run-time data areas,
User Data | CONST | used during user code execution
Start DS:0 ------->| _BSS |
+-------------+
| User Code | User program separately linked
Low Memory ------->| | with BRUN4x.LIB
+-------------+
| MS-DOS | MS-DOS Operating System
+-------------+
0000:0000 ------->

Figuur 2 (boven): het geheugen BRUN4x.EXE runtime-Module voor een. EXE

Figuur 3

Deze derde afbeelding (hieronder) ziet u de runtime-geheugen kaart de optie standaard - alleen library (BCOM4x.LIB) wordt gebruikt in combinatie met de methode afzonderlijke compilatie (EXE bestand maken...):
                   +-------------+
|Communication| User specified size
| buffers |
+-------------+
| | This area contains less frequently
| | used items, such as large
| FAR heap | numeric arrays, the user
| | environment table, dynamic
| | arrays.
| |
+-------------+

User Data ------->|Run-time heap| Files, buffers, etc.
End DS:xxxx +-------------+
| String heap |
+-------------+
| User Stack | Preset to 2K bytes
+-------------+
| Named | Named COMMON areas
| COMMON |
DGROUP +-------------+
| BC_DATA | User program variables
Up to +-------------+
64K | BC_CONST | User program constants
+-------------+
| Blank COMMON| Library and user definitions
+-------------+
| _DATA | QuickBasic run-time data areas,

User Data | CONST | used during user code execution
Start DS:0 ------->| _BSS |
+-------------+
|Run-time code| Run-time code linked into file
+-------------+
| User Code | User program separately linked
Low Memory ------->| | with BCOM4x.LIB
+-------------+
| MS-DOS | MS-DOS Operating System
+-------------+
0000:0000 ------->

Figuur 3 (boven): de zelfstandige (BCOM4x.LIB-bibliotheek)-geheugen voor een. EXE
Eigenschappen

Artikel-id: 45850 - Laatst bijgewerkt: 14 feb. 2017 - Revisie: 1

Feedback