JPH05210501A - Calling system for program module - Google Patents

Abstract

PURPOSE:To provide the calling system for program modules which can easily cope with a change in the calling order of a low-order module and new addition by enabling a high-order module to call the low-order module in optional order and combination. CONSTITUTION:According to input information, etc., to the high-order module 1, a 1st index is determined (step S1). Then the address of the low-order module corresponding to the index is obtained from an entry address table 2 (step S3). Branching to the low-order module having the obtained address is performed and after a specific process, a return value indicating an index in the entry address table 2 is generated (step S4). This operation is repeated according to the generated index (steps S5 and S2). When the index value is zero, a return is made and the calling of the low-order module ends (step S2).

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method of calling a program module in an electronic computer system for loading a program composed of modules onto a main memory and executing the program.

[0002]

2. Description of the Related Art In the prior art, a lower module exists as shown in FIG. 5 in order to call a lower program module (hereinafter referred to as lower module) from a higher program module (hereinafter referred to as higher module). The entry address on the main memory (or the name given to the module) is described inside the upper module as a branch destination.

Moreover, since the inter-module interface between the upper module and each lower module is different for each lower module, it is necessary to prepare for each. In the case of calling a module that branches into a large number, as shown in FIG. 6, the lower module called from the upper module becomes the next upper module, and the next lower module is called. It is being appreciated.

[0004]

However, in the above-mentioned conventional technique, the entry address (or the name given to the module) is changed, the module is added and the calling order is changed, and the interface is changed in the lower module. If this happens, there are the following operational problems.

First, it is necessary to investigate all the modules and extract the modules related to the modules that have changed or added. Then, in each of the extraction modules, modification work such as change of branch destination, change of inter-module interface, etc. must be performed. Moreover, the number of correction points at this time is not limited to one for one module.

Then, the corrected module has to be remade into an operable state. Further, as shown in FIG. 7, for example, the address (or name) of the module E
Is changed from e to h, not only the module E but also the branch destination address of the instruction JSR for branching to the module E of the related modules B, C, and D is e.
To h at the same time. in this way,
If a module that has changed, such as changed or added, has many related modules, or if the number of modules that have changed increases, the number of points that need to be corrected increases and the work time also increases proportionately.

Therefore, in the prior art, there is an unsolved problem that it is necessary to completely clear all of these work-related problems. So, this invention
The present invention has been made in view of the above-mentioned unsolved problems of the prior art, and makes a table of entry addresses of lower modules called from upper modules, and uses the entry address of the table and the return value that specifies the table index of the lower module. By so doing, it is possible to call the lower modules in an arbitrary order and combination, and to provide a program module calling method that can easily cope with changes in the lower module calling order and new additions.

[0008]

In order to achieve the above-mentioned object, a program module calling method according to the present invention comprises a high-order program module on a main memory and a low-order program module called from the high-order program module. In the program module calling method in the existing computer system, the entry address of the lower program module called from the upper program module is indexed and tabulated, and the index is specified when the lower program module returns to the upper program module. A return value creation module is prepared, and the upper program module branches to a new program module according to the index and the entry address. It is.

[0009]

In the present invention, the branch from the upper program module to the lower program module is performed by designating the index of the entry address table to obtain the entry address of the lower program module, and the lower program module returns to the upper program module. Sometimes the return value creation module creates a new index and returns to the upper program module. Therefore, it is possible to sequentially branch to multiple lower-order program modules by the index created by the return-value creation module, and at least by changing the index value created by the return-value creation module, the lower-order modules can be arranged in any order / set. Can be called together.

[0010]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a schematic configuration diagram showing an embodiment of the present invention. As shown in FIG. 1, it is assumed that there are a plurality of lower modules A to E called from the upper module 1. The entry address table 2 referred to by the upper module 1 stores the addresses a, b, c, d, and e where the lower modules A to E are arranged. In the index 0 of the entry address table 2, 0 is stored in order to mean completion of calling the lower module.

From the upper module 1 to the lower module (A
~ E), the address (or name) of the branch destination lower module is not directly described in the upper module 1 to branch, but the index value and the address described in the entry address table 2 are not used. And are used to branch to the lower module (any of A to E). When the return value from the lower module is 0, it indicates the index 0, so no further lower modules are called (see FIG. 2).

Each of the branched lower modules performs the required processing, and finally, the return value creation module 4
(See FIG. 3). The return value creation module 4 determines the return value by looking at the internal state of the system. It should be noted that the return value can take different values depending on the call destination, even for the same module, depending on the internal state of the system. The determined return value is the index value of the entry address table 2. When the return value is determined, the process returns to the upper module 1 (see FIG. 4).

The information (inter-module interface 5) used in all lower modules is secured in the area on the main storage device continuously with a certain data area used by each module, and the information is used in each module. All the data to be used is stored and the start address of the area is passed to the lower module. Therefore, when the upper module calls the lower module, the start address of a continuous area on the main storage device may be passed to the lower module as the inter-module interface 5. In order for the lower module to know from which position of the continuous data area the data area used by itself starts, the lower module has the start address of its own data area at which position of the continuous data area. It recognizes such an offset value. Therefore, the lower module can know the address offset by a predetermined area from the start address of the continuous data area as the start address of the data area used by itself.

Next, the operation of the above embodiment will be described with reference to the flowcharts of FIGS. FIG. 2 is a flowchart of the upper module 1. First, in step S1, the first index is determined based on the input information to the upper module 1, etc., and then in step S2, it is determined whether the index value is 0 or not. When it is 0, the process directly returns to the upper module. If not 0,
The process proceeds to step S3, and the entry address table 2
Get the address of the lower module corresponding to the index from.

Then, in step S4, the process proceeds to step S5 after branching to the lower module having the address acquired in step S3 and performing a predetermined process.
Using the return value from the lower module executed in 4 as an index, the process proceeds to step S2. Then, this processing loop is repeated until the index becomes 0. Figure 3
Is a flowchart of a lower module.

First, in step S11, individual processing for each lower module acquired in FIG. 2 is executed. Next, in step S12, the return value creation module 4
After performing a predetermined process by branching to step S5, the process proceeds to step S5 in the flowchart of FIG. FIG. 4 is a flowchart of the return value creation module. First, in step S21, an internal state of the system such as whether or not processing of all lower modules for the upper module 1 is completed or whether or not a high-priority interrupt has occurred is acquired, and then in step S22. , A return value, that is, an index of the entry address table 2 is created based on the internal state of the system, and the process proceeds to step S5 of the flowchart of FIG.

Therefore, by executing the above-described embodiment, first, the index value is created by the return value creation module, so that the lower modules whose addresses are registered in the entry address table 2 can be used in any combination. .. 1 and 2, upper module 1
, The lower index module B is selected by the index 2 of the entry address table 2 and the return value of the lower module B is 4, so the lower module D is selected next. Since the return value of the module D is 3, the lower module C is selected next, and since the return value of the lower module C is 0, the process returns to the upper module 1. That is, the lower modules are called in the order of B → D → C.

Next, when the order of calling the lower modules is changed, the return value creation module 4 may be modified, and it is not necessary to modify the lower modules. That is, in FIG. 1 and FIG. 2, in order to change the lower module called in the order of B → D → C in the order of B → C → D, the return value of the module B is 3, the return value of the module C is 4, The return value of D may be corrected to 0 by the return value creation module 4.

Next, when adding a new lower module, the return value creation module 4 and the entry address table 2 may be modified. That is, in FIG. 1 and FIG.
To add a module F to a lower module called in the order of B → D → C and change it in the order of B → F → D → C,
The address f of the module F is added to the entry address table 2, the return value of the module B is set to 6, and the module F is returned.
The return value of 4 may be corrected to 4 by the return value creation module 4.

Further, the interface between the upper module and the lower module is the start address i of the interface information used in all the lower modules in FIG.
Since it is delivered, it is not necessary to change the connection point between modules even if the content of information changes. That is, the inter-module interface 5 stores all the data used by all the lower modules.

[0021]

As described above, according to the program module calling method according to the present invention, the branch from the upper program module to the lower program module specifies the index of the entry address table and the entry address of the lower program module. The return value creation module creates a new index and returns to the upper program module when the lower program module returns to the upper program module. Therefore, it is possible to sequentially branch to multiple lower-order program modules by the index created by the return-value creation module, and at least by changing the index value created by the return-value creation module, the lower-order modules can be arranged in any order / set. It is possible to call them at the same time, which has the effect of facilitating changes in the calling order of lower modules and new additions.

[Brief description of drawings]

FIG. 1 is a schematic configuration diagram of a module call according to an embodiment.

FIG. 2 is a flowchart of an upper module of the embodiment.

FIG. 3 is a flowchart of a lower module of the embodiment.

FIG. 4 is a flowchart of a return value creation module according to the embodiment.

FIG. 5 is a descriptive diagram of a branch destination when a conventional module is called.

FIG. 6 is a module call diagram of a conventional example of a mochi type.

FIG. 7 is a modification work diagram of a conventional module.

[Explanation of symbols]

 1 Upper module 2 Entry address table 3 Lower module group 4 Return value creation module 5 Inter-module interface AF Lower module

Claims (1)

[Claims] 1. In a program module calling method in an electronic computer system in which a higher-order program module and a lower-order program module called from the higher-order program module exist in a main storage device, a lower-order program module called from a higher-order program module is used. While preparing a table by indexing the entry addresses, a return value creation module that specifies the index when the lower program module returns to the upper program module is prepared, and the upper program module uses the index and the entry address to A program module calling method characterized by branching to a new program module.