JPH10240564A - Debugging method and debugging system for object-oriented program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a debugging system capable of verifying an operation relating to the generation and extinction of an object without the need of setting a break point beforehand or the like. SOLUTION: A message monitoring sub system 11 imparts an instance variable for storing a message name and a transmission origin object name for urging the generation and extinction of the object to the respective objects. In the meantime, a memory monitoring sub system 12 prepares a memory table for managing a memory area used by the object and updates it corresponding to the generation and extinction of the object. Then, the message monitoring sub system 11 informs the transmission/reception of a message for urging the generation or extinction of the object and the memory monitoring sub system 12 informs the change of a memory state accompanying the loading or extinction of the object and thus, a user is provided with information relating to the generation and extinction of the object.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method and a system for debugging an object-oriented program. Regarding the debugging system.

[0002]

2. Description of the Related Art In a conventional debugger such as a C ++ compiler debugger, when verifying the creation and deletion operations of an object, the source code is executed line by line, and the object exists at a preset breakpoint. It is common to check whether or not to do so by referring to the memory.

[0003]

However, in such a method, the timing at which a certain object is created or deleted can be confirmed only by a preset break point. Also, since the source code is displayed on a line-by-line or block-by-line basis on the execution screen, in an object-oriented program in units of objects, it is difficult to understand the objects and messages that directly cause an object to be created or deleted. . Therefore, in a situation where messages are transmitted and received between a plurality of objects, it has been difficult to detect that an object is created or disappears against the intention of the programmer.

[0004] The present invention has been made in view of such circumstances, and provides a debugging method and a debugging system capable of verifying an operation relating to generation and extinction of an object without setting a breakpoint or the like. With the goal.

[0005]

SUMMARY OF THE INVENTION In order to achieve the above-mentioned object, the present invention provides an object in which information relating to creation and destruction of an object is held as an instance variable, and the update of the object is monitored and output. The purpose is to verify the creation and destruction operations of each object.

Therefore, according to the present invention, a user can respond to a message prompting creation or deletion of an object without having to set a breakpoint in advance, for example, even though the message has been transmitted or received. The object is loaded or erased from memory even though the object is not loaded or erased from memory, or no message prompting creation or destruction of the object has been sent or received. In this way, it is possible to detect an illegal operation related to the creation or extinction of an object, such as the occurrence of an object, so that the operation of creation and extinction of each object can be verified very easily as compared with the related art.

[0007]

Embodiments of the present invention will be described below with reference to the drawings. As shown in FIG. 1, a debugging system 10 according to this embodiment operates on a device including a CPU 1, a main memory 2, an external storage device 3, an input device 4, and a display device 5. It is configured as a program stored in the memory 2 and executed and controlled by the CPU 1. And this debug system 10
Comprises two subsystems, a message monitoring subsystem 11 and a memory monitoring subsystem 12.

[0008] The message monitoring subsystem 11 is for adding an instance variable to the object itself for storing the name of the message that caused the generation and deletion of each object and the name of the object that is the source of the message. On the other hand, the memory monitoring subsystem 12
Creates a memory table for managing the memory area used by the object that operates as an application, the memory area used by the object, the object name used, and whether the object is recognized from the system. It is for managing information. Then, the memory monitoring subsystem 12 updates the contents of the above-described memory table every time an object is generated or deleted.

Here, an outline of data processing based on object orientation will be described with reference to FIG. 2 and FIG. The object-oriented program is configured in units of objects having different functions, and each of these objects 20 includes an instance variable 21 and a method 22 for processing the same. Then, when a certain object receives a message from another object, data processing is performed by activating a method having the same name as the message in the received object. For example, the message "d
When “displayData” is transmitted from outside (FIG. 3
Step A1), the method “d” of the object A
displayData "is started (FIG. 3
Step A2). And "displayDat
By executing the process described in “a”, the variable of the object A is updated, a message is transmitted to another object, and the like.

Next, the operation principle of the message monitoring subsystem 11 and the memory monitoring subsystem 12 of this embodiment will be described. The message monitoring subsystem 11
Prior to execution of the program, instance variables and methods are added to all objects as shown in FIG.

(1) addAinstance: instance variable An instance variable for storing the name of the object that transmitted the message when the message prompting creation or deletion of the object is received.

(2) addAmethod: instance variable An instance variable for storing a message name when an object receives a message prompting creation or destruction of the object.

(3) showAinstance: method "addAinstance" or "addAmet"
A method for notifying the system that the "hod" instance variable has been updated.

On the other hand, the memory monitoring subsystem 12 creates a memory table on the main memory 2 for managing a memory area used by an application as shown in FIG. The following three items are stored in this memory table.

(1) Symbol for specifying an object to be loaded on the memory (2) Loaded address (3) Flag indicating whether loaded on the memory or deleted from the memory The initial value of the flag is 0 And This memory table is updated as follows in accordance with generation and disappearance of an object.

First, when an object is loaded on a memory, a symbol and an address indicating the object are written on a memory table, and a flag is set to "1". On the other hand, when the object is deleted from the memory, the flag corresponding to the deleted object is changed to 2. Therefore, it indicates that writing is possible on the address where the flag is 1, and when a new object is loaded, the value of the flag is changed to 1 and a symbol indicating the newly loaded object is displayed. Will be written.

Next, an operation procedure of the debug system 10 including the message monitoring subsystem 11 and the memory monitoring subsystem 12 will be described with reference to FIGS.

After the execution of the program is started, for example, when a message "createObject" prompting generation of object A is transmitted from object B (steps B1 to B3 in FIG. 6), the message monitoring subsystem 11 adds the message. Object A
The name of the object B is substituted for the instance variable "addAinstance" of the object A, and the message name "createObject" is substituted for the instance variable "addAmethod" of the object A (step B4 in FIG. 6).

When the values of these instance variables are updated, the object A sends the message "showAinstannc" to the message monitoring subsystem 11.
e ", the instance variable" ad "
The contents of "dAinstance" and "addAmethod" are notified to the message monitoring subsystem 11 (step B5 in FIG. 6). Then, the instance variables “addAinstance” and “addAmetho”
The contents of "d" are notified to the programmer or the like by being sent from the message monitoring subsystem 11 to the display device and displayed on the screen (step B6 in FIG. 6).

On the other hand, when writing to the memory is performed by generating the object A (step C1 in FIG. 7), the memory monitoring subsystem 12 determines that writing related to the generation or deletion of the object has been performed. The memory table is updated (Step C2 in FIG. 7). Then, the updated contents of the memory table are sent from the memory monitoring subsystem 12 to the display device and displayed on the screen, thereby notifying the programmer or the like of the generation of the object A (step C in FIG. 7).
3).

Similarly, for example, a message “deleObject” prompting the disappearance of the object A from the object C
When “ct” is transmitted (Step D1 to Step D3 in FIG. 8), the instance variable “addAi” of the object A added by the message monitoring subsystem 11 is transmitted.
"nstance" is substituted with the name of the object C, and the instance variable "addAmethod"
Is replaced with the message name "deleObject" (step D4 in FIG. 8).

When the values of these instance variables are updated, the object A sends a message "showAinstant" to the message monitoring subsystem 11.
e ", the instance variable" ad "
dAinsuance "and" addAmethod "
Is notified to the message monitoring subsystem 11 (step D5 in FIG. 8). Then, the instance variables “addAinsuance” and “addAmet”
The contents of "hod" are sent from the message monitoring subsystem 11 to the display device and displayed on the screen, thereby notifying a programmer or the like (step D6 in FIG. 8).

On the other hand, when writing to the memory is performed by erasing the object A (step E1 in FIG. 9), the memory monitoring subsystem 12 determines that writing related to creation or deletion of the object has been performed. The memory table is updated (step E2 in FIG. 9). Then, the updated contents of the memory table are sent from the memory monitoring subsystem 12 to the display device and displayed on the screen, thereby notifying the programmer or the like of the disappearance of the object A (step E in FIG. 9).
3).

As described above, the message monitoring subsystem 11 notifies the transmission / reception of the message prompting the creation or deletion of the object, and the memory monitoring subsystem 12 notifies the memory monitoring subsystem 12 of the change in the memory state accompanying the loading or deletion of the object. This makes it possible to provide the user with useful information for verifying the operation of generating and deleting the object.

In the above embodiment, the message monitoring subsystem 11 and the memory monitoring subsystem 1
An example has been described in which both outputs are always displayed on the screen. For example, by comparing these outputs, it is determined whether or not the object has been generated and deleted normally, and the determination result indicates that the object has been generated and deleted. It is also effective to display a message on the screen only when the operation is not performed normally.

[0026]

As described above in detail, according to the present invention, the transmission and reception of a message directly related to the creation or deletion of an object and the notification of a change in the memory state due to the creation and deletion of the object are notified. It is possible to verify the operation related to the creation and disappearance of the object without the necessity of the setting of.

[Brief description of the drawings]

FIG. 1 is a diagram showing a configuration of a debugging system according to an embodiment of the present invention.

FIG. 2 is a conceptual diagram showing a configuration of an object for explaining an outline of data processing based on object orientation.

FIG. 3 is a flowchart showing an operation procedure of an object for explaining an outline of data processing based on object orientation.

FIG. 4 is an exemplary conceptual diagram for explaining instance variables and methods added by the message monitoring subsystem of the embodiment.

FIG. 5 is an exemplary view showing storage contents of a memory table created by the memory monitoring subsystem of the embodiment.

FIG. 6 is an exemplary flowchart showing an operation procedure involved in object creation of the message monitoring subsystem of the embodiment.

FIG. 7 is an exemplary flowchart illustrating an operation procedure involved in generation of an object in the memory monitoring subsystem according to the embodiment.

FIG. 8 is an exemplary flowchart showing the operation procedure of the message monitoring subsystem according to the embodiment when the object disappears.

FIG. 9 is an exemplary flowchart illustrating the operation procedure of the memory monitoring subsystem according to the embodiment when an object is deleted.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 ... CPU, 2 ... Main memory, 3 ... External storage device, 4 ... Input device, 5 ... Display device, 10 ... Debug system, 11
... Message monitoring subsystem, 12 ... Memory monitoring subsystem.

Claims (16)

[Claims] 1. A step of adding, to each object to be debugged, an instance variable storing a message name and a source object name of a message prompting creation or deletion of an object and a method for monitoring updating of the instance variable. Creating a memory table for managing a memory area used by an object operating as a component of an application program; outputting the value of the instance variable when the method detects an update of the instance variable And updating the memory table in response to loading or erasing the object from / to the memory; and outputting the updated contents when the memory table is updated. Debugging method characterized by the operations relating to the outputted instance variables values and generating from the update content of the memory table of the object and extinction without requiring such settings Into was verifiable. 2. A step of adding, to each of the objects to be debugged, an instance variable storing a message name and a source object name of a message prompting generation or destruction of an object, and a method for monitoring updating of the instance variable. Creating a memory table for managing a memory area used by an object operating as a component of an application program; outputting the value of the instance variable when the method detects an update of the instance variable Updating the memory table in response to loading or erasing the object from / to the memory; and, when the memory table is updated, outputting the updated content; and I A step of determining whether or not an operation related to the creation and destruction of an object is normally performed based on the value of the stance variable and the updated content of the memory table; and when the result of the determination is that the normal execution is denied, Notifying the user of the fact. 3. The method according to claim 1, wherein the output value of the instance variable indicates that a message prompting generation of one of the objects has been transmitted, and the updated content of the output memory table indicates that the object has been updated. 3. The debugging method according to claim 2, wherein when the loading to the memory is indicated, it is determined that the operation related to the generation of the object is normally executed. 4. The method according to claim 1, wherein the output value of the instance variable indicates that a message prompting the disappearance of one of the objects has been transmitted, and the output content of the memory table indicates that the object has been updated. 3. The debugging method according to claim 2, wherein when the erasure from the memory is indicated, it is determined that the operation related to the generation of the object is normally performed. 5. The method according to claim 1, wherein, even though the value of the output instance variable indicates that a message prompting generation of any object has been transmitted, the loading of the object into the memory is performed. 3. The debugging method according to claim 2, wherein when there is no output of the update content of the memory table indicated, it is determined that the operation related to the generation of the object is not normally executed. 6. The method according to claim 1, wherein, even though the value of the output instance variable indicates that a message urging the disappearance of any object has been transmitted, the object is deleted from the memory. 3. The debugging method according to claim 2, wherein when there is no output of the update content of the memory table indicated, it is determined that the operation related to erasure of the object is not normally executed. 7. The method according to claim 7, wherein the determining step includes an instance indicating transmission of a message prompting generation of the object, although the output content of the memory table indicates loading of any object into the memory. 3. The debugging method according to claim 2, wherein when there is no output of the value of the variable, it is determined that the operation related to the generation of the object is not normally executed. 8. The method according to claim 1, wherein the determining step includes transmitting a message prompting the extinction of the object even though the output content of the memory table indicates erasure of the object from the memory. 3. The debugging method according to claim 2, wherein when there is no output of a variable value, it is determined that the operation related to the disappearance of the object is not normally executed. 9. A means for adding, to each object to be debugged, an instance variable storing a message name and a source object name of a message prompting generation or destruction of an object, and a method for monitoring updating of the instance variable. Means for creating a memory table for managing a memory area used by an object operating as a component of an application program; and outputting the value of the instance variable when the method detects an update of the instance variable. Means for updating the memory table in response to loading or erasing of an object from / to the memory; and means for outputting the updated content when the memory table is updated. Point settings, etc. Debugging system according to claim said that the operation from the value of the output instance variables and the updated contents of the memory table for the generation and extinction of the object was verifiable without necessity. 10. A means for adding, to each object to be debugged, an instance variable storing a message name of a message prompting generation or destruction of an object and a source object name, and a method for monitoring updating of the instance variable. Means for creating a memory table for managing a memory area used by an object operating as a component of an application program; and outputting the value of the instance variable when the method detects an update of the instance variable. Means for updating the memory table in response to loading or erasing the object from / to the memory; means for outputting the updated content when the memory table is updated; and Instance variable value Means for determining whether or not operations relating to the creation and destruction of an object are normally performed based on the updated contents of the memory table; and, when the result of the determination is that the normal execution is denied, the fact is notified. And a debug system. 11. The determining means determines that the output value of the instance variable indicates that a message prompting generation of one of the objects has been transmitted, and that the output contents of the output memory table indicate that the object has been updated. 11. The debugging system according to claim 10, wherein it is determined that the operation related to the generation of the object is normally executed when the loading to the memory is indicated. 12. The determination means according to claim 1, wherein the value of the output instance variable indicates that a message prompting the disappearance of any object has been transmitted, and the output content of the memory table has been updated to indicate that the object has been updated. 11. The debugging system according to claim 10, wherein when indicating the erasure from the memory, it is determined that the operation related to the erasure of the object is normally executed. 13. The method according to claim 1, wherein the determining unit loads the object into the memory even though the output value of the instance variable indicates that a message prompting generation of any object has been transmitted. 11. The debugging system according to claim 10, wherein when there is no output of the update content of the memory table indicated, it is determined that the operation related to the generation of the object is not normally executed. 14. The method according to claim 1, wherein the determining unit deletes the object from the memory even though the value of the output instance variable indicates that a message urging the deletion of any object has been transmitted. 11. The debugging system according to claim 10, wherein when there is no output of the updated content of the memory table indicated, it is determined that the operation related to the erasure of the object is not normally executed. 15. An instance indicating transmission of a message prompting generation of an object, even though the output content of the output memory table indicates that an object is loaded into a memory. 11. The debugging system according to claim 10, wherein when there is no output of the value of the variable, it is determined that the operation related to the generation of the object is not normally executed. 16. An instance indicating transmission of a message urging the extinction of an object even though the output updated contents of the memory table indicate erasure of any object from the memory. 11. The debugging system according to claim 10, wherein when there is no output of the value of the variable, it is determined that the operation related to the disappearance of the object is not normally executed.