JPH02259931A - Overlay module realizing system - Google Patents

Abstract

PURPOSE:To efficiently execute an overlay function without burdening a user by providing an exclusive overlay loading function and a start-up module exclusive for the overlay, and calling the start-up module exclusive for the overlay by means of a master module having the overlay module. CONSTITUTION:An overlay module means is provided with a start-up module means 2 and a program code to be an overlay main body 3, and a data segment is provided with a variable area having an initial value and a variable area without the initial value. When a master module means 1 executes the overlay module, the overlay start-up module is called, the overlay program is initialized by the start-up module means 2, then the overlay main body is called by the overlay start-up module. Thus the overlay function can be efficiently executed without burdening the user.

Description

[Detailed Description of the Invention] [Summary] Regarding the implementation method of an overlay module that is modularized into a file separate from the main body of the execution program, the present invention is based on MS-DO3 for efficiently performing the overlay function without burdening the user. The object of the present invention is to provide an overlay module implementation method, and the operation system includes an overlay loader means and an overlay module means, and the overlay loader means secures an overlay area in a parent module means and loads an overlay program. , executes the overlay program and exchanges segment information with the overlay module in order to release the overlay area, and the overlay module means saves the segment information and saves the initial value undefined area in order to initialize the overlay program. startup module means for initializing, and a program code that is an overlay body of a program of the startup module means and an overlay module in a code segment;
The data segment has an area for variables with initial values and an area for variables without initial values, and when the parent module means executes an overlay module, it calls an overlay startup module and performs initial processing of the overlay program. The overlay startup module is configured to call the overlay body after doing so by the startup module means.

[Industrial application field]

The present invention relates to a computer operating system, and more particularly to a method for implementing an overlay module that is modularized into a file separate from the execution program main body in MS-DO3.

When working on a small computer such as a microcomputer or personal computer, programs and data are transferred from the keyboard and disk to main memory.
Execute instructions sequentially. Then, if necessary, data is retrieved from the main memory and the processed results are stored in the main memory.

Main memory is often divided into sections of 1 byte, ie, 8 bits, and the main memory addresses are further divided into units called segments.

There are registers such as code segment C3 and data segment DS to indicate from which address in the main memory each segment starts.

For example, the CS register that stores code segments is used to indicate which segment in main memory the program is located in. The location address is then referenced using a pointer within the segment.

Although the size of a segment is free, the starting address is often an integral multiple of 16, and the maximum size of a segment is also limited to 64 bytes. Each segment can be relocated anywhere within the main memory, making it relocatable.

In order to enable users to use computers efficiently, there are standard operating systems (O8), one of which is MS-DO3.

This O8 manages not only system programs such as editors, linkers, assemblers, and debuggers, but also programs created by users. Under this O8, high-level languages such as Assembler, Fortran, Pascal, and C can be used.

This O8 also has standard functions for controlling input/output devices, such as inputting a single character from the keyboard or displaying a single character on the display, by calling each function in the form of a function call. When performing a call function, rules such as what information should be set in which register and which register should receive input are determined in advance, and these rules are summarized in the form of a so-called OS interface.

A part of the main memory is used as a buffer between the O8 and the input/output device, and commands are sent via this buffer. An assembly language or high-level language source program is converted into an object file through an assembler or combiner, and this object file is further linked to combine with other similarly created object files, resulting in , an executable file is generated.

The overlay module is modularized into a file separate from the main body of the execution program, and only one of the plurality of overlay modules is included in the execution program file and executed.

This overlay function is useful for main memory with limited capacity,
For example, this is an extremely effective function when configuring a large program within 1 megabyte.

The overlay function can also be used on MS-DO3, and is effective when designing and constructing an application program that operates a large function with a small amount of memory.

[Conventional technology]

Traditionally, the overlay loading function on MS-DO3 was
There is no function to adequately manage memory for segment information and overlay areas, and it is necessary to compile all main programs and overlay modules each time to create an object file, and to specify which module is an overlay even when linking. was there.

For example, suppose there are modules A, B, and C, where A is the main program and B and C are overlay modules. In this case, overlay modules B and C are called and executed within the main program of A, but the parent program informs the operating segment address when calling the overlay, and the overlay sends segment information to the calling program. Requires action to return.

Each source program is then compiled to create an object file, but it is also necessary to specify an overlay module during linking, and it is also necessary to control the overall segment information.

[Problem to be solved by the invention]

Therefore, in the conventional method, in order for a user to execute the overlay function, the user must be aware of the segment information for referring to the main memory and design and construct an application program, which poses a large burden on the user. There was a point.

SUMMARY OF THE INVENTION An object of the present invention is to provide a method for implementing an overlay module in MS-DO3 that efficiently implements overlay functions without burdening the user.

[Means to solve the problem]

FIG. 1 is a block diagram of the principle of the present invention.

The overlay loader means reserves an overlay area within the parent module means in the operation system;
The startup module means 2 loads the overlay program, executes the overlay program, and exchanges segment information with the overlay module to release the overlay area. The overlay module means initializes the value undefined area, and the overlay module means has a program code which is an overlay body 3 of the program of the startup module means 2 and the overlay module in a code segment, and a variable having an initial value in a data segment. When the parent module means 1 executes an overlay module, it calls the overlay startup module and performs the initial processing of the overlay program. is performed by the startup module means 2, and then the overlay startup module is configured to call the overlay main body.

[For production]

In the present invention, MS-DO3 has a dedicated overlay load function and a startup module dedicated to overlay, and a parent module having an overlay module simply realizes overlay by calling the startup module dedicated to overlay. ing.

〔Example〕

Next, embodiments of the present invention will be described with reference to the drawings.

As MS-DO3 becomes widely used and the number of applications running on it increases, the 1 megabyte memory limit of MS-DO3 becomes a bottleneck. Among them, overlay is a development method for realizing multiple functions. However, since MS-DO3 does not have sufficient functions for realizing overlay, overlay cannot be easily realized.

In the present invention, overlay is easily realized using the functions provided by the conventional MS-DO3.

FIG. 2 is a conceptual diagram of the overlay implementation method of the present invention. In the figure, 11 is a disk, and 12 is a memory structure on the main memory. The main storage area is divided into an overlay module area that stores the main program of the parent module and an overlay program, and a startup module for overlay that performs initial processing of the overlay program, which is a feature of the present invention.

The overlay modules are divided and stored on the disk, and when needed, one of the overlay modules is linked to the overlay module area on the main memory. Acquisition of an overlay area and reception of segment information are then executed while passing between the main program and the main program via the overlay loader.

The overall main memory structure consists of a parent module that is the calling source and an overlay module body that is the called side.The parent module manages the overlay area, loads the overlay module, and shares segment information with the overlay module. Contains an overlay loader for interaction. This overlay loader has four functions: 1. Securing an overlay area, 2. Loading an overlay module, 3. Executing an overlay module, and 4. Releasing an overlay area.

On the other hand, an overlay module is itself a program and has data and the like used when the program is executed. Therefore, it is composed of a code segment C8 that specifies a segment for code reference of a program, and a data segment DS that specifies a segment in which a data area is stored, that is, a code section and a data section.

FIG. 3 is a block diagram of the overlay module of the present invention.

The code segment C8 of the present invention includes a startup module in addition to the program code.

This module performs initial processing of the overlay program, and also saves segment information and initializes the initial value undefined area. On the other hand, the program code includes the program body of the overlay module.

The data in S in the data segment is DATA, which is an area for variables that have initial values, and uninitialized data, that is, UDAT, which is an area for variables that do not have initial values.
There is an A.

Since nesting of overlays is not allowed for the overlay function, the overlay area does not have a stack segment, ie, SS, and uses the SS of the caller.

FIG. 4 is a schematic diagram when one overlay body is called from the parent module of the present invention.

In the figure, 21 is a parent module which is the main program.

Inside the dotted line is an overlay module, which includes a startup module 22 and an overlay main body 23.

When the parent module 21 calls an overlay module, it is called FARCALL. There are two types of calls: near calls and far calls. Near is a 2-byte address, and far is a 4-byte address, i.e. It is called with an address of segment + offset, and if it is 4 bytes, it means calling a subroutine located 64 bytes away from the address of the instruction where it is located. After executing the overlay module called by FarReturn
(far return) will return to the parent module.

In the present invention, when the overlay module is called, the overlay itself is called via the startup module. Immediately after the startup module is activated, the DS, that is, the data segment register, is set to DA.
DS called TA? The value of DS from the parent process is guaranteed at the time of return using the saved contents of this DS register. This is,
This is a DS register setting function.

E3 of the extra segment which is another segment register. Registers such as the SS of the stack segment and the stack pointer SP pointing to the address within the stack segment use the values at startup as they are. This is the first basic function of the startup module within the overlay module.

The second basic function is initialization of the initial value undefined area, UDATA. When using the C language, variables that do not define an initial value must be set to O at startup, so before starting the main module, clear all the U D A T A 95 areas to O. . In other words, if the overlay body is written in C language, this initial value undefined area must be initialized, so UDATA
is cleared within the startup module.

The overlay body is the main ma of C language as shown in the figure.
The body starts with in().

FIG. 5 is a segment configuration diagram of the module of the present invention. An overlay startup module and a main program are stored in the code segment, and DATA and UDATA are stored in the data segment. In the figure, the upper side is a low-order address, and the lower side is a high-order address.

When calling the overlay body from the startup module within the overlay module, it is a near call. In other words, the call is made within an address expressed in 2 bytes, and within a range of ±64 bytes from the address where the current instruction ' is located.

In this way, since the address when calling is a relative address, the program can be made into a locator pull.

When creating a program, even if it grows to a certain extent, the main program and the overlay itself are programs that each perform a set of tasks.
It is a subroutine, that is, it is modular. Therefore, a large program is constructed as a collection of small subroutines, and the overlay body is formed from several types of overlay programs, each of which is stored in a disk and executed by being retrieved at runtime. In this way, it is possible to have substantially greater program functionality.

When calling an overlay, it is called in the form of a far call, each overlay body is called as a near call via the startup module, it is performed as a call that calls a subroutine and transfers control, and when returning from each procedure, it is called with a RET. Become.

When the startup module branches to the overlay body, it is done with a near call, but the label name must be main().

This has the advantage that the overlay itself can be developed in C language.

FIG. 6 is a schematic flowchart of the startup module. When started, it saves the contents of the DI register that stores the data segment DS, extra segment ES, and destination index, sets the overlay data segment DS, and determines the size of the UDA T A TiN area where variables with initial values of 0 are stored. calculate,
The overlay body is called with the 0th order CALL MAIN which initializes the U DATA 9m area to clear it to 0. Assuming that the overlay body is written in C language, this is compiled and executed. When the execution is stopped, the saved contents of the DS, ES, and DI registers are restored, and a far return is made to the main program. In other words, it ends up returning in the form of segment + offset.

FIG. 7 is a diagram showing an embodiment of the present invention. In the same figure, 3
1 is a parent module, 32 is an overlay/start amplifier module, and 33 is an overlay body written in C language. This embodiment is a conceptual diagram of an application program using MS-DO3+Lattice-C.

1nt21ah in the main body of the parent module MAIN =
48h is included, that is, an interrupt for acquiring a memory block. A function code numbered 48 in hexadecimal is set in the upper part of the A register, and a memory block is acquired when the 21st interrupt routine is executed.

The interrupt written at the bottom is 49h, which releases the memory block. In other words, the memory management of MS-DO3 is performed by the function 48h that allocates memory.
Funk Silan 49h, which frees up 1 memory, is available. This acquires the overlay area.

The overlay module is loaded using the interrupt routine 21 ah = 4bh 03 of Interabd. When reading the overlay module from disk,
The overlay loader first searches the current directory, then searches for overlay modules in the order of the directories set by the environment variable PATH=, and loads the overlay modules in the directories. In other words, it is moved to main memory. And FARCA
The overlay module will be executed in the LL overlay. Since this is a fur call, segment +
It will be called with a 4-byte offset address.

When called, the overlay startup module is executed from the start address of the overlay startup module. This saves segment information and initializes the initial value undefined area, as will be described later.

Call the overlay body written in C language with a near call,
After executing the overlay itself, perform a near return to return to the overlay startup module. and,
It pops the segment information from the save location and returns to the next instruction of the parent module's far call.

Then, at 1nt21ah=49h of the parent module, the memory block is released and the overlay area is released.

FIG. 8(a) and (bl) are diagrams showing an example of a program in assembler language for the processing process of the overlay startup module.

Comparing the program in Figure 8 with the flowchart in Figure 6, lines 49, 50, and 51 are DS,
ES: Save DI register, 53rd and 54th lines set overlay DS, 63rd to 68th lines calculate UDATA area, 69th to 73rd lines initialize UDATA area, 79th line CALLMAIN , 80th to 82nd lines are DS, ES:Dr and register return, 85th line is FRRE
It becomes T. The program shown in FIG. 8 will be explained in detail below.

At the beginning of the 86 series assembler language program, TIT
LE is given here, and the name INIT, which means initiate, is given here. The entire program is in the form of one code segment. In the program,
When including another program, an instruction called INCLUDE is used, and in this case, DO3MAC is included.

Comments for programs begin with the symbol ;. Comments are ignored by the assembler, so the ; part is not executed. On the 19th line, assembler parameter 5TKR3V representing the dummy stack size is set to 08 in hexadecimal.

EXTRN on the 26th line has an external meaning, and declares that if the program MAIN in the overlay main body is called by a near call with a 2-byte address without a segment, it is an external file, that is, a separate file. That is, the routine called main is an ear file, and the address when calling it is declared to be 2-byte l-(NEAR).

In the 32nd line, data is grouped.

DATA, NDATA, and UDATA are aggregated data, and the 33rd line specifies that the entire group is within the data segment S. That is, the body within the data segment is DGROUP
This specifies that the segment name is .

The 39th line defines the program segment.

PUBLIC on the 44th line indicates that the program INIT is open to the public, and is a declaration that it can be referenced from another external file. That is, a name that can be declared as EXTRN in a separate file is declared as PUBLIC on the other party's side.

Line 46 shows that the routine named INIT is a procedure (PROC), that is, a subroutine, and the FAR attached to the procedure indicates that the address of the location is 4 bytes long (segment+offset).

The end of the procedure is ENDP on line 87.

92 specifies the end of the program segment.
This is the row.

Since the procedure INrT is public, it can be far accessed from the parent module. In this procedure, saving of segment information is written from the 47th line to the 57th line, and from the 61st line to the 74th line, the initial value undefined area is initialized. and,
The 75th line to the 84th line is the part that calls the overlay itself, defines arguments for it, and calls it.

The bush instruction on the 47th line saves the contents of the register representing the base point, that is, the location address in the current segment. The move instruction on line 48 moves the current SP, that is, the contents of the stack pointer, to BP. Then, in the 49th line, the current data segment is saved, in the 50th line, the current construction segment is saved, and in the 51st line, the current destination index DI is saved. The CLI instruction on the 52nd line is a clear included instruction, and is an instruction that prohibits acceptance of interrupts from now on. In the 53rd line, the data segment called DGROUP, which was grouped in the 32nd line, is moved to the AX register of the accumulator, and in the 54th line, the AX is moved to the DS. Line 55 sets included and cancels the prohibition of interbed. In line 56, the contents of the current extra segment are set as a common segment address, and in line 57, this is moved to C0M0FF as a common offset address for the destination index.

Immediately after the startup module is activated in this manner, in lines 53 and 54, the DS, that is, the data segment register is set to the start address of the data segment area in which data such as DATA is stored.

Also, the current DS, BS, DI, etc. from the parent process is 49
．． Since they are saved at 50.51, their return is guaranteed upon return. Other segment registers such as ES of the extra segment, S81 of the stack segment, and a stack pointer SP pointing to an address within the stack segment use the values at startup as they are. Lines 59 to 73 are initialization of the initial value undefined area UDATA.

The starting address of the character string is set in the SI and DI registers, but the source of SL and the destination of DI have literal meanings, and when the direction of examining the character string is from front to back, CLD is used. It represents the direction, and conversely, when going from back to front, the command STD is used. and,
It is necessary to pre-centre the DS register for SL and the ES register for DI. When performing some operation on the entire string in the string, the CS register is used, and the length of the string is set here.

The direction in which the character string is examined in CLD on the 61st line is the forward direction. On the 62nd line, the contents of AX are cleared by exclusive ORing. On the 63rd line, the start address of the character string in the UDATA segment is set in the DI register. At line 64, the stack segment is moved to Cx.

On line 65, the contents of DI are subtracted from the contents of CX. 66.6
7. Shift the contents of the CX register to the left on line 68. Then, in the 69th line, the extra segment is bushed and saved, and in the 70th line, the current DI is moved to the ES.

Then, in line 71, the DI is cleared. The repeat instruction on line 72 is not an independent instruction in itself, but is added before the instruction that processes characters.It is, so to speak, a prefix, and is a predetermined instruction to repeat unless the CX register is 0. This process is repeated until the contents of CX become 0. The extra segment is saved on the 73rd line. That is, when using the C language, variables for which no initial value is defined must be set to 0 at startup by this routine, so the U DATA SJI area is all cleared to 0. That is, this routine initializes the initial value undefined area for the overlay body written in C language.

The 75th line to the 85th line is a routine that calls the overlay body. At line 77, save the current DS, and at line 78
Pop the ES on the row and pull it back.

Line 79 calls the C main or overlay, returns DI at 80, and returns ES and DS at 81 and 82, respectively.
is popping. Then, in the 83rd line, BP is transferred to SP, and in the 84th line, BP is pulled back. Returns on line 85 and returns to the parent module. Line 87 is the end of the procedure.

〔Effect of the invention〕

In this way, in the present invention, by creating a start amplifier module exclusively for overlays, programs can be developed without being aware of overlays at all even when developing the overlay itself. MS-D is also used when creating an executable file for an overlay module.

You can use the linker provided by S as is.

When designing and constructing an application program using S, it is possible to operate multiple functions, that is, modules, with very little memory resources, and therefore overlay can be easily realized.

[Brief explanation of drawings]

Figure 1 is a principle block diagram of the present invention, Figure 2 is a conceptual diagram of the overlay implementation method of the present invention, and Figure 3 is a conceptual diagram of the overlay implementation method of the present invention.
4 is a schematic diagram when one overlay main body is called from the parent module of the present invention. FIG. 5 is a segment configuration diagram of the module of the present invention. The figure is a schematic flowchart of the startup module, FIG. 7 is an embodiment of the present invention, and FIGS. 8(a) and 8(b) are diagrams of an embodiment of a program in assembler language for the processing process of the overlay startup module. be. - Parent module means; - Startup module means; - Overlay body.

Claims (1)

[Claims] 1) The operation system includes an overlay loader means and an overlay module means, the overlay loader means securing an overlay area in the parent module means (1), loading an overlay program, The overlay module executes the overlay program and exchanges segment information with the overlay module to release the overlay area, and the overlay module means saves the segment information and initializes the initial value undefined area to perform initial processing of the overlay program. a startup module means (2) for performing the above, and a program code which is an overlay body (3) of the program of the startup module means (2) and the overlay module in a code segment, and a data segment containing variables having initial values. When the parent module means (1) executes an overlay module, the overlay startup module is called and the initial processing of the overlay program is performed by the startup module means (2). The overlay module implementation method is characterized in that after the overlay start-up module calls the overlay main body (3). 2) The overlay module implementation method according to claim 1, wherein the operation system is MS-DOS. 3) When the parent module means (1) calls the overlay startup module means (2), it calls with a far call, and when the overlay startup module calls the overlay body (3), it calls with a near call. The overlay module implementation method according to claim 1. 4) The overlay body (3) is written in C language, and when the overlay startup module means (2) calls the overlay body (3), it calls a C language program. Overlay module implementation method. 5) Immediately after the startup module means (2) is started, it sets the DS register at the beginning of the data area DATA, and leaves other registers such as the extra segment ES, stack segment SS, and stack pointer as they are at the time of startup. 2. The overlay module implementation method according to claim 1, wherein variables that are used and do not define initial values for use in the C language are cleared before starting the overlay main body (3).