JPH01229339A - System for displaying debugging information - Google Patents

Abstract

PURPOSE:To make a succession relation intelligible and to facilitate debugging by displaying a succession tree and displaying the execution process of a method in a master class when the method in the middle of execution is defined in the master class. CONSTITUTION:When a user requests a certain class of the execution of the method, a window display means 1 opens and displays a window, and a succession tree display means 2 displays the succession tree showing the succession relation of the class to be requested, whereby a call class center display means 3 displays the call center. When the method is defined by the designated class, it is displayed as it is. When it is not defined, a master three is traced in the succession tree. When the defined class is detected, a defined class center means 4 displays the class center. When the execution of the method is executed, an execution process display means 5 displays the execution process in a center display frame. When the other method is called in the execution of the method, the means 1 opens a different window and a similar processing is executed by using it.

Description

[Detailed Description of the Invention] [Summary] For the purpose of easily understanding (informing) the class inheritance relationship of the method being executed in debugging an object-oriented language. a window display means for displaying a window for each class; an inheritance tree display means for displaying an inheritance tree indicating the inheritance relationship of the class in response to a method call; and a display including a method execution process display frame centered on the calling class. a calling class centered display means for displaying an execution process display frame centered on the definition class of the method when the definition class of the method is found; The system is configured to include execution process display means for displaying the execution process within.

[Industrial application field]

The present invention relates to debugging programs, and particularly to a method for displaying debugging information in an object-oriented language.

[Conventional technology]

Among programming languages, there are languages called object-oriented languages. This is a language in which the world is a collection of independent ``things,'' all ``things'' are expressed as objects, objects are considered as the center, and operations on objects are performed by sending messages. Object-oriented models are also used as artificial intelligence languages because they match our intuitive perception as models that represent the real world. A typical example is "Small Lalk."

Object-oriented languages have an inheritance function, and it is possible to reuse already created programs (classes).

By inheriting an already created class, you can use the functions (methods) of that class, and it is also possible to give different definitions to methods with the same name. Also, by inheriting multiple classes, you can create classes with various functions by combining existing classes. In addition, hierarchical multiple inheritance is also performed.

[Problem to be solved by the invention]

Although the inheritance function has these advantages, it also has the disadvantage that it is difficult to debug. By inheriting from another class, you will have methods that are not directly defined in your own class, so if you inherit many classes, the user who created it will not be able to figure out what methods can be executed. If a method that is not defined in that class is executed, it may become unclear which inherited class is using the method defined in it.

In the conventional debugging method, even when a method defined in an inherited class (parent class) is executed, it is displayed as a method of the inherited (child) class, so the method is not actually executed. If the user does not know which classes are defined in the program and does not remember the inherited classes and the methods defined in each class, the user must examine the source program, which makes debugging very difficult. be.

The problem to be solved by the present invention is to provide a debug information display method that eliminates such conventional problems.

[Means to solve the problem]

FIG. 1 shows a principle block diagram of the debug information display method of the present invention.

In the figure, ■ is a window display means, which provides and displays a window for each method call.

Reference numeral 2 denotes an inheritance tree display means, which displays an inheritance tree indicating the inheritance relationship of the class in response to a method call.

Reference numeral 3 denotes a calling class center display means, which displays a method execution process display frame centered on the calling class.

Reference numeral 4 denotes a definition class center display means which, when a definition class of the method is found, displays a display including an execution process display frame centered on the definition class.

5 is an execution process display means, which displays the execution process of the method in the execution process display frame.

[For production]

In this display method, while a program is being debugged, the parent class of the class to be debugged is displayed to clarify inheritance relationships. If the method being executed is defined in a parent class, the display is centered around that parent class so that the class in which the method is defined can be seen.

First, when a user requests a class to execute a method, the window display means 1 opens and displays a window, and the inheritance tree display means 2 displays an inheritance diagram indicating the inheritance relationship of the requested class. Figure 1 (1)))
The calling class center display means 3 performs a display centering on the calling class (FIG. 1(C)).

Next, if the method is defined in the specified class, it is displayed as is, and the execution process display means 4
displays the method execution process in the central display frame (Fig. 1(e)).

If the method is not defined in the specified class, the parent is traced through the inheritance tree to find the class that defines it. When the defined class is found, the definition class center display means 4 displays the found class (FIG. 1(d)), and when the method is executed, the execution process display means 5 displays the method. The execution process of is displayed in the central display frame (Fig. 1(e)).

If another method is to be called during execution of a method, the window display means 1 opens another window and performs similar processing using this window.

By displaying in this way, you can always understand the inheritance relationships of classes during debugging, and the class from which a method is defined becomes clear, making debugging much easier.

〔Example〕

The present invention will be explained in more detail below with reference to embodiments shown in FIGS. 2 to 5.

FIG. 2 is a diagram showing a system configuration of an embodiment of the present invention.

In the figure, 10 is an interpreter, 20 is an inheritance information file, 30 is a display device including a keyboard, and 40 is a program.

The interpreter 10 is a program that performs interpretation and execution, and receives a user's method execution request from the display device 30 and executes it while referring to a program 40 defined by the user. If the method is not defined in its own class, the inheritance tree information is fetched from the inheritance information file 20 and displayed, the parent class is traced, the display is changed to center on the class where the method is defined, and the execution process is displayed. Display within the center frame.

FIG. 3 shows the data structure of inheritance ↑ffN in one embodiment of the present invention. As shown in the figure, inheritance information is a single piece of information that includes a class and all of its parent classes, and only the direct parent class is described as the parent class.

FIG. 4 is a flowchart showing the operation of the interpreter in one embodiment of the present invention.

The operation will be explained below according to the steps of the flowchart.

Processing starts when a request for execution (method call) of a method made up of a class made up of users is issued.

■Create and display a window on the display screen.

■Search the inheritance information file, read the inheritance information indicating the inheritance relationship of the called class, and display the inheritance tree.

■Display the execution process display frame centered on the calling class.

■Check whether the method is defined in the class, and if it is defined, proceed to step ■; otherwise, proceed to step ■.

■Check if there is an unexplored parent class, and if so, step■
If no search is found, it will be displayed as a search failure and the process will end.

■Extract one parent class from the inheritance information and return to step ■.

■Display the execution process frame centered on the definition class. If this is the calling class, the display in step ■ remains as it is.

■Execute the method according to the execution request and display the execution process in the execution process display frame. If a call to another method occurs while a method is being executed, the process jumps to step (2) for that method.

■In the case of a method based on inheritance, determine whether the method execution was a failure, and if it is a failure, step [phase]
If not, jump to step 0.

[Phase] Invert class display (reverse display color and background color)
do.

■Determine whether the call was from another method, and if so, proceed to step @; if not, terminate the process.

■Delete the current window and end the process.

FIG. 5 is a diagram showing an example of a display during execution of processing according to an embodiment of the present invention.

FIG. 5(a) shows an example of an inheritance tree display, showing that class C inherits from classes a and b. That is, a −
+c indicates that a is the parent class of C.

Assume now that method m is not defined in class C, but is defined in classes a and b.

At this time, when the user issues a request to class C to execute method m, the diagram shown in FIG. 5 (bl) is displayed.

Since method m is not defined in class C, the parent class of C is checked. Since it is known that method rn is defined in class a, an execution process frame is displayed centering on class a as shown in FIG. 5(C), and the execution process of method rn of class a is displayed in this display frame.

Here, if execution in class a fails, a is highlighted and the next parent class is examined. Since method m is also defined in class b, the execution process of method m in class b is displayed as shown in Figure 5 (di). If this execution is successful, it means that the user has successfully executed method m of class C.

〔Effect of the invention〕

As explained above, according to the present invention, when debugging an object-oriented language, the inheritance tree is displayed, and if the method being executed is defined in the parent class, the execution process of the method is displayed in the parent class. By displaying, inheritance relationships are easy to understand and classes that are actually defined during execution can be known.Furthermore, by displaying calls of other methods being executed separately, the distinction becomes clear and contributes to debugging efficiency. The effect of doing so is extremely large.

[Brief Description of the Drawings] Fig. 1 is a block diagram of the principle of the present invention, Fig. 2 is a diagram showing the configuration of an embodiment of the present invention, and Fig. 3 is a data structure of inheritance information in an embodiment of the present invention. FIG. 4 is a flowchart showing processing according to an embodiment of the present invention, and FIG. 5 is a diagram showing an example of display according to an embodiment of the present invention. In the drawings, 1 is a window display means, 2 is an inheritance tree display means, 3 is a calling class center display means, 4 is a definition class center display means, and 5 is an execution process display means. Fig. 3 is a diagram showing the data structure of inheritance information in the eggplant parsley of the present invention; Fig. 3 is a flow chart showing the processing according to an embodiment of the present invention;
4 Figure (b) (
c) Diagram showing an example of display in one embodiment of the present invention
5 Figure

Claims (1)

[Claims] In debugging a program using an object-oriented language, there is provided a window display means (1) that displays a window for each method call, and an inheritance tree that shows the inheritance relationship of the class according to the method call. an inheritance tree display means (2) for displaying a method; a calling class centering display means (3) for displaying a method execution process display frame centered on the calling class; Definition class center display means that displays a method execution process display frame in the center (
4), and an execution process display means (5) for displaying the execution process of a method in the execution process display frame.