LARGA: Administración de memoria en QuickBasic & Basic Compiler

IMPORTANTE: Este artículo ha sido traducido por un software de traducción automática de Microsoft (http://support.microsoft.com/gp/mtdetails) en lugar de un traductor humano. Microsoft le ofrece artículos traducidos por un traductor humano y artículos traducidos automáticamente para que tenga acceso en su propio idioma a todos los artículos de nuestra base de conocimientos (Knowledge Base). Sin embargo, los artículos traducidos automáticamente pueden contener errores en el vocabulario, la sintaxis o la gramática, como los que un extranjero podría cometer al hablar el idioma. Microsoft no se hace responsable de cualquier imprecisión, error o daño ocasionado por una mala traducción del contenido o como consecuencia de su utilización por nuestros clientes. Microsoft suele actualizar el software de traducción frecuentemente.

Haga clic aquí para ver el artículo original (en inglés): 45850
Renuncia a responsabilidad de los contenidos de la KB sobre productos a los que ya no se ofrece asistencia alguna
El presente artículo se escribió para productos para los que Microsoft ya no ofrece soporte técnico. Por tanto, el presente artículo se ofrece "tal cual" y no será actualizado.
Resumen
Los programadores que desee comprender cómo Microsoft QuickBasic y el compilador de MicrosoftBasic organicen la memoria con el fin de escribir programas que makeefficient el uso de recursos del sistema. El lenguaje QuickBasic proporciona una variedad de tipos de datos y construcciones de código modular que permiten administrarel conjunto datos y código de sus programas.
Más información
En este artículo se trata los siguientes temas:

  1. Administración de código

    1. Programación modular
    2. Lo que sucede en el nivel de módulo en un módulo de soporte
    3. COMÚN, COMÚN COMPARTIDO, COMPARTIDO, DIM COMPARTIDA
  2. Administración de datos

    1. Metacommands $DYNAMIC y $STATIC
    2. Grandes arreglos
Apéndice A contiene un ejemplo de código para ilustrar los temas tratados en trate.

Apéndice B explica la. ASIGNAR el archivo creado cuando se vincula el programexample Apéndice A. Puede utilizar el mapa del vínculo para determinar la distancia eachmodule es alcanzando el límite de 64K código y cómo cerrar la. Variables estáticas del EXEprogram están obteniendo el límite de 64K en la DGROUP.

Los apéndices C y D describen en detalle la asignación de memoria para runningprograms en los siguientes tres entornos diferentes: el QB. Editor de EXE, un compilado. Programa EXE utilizando el módulo de tiempo de ejecución y una. EXE compiledwith la opción independiente.

Definiciones

Un "módulo" se define como un archivo de código fuente individuales que contiene Basicprocedures.

"Código de nivel de módulo" se define como las instrucciones dentro de un módulo que areoutside SUB... END SUB, FUNCIÓN... END FUNCTION, o DEF FN... Bloque de DEFdefinition END.

Un "módulo de apoyo" es un archivo de origen, separado del módulo principal, thatcontains otros procedimientos SUB o FUNCTION.

ADMINISTRACIÓN DE CÓDIGO

Programación modular

Programación modular se ocupa de la división de programas en módulos independientes (es decir, los archivos fuente independiente que contiene procedimientos SUB o FUNCTION). Thereasons para hacerlo son los siguientes:

  1. Una vez que haya escrito un bloque de código como un módulo, que fácilmente se puede incorporar a futuros proyectos.
  2. La depuración es más fácil. Problemas pueden encontrarse mucho más rápidamente y pueden estar contenidos en un área específica del programa.
  3. El compilador (BC. (EXE) y el medio ambiente (QB. (EXE) tienen una limitación de código de 64 K por módulo. Un estilo de programación modular permite crear programas mayor que 64 KB, desde cada módulo, aunque sea parte de un programa, puede ser de hasta 64 KB de tamaño.
Si un programa es grande, puede ser necesario dividirla en severalmodules. Esto se consigue fácilmente rompiendo SUB o FUNCTION proceduresout del módulo principal y colocarlos en los módulos de compatibilidad. Estos modulesare, a continuación, se compila por separado con BC. EXE y vinculado con el asin módulo principal en el siguiente ejemplo.

Considere un programa Main.BAS, que se divide en tres módulos:

  1. PRINCIPAL. BAS (que llama a un procedimiento externo)
  2. MODULE2. BAS (que contiene procedimientos SUB o función)
  3. MODULE3. BAS (que contiene procedimientos SUB o función)
Los tres módulos son, a continuación, se compilan por separado para producir archivos de objeto siguientes:

  1. CONTINUIDAD DEL NEGOCIO PRINCIPAL. BAS; ---> PRINCIPAL. OBJ
  2. MODULE2 BC. BAS; ---> MODULE2. OBJ
  3. MODULE3 BC. BAS; ---> MODULE3. OBJ
Para generar el archivo ejecutable (. Programa (EXE), el siguiente lineis comando utilizado:
    LINK Main.OBJ+Module2.OBJ+Module3.OBJ; ---->  Main.EXE				
Main.EXE es el programa ejecutable terminado. Cuando se compila entorno del inQuickBasic (QB. (EXE), el entorno automáticamente compileseach módulo y las vincula entre sí para producir el mismo. Programa ejecutable de OBJ archivos andfinished.

Para hacer una. Exe incluido en el QB. Entorno de EXE, haga lo siguiente:

  1. Elija el menú Ejecutar.
  2. Elija el archivo EXE que... opción.
  3. Elija la opción archivo de EXE independiente para crear un archivo independiente. Si no se selecciona esta opción, el programa requiere que el módulo de tiempo de ejecución de BRUN4x.EXE en tiempo de ejecución.
  4. Presione la tecla ENTRAR.
El entorno de QuickBasic le ofrece una manera fácil de hacer el followingoperations, que se describen más adelante:

  1. Cree un nuevo módulo de SUBs
  2. Editar subrutinas y módulos
  3. Eliminar SUBs
  4. Mover SUBs de un módulo a otro módulo
En QB. EXE para crear un módulo independiente (archivo de código fuente) para las subrutinas, para ello:

  1. Elija el menú archivo.
  2. Elija el archivo crear... opción.
  3. Escriba el nombre del módulo.
  4. Presione la tecla ENTRAR.
A continuación, se creará un archivo con el nombre especificado y será inmemory con los otros módulos. Para guardar todos los módulos cargados, haga lo siguientes:

  1. Elija el menú archivo.
  2. Elija la opción Guardar todo.
Cuando los módulos se guardan juntos, QuickBasic crea un archivo (con theextension. MAK) que realiza un seguimiento del módulo principal y el otro modulesthat se utilizan por el principal. Para cargar todos los módulos de una sola vez, haga lo siguientes:

  1. Elija el menú archivo.
  2. Elija el programa abierto... opción.
  3. Seleccione el módulo principal del programa como el archivo que desea abrir.
Para ver y seleccionar SUBs para modificarlo, haga lo siguiente:

  1. Elija el menú Ver.
  2. Elija las subrutinas... opción.
  3. Resalte el módulo o SUB que desea editar.
  4. Ficha hasta edición en activo o editar en división.
  5. Presione la tecla ENTRAR.
Para eliminar un procedimiento SUB, haga lo siguiente:

  1. Elija el menú Ver.
  2. Elija las subrutinas... opción.
  3. Resalte el SUB que desea eliminar.
  4. Ficha hasta la opción Eliminar.
  5. Presione la tecla ENTRAR.
Para mover un SUB en un módulo diferente, haga lo siguiente:

  1. Elija el menú Ver.
  2. Elija las SUBRUTINAS... opción.
  3. Resalte el SUB que desea mover.
  4. Ficha hasta la opción Mover.
  5. Presione la tecla ENTRAR.
  6. Seleccione el módulo que desee el SUB en.
  7. Presione la tecla ENTRAR.
Para obtener más información acerca de cómo utilizar el QB. Entorno de EXE, consulte la "Microsoft QuickBasic: aprender a usar" manual para la versión 4.50 o consulte la "Microsoft QuickBasic 4.0: aprendizaje y uso de" manual para versiones 4.00 and4.00b y las versiones de compilador básica 6,00 y 6.00b.

Lo que sucede en el nivel de módulo en un módulo de soporte

Un módulo de soporte técnico, cuando se compila, genera un objeto (. OBJ) que isLINKed con un módulo para crear un archivo ejecutable principal de archivos. El levelcode de módulo del módulo principal es el único código ejecutado directamente por QuickBasic.The no se puede llamar código de nivel de módulo de los módulos de soporte, ejecutar, orCHAINed. Este código de nivel de módulo de los módulos de compatibilidad sólo se utiliza para:

  1. Controladores de eventos o interceptación de errores
  2. Metacommands
  3. Escriba definiciones comunes y DIM SHARED instrucciones
Se pueden colocar en evento GOSUB y ON ERROR GOTO procedimientos de withinSUBprogram instrucciones de reventado [donde ON evento significa ON KEY(n), ON COM(n), ONTIMER(n), etc..]. Sin embargo, la línea o la etiqueta de línea que es el destino del evento o error de la trampa GOTO o GOSUB debe ser el código de nivel de módulo en el mismo módulo que dicho subprograma. Esto es porque QuickBasic no allowGOSUBs o instrucciones goto desde un subprograma a otros módulos o subprogramas, andQuickBasic permite sólo ON evento GOSUB y ON ERROR GOTO instrucciones jumpfrom un subprograma para el código de nivel de módulo.

El compilador metacommands (REM $INCLUDE $STATIC REM y REM$ DYNAMIC) también puede utilizarse en el nivel de módulo. REM $INCLUDE pastesextra código fuente en el módulo en tiempo de compilación. REM $DYNAMIC y REM$ STATIC declaran matrices posteriores como $DYNAMIC (asignado en tiempo de ejecución) o $STATIC (asignado en tiempo de compilación).

Puede utilizar el tipo... Instrucciones de tipo de extremo, DIM y compartidas comunes en el código de nivel de themodule. Variables y matrices pueden ser compartidos entre modulesusing la declaración común COMPARTIDA en el nivel de módulo.

COMUNES, comunes compartidos, SHARED y COMPARTIDA DIM

La instrucción SHARED proporciona un acceso de procedimiento SUB o FUNCTION a variablesdeclared en el nivel de módulo principal de ese módulo (sin pasarlos asparameters). No da acceso a las variables declaradas en supportmodules.

La declaración común, hace variables disponibles en el betweenmodules de nivel de módulo. El atributo SHARED de la declaración común (es decir, COMMONSHARED) es necesario para compartir las variables con subprogramas o FUNCTIONs.The lista de variables en las instrucciones común y compartido común debe tipo coincidente en las instrucciones común y compartido común de cada módulo.

Cuando se utiliza la instrucción común (o COMPARTIDA común), static y dynamicarrays se dimensiona diferente. Las matrices estáticas en común deben beDIMensioned instrucción antes el común en todos los módulos con los que COMMONstatement. Matrices dinámicas en común deben ser dimensionado después de la COMMONstatement en el módulo de principal y no deben ser declaradas en los módulos de anysupport.

Hay dos diferencias entre el uso de la instrucción SHARED y DIMSHARED:

  1. Para que una variable sea accesible por todos los subprogramas en un módulo, utilice DIM compartidos en el nivel de módulo.
  2. Para compartir una variable de nivel de módulo con un subprograma específico, coloque la variable en una instrucción de SHARED en el subprograma. La instrucción SHARED va directamente después de la primera línea del subprograma.

ADMINISTRACIÓN DE DATOS

Arreglos de discos $DYNAMIC y $STATIC

La configuración predeterminada para almacenar matrices es $STATIC REM, que almacena allarrays en DGROUP (el segmento de datos predeterminado). Para cualquier básico. EXE programa, DGROUP está limitada a 64K. Si utiliza las matrices estáticas, puede obtener morememory en DGROUP realizando los arreglos de discos dinámicos, que mueve en el montón de thefar. Para hacer que una matriz dinámica, la dimensión de la matriz después de themetacommand $DYNAMIC REM o la dimensión de la matriz con una variable en itssubscript.

Todas las matrices dinámicas se almacenan en el montón far excepto las matrices de cadenas de longitud variable. Cadenas, matrices de cadenas de longitud variable y simplevariables siempre se almacenan en DGROUP. Para almacenar cadenas en el montón far, es necesario acotar una matriz dinámica de cadenas de longitud fija. DIMensioningstrings como longitud fija en matrices dinámicas ayuda a liberar spacethat de almacenamiento de información que de lo contrario llevaba en DGROUP, que está limitado a 64K.

Grandes arreglos

Grandes matrices son matrices mayores de 64 KB. Al utilizar matrices grandes, se debe invocar el QB. Editor de EXE y continuidad del negocio. Compilador EXE con la opción /AH. La matriz de gran tamaño debe ser declarada como una matriz dinámica, con avariable en el subíndice de matriz o con la dinámica de $ REM metacommand anterior. La opción /AH permite matrices dinámicas de datos numéricos, cadenas de longitud fija y tipos definidos por el usuario hasta ocupar toda la memoria disponible.

El número de bytes de un solo elemento de una matriz de gran tamaño debe preferablybe una potencia de 2, con el fin de evitar la pérdida de memoria y habilitar los arreglos de discos belarger de 128 K, tal como se explica a continuación.

Se asigna espacio para una enorme matriz de forma contigua en el montón far, con therestriction que ningún elemento de matriz simple (o registro) puede estar splitacross un límite de 64K. Si un tamaño de registro no es una potencia de 2, la isallocated de matriz altos contrapartida suficiente, con respecto al segmentaddress de base de la matriz (devuelto por la función VARSEG), que no issplit de elemento de matriz a través del límite exactamente 64 k por encima del segmento base. El ValueReturned equivale por la función VARPTR para el primer elemento de la matriz de thenindicates tanto el desplazamiento de la matriz y también el tamaño de un montón far acuñó de gap. Esta brecha fragmenta el montón far y memoria desperdiciada, no utilizada. El tamaño de la brecha es igual a (65.536) MOD (tamaño de registro de matriz). [En caso de theworst, la brecha puede tener hasta (tamaño de registro de matriz) menos 1 tamaño.]

Se produce un error "Subíndice fuera del intervalo" al asignar una persona inmensa matriz 128 K si los elementos de la matriz tienen un tamaño que no es una potencia par de 2. matrices mayores que 128 K debe tener un tamaño de elemento es una potencia de 2 (2, 4, 8, 16, 32, 64, etc.), puesto que las matrices se almacenan de forma contigua y ningún elemento singlearray puede dividirse a través de un límite de 64 K.

El último aspecto importante QuickBasic de administración de memoria es que QuickBasicattempts para hacer eficaz uso de memoria, que puede ocasionar la variable lengthstrings, matrices de cadenas de longitud variable y matrices dinámicas para mover memoria aroundin de instrucción en tiempo de ejecución. (Otras variables tienen ubicación afixed determina en tiempo de carga EXE.) Además, si realizar la instrucción aCHAIN, pueden mover los datos pasados en un bloque común. Thismeans que los resultados de la VARPTR VARPTR, VARSEG, $ o functionshould SADD utilizar siempre inmediatamente después de que se llama a la función.

APÉNDICE A: PROGRAMA DE EJEMPLO

Este programa de ejemplo muestra los temas tratados en este artículo. Thisprogram proporciona un ejemplo de formas para matrices de una dimensión y pasar los módulos variablesbetween y subprogramas. El programa consta de dos módulos, eachwhich define un subprograma.

Módulo principal (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 BytesEND TYPE                       ' 32 Bytes Total, a power of 2, 2^5REM $STATICDIM A(100) AS INTEGER          ' Static array, stored in DGROUP.COMMON SHARED A() AS INTEGER   ' Share the variables with the otherCOMMON SHARED B AS STRING * 20 '  module and its SUBprograms.COMMON SHARED X() AS INTEGERREM $DYNAMICDIM 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 $STATICDIM SHARED M(100) AS LONG        ' These variables are shared with allDIM SHARED Equals AS STRING * 10 '  the SUBprograms in this module,                                 '  and are stored in the DGROUP.Num = 40DIM 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) = 7A(1) = 4CALL Subdemo             ' CALLs the SUBprogram of this module.CALL OtherModSub         ' CALLs the SUBprogram of the support module.END'SUBprogram of the Main Module:SUB SubdemoSHARED Plus$, NonFixedLen() AS STRING, Num    PRINT STR$(Num) + Plus$;    PRINT STR$(M(1))+ Equals + STR$(A(1));    A(1) = M(1)END SUB				

Módulo de soporte (EXAMPL2. BAS)

REM $STATICDIM A(100) AS INTEGER          ' Only the static array is DIMensionedCOMMON SHARED A() AS INTEGER   '  before the COMMON SHARED statement.COMMON SHARED B AS STRING * 20COMMON 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 PanicEND SUB				

APÉNDICE B: VÍNCULO. EXPLICACIÓN DEL ARCHIVO DE MAPA

A continuación se presenta una. Archivo de mapa creado cuando en el ejemplo de programa de islinked del apéndice A. . Archivo de asignación desde un vínculo exitoso muestra lo cerca que está un segmento module'scode alcanzando el código de 64 K limitar y cómo cerrar la staticvariables para toda la. Programa EXE son alcanzando el límite de 64K en la DGROUP. Para generar un mapa de listado de un programa, incluya un filenamein de mapa el tercer argumento del comando de vínculo, como en el ejemplo siguiente:
   LINK EXAMPL1.OBJ+EXAMPL2.OBJ,,EXAMPLE.MAP;				
Notas para el vínculo. MAPA que se muestra más abajo son las siguientes:

  1. EXAMPL1_CODE es el segmento de código para EXAMPL1. BAS.
  2. EXAMPL2_CODE es el segmento de código para EXAMPL2. BAS.
  3. El segmento de código de cada módulo debe ser menor que 64K. Cuando el segmento de código se está aproximando al 64 K, divida el módulo en dos o más módulos. Para encontrar la longitud de un segmento de código, busque en la columna longitud. Por ejemplo, la longitud del segmento de código para EXAMPL1. BAS es 15A bytes hexadecimales, 346 en notación decimal.
  4. FAR_MSG es el grupo de administración lejano que contiene texto de mensajes de error. NO es el montón far. Se asigna el montón far en tiempo de ejecución.
  5. Según el punto de origen en la parte inferior del mapa de vínculo, DGROUP comienza en 06DC:0, que es el hexadecimal 06DC dirección de párrafo, con un desplazamiento de 0. Es el mismo que el hex de 06DC0 dirección de bytes (como un párrafo contiene 16 bytes). Por lo tanto, en este ejemplo, DGROUP comienza donde comienza el BR_DATA.
  6. DGROUP termina en la dirección de la parada de la pila.
  7. Para saber el tamaño DGROUP del programa, tomar la dirección de la parada de la pila y restar la dirección de inicio del primer elemento de datos en el DGROUP. Por ejemplo, el tamaño de DGROUP del programa es 7F9F hexadecimal menos hexadecimal 6DC0, que equivale a 11DF de bytes hexadecimales (4575).
  8. Todas las direcciones en el. MAPA son sólo relativas al inicio de la. Programa EXE. La dirección de carga absoluta se determina por DOS en tiempo de ejecución. Las instrucciones VARSEG y VARPTR pueden utilizarse en el programa en tiempo de ejecución para mostrar las direcciones absolutas de las variables.

EJEMPLO. MAPA

 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   FMGROUPProgram entry point at 03A1:00C8				

Apéndice C: Donde QuickBasic 4.00, 4.00b, y 4.50 almacenar sus arreglos de discos

Hay una diferencia entre los programas que se ejecutan como compilado almacenamiento para la matriz. Programas y archivos EXE ejecutarán en las versiones de QuickBasic 4.00, 4.00b, and4.50 entorno (QB. (EXE). En el QB. Entorno de EXE, una matriz que isstatic no en común y no formado por cadenas de longitud variable, la almacena en el montón far (en lugar de DGROUP, como en. Programas EXE).

Esto cambia la administración de memoria en el programa, dependiendo de dónde se runyour programa.

Así, en los programas que se ejecutan dentro del QuickBasic 4.00, 4.00b o 4.50environment (QB. (EXE), se almacenan las matrices como sigue:

  1. Todas las matrices $STATIC en común se almacenan en DGROUP y se pueden hacer referencia con direcciones near.
  2. Todas las matrices de cadenas de longitud variable también se almacenan en DGROUP y también pueden hacer referencia con direcciones near.
  3. Todos los otros arreglos de discos se almacenan como objetos lejos y requieren direcciones lejanas. Esto incluye arreglos de discos de $STATIC que no están en una declaración común, y pueden mover estas matrices en memoria como las matrices $DYNAMIC.
En QuickBasic 4.00, 4.00b y 4.50 programas que se ejecutan como compilado. Archivos EXE, arreglos de discos se almacenan como sigue:

  1. Todas las matrices $STATIC se almacenan en DGROUP y se pueden hacer referencia con direcciones near.
  2. Todas las matrices de cadenas de longitud variable $DYNAMIC también se almacenan en DGROUP y también pueden hacer referencia con direcciones near.
  3. Todas las demás matrices $DYNAMIC se almacenan como objetos de extremo.

APÉNDICE D: MEMORIA MAPAS

Este apéndice contiene una asignación de memoria general y tres asignaciones de memoria en tiempo de detailedrun.

Diagrama de memoria general

El siguiente diagrama resume cómo QuickBasic había compilado areloaded de programas en la memoria en tiempo de ejecución:
          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				
Las siguientes figuras 1, 2 y 3 describen con más detalle el código de arrangementof y los datos en la memoria en tiempo de ejecución.

Figura 1

La primera figura (siguiente) muestra el mapa de la memoria en tiempo de ejecución cuando el isexecuted de programa dentro de la QB. Entorno de EXE versión 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.EXELow Memory ------->|    Code     |                   +-------------+                   |    MS-DOS   |  MS-DOS Operating System                   +-------------+0000:0000  ------->				
Figura 1 (anteriormente): la asignación de memoria para QB. Entorno de EXE 4.x

Figura 2

Esta segunda figura (más abajo) muestra el mapa de memoria de tiempo de ejecución cuando se appearswhen el módulo de tiempo de ejecución BRUN4x.EXE se utiliza con el método separatecompilation (asegúrese de archivo 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 variablesUp to              +-------------+64K                |   BC_CONST  |  User program constants                   +-------------+                   | Blank COMMON|                   +-------------+                   |   _DATA     |  QuickBasic run-time data areas,User Data          |    CONST    |     used during user code executionStart DS:0 ------->|   _BSS      |                   +-------------+                   |  User Code  |  User program separately linkedLow Memory ------->|             |     with BRUN4x.LIB                   +-------------+                   |    MS-DOS   |  MS-DOS Operating System                   +-------------+0000:0000  ------->				
Figura 2 (parte superior): la memoria del módulo de tiempo de ejecución de BRUN4x.EXE para un. EXE

Figura 3

Esta tercera figura (más abajo) muestra el mapa de memoria de tiempo de ejecución cuando se utiliza la opción de biblioteca independiente (BCOM4x.LIB) con el método de compilación independiente (asegúrese de archivo 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 variablesUp 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 executionStart DS:0 ------->|   _BSS      |                   +-------------+                   |Run-time code|  Run-time code linked into file                   +-------------+                   |  User Code  |  User program separately linkedLow Memory ------->|             |     with BCOM4x.LIB                   +-------------+                   |    MS-DOS   |  MS-DOS Operating System                   +-------------+0000:0000  ------->				
Figura 3 (arriba): independiente (biblioteca BCOM4x.LIB) memoria para una. EXE
QuickBas 4.00 4.00b 4.50 6.00 6.00b 7.00 7.10 1.00

Advertencia: este artículo se tradujo automáticamente

Propiedades

Id. de artículo: 45850 - Última revisión: 01/31/2016 23:48:00 - Revisión: 3.0

Microsoft BASIC Professional Development System 7.0, Microsoft BASIC Professional Development System 7.1

  • kbmt KB45850 KbMtes
Comentarios