JPH0264746A - Input/output control system in debugging system - Google Patents

Abstract

PURPOSE:To improve operability and debugging efficiency by making an existing line input debugger usable as the full screen debugger by using a window. CONSTITUTION:At an input/output interface part 16 of a processor (CPU/ memory) 15, a window control part 17 controls a window to be displayed on a display 11, and at a line input debugging processing part 22, debugging control is executed on a debugging objective program with a line input/output as a basis. A menu/command converting part 18 converts debugging instruction inputted by a menu through the control part 17 into a command, and an output converting part 21 converts the output of the line input debugging processing part 22 and makes it as the input of the window control part 17. By such a constitution, the processing function of the existing line input debugger can be used as it is, the full screen debugger which can use a window 12, a mouse 13, a keyboard 14, etc., is realized.

Description

DETAILED DESCRIPTION OF THE INVENTION (Summary) This invention relates to an input/output control method in a debug system that controls execution of a program to be debugged and outputs debug information.

The purpose of this is to enable the existing line input debugger to be used as a full-screen debugger using a window, improving operability and debugging efficiency.

The window 111m section controls the windows displayed on the display, the line input debug processing section is based on line input and line output, and has a debug control function for the program to be debugged, and the window control section allows input from the menu. A menu/command converter converts the debugging instruction information into commands according to the input format of the line input turnip bag processing section, and outputs the output of the line input debugging section so that it becomes input to the window wI control section. and an output conversion unit that performs conversion, and is configured to input and output debug information using a window.

[Industrial application field]

The present invention controls the execution of a program to be debugged,
It relates to an input/output control method in a debug system that outputs specified debug information.

To improve the reliability of developed programs.

It is important to test whether the program operates normally, and the time required for debugging it tends to increase year by year. Therefore, there is a need for tools that can perform efficient debugging.

[Conventional technology]

Figure 9 is an example of a conventional line input debugger.
Figure 0 shows an example of debugging using the conventional method.

In FIG. 9, 100 is a TTY screen where display output is performed line by line, and 101 is a conventional and commonly used line input debugger that is based on line input and line output.

The operator inputs commands to the TTY screen 100 by line input from the keyboard, and the line input debugger 101 operates by receiving commands from the TTY screen 100. In addition, the line manual debugger 101 displays the result output on the TTY screen 100, and the operator
Line human debugger by looking at 100 TTY screens! The receiver receives messages sent by O1.

Figure 10 shows the conventional line manual debugger 1 shown in Figure 9.
A specific example of debugging using 01 is shown. The operations ■ to ■ described below correspond to the operations shown in FIG. 10. In addition, ■ and ■.

These are messages notified by the debugger, and other commands are input by the operator.

■ Start the line-in debugger. The name of the program to be debugged is test.

■ A breakpoint is set at address 24 (hexadecimal) of the main program n+ain to interrupt execution.

:r” command, the debug target program tes
It instructs to start and execute t.

■ Execution is interrupted at address 24 (hexadecimal) of main program +eain. (Message from the debugger) ■ The contents of the register are displayed using the “$r” command.

■ Display the value of external variable 1ongna+mevar.

■ :01 command instructs to continue execution from the breakpoint.

■ The process finishes running. (Message from the debugger) ■ Instructs to end debugging.

■ [Problem to be solved by the invention] With conventional line manual debuggers like the ones above.

There are the following problems.

(a) When an operator issues some instructions to a line input debugger, he must input the commands by typing them on the keyboard. The operator must memorize commands by referring to an operating manual, and input using a keyboard is not easy for the operator to use.

(g)) Output from the line manual debugger is performed on the TTY screen. Output to TTY screen.

It will be in a dripping display state! When the i-side becomes full, you can only scroll downwards and cannot see the display at the top.

Therefore, in order to solve such problems, there is a demand for making the line input debugger operable using a window or a mouse. Therefore.

You will need to interface your existing debugger with new input/output devices such as windows and mice.

The present invention aims to solve the above-mentioned problems, and aims to provide a means for improving operability and debugging efficiency by enabling an existing line manual debugger to be used as a full-screen debugger using a window.

[Means to solve the problem]

FIG. 1 shows an example of the configuration of the present invention.

In FIG. 1, 11 is a display, 12 is a window that is a display frame that can be set in multiple sizes on the display screen, 13 is a mouse for selecting items on the screen, 14 is a keyboard, and 15 is a display frame. 16 is an input/output interface section; 17 is a window control section that performs input/output via the window 12; and 18 is a menu/command conversion section.

19 is a command buffer, 20 is an output buffer 7 in which output messages are stored, 21 is an output conversion unit that converts output to the window control unit 17, 22 is a line input debug processing unit, and 23 is a debug control unit according to commands. A debug control section that performs.

24 is a startup execution section, 25 is a breakpoint setting section, 2
6 represents a disassembling section, and 27 represents a program to be debugged.

The line input debug processing unit 22 debugs the program to be debugged 2 according to commands input in line input format.
A startup execution unit 24 that controls the startup execution of .7. A breakpoint setting unit 25 sets an execution interruption point for the debug target program 27; a disassemble unit 26 disassembles the instruction code of the debug target program 27. others.

Although not shown, it has various debug processing functions such as continuous execution, register contents display, and variable display.

These various processing functions are realized by utilizing the processing functions of the conventional line input debugger 101 shown in FIG.

While the conventional line input debugger 101 directly performs line input from the keyboard and line output of messages, the line input debug processing unit 22 according to the present invention inputs and outputs input and output via the input/output interface unit 16. It is designed to do this. This is achieved by rewriting the input/output function or input/output subroutine in the conventional line manual debugger 101 and changing its input/output edge to the input/output interface unit 16.

The window control unit 17 has well-known window control functions such as nine-screen division and menu selection control using the mouse 13.

The menu/command conversion unit 18 is a window control unit 1
7, debug instruction information input from the menu is converted into a command according to the input format of the line input debug processing section 22, and the command is stored in a predetermined command buffer 19. Command buffer 19
By reading the line input debug processing unit 22
performs processing using commands similar to those input from a conventional keyboard.

The processing result by the line input debug processing section 22 is notified to the output conversion section 21 by a function call or a subroutine call, and the output conversion section 21 sets the output contents in the output sofa 20 provided on the memory.

The window control unit 17 re-edits the message set on the cover sofa 20 according to a predetermined format and outputs the edited message to the window 12 for display.

[Effect]

By providing the input/output interface section 16 between the line input debug processing section 22 and the display 11 and mouse 13, it becomes possible to use the processing functions of the conventional line manual debugger as is, and
Window 12. A full-screen debugger that can use various input/output devices such as the mouse 13 or the keyboard 14 is realized.

As the line input debug processing unit 22, most of the processing functions of existing debuggers can be used as is, so development time and cost can be significantly reduced compared to developing a completely new full-screen debugger. be able to. In addition, it has functions not found in conventional line input debuggers.

It can be added inside or outside the line input debug processing section 22 as necessary.

〔Example〕

FIG. 2 is an explanatory diagram of processing operation according to an embodiment of the present invention, FIG. 3 is an explanatory diagram of startup execution processing according to an embodiment of the present invention, and FIGS. 4 to 8 are examples of debugging according to an embodiment of the present invention. shows.

In the present invention, as shown in FIG. 2, a window 12, an input/output interface section 16. The full screen debugger 30 is constituted by the line input debug processing section 22 and the like.The series of processing operations during debugging according to the present invention is, for example, as shown in (1) to (2) shown in FIG.

- The operator operates the mouse and selects a menu on the window 12 by clicking the mouse button.

■ The input/output interface unit 16 reads menu selection information on the window 12.

(2) Converting the menu selection information into a command for the line input debug processing unit 22, that is, a command corresponding to the input format for a conventional line input debugger.

■ Set the converted command in the command buffer,
The line input debug processing unit 22 is notified. As a result, the line input debug processing section 22 operates and outputs a message to the operator regarding the processing results and the like.

■ The message is set in the output cover in memory.

■ The input/output interface unit 16 cleans the contents of the buffer. That is, it is edited into a display format on the window 12.

(2) The input/output interface section 16 displays the corrected message on the window 12 at the appropriate timing.

■ The display on the window 12 is recognized by the operator. When the operator instructs scrolling of 3 displays, the input/output interface unit 16 uses well-known window control, regardless of the line input debug processing unit 22.

Scroll the displayed content, if there is insufficient information in the scrolling display.

The input/output interface section 16 generates a command to the line input debug processing section 22, and the necessary information can be received from the line input debug processing section 22. Scrolling can be made faster by processing such as 0 or more. It will be done.

FIG. 3 shows an example of processing related to command issuance during startup execution in one embodiment of the present invention.

In the following explanation, fa) to (kl) correspond to the processes (al to (kl) shown in FIG. 3).

fa) When starting the debugger, perform setup such as displaying the initial screen and initializing various tables.

Yama) Receives input events from the mouse, etc.

tel Determine whether the input event is "process startup execution".

ldl If the input event is not "process startup execution", execute processing according to other input events.

(el If the input event is "process startup execution", open the input screen option sheet for inputting selection items such as module path name, address, parameters, etc.).The input screen option sheet is used for data input. It is a predefined window.

(fl Display selection items on the human-powered screen option sheet.

(Kozue: Receives the data entered on the input screen option sheet by the operator.

(hl The line input debug processing unit 22 shown in FIG.
Generate a startup execution command, for example “:r”, for
Store in command buffer.

+11 Close the manual screen option sheet.

('') Issues the startup execution command stored in the command buffer to start and execute the debug target program 27.

佽) When the debug end signal is received, the process ends. If not, return to process fbl.

Repeat the process in the same way.

The above processing flow is mainly for process startup execution, but the same applies to processes such as setting breakpoints and displaying variables.

Next, a specific example of debugging according to an embodiment of the present invention will be described with reference to FIGS. 4 to 8. Regarding the content of debugging in the following example, please refer to the conventional example shown in Fig. 10.
It is functionally equivalent to ■.

A debug system according to an embodiment of the present invention.

When this full-screen debugger is activated, a window screen as shown in FIG. 4 is displayed. Here, parameters such as the module name of the program to be debugged are input. When "Execute" in the lower left corner is clicked with the mouse, the window screen shown in FIG. 5 is displayed.

In the screen shown in FIG. 5, 50 is a global menu, 51 is a disassembly list display area, 52 is a register contents display area, and 53 is a data display area such as stack contents.

In the disassembly list display area 51, the module destination is displayed first! ! A disassembly list starting from (4th byte) is displayed. The portion corresponding to the value of the program counter indicating the execution address, in this example, the instruction at address 4 of main+Ox is highlighted. In addition.

In FIG. 5, the instruction at the execution address is shown surrounded by a square instead of 9 highlighted. By operating the arrow at the right end of the window shown in FIG. 5 with a mouse, the display contents of the disassembly list display area 51 can be scrolled up and down. Of course, scrolling forward from the beginning of the module is suppressed.

When displaying a disassembly list as shown in FIG. 5, the window control unit 17 shown in FIG. 1 automatically generates a command instructing disassembly.

The disassembling unit 26 in the line manual debugging processing unit 22 is called, and the line-by-line output from the disassembling unit 26 is received via the output cover sofa 20, and it is written in a fair copy and displayed in the disassembly list display area 51. indicate.

When "1 Execution Control" in the global menu 50 is selected with the mouse, its pull-down menu is expanded.The pull-down menu includes "Process Startup Execution" and "Breakpoint Setting".

There are other menu items.

When 9, for example, "Breakpoint settings" is selected with the mouse, an option sheet for viewing breakpoints as shown in FIG. 6 is displayed.

Modes include setting or canceling breakpoints.

Here, the main program main+ (lx 24.
That is, an input is made to set the execution interruption point at address 24 in hexadecimal.

When "Process Startup Execution" is selected from the "Execution Control" pull-down menu in the global menu 50 shown in FIG. 5, the result is displayed as shown in FIG.

An option sheet for starting the process will be displayed. Here you can enter the module path name, address, parameters, etc. Here, when an "execution" instruction is given, a startup execution command is generated by the process shown in FIG.

By starting and executing the debug target program with the module name test t, the instructions from the beginning are executed sequentially, and the
When execution control is transferred to the breakpoint in+ox24, execution is interrupted there. then.

Display of the disassembly list, display of register contents, display of data such as stack at the execution interruption point is the fifth
This is done through a window as shown in the figure. In the disassembly list, the instruction at address main+OX24 is highlighted.

If you select "Information Output 2" in the global menu 50 and select "Display Variable" from the pull-down menu,
A variable display window is output. Here, variable name 1
For example, when longnaevar is input manually, the values of variables in various numerical formats are displayed based on the address of variable 1ongnamevar, as shown in FIG.

After checking the variable display, select the "Run process m'iA" menu. A screen similar to the process startup execution window shown in Figure 7 will be displayed, and according to the execution instructions, the program to be debugged will be executed. will be resumed. When the execution of the program to be debugged is finally completed, guidance for confirming the completion is output, and upon inputting the confirmation, the display returns to the initial screen as shown in FIG. 4.

As described above, in this embodiment, instead of inputting commands,
Debug instruction information can be entered manually by selecting menus using the mouse. Also.

At the execution interruption point of the program to be debugged, etc.

Since the disassembly list and register contents are automatically displayed, there is no need to enter the command manually.
By scrolling if necessary.

You can view the disassembly list before and after that with a simple operation.

〔Effect of the invention〕

As explained above, according to the present invention, an input/output device such as a mouse or a window is connected to a conventional debugging system based on line input and line output, thereby providing a debugging system with good operability and debugging efficiency. will be able to realize it.

[Brief explanation of the drawing]

FIG. 1 shows a configuration example of the present invention. FIG. 2 is an explanatory diagram of processing operations in an embodiment of the present invention. FIG. 3 is an explanatory diagram of a startup execution process according to an embodiment of the present invention. 4 to 8 show debugging examples according to an embodiment of the present invention. Figure 9 is an example of a conventional line input decoder. FIG. 10 shows an example of debugging using the conventional method. In the figure, 11 is a display, 12 is a window 13, a mouse, 14 is a keyboard, 15 is a processing device, 16 is an input/output interface section, 17 is a window control section, and 18 is a menu/command conversion section. 19 is a command buffer, 20 is an output sofa. 21 is an output conversion unit, 22 is a line input debug processing unit,
23 is a debug control unit, and 24 is a startup execution unit. Reference numeral 25 represents a breakpoint setting section, 26 a disassembling section, and 27 a debug target program. Patent ratio: 11 people Representative: Fujitsu Limited Patent attorney: Yoshiyoshi Ogasawara (2 others)
m

Claims (1)

[Claims] A debug system that controls the execution of a program to be debugged (27) and outputs debug information, comprising a window control unit (17) that controls a window displayed on a display, and a line input and line output. Basically, a line input debug processing unit (22) having a debug control function for the program to be debugged and the window control unit input debug instruction information input from the menu into the input format of the line input debug processing unit. a menu/command conversion unit (18) that converts the output of the line input debug processing unit into a command according to the above, and an output conversion unit (21) that converts the output of the line input debug processing unit so that it becomes input to the window control unit. An input/output control method for a debugging system, characterized in that debugging information is input/output using a window.