JPS63100543A - Program debugging backup device - Google Patents

Abstract

PURPOSE:To efficiently debug a source program by providing a display means on which the source program is displayed together with errors for interpretation and execution of the source program and a display means on which positions of errors can be identified in the display of the source program. CONSTITUTION:The source program of user definition functions is displayed on a text display part, and a formula (list) 25 where error is detected in this display is emphasized by inversion and displayed to allow a user to identify the error position. Since the user definition function including the error is displayed on an editing screen with respect to the error in the source program and the error position is emphasized by inversion and displayed, the user saves trouble to retrieve the error position and can directly correct the error position, and therefore, the time for correction is shortened and mistake of the correction position is reduced. In an example shown in the figure, 'f' is substituted with 'fact' to correctly operate the program by recursive call of 'fact'.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a language processing system that is executed in an interpreter format, especially when the internal representation of a program is a list-structured L
I8P (Li5t Processor) 0 related to a debugging support device suitable for program debugging [Prior art] A LISP program is (i2+□...1
1...) is expressed in a parenthesized list format.

Here, the list element il is a character string, a numerical value, or a list in the same format as above. The LISP processing system interprets each list as (function argument...argument), with the first element of the list as a function and the second and subsequent elements as arguments of the function. These are built-in functions prepared in advance by the processing system, or user-defined functions (equivalent to subroutines). For example, when expressed in a kLIsP program, the formula ANS: (X+Y)*Z becomes (5ETQ
ANS(*(+X Y )Z)). A user function is expressed by a combination of expressions expressed as a list. Here, the character or character string after the left parenthesis "(" is 5E
TQ, *, and + are each built-in functions of LISP. The LISP processing system sequentially evaluates (interprets and executes) lists with left and right parentheses. In the above example, first (S
When trying to evaluate a list of E 'r Q......).

The argument has a list (*(+XY)Z),
Furthermore, it is necessary to evaluate the list (+X Y) in that list, and the evaluation is performed in order from the inner list.

By the way, if the directness of
Introduction to SP: Written by Yuasa, Iwanami Shoten 1986.

7.18 issue pp. 313-315, E.
rror: The variable X is
unbound.

Error signaled by ten.

A message will be displayed. That is, only the contents of the error and the function in the list where the error occurred are displayed.

[Problem that the invention seeks to solve]

In the conventional LISP processing system mentioned above, when displaying errors, only the 81 types of errors and the direct function where the error occurred are presented, so it is difficult to know which expression in which user-defined function caused the error. was there. Also, as a function of the debugger, which is a utility for analyzing errors, there is a function to backtrace the function name stored on the stack every time a function is called, but the display by the backtrace function is , it was difficult to identify the location where the error occurred, such as when the same expression existed in multiple locations within the same user function. Additionally, since the display of the location where the error occurred and the program that corrects the program with the error were separate, each display screen was different, and there was a problem with the possibility of incorrectly correcting the wrong location. was there.

The purpose of the present invention is to immediately clarify in which expression of which user function (subroutine) the error occurred when an error occurs during execution in a code processing system such as LIMP that executes expressions one by one. However, the object of the present invention is to provide a processing system that can directly correct the presented error location on the same screen.

[Means for solving problems]

The above object is achieved by means for displaying a source program of a user function containing an error on an editing screen when an error is detected during program execution, and identifying and displaying the last executed expression on the display.

[Effect]

The means for finding the user function containing the error expression is as follows:
Control information including the function name is stored in the register for each new function call, and for functions that have completed processing,
This is achieved by removing the relevant control information from the stack, and at the time of occurrence of the error, backtracing the control information on the stack and searching for the user function name near a.

Also, to identify the last realized expression, the location of the last executed expression is always maintained during execution, and in the process of displaying each expression of the user function, the location of each expression in the source program to be displayed is identified. , is realized by detecting a match between the locations of the expressions executed last.

The user function containing the error formula and the location where the error occurred are clearly displayed on the program collection screen, allowing you to directly correct the error location.

〔Example〕

An embodiment of the present invention will be described below.

FIG. 1 is a configuration diagram of a debug support device of the present invention.

In the embodiment, LIMP is executed and debugged using the device t. The source program shown in FIG. 1 is input to an interpretation/execution mechanism (interpreter) 2, where each expression (list) is interpreted and executed one by one, and the execution results are displayed by a display mechanism 4. If there is an error during execution in 2, an error message is also displayed in 4. 3
is a text editor that is a mechanism for editing source programs, including inputting and modifying them. 1 to 4 are known operating mechanisms that have been realized in a concise manner in the language processing system of each conventional program.

In this embodiment, five new error location extraction mechanisms are added. 5, when an error occurs during the execution in 2, searches for the user function containing the error, displays the entire source program of the user function, and identifies and displays the error expression (list) in the source program. This is a mechanism for extracting error points, which always holds the address of the last executed expression (list), and a mechanism 51 that always holds the address of the expression (list) executed last. Mechanism for searching executed user functions 52. The address of each expression in the user function source program extracted in 52, and 5
It consists of a mechanism 53 that detects a match between the addresses held in 1. The expression whose address matches in 53 (for example, it is displayed in the display mechanism in 4 to distinguish it from other expressions. The source program of the user function extracted in 5 and the error expression are input to the editing mechanism in 3. , it is also possible to display it on the editing screen.

Figure 2 shows L for calculating the factorial of n using the apparatus of Figure 1.
This is an example of a screen that is displayed when an error occurs during execution due to an error in the program description when the IMP program fact is executed. An error occurs when an attempt is made to execute an undefined function name f in the program fact. In the conventional LISP processing system, only the messages displayed in the 13 message lines on the screen are displayed.

In this message, although it is known that f is in the function *, it is not displayed that it is in the user-defined function fact.

In this embodiment, the source program of the user-defined function is displayed as shown in the text display section 22, and the expression (list) 25 in which an error has been detected is inverted and highlighted to identify the error location. I tried to force it. Figure 2
0 is a heading section of the editing screen, and 24 is a command input section. According to this embodiment, for errors in the source program.

User-defined functions containing errors are displayed on the editing screen, and the error location is inverted and highlighted, saving users the trouble of searching for the error location and allowing them to directly correct the error location, reducing the time it takes to make corrections. It can be shortened and there are fewer mistakes in the corrected parts. In this display example, by replacing "@f" with "fact", the recursive call of fact operates correctly.

As a second embodiment, when an error occurs, the screen shown in Figure 1 is displayed by entering the debugger mode and entering the debugger command "@WHERE" instead of directly switching to the editing screen display. You can.

FIG. 3 describes the internal operation flow of the interpretation/execution mechanism 2 and the error location extraction mechanism 5. The interpretation/execution mechanism 2 sequentially extracts the expressions of the specified function 301
), the address of the latest expression is always held by the executable expression address holding mechanism 51 ((302). The retrieved expression is interpreted and executed (303), and processing proceeds to the next expression. 30
When an error is detected in the processing of step 3 (304), the debugger mode, which is a processing mode of the interpretation/execution mechanism 2, is entered (305). Next, deva from the terminal.

When a command is input, the interpretation/execution unit 2 interprets the command (306). The debugger command is °W
HERE” (307), the user function search mechanism 52 searches for a user function a that includes the error expression (308) [Details will be described later].For other commands, the corresponding Perform command processing (30
9).

[Description omitted as it is not related to the present invention]. In the second embodiment, 305 to 307f! I like it, I like it.

When a user function is found in step 308 and the editing mechanism 3 is called using the user function as an argument, the source program of the user function is sequentially displayed on the editing screen (30). At this time, the address matching mechanism 53 determines the location of each expression in the source program and the process 3.
Compare the location (address) held in 02 311
, 312) Matched expressions are highlighted in reverse (313), and the others are displayed with normal brightness (314).

Figure 4 shows Seki g! 1 is a diagram illustrating a list structure of an internal representation of a 1fact source program. When extracting an expression in processes 301 and 310 in FIG. 3, addresses indicated by A, B, C, D, E, and F in FIG. 4 are referenced and stored.

FIG. 5 illustrates the state of the stack that is referred to when the user function search mechanism 52 searches for a user function that includes an error expression. Each time a function is referenced, control information including the referenced function name is stored on the stack, and when the processing of that function is completed and processing returns to the original function, from the stack.

Remove the control information for the function. In this example, when an error occurs when referencing function f, the stack contains fact,
Control information including function names cond, T, *, f, and debug is stored. Here, as shown at 500, by referring to the function names in order from the bottom and searching for functions that are not built-in functions in the system, a user function called "fact" can be found.

A function that completes with a value of 1 on the editing screen is manually changed to a list structure with a new definition using the end command.

〔Effect of the invention〕

According to the present invention, when an error occurs during execution in a 100-word processing system such as LLSP that executes expressions one by one, it is possible to edit which user function (subroutine) and in which expression the error occurred. Since the error displayed and presented on the screen can be directly corrected, the user does not have to keep track of the location where the error occurred, and the possibility of making a mistake in the location to be corrected is reduced.

Therefore, the efficiency of debugging work is greatly improved.

[Brief explanation of the drawing]

FIG. 1 is a block diagram of an apparatus according to an embodiment of the present invention, FIG. 2 is a diagram showing an example of a display screen of the embodiment, and FIG. 3 is an operational flow diagram inside the apparatus. , a list structure diagram of the internal representation of the source program, FIG. 5 is a diagram showing the state of the stack when searching for user functions. 5: Error location extraction mechanism 20: Error identification display screen 22: Source including error display Program display section 25:
Reverse display of error part Sheep 1vJ 3rd mouth leak 41! I l-8

Claims (1)

[Claims] 1. In a language processing device having an interpreter that interprets and executes each fragment of a source program one by one, displaying the source program including errors during interpretation and execution of the source program, and displaying the source program A program debugging support device having a display means that allows the location of an error to be identified within the display. 2. The program debugging support device according to item 1, wherein the display of the source program including the identification display of the location where the error has occurred is activated by inputting a specific command after displaying the error message. 3. Means for retaining the location of the last executed expression in the program debugging device described in paragraph 1, and means for detecting a match between the location of each expression in the source program containing an error and the retained location. , a program characterized in that it is possible to identify and display the location where an error has occurred.
Debugging support device.