JP2001209558A - Debug processing system and recording medium - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a debug processing system for enabling to debug a subject program easily and quickly. SOLUTION: Debug processing system 10 detects and corrects errors of debugged program 15 using processing device (computer) 11 which has display means (display device) 12, input mans (input device) 13, memory means (memory device) 14 and so on. Computer 11 outputs progress display 21 (executing and processing order 22) of the program 15 to display device 12.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a debug processing system and a recording medium capable of performing a debug process while confirming an execution sequence of a program on a screen.

[0002]

2. Description of the Related Art Conventionally, when a program runs away when a program is developed and executed, there is a case where a reaction to a debug processing system is lost. In such a case, the operator repeats the debugging operation until the stage immediately before the debug processing system stops responding, finds out a runaway point while executing the program one step at a time, and makes an error (hereinafter referred to as a bug).
I was doing the work to remove.

When the execution of the program to be debugged is examined step by step in the debugging operation, the processing is performed without interruption until just before the reaction stops due to work efficiency. But if the desired processing phenomenon is not constant,
The breakpoint was shifted every time debugging was performed, and the debugging process was performed by setting the breakpoint again and again.

In order to execute a program to be debugged by setting a step unit or a break point, if the user is not familiar with the function of the program to be debugged or the structure of the program to be debugged, the debugging process can be performed efficiently. Did not. Therefore, in a debugging process performed by a person other than the writer of the program to be debugged, the efficiency of debugging is reduced, and a bug may remain without being completely processed.

[0005]

However, if such a runaway occurs during the execution of a program to be debugged, there is often no response to the debug processing system many times, and it is troublesome to find a runaway location every time. The operation had to be repeated. The debugging process of the program to be debugged takes a great deal of time, and the skill of the skilled worker depends on intuition and reasoning to perform the debugging. For this reason, there has been a demand for the development of a debug processing system in which the execution progress of a runaway program is displayed on a display device, and the progress display is followed to easily perform a debugging process.

In many cases, a program to be debugged is linked with a large number of source programs, and these source programs are developed by a large number of programmers, system designers and the like. For this reason, there has been a problem that the debugging work must be performed not only by the programmer but also by all the development personnel who are not necessarily familiar with the individual debugging target programs when it comes to the final step of the debugging target program.

[0007] Further, the only material that proves that the debug target program has been sufficiently tested is the input to the debug target program and the output result. For this reason, there is no material for certifying the execution contents such as which part of the program to be debugged has been confirmed, and there has been a problem that it is not clear how the debugging work was performed.

SUMMARY OF THE INVENTION The present invention has been made to solve the problems of the related art, and has as its object to provide a debug processing system capable of easily and promptly performing a debugging operation on a program to be debugged. Aim.

[0009]

That is, a debug processing system according to the first aspect of the present invention uses a processing device having a display unit, an input unit, a storage unit and the like to detect and correct an error in a program to be debugged. The processing device displays a progress display of the execution processing order of the debug target program on the display means.

According to a second aspect of the present invention, there is provided a recording medium for causing a computer to execute a process of executing a program to be debugged and a process of displaying a progress display on a display unit in the order of execution of the program to be debugged. It is a computer readable recording of the program.

According to a third aspect of the present invention, there is provided a debug processing system or a recording medium according to the first aspect.
The progress of the execution processing order of the debug target program is displayed by the background color of the program displayed on the display means.

Further, in the debug processing system or the recording medium according to the present invention, the execution processing is executed in the order of steps with the structure list of the program to be debugged displayed on the display means. In this case, the background color of the execution part in the same column is set as the first background color in the order of steps, and the second background color indicating the execution direction is displayed at the step where no execution is performed, and the third background indicating the end of execution of the function. By using colors, the progress display of the execution order of the structure list is displayed.

[0013]

Next, an embodiment of the present invention will be described in detail with reference to the drawings. FIG. 1 is a schematic diagram showing a progress display 21 of an execution processing sequence 22 of a program structure list 17, FIG. 2 is a schematic diagram showing a source program 16 by specifying a background color 18 in FIG. 1, and FIG. 3 is a display device. FIG. 12 is a flow chart showing the operation of the debug processing system 10, and FIG.

The debug processing system 10 finds a bug in the program 15 to be debugged. A general-purpose personal computer (hereinafter, referred to as a computer) 11 is used as a processing device, and the computer 11 has a display device 12 as a display means. The input means and the storage device 14 are connected. The storage device 14 stores a debugger program 23, a debug target program 15, an operating system (not shown), and the like. Incidentally, an input device 13 such as a keyboard or a mouse is used as the input means.

The debugger program 23 divides and executes the debug target program 15 for each instruction, and executes the debug target program 15 in the order of execution with the background color 1 for one character.
8 is displayed on the display device 12 so that the execution process sequence 22 can be traced by changing the execution process sequence 22, and the progress display 21 and each machine instruction 20 in the execution order can be recorded in the storage device 14. I have. Then, it is configured so that the operator can display the progress display 21 of the debug target program 15 on the display device 12 later to find and correct a bug.

The debugger program 23 divides the screen of the display device 12 into a plurality of parts and allocates a debug target program (a source program 16 in C language, assembler language, etc., and an executable file in which these are compiled) 15. The program 17 is configured so that the program structure list 17 of the debug target program 15 can be divided and designated in units of functions 17A and displayed on the display device 12. The debugger program 23 designates the range of the progress display 21 by specifying the name of the function 17A described in the debug target program 15 and the program structure list 17 based on the depth of the child function 17A called from the function 17A. Fifteen
, And a program structure list 17 composed of functions 17A, each of which is specified in a different range so that a bug can be corrected.

That is, the debugger program 23 changes the background color 18 for one character on the program structure list 17 displayed on the display device 12 in the order in which the entry and exit of the function 17A of the progress display 21 are executed. , And the display result can be recorded in the storage device 14. Then, the storage device 14
Is displayed on the display device 12 by the operator later, so that a rough process progress of the debug target program 15 can be confirmed. As a result, the worker can program 1 to be debugged.
The configuration is such that the vicinity of the bug position of No. 5 can be easily found and the bug can be easily corrected. Note that the program structure list 17 includes a screen in which a specific function 17A is the highest-order function 17A and a general-purpose screen in which other functions 17A which are not included in the function 17A are displayed. .

Next, referring to FIG.
Will be described. Incidentally, reference numeral 21 denotes a progress display indicating the execution processing order 22 of the program structure list 17.
The row numbers (step numbers) SNO of the execution process are sequentially displayed as 1, 2, 3, 4,... From the upper left to the lower side, and the column numbers LNO are 1, 2,.
3, 4,..., 46 are displayed. Note that the column number LNO is not displayed on the screen of the actual display device 12.

The function 1 of the program structure list 17
If 7A is AA to OO, the function 17A (AA) is the row number SNO, the column number LNO (1, nineteen), the function 17A
(BB) is a row number SNO, a column number LNO (2, 21),
Function 17A (CC) is converted to row number SNO and column number LNO
(3, 23), DD is row number SNO, column number LNO
(4, 25), EE is row number SNO, column number LNO
(5, 27), FF is row number SNO, column number LNO
(6, 29), GG is row number SNO, column number LNO
(7, 27), HH is the row number SNO, column number LNO
(8, 23), II is row number SNO, column number LNO
(9, 23), JJ is the row number SNO, column number LNO (1
0, 23), KK is the row number SNO, column number LNO (1
1, 21), LL is the row number SNO, and the column number LNO (1
2, 23), MM is the row number SNO, column number LNO (1
3, 25), NN is the row number SNO, column number LNO (1
4, 27), OO is row number SNO, column number LNO (1
5, 21). That is, the progress display 21 as the execution processing order 22 is displayed corresponding to the row number SNO and the column number LNO (1 to 15, 19 to 30) of each function 17A.

Although the progress display 21, the program structure list 17, and the execution processing sequence 22 are shown separately for the sake of explanation, the actual display device 12
The program structure list 17 (the description of the function) is displayed as it is, and the progress display 21 is displayed by changing the background color 18 of the program structure list 17 in units of one character according to the execution processing order 22. That is, the execution processing sequence 22 is not displayed on the display device 12, but the progress display 21 and the program structure list 17 are displayed on the display device 12 in an overlapping manner.

When the function 17A of the program structure list 17 is executed in the order of steps (in this case, the order of the line numbers SNO), the progress display 21 changes the background color 18 of the same column number LNO to the first background. The first background color 18 is displayed in yellow (YELLOW) 18Y (Y in the figure). And yellow one
The row number SNO that is not executed with the same column number LNO as the background color 18 of 8Y is set as the second background color 18, and this second background color 18 is set to a down arrow (in this case, a background color different from the second background color 18). The color 18 or a downward triangle may be used.

The background color 18 of the downward arrow 18L indicates that the process proceeds in the execution processing order 22 (in this case, the order of the row numbers SNO). That is, the execution processing order 22 of the same column number LNO in the program structure list 17 is made continuous with the background color 18 of yellow 18Y and the background color 18 of down arrow 18L.
At the place where the background color 18 is interrupted, the execution processing order 22 of the column
Is completed, the process moves to the next adjacent column number LNO, and reverses the row number SNO or changes the background color 18 of the same row number SNO. The background color 18 of the adjacent column number LNO is different from the background color 18.

The end of execution of each function 17A is set as a third background color 18, and this third background color 18 is set to light blue (WATE).
R BLUE) 18W (W in the figure), and the steps not executed with the same column number LNO as the background color 18 of the light blue 18W are indicated by an up arrow 18U (U in the figure, in this case, a color different from the third background color 18). The background color 18 or an upward triangle may be used. The background color 18 of the up arrow 18U indicates that the execution processing sequence 22 proceeds in the reverse direction (in this case, the reverse of the line number SNO).

That is, the end of the execution of the function 17A is indicated by light blue 18W.
Since the background color 18 of the upward arrow 18U is continuously displayed on the background color 18 of the light blue 18W, the background colors of the light blue 18W and the upward arrow 18U (gray 18D, purple 18P described later) are displayed. The execution processing sequence 22 of the debug target program 15 can be reliably traced simply by following the sequence 18 in turn, whereby the location where the bug has occurred can be grasped. In addition, blue (BLU
E) 18B (B in the figure), purple (PURPLE) 18P
The background color 18 (P in the figure) is the end of execution of the function 17A, and the background color 18 of the gray (DARK GRAY) 18D (D in the figure)
Indicates that the lower-order function 17A is executing, and that the green (GREEN) 18G
(G in the figure) indicates an even-numbered execution start.

The debugger program 23 executes the program structure list 17 in the execution processing order 22 (1, 2, 3,.
4, 17) according to the function 17A (AA, BB, CC, D
D, GG), the function 17A (EE, F)
F) is skipped. This will be described by replacing the progress display 21 with the column number LNO (1) and the row number SNO.
(1, 2, 3, 4, 7) are displayed in the background color 18 of yellow 18Y, respectively, and the row number SNO of the column number LNO (one)
(5, 6) are the background colors 18 of the down arrow 18L, respectively, and the row numbers SNO (1 to 7) of the column number LNO (1) are set to the
8 is displayed continuously.

Next, according to the execution processing order 22 of the program structure list 6, 6, 7, 8, 9 (function 17A (G
Function 17A (DD) called upon completion of execution of G)
After returning to the function 17A (CC) and ending the execution, the function 17A is executed in the order of executing the next function 17A (HH). , 7) are skipped and executed. When this is replaced with the progress display 21, the column number LNO
In (2), row numbers SNO (7, 4, 3) are each light blue 18
The row number SNO (6, 5) is displayed in the background color 18 of W, the row number SNO (6, 5) is in the column number LNO (2), and the row number SNO (7 to 3) in the column number LNO (2) is in the background color 18 of the up arrow 18U. Color 18
Are configured to be displayed continuously. That is, the debugger program 23 executes 1, 2, 3, 4, 5,... 32 and each function 17A in accordance with the execution processing order 22 of the program structure list 17, and displays the progress display 21 on the display device 12. Is configured.

Then, while the progress display 21 of the structure list 17 of the debug target program 15 is displayed, for example, the background color 18 of the line number SNO (7) and the column number LNO (1)
When yellow 18Y is designated, the source program 16 is displayed between the line numbers SNO (7) and SNO (8) (in this case, the execution program may be displayed by operating the input device 13). Is possible). The row number SNO (7) and the column number LNO (one) correspond to the function 17A.
(GG) corresponds to this function 17A (GG)
Is displayed between the line numbers SNO (7) and SNO (8) (FIG. 2).

The progress display 2 of the source program 16
1 is shown in FIG. Note that the row numbers SNO are C51 to C
Although not shown, it is assumed that a predetermined serial number is assigned to the column number LNO (not shown). When the debugger program 23 executes the debug target program 15, the execution contents of each machine instruction 20 in the progress display 21 range of the debug target program 15 are recorded in the memory, and the execution progress of the source program 16 is displayed on the display device 12. In this case, the debugger program 23 changes the background color 18 for one character at the left end of the same column number LNO in the execution order of the source program 16. That is, the debugger program 23
Changes the background of one character at the left end of the source program 16 in the order of execution lines as described above. In this case, for example, the line number SNO
(C52, C54, C57, C58), the background color 18 in the first row is changed to green 18G.

In the case where the source program 16 contains a loop or a return instruction, the order of execution is changed and processed by the instruction (in this case, a line having a small line number SNO of the debug target program 15). When the number SNO is executed), the debugger program 2
3 changes the background color 18 for one character from the left (the second column) to, for example, yellow 18Y. When a larger number of loops or processes such as return instructions are performed, the background color 18 is changed to the third column, the fourth column, and so on. Although not shown, if the background color 18 of the column is not continuous in the order of execution, that is, if the background color 18 of the column is skipped, a down arrow 18L indicating the execution direction is displayed at the skip location.

When the background color 18 is changed to the vicinity of the right end of the screen of the display device 12, the debugger program 23 automatically moves the display to the left by about one third of the screen width, and This prevents the display of the running progress display 21 from being hidden behind the right side of the screen of the display device 12. Note that the background color 18 that is successively displayed on the background color 18 (green 18G) adjacent to the background color 18 (yellow 18Y) is green 18G, yellow 1
A color other than 8Y, or green 18G and yellow 18Y may be alternately used as the background color 18.

Then, the operator operates the display device 12.
While observing the execution status of the debug target program 15 while observing the progress display 21 sequentially displayed on the display device, the input device 13 is operated as necessary, and the debugger program 23 is displayed on the display device 12, and the debug target program 15 is displayed. Of the debug target program 15
Confirm the contents of Then, the debugger program 23
Stops the debug target program 15 at the break point, and the operator observes the progress display 21 of the debug target program 15 sequentially displayed on the display device 12.

When the operator observes the progress display 21 of the display device 12 without any bugs and does not need to execute the debugger program 23 any more, the operator operates the input device 13 to display the debugger program 23 on the display device 1.
2 and the execution of the debug target program 15 is interrupted and terminated. When correcting a bug, the user operates the predetermined background color 18 of the progress display 21 with the input device 13 to display the machine instruction 20 (in this case, the history of the progress display 21 such as the machine instruction 20). Can also be modified. In this case, the line number SNO (C5
2) When the green 18G in the first column is designated by the input device 13, the row number SNO (C52) and the row number SNO (C53)
In between, the machine instruction 20 corresponding to the designated background color 18 of green 18G is displayed. In addition, information accompanying the source program 16 on the designated line (in this case, the machine instruction 2
History such as 0) is displayed on the line following that line,
It is possible to accurately and quickly grasp the information of the specified line and to perform debugging. 20A is a number indicating the number of times the function has been called.

The row number SNO (C52), the first column green 18G, the second column yellow 18Y, and the third column green 18G
When G and the yellow 18Y in the fourth column are designated by the input device 13, machine instructions 20 (13, 14, and 15 of numbers 20A indicating the number of executions) corresponding to the designated background color 18 are displayed. Thus, the configuration is such that a worker can easily correct a bug that is difficult to understand even when looking at the source program 16. If the row number SNO (C52), the first column green 18G, the second column yellow 18Y, the third column green 18G, and the fourth column yellow 18Y are specified by the input device 13, the machine instruction 20 Number SNO (C52) and line number SNO
Between (C53), they are sequentially displayed below the line number SNO (C52).

That is, when the progress display 21 of the debug target program 15 is displayed on the display device 12 and the leftmost green 18G is designated by the input device 13, the debugger program 23 executes the execution line of the debug target program 15 and the next line. A history line is added and displayed between the execution line. In addition, yellow 1 adjacent to the background color 18 of green 18G in the first row
8Y background color (in this case, the second column) 18 is input device 13
Is specified, the history is added and displayed between the history line displayed by specifying the green 18G and the next execution line.

When the background color is specified in order from the left end, the history is displayed in order between the line following the description line of the debug target program 15 and the execution order 22 of the debug target program 15. Thus, the history can be easily grasped, and the debug of the debug target program 15 can be easily performed. Note that the debugger program 23
When the background is changed to the vicinity of the right end of the screen of the display device 12, the screen is automatically moved to the left by about 1/3 of the screen width as described above.
The progress display 21 which is moved to the left of the screen and is hidden can be changed to a function 17 by performing a predetermined operation with the input device 13.
It is configured so that it can be moved left and right in units of A and redisplayed on the display device 12.

Next, the operation of the debug processing system 10 having the above configuration will be described with reference to the flowchart of FIG. The computer 11 is connected to a commercial power supply (not shown), and the debugger program 23 stores the recording medium 1 such as a floppy disk 19A (including a magneto-optical disk).
9 is recorded. The description content of the debug target program 15 displayed on the display device 12 is normally displayed in black, the background color 18 is set to white, and the other colors are set to arbitrary colors.

At step S1, the worker enters the computer 11
And proceeds to step S2, where the operator operates the input device 13 (keyboard or mouse) to read and activate the debugger program 23, and proceeds to step S3. In step S3, the operator operates the input device 13 to activate the predetermined debug target program 15 from the debugger program 23. The debugger program 23 executes until just before the first execution line of the debug target program 15, displays the executed debug target program 15 on the screen of the display device 12, and executes the next execution line (in this case, the display device 12 The cursor moves to the first execution line of the debug target program 15 displayed on the screen and waits for the next support by the operator.

Next, proceeding to step S4, the operator designates the execution monitoring range of the debug target program 15. In this case, the debug target program 15 by the debugger program 16 (the source program 16 or
The execution monitoring range of the program structure list 17) is designated. When a predetermined range of the program structure list 17 is designated, a broad and rough progress can be grasped.
It is possible to find out where the runaway occurred and stopped from the name of the function 17A, and if the range of the source program 16 is specified, it is possible to find out where the runaway occurred and stopped from the description of the source program 16.

If necessary, an interrupt condition (eg, a breakpoint,
Alternatively, by specifying a numerical value, a character, the number of repetitions, etc.), the debug target program 15 is interrupted at a predetermined position, and a bug of the debug target program 15 is displayed, so that the debug target program 15 up to the stopped point is displayed.
It is possible to determine whether or not there is a bug.

Next, proceeding to step S5, the debugger program 23 executes the debug target program 15. Then, the debugger program 23 records the execution contents of each machine instruction 20 of the designated debug target program 15 in the memory, and displays the execution progress of the program structure list 17 on the display device 12 (progress display 21).
Is displayed. In this case, the debugger program 23 displays the execution processing sequence (progress display 21) 22 by changing the background color 18 of the leftmost character at the same position in the same sequence position in the program structure list 17 as described above. The input device 13
The operation progress (the progress display 21) of the source program 16 may be displayed on the display device 12 by operating a (keyboard or mouse).

When the execution of the predetermined function 17A in the program structure list 17 is completed, the debugger program 23 moves to the next column and displays the background color 18 for one character as the background color 18 of light blue 18W, for example. At the same time, the progress display 21 as shown in FIG. 1 is displayed. When a loop or a return instruction is described in the source program 16 and the execution order is returned and the processing is performed, the debugger program 23 moves to the next column and sets the background color 1 for one character.
8 is changed to, for example, yellow 18Y, and the progress display 21 as shown in FIG. 3 is displayed.

Thus, even when the background color 18 indicating the execution processing order 22 is displayed on the display device 12 in the same row over two or more screens, the predetermined background color 1
8, debugging can easily be performed by following the execution processing sequence 22, and the debug target program 15 runs away on the way, and the execution processing sequence 2
In the case where 2 is interrupted or the like, the operator can quickly debug by examining the source program 16 by operating the program structure list 17 or the input device 13 at that location. Note that the debugger program 23 records the progress display 21 and each machine instruction 20 in the execution order in the storage device 14, checks each machine instruction 20 recorded by an operator or the like at a later date, and checks the debug target program 15 The document can be used as a proof of the certification.

When the background color 18 is changed to the vicinity of the right end of the screen of the display device 12, the debugger program 23 automatically moves the screen to the left by about one third of the screen width and executes the current execution. This prevents the progress display 21 from being hidden behind the right side of the screen of the display device 12. The source program 16
The background color 18 indicating the execution processing order 22
The background color 18 of the green 18G adjacent to Y is green 18G,
Color other than yellow 18Y, or green 18G, yellow 18Y
May be displayed in alternate background colors 18.

Next, proceeding to step S6, the operator grasps the execution status of the program 15 to be debugged while observing the progress display 21 sequentially displayed on the display device 12, and if necessary, the input device (keyboard or keyboard). The debugger program 23 is displayed on the display device 12 by operating the mouse 13, and the debug target program 1 is displayed.
5 and the process proceeds to step S7.

Then, the operator observes and verifies the progress display 21 of the debug target program 15 sequentially displayed on the display device 12. The debug target program 15 is verified in the order of execution, and when the verification is completed, step S
Proceed to 8. In step S8, if the debugger program 23 is not terminated and debugging is to be performed continuously by specifying a predetermined range of the debug target program 15, step S4
And returns to step S7. That is, the worker
In the case where the debug target program 15 is to be corrected again by specifying a predetermined range, the input device 13 is operated to
Returning to step S4, steps up to step S7 are executed again.

In step S8, if the operator observes and verifies the progress display 21 of the display device 12 and finds no bug, and the further execution of the debugger program 23 becomes unnecessary, the input device 13 is operated to operate the debugger. The program 23 is displayed on the screen of the display device 12, the execution of the debug target program 15 is interrupted, and step S
Go to 9. The process also proceeds to step S9 when the debug target program 15 has been executed to the end. If the process ends without specifying the range of the debug target program 15 in step S8, the operator operates the input device 13 and proceeds to step S9.

In step S9, when the operator debugs another program 15 to be debugged, the input device 1
3 and returns to step S3 to read another program 15 to be debugged, from step S4 to step S8.
Run up to. If there is no other debug target program 15 to be debugged in step S9, the operator operates the input device 13 and terminates.

As described above, the computer 11 displays the progress display 21 indicating the execution processing order 22 of the debug target program 15 on the display device 12, and executes the execution process of the debug target program 15 and the debug target program 15. A process of displaying the execution processing sequence 22 on the display device 12 as a progress display 21;
The computer 11 on which the debugger 23 program to be executed by the computer 11 is recorded is readable, so that the debug target program 1 displayed on the display device 12
5, the debug target program 1
By displaying the progress display 21 indicating the execution processing sequence 22 of No. 5, the execution processing sequence 22 of the debug target program 15 can be easily grasped only by following the order of the background color 18.

As a result, the operator can easily perform debugging by following the execution processing sequence 22 of the debug target program 15, and runaway occurs during execution of the debug target program 15 as in the prior art. Then, even if there is no response to the debug processing system 10 many times, there is no need to repeat the troublesome operation of searching for a runaway point every time. Therefore, debugging can be performed in a short period of time, so that the labor for debugging can be greatly reduced, and the debugging can be performed with high accuracy. In addition, since the progress display 21 indicating the execution processing order 22 of the debug target program 15 is displayed, it becomes possible for the program orderer to verify the program description and to grasp the changed points accurately, In education, etc.
It is possible to perform a demonstration at the source program 16 level of the teaching material.

The search for a bug is performed by displaying a progress display 21 of the debug target program 15 displayed on the display device 12.
Are displayed in the order of the background color 18 or the progress display 21 is displayed in the background color 18
Can be easily traced in reverse order, so that even the final process of the debug target program 15 including a plurality of source programs 16 developed by a large number of programmers and system designers, etc., become familiar with the individual debug target programs 15. Even non-developed development staff can easily debug. Further, since the debugger program 23 records the progress display 21 (including each machine instruction 20 etc.) in the storage device 14, the worker or the like later displays the progress display 21 recorded in the storage device 14 on the display device 12. By displaying it, it is possible to prove that the debug target program 15 has been confirmed.

When the execution process is executed in the order of steps in a state where the structure list 17 of the debug target program 15 is displayed on the display device 12, the background color 18 of the execution part in the same column in the order of the steps is set to yellow 18Y. Arrow 18 indicating the execution direction
L is displayed as a second background color (in this case, a background color 18 different from the second background color 18 or a downward triangle or the like) 18 and a third signal indicating the end of execution of the function 17A. Is displayed in the background color (light blue 18W), so that the execution processing order 22 of the structure list 17 can be traced.
The execution processing sequence 22 in 7A and the completion of execution of the function 17A can be easily grasped only by the background color 18. In this way, it is possible to ascertain the position (function 17A) in the debug target program 15 where the bug has occurred by merely checking the background color 18 and to check the debug target program 15
Can be debugged.

In the embodiment, the background color 18 for one character of the debug target program 15 is changed in the execution order, and when the execution processing order 22 is returned and processed, the background color 18 for one character in the next column is changed. However, the present invention is not limited to this. When the execution processing order 22 is returned and processed, the background color 18 for one character to be returned is changed to another background color 18 different from the background color 18 indicating the execution processing order 22 up to that point. Alternatively, the present invention is effective even if the background color 18 is blinked to display the return point in an easy-to-understand manner.

The present invention is also effective when the progress display 21 is displayed for a program in which the source program 16 is converted into a different description by the translation program. That is,
Translation into a different programming language, or reverse translation into a symbol that is visible to the operator once it has been translated into machine code, or substitution with an alternative instruction, decomposition into multiple instructions, or multiple instruction Aggregation into one command, or
The execution process order 22 may be displayed in the progress display 21 in a translated program or the like generated by replacing a plurality of instructions with a plurality of instructions.

[0054]

As described in detail above, according to the first and second aspects of the present invention, the processing device displays the progress display of the execution processing order of the debug target program on the display means,
Since a debugger program for causing a computer to execute the execution process of the debug target program and the process of displaying the execution processing order of the debug target program on the display means is made readable by a computer, for example, By displaying the progress display of the execution processing order of the debug target program by the background color of the program displayed on the display means as in 3, it is easy to grasp the execution processing order of the debug target program simply by following the order of the background colors. It becomes possible. As a result, the operator can debug the program to be debugged by following the execution target sequence.
Therefore, even if a runaway occurs during the execution of the program to be debugged and there is no response to the debug processing system many times as in the past, there is no need to repeat the cumbersome operation of searching for a runaway location each time. In a short time, and the practical effect of the debug processing system can be greatly improved.

In particular, the bug search can follow the progress display of the program to be debugged displayed on the display device back and forth in the order of the background color, so that a plurality of sources developed by many programmers and system designers can be searched. Even in the final step of the debug target program consisting of programs, without being familiar with individual debug target programs,
In addition, even unskilled development staff can easily debug without relying on intuition and inference.
This will greatly reduce the mental burden of debugging.

According to a fourth aspect of the present invention, in the debug processing system or the recording medium according to the third aspect, the execution processing is executed in the order of steps with the structure list of the program to be debugged displayed on the display means. In this case, the background color of the execution part in the same column is set as the first background color in the order of steps, and the second background color indicating the execution direction is displayed at the step where no execution is performed, and the third background indicating the end of execution of the function. By displaying colors, the progress display of the execution order of the structure list is displayed.For example, the execution processing order of the functions constituting the structure list, and the completion of the function is indicated only by the background color It is possible to easily grasp.
This makes it possible to know at which position (function) in the debug target program the bug has occurred by merely checking the background color, so that the bug can be corrected very easily. Therefore, since the location where the bug occurs can be greatly narrowed, the bug can be found and debugged in a very short time.

[Brief description of the drawings]

FIG. 1 is a schematic diagram showing a progress display of an execution processing order of a program structure list.

FIG. 2 is a schematic diagram showing a source program displayed by designating a background color of FIG. 1;

FIG. 3 is a diagram showing the progress of a source program displayed on a display device.

FIG. 4 is a flowchart illustrating an operation of the debug processing system.

[Explanation of symbols]

 Reference Signs List 10 debug processing system 11 computer 12 display device 13 input device 14 storage device 15 debug target program 16 source program 17 structure list 17A function 18 background color 18B blue 18D gray 18G green 18L down arrow 18P purple 18U up arrow 18W light blue 18Y yellow 19 record Medium 19A Floppy disk 21 Progress display 22 Execution sequence 23 Debugger program

Claims (4)

[Claims] 1. A debug processing system for detecting and correcting an error in a program to be debugged by using a processing device having a display unit, an input unit, a storage unit, and the like. A debug processing system for displaying a progress display of an execution processing order of the debug target program. 2. A process for executing a program to be debugged,
A computer-readable recording medium which stores a debugger program for causing a computer to execute a process of displaying a progress display on a display means of an execution processing order of the debug target program. 3. The debug processing system or recording medium according to claim 1, wherein a progress display of an execution processing order of the debug target program is displayed by a background color of the program displayed on the display means. 4. When the execution process is executed in the order of steps with the structure list of the program to be debugged displayed on the display means, the background color of the execution part in the same column in the order of the steps is set as the first background color, and the execution is executed. In the steps that are not performed, a second background color indicating the execution direction is displayed and a third background color indicating the end of execution of the function is displayed, so that the progress display of the execution processing order of the structure list is displayed. 4. The debug processing system or recording medium according to claim 3, wherein: