JPH02224142A - Prolog source level debugging system - Google Patents

Abstract

PURPOSE:To output only truely necessary trace information at the time of debugging by optionally setting up a spy point on a position required by a user. CONSTITUTION:The system is provided with a prolog source program 1, a source text extracting part 2, a spy point position/specification setting part 3, a debugging source text registering part 4, a source text restoring part 5, a debugging work I/O part 6, a man/machine interface part 7, a prolog program execution part 8, a debugging source text 9, a source text 10, a display 11, and a mouse 12. A spy point to be used for debugging is set up by inserting an action program code into a source text. Consequently, only the trace information truely required at the time of debugging can be outputted.

Description

[Detailed Description of the Invention] (Field of Industrial Application) The present invention is written in the Prolog language used in natural language processing, expert systems, etc. in the field of artificial intelligence, or a similar Prolog programming language. This article relates to a debugging device for programs.

(Prior art) In the field of artificial intelligence, f! is used as a programming language that supports logical programming. dCAAD, Deper
t-ment of Architecture,
Prolog-based languages such as C-Prolog developed at the University of Edinburgh are known.

This Prolog language is a conversational language, and a program as shown in FIG. 3 is read into the working memory, and the program is executed by predicate calling as shown in FIG. Third
The program in the figure is a descendant,
Relationship and facts between children (offapring) and parents (gt308 is gts328's parent, di
No.246 defines the parent of gtb308. FIG. 4 is an example of execution for finding descendants of dino246. In Figure 4, for the solution (gtn308) found once,
This is negated by ";" and another solution (gts328) is found by backtrunk.

In FIG. 3, descendanL offspr
ing, pa-rent are predicates of arity 2, x, y, z are variables, dino246, gtb3
08, g ts328 is a value called an atom. Execution of a predicate is performed by unifying variables and values and backtrack control, and the effective range of variables is closed within one predicate definition, and all variables are local variables. -The value of a variable given by Unify can only be changed using a bank track.

From FIG. 5 to FIG. 7, C-Pro-1 as described above is shown.
Using the debugging function of og, trace information is output for each step in the execution of the program shown in FIG. 4, and is broken down into each figure.

In this debug function, first specify the predicate to be debugged using the spy predicate name/arity. Thereafter, when the program encounters the entrance or exit of the predicate procedure specified by spy during program execution, execution is interrupted and trace information is output. As the entrance to the predicate procedure, call the predicate.
a1l), but the exits are success (Exit), backtrack (BackTo), and failure (Fa-il).
There is. The trace information indicates the value of the argument at the time it is encountered, and xxx means the value is undefined.

If execution is interrupted, a "?" prompt is output, in response to which the user enters a debug command.

There are debug commands as shown in Figure 8.
The user performs debugging work while controlling execution using these debugging commands.

FIG. 9 is an example of a predicate update operation in which a source program in which a predicate is defined is read into the working memory.

In the conventional debugging function described above, when the predicate becomes as complex as shown in Figure 9, it is divided into Figures 10 to 15 to show the whole (source file XXX where the predicate in Figure 3 is defined). (Example of step-by-step reading), it becomes quite complicated.

(Problems to be Solved by the Invention) In the conventional debug function described above, spy points are set for each predicate, so as illustrated in FIGS. 10 to 15, it is difficult to obtain truly necessary trace information. There is a problem in that the debugging steps up to this point become complicated and require a long string of debugging commands.

Another problem with conventional debugging functions is that trace information output during debugging includes a lot of unnecessary information, resulting in a lot of waste.

(Means for Solving the Problems) The Prolog source-level debugging system of the present invention includes a source text extraction unit that extracts the source text of a predicate to be debugged from a source program by specifying the predicate to be debugged, and The apparatus includes a spy point position and specification setting section for setting the spy point position and specifications in an interactive manner using a display and a mouse on the text.

Setting of this spy point is performed by inserting action program code at the spy point at a position between predicate calls that constitute the predicate body in the source text.

In addition, the specifications of the spy point include the movability of the spy point (whether the action at the spy point is valid or not), the interrupt condition for program execution (the conditional expression that determines whether or not to interrupt program execution at the spy point), Trace information output conditions (
A conditional expression for determining whether to output trace information at a spy point), content of trace information (content of trace information to be output at a spy point: values of variables appearing in a predicate definition, etc.) are set. Note that since the action program code does not change the control of the original program, it is normally implemented in such a way that the call succeeds and the bank track fails.

Specifically, the Prolog source-level debugging system of the present invention debugs the debugging source text into which the action program code at the spy point is inserted into Prolog.
The Prolog program execution section is equipped with a debugging source text registration section that enables debugging by the execution section by temporarily registering it in the working memory of the program execution section. Sometimes, it has the function of performing debugging work such as outputting trace information, suspending and resuming execution, and executing an arbitrary program by using Break by executing an action program code corresponding to a spy point.

The program includes a source text restoring section that restores the working memory of the Prolog program execution section to the state before the start of debugging by re-registering the original source text when debugging is finished.

In this manner, according to the debugging system of the present invention, the spy point can be set at any desired location by the user, so that only trace information that is truly necessary during debugging can be output.

What's more, the operations necessary for setting can be performed easily and reliably using the display and mouse interactive format.

Hereinafter, the operation of the present invention will be explained in detail together with examples.

(Embodiment) FIG. 1 is an overall configuration diagram of a Prolog source level debugging system according to an embodiment of the present invention, in which a Prolog source program 1, a source text extraction unit 2, a spy point position and specification setting unit 3, a Source text registration section 4, source text restoration section 5, debug work input/output section 6, man-machine interface control section 7, Prolo
g program execution unit 8, debugging source text 9,
Source text 10, display 11 and mouse 12
It is equipped with

The source text extraction unit 2 extracts the source text of the predicate to be debugged from a file in an external storage device or from a Pr
o Extract from the source program 1 held in the working memory of the log program execution unit 8.

The spy point location and specification setting unit 3 sets the location and specifications of a spy point at which action program code for debugging is inserted into the extracted source text.

The debug source text registration unit 4 registers the debug source text 9 into which the debug action program code has been inserted into the working memory of the Prolog program execution unit 8, and sets the execution state of the Prolog program execution unit 8 to the debug mode. Make it.

The source text restoring unit 5 restores the original source text 1 immediately before loading the source text for debugging after the debugging operation is completed.
By re-registering 0 in the working memory of the Prolog program execution unit 8, this working memory is restored to the state before the start of debugging.

The debugging input/output unit 6 serves as an input/output front end during debugging in the Prolog program execution unit 8. That is, regarding the action program code executed at the spy point during debugging, output of trace information and input of debugging commands are performed via this debugging input/output unit 6.

The man-machine interface control section 7 is a man-machine interface control section that allows the user to efficiently utilize the functions of the above-mentioned sections 2 to 6 using the display 11 and the mouse 12.

FIG. 2 shows an example of what is displayed on the display screen 21 when the debugging device shown in FIG. 1 debugs the predicate update illustrated in FIG. 7.

In this example, the display 11 and mouse 12 are controlled by a multi-window system, and the Prolog
The program execution unit 8 is a Prolog window 22
, the other parts communicate with the user via the debug window 23.

This debug window 23 is composed of a spy subwindow 24, a panel subwindow 25, a text subwindow 26, and a trace subwindow 27. Among these, the spy subwindow 24, the text subwindow 26, and the trace subwindow 27 are text display windows that have scroll bars on the left side.These scroll bars indicate the position and proportion of the displayed part in the text. , the display part can be moved by mouse operation.

In the illustrated example, the spy subwindow 24 displays the entire text, the text subwindow 26 displays the upper half of the text, and the trace subwindow 27 displays the lower half of the text. The panel subwindow 25 consists of a plurality of button areas, and by selecting each button area with the mouse 12, a specific action is performed on that button area. Panel subwindow 25
shows that the break button is selected (the diagonal arrow is the mouse cursor).

An example of debugging using the debug window 23 will be explained with reference to FIG.

1, 5pyset button area selection aba. A prompt for inputting the name/arity of the predicate to be traced is displayed in the trace subwindow 27. This displayed prompt allows you to update the predicate name/arity (update/
2) is input from the trace subwindow 27.

The source text of the specified predicate is displayed in the text subwindow 26.

2,5 pyne-button area selection Default specifications for a new spy point (SI) are displayed in the spy subwindow 24.

In the illustrated example, spy point name predicate predicate name/arity state spy point state (active
e or 1nactive) trace) Race information output judgment conditional expression % expression% s topback Execution interruption judgment conditional expression when backtracking traceX) The specification is a sequence of expressions for outputting race information.

By default, predicate is the predicate currently displayed in the text subwindow 26, state
is active, trace is true (
always output), 5top is true (always interrupt), 5
topback is false (always passed through), tr
aceX is a list of variables that appear in the source text. Note that the spy point is deleted by pressing the 5pycl-ear button area.

3. In the text subwindow 26, set the spy point position by operating the mouse 12.

The spy point name (Sl) is inserted in outline font at the set position of the spy point.

4. Change the specifications of the spy point in the spy subwindow 24.

In the example, traceX becomes pile, X, A,
Change to B, F, N 5, 5 pysave Button selection The debugging source text with spy points set is Pro
It is registered in the working memory of the Prolog program execution unit 8, and the Prolog program execution unit 8 is placed in debug mode.

6. In the Prolog window 22,
A program is executed for Soge.

In the example, update (xxx).

7. The execution result of the action program code at the spy point is output to the trace subwindow 27 (X=,
0. p= , , N= , , ), and furthermore, at the time of interruption (st
.

A prompt (command?) for inputting a debugging command is output to p at Sl).

8. When suspending at the spy point, select the debug command button area.

conttnue continues execution, abort stops execution, and break enters a new execution level.

9.5 Re-register the pyoff button area selection original source text in the working memory of the Prolog program execution unit 8, and terminate the debug mode of the Prolog program execution unit 8.

Note that the quit button area ends the operations of each section 2 to 7.

(Effects of the Invention) As explained above, the Prolog source-level debugging system of the present invention sets the spy points used during debugging by inserting action program code into the source text of the predicate definition. It is possible to output only the trace information that is truly necessary during debugging.

Furthermore, since the configuration allows setting of the spy point location and specifications in a conversational manner using a display and a mouse, debugging can be performed extremely efficiently.

[Brief explanation of the drawing]

FIG. 1 is a functional block diagram showing the configuration of a Prolog source-level debug system according to an embodiment of the present invention.
The figure is a conceptual diagram illustrating the display contents of the display screen during debugging work by the above debugging system.
Conceptual diagram showing an example of a rolog language program, Part 4
The figure is a conceptual diagram showing an example of the execution of the program in Figure 3. Figures 5 to 7 are conceptual diagrams showing an example of the content of debugging using the conventional debugging function for the program in Figure 3. A conceptual diagram showing a list of debug commands in the conventional debug function for the Prolog language,
FIG. 9 is a conceptual diagram showing another example of a program in the Prolog language, and FIGS. 10 to 15 are conceptual diagrams showing an example of the content of debugging work performed by the conventional debugging function on the program in FIG. 9. DESCRIPTION OF SYMBOLS 1... Prolog source program, 2... Source text extraction section, 3... Spy point position and specification setting section, 4... Source text registration section for debugging, 5.
... Source text restoration section, 6. Debugging work input/output section, 7. Man-machine interface control section, 8.
...Prolog program execution part, 9... Source text including debugging action code, 10...
Original source text restored after debugging, 11
...Display, 12...Mouse, 21...Display screen, 22...Prolog window,
23...Debug window, 24...Spy subwindow, 25...Panel subwindow, 2
6...Text subwindow, 27...Trace subwindow. Diagram

Claims (1)

[Claims] Between a source text extraction unit that extracts the source text of a predicate specified as a debugging target from a source program in a Prolog language, and a predicate call that constitutes the predicate body in the extracted source text. In addition to setting the location of the spy point, specify the specifications of the spy point, including the validity of this spy point during debugging, conditions for suspending program execution, conditions for outputting trace information, and content of trace information to be output. a spy point and specification setting section that generates a debugging source text by inserting an action program code into the spy point position based on the Prolog program execution section;
A debug source text registration unit that enables debugging by the g program execution unit, and outputs trace information and interrupts execution according to the specifications of the set spy point when control reaches a spy point during the debug execution. , resuming execution, executing arbitrary program execution, etc. P
rolog program execution unit; a source text restoration unit that restores the source text in the working memory of the Prolog program execution unit to the state before the start of debugging when the debugging ends; operations of each of the units can be controlled interactively. 1. A Prolog source-level debugging system comprising a display, a mouse, and a man-machine interface section.