JP2008059515A - Method, system, and program for displaying program execution process - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To represent a locus, through which a program has moved actually, by an arrow following source code control syntax for presenting an execution process of the program more clearly. <P>SOLUTION: This method includes a first step, a second step, a third step, and a fourth step. In the first step, using an execution class compiling source codes and information of an abstract syntax tree serving as a syntax analysis result as input, instructions for outputting line number positions of corresponding source codes as execution information are embedded to start positions and end positions of methods constituting the execution class and the heads of variable declarations, determination formulas, declaration sentences, and return sentences. In the second step, the execution class with the embedded execution information is operated. In the third step, pieces of the execution information output by the execution class are collected and sorted in execution time order and classified by method, and based on the classification result and the information of the abstract syntax tree, execution processes of the methods and the like in the execution class are tracked. In the forth step, the tracked execution processes are displayed by arrows on the source code of the program displayed on a display screen. <P>COPYRIGHT: (C)2008,JPO&INPIT

Description

  The present invention relates to a program execution process display method and system, and a program. More specifically, the execution process such as a process branching process and a repetition process is traced for each execution unit of the program, and the execution process is displayed on a display screen. The present invention relates to a method, a system, and a program for visually displaying the source code by arrows.

Increasing use of computers has increased the scale and complexity of programs, and improving their quality and productivity has become an important issue.
In the recent program development field, it is very good to execute the program to identify the location of the failure and to check the actual operation process by sequentially highlighting the source code line corresponding to the execution step. Has been done.

FIG. 25 is a diagram showing an execution screen of such a program development environment.
In this environment, an execution information output instruction is inserted for each step, the program is executed, and the output execution information is analyzed to sequentially highlight source code lines corresponding to the execution steps. is there. In the example shown in the figure, since the highlight is switched from 2501 in the 45th line to 2502 in the 50th line, the developer understands that the 50th line is executed next to the 45th line.
Here, the execution information is information for specifying a position on the source code corresponding to the executed step, and indicates information such as the 45th line of the MyClass.java file, for example.
The following patent document 1 is given as a known technical document related to the present invention.

Japanese Patent Application No. 2005-282571

By the way, since the source code has a control syntax such as iteration, conditional branching, and exception handling, the highlight position may not only be switched from top to bottom, but may be switched across lines.
For this reason, in order to determine whether the operating process is normal in terms of processing, it is necessary for the developer to memorize the order of highlighting up to that point and to observe while predicting the next highlighted line. Therefore, deep knowledge about the target program is required, and it is difficult for an inexperienced beginner or a person other than the person in charge to specify the location of the failure by such a method.
This can be solved by expressing the highlighted process with shades of color.

However, the reason for reaching the line cannot be determined only from the highlighted progress. For example, when the line of interest is not executed, it cannot be read from the highlighted progress whether it was not executed by a conditional branch or was not interrupted by exception processing. Therefore, in the end, developers need to interpret the syntax of the source code.
In addition, normally, one line is executed a plurality of times, and there remains a problem of how to express each execution separately.

  SUMMARY OF THE INVENTION An object of the present invention is to display a program execution process display method and system capable of expressing a trajectory in which a program has actually moved with an arrow along a control syntax of a source code and presenting the execution process of the program in an easy-to-understand manner, and To provide a program.

In order to achieve the above object, a display method of a program execution process according to the present invention is a method of displaying the execution process of a target program on the source code of the program displayed on a display screen,
The execution class obtained by compiling the source code of the program and the abstract syntax tree information that is the result of the syntax analysis are accepted as inputs, and the start, end position, and variable declaration of the method constituting the execution class based on the information of the abstract syntax tree; A first step of embedding by a first means an instruction for outputting the line number position of the corresponding source code as execution information at the head of a judgment expression, declaration statement, and return statement, and the execution in which the execution information is embedded The second step of executing the class by the second means, and the execution information output by the execution class executed by the second means are collected, sorted in order of execution time, and then classified into method units. Based on the classification result and the abstract syntax tree information, methods, variable declarations, judgment expressions, declaration statements, and litters in the execution class A third step of tracking the execution process of the sentence by the third means; a fourth step of displaying the tracked execution process by an arrow by the fourth means on the source code of the program displayed on the display screen; It is characterized by providing.

The program execution process display system according to the present invention is a system for displaying the execution process of the target program on the source code of the program displayed on the display screen,
The execution class obtained by compiling the source code of the program and the abstract syntax tree information that is the result of the syntax analysis are accepted as inputs, and the start, end position, and variable declaration of the method constituting the execution class based on the information of the abstract syntax tree; First means for embedding an instruction to output the line number position of the corresponding source code as execution information at the head of the judgment expression, declaration statement, and return statement, and executing the execution class in which the execution information is embedded The execution information output by the execution class executed by the second means and the second means is collected, sorted in order of execution time, and classified into method units, the classification result and the abstract syntax tree information And a third means for tracking the execution process of the method, variable declaration, judgment expression, declaration statement, and return statement in the execution class based on The execution process, characterized in that it comprises a fourth means for displaying by the arrow on the source code of the program displayed on the display screen.

Further, the display program of the execution process of the program according to the present invention is a computer program for displaying the execution process of the target program on the source code of the program displayed on the display screen,
Computer
The execution class obtained by compiling the source code of the target program and the abstract syntax tree information that is the result of the syntax analysis are accepted as input, and the start, end position, and variable declaration of the method constituting the execution class based on the abstract syntax tree information First means for embedding an instruction for outputting the line number position of the corresponding source code as execution information at the head of the judgment expression, declaration statement, and return statement, and executing the execution class in which the execution information is embedded The execution information output by the second means and the execution class executed by the second means is collected, sorted in order of execution time, and then classified into method units. The classification result and the abstract syntax tree information And a third means for tracking the execution process of the method, variable declaration, judgment expression, declaration statement, and return statement in the execution class based on It was execution process, characterized in that it comprises a step to act as a fourth means for displaying by the arrow on the source code of the program displayed on the display screen.

According to the present invention, the target program is parsed, and the start, end position and variable declaration, judgment expression, declaration statement, and return statement of the method that constitutes the execution class of the target program by the abstract syntax tree Embed an instruction that outputs the line number position of the corresponding source code as execution information, collect the execution information obtained by executing the program with this execution information embedded, trace the execution process of each method, etc. An arrow indicating the process is generated and displayed on the source code of the target program. For example, if the target line was not executed, it was not executed by a conditional branch, or how many times the target line was executed Can be visually recognized.
As a result, the execution process of the program can be intuitively understood, and the location where the failure occurs can be easily identified. In addition, even an inexperienced beginner can understand the flow of program processing, so it can be used as a teaching material in the place of program education.

FIG. 1 is a system configuration diagram showing an embodiment of a program development system to which the present invention is applied.
The program development system of this embodiment is intended for Java (registered trademark of Sun Microsystems) application development, and includes a computer 102 having a program development environment 101 and a computer 104 having a program execution environment 103. Is done.
Each of the computers 102 and 104 includes a keyboard 105 and a mouse 106 for accepting developer input. A screen display device 107 for displaying an execution screen of the program development environment 101 is also provided.
In this embodiment, the program development environment 101 and the program execution environment 103 are mounted on different computers 102 and 104, but one computer may be mounted on both environments.

  The program development environment 101 is an environment for developing a program. The source code holding unit 108 that stores source code, the source code editing unit 109 that displays and operates the stored source code, and the source code are compiled. A compiler 110 for executing the program, an execution class holding unit 111 for storing the execution class generated by the compiler 110, a syntax analysis unit 112 for analyzing the syntax of the source code, and an abstract syntax tree generated by the syntax analysis unit 112. Based on the abstract syntax tree holding unit 113, an execution information output instruction embedding unit 114 that embeds output processing of execution information in the execution class based on the abstract syntax tree, and execution information that classifies the output execution information 115 into execution units An operation for generating operation process information based on the classification unit 116 and the classified execution information and the abstract syntax tree The process tracking unit 117, the operation process information holding unit 118 for storing operation process information (execution process information), and the operation process information drawing for drawing an arrow on the source code displayed by the source code editing unit 109 based on the operation process information Part 119.

On the other hand, the program execution environment 103 is an environment for executing a program created by the program development environment 101, and includes an execution class holding unit 120 that stores a target execution class, and a program execution unit 121 that executes a program. Composed.
If the program execution unit 121 executes the execution information output command embedding unit 114 with the execution information output command embedded therein, the execution information 115 is output.
The execution information 115 is information for specifying a position on the source code corresponding to the executed step.

FIG. 2 shows an execution screen of the program development environment 101 described in FIG. 1. The upper screen is a state before displaying the execution process, and the lower screen is a state after displaying the execution process.
The program development environment 101 includes an area 201 for editing a program, an area 202 for indicating a line number, a compile button 203, an operation process display button 204, and an arrow 205 indicating an operation process of the program. The
A series of arrows 205 indicate individual execution processes. Taking the contents of the figure as an example, the method showDetail with line number = 35 has three arrows in the vertical direction to and from the method with line number = 37. Indicates that it has been executed twice.
Also, each arrow indicates whether or not it has been executed at that horizontal position. For example, taking the contents of the figure as an example, the System.out.println command on the 38th line was executed three times in total, but two times are actually executed because two arrow lines come and go in the vertical direction. It shows that it was done.
In addition, the repetition is expressed by a repeated arrow as shown in the 41st to 43rd lines. The number of arrows indicates the number of times of repeated execution. For example, the next instruction on the 42nd line means that it has been repeatedly executed eight times by one out of a total of three times.
A line whose processing is interrupted due to a failure is represented by an “x” mark. For example, the getItem method on the 40th line means that a failure has occurred and interrupted once in a total of three times.

FIG. 3 is a flowchart showing the overall flow of the development process in the program development system of the embodiment of FIG.
First, the developer activates the program development environment 101 (step 301). The program development environment 101 reads the specified source code from the source code holding unit 108 and displays it in the program editing area 201.
The developer uses the keyboard 105 and the mouse 106 to edit the source code. When the implementation is completed, the developer shapes the indentation depth and presses the compile button 203.
Then, the program development environment 101 generates an execution class using the compiler 110 (steps 302 and 303).
Note that generation of an execution class from source code is a known technique, and thus description thereof is omitted.

When the compilation is completed, the program development environment 101 then creates an abstract syntax tree in the syntax analysis unit 112 and embeds execution information output processing in the execution class in the execution information output instruction embedding unit 114 (step 304).
Next, the developer executes the execution class in which the execution information output process is embedded in the program execution environment 103, and collects the output execution information 115 (step 305).
Next, the developer presses an operation process display button 204 in the program development environment 101. Then, the program development environment 101 reads the collected execution information 115 and classifies the execution information 115 read by the execution information classification unit 116 into execution units. Then, operation process information is generated based on the result of the classification in the operation process tracking unit 117 and the parse tree (step 306). Next, the operation process information drawing unit 119 draws an arrow 205 in the program editing area 201 based on the operation process information and ends (step 307).

FIG. 4 is a diagram illustrating an example of an abstract syntax tree generated by the syntax analysis unit 112.
An abstract syntax tree is a tree structure that represents the contents of the source code. The section of the control syntax is represented by a section such as 401, and the contents of each line such as method execution and variable declaration are represented by a leaf such as 402. Express. The leaf holds the line number 403 on the corresponding source code and the digit number 404 at the head position as attributes.
Since a technique for generating an abstract syntax tree from source code is known, detailed description of the internal processing of the syntax analysis unit 112 is omitted.

FIG. 5 is a flowchart showing details of the process of embedding the output processing instruction of the execution information in step 304 in FIG.
The execution information output instruction embedding unit 114 acquires an abstract syntax tree for the source code opened in the source code editing unit 109 (step 501), scans all method definitions existing in the source code (step 502), and Execution information output instructions are inserted into the start and end lines of the method by bytecode operations (step 503).
Also, the contents of the corresponding method of the abstract syntax tree are scanned (steps 504 and 505), and the acquired line is a variable declaration statement (step 506), a determination expression (step 507), a method execution statement (step 508), or When a return instruction (step 509) is included, an execution information output instruction is embedded at the beginning of the line by bytecode operation (step 510).
Here, since a technique for embedding a specific instruction at the start line, end line, or specified position of a method by bytecode operation is well known, description thereof is omitted. Also, an output command to be embedded in the end line is embedded so that it is always output even when processing is interrupted. This can be achieved by enclosing the entire target code in a try clause and manipulating the bytecode so that a log output command is called in the finally clause.

FIG. 6 is a diagram illustrating an example of the execution information 115 to be output.
The execution information includes an output time 601, a thread ID 602, a target class name 603, a target method name 604, and a line number 605. Among these, the output time 601 and the thread ID 602 are dynamically determined and output internally during program execution.
Here, the thread ID 602 uniquely identifies the executed thread.
A target class name 603, a target method name 604, and a line number 605 output a static character string specified as an argument when embedding execution information. Also, in the case of line number 605, if it is output to the method start / end line, identifiers representing start (S) and end (E) are output instead of the line number.

FIG. 7 is a diagram illustrating an example of the result of classification by the execution information classifying unit 116.
The execution information classification unit 116 sorts the collected execution information 115 according to the output time 601 and classifies the collected execution information 115 for each target class name 701, target method 702, and thread ID 703, from the start identifier (S) to the end identifier (E). A series of execution information is integrated into one.
A set of execution information sandwiched between a start identifier (S) and an end identifier (E) as shown in 704 is called a context here, and the line number of each piece of data in the context is called context data. Context indicates the order of executed lines in one method execution. As shown in the figure, one method may hold multiple contexts, and one thread holds multiple contexts. There is a case.
Hereinafter, a procedure for drawing the arrow 205 from the context and the abstract syntax tree to the source code editing unit 109 will be described.
As shown in FIG. 4, the abstract syntax tree holds various information such as attributes such as method declarations and block ranges, but here, in order to simplify the explanation, a simple syntax that holds only the structure of control syntax and line numbers. An example of a generalized abstract syntax tree will be described.

FIG. 8 shows an example of such a simplified abstract syntax tree.
In this abstract syntax tree, the target method name is represented by the root attribute, and the line number is represented by the node attribute. Further, in this abstract syntax tree, only the lines that are to be embedded in the execution information output processing embedding unit, that is, the lines in which any of variable declarations, judgment expressions, method execution statements, and return statements exist are targeted. Hereinafter, these lines are called effective lines.
For example, the contents of FIG. 8 represent the contents of the source code shown in FIG. 2, but the 44th, 46th, and 49th lines in FIG. 2 are not valid lines because they do not include the above instructions. . The arrow connected to each node means the order of effective rows to be executed. Taking the contents of the figure as an example, the showDetail method 801 executes the 37th line after the 36th line 86. Further, when a plurality of arrows extend from one node, it represents a determination formula for the if clause or the switch clause, which means that one of the plurality of nodes is executed. Taking the content of the figure as an example, the 37th line is a judgment formula, which means that either the 38th line or the 47th line is executed next.

When nodes are connected by a “straight line” instead of an arrow, it indicates a judgment expression of a for clause or a while clause, and means that a series of connected nodes are repeatedly executed. Taking the content of the figure as an example, the 41st line is a judgment formula, which means that the 42nd to 43rd lines are repeatedly executed.
Further, when connected by a curve, it represents that the node of the connection destination is a jump destination of exception processing. Examples of curves will be described later.
The terminal node that is not connected with an arrow represents the end point of iteration or method execution. Taking the contents of the figure as an example, the execution of the showDetail method ends at the 50th or 48th line. In addition, the iterative process ends at the 43rd line.

FIG. 9 is a diagram showing a data structure of the simplified abstract syntax tree shown in FIG.
This abstract syntax tree includes two types of tables, a root and a node. The root table 901 includes a class name 903, a method name 904, and a next line ID 905. Of these, the class name 903 stores the fully qualified name of the target class. The method name 904 stores the name of the target method and the argument type. Note that the combination of the class name 903 and the method name 904 is unique in the target program. The next row ID 905 stores the ID of the row to be executed first in the target method.

  The node table 902 includes an ID 906, a line number 907, a next line ID 908, an iteration start line ID 909, and a jump line ID 910. Among these, ID 906 stores a value unique to the target program. The line number 907 stores the line number on the corresponding source code. The next row ID 908 stores the ID 906 of the next row to be executed. When the target row is a conditional branch determination formula, a plurality of next row IDs 908 are stored. If the corresponding line is an iteration or the end point of method execution, the next line ID 908 is empty. The iteration start line ID 909 and the jump line ID 910 store the ID 906 of the line that starts the iteration and the ID 906 of the line that jumps when an exception occurs. The iteration start line ID 909 is always one, but there may be a plurality of jump line IDs 910 in one node.

FIG. 10 is a diagram illustrating a data structure of the operation process information generated by the operation process tracking unit 117.
The operation process information is information on which an arrow is drawn in the source code editing unit 109, and stores information such as whether or not the execution has been performed for each valid line. Also, one piece of operation process information is generated for one context.
Each operation process information includes an area for storing a target class name 1001 and a method name 1002.
Also, one piece of operation process information holds the operation process of the effective row excluding the repetitive process called main flow, and the main flow holds the operation process of the repetitive section called partial flow. A partial flow may also hold a partial flow. The main flow and the partial flow are composed of a flow ID 1003, a line number 1004, a state 1005, a partial flow 1006, and a jump line 1007. The flow ID 1003 is a numerical value that identifies the main flow and each partial flow in one operation process information, and the value of the main flow is 1.

Line number 1004 corresponds to the line number of the source code.
The status 1005 takes one of the values none, exec, error, or return, and the corresponding line was not executed, executed, or should have been executed, but was interrupted due to a failure. It means that it was interrupted by return processing.
In the node where the partial flow 1006 exists, the corresponding row is an iterative determination formula, and a partial flow area is generated as many times as the number of repeated executions, and the flow ID 1003 is stored. For example, since the 86th line in the example holds two partial flows 1006, it indicates that the iterative process has been executed twice, which means that two partial flows represented by flow IDs 2 and 3 have been executed.
The jump row 1007 stores a jump destination row when exception processing is performed.

FIG. 11 is a flowchart showing details of processing for generating operation process information from the parse tree and execution information in step 306 of FIG.
First, the program development environment 101 acquires contexts classified by the execution information classification unit 116 (steps 1101 and 1102).
Next, the class name 701 and the method name 702 are obtained from the context, and the method definition that matches them is obtained from the abstract syntax tree (step 1103). Next, one operation process information area is generated, and the acquired class name and method name are stored (step 1104).
Next, it is checked whether the next line ID 905 exists in the data of the acquired abstract syntax tree route table 901 (step 1105). If not, the next context is processed (step 1101).

If it exists, the node indicated by the next row ID is scanned, and the number of valid rows excluding the repeated section is counted. Then, the corresponding number of the main flow with ID 1 is secured in the operation process information and the corresponding row number 1004 is stored, and each state 1005 is initialized with none (steps 1106, 1107, 1108). Then, the contents of the context and the abstract syntax tree are compared, and the result is stored in the operation process information (step 1109).
When the process for one context is completed, the next context is processed, and the process ends when all the contexts are processed (step 1101).

FIG. 12 is a flowchart showing details of the processing of comparing the context of step 1109 with the contents of the abstract syntax tree and storing the result in the operation process information.
The operation process tracking unit 117 first initializes the reference position of the abstract syntax tree called a node pointer with the position of the corresponding data in the route table (step 1201).
Next, data indicated by the node pointer is acquired (step 1202).
Next, the operation process tracking unit 117 acquires context data from the target context (step 1203).
Next, the operation process tracking unit 117 checks whether or not a value exists in the next row IDs 905 and 908 of the data pointed to by the node pointer (step 1204). If it exists, the line number 907 is acquired from the node with the matching ID 906 and compared with the context data (step 1205).
If they match, the node position corresponding to the matched line number is stored in the node pointer (step 1206), and the data state 1005 of the operation process information corresponding to the matched line number is overwritten with exec (step 1207). ), Processing the remaining context data (step 1202).

If there is no value in the next row IDs 905 and 908 or if they do not match, it is checked whether or not there is a value in the iteration start row ID 909 in the data pointed to by the node pointer (step 1208). If the node pointer points to data in the route table 901 in the initial state, the iteration start row ID 909 does not necessarily exist.
When the node pointer refers to the data in the node table 902 and the repetition start row ID 909 exists (step 1207), the contents of the context data are examined (step 1209). If the context data is null and there is no remainder, it is considered that the process has ended normally without being executed as a result of the iteration determination. Therefore, the data state 1005 of the operation process information corresponding to the line number 907 of the data pointed to by the node pointer Is overwritten with return (step 1210), and the processing for this context is terminated.

If context data exists, the line number 907 of the node having the same repetition start line ID 909 and ID 906 is acquired and compared (step 1211). If they match, it is considered that the processing of the repetitive section has been started, so the data pointed to by the node pointer is stored in the stack (step 1212), and a partial flow area is generated in the operation process information (step 1213).
Next, the node pointer stores the position of node data where the iteration start line ID 909 and ID 906 match (step 1214), and further overwrites the data state 1005 of the operation process information corresponding to the matched line number 907 with exec. (Step 1207), the remaining context data is processed.

If the iteration start line ID 909 does not exist or does not match the context data, it is checked whether or not the jump line ID 910 exists in the data pointed to by the node pointer (step 1215). Note that when the node pointer points to data in the route table 901 in the initial state, the jump row ID 910 does not necessarily exist.
If the node pointer refers to the data in the node table 902 and the jump row ID 910 exists, the row number 908 of the data whose ID 906 matches that stored in the jump row ID 910 is acquired and compared with the context data ( Step 1216). If it matches with the context data, it is considered that exception processing has been performed, so the line number 907 that matches the jump line 1007 of the data of the operation process information corresponding to the line number 907 of the data pointed to by the node pointer is stored (step). 1217).

Next, the data position where the jump row ID 910 matches ID 906 is stored in the node pointer (step 1218). Next, the data state 1005 of the operation process information corresponding to the matched line number 907 is overwritten with exec (step 1207), and the remaining context data is processed. If no ID exists in the jump row ID 910 or does not match the context data, it is checked whether there is data saved in the stack (step 1219).
If there is data on the stack, processing of the repetitive block may have been completed, so data is acquired from the stack (step 1220), and the line number 907 is compared with the context data (step 1221). If they match, it is considered that the iterative process has been completed and the determination formula has been executed again, so the position of the acquired data is stored in the node pointer (step 1222), and the operation process information corresponding to the matched line number 907 The data state 1005 is overwritten with exec (step 1207), and the remaining context data is processed.

If there is no data in the stack, or if the stack data row number 907 does not match the content of the context data, there is a possibility of an error or normal termination, so whether the data pointed to by the node pointer holds the next row ID 908 Check again. If it exists, since it is contrary to the contents of the abstract syntax tree, the state 1005 of the operation process information corresponding to the line number 907 of the data pointed to by the node pointer is overwritten with error, and the processing of the target context is terminated (step 1224).
If it does not exist, it is considered that the program has ended normally, so the state 1005 of the operation process information corresponding to the line number 907 of the data pointed to by the node pointer is overwritten with return, and the processing of the target context is ended (step 1210). .

FIG. 13 is a flowchart showing details of the process of generating a partial flow area in the operation process information in step 1213.
First, the operation process tracking unit 117 obtains a section to be repeatedly executed from the iteration start line ID 909 from the abstract syntax tree, and if there is data in which the iteration start line ID 909 further exists in the iteration section, the section number 907 excluding them is set. A corresponding area is secured in the operation process information, and the row number 1004 is stored in each data (step 1301).
For example, when the repetitive section is the 21st, 22nd, 23rd, 24th and 25th lines, and the 22nd, 23rd and 24th lines are further repetitive sections, the area corresponding to the 21st and 25th lines excluding the repetitive sections is the operation process. Generated into information.

  Next, the flow ID 1003 of the generated area stores the largest value in the operation process information incremented by 1 (step 1302). Then, the stored ID is added to the data partial flow 1006 of the operation process information corresponding to the row number 1004 of the data pointed to by the node pointer (step 1303), and the state 1005 of the generated area is all initialized to none, and the process ends. (Step 1304).

14 to 18 are diagrams for specifically explaining the processing of FIG.
In these examples, the content of the context to be processed is represented on the right side of the diagram, the content of the abstract syntax tree to be processed is represented in the center of the diagram, and the content of the operation process information of the processing result is represented on the left side of the diagram. In the abstract syntax tree, the position indicated by the white arrow represents the position of the node pointer.
FIG. 14 shows the case where the row number of the data indicated by the next row ID 908 matches the context data in step 1205 and the exec is stored. In step 1224, the data pointed to by the node pointer does not have the value of the next row ID. A specific example in the case where is stored will be shown.
The abstract syntax tree 1401 in this example expresses sequential execution from the 11th line to the 14th line. In the operation process information 1402, a main flow area from the 11th line to the 14th line corresponding to the abstract syntax tree is created in step 1106.
First, in accordance with step 1201, the operation process tracking unit 117 stores the data position 1403 of the route table 901 in the node pointer.

Next, context data is acquired. At this stage, since it is the first acquisition, it becomes the top 11.
Next, according to step 1204, the line number of the next line of the data pointed to by the node pointer is acquired. In this example, it is the 11th line.
Next, in step 1205, it is checked whether or not it matches the value of the context data. In this example, since both are 11 as indicated by 1404, the position of the node data 1405 corresponding to the 11th row is stored in the node pointer (step 1206), and the state of the 11th row of the operation process information is changed according to step 1207. Overwrite with exec.
Next, the 12th and 13th lines are processed in the same manner, and the state of the corresponding operation process information is overwritten with exec. At the stage where the state of the operation process information corresponding to the 13th line is overwritten by exec, the node pointer points to the data 1406 of the node corresponding to the 13th line. In this data, the ID of the node corresponding to the 14th row is stored in the next row ID 908, but the context data does not exist and is null and does not match as indicated by 1407. Then, the operation process information state 1005 corresponding to the 13th line indicated by the node pointer is overwritten again with error, and the process ends.

FIG. 15 is a diagram illustrating a specific example in the case where there are a plurality of next row IDs 908 in step 1205 and the case where the normal termination is performed in step 1210.
In the abstract syntax tree 1501 of this example, the third line is a judgment formula, and one of the fourth, fifth and eighth lines or the sixth and seventh lines is executed depending on the result of the judgment formula. In the operation process information 1502, a main flow area corresponding to the second to eighth lines corresponding to the abstract syntax tree is created in step 1106.
The operation process tracking unit 117 overwrites the state of the operation process information corresponding to the third line with exec, obtains the fourth and sixth lines indicated by the next line ID, and compares them with the context data. Since the context data referred to at this time is “4”, the position 1503 of the node whose row number is “4” is stored in the node pointer according to step 1206, and the state of the operation process information corresponding to the fourth row 1005 is overwritten with exec according to step 1207. Then, the fifth and eighth lines are processed in the same manner, the state of the eighth line is overwritten with exec, the contents of the data pointed to by the node pointer 1504 are confirmed, the next line ID, the iteration start line ID, the jump line ID, and Since all the nodes on the stack do not exist, step 1210 is reached, and the state of the operation process information corresponding to the eighth line pointed to by the node pointer 1504 is overwritten again by return, and the process ends.

FIG. 16 is a diagram illustrating a specific example when a partial flow is generated in step 1213.
The abstract syntax tree 1601 of this example executes the 7th line, which is the determination formula for the iteration process, after the 6th line, and repeatedly executes the 8th and 9th lines according to the result. Execute eyes and exit. In the operation process information 1602, a main flow region corresponding to the sixth, seventh, and tenth lines excluding the eighth and ninth lines, which are repetitive sections, is generated in step 1106.
The operation process tracking unit 117 overwrites the state 1005 of the operation process information corresponding to the seventh line with exec, and then acquires the node on the tenth line indicated by the next line ID 908, but the context data is the eighth line. Therefore, the process reaches step 1211 and coincides with the iteration start line. Therefore, the node pointed to by the node pointer 1603 is stored in the stack 1604, and the partial flow areas corresponding to the 8th and 9th lines are flown according to steps 1301 and 1302. Generate with ID2.

Next, after adding 2 to the partial flow 1006 of the operation process information corresponding to the seventh line indicated by the node pointer 1603 according to the step 1303, the data state 1005 of the secured flow ID 2 is initialized to none according to the step 1304. In step 1214, the node position corresponding to the eighth line is stored in the node pointer. Further, in step 1207, the state 1005 of the operation process information corresponding to the eighth line is overwritten with exec.
Thereafter, after the operation process tracking unit 117 overwrites the state of the operation process information corresponding to the ninth line with exec, the data pointed to by the node pointer 1605 does not include the next line, the jump line, or the repetition start line. The node data corresponding to the seventh line stacked in the stack is obtained and compared with the context data. Since both coincide with each other in the seventh line, the node position corresponding to the seventh line is stored in the node pointer. . Then, the next context data is processed by overwriting the state 1005 of the operation process information corresponding to the seventh line with exec.

FIG. 17 is a diagram showing a specific example of a case where a plurality of data is stacked on the stack among the examples where nodes are stacked on the stack in step 1213.
In this example, after executing the 14th line, the abstract syntax tree 1701 performs an iterative process determination process on the 15th line, and repeatedly executes the 16th and 18th lines according to the result. The 16th line is a determination formula for the iterative process, and the 17th line is repeatedly executed according to the result.
In the operation process information 1702, a region of the main flow corresponding to the 14th and 15th lines excluding the repetitive section is generated in step 1106.

The operation process tracking unit 117 overwrites the state of the operation process information corresponding to the 15th line with exec, and then the 16th line as the iteration start line matches the context data, so the node corresponding to the 15th line is stacked. To store. Then, according to steps 1301 and 1302, a partial flow region corresponding to the 16th and 18th lines excluding the 17th line which is a further repeated section from the 16th, 17th and 18th lines which is a repeated section is generated with a flow ID2.
Also, according to step 1303, the flow ID 2 is stored in the partial flow 1006 of the data of the operation process information corresponding to the 15th line indicated by the node pointer 1703. Further, according to step 1214, the node position corresponding to the 16th line is stored in the node pointer, and the state of the operation process information corresponding to the 16th line is overwritten with exec. Next, since the repetition start line pointed to by the node pointer 1704 and the content of the context data coincide with each other on the 17th line, the data of the node corresponding to the 16th line pointed to by the node pointer 1704 is stored in the stack according to step 1212.

Next, according to steps 1301 and 1302, a partial flow area corresponding to the 17th line which is a repetitive section is secured by ID3 and processed.
Next, since the contents stacked on the stack coincide with the contents of the context data on the 16th line, the node position corresponding to the 16th line is stored in the node pointer according to step 1222. Further, according to step 1207, the state of the data of the operation process information corresponding to the 16th line is overwritten with exec, and the next context data is processed.

FIG. 18 is a diagram showing a specific example in the case where the jump line 1007 is stored in step 1215.
The abstract syntax tree 1801 in this example sequentially executes the 34th, 35th, and 45th lines. A solid curve 1803 extending from the node representing the 34th and 35th lines represents the jump destination. If an exception occurs when the 34th and 35th lines are executed, the 40th and 41st lines are displayed. Indicates what will be done instead.
In the operation process information 1802, an area of the main flow corresponding to the 34th, 35th, 40th, 41st, and 45th lines is generated in step 1106.

After the action tracking unit 117 overwrites the state of the operation process information data corresponding to the 34th line with exec, the context data and the jump line of the data pointed to by the node pointer 1804 coincide with each other. The row number 40 of the data whose ID matches the jump row ID 910 of the node corresponding to the 34th row is stored in the jump row of the data of the operation process information corresponding to the 34th row.
Next, the position of the node corresponding to the 40th line is stored in the node pointer according to step 1218, and the remaining context data is processed by overwriting the data state of the operation process information corresponding to the 40th line with exec according to step 1207. .

FIG. 19 is a flowchart showing details of the process of drawing the operation process information in step 307 in FIG. 3 on the source code editing unit.
First, the operation process information drawing unit 119 acquires one operation process information from the operation process information holding unit 118, and acquires all operation process information whose class name 1001 and method name 1002 match (steps 1901, 1902).
Next, a value for correcting the horizontal position for drawing an arrow called a correction value is initialized to “0” (step 1903).
Next, one piece of operation process information is acquired from the operation process information group acquired in step 1902 (step 1904).
Next, the line number of the declaration line of the corresponding method is acquired from the source code editing unit 109, and an arrow from the left to the right is drawn at that position (step 1905).
Next, the horizontal position of the first character of the method declaration is calculated from the number of digits, and the correction value is added to it. This position is hereinafter referred to as the left position (step 1906).
Next, one piece of data is sequentially acquired from the main flow of the operation process information (step 1907).

Next, the horizontal position at the head of the line corresponding to the acquired data is calculated from the number of digits, and a correction value is added to the calculated horizontal position. Hereinafter, this horizontal position is referred to as the right side (step 1908).
A line with a line drawn on the right side means that the line has been executed, and a line with a line drawn on the left side means that the line has not been executed. If the horizontal position of the line to be drawn is different from that drawn immediately before, a horizontal arrow connecting the two lines is drawn.
Next, the state 1005 of the acquired data is checked, and if it is error or return (steps 1909 and 1910), an upper and lower straight line is drawn on the right side, and an arrow is drawn leftward from the end of the straight line (step 1911). Then, a constant is added to the correction value (step 1912), and the remaining operation process information is processed (step 1904).

If the status is error, a “x” mark is further drawn on the right side (step 1913). Since a fixed value is added to the correction value in step 1912, the drawn arrows do not overlap even when there are a plurality of pieces of operation process information.
If there is a jump line 1007 in the acquired data (step 1913), a straight line is drawn on the right side in the vertical direction, and the line from the end to the right side of the jump destination line is connected with a curve (step 1914). Then, the data of the operation process information after the jump preceding is processed (steps 1915 and 1907).

If the acquired data includes the partial flow 1006 (step 1916), iterative processing is drawn (step 1917), and the next data of the operation process information is processed (step 1907). Drawing of the iterative process will be described later.
If the data state 1005 is none (step 1918), upper and lower straight lines are drawn on the left side (step 1919), and the remaining data is processed (step 1907).
If the data state is execute (step 1920), upper and lower straight lines are drawn on the right side (step 1921), and the remaining data is processed (step 1907).

FIG. 20 is a flowchart showing details of processing for rendering the iterative processing in step 1917 in FIG.
First, the operation process information drawing unit 119 checks the number of partial flows 1006 held by the target data (step 2001).
If the number of flows is two or more, an arrow extending from the bottom to the right side of the iteration section is drawn to express that the iteration has been executed (step 2002).
Next, a horizontal position correction value called an iterative correction value is initialized to 0 (step 2003). This is increased each time the internal flow is drawn, and a line is drawn at a position obtained by further adding the repeated correction value to the correction value in the repeated section.
This prevents lines drawn by repetition from overlapping.

Next, the operation process information drawing unit obtains a series of data designated by the partial flow 1006 (step 2004), and sequentially processes individual data in the partial flow (steps 2005 and 2006).
Since this process is the same as the main flow process except that the iterative correction value is added to the correction value, a description thereof will be omitted.
When one partial flow is processed, an arrowhead at the end is drawn (step 2007), the iterative correction value is increased by a constant (step 2008), and the remaining partial flow 1006 is processed (step 2004).
When the processing of all the partial flows is completed, the start points of the drawn arrows and the end points are connected by a horizontal straight line, and the process ends (step 2009).

21 to 24 show specific examples of processing for drawing the operation process information in step 307 in FIG. 3 on the screen displayed by the source code editing unit 109.
In these examples, the contents of the target operation process information are shown in the left area of the figure, and the display contents of the source code editing unit are shown in the right area of the figure.
FIG. 21 shows specific examples of processing for drawing an arrow from left to right at the method declaration position in step 1905 in FIG. 19, processing for drawing a straight line on the left side of step 1919, and processing for drawing a straight line in step 1930 on the right side. .
First, the operation process information drawing unit 119 acquires a class name 1001 and a method name 1002 from the acquired operation process information, acquires a method declaration line from the source code editing unit 109, and moves an arrow from left to right to the position. Drawing is performed (step 1905).
In this example, the class name of the operation process information is MyClass, the method name is showDetail (String), and the corresponding method declaration is on the 35th line, so an arrow is drawn at a position 2101.

Next, the operation process information drawing unit 119 acquires and draws data in order from the acquired main flow data.
In this example, the data on the 36th line is first targeted, and since the state is exec, a straight line in the vertical direction is drawn at the right position 2102 according to step 1921. Similarly, since the data in the next 37th line is also in the exec state, a vertical straight line is drawn at the right position 2102.
Next, the data on the 38th line is processed. Since the state is none, a straight line in the vertical direction is drawn at the position 2103 on the left side. Also, since the right side is drawn right before and the position in the horizontal direction is different, the end point of the straight line on the 37th line and the start point of the straight line on the 38th line are connected by a horizontal arrow. Similarly, since the states from the 39th line to the 45th line are none, a straight line is drawn at the left position 2103, and the 47th line is drawn on the right side. Since the state in line 48 is “return”, an upper and lower straight line is drawn on the right side, an arrow is drawn from the right to the left as shown at 2104 from the end, and the processing of the operation process information is finished.
The developer can intuitively recognize that the 36th, 37th, and 47th lines are executed and the process is interrupted at the 48th line by the series of drawn arrows.

FIG. 22 is a diagram showing a specific example of the process of drawing the iterative process of step 1917 in FIG.
The operation process information drawing unit 119 obtains new operation process information in which the class name 1001 and the method name 1002 match, and draws an arrow. When a plurality of arrows are drawn, correction values are added in step 1912, so that the arrows are displayed so as not to overlap as shown at 2201. Further, since the partial flow is included in the process on the 41st line, the flow for rendering the iterative process shown in FIG. 20 is executed.
First, since the 41st line holds two partial flows, an arrow 2202 from bottom to top is drawn on the right side of the repetitive section according to steps 2001 and 2002.
Next, in step 2003, the iterative correction value is initialized with a constant. The distance indicated by 2203 in the figure is the magnitude of this constant.

Next, partial flows are acquired and processed one by one. Specifically, first, since ID2 is stored in the partial flow, the data in the 42nd and 43rd lines where the flow ID is “2” is processed, and the state is “exec”, so the repeated correction value 2203 is added. Draw a horizontal straight line to the position. Since there is no data after the 43rd line, an arrowhead is drawn at the end of the straight line drawn according to step 2007.
Next, the iterative correction value is increased in accordance with step 2008 so that the partial flow drawing results do not overlap. The increasing value is the distance 2204 in the figure.
The partial flow with the flow ID 3 is processed in the same manner, and finally rendered as 2205, and the developer intuitively understands that the 42nd and 43rd lines are executed twice by repeated processing. Can be recognized.

FIG. 23 is a diagram illustrating a specific example in the case where the state 1005 is “error” in step 1909 in FIG. 19.
In the operation process information of this example, since the state of the 40th line is error, according to step 1913, an “x” mark is drawn at the right position, and further according to step 1911, a vertical straight line and the left direction from its end. Draw an arrow that extends to The drawn result is 2301.
From the drawn arrow, the developer can intuitively recognize that a failure has occurred in the 40th line and the method processing has been interrupted.

  Also, assuming that there are only three operation process information for the showDetail method as described in FIGS. 21 to 23, the developer executes the method three times in total from the three arrows drawn, and one of them causes a failure. It is possible to recognize that the method processing has been interrupted and the iterative processing has been executed twice.

FIG. 24 is a diagram showing a specific example of step 1913 in FIG. 19 when there is a jump line 1007.
Since the 82nd line of the operation process information to be processed has a value in the jump line, the operation process information drawing unit draws a straight line on the right side according to step 1914, and the right side of the 84th line which is the jump line from the end. Connect up to a curve. The drawn result is 2401.
By looking at the rendered result, the developer can intuitively recognize that an exception has occurred in the 82nd line and that the 84th line has been executed.

In the above embodiment, the case where the program developer confirms the execution process of the target source code has been described. However, the case where a person other than the developer in charge confirms the execution process of the existing source code is also described. It goes without saying that it can be used as well.
If an execution class obtained by compiling the target source code with a compiler and an abstract syntax tree that has been parsed already exist, compilation and parsing processing can be omitted.

It is a system configuration figure showing an embodiment of the invention. It is a figure which shows the example of the execution screen of a program development environment. It is a flowchart which shows the whole flow of the development process in the program development system of embodiment. It is a figure which shows an example of the abstract syntax tree produced | generated by the syntax analysis part. It is a flowchart which shows the detail of the process which embeds the output process command of execution information. It is a figure which shows the example of the execution information output. It is a figure which shows the example of the result classified by the execution information classification | category part. It is a figure which shows an example of the simplified abstract syntax tree. It is a figure which shows the data structure of the simplified abstract syntax tree. It is a figure which shows the data structure of operation | movement process information. It is a flowchart which shows the detail of the process which produces | generates operation | movement process information from a parse tree and execution information. It is a flowchart flow which shows the detailed detail which stores the comparison result of a context and an abstract syntax tree. It is a flowchart which shows the detailed detail which produces | generates the area | region of a partial flow to operation | movement process information. It is a figure which shows the specific example when exec is stored in the state, and when error is stored It is a figure which shows the specific example in the case where multiple next lines exist and when it completes normally. It is a figure which shows the specific example in case a partial flow is produced | generated. It is a figure which shows the specific example in case a some data is stacked on a stack. It is a figure which shows the specific example in case a jump line is stored. It is a flowchart which shows the detail of the process which draws operation process information. It is a flowchart which shows the detail of the process which performs drawing of an iterative process. It is a figure which shows the specific example of the process which draws an arrow from the left to the right, and the process which draws a straight line. It is a figure which shows the specific example of the process which draws an iterative process. It is a figure which shows the specific example drawn when a state is error. It is a figure which shows the specific example drawn when a jump line exists. It is a figure which shows the execution screen of the conventional program development environment.

Explanation of symbols

DESCRIPTION OF SYMBOLS 101 Program development environment 102 Computer 103 Program execution environment 104 Computer 107 Screen display apparatus 108 Source code holding part 109 Source code editing part 110 Compiler 111 Execution class holding part 112 Syntax analysis part 113 Abstract syntax tree holding part 114 Execution information output instruction embedding part 116 execution information classification unit 117 operation process tracking unit 118 operation process information holding unit 119 operation process information drawing unit 120 execution class holding unit 121 program execution unit

Claims (3)

A method of displaying the execution process of the target program on the source code of the program displayed on the display screen,
The execution class obtained by compiling the source code of the program and the abstract syntax tree information that is the result of the syntax analysis are accepted as inputs, and the start, end position, and variable declaration of the method constituting the execution class based on the information of the abstract syntax tree; A first step of embedding an instruction to output the line number position of the corresponding source code as execution information at the beginning of a determination formula, a declaration statement, and a return statement by first means;
A second step of executing the execution class embedded with the execution information by a second means;
The execution information output by the execution class executed by the second means is collected, sorted in order of execution time, and then classified into method units. The execution class is based on the classification result and the abstract syntax tree information. A third step of tracking the execution process of the method, variable declaration, judgment expression, declaration statement, and return statement in step 3 by a third means;
A program execution process display method comprising: a fourth step of displaying the tracked execution process by an arrow by means of a fourth means on the source code of the program displayed on the display screen. A system for displaying the execution process of a target program on the source code of the program displayed on a display screen,
The execution class obtained by compiling the source code of the program and the abstract syntax tree information that is the result of the syntax analysis are accepted as inputs, and the start, end position, and variable declaration of the method constituting the execution class based on the information of the abstract syntax tree; A first means for embedding an instruction to output the line number position of the corresponding source code as execution information at the beginning of a determination expression, a declaration statement, and a return statement;
A second means for executing the execution class in which the execution information is embedded;
The execution information output by the execution class executed by the second means is collected, sorted in order of execution time, and then classified into method units. The execution class is based on the classification result and the abstract syntax tree information. A third means for tracking the execution process of the method, variable declaration, judgment expression, declaration statement, and return statement in
A program execution process display system, comprising: a fourth means for displaying the tracked execution process by an arrow on the source code of the program displayed on the display screen. A computer program for displaying the execution process of the target program on the source code of the program displayed on the display screen,
Computer
The execution class obtained by compiling the source code of the target program and the abstract syntax tree information that is the result of the syntax analysis are accepted as input, and the start, end position, and variable declaration of the method constituting the execution class based on the abstract syntax tree information First means for embedding an instruction to output the line number position of the corresponding source code as execution information at the beginning of the determination expression, declaration statement, and return statement;
A second means for executing the execution class in which the execution information is embedded;
The execution information output by the execution class executed by the second means is collected, sorted in order of execution time, and then classified into method units. The execution class is based on the classification result and the abstract syntax tree information. A third means for tracking the execution process of the method, variable declaration, judgment expression, declaration statement, and return statement in
A computer program, comprising: a step of causing a tracked execution process to function as a fourth means for displaying by an arrow on a source code of the program displayed on a display screen.

Images