JPS63317840A - Program debugging method - Google Patents

Abstract

PURPOSE:To realize an easy and accurate program debug system by displaying the executing traces of each module on different windows and switching the display screens with call of modules. CONSTITUTION:A program including plural modules is debugged as a program 16 to be debugged. In this case, plural windows 13 are displayed on a display 12 for each module. Then a module Mj is called by a call sentence while another module Mi is carried out under the control of a program execution control part 14. Thus a window Wj corresponding to the called module Mj is displayed on a screen with preference. When the executing trace is through with the module Mj via the window Wj, the window Wj is erased or moved under another window that receives the preference. Then an original state, i.e., a window Wi of a module Mi is displayed with preference.

Description

[Detailed Description of the Invention] [Summary] This invention relates to a program debugging method, in particular, utilizes multi-window technology that displays multiple windows on one screen, and allows individual debugging of a program consisting of multiple modules. To provide a program debugging method in which modules are made to correspond to each window and debug information for each module is displayed for each window.

Conventional program debugging methods target the entire program and display debugging information on a single screen while scrolling, which has the disadvantage that it is difficult to understand mutual coupling relationships between modules, especially calling relationships using call statements. Ta.

The present invention debugs a specific module for each statement, and when another module is called by a call statement, the window corresponding to the called module is prioritized over the currently displayed window. This is a debugging method that displays information on a display and uses multiple windows that correspond to the logical structure of the program or the hierarchical structure of modules.

According to the present invention, the execution trace of each module is displayed in a separate window, and the display screen is switched by calling a module, so that the program can be debugged easily and accurately.

[Industrial application field]

The present invention relates to a program debugging method for discovering and correcting program errors, and in particular utilizes multi-window technology that displays multiple screens to display information on individual program modules in each window. This invention relates to a program debugging method that enables debugging.

[Traditional technique]

In order to discover and correct errors in a program, a debugger is generally used to debug the program. Generally, a program is configured by combining a plurality of modules in a hierarchical manner, and when debugging a program, it is often the case that a specific module is first specified and then information within that module is specified. In order to discover and correct errors in the programs created in each module, the flow of program execution can be checked by tracing the program execution for each statement, which is the smallest unit of the program, using a debugger and displaying the results in order. , examine program information such as variable values as needed. In this way, a program is composed of multiple modules, and there is a mutual relationship between the modules.
Although they are more closely linked by the l statement, conventional debugging methods target the entire system to be debugged, and the execution trace information of multiple modules is mixed together and displayed on a single screen.

[Problem that the invention seeks to solve]

In such conventional program debugging methods, the mutual relationship between each module was not considered important, so it was troublesome to identify which part of the trace belonged to which module, and it was also difficult to identify which part of the trace belonged to which module. It was also difficult to confirm the relationship, that is, what parameters were used when calling, and what values were returned when exiting or returning. Furthermore, in conventional debugging methods, the entire program is treated as one unit, so in order to obtain information such as local variables within a module, you must first identify the module and then specify the information you want to obtain. It had the disadvantage that it could only be done on one screen.

The present invention uses multi-window technology that displays multiple windows on a display image to display the execution trace of a program to be debugged in a window for each module that makes up the program, so that a debugger can check the calling relationships between modules. To provide a program debugging method that allows you to check the flow of program execution while checking it.

[Means for solving problems]

The configuration of the system of the present invention is shown in FIG. 1(a). In the present invention, the program to be debugged is executed in separate windows for each module that constitutes the program, and debugging means is provided for each displayed module.

The program to be debugged 16 is composed of a plurality of modules, that is, program modules 17 . The program execution control unit 14 executes the module 17 one sentence at a time and displays the trace on the first window 13 of the display device 12. If the executable statement is a call to an external module, a second window 13 for executing the external module is created on the display device 12, and the newly created second window 1 is
Trace the execution of the external module called in step 3. When the module finishes executing (axit), the second window 13 for that module is removed from the display screen 12 (or moved below the preferred window), and the call statement of the calling module is Immediately after, execution tracing is restarted on the first window 13. 3rd in module of 2nd window 13
The same applies when calling the module. The debugger 11 can inquire about information regarding the module and request execution control from each window 13, but when the program execution control unit 14 receives such input, it is activated for each window (module). The debugger 15 is used to perform the requested processing. Note that a known debugger can be used as the debugger 15 as is. The above process is repeated until all modules in the program exit.

[For production]

Tracing the execution of each module is done on its corresponding window, and when a call to another module occurs within the current module, the execution tracing on that window is paused, and the execution tracing of the called external module is started. Start in a separate window. When the execution of this external module is finished, the suspended execution trace of the calling current module is resumed. Each window also performs execution control such as making inquiries about the values of variables related to the module being executed in that window, pausing execution, and changing tracing.

〔Example〕

Next, embodiments of the present invention will be described with reference to the drawings.

The present invention is a debugging method that utilizes a multi-window method in which a plurality of windows are displayed on one display screen, and performs debugging while displaying information on individual modules of a program in each window.

FIG. 2 is a relationship diagram showing the relationship between a program 20 consisting of a plurality of modules and a display screen 21 having a multi-window function in the program debugging method of the present invention. The program 20 includes, for example, modules 1, 2, 3, . In the present invention, each module is logically and hierarchically connected.
There are windows on the display screen 21 corresponding to each module hierarchically connected in this way. Module l corresponds to window l,
Module 2 corresponds to window 2 and module 3 corresponds to window 3. Then, in each window corresponding to each module, the execution results of the corresponding module or the contents of the execution trace by the debugger are displayed. That is, the display contents of the window 1.2.3 are the execution results or execution trace contents of the module 1.2.3, respectively. Then, the window in which the trace is currently being executed is controlled to transition to another window.

In the system shown in FIG. 14 is a program execution control unit that manages processing and control of each module of the program displayed in each multi-window according to the multi-window function;
The control unit 14 includes a debug function using a debugger 15. Further, 16 is a debugged program stored in the main storage unit, which includes a plurality of modules, for example, modules 1. Module 2. It is configured by logically and hierarchically connecting a plurality of modules including module 3 and the like. FIG. 1(b) briefly shows the structure of the program statements that are the contents of each module. For example, module 1 calls module 2 after a set of non-cal1 statements such as assignment statements. call modu
le 2” statement, followed by a set of non-cal1 statements and finally an ex to exit module 1.
There is an it statement. Similarly, module 2 has a cal that calls module 3 after a set of non-cal1 statements such as assignment statements.
l module 3" statement, followed by a set of non-cal1 statements, and finally an exit statement to exit module 2. Module 3 has no call statement that calls other modules, and is simply an assignment. Sentences etc. non-c
This is a module that executes the al1 statement and exits with the exit statement.

In the present invention, when debugging a program composed of such modules as the program to be debugged 16, a plurality of windows 13 are displayed for each module on the display device 12, and the program execution control unit 1
4, when another module Mj is called by a call statement while the module Mi is being debugged, the window Wj corresponding to the called module Mj is preferentially displayed on the screen. Therefore, the window Wj
and display the execution trace of that module Mj. When the execution trace of debugging module Mj using window Wj is finished, the 'window Wj
is removed or moved below the superseded window. And the original state, that is, the window Wi of module Mj
to be displayed preferentially.

At this time, if debugging processing by the debugger 15 is required in each window, the program execution control unit 14 uses this as a debugging means to check the value of a variable or set the value of a variable to a certain value. has. That is,
The program execution control unit 14 has a call in each module.
When another module Mj is called by a statement, the window W corresponding to that module Mj is
j and debugger 15 in that window WjO.
If necessary, the debugger 15 is operated.

In other words, this control follows a multi-process method in which the debugger 15 is operated for each process of each window.

For example, as shown in Figure 1 (bl), module 1.2゜3
The debugged program 16 consisting of
) When debugging the system shown in ), window l corresponding to module 1 is initially displayed.

Module 2 is the same as module 1'''call mod
ule 2'', window 2 corresponding to module 2 is displayed preferentially by executing this call statement.Furthermore, window 2 corresponding to module 2 is displayed preferentially.
is called by "call module 3", so by executing this call statement, window 3 corresponding to module 3 is preferentially displayed. module 3
does not call any other module, so after executing exit, window 3 is deleted and the original window 2 is displayed. Then, by executing the module 2 exit, the display returns to the module 1 display.

An example of window display transition within a screen under the control of the program execution control unit 14 is shown in FIG.

In FIG. 3, screen (1) shows a state in which module 1 is in the middle of execution and immediately before module 2 is called, and window 1 corresponding to module 1 is displayed. When module 2 is called by call module 2'' in the module, screen (2) will be displayed.In other words, window 1 of module l will be below window 2 of module 2, and window 2 of module 2 will have priority. will be displayed.

Furthermore, the state of screen 2 is “call” in module 2.
If module 3 has just been called with modqle 3'', the contents of module 3 are not present yet, but window 3 corresponding to module 3 is created and displayed.Then, processing by the debugger is executed within module 3. The screen will transition to screen (3), and tracing will be executed in module 3 of window 3, including checking the values of variables and setting variables.Just before the execution of module 3 ends, the screen shown in screen (4) will be executed. e of module 3 so that
xit processing is performed. When the processing routine is exited from module 3 by this exit, window 3 corresponding to module 3 is deleted in this example, as shown in screen (5). Debug trace is module 2
However, when module 2 finishes executing, the screen (
As shown in 6), window 2 corresponding to module 2 also disappears from the screen in this example, and execution is shifted to the processing of module 1 again. Therefore, only window 1 of module 1 remains on the screen, and exit processing is performed when execution of module 1 ends.

Next, the processing flow executed by the program execution control unit 14 will be explained using FIG.

When the process starts, in step 41, it is determined whether or not there is a request from the debugger 11 to the debugger 11. If there is no request, in step 42, the program statement in the current module is traced by one step. is executed, and in step 43 the trace result of that step is displayed in the window corresponding to the current module. That is,
In each module, trace display and trace information are prepared for each step. When the processing routine moves to step 44, a process for determining whether the current module is calling another external module is executed. If it is callL, the process moves to 45,
Window creation processing is performed to display the window of the external module on the screen. If the current module does not call another external module, the process moves to 46, where it is determined whether the current module should exit. If it is an exit, the window of the current module is generally deleted in process 47, and the process moves to process 48. If it is not an exit, the process directly proceeds to step 48 to execute the current module. In step 48, it is determined whether or not the execution of the program has been completed. If the program has not been completed, the process returns to step 41 and the same processing is performed. In process 41, if there is a request from the debugger, the process moves to process 49, calls the debugger 15, and processes the request. For example, check the value of a variable, set the value of a variable, etc. Then, the process moves to step 48, where it is determined whether the program execution has ended. If the execution of the program has ended in process 48, it becomes end.

In this way, in the program execution control section 14 of the present invention, 1
Prepare a trace display for each step, and if there is a call from an external module during the execution of the current module, create a window for that external module, and if there is no call, display the exit if the current module has one. Delete a module. This processing flow is repeated until the program execution is completed. If there is a debug request during processing, the debugger 15 is called and debug processing is performed.

〔Effect of the invention〕

According to the present invention, the execution trace of each module is displayed on a separate screen, and the display screen can be switched by calling a module, and debugging means can be provided for each module, so the logical structure of the program can be Debugging work can be performed in accordance with a certain module structure.

Therefore, the present invention has the advantage that debugging can be performed according to the logical structure of a program, and software can be debugged easily and accurately.

[Brief explanation of drawings]

Figure 1 (Ta) is a system diagram showing the basic configuration of the present invention, Figure 1 (b) is a diagram briefly showing the contents of each module, and Figure 2 (Ta) is a system diagram showing the basic configuration of the present invention. 3 is a diagram showing the relationship, FIG. 3 is an explanatory diagram of the transition of window display on the screen under the control of the program execution control section, and FIG. 4 is a processing flow of the program execution control section. DESCRIPTION OF SYMBOLS 11... Debugger, 12... Display device, 13... Window, 14... Program execution control unit, 15... Debugger, 16... Program to be debugged, 17... Module. Patent applicant: Fujitsu Ltd.
7th grade call module 2 ca
ll module 3'(b
) 4-Moji 1-/Shimeuchi Keise Tomoh 1=f4Z Figure 1 11° Tem buffer 12 ・Dice array device 13...tsu (ndoku 14...bu O) tsumu, tsu(tT Condolence gP country 1
5... Dill 1. Force゛16... version de power tour 07゛°hum17...
... 7th Gen'il misfire 88's exhaustion $4'7 structure eight'''i-〒・T'＞S T Muro Figure 1 Marlenau'i> Dokupiri Aki Tsubasa E-cho, T6 Gu Figure 2

Claims (1)

[Claims] 1) In a computer system, a debugged program (16) in a main memory is executed in a central processing unit;
In a program debugging method for discovering and correcting errors in a program, a window (one
3) on the screen of the display device (12); and means (15) for executing debug processing on the module corresponding to the displayed window (13); A program debugging method characterized in that a program to be debugged is executed on a module-by-module basis in separate windows, and each module is further debugged. 2) The control means includes a processing means for tracing a module corresponding to a currently displayed window among windows corresponding to a plurality of the modules. program debugging method. 3) The program according to claim 2, wherein the control means has a window display means for displaying a window with priority given to a window corresponding to a current module that is being traced by the processing means. Debug method. 4) When a call to another external module occurs in the current module, the control means suspends the execution trace on the window corresponding to the current module, and controls the execution trace to correspond to the called external module. the window of the external module is preferentially displayed by the window display means, and the trace of the called external module is executed by the processing means; 4. The program debugging method according to claim 3, wherein said processing means is capable of controlling restart of execution of said current module.