JPH08194624A - Executing form program preparing method - Google Patents

Abstract

PURPOSE: To execute a suffix range check or the like at high speed by providing the suffix range check of arranged elements included in a DO loop and the check of non-defined arranged elements or parameters outside the DO loop. CONSTITUTION: An intermediate text generating part 11 of a translating part 10 prepares an intermediate text by translating a source program 1 including the repeating processing of the DO loop or the like. In that case, a repetition information table preparing part 12 requires the repeating processing of the DO loop or the like included in the intermediate text and prepares a repetition information table 13 including the start value and end value or the like of repeating processing from its description. Further, an inspection means inserting instruction preparing part 14 prepares an instruction for inserting an inspection means to the intermediate text and when the operator of addition or multiplication is not included in the arranged elements to be used for repeating elements, the inspection means is arranged outside the repeating processing. Thus, the inspection of arranged elements or parameters included in the repeating processing of the DO loop or the like can be processed at high speed.

Description

Detailed Description of the Invention

The present invention relates to a method for creating an executable program generated by compiling a source program,
In particular, the present invention relates to a method of creating an executable program that processes at high speed an inspection of a subscript range of an array or the like, or an inspection of an undefined array or an undefined variable.

A high-level programming language such as FORTRAN is a subscript for checking whether or not an array element used in a process is within a defined array size with respect to an intermediate text generated by a compiler. Range check (generally supported by SUBCHK in FORTRAN), or undefined variable check (in FORTRAN, which checks whether the right side of an assignment statement or the output of a WRITE statement without describing an array or variable and whether or not it is described) (Generally supported in UNDEF).

When subscript checking or undefined checking is performed on an array element, variable, etc. used in a repetitive process such as a DO loop in a source program, SUBCHK, UNDEF, etc. are incorporated in the DO loop. ， It took a long time to check the program at the time of execution.

The present invention provides an executable program capable of processing subscript range check or undefined variable check at high speed.

[0005]

2. Description of the Related Art FIG. 9 is an explanatory diagram 1 of the prior art, in which F
The case of ORTRAN77 is shown. In FIG. 9, 200
Is an example of a source program and is a description of a DO loop.

Reference numeral 201 denotes an instruction sequence generated by compiling, which is a SUBC for the source program 200.
Check subscript range of array by specifying HK and UNDEF,
It is an executable program generated when compiling to check undefined variables.

FIG. 10 is an explanatory view 2 of the prior art. FIG. 10 shows an array parameter list used in the DO loop. Reference numeral 220 denotes a parameter list, which is a pointer of the array name, a declaration part of the array A (A is an array name) (indicating that the minimum value of the array is 1 and the maximum value is 100), and the value of the subscript expression (I ) Is stored in the area.
The value I of the subscript expression is a value from 1 to 100. Otherwise, an error will occur during execution.

Reference numeral 221 denotes an area for the name of the array A, which is designated by the pointer for the array name in the parameter list 220. Has a pointer to the area to which the array is allocated. Reference numeral 222 denotes an allocation area of the array A, which is designated by the pointer of the area 221 of the array name A.

The operation of the program shown in FIG. 9 will be described. For the description of the DO loop of the source program 200, S
When the UBCHK and UNDEF are designated and compiled, the executable program 201 is created.

CALL SUBCHK (A (I)) is an instruction to call SUBCHK. CALL UND
EF (B (I)) is an instruction to call UNDEF. t1 is a temporary generated by the compiler.

When the executable program 201 is executed,
When I = 1 to 50 in the processing of the DO loop, A (I), B (I), and C (I) are defined for each value taken by I, arrays 1 to 100 of A, and arrays 1 to 100 of B. , C sequences 1-1
00 is checked with SUBCHK. Also, it is checked in UNDEF whether or not B and C on the right side of the arithmetic expression A = B + C are within the defined range. Then, in SUBCHK, an array whose subscript is out of the defined range (for example, array (101)) is generated,
In UNDEF, if an undefined array element name or variable name exists on the right side of an assignment statement, or if it is undefined and is output and used in a WRITE statement, it is treated as an error.
An error message is output during execution.

[0012]

The conventional subscript range check and undefined variable check are, for example, when inspecting array elements and variables used in a repetitive process such as a DO loop.
The inspection means is incorporated in the DO loop. for that reason,
Since the array elements sequentially specified in the DO loop were compared with the defined range, the execution process took a long time.

According to the present invention, a subscript range check (SUBCHK) of array elements included in a DO loop, undefined array element names (A (I), B (I), C (I), etc.), variable names or arrays An object of the present invention is to provide a method of creating an executable program capable of processing an element inspection (UNDEF) at high speed.

[0014]

The present invention provides a subscript range check and an undefined range check by providing a subscript range check for array elements included in a DO loop and a check for undefined array elements and variables outside the DO loop. Enabled to check array elements and variables of in high speed.

Before explaining the basic configuration of the present invention shown in FIG.
The subscript formula of the present invention will be described with reference to FIG. 11 (an explanatory diagram of the technique of the present invention). In FIG. 11, 230 is a parameter list. The difference from the parameter list in FIG. 10 is that the start value, end value, and increment value of the DO loop are included in the value part of the subscript expression.

Reference numeral 231 is an area for the name of the array A. 23
2 is an allocation area of the array A. FIG. 1 shows the basic configuration of the present invention.

In FIG. 1, reference numeral 1 is a source program, which includes repetitive processing such as a DO loop.

Reference numeral 2 represents the description of the definition (definition range) of the processing element A. 3 represents the description of the iterative process including the element A (including the start value, the end value, etc. of the DO loop).

A translation unit 10 translates (compiles) the source program 1 into an executable program. Reference numeral 11 denotes an intermediate text generation unit that creates a translated intermediate text.

Reference numeral 12 denotes a repetitive information table creating section for creating a repetitive information table including a start value and an end value of the repetitive processing. Reference numeral 13 is a repetition information table.

Reference numeral 14 is an inspection means insertion command preparation section,
An instruction for calling the inspection means is created from the inspection means holding unit 15. Reference numeral 15 denotes an inspection means holding unit, which holds inspection programs such as subscript range checking, undefined array element and variable checking.

Reference numeral 16 denotes an execution format program creating section for connecting a plurality of intermediate texts and incorporating a checking means in the intermediate texts. Reference numeral 21 is an inspection means that can inspect the start value, end value, and increment value of repeated processing such as array definition range inspection (for example, SU
BCHK). Alternatively, an undefined array element that can be inspected by comparing with an initial value (default value), a variable check, or the like (for example, UNDEF) is performed.

Reference numeral 22 is an execution format program for repetitive processing. Reference numeral 23 is a repetitive information holding unit, which holds repetitive information fetched from the repetitive information table 13.

[0024]

The operation of the basic configuration of the present invention shown in FIG. 1 will be described. The translation unit 10 inputs the source program 1. Then, the intermediate text generation unit 11 translates the source program 1,
Create intermediate text. At that time, the repetition information table creating unit 12 obtains the repetition processing such as the DO loop included in the intermediate text, and creates the repetition information table 13 including the start value and the end value of the repetition processing from the description. Further, the checking means insertion command creating unit 14 creates a command for inserting the checking means into the intermediate text. At that time, if the array element used in the repeating element does not include an operator such as addition or multiplication, the checking means is arranged outside the repeating process.

The execution format program creation unit 16 combines a plurality of intermediate texts, extracts the inspection means from the inspection means holding unit 15 based on the inspection means insertion command, inserts the inspection means at the designated location, and executes the execution format. Create a program.

When the executable program 20 is executed,
The checking unit 21 refers to the start value and the end value of the iterative process included in the iterative information holding unit 23, and determines whether the range of the array generated in the execution process is within the defined range, or The inspection of undefined variables is also judged based on whether the initial value of variable definition (default value of variable) is changed. Further, a program such as the execution format program 22 of the repetitive processing is executed. If an error is judged by the judgment result of the inspection of the inspection means 21, the error is displayed.

According to the present invention, the inspection of array elements, variables, etc. included in the repetitive processing such as DO loop can be processed at high speed. The present invention is described below in FORTRAN.
The DO statement (loop) will be described as an example.
The present invention can also be applied to other languages such as a loop by the WHERE statement of the ORTRAN 90, a FOR statement of C language, or repetitive processing.

[0028]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 2 shows the configuration of an embodiment of execution format program creating means of the present invention. In FIG. 2, 1 is a source program.

Reference numeral 5 is an executable program creating means (generally called a combiner). 1
Reference numeral 6 denotes an execution format program creation unit (which generally performs a combined edit process).

Reference numeral 20 is an executable program (load module). Reference numeral 30 denotes a syntactic analysis unit, which performs lexical analysis and syntactic analysis of the source program to create an intermediate text. Also, a flag is added to the intermediate text including the DO loop (nested (NE
(ST) may be instructed). Then, in the syntax analysis unit, the DO loop information creation unit (corresponding to the repetition information table creation unit in FIG. 1) identifies the DO loop by the flag or the nested identifier (NEST), and creates the DO loop information table.

Reference numeral 31 denotes a semantic analysis unit, which performs semantic analysis on the intermediate text (identification of operators, assignment statements, etc.), and a range S
UBCHK (means for checking array element range outside array loop) or element SUBCHK
An instruction to insert (means for checking the range check of array elements in a DO loop (conventional SUBCHK)) is created. The same applies to UNDEF. Either the range UNDEF (a means for collectively checking whether it is undefined outside the DO loop) is placed outside the DO loop statement, or the element UNDEF (same as the conventional UNDEF) is set to the DO loop statement. Create in. (Hereafter, the range SUBCH
K and the element SUBCHK are explained, but the range UND
The same applies to the EF and the element UNDEF, and therefore omitted.)

Reference numeral 32 denotes an address allocating unit, which allocates areas (addresses) to variables, constants, arrays and the like. Also, the parameter list of the array used in the DO loop (corresponding to the information held in the repeated information holding unit in FIG. 1) is created and the addresses are assigned.

(The intermediate text generation unit and the repetition information table generation unit in FIG. 1 are included in the structure including the syntax analysis unit 30 and the semantic analysis unit 31). A code generation unit 33 (corresponding to the inspection means insertion instruction creation unit in FIG. 1) is for allocating registers and converting the intermediate text into hard instructions (machine language instructions). Also, the range S
A library call instruction having respective checking means is created from the intermediate text of UBCHK and element SUBCHK.

Reference numeral 34 is a library (corresponding to the inspection means holding unit in FIG. 1), which has a range SUBCHK and an element SUBC.
It has the function of HK and is combined when combining and editing. FIG. 3 shows an embodiment of the syntactic analysis unit.

In FIG. 3, reference numeral 30 is a syntax analysis unit.
40 is an intermediate text creation unit.

Reference numerals 41, 42, and 43 are the intermediate text 1, the intermediate text 2, and the DO loop intermediate text 43 created by the intermediate text creating unit 40, respectively. 44 is DO
Represents the intermediate text of a loop and has a flag. NEST (nested identifier) may be provided instead of the flag.

Reference numeral 50 is a DO loop information table,
NEXT, DO indicating the next DO loop information table 51
Data that specifies the constant table with the loop start value, end value, and increment value, the start sequence number of the DO loop statement,
It has the final sequence number of the DO loop statement (see the source program 1 of FIG. 1 for the start sequence number and the final sequence number of the DO loop statement). DO
The range of the DO loop statement is detected by the start sequence number and the final sequence number of the loop statement.

Reference numeral 51 is the next DO loop information table. A constant table 52 has a start value, an end value, and an increment value (standard is 1) specified in the DO loop information table 50.

FIG. 4 shows an embodiment of the semantic analysis unit of the present invention. In FIG. 4, 31 is a semantic analysis unit.

Reference numeral 60 is a SUBCHK setting means. 61
Is a range SUBCHK (means for checking the range of array elements outside the DO loop statement) or element SU
It is determined whether an instruction to insert BCHK (a means for checking the array element range check in the DO loop portion) is created.

Reference numeral 62 denotes a SUBCHK insertion instruction preparation section, which is used for the area SUBSK at a position requiring the area SUBCHK.
An instruction to call HK is created, and an instruction to call the element SUBCHK is created at a place where the element SUBCHK is required.

Reference numeral 63 is an intermediate text, which represents the intermediate text generated by the semantic analysis unit. 64 is the range SUBC
This is an HK insertion instruction. Reference numeral 65 represents the description of the DO loop processing start line.

Reference numeral 66 is an element SUBCHK insertion instruction.
67 represents the description of the DO loop processing end line. In the configuration of FIG. 4, the SUBCHK insertion instruction creation unit determines whether or not the subscript expression of the intermediate text of the DO loop is a simple expression (for example, when it is composed of only variables or constants),
If it is a simple expression, an instruction for extracting the range SUBCHK is created so that the range SUBCHK is arranged outside the DO loop. Also, if the subscript expression of the intermediate text of the DO loop is complicated, the SUBCHK insertion instruction creation unit will write the element SU.
The element SU so that BCHK is placed in the DO loop
Create an instruction to retrieve BCHK.

The intermediate text 63 shows the arrangement of the range SUBCHK and the element SUBCHK thus arranged. The range SUBCHK is placed outside the DO loop and the element SUBCHK is placed inside the DO loop.

FIG. 5 shows an example of the source program and intermediate text of the present invention. In FIG. 5, 1 is an example of a source program, which is a description of a DO loop.

Reference numeral 70 denotes an intermediate text, which is SUBCH
The source program 1 is translated by designating K. Reference numeral 71 is an insertion of a calling instruction in the range SUBCHK (HSUBCHK).

72 is an element SUBCHK (YSUBCH
K) is a call instruction insertion. Sequence A (I), C
Since the subscript range check of the array of (I) does not include an operator in the element, the calling instruction "CALL of the range SUBCHK
HSUBCHK (A, 1,100,1,50,
1) ”,“ CALL HSUBCHK (C, 1, 10
0, 1, 50, 1) ”is arranged so as to be arranged outside the repetitive processing (strictly speaking, the instruction also includes the attribute and the number of dimensions, but this description is omitted).

Since the subscript expression (I + 1) of the array B (I) is not a simple expression in the SUBCHK of the array B (I), the calling instruction "CALL YSUBCHK (B, 1,1) of the element SUBCHK is performed.
00, t1) ", so that they are arranged in the repetitive processing.

FIG. 6 is a flow chart of an embodiment of the execution format program creating means of the present invention. Enter the S1 source program.

The S2 syntactic analysis unit performs lexical analysis and syntactic analysis of the source program to create an intermediate text. Then, a flag or a nested identifier (N
EST) is added.

The S3 syntax analysis section creates a DO loop information table. S4 The semantic analysis unit performs semantic analysis based on the intermediate text created by the syntax analysis unit.

S5, S6 The semantic analysis section determines whether or not the user has designated to include SUBCHK and UNDEF in the executable program. SUBCHK, U
If NDEF is specified, the process proceeds to S7, and if not, the process proceeds to S10.

S7: It is determined whether the repeating element of the intermediate text of the DO loop is a simple expression. If it is a simple expression, proceed to S8, and if not, proceed to S9. S8 The semantic analysis part is outside the DO loop and the range SUBCH
Insert K, (and / or range UNDEF) call instructions. If necessary, a calling instruction for the range UNDEF is also inserted. Or, instead of the range SUBCHK,
Only the instruction to call the range UNDEF may be used.

S9 The semantic analysis unit inserts a calling instruction for the element SUBCHK, (and / or the element UNDEF) in the DO loop. Element UNDEF if necessary
Also insert the call command of. Or the element SUBCH
Instead of K, only the instruction to call the element UNDEF may be used.

The address allocating section at S10 allocates addresses (areas) to variables, constants and arrays. The parameter list of the array used in the S11 DO loop is created and the addresses are assigned. At this time, parameters such as the DO loop start value, end value, and increment are fetched from the DO loop information table.

S12: Initial values for detecting undefined arrays and undefined variables are set in the elements. S13 Register allocation is performed and the intermediate text is converted into a hard instruction. S14 A library call instruction having respective checking means is created from the intermediate text of the range SUBCHK and the element SUBCHK.

The example shows an example of the instruction sequence. "LA
“1, parameter list” is an instruction to set the parameter list in the register 1. "L 15, = V (range SU
"BCHK)" is an instruction to set an address in the register 15 having a checking means of the range SUBCHK name. "BAL
“R 14, 15” is an instruction to branch to the address set in the register 15 and return to the address set in the register 14 when the processing is completed.

DC is an instruction to instruct setting of the "attribute" and the "number of dimensions" in which the length (L) of the hexadecimal number (X) is 1 byte in the parameter list. In step S15, the execution format program creating unit combines and edits the intermediate texts. At this time, range SUBCHK, element SU
Incorporate BCHK into the intermediate text.

S16 The executable program is output. After that, range SUBCHK, element SUBCHK, range UN
Executes an executable program that includes DEF and element UNDEF. The range SUBCHK then compares the start and end values of the DO loop with the minimum and maximum numbers in the array definition, respectively. If the start value of the DO loop is larger than the minimum value of the array and the end value of the DO loop is smaller than the maximum value of the array definition, it is determined that the array generated by the DO loop is correct.

For example, in the case of the source program 1 in FIG. 5, since the start value of the DO loop is 1 and the end value is 50, it is in the range of the minimum value A (1) and A (100) of the array definition. Is said to be correct. However, if the initial value of the DO loop is I = 0, the minimum value of the array is A
It is an error because it is (1). If the end value of the DO loop is 101, the maximum value of the array is A (100), which is outside the array definition range and an error is generated.

In the range UNDEF check, the initial value (default) of the array or variable is set to a value that is not commonly used, and if the array or variable is defined, the value is changed. By the initial stage of the array or the variable, it is possible to perform an unscheduled array and the existence of the variable (UNDEF). Also, the range UND
The range of the subscript of the array in EF is performed by comparing the initial value and the end value of the DO loop with the minimum value and the maximum value of the array definition as in the range SUBCHK.

When an error-free execution format program is created in this way, the execution format program that does not include the inspection means is created by designating no inspection and recompiling.

[0063]

According to the present invention, the inspection of array elements, variables, etc. included in the repetitive processing such as DO loop can be processed at high speed. Therefore, it becomes possible to compile efficiently.

[Brief description of drawings]

FIG. 1 is a diagram showing a basic configuration of the present invention.

FIG. 2 is a diagram showing an embodiment configuration of an execution format program creating means of the present invention.

FIG. 3 is a diagram showing an embodiment of a syntax analysis unit of the present invention.

FIG. 4 is a diagram showing an embodiment of a semantic analysis unit of the present invention.

FIG. 5 is a diagram showing an example of a source program and intermediate text of the present invention.

FIG. 6 is a diagram showing a flowchart of an execution format program creating means of an embodiment of the present invention.

FIG. 7 is a diagram showing a flowchart of an execution format program creating means of an embodiment of the present invention.

FIG. 8 is a diagram showing a flowchart of an execution format program creating means of an embodiment of the present invention.

FIG. 9 is an explanatory diagram 1 of a conventional technique.

FIG. 10 is an explanatory diagram 2 of a conventional technique.

FIG. 11 is an explanatory diagram of the technique of the present invention.

[Explanation of symbols]

 1: Source program 2: Definition of processing element A (definition range) 3: Repeat processing including element A (start value, end value) 10: Translation part 11: Intermediate text generation part 12: Repeat information table creation part 13: Repetition information table 14: Checking means insertion command creating section 15: Checking means holding section 16: Execution format program creating section 20: Execution format program 22: Execution format program of repetition processing 23: Repeating information holding section

Claims (4)

[Claims] 1. A method for creating an executable format program capable of checking a program by an executable format program creating means comprising a translation section of a source program and an inspecting section for inspecting the translated program, wherein the translation section analyzes the source program. To generate an intermediate text, obtain an iterative process in the intermediate text, and inspect the element with only the start value or the end value of the iterative process, the means for inspecting the element is provided outside the iterative process. How to make. 2. The method according to claim 1, wherein it is determined whether or not the expression is a simple expression, and if the expression is a simple expression, the checking means is inserted outside the iterative processing. A method for creating an executable program, characterized in that the inspection means inserted inside and inserted into the repetitive processing inspects the element for each repetitive processing. 3. The repetitive process according to claim 1 or 2, wherein the repetitive process is a DO loop, an information table including a start value and an end value of the DO loop is created, and the element is an array element and is provided outside the repetitive process. The checking means compares the start value and the end value of the information table with the minimum value and the maximum value of the array definition, respectively, and the subscript range of the array processed by the DO loop is included in the subscript range of the defined array. A method of creating an executable program, characterized by inspecting whether or not it is a thing. 4. The element used in the iterative process according to claim 1 or 2, is an array or variable to be assigned to the right side of an assignment statement, or a description of an output sequence of a WRITE statement, and the checking means is its definition range or definition. A method for creating an executable program, characterized by inspecting the presence or absence of [Industrial applications]