JPH01261734A - Program output processing system based upon debugged result - Google Patents

Abstract

PURPOSE:To automatically reflect a debugged result to a source program by providing the title system with an output inquiring processing part for inquiring whether an output to the source program for correcting information or the like is to be generated or not. CONSTITUTION:When an instruction is added, deleted or corrected to/from a debugged program by a display terminal 14, a debugging execution part 15 stores the executed result in a working intermediate text storing part 16 in an intermediate text format. The output inquiring processing part 17 inquires whether the instruction added, deleted or corrected at the time of debugging is to be reflected to the source program or not. A source program output processing part 18 converts the intermediate text stored in the storage part 16 into a source program and outputs a new source program 19. Consequently, a reflecting work can be automatically executed and the generation of reflection leakage of a corrected result to the source program can be prevented.

Description

DETAILED DESCRIPTION OF THE INVENTION [Summary] This invention relates to a program output processing method based on debugging results in a processing system having a debugging processing function using intermediate text obtained by compiling a source program.

The purpose is to provide a means to automatically reflect debugging results in source programs.

A working intermediate text storage means for storing addition, deletion, or modification information in an intermediate text format when instructions are added, deleted, or modified during debugging, and instructions are added during debugging.

Output adjustment processing means for inquiring whether deletions or modifications are to be reflected in the source program; and source program output processing means for converting and outputting the source program.

[Industrial application field]

The present invention relates to a program output processing method based on debugging results in a processing system having a debugging processing function using intermediate text obtained by compiling a source program.

[Conventional technology]

FIG. 4 shows an example of the conventional method.

For example, when debugging a source program 10 written in a programming language such as C0BOL.

The compiler 11 is started with the debug option specified, and the source program 10 is translated into intermediate text 12. Then, using the interactive debugger 13, while interactively setting execution interruption points, adding and deleting instructions, etc., the intermediate text 1 which is the program to be debugged is
2 and check the operation. Normally, when users add, delete, or modify instructions during debugging, they write the changes in the source program list 4o, which is the output of the compiler 11, using a red pen, etc. ( .

When the user adds, deletes, or modifies instructions, and as a result of debugging, it is confirmed that the program operates normally, the user displays the debugging results 42 and the modified source program list 40' in which modification information, etc. is entered. As a reference, the editor 43 prepared separately from the interactive debugger 13 is operated to modify the source program IO.

[Problem to be solved by the invention]

In the conventional method, as shown in FIG. 4, instructions are added, deleted, modified, etc. during debugging, and the results are displayed.

When modifying a program that has been confirmed, it is necessary to terminate the interactive debugger 13, start up a new editor 43, and modify the source program 10. Therefore, it not only takes time to modify the source program 10;

There has been a problem in that due to operational errors, modification information and the like may not be reflected in the source program 1o.

Therefore, especially when there is a large amount of modification, in order to check for omissions in 2 reflections, after modifying the source program 10, recompile it again using the interactive debugger 13.
Therefore, it was necessary to run the modified program and reconfirm whether the modification was correct.

An object of the present invention is to solve the above-mentioned problems and to provide a means for automatically reflecting debugging results in a source program.

[Means to solve the problem]

FIG. 1 is a block diagram of the principle of the present invention.

In FIG. 1, IO is a source program to be debugged, 11 is a compiler that translates the source program IO, 12 is an intermediate text created by the analysis result of the source program IO, and 13 is an interactive text for setting debugging information, 14 is a display terminal; 15 is a debug execution unit that interprets intermediate text and executes the debugged program; 16 is the debugged program; A working intermediate text storage unit stores intermediate text information related to a program; 17 is an output adjustment processing unit that inquires whether correction information etc. should be output to the source program; 18 is a working intermediate text storage unit 1
6, a source program output processing unit that generates and outputs a source program from the to information, and 19 represents a new source program incorporating correction information at the time of debugging.

The debug execution unit 15 interacts with the user via the display terminal 14 and interprets and executes the intermediate text developed in the 5 work intermediate text section tα section 16.
Proceed with debugging. When an instruction is added, deleted, modified, etc. to the program to be debugged from the display terminal 14, it is stored in the intermediate text storage unit 16 for one work in intermediate text format.

At the end of debugging, the output timing processing unit 17 performs a process of inquiring whether instructions added, deleted, or modified during debugging are to be reflected in the source program.

The source program output processing unit 18 outputs the intermediate text stored in the one-work intermediate text storage unit 16 according to an instruction to reflect it in the source program.

Convert to source program 1 Original source program 1
It is output as a new source program 19 having the same file name as 0 or a different file name.

(Operation) In the present invention, the source program output processing unit 17 simply responds to the inquiry from the output timing processing unit 17, and the source program output processing unit 17
8, the new source program 19 is reversely output. Therefore, automation of one reflection work is realized, and omission of reflection of modification results to the source program is prevented.

〔Example〕

FIG. 2 shows an embodiment of the present invention, and FIG. 3 shows an example of a processing configuration according to the embodiment of the present invention.

Hereinafter, the present invention will be explained in detail using debugging processing of a COBOL program as an example.

C0BOL such as the source program 10 shown in FIG.
When debugging a program, a C0BOL compiler is used to compile the program with debug options specified. The COBOL compiler thereby outputs intermediate text 12 containing source information.

The record format 21 of the intermediate text 12 has an area for two line numbers, source code information, instruction type identification information, and instruction specific information corresponding to each line of the source program 10. This instruction-specific information area contains data depending on the instruction type.

Various information such as conditional expressions and jump destinations are stored. Note that the source code may be managed separately and pointed to from the source information area in each record.

The C0BOL program debugger saves intermediate text 12 to work file 2 through initialization processing at startup.
2 and through dialogue processing.

Set execution interruption points, etc. 1 by execution start instruction
The intermediate text in the work file 22 is interpreted and executed.

Assuming that an interruption point is set at line number=001660, when this line is executed, the execution of the denomaged program is interrupted and the status of the program is displayed. At this break point 1 e.g. [001671PERFORM
When an instruction such as 5UBIJ is added, the debugger outputs this debugger information in intermediate text format to one work file 22. Then, in response to an execution restart instruction, execution is resumed from the interrupted point.

The above processing is similar to processing by a conventional COBOL debugger. In an embodiment according to the invention.

Furthermore, the following processing is performed.

At the end of the debug execution, the output adjustment processing unit 17 shown in FIG. 1 displays an output adjustment menu 23 as shown in FIG. 2, and performs menu selection processing. Here as a menu item.

Output the fat source program. (b) Change information -
Display list. There are tclK, and one of these can be selected using the cursor. When "End" of FC+ is selected, the debugging process is ended without outputting the source program. Regarding the selection of "Display change information - list" of fbl.

All change information such as addition, deletion, and modification of instructions performed during debugging is read out from one work file 22 and displayed as an image of the source program.

fat's "output source program" is LM) Jt
If so, enter the file name where it will be saved.

Check whether there are existing programs with the same two file names. If there is an existing program with the same file name, an additional menu 24 will be displayed to alert the user.
is displayed, and the menu selection process of ``Replace'' with the existing program or ``Cancel'' the source program output is performed.

If there is no existing program with the same file name, or if "Replace" is selected in the menu 24, a new source program 19 is edited based on all the intermediate text information stored in the 1 work file 22. Output. Here, when debugging, between line number 2 = 001670 and line number 001680, r001671 PE
Since the RFORM 5UBIJ instruction has been added, this instruction is inserted in the new source program 190 editing process. Then, according to the specification, new line numbers are assigned and output as a new source program 19.

FIG. 3 shows an example of a processing configuration for executing such processing. In FIG. 3, the same reference numerals as in FIG. 1 correspond to those shown in FIG.

22 is a work file corresponding to the work intermediate text storage section 16 shown in FIG. 1; 30 is an intermediate text input section; 31
32 represents a work file expansion unit, 32 a work file access unit, 33 a source program conversion unit, 34 a source program output unit, and 35 a processing device including a CPU, memory, and the like.

When the intermediate text 12 of the program to be debugged is specified and the interactive debugger 13 is activated, the interactive debugger 13 executes the following processing.

(1) First, the 1-work file expansion unit 31 calls the intermediate text input unit 30 and inputs the intermediate text 12 specified at the time of starting the debugger. Then, the input intermediate text is output to the second work file 22 by calling the second work file access section 32. Once all of the intermediate text 12 has been expanded into the work file 22, the process moves to the tertiary process (2).

(2) The debug execution unit 15 starts debugging by reading the intermediate text developed into nine work files via the two work file access unit 32. When a user gives an instruction to change an instruction, etc., the information such as the changed instruction is converted into intermediate text, and the work file access unit 32 is called to create a work file 22 according to the converted intermediate text. This updates 1.
The work file 22 stores intermediate text corresponding to the state currently being debugged.

■ At the end of debug execution, output timing processing unit 1
7, the user is asked whether or not to output the source program.

(2) When the user specifies output of a source program, the source program converter 33 transfers control to the source program converter 33.

Perform the following processing.

i) Call the work file access section 32 and input the intermediate text stored in the 1 work file 22.

11) Create a source program based on the input intermediate text information. Assign new line numbers if necessary.

1ii) Call the source program output unit 34 to output the text of the created source program as the new source program 19.

〔Effect of the invention〕

As described above, according to one aspect of the present invention, as part of debugging processing, the content of the result of confirming normal operation can be automatically reflected in the source program. Therefore, correction work using an editor or the like is not necessary, and five working hours can be shortened. In addition, since the results of corrections made during debugging are completely reflected in the source program, failure to reflect them is prevented.

[Brief explanation of the drawing]

FIG. 1 is a block diagram of the principle of the present invention. FIG. 2 shows an embodiment of the present invention. FIG. 3 is an example of a processing configuration according to an embodiment of the present invention. FIG. 4 shows an example of the conventional method. In the figure, 10 is a source program, 11 is a compiler, 1
2 is an intermediate text; 13 is an interactive debugger; 14 is a display terminal; 15 is a debug execution unit; 16 is a working intermediate text storage unit; 17 is an output adjustment processing unit; 1 is a source program output processing unit; Represents a new source program.

Claims (1)

[Claims] In a processing system having a debugging function using intermediate text obtained by compiling a source program, when an instruction is added, deleted, or modified during debugging, information on the addition, deletion, or modification is stored in intermediate text format. Working intermediate text storage means (16)
an output adjustment processing means (17) for inquiring whether addition, deletion, or modification of instructions during debugging is to be reflected in the source program; A program output processing method based on debugging results, comprising source program output processing means (18) for converting intermediate text stored in the means into a source program and outputting the source program.