JPH07334388A - Debugging device for function type information processor - Google Patents

Abstract

PURPOSE:To provide the debugging device for simplifying the debugging of a program prepared in a function type language concerning the debugging device for information processor to process the function type language. CONSTITUTION:When a language translating means 13 translates a source program to be inputted, a program memory 12 stores an execution form program, a position information table 15 stores the relation of correspondence between a function starter and a function stopper related to the function language, the execution is stopped for the unit of a function while referring to the position information table 15 when executing the execution form program stored in the program memory 12 with a step executing means 14, and the position of execution or that provided function value is displayed on a display means 16. Since the position information table stores the storage position of the execution form program and the position relation between the function starter and the function stopper, the function value related to the step execution of the function can be provided for the unit of a step.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a debugging device of a functional information processing device for performing step execution of a program of a functional language in units of functions.

[0002]

2. Description of the Related Art The basic structure of a functional language is (F OP1
OP2 ... OPn). The opening parenthesis '(' is the function starter and the closing parenthesis ')' is the function ender,
“F” is a function name, and OP1, OP2, ... OPn are n arguments of the function. The argument of the function may be the function itself.

FIG. 7 is a diagram showing an example of the configurations of an information processing device and a debugging device for processing a functional language. The information processing device 10 includes a machine language memory 1, a data memory 2, a CPU 3
And an interface unit 4. The data memory 2 stores the functional language to be processed. The machine language memory 1 stores a program obtained by converting the functional language to be processed into a machine language. The CPU 3 processes a machine language program stored in the machine language memory 1. The interface unit 4 is a transmission unit between the information processing device 10 and the debug device 11.

The debug device 11 comprises an interface section 5, an input device 6, a display device 7, a CPU 8 and a memory 9. The interface unit 5 transmits data with the interface unit 4 of the information processing device 10. The input device 6 inputs a debug menu specification, a breakpoint specification, and the like from the user. The display device 7 displays a response to a command from the input device 6, and also displays a source program, a menu at the time of debugging, and data being executed. The CPU 8 executes the control program stored in the memory 9 or causes the information processing apparatus 10 to execute the program of the functional language created by the user to execute the debugging process.

The memory 9 may be used as a substitute for the data memory 2 and the machine language memory 1 of the information processing apparatus 10.
Further, the debug device 11 may be equipped with an auxiliary storage device for storing the functional language created by the user. Although the information processing device 10 and the debug device 11 are separated in the example of FIG. 7, they may be integrated without an interface unit.

When a user creates a program, it is usually not completed only by desk debugging, and the user completes the program by performing debugging using the above-described debugging device.

As a debugging method for an information processing apparatus that processes a functional language, the following two methods have been conventionally used. In the first method, the user specifies a specific function in the program in advance, and when the debug device 11 executes the function, a stop signal is generated to interrupt the process or restart the interrupted process. As a result, the user stops the information processing device 10 with the designated function in the program,
You can check the intermediate results.

In the second method, when it is desired to know the processing result of a function whose argument is a function when the argument is a function, a function for storing the processing result of this function in the memory is written in the program, and the debugging device makes the argument. The function including the is executed and then stopped, and the processing result of the function which is the argument is confirmed from the contents stored in the memory. This is because if the argument is a function, the debug device cannot stop execution with this argument.

[0009]

In the first method, the user can stop at any function in the program. However, in order to confirm the movement of the program, the user who performs debugging needs to know the movement of the program in advance, and it is necessary to execute the program while sequentially changing the stop position of the program. If the execution of the program is followed in detail, there is a problem in that it is necessary to frequently specify or cancel the interruption so that the debugging work becomes very troublesome.

Furthermore, in a functional language, the processing order of the functions that are arguments in the function is not defined, and that order depends on the processing system. Therefore, the complete execution order of the programs is determined by this method. There was a problem that it could not be confirmed.

Further, in the functional language, for example, when the argument is a function, the processing result of the function of the argument may be used as it is by the function outside thereof as the value of the function. For this reason, the user has no means for confirming the processing result of the argument function, and must use the second method to confirm the processing result of the argument function.

However, in the second method, since it is necessary to write in the program a function for writing the result of the function for which the user wants to know the processing result to the memory, a function not related to the original processing is written in the program. There was a problem that the program became redundant. In addition, there is a possibility that a mistake may occur when unnecessary functions are deleted from a redundant program after debugging is completed.

An object of the present invention is to provide a debugging device that simplifies the debugging of a program created in a functional language.

[0014]

FIG. 1 is a block diagram showing the principle of the present invention. The present invention relates to a debug device of an information processing device that processes a functional language.

The position information table 15 stores the position of the execution format corresponding to the positions of the function starter and the function ender in the source program described in the functional language. The language translation unit 13 converts the correspondence relationship into the position information table 15 when converting the source program into an executable program and storing it in the program memory 12.
To store.

The step executing means 14 refers to the position information table 15 and executes the program in the execution format step by step on a function basis. The display unit 16 displays the execution position in function units when the step execution unit 14 executes the steps. Further, the function value of the processing result of step execution is read, and the function value is displayed together with the execution position.

[0017]

When the language translation means 13 translates the input source program, it stores the execution format program in the program memory 12 and also associates the position of the execution format program with the function starter and function end element related to the functional language. Is stored in the position information table 15.

The step executing means 14 refers to the position information table 15 when executing the executable program stored in the program memory 12, and stops the execution in function units. Then, the execution position and the obtained function value are displayed on the display means 16.

Since the positional relationship between the storage position of the executable program and the function starter and ender is stored in the position information table 15, the function value related to the step execution of the function can be obtained and displayed in steps. .

[0020]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A detailed description will be given below with reference to FIGS. 2 to 6 which are embodiments of a debugging device of an information processing device for processing a functional language according to the present invention.

In FIG. 2, the line number and column position in the source program of the function starter and the function endator, and the machine language address information corresponding to the function starter and the function ender are set as one record, and the source program in the source program is stored. It is a flowchart which creates the table which consists of the same number of records as a function. In this table, the programming device uses a functional language as a machine language,
That is, it is created when the language translation means 13 converts it into an executable program.

Here, the programming device is a device for creating or editing a source program and converting the created source program into a machine language. The debug device may also function as the programming device.

The routine of FIG. 2 creates a record of the row and column positions of the function starter and function ender of each function from the source program, and creates a table of the records of all the functions. The function is converted into a machine language while referencing the record created by the process, and the machine language address corresponding to the function starter and function endator is additionally stored in the record from the converted machine language to complete the record. , Post-processing of storing machine language addresses for all functions and creating a table.

When the routine of FIG. 2 is entered, first, step S
At 31 it is confirmed whether one character of the source program is a code indicating the end. If one character of the source program is not the code indicating the end (step S3)
1, N), one character in the source program is read in step S32, and it is confirmed whether the one character in the read program is a closing bracket (function terminator) of a function. If this one character is not a closing parenthesis (step S33, N), it is again determined in step S31 whether the program is the last one, and one character in the source program is read in step S31. Then, in steps S32 and S33, the characters in the source program are read until the read one character becomes a closing parenthesis.

When one character in the program detects a closing bracket (Y in step S33), step S3
In step 4, the opening parenthesis (function starter) corresponding to this closing parenthesis is searched. When the parenthesis corresponding to the opening parenthesis is detected, the line number and the digit position in the source program of the opening parenthesis and the line number and the digit position in the source program of the closing parenthesis are recorded in the table as one record in step S35. Write. By this processing, the function starter and function ender of one function are registered in the table. When the writing of one record is completed, the process returns to step S31.

The above operation is repeated until the code indicating the end of the source program is confirmed. By repeating this, the records of all the functions are written in the table.
When the code indicating the end of the source program is confirmed (step S31, Y), the preprocessing is ended here. Then, in step S36, the pointer indicating the position in the source program is returned to the beginning. A code such as EOF is stored at the end of the source program.

When the processing of step S36 is completed, post-processing is started, and the source program is converted into a machine language that can be executed by the CPU (microprocessor), that is, an executable program, and a machine corresponding to the opening parenthesis and closing parenthesis of the function. Store the word address in the record.

First, in step S37, it is confirmed whether one character of the source program is a code indicating the end. If one character of the source program is not the code indicating the end (step S37, N), the first record in which the row and digit data of the source program are stored is read from the table created in the preprocessing in step S38.
Since this record corresponds to one function and further has the positional information of the line number and the column position of the opening parenthesis and the closing parenthesis, one function in the source program is read from this positional information in step S39. And step S4
At 0, the machine language of this read function is generated.

In step S41, the first machine language address when one function is generated in the machine language and expanded in the memory corresponds to the opening parenthesis, and the last machine word address when expanding corresponds to the closing parenthesis. In step S41, the start address and end address of the corresponding machine language are additionally stored in one record in the table. As a result, the first record is created in the table.

When one record is created, step S3
Returning to 7, it is confirmed whether one character of the source program is a code indicating the end. If one character of the source program is not the code indicating the end (step S37,
N) Similarly to the above, the second record in which the row and digit data of the source program are stored is read again from the table created in the preprocessing in step S38. Then, when the record is read, one function is read in the same manner as the first record in step S39, and this function is converted into a machine language in step S40 to generate a machine language,
The machine language address corresponding to the opening parenthesis and the closing parenthesis from the machine language is stored in the second record in step S41 (step S41).

Thus, steps S37 to S are executed until the code indicating the end of the source program is confirmed.
The processing of 41 is repeated to generate the machine language of all functions, and records are created to complete the table.

When the code indicating the end of the source program is confirmed (step S37, Y), all the processes are finished (step S42). The table created by the above process is searched by using the closing bracket of the record as a key, and the table is created while searching for the opening bracket corresponding to the closing bracket, so that the closing bracket appears in the table in the order in which it appears. A pair of open and close brackets is registered. Thus, for example, if the function has three arguments A1, A2, A3, and if all these arguments are functions, the table is the function A
Records are generated and registered in the order of 1, function A2, and function A3. Therefore, since the debug device executes the function A1, the function A2, and the function A3 in this order when performing the step execution, the flow of the program is easy to understand and it is very easy to debug.

FIG. 3 is a table showing correspondence between parenthesis positions and machine language addresses of a source program created by executing the processing flow of FIG. 2. The table structure will be described below.

In this table, the parentheses of the source program of the function starter and the function endator are associated with the position information of the machine address on a one-to-one basis to make one record. A record is created.

One record consists of the opening parenthesis '(' of the source program of the function starter in one function and the line number and column position of the source program and the opening parenthesis '(' of the position when the source program is converted into a machine language). It consists of six elements: the machine language address, the line number and column position of the source program of the closing parenthesis ')' of the function terminator, and the machine language address of the closing parenthesis ')' position.

Since one record corresponds to one function when the debug device executes the function, the CPU (microprocessor) starts execution from the machine language address of the function starter and the machine language address of the function endator. By executing up to, one function can be executed.

FIG. 4 is a flowchart of a process in which the debug device causes the information processing device to perform step execution using the created table. One step execution is performed according to the processing flow of FIG.

This routine is entered when the user selects stepping. First, the processing of the debug device reads the machine language address of the current stop position on the machine language from the information processing device (step S61). In step S62, the read machine language address for starting step execution and the machine language address for the closing parenthesis in the table are set. That is, the machine language address for the record of the closest closing bracket, which is after the current stop position in the table, is set as the new stop position for step execution. Then, in step S64, the line number and the column position of the source program of the opening parenthesis (function starter) and the closing parenthesis (function endator) of the record at this time are stored in an area of the memory.

Next, for the information processing apparatus, step S6
At 4, the machine code is executed one code at a time from the current stop position, and one machine code is executed in sequence until the stop position exceeds a new stop position for step execution.
One function is executed by sequentially executing the processing of steps S61, S62, S63, and S64, and the function value of the processing result is stored in a specific memory area of the information processing device.

Subsequently, the line numbers and column positions of the source programs of the function starter and the function ender stored in step S64 are read out, and these positions are used to store the source program displayed on the source screen. Highlight the executed function. This allows the user to see at a glance which function has been executed.

Then, the function value of the processing result of the function executed in step S66 is read from the specific memory area of the information processing apparatus, and the function value is displayed in a predetermined area on the screen of the display device (step S67).

When step execution is selected as described above,
The debug device step-executes one function, highlights the executed function of the source program displayed on the screen using the position information of the function starter and function ender of the record, and executes the function of the executed function. Display the value in place on the screen.

If step execution is selected and further step execution is continuously selected, continuous step execution executes the processing flow of FIG. Done in. Along with that, the highlighting of each function moves on the screen as the step is executed.

FIG. 5 is a diagram showing changes in the display of the source screen during step execution according to the present invention. Here, the source screen, when the debug device debugs the functional language,
It is the figure which extracted only the source program in a source screen.

As described above, since the closing parenthesis is used as a key for retrieval, the record in the table is the function K71,
The order is function K72, function K73, function K74, and function K75. When step execution is continuously selected,
Step execution is performed in the order stored in the table in the order of function K71, function K72, function K73, function K74, function K.
75 are sequentially executed in function units. Along with the execution, the function K71, the function K72, and the function K7 are displayed on the screen.
3, the function K74 and the function K75 are highlighted in this order.

As described above, since step execution is continuously executed in function units, the user does not need to specify the next stop position, and the progress of step execution is displayed in an easy-to-understand manner, so debugging is easy. Can be done.

FIG. 6 is a diagram of a source screen during step execution of the debug device according to the present invention. In the source screen of FIG. 6, a menu of the debug device, a source program of a functional language, the status of step execution, the function value of the executed function, etc. are displayed. File (F), edit (E), operation (O), display (D), search (S), and test (M) are displayed on the upper part of the screen as a menu of the debug device, and are exclusively for an input device not shown. It is designated by a key or a function key corresponding to the menu.

The source screen in FIG. 6 shows the function K8 after the user selects step execution and executes the function K84.
This indicates that the function K86 having the argument of 5 is executed. The display of the executed source program of the function K86 is highlighted and highlighted. Here, the highlighted display of the function K84 executed before the function K86 is canceled before the highlighted display of the function K86. As a result, the executed function is displayed and highlighted for each function, so the operation related to debugging becomes very easy to understand. The method of highlighting the executed function is not limited to reverse display, and there are various display methods such as underlining, changing colors, and blinking.

Further, the function value of the processing result of the function K86 is displayed in the function value area K81 of the small window. Area K8
1 is for displaying the function value '1234' of the function K86.
This eliminates the need to write a function for writing the processing result of the function K86, which is an argument, in the memory in the program. It should be noted that in this small window, "step being executed" is displayed to indicate that the step is being executed. Further, "execution" for executing the next function K87 or "cancel" for stopping the step execution is displayed, and is selected by a designated key of an input device (not shown). By continuously specifying'execution 'by the user, the debug device continuously performs step execution in function units by executing the processing flow of FIG. 4 described above, and automatically calculates the function value of the processing result of the sequentially executed functions. It is displayed in the function value area K81.

Although the small window is used to display the processing result of the function in the source screen example, a specific area in the source screen may be used instead of the small window.

[0051]

According to the present invention, when step execution is performed, the debug device sequentially executes the functions in the program in function units, and the source program is displayed even if the user does not specify the next stop position. The progress of the step execution is displayed on the screen so that the user can easily understand it, and the function values of the processing results of the sequentially executed functions are automatically and sequentially displayed at predetermined positions. In this way, since the function value of the processing result of the function during step execution is displayed for each function, it is not necessary to rewrite the program for debugging, and it is possible to easily debug a program created in the start-type language. .

[Brief description of drawings]

FIG. 1 is a principle block diagram of the present invention.

FIG. 2 is a flowchart for creating a table.

FIG. 3 is a diagram of a table in which parenthesis positions in a source program correspond to machine language addresses.

FIG. 4 is a flowchart of step execution.

FIG. 5 is a diagram showing a change in display of a source screen during step execution according to the present invention.

FIG. 6 is a diagram of a source screen during step execution according to the present invention.

FIG. 7 is a diagram showing an example of configurations of an information processing device and a debugging device that process a functional language.

[Explanation of symbols]

 12 Program Memory 13 Language Translation Means 14 Step Execution Means 15 Position Information Table 16 Display Means

Claims (3)

[Claims] 1. A debugging device of an information processing device for processing a functional language, wherein an execution form of an execution format is associated with a position of a function starter and a position of a function ender in a source program written in the functional language. Position information table (15) that stores the positional correspondence
A language translation means (13) for storing the correspondence in the position information table (15) when the source program is converted into an executable program and stored in a program memory (12), and the position information table (15) A debug device for a functional information processing device, comprising: step execution means (14) for stepwise executing an executable program in the function unit. 2. When the step execution means (14) performs step execution using the information of the position of the function starter, the position of the function ender, and the position of the execution format, the execution position is displayed in function units. The debug device for a functional information processing apparatus according to claim 1, further comprising a display means (16) for performing the operation. 3. The step execution from the information processing device when the step execution means (14) performs step execution using the information of the position of the function starter, the position of the function ender and the position of the execution format. Read the function value of the processing result of
Display means (16) for displaying the function value together with the execution position
The debugging device for a functional information processing device according to claim 1, further comprising: