JPS58169637A - Compile processing system - Google Patents

Abstract

PURPOSE:To ensure a quick compiling process, by carrying out simultaneously both an error correction of a high-class language part and error correction of an assembler language part. CONSTITUTION:A source program of a high-class language containing an assembler language is fed to a scanning part 3. A sentence structure analyzing part 4 analyzes a sentence structure, and a describing part of the assembler language is detected. An assemble language sentence processing part 7 checks errors of the assmebler language set into a high-class language and then delivers the error information onto a compiling list 10 via a list output part 9 in case an error is detected.

Description

DETAILED DESCRIPTION OF THE INVENTION (1) Technical Field of the Invention The present invention relates to a compile processing method, a combination compile processing method for a high-level language for electronic computers that can write an assembly language description in q#. ) Background of the Technology Electronic computers perform desired data processing by sequentially fetching and executing machine language instructions consisting of combinations of "0" and "1". There is an assembler language as a language at a level that encodes these machine language instructions.By writing the program in an assembler language and processing the program with the assembler, a target program of machine language instructions is generated.

On the other hand, languages created to be easy for humans to understand9 include FORTRAN and COBOL.

PL/I There are other high-level languages.O Programs written in high-level languages are 1 usually translated explicitly or implicitly into assembly language by a compiler9. After that, a target program is generated from the machine language instructions. High-level languages have many advantages such as being easy to write, easy to understand, and versatile, but on the other hand, assembly language H.

There are problems in that it is difficult to write instructions that are closely related to hardware, and there are limits to a single function and execution speed.

Therefore, some high-level languages include Marugame's, which allows descriptions in assembly language 11 to be written by incorporating them into a part of the language.

(8) Prior art and problems Conventionally, high-level language computers including assembler language have been implemented as follows.

Figure 1 shows an example of a conventional compilation processing method.
As shown in Figure 1, the compiler compiles only the high-level language part of the program, does not process the assembly language part at all, and embeds it in the compilation result of the high-level language part. If the resulting assembler language program is then input into an assembler, the target program will be obtained. However, according to such conventional methods, if there is a writing error in the high-level language part of the source program, the compiler will discover it and output a list of errors to a line printer, etc., but if there is an error in the assembler language part, Even if there is a compiler, the compiler will not detect any errors because the compiler does not look at the contents of the assembler language part at all.The error will only be discovered when the assembler is run afterwards.

Figure 2 shows an example of conventional error handling.As shown in Figure 2, when a source program is created and compiled, a compile list is output to a line printer, etc. along with an assembler language statement file. Ru. The user examines the list to check for errors. If there is an error, correct the high-level language part and rerun the assembly language program output by Controller 7 (Ira). Repeat the process in the same way until the error disappears, and then rerun the assembler language program output by Controller 7 (Ira). This time, we will check the assembler list for errors in the assembler language part.If there are errors, we will correct the part written in the assembler language of the source program, and repeat 1+compilation and 6 refunds.

In this way, according to the conventional method, the high-level language part and the assembler language part of the error checking and error correction process are required separately and doubly, so the drawback is that it is extremely time-consuming. Ta. The errors discovered at the Ayambra stage are:

Since it is output as an error list for the assembler language program, it is difficult for the user to read and understand the correspondence with the source program. Another drawback was that it was difficult to correct errors.

It is also possible for pX to correct errors using an assemble language program rather than a source program.

This is not desirable because errors will remain in the source program. - (4) Purpose of the Invention The present invention aims to solve the above-mentioned problems, and enables error correction in the high-level language part and error correction in the assembler language part at the same time, thereby enabling quick compilation processing. It is an object.

(15) Structure of the Invention In order to achieve the above object, the present invention is such that the controller also performs error checking on the assembler language portion of the source program.

In other words, the compiling processing method of the present invention is a compiling processing method for a high-level language in a data processing device that can be embedded and described in an assembler language t-'jo-gram. a scanning unit that inputs a language source program; a syntax analysis unit that analyzes the syntax of the source program input by the scanning unit and detects an assembler language description part; an assembler language statement processing unit that performs a description error check for the incorporated assembler language; and a list output unit that outputs error information on a compile list when the assembler language statement processing unit detects a description error. Equipped with
The present invention will be described based on an embodiment with reference to the drawings, which is characterized in that errors in the assembler language part are checked when compiling the high-level language.

(6) Embodiment of the Invention Fig. 3 shows the configuration of an embodiment of the invention, Fig. 4 is an explanatory diagram of the compiling process according to the invention, Fig. 5 is an explanatory diagram of the processing of the assembler language sentence processing section, and Fig. 6 0 shows a processing explanatory diagram of the code conversion output unit. In the figure, 1 is a compiler, and a high-level language l! that includes an assembler language description is shown. 4, 2 is a source program file in which a high-level language source program including an assembler language description is stored.

Reference numeral 3 denotes a scanning section, which is a source i-program file 2.
One that performs the process of sequentially reading source programs from
Reference numeral 4 denotes a syntactic analysis unit, in which the scanning unit 3 parses the syntax of the statements of the Kobashi-Kyusauken program; and 5, a semantic analysis unit, which analyzes the meaning of the high-level language part and detects errors in the high-level language part. What is detected is an internal code generation unit 6 which generates an internal code to be analyzed by the semantic analysis unit 5 and translated into assembler language based on the results.

7 is an assembler language sentence processing unit that checks errors in assembler language sentences incorporated in the high-level language;
If there is no error, the result t is output to an assembler language statement file, 8 is a high-level language part generated by the internal code generator, 9 is an assembler language statement created according to the internal code, and t is an assembler language statement for the assembler language part. 9 is a code conversion output section that reads from a statement file and outputs the assembly language result of compilation processing to an mt output file; 9 is a list output section that outputs a compilation list of compilation processing results along with error information; 10 is a line printer, etc. Output nine pun pile list, 1
1 is an output file in which the results of conversion to an assembler language program are stored.

Reference numeral 12 represents an assembler language sentence file used as a work file in which the assembler language description portion is stored.

Next, the processing of the compiler 1 will be explained according to FIGS. 4 to 6.

In FIG. 4, when the file name of the source program is added and the compiler is started, the tzu syntax analysis unit 4
Control is transferred to The syntax analysis unit 4 performs the illustrated processing 2 in FIG.
Reserve a buffer with 0.

Performs initial setting processing such as initial setting of internal control table.

The scanning unit 3 is activated by process 21. The scanning unit 3 opens the source program file.

The source program is read by process 22.

Syntax analysis processing unit 2 of syntax analysis unit 4 for each statement
Hand over to 3. The syntax analysis processing unit 23 analyzes the syntax and determines whether the parsed statement is an assembly language statement, a declaration statement t or an executable statement of a high-level language statement, and whether t indicates the end of the program. conduct.

If it is an assembler language sentence, use process 24.

The assembler language sentence processing unit 7 is activated. The assembler language sentence processing unit 7 performs error checking of the assembler language sentence through process 28, as will be described later with reference to FIG. When the process is completed, the syntax analysis unit 4 is notified, and the list output unit 9 is activated in process 29. The list output section 9 outputs the processing results of the assembler language statement processing section 7, especially information on errors if there are any, to the compile list.Next, the scanning section 3 is activated by the processing 21, and the first statement is syntaxed. It is handed over to the analysis section 4.

As a result of the syntax analysis process, if a declarative sentence is detected, the semantic analysis unit 5 is activated in process 25.The semantic analysis unit 5 collects information for the compiler 7 (file process) in process 31. is detected and is 9, the semantic analysis unit 5 is activated in the same way through process 26, and the semantic analysis unit 5 executes process 32.
Interpret the meaning of the sentence by
3 generates internal code for expanding the executable statement into assembler language. After the process 33 is completed, the compile list output process 30 is performed by the output section 9 via the process 29.

Note that if an error is detected by the syntax analysis processing section 23, the list output section 5 is immediately activated in process 29, and error information is displayed on the compile list.

Similarly, the process is repeated until the end of the program is detected, and if the end of the program is detected, process 27
The code conversion output unit 8 is activated by this. The code conversion output section 8 performs code conversion and output through processing 34, as will be described later with reference to FIG. That's all 31 compilations! Complete.

Once activated, the assembly language sentence processing section 7 processes as shown in FIG. First, by the process 40 shown in FIG. 5, a source program of assembler language statements is read from a source program file. Next, in process 41, error checking is performed as follows.

First, for easy syntax analysis of the assembler language, operation codes and operands are identified one by one. In particular, for operands, it is determined whether they are reserved words in an assembler language or variable names in a high-level language. When a variable name in a high-level language is an array, the subscripts of the array are also checked to see if they are outside the subscript range. For example, if a jump destination label is used for a 9-branch instruction, the label operand is checked to see if the jump destination label is declared. Similarly, the subroutine name operand is checked to see if the subroutine name has been declared. If an error is detected by the above error check, the error information is notified to the list output unit 9 along with the contents of the source program,
It is processed so that it appears in a list in the same way as the error information in the high-level language part.

Next, in process 42, the analyzed assembler language sentence is written to an assembler language sentence file, and in process 43, it is determined whether or not the assembler language sentence has ended, and if it is not yet the end, processes 40 to 42 are similarly repeated. . In the case of the end, control is returned to the syntax analysis unit 4 to end the processing of the assembly language sentence.

The code conversion output unit 8 processes as shown in FIG. First, in process 44, the internal code generated by the internal code generation unit 6 is analyzed. By processing 45, the internal code is
Determine whether the code has finished.

If the sentence has not been completed, it is determined in step 46 whether the sentence is an assembler language sentence. If it is not an assembler language sentence, the internal code is converted into assembler language in step 47. In the case of an assembler language sentence, processing 48 reads the assembler language sentence from the assembler language sentence file. Then, the result of process 47 or process 48 is
Process 49 writes to the output file, returns to process 44, and repeats the same process until the internal code is finished.

If the end of the internal code is detected in step 45, the compiling process ends.

FIG. 7 shows an example of a program with an error, and FIG. 8 shows an example of a compile list of the program shown in FIG.

The nine programs shown in FIG. 7 are examples of programs written in a high-level language including assembly language *'. Here, I! Line 8 [@A8MSTART J sentence and 13th
The part from the 9th line to the 12th line surrounded by the sentence [$A8MBNDJ] is the part written in the assembler language. The second assembler language statement on line 12
The operand should be 1-IOUTJ, but t-[IO
[JRJ is written incorrectly, so [l0
URJ is undefined.

When such a program is compiled according to the method of the present invention, a compile list as shown in FIG. 8 is output. In other words, for an error in the assembler language description on line 12, an error like the one shown on the next two lines
Since a list is output, the user can detect errors in the assembler language part simply by running the compiler without running the assembler.

(7) As described in the detailed description of the invention, according to the conventional method, when an error occurs in the assembler language part, a 7-sample list is output at the assembler stage.

In contrast to having to investigate errors, according to the present invention, the cause of errors can be discovered during compilation, making it possible to correct errors at an early stage. Also,
The assemble list is much longer than the compile list, and it is difficult to grasp the correspondence with the source program; however, according to the present invention, error information can be detected from the list of the source φ program written by the user. .

Finding and correcting errors becomes extremely difficult. especially.

Resources can also be saved since there is no need to output an assembly list.

[Brief explanation of the drawing]

FIG. 1 is an example of a conventional compilation processing method, FIG. 2 is an example of a conventional error handling method, FIG. 3 is a diagram illustrating the configuration of an embodiment of the present invention, and FIG. Figure 5 is an explanatory diagram of the processing of the assembler language statement processing unit, Figure 6 is an explanatory diagram of the processing of the code conversion output unit, Figure 7 is an example of a program with an error, and Figure 8 is a compilation diagram of the program shown in Figure 7. Here is an example of a list. - In the figure, 1 is a compiler, 2 is a source program file, 3 is a scanning section, 4 is a syntax analysis section, 7 is an assembly language sentence processing section, and 9 is a list output section. Represents the 10Fi compile list. Original person for patents 1 patent attorney for Fujitsu Ltd. Mori 1) Hiroshi (1 other person)

Claims (1)

[Claims] In a high-level language compilation processing method in a data processing device capable of writing an assembly language embedded in a program, a scanning unit inputs a high-level language source program including at least an assembly language;
The scanning unit analyzes the syntax of the above source program as input and detects the assembler language description part, and the syntax analysis unit starts it and checks for errors in the description of the assembly language incorporated into the high-level language. and a list output section that outputs the error information on the compilation Φ list when the assembler language statement processing section detects a description error. A compilation processing method characterized by checking for errors.