JPH06149556A - Automatic specification generating system - Google Patents

Abstract

(57) [Summary] [Purpose] To create a specification that is easier to understand by putting together the substitution processes that have a strong relationship with each other in a single table. [Structure] Variables to be assigned in the assignment statement of program 1 are classified into categories using the variable naming convention or data structure, and a set of assignment statements having variables of the same type as the assignment destination is extracted. Then, for variables that can be converted into a table, the patterns of the table are converted for each variable having a strong relationship. For assignment statements divided by conditional branching, assignment statement strings are classified according to conditions. Furthermore, when the variables corresponding to the substitution destinations in the continuous tables converted as described above are of the same type, these tables are combined into one table. The assignment statement converted into a table is converted into a natural language such as Japanese and a specification 2 having a table classified according to categories is generated.

Description

Detailed Description of the Invention

[0001]

[Industrial application] In order to facilitate the maintenance work of existing programs, it is required to electronically manage the specifications and facilitate reference retrieval. However, many of the specifications of existing programs are handwritten, and it takes manpower to create them. In order to save such trouble and create a specification that can be managed electronically, a function of extracting the specification from the program and automatically generating the specification is required.

As described above, the present invention relates to a specification generation method for automatically generating specifications from an existing program, and in particular, the present invention converts variables used in an existing program into a table and converts them into a table. The present invention relates to an automatic specification generation method that can be replaced with a language expression.

[0003]

2. Description of the Related Art In many conventional specification generation methods, a program is converted into a natural language as it is. Also, when converting the variables used in the program to the table format, there are some that generate a conversion table for data declaration and a decision table, but pay attention to the variable substitution destination,
It is not known to convert the same kind of substitution into a table.

[0004]

As described above, hitherto, there has not been known a method of collectively converting substitutions of the same kind into a table by paying attention to substitution destinations in a program. The present invention has been made in view of the above-mentioned problems of the prior art. When generating a specification, the substitution processes having a strong relationship with each other are put together in one table to generate a specification that is easier to understand. The purpose is to provide an automatic specification generation method.

[0005]

FIG. 1 is a block diagram showing the principle of the present invention. In the figure, 1 is a program to be input, and 2 is a generated specification document. In order to solve the above problems, the invention of claim 1 of the present invention provides a program 1
In the specification automatic generation method for converting the specification into a natural language and automatically generating the specification 2, as shown in FIG. 1, variables are classified into categories by using the variable naming convention, and variables of the same kind are assigned to the substitution destination. A set of substitution statements that it has is extracted, the extracted substitution statements are converted into a table, and the specification 2 is automatically generated.

According to a second aspect of the present invention, there is provided a program 1
In the automatic specification generation method for converting the specification into a natural language and automatically generating the specification 2, as shown in FIG. 1, the variables are classified into categories using the data structure of the variables, and variables of the same kind are assigned to A set of assignment statements having the above is extracted, the extracted assignment statements are converted into a table, and the specification 2 is automatically generated.

According to a third aspect of the present invention, there is provided a program 1
In the automatic specification generation method for converting the specification into a natural language and automatically generating the specification 2, as shown in FIG. 1, variables are classified into categories by using a variable naming convention, and are divided by conditional branching. A set of assignment statements that have the same type of variable as the assignment destination is extracted from the assigned assignment statement sequences, the assignment statement sequences are classified according to the conditions, converted into a table, and specification 2 is automatically generated. is there.

According to a fourth aspect of the present invention, there is provided a program 1
In the automatic specification generation method for converting the specification into a natural language and automatically generating the specification 2, as shown in FIG. 1, variables are classified into categories by using a variable data structure, and are divided by conditional branching. A set of assignment statements that have the same type of variable as the assignment destination is extracted from the assigned assignment statement sequences, the assignment statement sequences are classified according to the conditions, converted into a table, and specification 2 is automatically generated. is there.

According to a fifth aspect of the present invention, there is provided a program 1
In the automatic specification generation method for converting the specification into a natural language and automatically generating the specification 2, as shown in FIG. 1, variables are classified into categories by using the naming convention of variables or the data structure of variables, and Extracts a set of assignment statements that have variables as assignment destinations and converts them to the first table, and also extracts a set of assignment statements that have the same type of variables as assignment destinations from the assignment statement sequence divided by conditional branching Then, the assignment statement strings are classified according to conditions and converted into the second table, and when the variables corresponding to the assignment destinations in the consecutive first and second tables are of the same type, The second table is combined into one table, and the specification 2 is automatically generated.

[0010]

[Function] The substitution destination variable in the substitution statement of program 1 is
By using the variable naming convention or the data structure, the variables are classified into categories and a set of assignment statements having the same type of variable as the assignment destination is extracted. Then, for variables that can be converted into a table, the patterns of the table are converted for each variable having a strong relationship.
For assignment statements divided by conditional branching, assignment statement strings are classified by conditions and converted into tables. Furthermore, when the variables corresponding to the substitution destinations in the continuous tables converted as described above are of the same type, these tables are combined into one table. The assignment statement converted into the table is converted into a natural language such as Japanese, and a specification having a table in which the assignment statement string is classified according to the assignment destination variable is generated.

According to the first to fifth aspects of the present invention, since the specifications are automatically generated as described above, one assignment statement having the same type of assignment destination variable is specified in the specifications. It can be converted into a table, and a specification that is easier to understand can be created.

[0012]

FIG. 2 is a diagram showing the overall construction of an embodiment of the present invention, in which 11 is a program written in a language such as COBOL, 12 is a program 11, and the syntax structure is analyzed. And 13 is a syntactic analysis unit that generates an intermediate expression that represents a data structure, 13 is an intermediate expression generated by the syntactic analysis unit 12, 14 is a table conversion unit that converts a part of the intermediate expression 13 into a table pattern, and 15 is the An intermediate expression, 16 is a name tag dictionary storing names representing meanings corresponding to identifiers in the program, and 17 is an intermediate expression 15 based on the information in the name tag dictionary 16 and is a table expressed in natural language and natural language. The replacement natural language generation unit, 18 indicates the created specifications.

FIG. 3 and FIG. 4 are diagrams showing an example of the input program 11 written in COBOL. In this program, the assignment statement written in "MOVE ..." Is the part that becomes
The second line of the program in FIG. 4, "MOVE XHIHII
In "TO XLWCDT", the variable "XL
WCDT ”is extracted, and the variables and their values are collectively converted into a table for each category (type).

Further, whether or not the categories of the substitution destination variables are of the same type is determined by, for example, the following method. Method of using variable naming convention information Variable naming may be specified so that it can be classified according to business or use. For example, the first three letters of the variable name (for example, "TMP-" are the first three letters). The type of the variable to be attached is represented by "corresponding to" temporary variable ").

Therefore, in this case, the prefix 3 of the variable name
The type can be determined by the character. Method of Using Data Structure Information of Variables When naming a variable, for example, variables lower than the variable “XXXV1” are “XXXV11”, “XXXV12”, ...
Further, the variable may have a hierarchical structure such that the variable under the variable “XXXV11” is “XXXV111”, and a variable name having a structure according to its type and hierarchy may be given. In this way, when the types of variables are classified by the data structure, the category of the variable can be determined by looking at the structure of the variable.

In FIG. 2, the syntactic analysis unit 12 analyzes the program 11 shown in FIGS. 3 and 4, for example, and generates an intermediate representation 13 expressing the syntactic structure and data structure. 5 to 7 are diagrams showing an example of the intermediate representation 13 generated by the syntax analysis unit 12, which is shown in FIG.
From the program written in COBOL shown in FIG.
It shows a case where an intermediate expression described in ISP is generated.

For example, the intermediate representation 13 shown in FIGS. 5 to 7 generated in the syntax analysis unit 12 is given to the table conversion unit 14, and the table conversion unit 14 executes the determination method shown in the above. The category of the variable of the assignment statement is determined by using the variable, and the variable that can be converted into the table is converted into the pattern of the table for each variable having a strong relationship to generate the intermediate expression 15.

The natural language generator 17 converts the intermediate language 15 into a natural language (for example, Japanese) using the variable names stored in the name dictionary 16 and generates a specification 18. FIG. 8 is a diagram showing an example of table conversion of continuous assignment statement strings. FIG. 8A shows a COBOL program to be converted,
The figure (b) is the intermediate representation generated by the syntax analysis unit 12, and the figure (c) is the variable “Y” that is continuously input.
The result of the table conversion of the assignment statement including "YYV1" to "YYYV4" is shown.

The natural language generation unit 17 is used to generate the specifications expressed in natural language shown in FIG.
Converts a variable into a natural language by referring to the following information stored in the name dictionary 16, for example. WK1 to WK1: Work 1 to Work 6 XXXV1 to XXXV2: Variable X1 YYYV1 to YYYV3: Variable Y1 to variable Y3 ZZZV1: Variable Z1 FIG. This embodiment will be described.

In the figure, in step S11,
When a new assignment statement is input, in step S12,
The substitution target variable is extracted. In step S13, it is determined whether the category 1 and the variable of the new substitution destination are the same type, or whether the category 1 has no value. When the assignment statement is first input, category 1 has no value, so go to step S14 to add the assignment statement including the variable to the table conversion candidate, and to add a variable of the same type as the extracted substitution destination variable to the category. Set as 1. Then, in step S15, it is determined whether or not the sentence is completed. If the sentence is not completed, the process returns to step S11.

For example, in the example of FIG. 8, when the assignment destination variable "XXXV1" is first extracted, an assignment statement including the above variable is added as a table conversion candidate, and an assignment destination of the same type as the above assignment destination variable is added. Variable (in this example, "XX
The substitution destination variable starting with the three characters "X") is set as category 1. Next, in step S11, a new assignment statement is input, and in step S12, the assignment destination variable is extracted. In step S13, whether the category 1 and the variable of the new substitution destination are of the same type as described above,
Alternatively, it is determined whether category 1 has no value.

Here, the extracted substitution destination variable is "YYY".
In the case of “V1”, since it is not the same type as category 1, it goes to step S16 and it is determined whether or not the table conversion candidate is empty. If the table conversion candidate is not empty (in this case,
Since the variable "XXXV1" is set as category 1 and is not empty), the table ends before the input assignment statement, so the table conversion candidates are converted in step S17. In addition, when the substitution target variables of the same type are not continuously input, the assignment statement is directly converted to the natural language without being converted into the table.

For example, as described above, the substitution destination variable "XX
If "YYYV1" which is a substitution destination variable of a different category is extracted after one "XV1" is extracted,
Since the substitution destination variables starting with the three letters "XXX" are not continuous, they are not converted into a table, and as shown in FIG. 8C, the substitution statement is directly converted to the natural language, such as "set variable X1 to work 1". To do.

Then, in step S18, to prepare for the next table conversion, category 1 and the table conversion candidates are cleared, and in step S19 it is judged whether or not the sentence has ended. , Step S11
Then, the same processing as above is performed for the assignment statement including the assignment destination variable “YYYV1”. For example, as shown in FIG. 8A, when an assignment statement including a variable “XXXV1” is input, and then an assignment statement including an assignment destination variable that starts with three letters “YYY” is continuously input. Is added as a table conversion candidate, and the table is converted in step S17.

As a result, the substitution destination variable "YYYV1",
"YYYV2" and "YYYV3" are converted into the corresponding natural language expressions "variable Y1", "variable Y2", and "variable Y3", and the assignment statement is converted into a table as shown in FIG. 8C. It In addition, “Set a value in the following area.” Is added in front of the table. Then, the substitution destination variable "ZZZZV
When an assignment statement including "1" and "XXXV2" is input, as in the case where an assignment statement including an assignment destination variable "XXXV1" is input, as shown in FIG.
It is converted into “Set work 5 to variable Z1” and “Set work 6 to variable X2”.

FIG. 10 and FIG. 11 are diagrams showing an example of table conversion of the assignment statement in the conditional branch statement. FIG. 10A is a COBOL program to be converted, and FIG. The intermediate representation generated in FIG.
Indicates the result of table conversion of the assignment statement in the conditional branch statement including the variables “YYYV1” to “YYYV3”. 12
FIG. 4 is a diagram showing a flowchart for converting an assignment statement in a conditional branch statement into a table, and this embodiment will be described with reference to FIG.

In step S21, a new conditional sentence is input, and in step S22, an assignment sentence is extracted. In step S23, the substitution destination variable is extracted, and step S
At 24, it is determined whether the variables are the same as the category 1 or the category 1 has no value. As in the case of the flowchart of FIG. 9, when the assignment statement is input for the first time, category 1 has no value, so go to step S25 to add the assignment statement including variables to the table conversion candidates and extract it. A variable of the same type as the substitution destination variable is set as category 1, and a condition is added to the substitution source.

Then, in step S26, it is determined whether or not the sentence is completed. If the sentence is not completed, the process returns to step S22 and the next assignment sentence is extracted. For example, in the example of FIG. 10, first, the substitution destination variable “YYY
When “V1” is extracted, an assignment statement including the above variable is added as a table conversion candidate, and an assignment destination variable of the same type as the above assignment destination variable is set as category 1. In addition, as a condition for the substitution source, “IF cond-A THE
When the condition “cond-A time” corresponding to “N” is added and the statement is not completed, the process returns to step S22 and the next assignment statement is extracted.

Next, in step S24, step S
It is determined whether the substitution destination variable of the substitution statement extracted in 23 is the same type as category 1. Here, the extracted substitution destination variable is, for example, "YYYV" as shown in FIG.
In the case of “2”, since it is the same type as category 1, step S
25, an assignment statement including the above variables is added as a table conversion candidate, and the assignment source is given a condition of “IF
A condition "time of cond-A" corresponding to "cond-A THEN" is added.

Similarly, the assignment statement is added as a table conversion candidate, and the assignment destination variable “YYYV3” in FIG.
When an assignment statement containing is input and added to the table conversion candidates,
Since the assignment statement is completed, the process goes to step S27. In step S27, the table conversion candidates are converted into a table and
Collect the same assignment destinations in the same column. Also, in order to prepare for the next table conversion in step S28, table conversion candidates and category 1
Is cleared, and in step S29, it is determined whether or not the sentence has ended. If the sentence has not ended, the process returns to step S21 and the above process is repeated.

If it is determined in step S24 that the category 1 and the extracted substitution target variables are not of the same type, the process proceeds to step S28, and the table conversion is performed to prepare for the next table conversion as described above. The conversion candidate and category 1 are cleared, and in step S29, it is determined whether or not the sentence has ended. If the sentence has not ended, step S2
Returning to 1, the above processing is repeated.

As a result of the above processing, the substitution destination variable "YYYV
"Variable Y1", "Variable Y2", "Variable Y" which are natural language expressions corresponding to "1", "YYYV2", and "YYYV3".
3 ”, and as shown in FIG.
The conditions "d-A", "other than the above", and "not con-A" are added, and the assignment statement is converted into a table for each assignment-destination variable. In addition, “Set a value in the following area.” Is added in front of the table.

FIGS. 13 to 15 are views showing an example of table conversion of a program consisting of an assignment statement string and an assignment statement string in a conditional branch statement. FIG. 13 is a COBOL program to be converted, and FIG. 14 is a syntax. The intermediate representation generated in the analysis unit 12, FIG. 15 shows the result of tabular conversion of the intermediate representation. FIG. 16 is a diagram showing a flowchart for converting an assignment statement string and an assignment statement string in a conditional branch statement into a continuous table, and this embodiment will be described with reference to the same figure.

In step S31, a new sentence is input, and in step S32, the input sentence is judged. If the input sentence is a sequence of assignment sentences, the success or failure of registration as a table conversion candidate is determined in step S33 by performing the processing shown in the flowchart of FIG. If registration to the table conversion candidate is successful, step S34.
Then, it is determined whether or not the sentence is finished. If it is not finished, the process returns to step S31 to repeat the above process.
In step S33, if another type of substitution destination appears in the middle of the process, the table conversion candidate is considered to have failed in the middle, registration of the table conversion candidate is stopped, and the table conversion candidate is converted into the table in step S37. Next, in step S38, to prepare for the next table conversion, the table conversion candidates and category 1 are cleared, and in step S39 it is determined whether or not the sentence has ended. If the sentence has not ended, , And returns to step S31 to repeat the above process.

If it is determined in step S32 that the input sentence is a conditional branch sentence, step S3.
5, the process as shown in the flowchart of FIG. 12 is performed to determine the success or failure of registration as a table conversion candidate. If the registration to the table conversion candidate is successful, the process goes to step S34 and the same process as above is performed. If another type of assignment destination appears in the middle of step S33, the conditional branch statement cannot be the same table as the table so far, so the procedure goes to step S36 to cancel the registration so far. The process proceeds to step S37 and the same processing as above is performed.

If it is determined in step S32 that the input sentence is another sentence, step S3
7, the same processing as above is performed. As a result of the above processing, the program shown in FIG. 13 is converted into the table shown in FIG. When the tables are combined as described above, assignment statements that cannot be made into tables by themselves, such as assignment to the last variable Y9 in FIG. 15, can be put together in the table.

[0037]

As is apparent from the above description,
In the present invention, the variables are classified into categories by using the variable naming convention or the variable data structure, a set of assignment statements having the same type of variable as the assignment destination is extracted and converted into a table, and as described above. When the variables corresponding to the substitution destinations in the continuous tables converted by the above are the same type, these tables are combined into one table and the specifications are automatically generated. In, the semantically identical substitution processing can be converted into one table, and a more easily understandable specification can be generated.

[Brief description of drawings]

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

FIG. 2 is a diagram showing an overall configuration of an embodiment of the present invention.

FIG. 3 is a diagram showing an example of an input program written in COBOL.

FIG. 4 is a diagram (continuation) showing an example of an input program described in COBOL.

FIG. 5 is a diagram showing an example of an intermediate expression generated by a syntax analysis unit.

FIG. 6 is a diagram (continuation) showing an example of an intermediate expression generated by a syntax analysis unit.

FIG. 7 is a diagram (continuation) showing an example of an intermediate expression generated in the syntax analysis unit.

FIG. 8 is a diagram showing an example of table conversion of continuous assignment statement strings.

FIG. 9 is a diagram showing a flowchart for converting a continuous substitution statement string into a table.

FIG. 10 is a diagram showing an example of table conversion of an assignment statement in a conditional branch statement.

FIG. 11 is a diagram (continuation) showing an example of table conversion of an assignment statement in a conditional branch statement.

FIG. 12 is a diagram showing a flowchart for converting an assignment statement in a conditional branch statement into a table.

FIG. 13 is a diagram showing an example in which a continuous table is converted into one table.

FIG. 14 is a diagram (continuation) showing an example in which a continuous table is converted into one table.

FIG. 15 is a diagram (continuation) showing an example in which a continuous table is converted into one table.

FIG. 16 is a diagram showing a flowchart for converting a continuous table into one table.

[Explanation of symbols]

 1, 11 program 12 syntax analysis unit 13, 15 intermediate representation 14 table conversion unit 16 name tag dictionary 17 natural language generation unit 2, 18 specifications

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Masaaki Noro 1015 Kamiodanaka, Nakahara-ku, Kawasaki-shi, Kanagawa Inside Fujitsu Limited

Claims (5)

[Claims] 1. In a specification automatic generation method for converting a program into a natural language and automatically generating specifications, variables are classified into categories by using a variable naming convention,
An automatic specification generation method characterized by extracting a set of substitution statements having the same type of variables as the substitution destinations, converting the extracted substitution statements into a table, and automatically generating specifications. 2. In a specification automatic generation method for converting a program into a natural language and automatically generating a specification, variables are classified into categories using a data structure of variables, and variables of the same kind are used as substitution destinations. An automatic specification generation method characterized by extracting a set of substitution statements, converting the extracted substitution statements into a table, and automatically generating specifications. 3. In a specification automatic generation method for converting a program into a natural language and automatically generating specifications, variables are classified into categories by using a variable naming convention, and substitutions are divided by conditional branching. Of the sentence sequence,
An automatic specification generation method characterized by extracting a set of substitution statements that have the same type of variable as the substitution destination, classifying the substitution statement strings according to conditions, and converting them into a table to automatically generate specifications. 4. In a specification automatic generation method for converting a program into a natural language and automatically generating specifications, variables are classified into categories by using a variable data structure, and substitution is performed by conditional branching. Of the sentence sequence,
An automatic specification generation method characterized by extracting a set of substitution statements that have the same type of variable as the substitution destination, classifying the substitution statement strings according to conditions, and converting them into a table to automatically generate specifications. 5. In a specification automatic generation method for converting a program into a natural language and automatically generating a specification, variables are classified into categories by using a variable naming convention or a variable data structure, and variables of the same type are generated. While extracting the set of assignment statements at the assignment destination and converting it to the first table,
From the assignment statement sequence divided by the conditional branch, a set of assignment statements having the same type of variable as the assignment destination is extracted, the assignment statement sequence is classified according to the condition, converted into the second table, and the continuous first And when the variables corresponding to the substitution destinations in the second table are of the same type, the first table and the second table are combined into a single table, and the specifications are automatically generated. Automatic specification generation method.