JPS63268031A - Program execution control system - Google Patents

Abstract

PURPOSE:To realize the replacement of a part of an instruction sentence forming a module with another instruction sentence, by adding a proper lable to each program module and shifting the control to another program module in response to a shift instruction of the label. CONSTITUTION:A ROM 2 stores program to interpret and execute various programs and languages for control of a CPU 1. The line number added to the lines of program modules A-C can be used in common with the corresponding instruction sentences obtained before and after replacement. At the same time, a proper label is added to the first line of each module. When a shift instruction is produced during execution of the module A to shift the label showing the module A to the label showing the module B, it is decided whether a common line number corresponding to the module B is included in the module A or not. If so, the control is shifted to the module B and then returned to the original module A after execution of the module B. Thus a part of an instruction sentence forming the module A is replaced with the instruction sentence of the module B.

Description

[Detailed Description of the Invention] <Industrial Application Field> The present invention enables execution of an already completed program module by automatically switching a part of the routine to another program module. Regarding program execution control methods.

<Prior Art> Generally, in a computer system, there are cases where it is desired to execute only a part of an already completed program using a different routine.

Although this problem can be solved by re-creating the entire program, it is necessary to confirm again whether the newly created program will be executed as desired, which takes time and effort for debugging. Furthermore, if the already completed program is an application program or the like and is supplied from a ROM that cannot be rewritten, it is not possible to combine the routines into one. Also, if you want to rewrite a part of the original program and store it in RAM, the same number of program steps will be required, which will put pressure on the RAM storage capacity, so if you don't have enough storage capacity, is not appropriate.

<Purpose> The present invention provides a method for replacing a part of an already completed program with another program and reprogramming only a necessary part of the routine within the program without changing the completed program. To make it possible to arrange arbitrary lines of a pre-completed program, to give versatility to the completed program, and to omit the labor of program development.

<Embodiment> FIG. 1 is a system block diagram of an embodiment of the present invention. In the same figure, l is CP, U (central processing unit),
2 is a ROM (read-only memory), and the CPU I
Interprets and interprets various programs and high-level languages that control the operation of
Programs to be executed are stored. 3 is RA
M (readable/writable memory), in which the CPtJl work area, high-level language work area, data for execution of application programs created on the high-level language, etc. are stored. Reference numeral 4 represents an expansion RoM into which an application program is stored, and 5 represents a display memory. Information corresponding to the contents written here is displayed on a display 6. 7 is a human output boat, and 8 is a keyboard. And CPUI and RO
M 2, RAM 3, expansion ROM 4, display memory 5
! 3 and the input/output port are connected via a system bus 9, and the CPU reads and writes data to and from each via the system bus 9.

Next, a program execution control method to which the system with the above configuration is applied will be described, taking as an example the case of executing an inscriptor program in the Böhnschiff language.

In FIG. 2, program module A represents one module completed as an application program, and is stored in the expansion ROM 2, for example.

Furthermore, program modules B and C are newly created modules to replace a part of the command sentences constituting program module A with other command sentences, and are stored in the RAM 3 after the programs are created. In this example, two replacement program modules B and C are provided for the purpose of simplifying the explanation, but the present invention is not limited to this.

When executing a program, line numbers are assigned to each of these program modules A, B, and C in advance. The line number is set in hexadecimal notation between 0001 and FEFF in the order of program execution.Also, the first line of each program module A, B, and C has a line number and a separate line number. Attach a label to identify each program module.For example, program module ASB
.

Label each first line of C with α, β, γ, etc.

Furthermore, in order to transfer control from the execution of one program module to the execution of another program module, at least one line number of the corresponding command statements before and after replacement is designated in common. For example, in this example, as shown in FIG. 2, the statement at line number "30" of program module A is executed by program monologue B1. :W and execute it, specify the first line number of program module B as "30". Furthermore, if the instruction statement at line number "38" of program module B is to be executed by replacing it with program module C, the first line number of program module C is designated as "36".

To transfer execution control from one program module to another during program execution, a dedicated basic command statement is written in advance in a main routine program (not shown) and the command is given to the CPUI. There are four types of basic instructions:

■C0NTR0LL "Label 1" TO "Label 2" When executing a program module with label l, if the same line number as the one waiting for execution is in the program module with label 2, the corresponding line number of the program module with label 2 will be executed. Execution control is transferred to that line, and if the same line number is not in a program module with label 2, the program module with label l is executed. This command is valid only when the next command (■) is executed. For example, when transferring execution from program module A to program module B, C0NTR0LL"
Give the imperative sentence α”To”β”.

■C0NTR0LL “Label 1” ON When this command is executed, the command (■) becomes effective.

■ CON T ROL L "Label l" 5 TOP When this command is executed, the command (■) becomes invalid, but the contents declared in (■) remain valid, and when (■) is executed again, the command (■) becomes valid.

■C0NTR0LL “Label 1” OFF Clear ■ and ■.

When a program is executed, it is first in the command state of ■, and even if ■ is commanded many times, if ■ is not commanded, execution will not move between program modules. Furthermore, it is an error if Label 1 and Label 2 do not exist or if Label I and Label 2 are the same.

Figure 3 shows the R secured when executing the instructions from ■ to ■.
FIG. 2 is an explanatory diagram showing a work area secured within AMa. In the figure, a bit is set in the FON area when the instruction (3) is executed, and at this time, the corresponding bit in the FOFF area is cleared. Further, a bit is set in the FOFF area when the instruction (3) is executed, and at this time, the bit in the corresponding FON area is cleared.

The TAI area contains the starting address of the first line of the program module with the label 1, and the TA2 area contains the starting address of the first line of the program module with the label 2. Further, the maximum number N of combinations that can be used for each of the instructions ① to ② is predetermined, and all of them are cleared when the program is run. Note that when both the FON and FOFF bits are set, it indicates that execution has been moved between program modules.

FIG. 5 shows the main routine program with the command statement C0NTR0LL "label l"T.

If “Label 2” is entered, CP
This is a flowchart for the UI to perform preparation operations such as securing a work area in the RAM.

When there is an instruction (①), CPU I searches for label l (step 1) and determines whether label I exists (step 2).
. This search for label l is performed on program modules A1B and C stored in RAM3 and expansion ROM4. If label 1 does not exist, it is an error, and if label 1 does exist, it is determined whether it is in the first line of the program monologue (step 3). If it is not in the first line, proceed to an error. Next, it is determined whether label l has already been declared (step 4). The presence or absence of a declaration of label 1 is determined by searching whether there is a file in the TAI of the work area shown in Figure 3 that matches the first address corresponding to the first line of the program module labeled with label 1. . If the label l has not been declared, it is determined whether there is room to write the start address of the program module in the work area indicated by TAI in FIG. 3 (step 5). If there is no room, it is an error, and if there is space, the top part of the work area TAL that has not been filled out (here, TAL
TA of (mth work area counting from the top)
Write the start address of the program module with label 1 in 1m (Step 7). In step 4, label 1
If it has already been declared, clear the work area of TAI where label 1 is written (Step 6)
, if there is content declared after the work, it is moved to the front, and after clearing the undeclared area, the operation of step 7 is performed. Subsequently, search for label 2 (step 8), and determine the presence or absence of label 2 (step 9).
.

If label 2 does not exist, it is an error, and if label 2 exists, it is further determined whether label 2 is in the first line of the program module (step 10). If label 2 is not in the first line of the program module, it is an error; if it is in the first line, it is further determined whether label l and label 2 are the same (
Step 11). Label 2 determines whether both labels match or not.
The start address of the program module obtained as a result of the search is compared with the contents of the latest start address TA1m entered into the work area in FIG. 3, and if they match, they are the same label. If the two labels do not match, set the start address of the program module with label 2 to T in the work area.
Write at the corresponding position TA2m of A1m (step +2).

This completes the maintenance operation according to the command (Step 1).
3).

As a specific example, program module A in FIG.
, B, and C match the memory address (as explained below), C0NTR0LL"
If there is an instruction statement α"TO"β", the number "10" of the first line of program module A is stored in TAt of the work area in FIG. 3, and the number "10" of the first line of program module A is stored in TA2. 30” is memorized. Also, CON T
If there is an instruction statement ROL L “β” TO “γ”, program module B will be placed in the TAI of the work area in Figure 3.
The number "30" of the first line of the program module C is stored in TA2, and the number "36" of the first line of the program module C is stored in TA2. In addition,
In step [1, if label 1 and label 2 are the same, it means that the same program module is specified and an error occurs (step 15), but before that, step 7
Since the TAIm data has already been written to the work area, clear that work area (step 1).
4). Whether or not the instruction in (2) has been declared is determined based on the contents of TAI, so if data remains in part of the work area TA Im even though it is actually an error, a malfunction will occur, so it is necessary to prevent this. This is because there is.

FIG. 6 is a flowchart showing the preparatory operation of the CPU for the command CONT ROL L "LABEL 1" ON. When this command is received, CPU I first searches for label 1 (step 16) and determines whether label I exists (step 17). If label 1 does not exist, it is an error; if label 1 exists, then it is determined whether label 1 has already been declared in the ■ command statement (step 1
8). To determine whether it has already been declared, compare the starting address of the line with label 1 with the contents of TAI in the work area of FIG. 3, and if they match, it can be determined that it has been declared. Here, if it matches the mth work area in Figure 3, then F
The ONm bit is set, the FOFFm bit is reset (step 19), and the process ends (step 20).
). If they do not match in step 18, the process moves to an error handling routine (step 21).

Figure 7 is a flowchart showing the operation of the CPIJl in response to the C0NTR0LL "label 1" STOP command in ■. Figure 8 is a flowchart showing the operation of the CPU in response to the C0NTR0LL "label 1" OFF command in ■. . The difference from FIG. 6 is that there are steps 25 and 31 in place of step 19. In step 25 of Figure 7, set the FOFFm hint in the work area and
Reset the m bit. On the other hand, step 31 in FIG.
Now, clear the area written in the m-th label 1 of TAI, fill in any declared items after that, and clear all undeclared areas. The other operations are the same as in the case of FIG. 6, so the explanation will be omitted.

Next, automatic switching and movement of execution between program monocalls will be explained.

As shown in Figure 4(a), RAMa contains the address corresponding to the line number currently being executed, the address corresponding to the first line of the program module being executed, and the address corresponding to the first line of the program module being executed. A dedicated work area is reserved for storing the address of the execution line to return to when moved. Furthermore, since program module switching is executed by specifying a label, RAM
Inside, as shown in FIG. 4(b), a stack is separately reserved for storing the address of the first line of the program monologue after execution movement (automatic interrupt). This stack has N stages and is cleared when the program starts executing. This stack occupies l stacks with two pieces of information as one set.

Here, the [start address of the module being executed] loaded on the stack refers to the start address of the first line of the program module being executed immediately before the execution of the program module is moved from one side to the other. Furthermore, the term "start address of the module to be moved" refers to the start address of the first line of the program module to be moved. Furthermore, "JFLAG" is used here to determine whether execution has jumped from one line to another line by a basic command statement such as a GOTO statement or GOSUB.

This "JFLAG" is set when jumping,
Otherwise, it is reset when moving to a new line after the end of one line.

Figure 9 shows ■ CON T ROL L “Label 1” T
When the O “label 2” instruction and the ■ C0NTR0LL “label 1” ON instruction are both declared, 1
12 is a flowchart showing a control operation for switching execution between program modules when the execution of one line is finished and the next line is executed.

At the entrance of this flowchart, JFLAG is reset when execution of one instruction is completed and execution moves to the next line (step 33). Next, find the next line number (
Step 34). Furthermore, the first byte of the line number is FF.
It is determined whether it is a code (step 35). If there is an FF code, the process advances to step 36, where execution is forcibly terminated with execution transferred to another program module.

Therefore, when execution control transfer occurs between program modules, if you want to return execution to the original program module, assign a line number with a value greater than the line number of the return address to the end of each program module in advance. I'll keep it. However, when J FLAG=1, there is no specified line to jump to, so the process returns with error information.

In step 35, if there is no FF” code,
In order to determine whether the execution of the currently executing program module has been transferred from another program module, it is determined whether the stack stage number (interrupt stage number) is "0" or not (step 37). When the stack level is “0”,
Since execution is not moved between program modules, the process advances to step 39. If the number of stack levels is not "0", execution has already been moved between program modules, so next, the start address of the program module currently being executed in Figure 4(a) and Figure 4(b) ) is compared with the first address of the module to be moved that has been most recently placed on the stack (step 38). This is GOTO
This is to determine whether there is a jump command such as a sentence. If the two leading addresses do not match, a jump has occurred, and the process advances to step 39. If the two match, only execution movement between program modules is currently occurring. For example, if execution control has already been transferred from program module A to program module B,
The starting address of the currently executing module shown in a) is '30
", and the starting address of the latest module to be moved on the stack shown in FIG. 4(b) is also "30", and both match.

In step 39, it is determined whether the program module currently being executed is to be executed by the instructions ① and ②. This is determined by checking whether there is a program module in the TAI of the work area in FIG. 3 that matches the start address of the currently executing program module stored in FIG. 4(a). Ru.

If both match, the matched T
Check whether the FON at the position corresponding to AI is 15FOFF or 0. If that condition is met, we know that the program module being executed is the target of the commands ■ and ■, and then the module to be moved has the same line number as the next line. Determine whether it exists or not. For example, when the execution of line number "10" in program module A ends, there is no line with the same line number as the next line number "20" in program module B, so in that case automatic switching to program module B will not occur. Proceeding to step 53, the instruction of the next line number "20" is executed. On the other hand, line number “20” of program module A
”, the same line number as the next line number “30” exists in program module B, so in that case, a plan is made to transfer execution control to program module B from step 41 onwards. That is, , First, Fig. 4(b)
It is determined whether the stack shown in (step 41) has enough room.
).

If there is no margin, it is an error (step 54) and JFL
If AG is set, return with error information.

On the other hand, if there is room on the stack, the start address of the module currently being executed and the start address of the target module to which execution is to be switched are placed on the stack, as shown in Figure 4(b).
Step 42.43).

Then, the stack pointer is incremented by one (step 44). Briefly, in step 39, both the FON and FOFF flags located at the positions corresponding to the matched start addresses are set to indicate that movement is currently being executed (interrupts are currently being accepted). Next, for the work area of FIG. 4(a), set the start address of the destination program module obtained in step 40 as the execution address, and set the start address of the destination program module as the start address of the module being executed. After assigning each as an address and storing the address of the execution line to return to, the process returns to the progressive 34.

For example, when execution switches from line number "30" of program monoyl A to program module B, "IO" is placed in the stack of FIG. Information of "30" is loaded as the first address.

In addition, the start address "30" of the program module B to be moved to the work area of FIG. 4(a) is the execution address,
Then, they are assigned as the start address, and the address "40" of the execution line of the program module A to which the return destination is returned is stored.

In step 38, if it is determined that movement between program modules has occurred and the interrupt program module is being executed, check J FLAG and check JFLA
If G=O, it is determined whether the next line number of the currently executed line (which has already been obtained in step 34) exceeds the return destination line number (step 48).

For example, if the next line number is "100" after completing the execution of line number "38" in program module B, it will exceed line number "40" of program module A to return to, so in that case, It is determined that the interrupt control has ended, and preparations are made to return to the original program module from step 49 onwards. Also, in step 48, JPLAG=
If it is 1, search for the same line number to jump to. If not, proceed to step 53.

In step 49, the starting address of the monoyl currently being executed on the stack is set in the work area shown in FIG. 4(a) (step 49). Furthermore, the address of the return destination row number obtained in step 48 is entered as the execution address in the work area of FIG. 4(a) (step 50). For example, when returning execution from program monologue B to A, the start address of the program module currently being executed is set to “lO
”, and “40” is assigned as the address of the execution line.

Next, enter the TAL that is the same as the start address of the program module being executed (lO” in the above example) returned in step 4.
If there is, set the PON in the corresponding position,
FoFF is reset (step 51).

This may be cleared by the instruction (■) during interrupt processing, and in this case, the corresponding TAI does not exist, so the flag is not set. Next, after returning the number of stack levels by one, the process advances to step 34.

In step 53, when JFLAG=O, the next instruction is executed, and when Jr'LAG=1, it is a specified line search subroutine to be described later, so the process returns.

Next, the command statement for basic (GOT 0 statement, GO9UB
FIG. 11 shows a specified line search subroutine when jumping to another line or module line.

When there is a jump instruction, etc., first, among the information currently being executed, the execution address and the start address of the module being executed are temporarily saved (step 54), and JFLAG is set (
Step 55). Then search for the specified line number (
Step 56). This search starts from the beginning of the memory when the line number is specified by a label, and if it does not exist in one program module, searches for the next other program module. On the other hand, when the specification is a line number,
Search from the first line of the program module currently being executed. Next, if there is no specified line, the process proceeds to step 60, where the error information is returned as 6. If the specified line is found, the starting address of the program monologue containing the specified line is moved to the starting address of the module being executed (step 58), and the starting address of the specified line is moved to the execution address (step 59). ). After this preparation is completed, the entire control program from step 34 to step 54 shown in FIG. 9 is called as a subroutine (step 60). If an error occurs during execution of the flowchart in FIG. 9 (step 61), the process advances to step 62 and returns with error information. If no error has occurred, enter the execution address of the program module obtained in step 6.degree. and its start address into the work area shown in FIG. 4(a) (step 63). Then, restore the information temporarily saved in step 54 (step 64)
.

Note that among basic command statements, when a line specification is not required, such as in a RUN statement, the first line of the program monologue to be executed from now on is the search target in the line number search in step 56.

Effects> As described above, according to the present invention, a part of the routine of an application program that has been completed in advance can be arbitrarily modified and executed, so that the program can be made versatile, and furthermore, Creating programs becomes easier. Furthermore, since the storage capacity required to be stored in the RAM is small, there is an advantage that memory can be saved.

[Brief explanation of drawings]

The drawings show an embodiment of the present invention, and FIG. 1 is a system block diagram for carrying out a program execution control method according to the embodiment of the present invention, FIG. 2 is an explanatory diagram of a program module, and FIG.
5 and 4 are explanatory diagrams schematically showing the work area in the RAM, FIGS. 5 to 8 are flowcharts of the preparation operation of the CPU in response to instructions for program execution control, and FIG.
This figure is a flowchart showing a control operation for transferring execution between program modules, and FIG. 1O is a flowchart showing a search routine for a designated line when jumping to another line number with a basic statement. ! ...CPU, 2...ROM, 3...RAM, 4
...Expansion ROM 0 Figure 1 (Figure 077 of implementation column) Figure 2 (Figure 318 of program module) Figure 3 (S front diagram of the wharf area in RAM) Figure 4 (RAM Figure 10 Figure 6 (70-+ yards of command statement ■) Figure 7 (Flowchart of command statement ■) Figure 8 (Command statement ■) Sentence ■ flowchart)

Claims (1)

[Claims] (1) In a high-level language with line numbers, for one completed program module, create a separate program module for replacing part of the imperative statements that make up that module with other imperative statements, A unique label is attached to each of these program modules, and at least one line number of the corresponding statement before and after replacement is commonly specified, and a movement instruction from one label to the other label is used when the program is executed. When a program module is replaced, a soft interrupt is generated to determine whether or not there is a common line number corresponding to the program module after replacement in the program module before replacement.
A program execution control method characterized by passing control to a replacement program module when a corresponding line number exists, and returning control to the original program module after the program module is executed.