DLOUHÉ: Správa paměti v jazyk QuickBasic a Basic Compiler

Prohlášení o odmítnutí odpovědnosti pro už nepodporovaný obsah KB

Tento článek byl napsán pro produkty, ke kterým již Microsoft nadále nenabízí podporu. Článek je tedy poskytován „tak, jak je“ a nebude už nadále aktualizován.

Souhrn

Programátoři chtít pochopit, jak Microsoft QuickBasic a základní kompilátoru Microsoft uspořádat paměti k zápisu programy, které usnadňují efektivní využívání systémových prostředků. Jazyk QuickBasic jazyk obsahuje různé datové typy a konstrukce kódu modulů, které umožňují spravovat data a kód aplikace.

Další informace

Tento článek obsahuje následující témata:


  1. Kód řízení


    1. Modulární programování
    2. Co přejde na úrovni modulu v modulu podpory
    3. SPOLEČNÝ SPOLEČNÝ SDÍLENÉ, SDÍLENÉ, DIM SDÍLENÉ
  2. Správa dat


    1. $DYNAMIC a $STATIC metacommands
    2. Velmi velké matice
Dodatek A obsahuje příklad kódu, který ilustrují témata v tomto článku.


Dodatek B: vysvětluje,. MAPOVAT soubor vytvořený v příkladu program dodatku A propojen. ODKAZ mapy můžete použít k určení, jak blízko každý modul se blíží limit 64 kB kódu a jak zavřít. EXE program statické proměnné jsou stále limit 64 kB v DGROUP.


Dodatky, C a D jsou popsány podrobně mapování paměti pro spuštění programů v následujících třech různých prostředích: QB. EXE editor kompilované. EXE program používá modul runtime a. EXE kompilována s možnost samostatné.

Definice

"Modul" je definován jako soubor jednotlivých zdroj obsahující základní postupy.


"Úroveň modulu kód" je definován jako příkazy uvnitř modulu, které nespadají do procedury SUB... END SUB, FUNKCE... END FUNCTION nebo DEF FN... ÚČELEM DEF definice bloku.


"Podpora modulu" je zdrojový soubor, oddělené od hlavní modul, který obsahuje další procedury SUB nebo FUNCTION.

KÓD ŘÍZENÍ

Modulární programování

Modulární programování se zabývá programy rozdělení do samostatných modulů (tj, samostatných zdrojových souborech obsahující procedury SUB nebo FUNCTION). Důvody pro to jsou následující:


  1. Jednou napsané blok kódu jako modul, lze jej snadno začlenit do budoucích projektů.
  2. Je snadnější ladění. Problémy mohou být umístěny mnohem rychleji a mohou být obsaženy v určité oblasti programu.
  3. Kompilátoru (BC. (EXE) a prostředí (QB. (EXE) mají kód omezení 64 kB na jeden modul. Modulární styl programování umožňuje vytvořit programy větší než 64 kB od každého modulu, přestože je součástí jeden program, může být až 64 kB.
Program je velký, může být nutné rozdělit do několika modulů. To lze snadno provést procedury SUB nebo funkce z modulu hlavní a jejich uvedení v modulech podporu. Tyto moduly jsou potom samostatně kompilována s BC. EXE a propojené s hlavní modul, jak ukazuje následující příklad.


Zvažte program, Main.BAS, která je rozdělena do tří modulů:


  1. HLAVNÍ. BAS (který volá externí procedury)
  2. MODULE2. BAS (který obsahuje procedury SUB nebo funkce)
  3. MODULE3. BAS (který obsahuje procedury SUB nebo funkce)
Tři moduly jsou pak každý kompilován samostatně vytvářejí soubory následující objekt:


  1. HLAVNÍ BC. BAS; HLAVNÍ--->. OBJ
  2. BC MODULE2. BAS; ---> MODULE2. OBJ
  3. BC MODULE3. BAS; ---> MODULE3. OBJ
Chcete-li vytvořit spustitelný soubor (. Je používán program (EXE), na příkazovém řádku následující:
    LINK Main.OBJ+Module2.OBJ+Module3.OBJ; ---->  Main.EXE
Main.EXE je dokončené spustitelný program. Při sestavování prostředí jazyk QuickBasic's (QB. (EXE) prostředí automaticky kompiluje každý modul a jejich společně předložit stejné spojení. OBJ soubory a dokončené spustitelný program.


Chcete-li. EXE program QB. EXE prostředí, proveďte následující kroky:


  1. Zvolte v nabídce spuštění.
  2. Zvolte vytvořit EXE soubor... možnost.
  3. Zvolte možnost soubor EXE Stand-Alone vytvořit samostatný soubor. Pokud tato volba není vybraná, program vyžaduje modul runtime BRUN4x.EXE dispozici v době běhu.
  4. Stiskněte klávesu ENTER.
Jazyk QuickBasic prostředí poskytuje snadný způsob, jak provést následující operace, které jsou dále popsány níže:


  1. Vytvořte nový modul pro SUBs
  2. Upravit modulů a Nah
  3. Odstranit Nah
  4. Nahradi přesunout z jednoho modulu do jiného modulu
V QB. EXE, můžete vytvořit samostatný modul (zdrojový soubor) pro SUBs, postupujte takto:


  1. Zvolte nabídku soubor.
  2. Zvolte vytvořit soubor... možnost.
  3. Zadejte název modulu.
  4. Stiskněte klávesu ENTER.
Pak bude vytvořen soubor s názvem jste zadali, a bude v paměti s jinými moduly. Chcete-li uložit všechny načtené moduly, postupujte takto:


  1. Zvolte nabídku soubor.
  2. Zvolte možnost Uložit vše.
Moduly jsou uloženy společně, jazyk QuickBasic vytvoří soubor (s příponou. MAK) který uchovává informace o modulu hlavní a moduly, které jsou používány hlavní. Chcete-li načíst všechny moduly v najednou, postupujte takto:


  1. Zvolte nabídku soubor.
  2. Zvolte Otevřít Program... možnost.
  3. Hlavní modul programu vyberte soubor, který chcete otevřít.
Chcete-li zobrazit a vybrat Nah pro úpravy, postupujte takto:


  1. Zvolte nabídku zobrazit.
  2. Zvolit Nahradi... možnost.
  3. Zvýrazněte modul nebo SUB, který chcete upravit.
  4. Karta na úpravy v aktivním nebo upravit rozdělení.
  5. Stiskněte klávesu ENTER.
Chcete-li odstranit do procedury SUB, postupujte takto:


  1. Zvolte nabídku zobrazit.
  2. Zvolit Nahradi... možnost.
  3. SUB chcete odstranit zvýraznění.
  4. Kartě na možnost odstranit.
  5. Stiskněte klávesu ENTER.
Přesunout do procedury SUB jiného modulu, postupujte takto:


  1. Zvolte nabídku zobrazit.
  2. Zvolit NAHRADI... možnost.
  3. Zvýrazněte SUB, kterou chcete přesunout.
  4. Kartě na možnost přesunout.
  5. Stiskněte klávesu ENTER.
  6. Vyberte modul, který chcete SUB v.
  7. Stiskněte klávesu ENTER.
Další informace o použití QB. EXE prostředí, naleznete v příručce "Microsoft jazyk QuickBasic: Learning k použití" pro verze 4.50 nebo v příručce "Microsoft jazyk QuickBasic 4.0: studia a použití" pro verze 4.00 a 4.00b a Basic compiler verze 6.00 a 6.00b.

Co přejde na úrovni modulu v modulu podpory

Podpora modulu při kompilaci, vytvoří objekt (. OBJ) soubor, který je spojen s hlavní modul pro vytvoření spustitelného souboru. Úroveň modulu kódu modulu hlavní je pouze kód přímo spustit jazyk QuickBasic. Kód úroveň modulu podporu moduly nelze volané RUN a CHAINed. Tento kód úroveň modulu podporu moduly se používá pouze pro:


  1. Obslužné rutiny událostí nebo Chyba soutisku
  2. Metacommands
  3. Zadejte příkaz SDÍLENÉ definice DIM a společné
Můžete vložit událostí GOSUB ON a ON GOTO Chyba soutisku výkazy v rámci postupů podprogramem [kde ON událostí znamená ON KEY(n) ON COM(n), dále TIMER(n), atd.]. Musí být však na úroveň modulu kód v modulu stejné jako tímto podprogramem řádku nebo popisek řádku, který je cíl GOTO nebo GOSUB soutisku události nebo chyby. Je to proto, že jazyk QuickBasic neumožňuje GOSUBs nebo GOTOs z podprogramem pro ostatní moduly nebo podprogramy a jazyk QuickBasic umožňuje pouze událostí GOSUB ON GOTO chyba ON příkazy a přecházet z podprogramem úroveň modulu kódu.


Metacommands kompilátoru (REM $INCLUDE, REM $STATIC a REM $DYNAMIC) lze použít také na úrovni modulu. REM $INCLUDE vloží další zdroje do modulu v době kompilace. REM $DYNAMIC a REM $STATIC deklarovat následující pole jako $DYNAMIC (přiřazována v době běhu) nebo $STATIC (přiděleny v době kompilace).


Můžete použít typ... Typ ZAKONČENÍ, DIM a společné SDÍLENÉ příkazy v kód úroveň modulu. Proměnné a pole mohou být sdíleny mezi moduly pomocí SDÍLENÉ společné prohlášení na úrovni modulu.

SPOLEČNÝ společný SDÍLENÉ, SDÍLENÉ a DIM SDÍLENÉ

Příkaz SDÍLENÉ poskytuje SUB nebo FUNCTION postupu přístup k proměnné deklarované na úrovni modulu Hlavní modul (bez je předáte jako parametry). Neposkytuje přístup k proměnné deklarované v modulech podporu.


SPOLEČNÉ prohlášení k dispozici proměnné na úrovni modulu mezi moduly. Sdílení proměnných s podprogramy nebo funkce je vyžadován atribut SHARED společné prohlášení (tj, společné SDÍLENÉ). Seznam proměnných v společné a SDÍLET společné prohlášení musí odpovídat typu ve společné a společné SDÍLENÉ příkazy do každého modulu.


Při použití příkazu společného (nebo SDÍLENÉ společné), statické a dynamické pole jsou dimenzovány odlišně. SPOLEČNÉ statické pole musí být dimenzovány před společné prohlášení ve všech modulech s toto společné prohlášení. Dynamická pole společné musí být dimenzovány po společné prohlášení do hlavní modul a všechny moduly, podpora by neměla být dimenzovány.


Existují dva rozdíly mezi použitím příkazu SHARED a příkazu DIM SDÍLENÉ:


  1. Chcete-li zpřístupnit proměnnou tak, že všechny podprogramy v modulu, použijte DIM SDÍLENÉ na úrovni modulu.
  2. Proměnná na úrovni modulu sdílet s konkrétní podprogramem, umístěte v příkazu v podprogramem SDÍLENÉ proměnné. Příkaz SDÍLENÉ přejde přímo po první řádek podprogramem.

SPRÁVA DAT

$DYNAMIC a $STATIC pole

Výchozí nastavení pro uložení pole je $STATIC REM, který ukládá všechny matice v DGROUP (výchozí datový segment). Pro všechny základní. EXE program DGROUP je omezena na 64 kB. Pokud používáte statické pole, můžete získat více paměti DGROUP provedením matice dynamické, která přesune do zcela haldy. Chcete-li dynamické pole, po metacommand REM $DYNAMIC dimenze matice nebo dimenze matice s proměnnou v jeho dolní index.


Na vzdálenější haldy s výjimkou pole proměnné délky řetězců jsou uloženy všechny dynamická pole. Řetězce, řetězce proměnné délky pole a jednoduché proměnné jsou vždy uloženy v DGROUP. K uložení řetězců ve vzdálenější haldy, musí dimenze dynamické pole pevné délky řetězce. Měření jako v dynamická pole pevné délky řetězce pomáhá uvolnit úložný prostor, který jinak by vzali v DGROUP, který je omezen na 64 kB.

Velmi velké matice

Velké pole jsou pole, která jsou větší než 64 kB. Používáte-li velké pole, je nutné vyvolat QB. EXE editor a BC. EXE kompilátor /AH možnost. Velmi velké matice musí být dimenzovány jako dynamické pole s proměnnou v dolní index matice nebo s předchozím metacommand REM $DYNAMIC. /AH možnost umožňuje dynamické pole v uživatelem definované typy, pevné délky řetězce a číselné údaje použít všechny dostupné paměti.


Počet bajtů v jeden prvek velké pole by měl přednostně mocninou čísla 2, aby se zabránilo plýtvání paměti a chcete-li povolit pole být větší než 128 kb/s, jak je popsáno níže.


Je přiděleno místo pro velké pole souvisle v vzdálenější haldy, s tím omezením, že žádný prvek jednoho pole (nebo záznam) může být rozdělen na hranici 64 kB. Pokud velikost záznamu není mocninou čísla 2, pole je vytížena na dostatečně vysoké relativní adresu základní segmentu pole (vrácené funkcí VARSEG), posun tak, aby se žádný prvek pole rozdělit přes hranice na přesně 64 kB nad základní segment. Hodnota vrácená funkcí VARPTR prvního prvku matice pak znamená i posun pole a také velikost mezery vytvořené v vzdálenější haldy. Tato mezera fragmenty vzdálenější haldy a nepoužívané, nevyužité paměti. Velikost mezery je rovna (65536) MOD (velikost pole záznamu). [V nejhorším případě rozdíl může mít maximální délku (velikost pole záznamu) minus velikost 1.]


"Dolní index mimo rozsah" chyba nastane při přidělování velké matice, která je větší než 128 kb, pokud prvky pole mají velikost, která není sudou mocninou čísla 2. Pole větší než 128 kb / s, musí mít element velikost, která je násobkem 2 (2, 4, 8, 16, 32, 64, atd.), protože pole jsou uloženy souvisle a žádný prvek jednoho pole je povoleno rozdělit přes hranice 64 kB.


Konečný aspekt hlavní jazyk QuickBasic Správa paměti je, že jazyk QuickBasic pokusu o efektivní využití paměti, což může způsobit proměnnou délkou řetězce, řetězce proměnné délky pole a dynamická pole Pohyb v paměti údajů z prohlášení v době běhu. (Ostatní proměnné jsou pevné umístění určuje v okamžiku načtení EXE.) Navíc pokud provádíte výpis ŘETĚZCE, pak žádná data předaná v běžné bloku se může pohybovat. To znamená, že výsledky VARPTR VARSEG, VARPTR$ nebo funkce SADD by se měl ihned po, že je vyvolána funkce.

DODATEK A: UKÁZKOVÝ PROGRAM

Tento ukázkový program demonstruje témata v tomto článku. Tento program poskytuje příklad způsoby dimenze matice a předávání proměnných mezi moduly a podprogramy. Program sestává ze dvou modulů, každý, který definuje jeden podprogramem.

Hlavní modul (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

Podpora modulu (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

DODATEK B: PROPOJENÍ. VYSVĚTLENÍ SOUBOR MAPY

Dále je. Soubor MAPY vytvořené v příkladu program v dodatku A propojen. Na. Soubor MAPY z úspěšného spojení ukazuje, jak blízko se blíží limit 64 kB kód segment kódu modulu a jak zavřít statické proměnné pro celý. EXE program se blíží limit 64 kB v DGROUP. Generovat mapu výpis programu, patří název souboru mapy ve třetím argumentu příkazu propojení, jako v následujícím příkladu:
   LINK EXAMPL1.OBJ+EXAMPL2.OBJ,,EXAMPLE.MAP;
Poznámky pro propojení. Zobrazí další MAPY níže jsou takto:


  1. EXAMPL1_CODE je segment kódu pro EXAMPL1. BAS.
  2. EXAMPL2_CODE je segment kódu pro EXAMPL2. BAS.
  3. Segment kódu každého modulu, musí být menší než 64 kB. Pokud kód segmentu dostává téměř 64 kB, rozdělte na dva nebo více modulů modulu. Délka segmentu kódu, hledejte ve sloupci délka. Například délka segmentu kódu pro EXAMPL1. BAS je šestnáctkově 15A, což je 346 v desítkovém zápisu.
  4. FAR_MSG je daleko řídicí skupiny, který obsahuje text chybové zprávy. Toto není zcela haldy. Vzdálenější haldy je přidělen v době běhu.
  5. Podle části původ v dolní části odkaz Mapa začíná DGROUP 06DC:0, což je odstavce adresu 06DC hex s posunem 0. To je stejné jako šestnáctkový bajt adresy 06DC0 (protože odstavec obsahuje 16 bajtů). Proto v tomto příkladu DGROUP spustí kde začíná BR_DATA.
  6. DGROUP končí na adrese Stop zásobníku.
  7. Chcete-li zjistit, jak velké jsou programu DGROUP, převzít adresu Stop zásobníku a z ní odečíst počáteční adresa první prvek dat DGROUP. Například velikost DGROUP programu je hex 7F9F minus hex 6DC0, což se rovná 11DF (4575) šestnáctkově.
  8. Všechny adresy v. MAPY jsou pouze relativně k začátku. EXE program. DOS je určena adresa absolutní zatížení pouze v době běhu. VARSEG a VARPTR příkazy lze použít v programu v době běhu zobrazit absolutní adresy proměnných.

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

Dodatek C: Pokud jazyk QuickBasic 4.00, 4.00b, a jejich pole uložit 4.50

Existuje jeden rozdíl v poli úložiště spustit kompilované programy. EXE soubory a programy spustit v prostředí jazyk QuickBasic verze 4.00, 4.00b a 4.50 (QB. (EXE). V QB. EXE prostředí, která je statická, není v běžných a ne se skládá z řetězce proměnné délky pole jsou uloženy v vzdálenější haldy (namísto DGROUP, jako v. EXE programy).


Změní se správa paměti v programu, podle toho, kde spustit program.


Tedy programy spustit v prostředí jazyk QuickBasic 4.00, 4.00b nebo 4.50 (QB. (EXE), pole jsou uloženy následovně:


  1. SPOLEČNÉ $STATIC matic jsou uloženy v DGROUP a lze odkazovat pomocí blízké adres.
  2. Všechna pole proměnné délky řetězců jsou uloženy v DGROUP a lze také označit blízké adres.
  3. Všechna ostatní pole jsou uloženy jako objekty vzdálenější a vyžadují daleko adresy. Jedná se o $STATIC matic, které nejsou ve SPOLEČNÉM prohlášení a tato pole můžete přesunout v paměti jako pole $DYNAMIC.
V jazyk QuickBasic 4.00, 4.00b a 4.50 programy, které jsou spuštěny v režimu kompilován. EXE soubory, pole jsou uloženy následovně:


  1. Všechny matice $STATIC jsou uloženy v DGROUP a lze odkazovat pomocí blízké adres.
  2. Všechny $DYNAMIC pole proměnné délky řetězců jsou uloženy v DGROUP a lze také označit blízké adres.
  3. Jiná $DYNAMIC pole jsou uloženy jako objekty vzdálenější.

DODATEK D: MAPOVÁNÍ PAMĚTI

Tento dodatek obsahuje jednu mapu v hlavní paměti a tři mapy podrobná běhu paměť.

Diagram obecné paměti

Následující obrázek shrnuje, jak jazyk QuickBasic zkompilován programy jsou načteny do paměti za běhu:
          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

Na následujících obrázcích 1, 2 a 3 podrobněji popisují uspořádání kódu a dat v paměti za běhu.

Obrázek 1

První obrázek (níže) ukazuje mapování paměti v době spuštění při spuštění programu v QB. EXE verze 4.x prostředí:
                   +-------------+
| 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 ------->

Obrázek 1 (nahoře): mapování paměti pro QB. EXE 4.x prostředí

Obrázek 2

Mapování paměti v době spuštění tento druhý obrázek (níže) ukazuje, jak se zobrazí po spuštění modulu BRUN4x.EXE se používá pro metodu samostatné kompilace (vytvořit EXE soubor...):
                   +-------------+
| 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 ------->

Obrázek 2 (výše): BRUN4x.EXE paměť modulu Run-Time. EXE

Obrázek 3

Tento třetí obrázek (níže) ukazuje mapování paměti v době spuštění při použití možnosti samotné knihovny (BCOM4x.LIB) - stojan s metodou samostatné kompilace (vytvořit EXE soubor...):
                   +-------------+
|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 ------->

Obrázek 3 (výše): samostatné (BCOM4x.LIB knihovna) paměti pro. EXE
Vlastnosti

ID článku: 45850 - Poslední kontrola: 16. 1. 2017 - Revize: 1

Váš názor