JPH04369048A - Program correcting system in debugging - Google Patents

Abstract

PURPOSE:To attain a program correcting system in debugging which can sharply reduce labor and improve debugging efficiency storing data corrected during the period of debugging and adding the corrected data to a program based upon an operator's instruction when necessary. CONSTITUTION:A correction control part 14 for controlling program correcting work in debugging, a correcting information table 15 for registering management information relating to correction and a correction data registering part 16 for registering correction data are connected to a debugging auxiliary tool 13, and at the time of debugging operation, the management information relating to correction is registered in the table 15 by an operator's instruction, the correction data are registered in a correction data storing part 16, and when necessary, the succeeding program or after is corrected by using these registered data.

Description

[Detailed description of the invention]

0001

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program modification method during debugging, which improves the efficiency of program debugging.

0002

2. Description of the Related Art Conventionally, program debugging work has been carried out by loading a target program 2 from a disk device 1 into a main storage device 3, and then executing the program, as shown in FIG. 4, the operator operates the keyboard 5 to correct data errors M1 and logic errors M2 in the program (this logic error M2 is taken out of the program through branch processing and corrected). A method of making corrections on the storage device 3 has been common.

0003

However, in the program modification method described above, the program can only be modified in the main storage device 3, so even if the amount of modification is small, if the amount of modification is large, A considerable amount of time and effort will be spent on corrections, and in addition, human errors will also be involved in the correction work. Furthermore, if the program needs to be restarted after debugging has been temporarily stopped, the program will be loaded onto the main storage device 3 again, but since the modified parts will be returned to the original when reloading, the operator must be re-corrected by repeating the same correction operation. In the end, you have to give up on debugging and modify the program source based on the information gathered during debugging. Even during this modification process, obstacles may occur due to human modification errors, and as a result, debugging programs requires a considerable amount of time and effort, and debugging cannot be done efficiently unless you have the appropriate experience. There was a problem.

[0004] According to the present invention, the modified data of the part modified during debugging is stored, and the stored modified data is read out and modified the next time the modification is performed, thereby greatly reducing the time and effort in debugging work. The purpose of this study is to realize a program modification method during debugging that reduces the number of errors and improves debugging efficiency.

[0005]

[Means for Solving the Problems] FIG. 1 is a block diagram for explaining the principle of the present invention. In the figure, reference numeral 10 denotes a storage unit that stores a program 11 to be debugged, and uses a disk device, for example. 12 is the main storage device, 13
is a debugging auxiliary tool, and this debugging auxiliary tool 13 includes a modification control unit 14 that controls program modification work, a modification information table 15 that registers management information regarding modification, and a modification data registration unit 16 that registers modification data.
is added. For example, a disk device is used as the modified data registration unit 16, and the modified data is stored in a predetermined file 161.

Further, in the figure, numeral 17 is a data input section for an operator to input data, and a keyboard is used, for example.

[0007]

[Operation] In such a configuration, debugging work is performed as follows. The processing procedure will be explained with reference to the flowchart of FIG.

First, the program to be debugged 11 is loaded from the disk device 10 into the main storage device 12, and the program is executed to perform debugging (processing S1). Then, while executing the program, it is discovered that the program has a data error M1 or a logic error M2, etc.
When it becomes necessary to correct these mistakes M1 and M2, the operator inputs a correction storage start instruction from the data input section 17 as an operation for storing the correction contents. When this correction storage start instruction is input (processing S2)
, the storage flag is turned on (processing S3), and while this storage flag is on (processing S4), the error locations M1 and M2 are
Enter data to correct. When this data is given to the debugging auxiliary tool 13, it is notified to the modification control unit 14, which causes the modification control unit 14 to store management information regarding modifications necessary for searching modification data, such as modification history, in the modification information table 15. (processing S5)
In addition, a predetermined file 16 of the modified data registration unit 16
1, correction data corresponding to the management information written in this correction information table 15 is written (processing S6).

On the other hand, the correction data inputted from the data input unit 17 is also given to the correction part (data miss M1, logic mistake M2) of the program being debugged by the debugging auxiliary tool 13, and the correction data for that part is carried out ( Processing S
7). When all the program modifications are completed in this way, the operator inputs an instruction to end the modification storage from the data input section 17. Then, the operator executes the modified program to check its operation.

[0010] Thereafter, when the debugging operation is temporarily stopped and it becomes necessary to reload the program due to factors such as restarting the program, the operator reloads the program 11 from the disk device 10 into the main storage device 12.
Load into.

[0011]The operator then inputs a read instruction from the data input unit 17 to read out the modified data previously stored in the modified data registration unit 16. The debugging auxiliary tool 13 receives this read instruction, and the correction control unit 1
As a result, the modification control section 14 searches the modification information table 15 and reads out the specified modification data from the modification data registration section 16. The correction data read from the correction data registration section 16 is given to the debugging auxiliary tool 13, and the program is corrected.

As described above, when a program is modified during program debugging, the modification management information and modification data are stored in the modification information table 15 and modification data registration section 16 according to the operator's instructions during the first modification operation.
Therefore, even if it becomes necessary to reload the program due to factors such as restarting the program, the operator can simply issue an instruction to read the modified data and the modified data can be retrieved from the modified data registration section 16. Data can be read and debugging can be performed efficiently and reliably.

[0013]

Embodiments Next, embodiments will be described based on the principle of the present invention as described above. FIG. 3 is a configuration diagram of the first embodiment,
The same parts as in FIG. 1 are given the same reference numerals. In this first embodiment, a modified data saving and restoring section 20 is provided in the modification control section 14 shown in FIG. For example, the data is saved on a floppy disk 21 as a convenient storage and portable storage medium. This will be explained with reference to the flowchart of FIG. In the flowchart of FIG. 4, processes S1 to
The series of processing steps up to processing S8 are those explained in the principle of the present invention, and here, the judgment processing (processing S2) as to whether or not a storage start instruction is input is "NO", and the judgment processing as to whether or not a storage end instruction is input is determined. After the determination process (process S9) is "NO", the process procedure of this second embodiment continues. That is, when it becomes necessary to protect the modified data registration section 16 in which the modified data of the program is written, to protect it from damage, to store it, or to use it for another purpose, the operator saves the modified data stored in the modified data registration section 16. Instructions are input from the data input section 17. When this evacuation instruction input is issued (processing S10), the debugging auxiliary tool 13 corrects the evacuation instruction to the correction control unit 1.
4, thereby controlling the modification information file saving and restoring unit 20 to save the management information regarding the modification data to be saved from the modification information table 15 to the floppy disk 2.
1 (processing S11), and then extracting the corresponding modified data from the modified data registration unit 16 and saving (writing) it to the floppy disk 21 (processing S11).
12).

By saving the modified data written in the modified data registration section 16 to the floppy disk 21 in this manner, storage efficiency is excellent and the modified data can also be used in other systems. Figure 5 shows
This shows a case where the modified data stored on the floppy disk 21 is used in another system.
When the operator inputs a restoration instruction from the data input unit 31 (process S13 in FIG. 4), the operator inputs the restoration instruction to the debugging auxiliary tool 3.
2 receives it, notifies the modification control section 33, controls the modified data saving and restoring section 34, restores the management information from the floppy disk 21, registers it in the modification information table 35 (processing S14), and then updates the modified data. is restored and written to the predetermined file 361 of the modified data registration unit 36 (processing S15)
. Then, the error location M1 in the program 37 is corrected using the written correction data (processing S16). In FIG. 5, 38 is a main storage device, and 39 is a disk device that stores the program 37 to be debugged.

[0015] In this way, the same modifications can be made to programs by using the floppy disk 21 in other systems and simply by having the operator input a restoration instruction. Next, a second embodiment will be explained with reference to FIG. This second
The purpose of this embodiment is to embed all corrections into the program during debugging, thereby eliminating confusion in the program execution order and logic during debugging. That is, in the case of a logical error in a program, if it cannot be corrected within the program, it is taken out by branch processing. In FIG. 6, the hatched portion of logic error M2 is the data originally located in the portion A in the figure, and is shown as having been corrected by branching and exporting it. In this second embodiment, a correction content correction unit 41 is provided in the correction control unit 14, and specifically, based on the correction data registered in the correction data registration unit 16, the correction content correction unit 41 makes corrections. A correction is made to return the part to the original part of the program (the part indicated by arrow A in the figure). This will be explained with reference to the flowchart in FIG. In the flowchart of FIG. 7, processing S1 to processing S
The series of processing steps up to step 8 have been explained in terms of the principles of the present invention, and here, after the judgment (processing S9) as to whether or not the storage end instruction has been input is "NO", that is, processing S2
The steps after the first determination of “whether or not a correction instruction is input” will be explained.

When the operator issues a correction instruction (processing S21), a search is made to see if there is a branch (Jmp) instruction in the corrected data (processing S22). Then, by discovering a branch (processing S23), it is found that the corrected data is a logical error, and the size of the corrected data for that logic is determined (processing S24). This is to calculate the size of the area for inserting the change data of the logical error into the program.

Next, an area for inserting the modified data is secured in the program on the main storage device 12 (processing S25), the modified data is written in that area (processing S26), and then branching is performed (processing S25).
Jmp) instruction and return (RTS) instruction (processing S
27).

By performing such a processing procedure, the data of the modified part is inserted into the original part (the part indicated by arrow A in the figure) inside the program, and as a result, redundant branch processing etc. are deleted and the debug area is It is possible to save money and improve debugging efficiency.

Next, a third embodiment will be explained with reference to FIG. In this third embodiment, a program source generation section 51 is provided in the modification control section 14, and when it becomes necessary to modify the program source, the program source is generated based on the modification data used during debugging. This is for modifying the program source. Specifically, in FIG. 8, the program source generation unit 51 generates a program source using all the modified data (data stored in the file 161) modified during debugging, and the program source is sent to the modified data registration unit. 16 predetermined files 1
62, and this program source is reflected in the main program 53 stored in another disk device 52.

The present program 53 stored in the disk device 52 is a program that is already in an executable format (compiled and linked), whereas the program 11 stored in the disk device 10 is already in an executable format (compiled and linked). This is the program before it was released. After reflecting the program source generated based on the modified data on this program 53, it is made into an executable program.

The processing procedure of this third embodiment will be explained below with reference to FIG.
This will be explained with reference to the flowchart. In the flowchart of FIG. 9, the series of processing steps from processing S1 to processing S8 are explained in accordance with the principle of the present invention as described above, and here, the determination of whether a storage end instruction is input (processing S9)
A description will be given of the process after the case where "NO" is determined, that is, the process after the process S31 for determining whether or not it is a source generation instruction.

First, when the operator inputs a program source generation instruction from the data input section 17 (processing S31
), the source generation unit 51 generates a program source based on the modified data registered in the modified data registration unit 16 (processing S32), and stores this in a predetermined file 162 of the modified data registration unit 16. (Processing S33). Then, the program source stored in this file is reflected in the main program 53 stored in the disk device 52 (processing S34), and the program source of the main program 55 is corrected. If this modified program source is compiled and then linked to create an executable program, this executable program can be used as an already modified program, making it possible to improve the efficiency of program modification work. .

In each of the above embodiments, the disk device 10 that stores the program to be debugged and the modified data registration section 16 that stores the modified data, or the disk device 52 that stores the program in the third embodiment. For convenience of explanation, these are explained as separate disks, but it goes without saying that they may be a common disk. However, if a common disk device is used, it is necessary to accurately associate which program or data is stored in which file. Furthermore, it goes without saying that other storage devices may be used instead of disk devices.

[0024]

[Effects of the Invention] According to the present invention, by providing a function to store corrected data that corrects data errors and logical errors in a program during debugging, program correction operations only need to be performed the first time. From the second time onward, the operator only needs to issue correction instructions, and the correction contents can be read out and corrected automatically. This simplifies program correction work and greatly improves efficiency. can. In addition, by providing a function to save modified data to a floppy disk, etc.,
It is convenient for storing modified data and can be used in other systems, making it highly versatile. Additionally, by providing a correction function that inserts the corrected part into the program, unnecessary branch processing and the like can be deleted. Furthermore, by providing a function to generate program sources based on the modified contents, and by reflecting the generated program sources in this program, it is possible to greatly improve the efficiency of program source modification work.

As described above, the present invention can significantly reduce the time and labor required for debugging work, and can greatly contribute to improving debugging efficiency.

[Brief explanation of drawings]

FIG. 1 is a configuration diagram for explaining the principle of the present invention.

FIG. 2 is a flowchart showing a processing procedure according to the principle of the present invention.

FIG. 3 is a configuration diagram of a first embodiment of the present invention.

FIG. 4 is a flowchart showing the processing procedure of the first embodiment.

FIG. 5 is a configuration diagram when a floppy disk is used in another system in the first embodiment.

FIG. 6 is a configuration diagram of a second embodiment of the present invention.

FIG. 7 is a flowchart showing the processing procedure of the second embodiment.

FIG. 8 is a configuration diagram of a third embodiment of the present invention.

FIG. 9 is a flowchart showing the processing procedure of the third embodiment.

FIG. 10 is a configuration diagram showing a conventional debugging method.

[Explanation of symbols]

11 Program to be debugged 12
Main storage device 13 Debugging auxiliary tool 14 Modification control section 15 Modification information table 16 Modification data registration section 17 Data input section

Claims (4)

[Claims] Claim 1: In a program modification method during debugging in which debugging is performed using a debugging auxiliary tool during program execution and the program is modified, a modification control unit (14) that controls program modification and management information regarding modification are provided. A correction information table (15) for registering correction data and a correction data registration section (16) for registering correction data are provided in addition to the debugging auxiliary tool (13), and management information regarding corrections can be corrected according to instructions from an operator during debugging work. Program correction during debugging characterized by registering correction data in an information table (15) and registering correction data in a correction data registration section (16), and using these registered data to correct the program from the next time onwards. method. 2. The modification control section (14) is provided with a modification file saving and restoring section (20), which registers management information and modification data regarding modification from the modification information table (15) according to an operator's instructions as necessary. The revised data from section (16) is stored on a storage and portable storage medium (
21. The method for modifying a program during debugging according to claim 1, wherein the contents are saved in a storage medium (21) and the contents saved in the storage medium (21) can be read and restored. 3. The correction control unit (14) is provided with a correction content correction unit (41) that corrects the correction content of the program, and calculates the data amount of the part that has been corrected according to an operator's instruction, and restores the original program. 2. The method for modifying a program during debugging according to claim 1, wherein an area corresponding to said amount of data is secured within said area, and data of a modified portion is written in this area. 4. The modification control section (14) is provided with a program source generation section (51), which generates a program source based on the modification data registered in the modification data registration section (16) according to instructions from an operator. 2. The method for modifying a program during debugging according to claim 1, wherein the generated program source is reflected in the program source to modify the program source.