JP2696210B2 - Displaying execution trace of logical language program - Google Patents

Description

Description: TECHNICAL FIELD The present invention relates to an execution trace of a program, in particular,
The present invention relates to displaying an execution trace of a program described in a logical language. [Prior Art] Generally, the execution trace of a program is performed to assist a debugging operation, and therefore, which part of the program is currently being executed can be easily determined at any time from the displayed trace information. It is desirable to be able to grasp it. Conventionally, the execution trace of a logical language program is displayed at the control points of terms, for example, call (CALL), recall (REDO), successful end (EXIT), and failed end (FA).
IL) are sequentially displayed in a character string, along with the predicates, terms, and the like to be executed.
F. Clockskin, originally written by CSMellish, translated by Katsuhiko Nakamura, “Prolog Programming”, published by Microsoftware 1983). FIG. 11 shows an example of execution trace display in a format belonging to the prior art, for the Prolog program of FIG. 4 described later. In this example, as the types of control points, in addition to the above-mentioned four points, those special cases, namely, the unification call (UCALL) and the unification recall (URED)
O), Unification Successful End (UEXIT) and Unification Failure Unsuccessful End (UFAIL). For the head term (head term) of the sentence, these added control point types are used instead of the control point types described above. In FIG. 11, the leftmost numeral indicates the level of the predicate, the right column indicates one of the eight types of control points passed, and the further right column indicates the item to be executed and the like.
For example, the fourth line shows that the term r (2,
X) has passed the CALL point, and the fifth line shows that the first term r (1, X) of the sentence r (1, X):-s (X) in this predicate r
Line 6 indicates that we have crossed the UCALL point.
The line 7 indicates that the statement has passed the IL point.
(2, X): the leading term r (2, X) of -t (X), s (X) is UCAL
Line 8 indicates that this point has passed the UEXIT point, line 8 indicates that this term has passed the UEXIT point, and line 9 indicates that the second term t (X) of this sentence has passed the CALL point, Thus, we indicate that the predicate t will be tried next. It has already been proposed to display each term of a program in a logical language by enclosing it in a box-shaped figure, and to express the change in the call for each term and the past execution state using the four sides of this box-shaped figure ( JP-A-62-55739 and JP-A-62-57033
issue). However, these proposals do not extend to displaying execution traces. [Problems to be Solved by the Invention] The conventional execution trace display as shown in FIG.
The amount of information is sufficient. However, it is not easy to know which part of a program is running from its display. In addition, since backtracking occurs frequently in logic language programs, it is not enough to simply point out the current execution point, and it is necessary to be able to grasp the process leading up to that point. is there. Usually, a programmer describes a program in a format that is as easy to understand as possible by indentation, line breaks, insertion of annotations, etc., as far as the language specification allows, and understands the program in this specific description format. Therefore, the eleventh
When performing debugging while referring to the trace display in the format shown in the figure, many program writers
Prepare a separate program source list output in the format you described, and infer and judge the current execution point on this program source list and the process leading to it from the trace information shown in Fig. 11. I will be forced. This effort to make inferences and judgments has hindered the improvement of debugging efficiency. An object of the present invention is to provide an execution trace display in a format in which a current execution point in a program of a logical language and a process leading to the current execution point can be easily grasped, thereby reducing the above-described effort for inference and judgment. And contribute to improving the efficiency of debugging. [Means for Solving the Problems] The present invention provides a step of displaying a program source list of at least one predicate being processed, and displaying the latest execution state of this predicate on the displayed program source list. And graphically displaying steps. [Operation] As a result of the above steps, the predicate being processed is displayed in a description format at the time of program creation, and on the display in such a format, the execution state of the predicate has been reached. It is represented in a simplified diagram. For example, whether the execution state that each item has reached is calling, recalling, successful or unsuccessful termination after the call, or successful or unsuccessful termination after the recall, is a box surrounding the item. It is indicated by one of the sides and vertices of the figure. Therefore, by following the graphically illustrated execution state of the various items on the program shown in a format that is easy for the programmer to understand,
The current execution point and the process leading to it can be easily grasped. Embodiment FIG. 2 shows an example of a data processing apparatus for executing an embodiment of the present invention. This device comprises a central processing unit 1, a main memory 2, an auxiliary memory 3, a CRT display device 4, a keyboard 5, and a bus 6 connecting them. FIG. 3 shows an example of a software configuration for the device shown in FIG. In the figure, a solid line represents transmission of information to be processed, and a dotted line represents control of activation. This software is prepared in the main memory 2. The control unit 31 passes the query information and the user program reading instruction input from the keyboard 5 to the inference unit 34 and the input unit 32, respectively.
Launch them. The input unit 32 reads the user program stored in the auxiliary memory 3 into the data area 33 according to the user program reading instruction. Data area 33
Holds the user program during its execution period and also holds various information necessary for executing inference and execution trace display. The inference unit 34 performs inference with reference to the data area 33 in response to the inquiry information. The trace display unit 35 processes the inference information given from the inference unit 34 and the information in the data area 33, and displays an inference execution state, that is, execution trace information on the CRT display device 4. The user creates a user program in advance and stores it in the auxiliary memory 3. FIG. 4 shows an example of a user program described in Prolog. In FIG. 4, a sentence or tag constitutes a user program. Prol
An og program usually consists of rules and facts. It is a sentence or rule sentence, and is a sentence or fact sentence. For example, a rule sentence indicates a rule that if the fact indicated by r (2, X) is true, the fact indicated by p (X) is true, and the fact sentence indicates the fact indicated by t (a). Represents the fact that is true. A set of statements having the same name of the first term in the statement and the number of arguments is called a predicate. For example,
Constructs a sentence or a predicate whose name is r,
The number of arguments is two. The predicate name and the number of arguments are collectively referred to as a predicate name, and this term is used in the description below. After instructing the system to read a program consisting of sentences or sentences from the auxiliary memory, the user inputs query information in the form of sentences through the keyboard 5. The statement represents a query as to whether the fact indicated by p (X) is true. The system outputs a response to the query in the format as shown in the following. This response is to the effect that the fact in question is true when X = a. The process of generating a response from the inquiry information is performed by the inference unit 34. However, the object of the present invention is not the response generation processing itself but the display of the execution process of the inference unit 34, which is performed by the trace display unit 35. Therefore, a detailed description of the response generation processing by the inference unit 34 is omitted, and the trace display process by the trace display unit 34 will be described in detail below. First, the data area 33 used in the trace display process
The information part will be described. As shown in FIG. 5, the data area 33 includes a name table 51, a display stack 52, a stack pointer area 53, and a heap area 54. The name table 51 is a table that holds a pointer to related information for each of the above-described predicate names (the predicate name and the number of arguments). One record is assigned to each predicate name, and each record is composed of a predicate name field 511, a text information pointer field 512, a position information pointer field 513, and a tree structure information pointer field 514. The peep area 54 is a tree structure information pointed to by the pointer.
541, position information 542, and text information 543 are held.
This structure information 541 is information representing the tree structure of each sentence in the user program. This information is obtained by parsing each sentence and is mainly used by the inference unit 34. The text information 543 is information that expresses the user program in the format as described by the user,
When displayed on T, a user program in a format described by the user, that is, a program source text is displayed. The position information 542 is information indicating the position on the display screen of each item of each sentence in the program source text (hereinafter abbreviated as text). FIG. 6A shows details of the position information 542 for a part thereof. One sentence node (61,62) corresponding to each sentence
Is provided, and one item node (63 to 67) is provided corresponding to each item in each sentence. The statement node consists of two pointers, the first pointer points to the address of the term node corresponding to the first term of the corresponding statement, and the second pointer is the address of the statement node corresponding to the next statement belonging to the same predicate. And the second pointer of the statement node corresponding to the last statement is 0
Is set. The contents of the position information field 513 of each record in the name table 51 (FIG. 5) indicates the address of the statement node corresponding to the first sentence of the corresponding predicate. Each term node is
It consists of one pointer and four pieces of position information. This pointer points to the address of the term node corresponding to the next term in the same sentence, and is set to 0 in the term node corresponding to the last term. The four pieces of position information of each item node indicate the position on the CRT screen where the corresponding item should be displayed when the text is displayed (see FIG. 6 (b)). FIG. 6 exemplifies a part of the position information corresponding to the predicate name r (the number of arguments 2) in the program shown in FIG. This predicate is composed of three sentences to, and the sentence node 61 corresponds to the first sentence, and the sentence node 62 corresponds to the second sentence. The first sentence consists of two terms r (1, X) and s (X), which correspond to term nodes 63 and 64, respectively. The second sentence is composed of three terms r (2, X) and t
(X) and s (X), and these terms are term nodes
They correspond to 65, 66 and 67 respectively. The four pieces of position information x ₁ , x ₂ , y ₁ , y ₂ of the term node 67 are represented by a box shape surrounding the corresponding term s (X) on the CRT screen 68 as shown in FIG. Figure 6
Indicates the position of 9. FIG. 7 shows the display stack 52 and the stack pointer area.
Shows 53 details. The display stack 52 is a storage area that functions as a stack, and records the execution process of the inference unit 34 for display control. Each record in the display stack 52 corresponds to each predicate called and consists of the following six fields. pid field 71: a field pp storing the record number (predicate name identifier pid) in the name table 51 for the predicate name; a field pp field 72: pointer to a record in the display stack 52 corresponding to the caller predicate (parent pointer pp) A field clp field 73 that stores a pointer to a statement node (statement pointer clp) corresponding to the statement being executed in the position information 542 of the predicate is a field glp field 74 that is executing in the position information 542 of the predicate. A field kd field 75 for storing a pointer (high pointer glp) to the term node corresponding to the term, a field fp field 76 for storing the latest control point type sent from the inference unit 34 regarding the predicate, and a predicate for the source text Field stack pointer area that stores the file number of the output window allocated for CRT display of the part The 53, current pointer (CP) 77 and an empty pointer (EP) 78 is stored. The count pointer 77 points to the address of the record in the display stack 52 corresponding to the currently executing predicate.
Indicates the start address of the empty area of the display stack 52. The inference unit 34 calculates, for each term, its eight control points (CAL
L, EXIT, REDO, FAIL, UCALL, UEXIT, UREDO, UFAIL), the predicate name and the control point type are passed to the trace display unit 35 as inference control information and activated. . When activated, the trace display unit 35 performs a control point display process 81 and a stack process 82 as shown in FIG. 8, and then, when the control point type is CALL or REDO, a text display process 83 or The text redisplay processing 84 is performed. The control point display processing 81 determines which type of control point the processed term has passed by using a current pointer 77 (FIG. 7).
Is displayed on the text based on the contents of the display stack record (hereinafter referred to as the current record) indicated by, or the record indicated by the pp field of the record (hereinafter referred to as the parent record), and the control point type information from the inference unit 34. . The stack processing 82 updates the display stack 52 and both pointers 77 and 78 according to the control point type information from the inference unit in preparation for displaying the next processing result. Text display processing 83, CALL
The text of the predicate to be processed next is displayed as a result of the processing, and the text redisplay device 84 redisplays the text of the predicate to be redone next as a result of the REDO processing. Next, details of these processes will be described.
The stack processing 82 will be described first. FIG. 9 is a flowchart showing the stack processing 82 in somewhat more detail. First, the control point type in the inference control information received from the inference unit 34 is determined (process 900). If the control point type is CALL, the following processes 901 to 904 are performed. (1) “CALL” is set in the kd field of the record (current record) pointed to by the current pointer 77 (901). (2) A new record is created at the record position indicated by the null pointer 78, and the values of its fields are set as follows (902). pid = predicate name identifier corresponding to the predicate name in the inference control information (a table indicating the correspondence between the predicate name and the predicate name identifier is prepared in advance) pp = the value of the current pointer 77 clp = the name indicated by the pid The value of the position information pointer field 513 in the table record, ie, the address glp of the first statement node of the corresponding predicate = the value of the first pointer of the statement node indicated by the clp, ie, the address kd of the first term node = not set fp = file number of the output window newly allocated to this predicate (3) The value of the empty pointer 78 is set to the current pointer 77 (903). (4) The value of the empty pointer 78 is increased by one record,
It points to the new start address of the empty area (904). If the control point type is EXIT, the following processes 905 and 906
Is performed. (1) The glp field of the record (parent record) indicated by the pp field of the current record is changed to point to the next term node (905). In detail, the parent record glp
If the value is not 0, the pointer value of the term node pointed to by it (the address of the next term node in the same statement) is set in this glp field. However, if the glp value of the parent record is 0, the second pointer of the statement node indicated by the clp value of this record (the address of the next statement node) is taken out and set in this clp field. In the field, the value of the first pointer of the statement node indicated by the new clp value is set so as to point to the first term node of the statement. (2) The value of the current pointer 77 is set to the value of the pp field (address of the parent record) of the record currently pointed to (906). If the control point type is REDO, the following processes 907 and 908
Is performed. (1) “REDO” is set in the kd field of the current record (907). (2) Starting from the position indicated by the empty pointer 78, the current pointer 77
Going back to the position indicated by, search for a record that has the current pointer value in the pp field, and change the current pointer value to point to this record (90
8). If the control point type is FAIL, the following processes 909 to 912 are performed. (1) The window indicated by the fp field of the current record is deleted (909). (2) Change the glp of the parent record to point to the previous item node (910). When a FAIL occurs, glp of the parent record does not point to the first term node. (3) The value of the current pointer 77 is
Set to pp value and point to parent record (911). (4) The value of the empty pointer 78 is set to the old value of the current pointer 77 (912). If the control point type is UCALL, kd of the current record
Set the field to “CALL” (913). If the control point type is UEXIT, the glp of the current record
The value is the value of the pointer of the term node it points to, that is,
Change to the address of the next term node in the same sentence (914).
If the current glp points to the last term node, the pointer value of that term node is zero, so the glp value is set to zero. If the control point type is UREDO, kd of the current record
Set the field to “REDO” (915). If the control point type is UFAIL, clp of the current record
Change the value to the value of the second pointer of the statement node to which it points, ie, the address of the next statement node, and replace the glp value with the value of the first pointer of the statement node to which the new clp value points, ie, this Change to the address of the first node of the statement (91
6). After the stack processing as described above, the current pointer includes the term node normally expected as the next processing target,
Indicates whether it passed CALL or REDO last time. However, if the control point type received from the inference unit is EXIT or FAIL
In the case of, the parent record indicates the target item node and its previous control point type. Next, the control point display processing 81 will be described. FIG. 10 is a flowchart showing the process 81 in a little more detail. First,
The control point type in the inference control information received from the inference unit 34 is determined (100). If the control point type is a CALL or UCALL, positional information in terms node pointed to glp field in the current record _{(x 1, x 2, y} 1, y 2) in accordance connexion, on the display screen, the corresponding term The upper left vertex of the enclosing box-shaped figure blinks (101). If the control point type is EXIT or UEXIT, first, the previous control point type is checked (102). The last control point type was EXI
In the case of T, it is recorded in the kd field of the parent record (the record pointed to by the pp field of the current record), and in the case of UEXIT, it is recorded in the kd field of the current record. If the previous control point type was CALL, the upper side of the box-shaped figure surrounding the corresponding item is displayed as a bold line (103),
If the previous control point type is REDO, the right side of this box-shaped figure is displayed as a bold line (104). The position of this box-shaped figure is specified by the position information in the term node indicated by the glp field of the parent record in the case of EXIT and the current record in the case of UEXIT. If the control point type is REDO or UREDO, the lower right vertex of the box-shaped figure surrounding the corresponding item is blinked according to the position information in the item node indicated by the glp field of the current record (105). If the control point type is FAIL or UFAIL, the previous control point type is checked first (106). If it is CALL, the left side of the box-shaped figure surrounding the corresponding item is displayed as a bold line (107) and REDO is displayed.
If so, display the bottom side of this box-shaped figure as a bold line (10
8). The control point type and box shape position in the previous section are FAIL and UFA.
As in the case of IL, EXIT is obtained from the parent record, and UEXIT is obtained from the current record. In the text display process 83, in response to the control point type being CALL received from the inference unit 34, first, the fp field of the current record (the record created by the process 902 in FIG. 9) is referred to. To create a new window on the screen. Next, the name table record pointed to by the pid field is checked, and the text information pointed to by the text information pointer 512 is selected from the text information 543 and displayed in the previous window. In the text redisplay processing 84, in response to the control point type received from the inference unit being REDO, the pid field of the current record (the record pointed to by the current pointer updated by the processing 908 in FIG. 9) is changed. The name table record pointed to is checked, and the text information pointing to the text information pointer 512 is displayed again in the window indicated by the fp field. In the embodiment described above, the text of all predicates called as a result of CALL and REDO is displayed. However, a modification may be made so that only the text of the predicate specified by the user is displayed. For this purpose, for example, a flag that can be set by the user indicating whether or not the display is necessary may be added to the correspondence table between the predicate name and the predicate name identifier (pid), and the display of the text may be controlled accordingly. FIG. 1 (a) is a diagram corresponding to the pro program of FIG.
The same trace as in FIG.
4 shows an example of a T screen. However, in this example, the predicates t and s
And the text display of u is suppressed. Fig. 1 (b)
Indicates the display format of the control points described above. In FIG. 1A, output windows 11 and 12 are displayed on a CRT screen 10.
Is open. In the CALL on the first line in FIG. 11, the text of the predicate p is displayed in the output window 11, and the next UCALL
, CALL is displayed in the first term p (X), and the next UEXIT
In it it turns into CALL-EXIT. In the CALL of the fourth line, the CALL is displayed in the second term r (2, X) of the statement of the predicate p, the text of the predicate r is displayed in the output window 12, and the beginning of the first sentence in the next UCALL Term r (1, X)
CALL is displayed. Thereafter, the display of the first term in the UFAIL on the sixth line is changed to CALL-FAIL, CALL-EXIT is displayed on the first item of the second sentence of the predicate r in the UEXIT on the eighth line, and the second sentence is displayed in the next CALL Is displayed in the second term t (X). At this time, if not suppressed,
The text of the predicate t will be displayed in a new window. The second term t (X) of the second sentence in EXIT on line 12
Is displayed in the CALL of the last line, and CALL is displayed in the third term s (X) of the second sentence. The text display of the predicate s is suppressed. From the inspection of the current screen shown, the following can be easily understood. That is, the predicate r is currently being processed, and the current execution point is the CALL point of the term s (X). By the time this execution point is reached, the first term of the first sentence of the predicate r fails and ends. ,
This means that the first and second terms of the second sentence have been successfully completed, and thus control is passed to this term s (X) for the first time. In this embodiment, the display stack dedicated to the trace display unit 35 is used.
A trace display control area is added to the inference execution stack used by the inference unit 34, information to be stored in the display stack 52 is stored therein, and this stack is displayed in the trace display unit. May be shared with 35. In addition, all items may be displayed in a box shape from the beginning, and control points may be highlighted by flashing, bold lines, etc., or a box shape may be displayed for unexecuted items. Instead, only the control points for the executed term may be displayed.
The expression form of the control points is not limited to the above-described embodiment, and any symbol that can be displayed around each item can be used. [Effects of the Invention] According to the present invention, the current program execution point and the execution state of each point in the logic language program are intuitively understood on a source list in a format as described by the programmer. It is displayed in an easy-to-use format. Therefore, it is possible to easily understand the execution process of a logical language program which is normally difficult to grasp, and as a result, a remarkable improvement in debugging efficiency can be expected.

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 is a diagram showing a display screen obtained by an embodiment of the present invention, and FIG. 2 is a block diagram showing an example of a hardware configuration of a data processing device used for executing the present invention. FIG. 3 is a block diagram showing a software configuration for an embodiment of the present invention, FIG. 4 is a diagram showing an example of a program by Prolog, and FIG. 5 is a diagram showing details of a data area in FIG. 6, FIG. 6 shows an example of the position information area in FIG. 5, FIG. 7 shows an example of the display stack and the stack pointer area in FIG. 5, and FIG. 8 shows an embodiment of the present invention. 9 is a flowchart showing the outline of the trace display processing, FIG. 9 is a flowchart showing the details of the stack processing in FIG. 8, and FIG. 10 is a flowchart showing the details of the control point display processing in FIG. , FIG. 11 is a diagram showing an example of the trace display according to the prior art. 81,100-108 …… Execution status display step, 82,900-916…
... Display control information update step, 83,84 ... Program source list display step.

   ────────────────────────────────────────────────── ─── Continuation of front page    (56) References JP-A-62-257033 (JP, A)                 JP-A-62-55739 (JP, A)                 ICOT Research Bulletin TM-80               Papers presented at the 1st Japan Society of Software Science Conference               Shu (Showa 60-12-3) Toshiyuki Fujita, Akira Takeuchi               1. Hiroyasu Kondo, "Concurrent               Prolog window tracer               About "p.25-28

Claims (1)

(57) [Claims] A program source list of at least one predicate to be processed in a process of executing a program written in a logical language on a data processing device, the program source list including at least one predicate and each predicate including at least one term is displayed. An execution trace display method comprising: a step; and a step of graphically displaying the latest execution state of the predicate on a displayed program source list. 2. 2. The execution trace display method according to claim 1, wherein the diagram is a box-shaped figure surrounding each executed item, and a display form of at least a part of four sides and four vertices indicates the latest execution state of the item. . 3. In claim 2, the latest execution state is:
Call, recall, successful and unsuccessful termination after the call,
And two vertices of the box-shaped figure correspond to the calling and recalling, respectively, and four sides of the box-shaped figure correspond to the successful and unsuccessful ends and recalled after the calling. An execution trace display method corresponding to a successful end and a failed end after calling, respectively. 4. The method according to claim 1, 2 or 3, wherein the method includes a step of updating display control information for an associated predicate in response to execution state information indicating an execution state in a program execution process. The steps are controlled based on the execution state information and the display control information.
Execution trace display method. 5. In claim 4, the display control information includes:
Each of the information blocks includes a plurality of information blocks corresponding to one predicate and used for controlling the execution state display of the predicate, and pointer information indicating one of the information blocks, and the updating step generates a new information block. And a step of changing the content of the existing information block, and a step of changing the pointer information. 6. In claim 5, the information block comprises:
An execution trace display method including a part indicating a corresponding predicate, a part indicating a calling relationship between the predicates, a part indicating a processing target item, and a part indicating at least a part of the execution history. 7. In any one of claims 1 to 6, different windows on the display screen are assigned to program source lists of different predicates, and a window of a later executed predicate overlaps a window of a previously executed predicate. How to display the execution trace as you would.