JPH0776928B2 - USE procedure processing method in COBOL compiler - Google Patents

Description

[Detailed Description of the Invention] [Outline] In the object expansion of the USE procedure in the COBOL source program, two types of entrances, a first entrance and a second entrance, are provided, and jumps are made corresponding to these entrances, respectively. US used as an error exit by expanding instructions that perform return by instruction and return by return instruction
The E procedure can be referred to from the PERFORM command.

[Industrial application field]

The present invention is a U in the COBOL language, which is one of the computer languages.
It relates to the USE procedure processing method in the COBOL compiler that makes it possible to refer to the SE procedure from the PERFORM instruction.

[Conventional technology]

Fig. 4 is an explanatory diagram of conventional USE object expansion, and Fig. 5 is P
FIG. 6 is an explanatory diagram of the ERFORM instruction, and FIG. 6 is an explanatory diagram of a conventional PERFORM execution logic.

In the COBOL language, I / O commands (OPEN, READ, WRITE, REWRITE
And DELETE command), the processing procedure when an error occurs can be defined using the USE command.

As shown in FIG. 4, the USE procedure U1 returns control to the caller at the end of the object expansion of the USE procedure, considering that it is called by the call (CALL) instruction from the library 30 that performs input / output processing. You must expand the return (RET) instruction for.

By the way, in the conventional object expansion format, it was not possible to call the "USE procedure" with the PERFORM instruction. this is,
This is because it is a problem if the RET instruction is expanded at the exit of the procedure targeted by the PERFORM instruction.

The reason will be described with reference to FIG. PERFOR
The M instruction is generally used as shown in (1) and (2) of FIG.

If the CALL command is used for object expansion of this PERFORM command, the RET command for returning control must be expanded at the exit of the PERFORM command. In FIG. 5, the procedure B exit (3) and the procedure C exit (4)
Then, it is necessary to expand the RET instruction.

Here, PERFORM on the source program of Fig. 5 (1)
Consider the operation at the time of execution by describing the instruction. First, control is transferred to procedure A by the CALL command. After that, procedure B
Is executed, and control is returned by the RET instruction at the exit (3) of procedure B. Therefore, the process of the next required procedure C is not performed.

As can be seen from this example, the conclusion is that the PERFORM instruction cannot be expanded using the CALL instruction.

The actual expansion format of the PERFORM instruction is adapted to realize the execution logic shown in FIG.

The COBOL compiler prepares a return address area 41 for each procedure name that is the exit of the PERFORM instruction. In addition,
The initial value of the return address area 41 is the address of the next instruction, that is, the address of the instruction of the procedure name P2 in this example.
Then, object expansion that realizes the following execution logic is performed.

First, the contents of the return address area 41 corresponding to the exit of the procedure are saved in the return address save area 40 corresponding to the PERFORM instruction.

The return address (the address of the process in the object of the PERFORM instruction) is set in the return address area 41.

The jump (JMP) instruction transfers control to procedure name P1.

 Executes the P1 procedure instruction.

The jump instruction transfers control to the return address set in the return address area 41.

The contents set in the return address save area 40 are restored in the return address area 41.

[Problems to be solved by the invention]

As described above, the object expansion of the PERFORM instruction is
According to the conventional method, the USE procedure that returns control with the RET instruction cannot be referenced with the PERFORM instruction because it cannot be performed with an instruction. Therefore, there is a problem that the message output performed when an error occurs and other processing procedures by the USE procedure cannot be used by the PERFORM instruction during normal operation.

If the USE procedure can be used by referring to the PERFORM command, when the same processing is required in relation to error processing, duplicated processing description can be eliminated and unified error processing that can be easily changed can be realized. it is conceivable that.

It is an object of the present invention to solve the above problems and to provide a means for calling a USE procedure with a PERFORM instruction without changing the library for input / output processing as in the conventional case.

[Means for solving problems]

 FIG. 1 is an explanatory view of the principle of the present invention.

In Fig. 1, 10 is a COBOL source program written in COBOL, 11 is a processing unit consisting of a CPU and memory, 12 is a COBOL compiler that converts the COBOL source program 10 into machine language code, and 13 is a grammatical error. A parsing unit for generating an intermediate text by performing a check or the like, 14 is an intermediate text represented by an internal code based on a result of the parsing, 15 is an object expanding unit for generating a code, and 16 is an object program as a compilation result.

S1 and S2 in the COBOL source program 10 are definition statements of the USE procedure. Here, the calling condition and the like can be specified. U1 and U2 are USE procedures that are called from a library (not shown) and executed when an error of the conditions specified by S1 and S2 occurs. S3 is PERFORM
It is an instruction.

The syntactic analysis unit 13 inputs the COBOL source program 10, checks for grammatical errors, etc., and outputs the result to the intermediate text 14
Output as. The object expansion unit 15 inputs the intermediate text 14 and generates an object program 16 as shown in FIG. 1 particularly for the USE procedure.

In the object program 16, E11 and E21 are PERFORM
Instruction entry ports E12 and E22 are entry points from the library that performs input / output processing. In the present invention, two entrances are thus provided for each USE procedure.

OB1 and OB2 are object bodies of the A USE procedure and the B USE procedure, respectively. After executing A's USE procedure OB1 for the first A entrance E11, a jump (JMP) instruction i
Control is returned by 11 to the second E'inlet E12,
After execution of the USE procedure OB1 of A, control is finally returned to the caller by the return (RET) instruction i12. The same applies to B's USE procedure OB2.

20a and 20b are USE return address areas provided for each USE procedure, and are used for branch control of the USE procedure.
21a and 21b are USE return address save areas, which are used as USE return address save areas.

[Action]

According to the object expansion of the USE procedure according to the present invention, PE
When referring to the USE procedure OB1 from the RFORM instruction, control is transferred to the first entrance E11, and the control is returned by the JMP instruction i11. On the other hand, when calling from the library that performs input / output processing, it is necessary to return by the RET instruction, so control is transferred from the library to the second entrance E12, and finally by the RET instruction i12, the calling source Control is returned to a library. Therefore, the USE procedure can be commonly referenced from both the library and the PERFORM instruction.

〔Example〕

2 and 3 are diagrams for explaining the execution logic of the USE procedure according to the embodiment of the present invention.

The processing of the object program 16 relating to the USE procedure generated by the object expanding unit 15 shown in FIG. 1 will be described below with reference to FIGS. 2 and 3.

FIG. 2 shows an example in which the USE procedure is called by the CALL instruction from the library 30.

In the library 30 that processes input / output instructions such as OPEN, READ, WRITE, REWRITE and DELETE instructions, when an error occurs, the USE procedure defined in the program is called by the CALL instruction. Hereinafter, the description will be given according to the numbers 1 to 3 shown in FIG.

The control transfer destination by the CALL instruction of the library is the second entrance of the USE procedure. For example, if the USE procedure OB1 of A is specified as the error processing of the OPEN instruction, the control is executed at the second entrance A '. Cross

USE return address area provided for USE procedure
In 20a, as the initial value, since the USE procedure by the PERFORM instruction is continuously executed, the instruction address next to the end of the USE procedure on the source program, that is, the USE of B in this case.
The start address of procedure OB2 is set. This USE return address is saved in the USE return address save area 21a.

The address indicated by α for returning to the processing is set in the USE return address area 20a.

JMP instruction branches to USE procedure OB1 of A, and US
E Perform procedure processing.

After the execution of the USE procedure, a JMP instruction is used to branch to the contents (α) of the USE return address area 20a.

The value of the USE return address save area 21a is transferred to the USE return address area 20a to restore the return address.

 The RET instruction returns to the library 30.

Figure 3 shows the USE procedure of A and the U of B by the PERFORM command.
It shows an example where SE procedures are referenced continuously. The PERFORM instruction branches to the USE procedure with the JMP instruction. Hereinafter, the description will be given according to the numbers 1 to 3 shown in FIG.

In the object of the instruction of "PERFORM A THROUGH B.", first, the contents of the USE return address area 20b provided for the USE procedure of B finally executed are saved in the return address save area 40 for this PERFORM instruction. To do. In the USE return address area 20b, the address of the next instruction (address of C) is set as an initial value.

The start address (β) of the process is set as the return address in the USE return address area 20b.

The JMP instruction branches to the first entrance A and performs the USE procedure OB1 of A.

The process branches to the address set as the initial value of the USE return address area 20a, that is, the start address of the next B USE procedure, and the B USE procedure OB2 is processed.

Branches to the address (β position) set in the USE return address area 20b.

The value saved in the return address save area 40 is copied and restored in the USE return address area 20b.

As can be seen from the examples in Figs. 2 and 3, even when the USE procedure is called from the library, the U
Even when the SE procedure is called, the processing of the common USE procedure can be performed, and control can be returned to the caller by the RET and JMP instructions, respectively.

〔The invention's effect〕

As described above, according to the present invention, the USE procedure can be referenced from both the library and the PERFORM instruction, and the description of the COBOL source program can be simplified. In addition, it becomes easy to change the processing related to the error occurrence, and since the duplicated programs can be deleted, the object program can be downsized.

[Brief description of drawings]

FIG. 1 is a diagram for explaining the principle of the present invention, FIGS. 2 and 3 are diagrams for explaining the execution logic of a USE procedure according to an embodiment of the present invention, and FIG. 4 is a diagram for explaining a conventional USE object expansion. , Fig. 5 is an explanatory diagram of the PERFORM instruction, and Fig. 6 is a conventional PERFO.
It is an RM execution logic explanatory view. In the figure, 10 is a COBOL source program, 11 is a processing unit, and 12 is a CO.
BOL compiler, 13 is syntactic analysis part, 14 is intermediate text, 15 is object expansion part, 16 is object program, E11,
E21 is the first entrance, E12 and E22 are the second entrance, i11 and i21 are jump instructions, i12 and i22 are return instructions, 20a and 20b are USE return address areas, and 21a and 21b are USE return address save areas. .

Claims (1)

[Claims] 1. A COBOL compiler (1 that translates a COBOL source program (10) into an object program (16)
In the USE procedure processing method in 2), in the object expansion of the USE procedure, the first entrance (E11, E12) called by the jump instruction in the object expansion of the PERFORM instruction and the call instruction from the library that performs the input / output processing are called. Second entrance (E12, E2
2) and a jump instruction (i11, i21) to the address set in the specified return address area (20a, 20b) provided corresponding to the USE procedure after the main body of the USE procedure. For the control transfer from the above to the second entrance, after setting the address of the restoration processing unit including the return instruction (i12, i22) in the restoration address area (20a, 20b), the main body of the USE procedure To the caller library by returning to the calling source library by the return instruction (i12, i22) at the end of the execution of the USE procedure, and the return address area is previously set for the control transfer from the PERFORM instruction to the first entrance. The object is expanded by returning to the address set in (20a, 20b) by a jump instruction (i11, i21), and the USE procedure can be referenced from both the library and the PERFORM instruction. USE procedure processing method in a COBOL compiler.