JPH04266133A - Program debugging method - Google Patents

Abstract

PURPOSE:To grasp the corresponding position of a source program when an error occurs by setting a row number to specify an instruction of the source program that is referred to for conversion of the source program into a processing program. CONSTITUTION:A parser 1 debugs a program in an intermediate code interpreter system and generates an intermediate code from a source program SP. Then the parser 1 adds the row number of the SP that is referred to for generation of the intermediate code for production of the intermediate code information MC. A virtual machine 2 carries out only the intermediate code of the information MC and specifies this information MC when an error occurs. Then the machine 2 reads a row number and informs a host device 11 of the row number. Thus the program can be smoothly debugged.

Description

[Detailed description of the invention]

0001

[Industrial Application Field] The present invention is a program debugging method that converts a source program into a processing program that can be recognized by a processing device, and debugs the source program based on the execution result of the processing program by the processing device. Regarding.

0002

2. Description of the Related Art Programs for controlling computers use various high-level languages (programming languages) depending on the control purpose. Examples of high-level languages include C language, COBOL language, FORTRAN language, and BASIC language.

[0003] Programs written in these high-level languages need to be converted into processing programs that can be recognized by processing devices that execute processing based on the contents of the programs. This conversion method can be broadly classified into an interpreter method and a compiler method.

[0004] There are two further types of interpreter methods. One method is to convert various instructions (program lines) that make up a source program into code (processing lines) line by line as processing progresses by a processing device. program)
This is a simple method to perform the conversion to . In this case, the processing device must always perform conversion into actual code during the process of processing, which slows down the processing speed.

Another method is to first convert the entire source program into intermediate code (processing program) expressed by predetermined symbols, and then the processing device converts the intermediate code line by line as processing progresses. This is an intermediate code interpreter that reads and converts to real code by the processing device itself. In this case, for example, if a loop is formed,
The same actual code will be executed many times, but in such cases, intermediate code is generated so that it does not have to be converted to the actual code many times, improving processing speed. can be achieved.

[0006] The compiler method is a code (processing program) that allows a processing device to recognize the entire source program.
In this method, the processing device recognizes the real code and executes the process.The processing device only needs to execute the process corresponding to the real code, so high-speed processing can be achieved. .

FIG. 2 shows a conceptual diagram of the interpreter method. The figure shows the concept of a general intermediate code interpreter. In the figure, a parser 1 is a conversion mechanism that converts a source program SP into a processing program (in this case, an intermediate code group MC). The virtual machine (processing device) 2 recognizes the intermediate code group MC, converts it into real code, and processes the real code.

Now, when a source program SP consisting of a plurality of lines of instructions is generated, the parser 1 converts it into an intermediate code group MC. The intermediate code group MC is composed of a plurality of intermediate code strings corresponding to each instruction of the source program SP.

Here, the relationship between the source program SP and the intermediate code group MC will be explained with reference to FIG. Figure 3
is an explanatory diagram of the operation of the parser 1. As shown in the figure, the source program is "x=x+1" on the first line and "y" on the second line.
=y/x''. The parser 1 generates intermediate codes C1 to C6 corresponding to these two lines of instructions.

[0010] The intermediate code C1 is an intermediate code "GetValue
”. The intermediate code C2 is an intermediate code “Add 1” that indicates the content of adding 1 to a register. The intermediate code C3 is an intermediate code “SetValue x” that indicates the content of setting the content of the register as a variable x. It is.

[0011] The intermediate code C4 is an intermediate code "GetValue
”. The intermediate code C5 is an intermediate code “Div x” that indicates the contents of the register and the contents of the variable x. The intermediate code C6 indicates the contents of setting the register contents as the variable y. The intermediate code is "SetValue y".

Returning to FIG. 2 again, the intermediate codes (intermediate codes C1 to C6) generated by the parser 1 are sequentially recognized by the virtual machine 2, and each time they are recognized, they are converted into real codes and processed. The result EF is output.

[0013]

By the way, if an error occurs in the processing by the virtual machine 2, for example, if division by zero is executed in the execution of intermediate code C5, the result will be infinite. Treated as an error.

In such a case, it is determined which instruction of the source program SP the intermediate code C5 in which the error occurred is based on, and the host device 11 is informed as to which position in the source program SP the error occurred. We will notify you.

Conventionally, in order to grasp the instruction (position) on the source program SP corresponding to the intermediate code C5, the parser 1 executes the process of generating an intermediate code group MC corresponding to the source program SP again. The line of the source program SP read by the parser 1 and the generated intermediate code group MC are monitored, and the position on the source program SP read by the parser 1 when the intermediate code C5 is generated is specified.

In this case, since the parser 1 generates intermediate code C5 as a result of reading the second line of the source program SP, it must understand that the instruction of the source program SP in which the error occurred is the second line. Can be done.

The parser 1 notifies the grasping result to the host device 11, and the host device 11 displays the source program S on the display device 12.
The second line of P indicates that an error has occurred.

As explained above, in order to ascertain the location where an error has occurred in the conventional source program SP, the parser 1 must perform a conversion process. For this reason, a problem has arisen in that prompt error notification cannot be realized.

The present invention has been made with attention to the above points, and when an error occurs, it is possible to immediately determine which instruction in the source program has caused the error, and promptly notify the error. The purpose is to provide a method for debugging programs that can be used.

[0020]

[Means for Solving the Problems] A program debugging method of the present invention consists of a source program consisting of multiple lines of instructions and a plurality of codes that can be recognized by a processing device that executes processing corresponding to the source program. When debugging the source program by referring to the result of execution of the processing program by the processing device, the processing program includes the processing program that constitutes the processing program. A line number is set for each code that specifies the position of each instruction to be converted in the source program, and if an error occurs as a result of execution of the processing program, the line number where the error occurred is set. The line number corresponding to any code is acquired from the processing program, and the position of the instruction related to the error in the source program is specified.

[0021]

[Operation] In the above method, when converting a source program into a processing program, a line number is set in the processing program to specify the instruction of the source program referred to at the time of conversion. When an error occurs as a result of execution of the processing program, the position in the source program corresponding to the error is determined using the line number set in the processing program.

[0022]

DESCRIPTION OF THE PREFERRED EMBODIMENTS The program debugging method of the present invention is implemented in the intermediate code type interpreter described above with reference to FIG. Therefore, the present invention will be explained using the configuration shown in FIG. 2 as an example. FIG. 1 is an explanatory diagram of the operation of the parser 1 according to the present invention. As shown in the figure, it is assumed that the source program consists of two lines of instructions: the first line "x=x+1" and the second line "y=y/x". Parser 1 generates intermediate code information C11 to C11 corresponding to these two lines of instructions.
This will generate C16.

[0023] Each of the intermediate code information C11 to C16 is composed of, for example, 3 bytes of data, the first 2 bytes are composed of the intermediate code obtained by converting the source program, and the latter 1 byte is composed of the intermediate code. It consists of the position on the source program that was referenced during conversion, that is, the line number of the source program.

Since the intermediate code information C11 to C13 are intermediate codes obtained as a result of converting the contents of the first line of the source program SP, the line number "1" is stored in each of them. Similarly, since the intermediate code information C14 to C16 are intermediate codes obtained as a result of converting the contents of the second line of the source program SP, the line number "2" is stored in each of the intermediate code information C14 to C16.

The process of generating the intermediate code MC shown in FIG. 1 will now be described with reference to FIG. 4. Figure 4 shows
7 is a flowchart of intermediate code group generation according to the present invention. When converting source program 1, parser 1 first resets the line number register (content “1”) that manages the position (line number) of the source program to be converted.
(step S1).

After that, the parser 1 executes the source program S
One line (first line) of P is read (step S2). The parser 1 determines whether the read content is the content of the source program SP to be converted, that is, predetermined content (for example, EOF) indicating that the content is after the last line of the source program SP.
:END OF FILE code) (step S3).

If the result of step S3 is NO, the parser 1 increments the contents of the line number register (step S4), for example, the intermediate code "GetbValue x
”, “Add 1 ”, and “SetValue x” are generated (step S5).

After generating the intermediate code, the parser 1 generates intermediate code information C11 to C13 based on the generated intermediate code and the line number of the source program SP referred to when generating this intermediate code, and stores it in a predetermined storage area. Store in. Further, if the result of step S3 is YES, that is, if the conversion of all lines of the source program SP is completed, the parser 1 ends the process.

[0029] The virtual machine 2 executes the process by reading only the intermediate code of the generated intermediate code group MC, that is, after reading and executing 2 bytes, skipping reading 1 byte, and then reading and executing 2 bytes. I will do it. As a result, the line number of the intermediate code group MC is not recognized by the virtual machine 2, and only the intermediate code is read.

Now, a case where an error occurs as a result of processing executed by the virtual machine 2 will be described with reference to FIG. FIG. 5 is a flowchart of error processing according to the present invention. When an error occurs as a result of the processing executed by the virtual machine 2, the virtual machine 2 identifies intermediate code information in which the error has occurred, for example, intermediate code information C15, from among the intermediate code group MC (step S11).

When the virtual machine 2 specifies the intermediate code information C15, it reads the contents of the third byte of the intermediate code information C15, that is, the line number (step S12), and notifies the host device 11 of the read line number (step S12). S13), the virtual machine 2 ends the process for the occurrence of the error.

Thereafter, the host device 11 displays the notified contents on the display device 12 in the same manner as before, and displays the position in the source program SP where the error has occurred.

As explained above, as a result of processing execution by the virtual machine 2, an error occurs, and the position in the source program SP related to the occurrence of this error is stored in the intermediate code group M.
It can be easily understood from C.

The present invention is not limited to the above embodiments. Even if the intermediate code information of the intermediate code group does not have a 3-byte configuration, the data length can be set as appropriate if a separation code or the like that can separate the intermediate code and line number is specially set. Further, in the embodiment, the explanation has been given using an intermediate code type interpreter as an example, but the present invention can also be implemented in a compiler by setting the position (line number) on the source program in the compilation result. The line numbers may be set in a table or the like in which items are prepared in correspondence with the codes of the processing program, separately from the processing program.

[0035]

[Effects of the Invention] As explained above, according to the present invention,
Since there is no need to convert the source program to a processing program in order to determine the location in the source program where an error has occurred, the location in the source program where the error has occurred can be quickly notified, resulting in smooth debugging. can be realized.

[Brief explanation of the drawing]

FIG. 1 is an explanatory diagram of the operation of a parser according to the present invention.

FIG. 2 is a conceptual diagram of an interpreter method.

FIG. 3 is an explanatory diagram of the operation of a conventional parser.

FIG. 4 is a flowchart of intermediate code group generation according to the present invention.

FIG. 5 is a flowchart of error processing according to the present invention.

[Explanation of symbols]

1 Parser 2 Virtual machine 11 Upper device 12 Display device

Claims (1)

[Claims] 1. A source program consisting of multiple lines of instructions is converted into a processing program consisting of a plurality of codes that can be recognized by a processing device that executes processing corresponding to the source program, and the processing program is executed by the processing device. In the case where the source program is debugged by referring to the result of execution of the processing program, the processing program includes each of the instructions to be converted for each code constituting the processing program. A line number identifying a position on the source program is set,
If an error occurs as a result of the execution of the processing program, the line number corresponding to any of the codes in which the error occurred is obtained from the processing program, and the source of the instruction related to the error is obtained. A program debugging method characterized by identifying a position on the program.