JPH05341973A - Program analysis device - Google Patents

Abstract

(57) [Abstract] [Purpose] To provide a program analysis device for generating a technical document of a source program for efficient program maintenance. [Structure] The program analysis unit performs grammatical analysis of the non-comment portion of the source program and obtains a program analysis tree in a bottom-up method. The comment portion annotating the command statement is extracted by the comment extraction unit and classified by the comment classification unit,
Store the appropriate node in the program parse tree. After the conversion into the program analysis tree, the program analysis tree traversal unit in the diagram generation unit traverses the program analysis tree and detects each statement node. Next, the comment in the node detected by the comment statement node detection unit is determined. Then, the comment part is converted by the definition diagram conversion part, and the original command statement node is converted by the general diagram conversion part. As a result, the program parse tree is converted into a diagrammatic program representation diagram structure tree in units of statement nodes, and a program representation diagram according to the abstraction depth is drawn.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program analysis device for automatically generating a technical document related to a source program.

[0002]

2. Description of the Related Art In the process of developing a software system, the most man-hours and costs are to change and improve the program as the hardware is changed, the hardware is advanced, the processing object is expanded, and the algorithm is improved. "Maintenance"). At that time, the work is difficult unless the programmer completely understands the contents of the program. Therefore, in order to help understanding of the program to be maintained (hereinafter referred to as "source program"), a program analysis device that automatically generates a diagram expressing the technical content and logical content of the source program is proposed. ing. by the way,
A PAD diagram (Problem An
There is a method of expressing it in a flow chart or the like. Generally, a flow chart shows only the flow of processing a program, whereas a PAD diagram can show both the flow of processing and the structure of a program. For this reason, the PAD diagram is often used, but the conventional PAD
An example of the diagram generation device is a “C-PAD tool” commercialized by Matsushita Electric Co., Ltd., which is the applicant of the present application. This is a kind of software tool creation device, and automatically creates a PAD diagram corresponding to an input source program. As a representative of the program analysis device according to the related art, the "Software Development Support System C-PAD Tool" manual (1988) describes "C-PA".
22. As an example of the program written in the C language shown in FIG. 22, after being processed by the C-PAD tool, a PAD diagram as shown in FIG. Is generated by being included as an independent statement in the PAD diagram.

Next, in disclosing the present invention in the specification, since the C-language is used as a programming language and the PAD diagram is used as its representation diagram, some mention is made of these. First of all, it is the C language, but this C language is, for example, "Introduction to Personal Computer C Language" published by Hideyo Waki, Kodansha, CQ
Published by Publisher "Transistor Technology SPECIAL No.
14 ”, CQ publisher's“ Interface March 1990 issue ”“ April issue ”, etc., which are well-known programming languages described in technical-related paperback books and monthly magazines. Related techniques such as a C compiler for converting into a machine language program are also well known.
For this reason, in the present specification, the instruction content of the program shown in the C language will not be described in detail and in detail, and the explanation of important terms will be kept to the minimum necessary.

Next, a PAD diagram will be briefly introduced.
The PAD diagram is classified into four types of basic type, selection type, loop type and imperative sentence definition type according to each type of imperative sentence in the program. Hereinafter, these will be described in order with reference to FIG. FIG. 2A shows a basic type diagram: a simple statement, for example, an operation statement.

FIG. 2B shows a selection-type diagram: conditional branch statement. More specifically, there are two-branch selection and multi-branch selection. Two-branch selection: state 1 if Q is true
Is executed, and if false, statement 2 is executed. FIG. 2C shows multiple branch selection: from top to bottom, the suitability of the condition and value combination is checked in order, and only one true combination is selected and the processing is executed.

FIG. 2 (d) shows a loop type diagram: while Q is true,
Repeat the statement. FIG. 2E shows an instruction statement definition type diagram: a group of instruction statements necessary for completing a task represented by one comment. The PAD diagram consists of the above four types of diagrams. And
By connecting these four types of diagrams from top to bottom, it is possible to indicate the order of execution of imperative sentences. Also, by connecting from left to right, it is possible to show the operation method of a program by a nested (nest, fill in during procedure) execution structure.

As described above, the PAD diagram can show both the flow and the structure of the program, and unlike the conventional flow chart, the complicated flow line is unnecessary. Therefore, the PAD diagram can express the basic control structure of the program more clearly than the flowchart, and is therefore excellent in displaying the program.

[0008]

However, the PA automatically generated by the above-mentioned conventional program analysis device.
Diagram D is mainly for converting the imperative sentence in the source program, it is the part between the comments (/ * ... * /, which is read only by humans and ignored by the compiler). It is inconvenient to understand the contents. However, in practice, when a programmer tracks and interprets a source program, he also refers to the comments along with the source code. That is, simple comments help programmers understand the design principles or basic ideas of programs.
Therefore, if the comments in the source program can also be shown in the PAD diagram, the PAD diagram becomes easier to understand. This will be described in detail later, but a source program shown in C language as an example of the processing object of the present invention in FIG. 22 is compared with the PAD diagram according to the conventional technique generated by the “C-PAD tool” in FIG. 29. Then you will see the importance of comments. In the “P-CAD tool” of FIG. 29,
Only when one line is a comment is the target of the P-CAD tree, and other types of comments are not emphasized.
Also, the comments do not indicate the statement to be annotated. For this reason, it is still unsatisfactory in terms of reflecting the comments and forming a P-CAD tree. From the above, it can be seen that the conventional program analysis device has the following problems.

(1) Since the relationship between the comment and the annotated sentence is not clearly shown, the comment is less useful in interpreting the imperative sentence. (2) The PAD diagram does not completely abstract the program. The present invention has been made in view of the above points, and an object of the present invention is to provide a program analysis device that clearly shows the relationship between a comment and its annotated statement, and abstracts a program into a schematic program representation diagram. ..

[0010]

In order to achieve the above-mentioned object, in the invention of claim 1, a comment extraction unit for extracting a comment portion from a inputted source program by a comment symbol, and an attachment of a comment and a statement Depending on the position in the source program of the comment extracted by the comment extraction unit in order to determine an appropriate position in the program analysis tree according to the relationship, it is a comment of an expression statement or a comment of a compound statement or a comment of a statement group. The comment classification unit that classifies whether there is a comment, the program language grammar storage unit that stores the grammar of the program language, and the grammar analysis performed on the input source program by the grammar stored in the program language grammar storage unit. A program solution that obtains a program parse tree for a function represented by each statement in the up method Section, the program analysis tree obtained by the program analyzing section, and the classification result obtained by the comment classifying section, the grammar code representing the property of the node is stored in the data structure of each node. A grammar code storage field, a termination node source code storage field that stores a termination node and source code, and a command statement comment storage field that stores a comment of an expression command statement and a comment of a compound command statement belonging to a node of a compound command statement, A program parse tree storage unit having a comment pointer column of a statement group for directionally storing a comment corresponding to a statement group, and a child node pointer section for storing each child node pointer connecting each child node , For each statement node in the program analysis tree stored in the program analysis tree storage unit, a graphical program corresponding to the statement node As a program analysis device, comprising: a diagram generation unit that converts a comment in a source program into an imperative sentence definition diagrammatic representation form to generate a diagrammatic representation diagram of one function. There is.

In order to store the program analysis tree obtained by analyzing the source program,
The data structure of each node belongs to a grammar code storage field that stores a grammar code that represents the property of the node, a terminal node source code storage field that stores a terminal node and source code, a comment of an expression command statement, and a node of a compound command statement. It stores a comment storage field for command statements that stores comments for compound command statements, a comment pointer field for command statements that stores a corresponding comment for a command statement group, and a pointer for each child node that links each child node. In the program analysis tree storage unit having each child node pointer column, the program analysis tree transition unit that traverses each node in the program analysis tree storage unit in a recursive method to detect a statement node, and the program analysis tree transition unit Judge whether the detected statement node has a comment and define the statement node that has a comment In order to store the comment command statement node detection unit that passes the command statement node that does not have a comment to the general diagram conversion unit and the schematic program expression format, the data structure of the node at each node is A graphical program expression format field for storing the type, a graphical program expression format description field for storing the statement to be operated, a child node number storage field for storing the number of child nodes, and each child node for each branch Each child node description column for processing and storing the branching condition of the above, each child node pointer column for storing the start of branching of each child node pointer, and the execution order is directed to the next node Of a diagrammatic program representation diagram structure tree having a node pointer column of the above, and a comment part of a command statement node having a comment detected by the comment command statement node detection unit. The program is converted into a program expression format node and stored in the graphic program expression diagram structure tree storage unit, and the definition command conversion unit that passes the original command statement node to the general diagram conversion unit and the comment command statement node detection unit are detected. A command statement node having no comment or a command statement node passed from the definition diagram conversion unit is converted into a general graphic program expression format node by a tree structure correspondence and stored in the graphic program expression diagram structure tree storage unit. The general schematic conversion unit and the schematic program representation diagram structure tree read from the schematic program representation diagram structure storage unit determine whether or not to hide the comment statement according to the program abstraction depth set by the user. The program analysis device is provided with an abstract diagram drawing unit that generates a diagrammatic program representation diagram with a different degree of abstraction.

According to the third aspect of the invention, the program analysis apparatus according to the first aspect is characterized in that the graphical program representation diagram is a PAD diagram. In the invention of claim 4, the diagrammatic program representation diagram is a PAD diagram.

[0013]

With the above structure, in the program analysis device according to the invention of claim 1, after the source program is input to this device, the program analysis part performs grammatical analysis according to the grammatical rules stored in the program language grammar storage part. After that, the program parse tree of each program function is obtained by the bottom-up method for the part that is not a comment. After the comment is extracted by the comment extractor,
After being classified by the comment classifying unit, it is stored in an appropriate node in the program analysis tree. The primitive program stored after being converted into an appropriate node in the program analysis tree storage unit is converted into a diagrammatic program representation format corresponding to each statement node in the diagram generation unit, and a comment is a statement definition diagrammatic program representation format. Is converted into a schematic program representation diagram of one function.

According to the second aspect of the present invention, for the program analysis tree stored in the program analysis tree storage unit, the program analysis tree crossover unit in the diagram generation unit walks across the program analysis tree to detect each statement node. To do. The comment command statement node detection unit in the diagram generation unit determines whether or not the detected command statement node has a comment. The comment portion of the node of the imperative sentence having the comment is converted into a definitive diagram representation node by the definition diagram conversion unit in the diagram generation unit, and the original statement sentence node is processed by the general diagram conversion unit. Further, the child parse tree of the imperative sentence node having no comment is converted by the general graphic conversion unit into the corresponding graphical program expression format node. As a result, the program parse tree is converted into a diagrammatic program representation diagram structure tree by the tree structure correspondence in units of statement nodes.
The diagrammatic program representation diagram structure tree draws a corresponding abstract diagrammatic program representation diagram according to the abstraction depth set by the abstract diagram drawing unit.

In the third aspect of the invention, the PAD diagram is drawn as the graphical program representation in the first aspect of the invention. In the invention of claim 4, a PAD diagram is drawn as a graphical program expression in the invention of claim 2.

[0016]

EXAMPLES The present invention will be described below based on examples.
FIG. 1 is a block diagram of an embodiment of a program analysis device according to the present invention. The source program 10 is input by the input unit 30 in units of statements. As described in the [Prior Art] section, the statement without comments is subjected to grammatical analysis by the program analysis unit 60 after understanding the meaning of the semantic content according to the grammatical rules in the program language grammar storage unit 20. A parse tree node corresponding to the result application grammar rule is created and stored by the program parse tree storage unit 70. Each node in the program analysis tree storage unit 70 has a data structure 70 shown in FIG. In the process of creating a parse tree, nodes are divided into end nodes and intermediate nodes. Here, the terminal node stores the basic symbol of the source program. The basic symbol is Term
It is also called internal, for example, variables,
Constants, operators, etc. The intermediate node is an intermediate grammar symbol (Non) reduced by the grammar rule.
Record the terminal). Therefore, in the structure of each node in the program analysis tree, the term
There is a data field for recording the al / Nonterminal code. The terminal character string column records the character string of the source program. The four child node pointer fields are used to store the nodes corresponding to the child elements in the intermediate grammar element in an oriented manner. The parse tree is made into a multidimensional tree structure by such a knotting method. The comment in the source program is extracted by the comment extraction unit 40. The extracted comments are classified by the comment classifying unit 50. Then, it is placed in an appropriate statement node in the parse tree in the grammar analysis process. The entire analysis tree of the source program analyzed by the above work is stored in the program analysis tree storage unit 70. The PAD diagram generation unit 80 converts the program analysis tree into a PAD diagram. In the PAD diagram generator 80,
First, the program analysis tree stored by the program analysis tree walking unit 81 is walked in a recursive manner (tree w).
alk). As a result, the statement node in the program analysis tree storage unit 70 is detected. The comment statement node detector 82 determines whether or not the node has a comment. A statement node having no comment is converted by the general diagram conversion unit 84 according to the tree correspondence between the program analysis tree and the PAD diagram structure tree. The comment part of the statement node that has a comment is the definition diagram conversion part 83.
Is converted into a statement definition PAD diagram. After that, the general graphic conversion unit 84 processes the part of the imperative sentence. The converted PAD diagram structure tree is stored in the PAD diagram structure tree storage unit 90. Before the PAD diagram is drawn, the program parse tree is shown in Figure 1.
It is necessary to convert the data into a PAD diagram structure tree having the data structure shown in 90 of FIG. Each node in the PAD diagram structure tree corresponds to one PAD diagram. Of which P
The structure of each node in the AD diagram structure tree storage unit 90 is PA
The D-scheme column records the type of diagram, and the PAD-scheme description column stores the statements to execute for the basic PAD diagram. In other types of PAD diagrams, the number of child nodes storage column records the number of branches in one diagram, the branch condition is recorded in the child node description column for each branch, and the child node pointer column points to the start node of the branch. And the next node pointer points to the next node of the sequential execution. In the abstracted PAD diagram drawing unit 85, the PAD diagram structure tree storage unit 90 draws the PAD diagram 110 corresponding to the PAD diagram structure tree. Then, the output unit 100 outputs the data.

FIG. 4 is a flow chart of this embodiment.
Hereinafter, description will be given based on this. (S1) The source program according to the present invention is input to the program analyzer, and then it is determined whether or not the file ends. (S2) If it is not finished, the command statement of the program is read. (S3)
It is determined whether the statement is a comment.

(S8) Grammar rule if not a comment
Grammar analysis is performed by. In this embodiment, C language is adopted.
And the grammatical rules are shown below. translation unit: external declaration ｜ external declaration translation unit external declaration: function definition ｜ declaration function definition: declaration specifiers declarator declaration list compound statement ｜ declarator declaration list compound  statement ｜ declaration specifiers declarator compound statement ｜ declarator compound statement declaration: declaration specifiers init declarator list ';' ｜ declaration specifiers ';' declaration list ： declaration ｜ declaration list declaration declaration specifiers: storage class specifier specifier qualifie list ｜ storage class specifier ｜ specifier qualifie list storage class specifier: AUTO ｜ REGISTER ｜ STATIC ｜ EXTERN ｜ TYPEDEF type  specifier ： VOID ｜ CHAR ｜ SHORT ｜ INT ｜ LONG ｜ FLOAT ｜ DOBLE ｜ UNSIGNED ｜ struct or union specifier ｜ enum specifier ｜ typedef name type  qualifier ： CONST ｜ VOLATILE struct  or union  specifier: struct or union identifier '{' struct declaration list '}' ｜ struct or union '{' struct  declaration list '}' ｜ struct or union identifier struct  or union: STRUCT ｜ UNION struct  declaration list: struct declaration ｜ struct declaration list struct  declaration init  declarator list: init declarator ｜ init declarator list ',' init  declarator init  declarator: declarator ｜ declarator '=' initializer struct  declaration: specifier qualifier list struct  declarator list ';' specifier qualifier list: type qualifier ｜ type qualifier specifier  qualifier  list ｜ type specifier ｜ type specifier specifier qualifier  list struct  declarator list: struct declarator ｜ struct declarator list ',' struct  declarator struct  declarator: declarator ｜ declarator ',' constant expression ｜ ',' constant expression enum  specifier: ENUM identifier '{' enumerator list '}' ｜ ENUM identifier '{' enumerator list ',' '}' ｜ ENUM '{' enumerator list '}' ｜ ENUM '{' enumerator list ',' '}' ｜ ENUM identifier emunerator  list ： enumerator ｜ enumerator list ',' enumerator enumerator: identifier ｜ identifier '=' constant  expression declarator: pointer direct declarator ｜ direct declarator direct  declarator: identifier ｜ '(' declarator ')' ｜ direct declarator '' constant  expression '' ｜ direct declarator '' '' ｜ direct declarator '(' parameter type  list ')' ｜ direct declarator '(' identifier list ')' ｜ direct declarator '(' ')' pointer: '*' ｜ '*' type qualifier list ｜ '*' type qualifier list pointer ｜ '*' pointer type  qualifier  list: type qualifier ｜ type qualifier list type qualifier parameter type  list: parameter list ｜ parameter list ',' '.' '.' '.' parameter list: parameter declaration ｜ parameter list ',' parameter declaration parameter declaration: declaration specifiers declarator ｜ declaration specifiers abstract  declarator ｜ declaration specifiers identifier  list ： identifier ｜ identifier list ',' identifier initializer: assignment expression ｜ '{' initializer list '}' ｜ '{' initializer list ',' '}' initializer list ： initializer ｜ initializer list ',' initializer type  name: specifier qualifier list abstract  declarator ｜ specifier qualifier list; abstract  declarator ： pointer ｜ pointer direct abstract declarator ｜ direct abstract declarator direct  abstract declarator: '(' abstract declarator ')' ｜ direct abstract declarator '' constant  expression '' | '' constant expression '' ｜ direct abstract declarator '' '' ｜ '' '' '' ｜ direct abstract declarator '(' parameter type list ')' ｜ '(' parameter type list ')' ｜ direct abstract declarator '(' ')' ｜ '(' ')' typedef name: identifier statement: labeled statement ｜ case statement ｜ expression statement ｜ compound statement ｜ if statement ｜ switch statement ｜ while statement ｜ do while statement ｜ for statement ｜ goto statement ｜ continue statement ｜ return statement ｜ break statement ｜ COMMENT STATEMENT labeled statement: identifier ':' statement case  statement: CASE constant expression ':' statement ｜ DEFAULT ':' statement expression  statement: expression ';' ｜ ';' compound  statement: '{' declaration list statement  list '}' ｜ '{' statement list '}' ｜ '{' declaration list '}' ｜ '{' '}' statement list ： statement ｜ statement statement list if  statement: IF '(' expression ')' statement ELSE statement ｜ IF '(' expression ')' statement switch  statement: SWITCH '(' expression ')' statement while statement: WHILE '(' expression ')' statement do  while  statement: DO statement WHILE '(' expression ')' ';' for statement: FOR '(' expression ';' expression ';' expression ')' statement ｜ FOR '(' ';' expression ';' expression ')' statement ｜ FOR '(' expression ';' ';' expression ' ) 'statement ｜ FOR' ('expression'; 'expression'; '') 'statement ｜ FOR' ('expression'; ''; '') 'statement ｜ FOR' (''; 'expression'; '') 'statement ｜ FOR' (''; ''; 'expression') 'statement ｜ FOR' (''; ''; '') 'statement goto  statement: GOTO identifier ';' continue  statement: CONTINUE ';' break statement: BREAK ';' return  statement ： RETURN ';' ｜ RETURN expression ';' expression ： assignment expression ｜ expression ',' assignment expression assignment expression: conditional expression ｜ unary expression assignment operator assignment expression assignment operator: '=' ｜ MULBY ｜ DIVBY ｜ MODBY ｜ ADDTO ｜ MINBY ｜ SHRBY ｜ SHLBY ｜ ANDWT ｜ XORWT ｜ ORWT conditional expression: logical OR expression ｜ logical OR expression '?' expression ':' conditional expression constant  expression: conditional expression logical OR  expression: logical AND expression ｜ logical OR expression OR logical AND expression logical AND expression: inclusive OR expression ｜ logical AND expression AND inclusive  OR expression inclusive OR expression: exclusive OR expression '｜ inclusive OR expression '|' exclusive  OR expression exclusive OR expression: AND expression ｜ exclusive OR expression'∧ 'AND  expression (Note, ∧ is an upper subscript, and is shown for convenience of printing.) AND expression: equality expression ｜ AND expression '&' equality expression equality  expression: relational expression ｜ equality expression EQU relational  expression ｜ equality expression NEQU relational  expression relational  expression: shift expression ｜ relational expression '<' shift  expression ｜ relational expression '>' shift  expression ｜ relational expression LE shift  expression ｜ relational expression GE shift  expression shift expression: additive expression ｜ shift expression SHL additive  expression ｜ shift expression SHR additive  expression additive  expression: multiplicative expression ｜ additive expression '+' multiplicative  expression ｜ additive expression '-' multiplicative  expression multiplicative expression: cast expression ｜ multiplicative expression '*' cast  expression ｜ multiplicative expression '/' cast  expression ｜ multiplicative expression '%' cast  expression cast  expression: unary expression ｜ '(' type name ')' cast expression buildnode (cast expression, 1,1,0,0);; unary expression: postfix expression ｜ INC unary expression ｜ DEC unary expression ｜ unary operator cast expression ｜ SIZEOF unary expression ｜ SIZEOF '(' type name ')' unary operator: '&' ｜ '*' ｜ '+' ｜ '-' ｜ '~' ｜ '!' postfix expression: primary expression ｜ postfix expression '' expression '' ｜ postfix expression '(' argument expression list ')' ｜ postfix expression '(' ')' ｜ postfix expression '.' identifier ｜ postfix expression ARROW identifier ｜ postfix expression INC ｜ postfix expression DEC primary expression: identifier ｜ constant ｜ '(' expression ')' argument  expression list: assignment expression ｜ argument expression list ',' assignment  expression constant ： INT CONST ｜ CHAR CONST ｜ STR CONST ｜ FLT CONST identifier: ID (S9) The program analysis unit 60 uses the bottom-up method (B
opt-up, work from below the tree structure. )
Corresponds to the program statement previously read by
Create a node of the program analysis tree.

If it is determined in the step (S3) that the command statement read in the steps (S4) and (S2) is a comment, the comment classification unit 50 determines which one of the following types. It is classified according to the above. The classification rules in that case are shown below. 1. Expression statement comment: A comment that immediately follows the statement (that is, it is not separated from the statement by non-whitespace characters or line breaks).
For example, as shown in FIG. 3, / * Assemble the c
completefile name * /, / * Prep
process a source program f
ile * /, / * Check the syntax
of source program file * /
Is. It interprets the previous expression statement.

2. Compound statement comment: A comment that immediately follows the large bracket to the left of the compound statement (ie,
It is not separated from the compound statement by non-whitespace characters or line breaks). For example, / * Parsi shown in (Fig. 3)
ng a source program file *
/ Interpret compound statements (statements between left and right big brackets).

3. Comment of statement group: The start of one line is a comment. (That is, there is no non-whitespace character before it) Interpret the statement group (up to a blank line or other comment group) that follows it. For example, in the second line of (Fig. 3) / * Prepare assured prog
ram file for parsing * /. The comment interprets a command statement group (including statements on the third and fourth lines) separated by a blank line (fifth line).

4. Comments are not processed unless the above rules are met. When it is determined that the statement is not a comment in steps (S8) and (S3), the program analysis unit 60 performs grammar analysis in this step. (S9) If a certain grammatical rule of the program language grammar is satisfied, and if the grammatical rule is quoted, a node of the program parse tree corresponding to the grammatical rule is created. FIG. 5 shows a child tree in the program parse tree corresponding to the processed if statement. The if statement consists of five parts. It is keyword if, left parenthesis '(', conditional expression (express
Ion), right parenthesis ')', compound statement. Of these, if, left parenthesis, and right parenthesis are so-called fixed parts that are determined for each if statement, so they do not need to be stored in a special node. On the other hand, since the conditional expression and the compound statement have child parts, they are stored in each node. Therefore, each solid line emitted from each node in FIG. 5 corresponds to a child node pointer, and the node connected by the solid line is a child node of the node. Since the part connected by the broken line and the broken line is a fixed part, there are no child nodes. The character string in parentheses at the end node is the value recorded in the end node source code recording field at the node.

After the comments are classified in steps (S5) and (S4), each comment is converted and stored in the program analysis tree storage unit 70 in accordance with the program analysis tree. The comment column of the command statement and the comment pointer column of the command statement group in the data structure 70 shown in FIG. 1 are added and expanded for comment processing. And it works only when processing a node of a statement.

(S6) For the command statement node, the comment pointer column of the command statement group stores the node corresponding to the comment of the command statement group to which it belongs. That is, for each statement node belonging to the same statement group, the comment pointer column of the statement group stores the comment node of the same statement group while pointing. Similarly, the comment storage column of the command statement stores the comment of the formula command statement that belongs to the node of the formula command statement and the comment of the compound command statement that belongs to the node of the compound command statement.

When the comment of the expression command statement or the compound command statement is judged in the steps (S7), (S5) and (S6), an appropriate command statement node in the program analysis tree is selected. Then, the comment is placed at the selected statement node. If it is determined in the steps (S8) and (S5) that the comment is a statement group, grammar analysis is performed.

Next, how the above three types of comments are stored in the program analysis tree will be described. In addition,
Expression statement comments are primarily used to interpret expression statements. (S6) After the comment of the expression command statement is read, it is determined whether the expression command statement is simplified before the comment.

(S7) If so, the comment is stored in the comment field of the command statement in the node corresponding to the expression command statement. If not, the comment is not processed. This will be specifically described with reference to FIG. In the figure, / * multiplya by b * / is determined to be a comment of the expression command statement according to the classification rule. Then, since the preceding product = a * b also has an expression statement, this comment is stored in the corresponding expression statement node. If the comment of the compound statement is read, in steps (S6) and (S7),
The comment is stored in the comment column of the command statement in the node after the simplified command statement to which it belongs. For example, / * compute product * / in the figure is a comment of a compound command statement according to a rule, and is stored in the comment field of the command statement in the node after the compound command statement to which it belongs.

If the comment is a statement group, complicated processing is required. This is because, as described above, the present invention regards comments in a group of imperative sentences as special sentences. That is, it is a comment command statement. This will be described below. After being extracted in steps (S8) and (S5),
Perform grammar analysis. In this step, since it is analyzed as an imperative sentence, the following grammar rule is added to the grammar of the programming language. statement: COMMENT_STAT
The comment of the command group is read in the step (S2) and then simplified in this step by the grammatical rules described above.

At (S9), a comment statement node is created in the program analysis tree. FIG. 6 illustrates these. In this figure, the first line / * factual comp
notation * / is simplified into a comment statement, and a comment statement node is created. The command statement group is defined as a group of command statements in which consecutive command statements belong to the same level. A command line group and a command line group belonging to the same level are separated by a blank line or a comment command line. The command statement on the second, third, and fourth lines of this figure is the / * factual compute command on the first line.
It is an instruction statement group in which ion * / is a comment of the instruction statement group. The sixth line is another statement group. For each statement in the same statement group, when the node of the statement is created in step (S9) after being simplified by the step (S8) of FIG. 4, the comment pointer column of the statement group of the node Stores the comment node of the statement group to which it belongs in an oriented manner. Therefore, the comment pointer column of the node statement group corresponding to the statement on the second, third, and fourth lines of FIG. 6 points to the comment node of the same statement group (that is, / * factual computation).
Comment node of the statement group formed from * /). The three nodes will be connected in the parse tree.

The program analysis tree of the source program is obtained through the steps (S8) and (S9) of FIG. Then, the program analysis tree is converted into a PAD diagram structure tree. Next, in FIG. 7 to FIG. 10 (in FIG. 7 to FIG. 10, it is proper to adopt the drawing number of 1 originally, but it is divided into four for convenience of electronic filing). The correspondence relation of is shown by the data structure of each node corresponding to each PAD scheme. The sequential execution statement in the source program is P
This is represented by a PAD diagram which is connected from the upper side to the lower side in the AD diagram. PAD diagrams corresponding to a statement having a nested structure, for example, IF (conditional judgment), SWITCH (1 of multiple branch), and loop generate a hierarchical relationship. And P
The AD diagram just expands to the left and down to form a tree structure. The statement definition PAD diagram is displayed by including the comment in the source program in the PAD diagram according to the definition of the statement. As a result, the description to the programmer is better. 7 to 10 also show command statement definition PAD diagrams corresponding to three types of comments. The rightmost part of each figure shows the data structure of the stored PAD diagram of each diagram.

The tree structure correspondence conversion process from the program analysis tree to the PAD diagram structure tree starts from step (S10) in FIG. 4, and the program analysis tree walking unit 81 walks from the root node of the program analysis tree in a recursive manner. (S11) The command analysis node is detected by the program analysis tree walking unit 81, and the comment command statement node detection unit 82 determines whether or not the node has a comment.

(S13) If it is determined that the instruction statement node does not exist, it is determined what the instruction statement node is. (S14), (S15) General PAD diagram conversion is performed according to the type of the statement. The conversion corresponding to the type of each statement in the step (S15) will be described below.

In FIG. 11, in the steps (S14) and (S15), an expression command statement and a jump command statement (for example, GOTO, C).
(ONTINUE, BREAK, RETURN, etc.) is converted into a corresponding general PAD scheme. (S14)
When an appropriate node is detected, the source code is reduced by tracing the following child parse tree of the node of the parse tree previously detected by the source code reduction procedure.

(S15) The result is the newly generated PAD
Place it in the PAD diagram description field of the diagram node and finish the conversion. 12 to 14 show conversion methods of three types of loop command statements into corresponding loop PAD diagrams in steps (S14) and (S15). There are three types of loop command statements in C language: WHILE, DO-WHILE, and FOR. FIG. 12 shows a process of converting a WHILE statement into a loop PAD diagram. In the figure, the upper part is the parse tree of the WHILE statement. Among them, child parse trees expression and statement are included.

Reduction is performed on the following child parse tree of the expression node by the source code reduction procedure in step (S14). In step (S15), the result is placed in the child node description field of the newly generated loop PAD diagram node. The child node pointer is sta
The conversion is terminated by pointing to the PAD diagram node generated by the recursive conversion in the steps (S10) to (S15) from the element node.

Similar processing is performed for the other two types of loop command statements. The only difference is the content of the conditions stored in the child node description field. That is, in step (S14), "do" is inserted before the child node description in the corresponding PAD diagram node of the DO-WHILE statement. Similarly, FO
Three expression nodes are newly reduced to the R statement. Then connect them and put them in the child node description field.

With the above, the conversion explanation for the loop command statement of FIGS. 12 to 14 is completed. 15 to 1
7 shows a method of converting a selection command statement into a selection PAD diagram in steps (S14) and (S15). The selective PAD scheme handles multi-conditional branches. IF statement or S
There is a multi-condition branch in the WITCH statement. In FIG.
In the steps (S14) and (S15), the process of converting a simple IF statement into a two-branch selection PAD diagram node will be described. The upper part of FIG. 15 is the parse tree of the IF statement. In the figure, the IF command statement includes one conditional expression and two action statements, so in the selected PAD diagram node generated in step (S15), two child node pointer fields correspond to the two action command statements, respectively. The child PAD diagram node to be stored is oriented and stored.

In step (S14), the conditional expression is reduced by the source code reduction procedure. In the step (S15), the PAD diagram node is placed in the first child node description field. If the second statement is also an IF statement,
Nested IF-statemen
t). And the corresponding selected PAD scheme belongs to multi-branch selection. This is shown in FIG. As shown in the figure, the K level (Level, Level = “height”
The selected PAD diagram generated for the parse tree of the nested IF statement having t-depth ″) has K child nodes. The conditional expression of the statement at each level is (S1 in FIG.
In step 4), it is reduced by the source code reduction procedure, and in step S15, it is placed in the child node description field at the corresponding position. The child node pointer column directs and stores the child node generated by the recursive conversion from the imperative sentence after the conditional expression.

FIG. 17 shows a method of converting a SWITCH statement into a multi-branch selection PAD diagram in steps (S14) and (S15). Depending on the C language, one SWITCH command statement includes one set command statement and one compound command statement. The statement string in the compound statement is labeled_statement, which divides many statement blocks. Each labeled_
con after "case" in the statement
stan_expression is a condition value. When the expression statement corresponds to the condition value of a certain labeled_statement, the statement block to which it belongs is BRE.
Up to the AK (processing interruption) statement command is performed. Therefore, the content of each child node description field in the selected PAD diagram node is the formula command statement of the SWITCH command statement and labeled_s.
Includes the condition value of the term. In the conversion process,
For each statement block, calculation expression, and condition value, the conditional expression for reducing the statement block by the source code reduction procedure in step (S14) of FIG. Then, in the step (S15) of FIG. 4, the conditional expression is placed in the child node description field of the relative order position in the relevant node. As shown in FIG. 17, the child node pointer column indicates the start label of the statement block.
statemen in red_statement
The child node generated by the recursive conversion from the t node is oriented and stored.

In FIG. 4, the detected sentence node is (S
If it is determined in step 11) that it is a comment, in step (S12), the comment part of the statement node is converted into a defined PAD diagram. 18 and 19 (FIG. 19 should originally be (c) of FIG. 18,
It is divided into different figures for the convenience of electronic filing. 4) shows how to convert the three types of comments stored in the parse tree in step (S12) of FIG. 4 into a definition diagram.
FIG. 18A shows a comment conversion method of an expression command statement. When a comment for interpreting the expression statement is stored in the comment field of the statement in the expression statement node, the corresponding statement definition PAD diagram is generated. Then, the comment of the imperative sentence in the expression imperative sentence node is placed in the child node explanation column of the imperative sentence definition PAD diagram. In this way, the PAD diagram node of the original statement is generated. The steps from (S13) to (S15) in FIG. 4 are the corresponding conversion between the general statement and the PAD diagram. The child node pointer of the statement definition node points the expression statement PAD diagram node. FIG. 18B shows, for a compound statement node, if a comment for interpreting the compound statement is stored in the comment column of the statement in the compound statement node, the corresponding statement definition PAD diagram is displayed. It shows how to generate. The comment of the statement in the compound statement node is placed in the child node description column of the statement definition PAD diagram. The statement list in the original compound statement is PAD
A schematic node list is generated. The child node pointer of the statement definition analysis schematic node points the start node of the PAD schematic node list. FIG. 19 shows a method of converting a comment of a statement group. As described above, in the parse tree of the imperative statement list, the imperative statement group comment pointers of imperative statement nodes belonging to the same imperative statement group point to the comment imperative statement node that interprets the imperative statement group. It is to show the connection relationship. Therefore, in the conversion process, the comment of the command statement group stored in the comment field of the command statement is placed in the child node description field of the node in the newly created command statement definition PAD diagram. The command statement list included in the command statement group is used to generate another PAD schematic node list. The child node pointer of the statement definition PAD diagram node points to the start node of the PAD diagram node list.

The above is a description of the correspondence relationship between the program analysis tree and the PAD diagram structure tree. After each statement node in the program parse tree is converted by the above contrast method, the PAD diagram structure tree storage unit 90 of FIG. 1 has a PAD diagram structure tree corresponding to the PAD diagram. Then, in step (S16) of FIG.
Draw a diagram.

FIG. 20 shows the detailed flow of drawing this PAD diagram. The flow of this figure will be described below. (S
20) Input the abstraction depth of the PAD diagram specified by the user from the keyboard. Here, the abstraction depth is a concept close to a layer or “detail” of the PAD diagram to be drawn, and will be specifically described later.

(S21) Start diagram of PAD diagram (BEGI
N) is drawn. (S22) A PAD diagram is drawn by the recursive drawing procedure shown in FIG. 21 using the start node of the PAD diagram structure tree and layer = 1 as parameters. (S23) PAD
The drawing is ended by adding a completion drawing (END) after the drawing.
Next, the operation flow of recursive drawing will be described with reference to FIG.

(S24) When the recursive drawing procedure is performed, the PAD diagram is drawn according to the data structure of the parameter of the PAD diagram node. (S25) It is determined that the PAD diagram node is the imperative sentence definition PAD diagram.
(S26) If it is determined that the abstraction depth is larger than or equal to the abstraction depth specified by the layer, the following child PAD diagrams of the statement definition PAD diagram are not drawn. As a result, it is possible to prevent the generated statement of the PAD diagram from being created with emphasis on the details, and to show the flow of the entire program and its structure with a simple PAD diagram.

If the above conditions are not met, the current PAD
Drawing is added beside each child node of the schematic node. In (S27) and (S28), the child node pointed by each child node pointer and layer + 1 are used as parameters to perform the drawing by performing the recursive drawing procedure in the recursive method.

(S29) After the child node of the PAD graphic node is drawn, the recursive drawing means is called in a recursive manner by using the PAD graphic node and the layer pointed to by the node pointer next to the node as a parameter to vertically draw the child node. To draw. Complete PAD by the above method
Can draw diagrams. In the step (S16) shown in FIG. 4,
After the PAD diagram is drawn, it is output in the step (S17). This completes the conversion from the source program to the PAD diagram.

In the detailed flow of drawing the PAD diagram in FIG. 20, the abstraction depth directly affects the detail of the PAD diagram. When the abstraction depth is large, it is possible to generate a PAD diagram that reflects the details of a complete statement. On the other hand, when the abstraction depth is small, the generated PAD diagram allows the programmer to quickly understand the structure of the entire program. Therefore, the programmer sets a desired abstraction depth according to the purpose of the program abstraction.

Next, the operation of this apparatus will be described by way of example.
FIG. 22 shows a source program written in the C language, which includes a typical C language command statement and the above-mentioned three types of comments. Source program 10 has input section 30
After being input by, the program analysis unit 60 performs a grammar analysis while referring to the grammar stored in the program language grammar storage unit 20 in the program analysis unit 60. Then, the program analysis tree storage unit 70 stores the program analysis tree (shown in FIGS. 23 and 24) generated correspondingly. (Note that although FIG. 23 and FIG. 24 are originally one figure, they are divided for convenience of electronic filing.) The comments in the source program are classified by the comment classifying unit 50, and the program analysis tree is divided. It is arranged and stored in a corresponding position. The program analysis tree walking unit 81 walks through the program analysis tree stored by the recursive method. The comment portion in the imperative sentence node of the parse tree having the comment is converted into the imperative sentence definition PAD diagram by the definition diagram conversion unit 83. The node of the general command statement having no comment is converted by the general diagram conversion unit 84 in the steps shown from (S13) to (S15) in FIG. As a result, the parse trees in FIGS. 23 and 24 are the PAs shown in FIG.
After being converted into a D diagram structure tree, the PAD diagram structure tree storage unit 90
Memorized in. Finally, in the abstracted PAD diagram drawing unit 85, P
The AD diagram structure tree is shown in FIG. 2 by the procedure shown in FIGS.
6 is used to draw the PAD diagram 110 shown in FIG. At this time, as described above, the user can input the desired abstraction depth of the PAD diagram in the step (S20) of FIG.

FIG. 26 shows the case where the abstraction depth of the program is not set, and is a complete PAD diagram of the source program. FIG. 27 is a PAD diagram drawn with abstraction depth = 4. This figure is concise but has the essence of a source program. FIG. 28 shows the simplest PAD diagram with abstraction depth = 1. Programmer is this PA
It is easy to see from the diagram D that the function of the program contains two tasks. It is "Parsing a
set of source programfil
es "and" return the number of
program files that that canno
t be succeeded fully ”
Is.

Although the present invention has been described above based on the embodiments, it goes without saying that the present invention is not limited to the above embodiments. That is, for example, the language is not limited to the C language, and other language such as Fortran, Algol, etc., and the diagram may be a flow chart instead of the PAD diagram. Also in terms of hardware, it goes without saying that the output section may be a CRT or the like instead of the printing means.

[0051]

As described above, according to the program analysis apparatus of the present invention, a graphic program representation diagram corresponding to the source program is automatically generated. At this time, the comments in the program are classified and then graphically expressed in the imperative sentence definition graphical program expression format.
For this reason, the graphical program representation diagram is created with many comments, and the descriptiveness of the program is enhanced. In addition, since it also has a function of setting the depth of the program abstraction, it is possible to analyze the program with different program abstractions.

[Brief description of drawings]

FIG. 1 is a block diagram of an embodiment of the present invention.

FIG. 2 is a correspondence diagram between a statement in a program and a PAD diagram.

FIG. 3 shows a classification rule of comment command statements.

FIG. 4 is an operation flow chart of the above embodiment.

FIG. 5 is an example showing an imperative sentence segment (including a comment of an expression imperative sentence and a comment of a compound imperative sentence) described in C language and a program parse tree corresponding to it.

FIG. 6 is an example showing a command statement segment (including a comment of a command statement group) written in C language and a program analysis tree corresponding to the command statement segment.

FIG. 7 is a diagram showing a correspondence relationship between a C language command statement and each PAD diagram, and a data structure diagram of each node corresponding to each PAD diagram. (Part 1)

FIG. 8 Same as above. (Part 2)

FIG. 9 Same as above. (Part 3)

FIG. 10 Same as above. (Part 4)

FIG. 11 is a conversion method for converting an expression imperative sentence and a jump imperative sentence into a basic PAD diagram.

FIG. 12 is a conversion method corresponding to a WHILE loop statement with a loop PAD diagram.

FIG. 13 shows a DO-WHILE loop statement in a loop PA
This is a conversion method corresponding to the D diagram.

FIG. 14 is a conversion method that corresponds to a FOR loop statement to a loop PAD diagram.

FIG. 15 is a conversion method corresponding to a simple IF selection command statement to a two-branch selection PAD diagram.

FIG. 16 is a conversion system for converting a nested IF selection statement into a multi-branch selection PAD diagram.

FIG. 17 is a multi-branch selection PAD for a SWITCH selection statement.
This is a conversion method corresponding to the scheme.

FIG. 18 is a statement definition PA for three types of comments of statement.
This is a conversion method corresponding to the D diagram. (Parts (a) and (b))

FIG. 19 Same as above. (Part (c))

FIG. 20 shows PA in step (S16) in FIG.
It is a detailed flow of drawing the D diagram.

FIG. 21 is a flowchart showing a recursive drawing means.

FIG. 22 is a source program written in C language as one processing example in the present invention.

FIG. 23 is a diagram of a program analysis tree as one processing example in the present invention. (The upper part)

FIG. 24 Same as above. (At the bottom)

FIG. 25 is a diagram of a PAD diagram structure tree corresponding to FIG. 23;

FIG. 26 is a complete PAD diagram that is automatically generated as an example of processing according to the present invention.

FIG. 27 is a PAD diagram automatically generated by the program abstraction depth 4 as one processing example in the present invention.

FIG. 28 is a PAD diagram automatically generated by the program abstraction depth 1 as one processing example in the present invention.

FIG. 29 is a PAD using a conventional “C-PAD tool”.
It is a figure.

[Explanation of symbols]

 10 source program 20 program language grammar storage unit 30 input unit 40 comment extraction unit 50 comment classification unit 60 program analysis unit 70 program analysis tree storage unit 80 PAD diagram generation unit 81 program analysis tree walking unit 82 comment statement node detection unit 83 Definition diagram conversion unit 84 General diagram conversion unit 85 Abstract PAD diagram drawing unit 90 PAD diagram structure tree storage unit 100 output unit 110 PAD diagram

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Chen Megumi ▲ In ▼ Taiwan Taipai Shi Tha An Chi 10628 Ren Ren Ile San Toan 136 Hao 10 Law Sun Sha Tien Chi Chi Shu Kai Kai Khu Feng Yu Xi Sieng Kong Su (72) Inventor Reika Wu Taiwan Taipei Pay Ter An Chi 10628 · Len I Le San Touan · 136 · Hao · 10 · Luang Sun Sha Tien Chi Chi Shu Kai Fah Ku Khu Feng Yu Si Sien Con Su

Claims (4)

[Claims] 1. A comment extraction unit for extracting a comment portion from a inputted source program by a comment symbol, and a comment extraction unit for determining an appropriate position in a program analysis tree according to an adjunct relation between a comment and a statement. Depending on the position of the comment in the source program, the comment classification unit that classifies the comment by determining whether it is a comment of an expression command statement, a comment of a compound command statement, or a comment of a command statement group, and the grammar of the programming language is stored A program language grammar storage unit, and a program analysis for performing a grammatical analysis on the input source program by the grammar stored in the program language grammar storage unit to obtain a program parse tree of a function expressed by each statement in a bottom-up method. Part, and the program analysis tree and the previous obtained by the program analysis part In order to store the classification result obtained by the comment classification unit, a grammar code storage field that stores a grammar code that represents the property of the node with respect to the data structure of each node, and a termination node that stores a termination node and a source code A source code storage field, an instruction statement comment storage field for storing a comment of a formula instruction statement and a comment of a compound instruction statement belonging to a node of a compound instruction statement, and an instruction statement for directionally storing a comment corresponding to an instruction statement group. A program parse tree storage unit having a group comment pointer column and each child node pointer column that stores each child node pointer connecting each child node, and a statement in the program parse tree stored in the program parse tree storage unit For each node, convert it to the graphical program representation format corresponding to the statement node, and add the comment in the source program to the statement Program analysis apparatus characterized by comprising a drawing generation unit for generating a graphical representation of the program diagram of the conversion to one function Gizu programs representation. 2. In order to store a program analysis tree obtained by analyzing a source program, a data structure of each node stores a grammar code storage field for storing a grammar code representing the property of the node, an end node and a source code. The end node source code storage field, the comment storage field for the command statement that stores the comment of the expression command statement and the comment of the compound command statement that belongs to the node of the compound command statement, and the corresponding comment for the command statement group A program parse tree storage unit having a comment pointer column of a statement group to be stored and each child node pointer column storing each child node pointer connecting each child node, and each node in the program parse tree storage unit in a recursive method A program analysis tree crossing section for detecting a statement node by walking across the statement, and a statement detected by the program analysis tree crossing section Determining whether or not a comment has a comment, passing the statement node that has a comment to the definition diagram conversion unit, and passing the statement node that does not have a comment to the general diagram conversion unit Part, and in order to store the graphical program expression format, the data structure of the node in each node is a graphical program expression format section that stores the type of the graphic, and a graphical program expression that stores the statement to operate. Format description field, child node number storage field that stores the number of child nodes, each child node description field that stores the branching condition of each child node for each branch after processing, and branching of each child node pointer , A diagrammatic program representation diagram structure tree storage unit having each child node pointer column for storing the following, and a next node pointer column for connecting and storing the next node in the execution order pointing to the next node; Comment command statement node detecting unit converts a comment portion of a command statement node having a comment into a definition diagrammatic program representation format node and stores it in the diagrammatic program representation diagram structure tree storage unit A definition diagram conversion unit that passes a node to the general diagram conversion unit, and a statement sentence node that does not have a comment detected by the comment statement sentence node detection unit or a statement sentence node that is passed from the definition diagram conversion unit is tree-structured. A general-scheme conversion unit for converting into a general-scheme program representation form node according to a relationship and storing it in the schematic-program representation diagram structure tree storage unit; and a schematic program representation diagram read from the schematic program representation diagram structure tree storage unit. Depending on the program abstraction depth set by the user, the structure tree determines whether or not to hide the comment statement, and a graphical program with a different degree of abstraction is drawn. Program analysis apparatus characterized by comprising an abstraction diagram drawing section for generating a representation view. 3. The program analysis device according to claim 1, wherein the graphical program representation diagram is a PAD diagram. 4. The program analysis device according to claim 2, wherein the graphical program representation diagram is a PAD diagram.