ДЪЛГО: Управление на паметта в QuickBasic и основните компилатор

Отказ от отговорност за оттеглено съдържание на БЗ

Тази статия е написана за продукти, за които Microsoft вече не предлага поддръжка. Ето защо тази статия се предлага „както е“ и вече няма да бъде актуализирана.

Резюме

Програма може да искате да разберете как Microsoft QuickBasic и Microsoft Basic компилатор организира памет, за да пишат програми, които правят ефективно използване на системни ресурси. QuickBasic език предоставя различни типове данни и код на модулен изгражда, които ви позволяват да управлявате данни и код на програмите.

Допълнителна информация

Тази статия включва следните теми:


  1. Управление на код


    1. Модул
    2. Какво е нивото на модул модул за поддръжка
    3. ОБЩИ ОБЩИ СПОДЕЛЕНИ, СПОДЕЛЕНА, СЛАБО СПОДЕЛЕНИ
  2. Управление на данни


    1. $DYNAMIC и $STATIC metacommands
    2. Големи масиви
Приложение А съдържа код пример илюстрира темите, включени в тази статия.


Приложение Б обяснява. КАРТА на файл, създаден при приложение А примера е свързан. Можете да използвате ВРЪЗКАТА карта за определяне как близо всеки модул е наближава ограничението 64K код и как. EXE програмата статични променливи стават 64K ограничението в d група.


Приложения В и Г описва подробно съответствието памет за изпълнение на програми в следните три различни среди: QB. EXE редактор, компилиран. EXE програма с помощта на модула средата и. EXE компилирани самостоятелен опция.

Дефиниции

"Модул" се определя като отделна източник файл, съдържащ основни процедури.


"Код на ниво на модул" се определя като изреченията в модула, които са извън под... END SUB, ФУНКЦИЯ... КРАЕН функция или DEF FN... КРАЕН DEF definition блок.


"Поддръжка на модул" е файла източник, отделно от основния модул, която съдържа допълнителни процедури за SUB или функция.

УПРАВЛЕНИЕ НА КОД

Модул

Модул се занимава с разделяне на програми в отделни модули (т.е. източник на отделни файлове, съдържащи SUB или функция). Причините за това са следните:


  1. След като сте написали блок като модул, тя лесно може да се включи в бъдещи проекти.
  2. Отстраняване на грешки е по-лесно. Проблеми могат да бъдат намерени много по-бързо и може да се съдържат в конкретна програма.
  3. Компилатор (BC. EXE) и околната среда (QB. EXE) 64 K код ограничение на модул. Модулен стил на програмиране ви позволява да създадете програми по-големи от 64K, тъй като всеки модул, въпреки че е част от една програма, може да бъде до 64K по размер.
Ако дадена програма е голям, е необходимо да се раздели на няколко модула. Това се постига лесно разбиване SUB или функция процедури от основния модул и поставянето им в модули за поддръжка. Тези модули тогава се събират отделно с BC. EXE и свързани с основния модул като в следния пример.


Помислете за програма Main.BAS, който е разделен на три модула:


  1. ОСНОВНИ. BAS (което изисква външни процедури)
  2. MODULE2. BAS (която съдържа процедури за под и/или функция)
  3. РАЗПОРЕДБИТЕ НА МОДУЛ 3. BAS (която съдържа процедури за под и/или функция)
Модула са всеки компилирани отделно да създаде обект следните файлове:


  1. ОСНОВНИ BC. BAS; ---> Основни. OBJ
  2. BC MODULE2. BAS; ---> MODULE2. OBJ
  3. BC РАЗПОРЕДБИТЕ НА МОДУЛ 3. BAS; ---> Разпоредбите на модул 3. OBJ
Да изпълним файл (. Използва се EXE) програма, следния команден ред:
    LINK Main.OBJ+Module2.OBJ+Module3.OBJ; ---->  Main.EXE
Main.EXE е завършен изпълним програмата. При събиране на QuickBasic среда (QB. EXE), автоматично създава всеки модул и ги заедно, за да се генерират връзки. OBJ файлове и завърши изпълним програмата.


За да направите. EXE програма от QB. EXE среда, направете следното:


  1. Изберете менюто.
  2. Изберете направи EXE файл... опция.
  3. Изберете опцията за самостоятелната EXE файл за създаване на самостоятелен файл. Ако тази опция не е избрана, програмата изисква модул BRUN4x.EXE средата да присъства по време на изпълнение.
  4. Натиснете клавиша ENTER.
QuickBasic среда ви предоставя лесен начин да направите следните операции, които са както следва:


  1. Създаване на нов модул за наблюдение
  2. Редактиране на филми и модули
  3. Изтриване на филми
  4. Преместване на филми от един модул в друг модул
В QB. EXE, за да създадете отделен модул (източник файл) за филми, направете следното:


  1. Изберете менюто файл.
  2. Изберете създаване на файл... опция.
  3. Въведете името на модула.
  4. Натиснете клавиша ENTER.
След това ще бъде създаден файл с име сте посочили, и ще бъде в паметта с останали. За да запишете всички заредени модули, направете следното:


  1. Изберете менюто файл.
  2. Изберете опцията Запиши всички.
Когато модулите са записани заедно, QuickBasic се създава файл (с разширение. MAK), която следи на основния модул и други модули, които се използват от основния. За да заредите всички модули в наведнъж, направете следното:


  1. Изберете менюто файл.
  2. Изберете програмата Open... опция.
  3. Изберете основния модул на програмата като файлът да бъде отворен.
За да прегледате и изберете филми за редактиране, направете следното:


  1. Изберете менюто Изглед.
  2. Изберете филми... опция.
  3. Осветете модул или ред, който искате да редактирате.
  4. TAB до редактиране в активен или редактирате в раздели.
  5. Натиснете клавиша ENTER.
За да изтриете ред, направете следното:


  1. Изберете менюто Изглед.
  2. Изберете филми... опция.
  3. Осветете ред, който искате да изтриете.
  4. Раздел до опцията за изтриване.
  5. Натиснете клавиша ENTER.
За да преместите под друг модул, направете следното:


  1. Изберете менюто Изглед.
  2. Изберете филми... опция.
  3. Осветете ред, който искате да преместите.
  4. Раздел до опцията за преместване.
  5. Натиснете клавиша ENTER.
  6. Изберете искате под в модула.
  7. Натиснете клавиша ENTER.
За повече информация относно използването на QB. EXE среда, моля вижте ръководство за версия 4.50 на "Microsoft QuickBasic: обучение за употреба", или "Microsoft QuickBasic 4.0: обучение и използване на" ръководството за 4.00 и 4.00b и основните компилатор версия 6.00 и 6.00b.

Какво е нивото на модул модул за поддръжка

Поддръжка на модул, когато събира, произвежда обект (. OBJ) файл, който е свързан с основния модул, за да създадете изпълним файл. Ниво на модула кодът на основния модул, е само извършва директно от QuickBasic. Код на ниво на модула модули поддръжка не може да бъде наречен, изпълнение или CHAINed. Този модул ниво код поддръжка модули се използва само за:


  1. Манипулатори на събитие или грешка улавяне
  2. Metacommands
  3. Въведете дефиниции, СЛАБО и общи СПОДЕЛЕНИ отчети
Можете да поставите на събитие GOSUB и отидете на грешка улавяне на отчети в SUBprogram процедури [където на събитието означава, н KEY(n), н COM(n), н TIMER(n) и др.]. Обаче линия или етикет, който е обект на събитие или грешка прихващане преход или GOSUB трябва да бъде модул ниво код в модула същото като това SUBprogram. Това е така, защото QuickBasic не позволява GOSUBs или GOTOs от SUBprogram други модули или SUBprograms и QuickBasic позволява само на събитие GOSUB и отидете на грешка отчети направо от SUBprogram код модул ниво.


Metacommands компилатор (REM $INCLUDE REM $STATIC и REM $DYNAMIC) може да се използва на ниво модул. REM $INCLUDE поставя допълнителен код в модула по време на компилация. REM $DYNAMIC и REM $STATIC обяви следващи масиви $DYNAMIC (разпределени по време на изпълнение) или $STATIC (разпределени по време на компилация).


Можете да използвате тип... КРАЕН тип, СЛАБО и общи СПОДЕЛЕНИ отчети в модула ниво код. Променливи и масиви могат да се споделят между модулите използва отчета обща СПОДЕЛЕНА на ниво модул.

ОБЩИ общи СПОДЕЛЕНИ СПОДЕЛЕНИ и СЛАБО СПОДЕЛЕНИ

ОБЩА декларация дава SUB или функция процедура достъп до променливи обявени на основния модул ниво на този модул (без да ги преминават като параметри). Тя не дават достъп до променливи обявени в модули за поддръжка.


ОБЩА декларация предоставя променливи на модул ниво между модули. ОБЩО атрибут за обща декларация (т.е. обща СПОДЕЛЕНА) е необходимо да споделите променливите с SUBprograms или функции. Списъкът на променливите в общи и общите СПОДЕЛЕНИ отчети трябва да съвпадат тип обща и общи СПОДЕЛЕНИ отчети всеки модул.


При използване на отчета за общия (или общи СПОДЕЛЕНИ), статични и динамични масиви са разпределени по различен начин. Статичен масиви общо се размери преди общата декларация във всички модули с тази обща декларация. Динамични масиви общо трябва да бъде размери след общата декларация само основните модул и не трябва да бъде размери във всички модули за поддръжка.


Има две разлики между използването на отчета за общо и СЛАБО СПОДЕЛЕНИ декларация:


  1. За да променлива достъпна от всички SUBprograms модул, използвайте DIM СПОДЕЛЕНИ на ниво модул.
  2. За споделяне на ниво модул променлива с определен SUBprogram, поставете променливата в общо изявление в SUBprogram. Декларация за общо отива веднага след първия ред на SUBprogram.

УПРАВЛЕНИЕ НА ДАННИ

$DYNAMIC и $STATIC масиви

По подразбиране за съхранение масиви е REM $STATIC, който съхранява всички масиви в d група (сегмент за данни по подразбиране). За всеки основен. EXE програмата, d група е ограничен до 64K. Ако използвате статични масиви, можете да получите повече памет в d група чрез масиви динамични, които се премества в момента куп. Да масив динамични измерение масив след metacommand REM $DYNAMIC или измерение масив променлива в своите думи.


Всички динамични масиви се съхраняват в момента куп освен масиви низове с променлива дължина. Низове, низ променлива дължина масиви и просто променливи винаги се съхраняват в d група. За съхраняване на низове в момента куп, трябва да измерение динамичен набор от низове на фиксирана дължина. Оразмеряване низове като фиксирана дължина в динамични масиви помага да освободите място, те могат да взели в d група, който е ограничен до 64K.

Големи масиви

Големи масиви са масиви, които са по-големи от 64K. При използване на големи масиви, трябва да извикате QB. Редактор на EXE и BC. EXE компилатор /AH опция. Много трябва да се измери като динамичен набор, с променлива в масива горен или предходната metacommand REM $DYNAMIC. Опцията /AH позволява динамични масиви на потребителски видове низове с фиксирана дължина и числови данни да заемат всички памет.


Брой байтове в един елемент от огромно предпочитане трябва да бъде силата на 2, за да избегнете паметта и да разрешите масиви са по-големи от 128 K, както е описано по-долу.


За огромно последователно в момента куп, с ограничението, че няма един масив елемент (или запис) може да се раздели в 64K граница се отдели пространство. Ако запис не е мощност от 2, масив ресурси на изместване достатъчно висока, по отношение на масива база сегмент адрес (върнати от функцията VARSEG), така че няма елемент на масив се разделят през границата в точно 64 K над база сегмент. Стойност, върната от функцията VARPTR за първия елемент на масива от показва както offset на масива, а също и размера на разликата, създадени в момента свободна. Тази разлика фрагменти крайно динамичната памет и се губи, неизползваните памет. Размерът на пространството е равен на (65,536) MOD (масив запис размер). [В най-лошия, разликата може да бъде до (запис размера на масива) минус 1 размер.]


"Долен индекс извън обхвата" грешка при разпределяне на огромно над 128 K, ако елементите са с размер, който не е дори силата на 2. По-големи от 128K трябва да имат размер на елемент, който е мощност от 2 масиви (2, 4, 8, 16, 32, 64, и т.н.), тъй като масиви се съхраняват последователно и няма един масив елемент може да се раздели в 64K граница.


Основен елемент на QuickBasic управление на паметта е, че QuickBasic се опитва да направи ефективно използване на памет, която може да доведе до променлива дължина низове, низ променлива дължина масиви и динамични масиви да се придвижват в паметта от отчет за отчет по време на изпълнение. (Други променливи имат фиксирано местоположение определя времето за зареждане на EXE). Освен това ако изпълнявате верига отчет, всички данни в общ блок да преместете. Това означава, че резултатите от VARPTR, VARSEG, VARPTR$ или SADD функция трябва винаги се използва веднага след позоваване на функция.

ПРИЛОЖЕНИЕ A: ПРИМЕРЕН ПРОГРАМА

Тази програма пример показва темите, включени в тази статия. Тази програма дава пример за начина на измерение масиви и да се споделят променливи между модули и SUBprograms. Програмата се състои от два модула, които определя една SUBprogram.

Главен модул (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

Модул за поддръжка (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

ДОПЪЛНЕНИЕ Б: ВРЪЗКА. ОБЯСНЕНИЕ НА КАРТАТА ФАЙЛ

По-долу е. КАРТА на файл, създаден при примера в приложение А е свързан. . КАРТА файл от успешна връзка показва колко близо модул код сегмент наближава ограничението 64K код и как да затворите статични променливи за целия. EXE програма трябва да наближава 64K ограничение в d група. За генериране на карта списък на програма, включва име на картата в третия аргумент на командата хипервръзка, както в следния пример:
   LINK EXAMPL1.OBJ+EXAMPL2.OBJ,,EXAMPLE.MAP;
Бележки за връзката. Картата показва още по-долу са както следва:


  1. EXAMPL1_CODE е сегмент код за EXAMPL1. BAS.
  2. EXAMPL2_CODE е сегмент код за EXAMPL2. BAS.
  3. Код на сегмента на всеки модул трябва да бъде по-малко от 64K. Когато код сегмент става близо 64 K, разделите модул на две или повече модули. За да намерите дължината на сегмента код, потърсете под колоната дължина. Например дължината на код за EXAMPL1. BAS е 15 а hex байта, което е 346 в десетичен формат.
  4. FAR_MSG е много управление група, която съдържа текста на съобщения за грешки. Това не е много свободна. Крайно динамичната памет се заделя по време на изпълнение.
  5. По секцията произход в дъното на картата връзка d група започва 06DC:0, което е абзац адрес 06DC hex, с изместване на 0. Това е същото като байт адрес 06DC0 hex (тъй като абзац съдържа 16 байта). Така в този пример d група започва, когато BR_DATA започва.
  6. D група завършва стоп адреса на СТЕКА.
  7. За да разберете колко голям е d група на програмата, да спре адреса на стека и изважда от него начален адрес на първия елемент на данни в d група. Например размерът на d група на програмата е 7F9F hex минус 6DC0 hex, равен 11DF hex байта (4575).
  8. Всички адреси в. КАРТА са само по отношение на началото на. EXE програма. Абсолютен натоварване адрес се определя от DOS само по време на изпълнение. VARSEG и VARPTR отчети може да се използва в програмата по време на изпълнение за показване на абсолютната адресите на променливите.

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

ПРИЛОЖЕНИЕ C: Където QuickBasic 4.00, 4.00b, и 4,50 СЪХРАНЯВАТ СВОИТЕ МАСИВИ

Има една разлика в масива за съхранение между изпълнение, определени програми. EXE файлове и програми се изпълняват QuickBasic версии 4,00 4.00b и 4,50 среда (QB. EXE). В QB. EXE среда, масив, който е статичен, не общи а не се състои от променлива дължина на низа, се съхранява в момента куп (вместо d група, както и в. EXE програми).


Това променя управление на паметта в програмата, в зависимост от това, когато стартирате програмата.


По този начин в програми се изпълняват в средата на QuickBasic 4.00, 4.00b или 4.50 (QB. EXE), масиви са разположени както следва:


  1. Всички $STATIC масиви общо се съхраняват в d група и може да се използва с почти адреси.
  2. Всички масиви от низове с променлива дължина също се съхраняват в d група и може да бъде посочен с почти адреси.
  3. Всички други масиви се съхраняват като много обекти и изискват много адреси. Това включва $STATIC масиви, които не са в обща декларация и да преместите тези масиви в паметта като $DYNAMIC масиви.
В QuickBasic 4,00 4.00b и 4,50 програми, които се изпълняват, определени. EXE, масиви файлове се както следва:


  1. Всички $STATIC масиви се съхраняват в d група и може да се използва с почти адреси.
  2. Всички $DYNAMIC масиви от низове с променлива дължина също се съхраняват в d група и може да бъде посочен с почти адреси.
  3. Всички други $DYNAMIC масиви се съхраняват като много обекти.

ПРИЛОЖЕНИЕ D: КАРТИ ЗА ПАМЕТ

Това приложение съдържа една обща памет карта и три подробни средата памет карти.

Обща памет диаграма

Диаграмата по-долу обобщава как QuickBasic компилирани програми са заредени в паметта по време на изпълнение:
          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

Следните фигури 1, 2 и 3 опишете по-подробно подредбата на код и данни в паметта по време на изпълнение.

Фигура 1

Първата цифра (по-долу) показва средата памет карта, когато програмата се изпълнява в QB. EXE версия 4.x среда:
                   +-------------+
| 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 ------->

Фигура 1 (по-горе): карта с памет за QB. EXE 4.x среда

Фигура 2

Тази втората стойност (по-долу) показва средата памет карта подредбата когато средата модул BRUN4x.EXE се използва с метода на отделни компилация (направи EXE файл...):
                   +-------------+
| 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 ------->

Фигура 2 (по-горе): BRUN4x.EXE средата модула памет за. EXE

Фигура 3

Тази трета фигура (по-долу) показва средата памет карта, когато самостоятелни сам библиотека (BCOM4x.LIB) опция се използва с метода на отделни компилация (направи EXE файл...):
                   +-------------+
|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 ------->

Фигура 3 (по-горе): самостоятелни (BCOM4x.LIB библиотека) памет за. EXE
Свойства

ИД на статията: 45850 – Последен преглед: 16.01.2017 г. – Редакция: 1

Обратна връзка