JPH03223930A - Support system for generation of source - Google Patents

Abstract

PURPOSE:To effectively produce a source code after the change of a chart by reflecting the information on an existing source code corresponding to an unchanged control structure part to the corresponding structure of a skelton obtained after the change of the chart. CONSTITUTION:When a changed chart is inputted to a source generating means 12, a skelton is produced in response to the changed chart. This skelton has its control structure including a part equal to an existing source code corresponding to an unchanged chart. In addition, a newly added structure may possibly be included in the skelton together with a structure included in the existing source code. Thus a source generation support means 15 sorts these structures based on the skelton obtained after the change of a chart and the existing source code. Then the means 15 reflects the detailed information on the corresponding structure part of the existing source code to an unchanged structure part. Thus a source code is effectively produced in response to the change of a program.

Description

[Detailed Description of the Invention] [Purpose of the Invention (Industrial Application Field) This invention provides a system for creating a program (source program) by converting a chart showing the processing flow of a program to be created into source code. In particular, the present invention relates to a source generation support system suitable for efficiently generating source code (source program) from a chart when a program change (chart change) occurs.

(Prior Art) Generally, when creating a new program, a chart showing the process flow of the program is converted using a tool (source generation means) that converts it into source code written in a desired language. A template source (hereinafter referred to as a skeleton) that forms the skeleton of the source code of the corresponding program is automatically generated from the source code. This skeleton is
It indicates the control structure of the corresponding program, including if and while indicating the structure and control of the program, and comments as annotation statements corresponding to the structure (such comments are used as comments for explaining normal statements in the program). It consists of comments (called "structural comments" to distinguish them from the "comments"), and does not include variable declarations or processing statements (conditional expressions, assignment statements, etc.). Once the above-mentioned skeleton is automatically generated, the source code of the target program is created by manually reflecting variable declarations and processing statements in this skeleton.

Conventionally, when a created program needs to be changed, the corresponding existing chart is edited and the chart is changed. Next, a new skeleton is automatically generated from the changed chart using the source generation means. Then, by manually reflecting the variable declarations and processing statements in the new skeleton, the source code of the modified program is created.

However, if you automatically generate a skeleton from the changed chart after changing the chart, the source code parts that have not changed (variable declarations, processing statements, etc.) will be lost, and you will have to manually re-enter the variable declarations and processing statements. However, there is a problem in that re-examination is required even for parts that have not been changed. The time spent re-entering and re-testing increases each time the program is changed.

(Problem to be Solved by the Invention) As described above, conventionally, when a program change occurs, if a chart is changed and a skeleton is automatically generated using this changed chart, parts of the source code that have not changed are When generating source code from the skeleton, variable declarations, processing statements, etc. must be manually re-entered, and the relevant parts must be retested.

This invention was made in view of the above circumstances, and its purpose is to efficiently generate a changed source code from a changed chart by using the existing source code portion that has not been changed when a program change occurs. The purpose is to provide a source generation support system.

[Structure of the Invention (Means for Solving the Problem) This invention is a source generation method that generates a template source (skeleton) that forms the backbone of a source code based on a chart showing the flow of processing of a program to be created. After the chart is changed for program change, a new skeleton is generated by the source generation means corresponding to the changed chart, and structural comments are added based on the existing source code corresponding to the chart before the change. Source generation that detects a control structure that does not have any differences (changes), and reflects the information in the corresponding control structure of the existing source code to the corresponding control structure of the new skeleton to generate the source code after the chart has been changed. It is characterized by providing support means. The present invention also provides a means for generating (reproducing) a skeleton corresponding to an existing source code from an existing source code, and a new method corresponding to the generated skeleton and the above-mentioned changed chart. A control structure having no differences as described above is detected based on the comparison result of both skeletons.

(Operation) According to the above configuration, by inputting a chart changed due to a program change (changed chart) to the source generation means, a chart changed skeleton (template source) corresponding to the changed chart is generated. be done.

Regarding its control structure, this skeleton after chart change has a structure (unchanged structure) that is the same part as the existing source code corresponding to the chart before change.

There is also a possibility that there are newly added structures. Furthermore, there may be structures that exist only in existing source code, ie, structures that have been deleted due to chart changes. Therefore, based on the skeleton after changing the chart and the existing source code, the source generation support means is used to classify it as described above, and the unchanged structural parts are reflected in the detailed information of the corresponding structural parts of the existing source code. By doing so and generating the source code after changing the chart, compared to the conventional system where detailed information was manually edited and entered even in the unchanged structure part,
Source code can be efficiently generated in response to program changes.

(Example) An embodiment of the present invention will be described below with reference to the drawings.

Figure 1 is a block diagram of a source generation support system that uses existing source code to generate new source code from charts (chart information) that have been changed due to program changes, and Figure 2 is FIG. 1 is a block configuration diagram of a source generation system for generating source code from a chart.

In FIG. 2, 21 is chart information (chart information) indicating the process flow of a newly created program;
Reference numeral 2 denotes a source generation means as a tool for converting chart information 21 into source code written in a language specified by a program creator.

The chart information 21 sets a limit flag 1 imi based on a conditional determination as to whether the value of the variable a is greater than or equal to the upper limit value RH.
Assume that a chart of a C language program including a processing procedure for turning on (setting t to "]") is shown. A part of this chart is shown in FIG. To create a new program using the chart information 21, first input the chart information 21 into the source generation means 22 of the system shown in FIG. generate.

The skeleton 23 represents the control structure of the corresponding program, and as shown in part in FIG. The "/**Range Over**/" part surrounded by the dotted line frame indicated by 41, and the structural comment as an explanatory text indicating the structure of the processed sentence (proxy human text) (the part indicated by the dotted line frame indicated by 42) The enclosed "/**flag on**/" part) is included, but variable declarations and processing statements (here, the conditional expression "a") are included.
>=RH" assignment statement "1 imit=1"). In addition to the above if statement, control structures (structural statements) in the C language include while statements, for statements,
switch -c a se sentence, do-
while statement, goto, break, continue
There are e-sentences, etc. For example, for an if statement, if().

Else etc. each represent a part of the structure. Also (
)” to express multiple sentences, (″ and “)” become part of the structure. In addition, in this embodiment, in addition to each of the above-mentioned structural statements, function calls and proxy statements (range represented by one box as a process in a flowchart) are also included.
I try to treat it as one structure. In addition, in Figure 4,
The row number of the skeleton information starts from 5, but this is because only a part of the skeleton 23 is shown, and generally starts from 1.

Now, in C language etc., comments are generally "/*"
It is written by surrounding it with "*/". Therefore, in this embodiment, in order to distinguish structural comments, that is, comments that serve as annotation sentences corresponding to the control structure of a program, from comments that explain normal statements in a program, (separately from /* and */). The * added at the beginning and end of this comment are treated as part of the comment during program processing, so in the above example, “
*Range over*" and "*Flag on*" are treated as comments, and there is no problem with the syntax of the C language.

After generating the skeleton 23 from the chart information 21 using the source generation means 22, the program creator operates the editing means 24 to manually edit detailed information such as declaration statements and processing statements for the skeleton 23. The target source code (source program) 25 is completed. Here, in the skeleton 23 shown in FIG. 4, the conditional expression "a>-RH" and the assignment statement "11m1t-1; ) is manually added to generate the source code 25.

When it becomes necessary to change the program after generating the source code 25 as described above, the program creator changes the chart (adding or deleting steps) and changes the chart information (chart information after chart change) 11. (See Figure 1).

This chart change chart information 11 is the chart shown in FIG. 3 (immediately before the step of determining the range over condition)
As shown in FIG. 6, it is assumed that the chart is obtained by adding a step of determining whether or not to execute a test, which is surrounded by a dotted line frame indicated by reference numeral 61, and changing the chart.

By inputting the chart information 11 after chart change into the source generation means 12 (corresponding to the source generation means 22 in FIG. 2) in the source generation support 1 tool IO shown in FIG. A skeleton (skeleton after chart change) 13 is automatically generated from. As shown in FIG. 7, the skeleton 13 after the chart change includes the control structure "if()+1" of the if statement corresponding to the chart change part (the step of determining the condition for whether or not to execute the added test) and the if statement. A structural comment "/**Test execution**/" (the part surrounded by the dotted line frame indicated by reference numerals 71 and 72) as an explanatory text has been added to the skeleton 23 in FIG.

Now, conventionally, as described above, from the chart change chart information 11 to the chart change skeleton 13 shown in FIG.
When automatically generated, skeleton 13 after changing this chart
By manually editing declaration statements, processing statements, etc., a new source code corresponding to the chart information 11 after chart change was created. However, in this method, the source code 2 corresponding to the chart information 21 before the change is
5 (this will be referred to as the existing source code 14 for convenience), the parts that have not changed (here, the conditional expression "a>-RH" corresponding to the range over condition determination step and the flag-on processing step) are unchanged. Assignment statement “l imi t=1 ;”)
up to and including is lost.

Therefore, the program creator needs to use the skeleton 2 mentioned earlier.
In the same way as when creating source code 25 from 3,
The lost portions mentioned above had to be re-entered, which was cumbersome. Therefore, in this embodiment, the source generation support means 15, which forms the center of the source generation support tool IO shown in FIG.
, it is possible to generate source code after chart changes without losing any parts that have not changed. The source code generation process by the source generation support means (5) will be explained below with reference to the flowchart of FIG.

First, as shown in step S1 in FIG. 8, the source generation support means 15 inputs the existing source code 14 (see FIG. 5), performs structural analysis, and analyzes the structure sentences (if statements, w
A skeleton 16 corresponding to the existing source 3 code 14 is reproduced using the structure comment generated from the file (file statement, etc.) and chart information.

In other words, the source generation support means 15 extracts from the existing source code 14 conditional expressions of structural statements of the language, arguments in function call statements, and normal comments (comments other than structural comments, that is, "/** **/" ), lines with declaration statements (variable type lines), and lines with assignment statements (here, the conditional expression "a>-RH" and the assignment statement "1 fmi -1;") By removing , the skeleton 1B (as created by the source generation means 2 or 22) corresponding to the existing source code 14 is reproduced.

The method of generating a skeleton in the source generation process of the source generation means 12 or 22 is predetermined, as is clear from the above-described example of generation of the skeleton 23 (see FIG. 4). Therefore, the skeleton (source code that does not include conditional expressions, arguments in function calls, normal comments, etc.)
Even if the source code (here, the existing source code 14) is completed by manually adding executable statements to the source code, a skeleton (as created by the source generation means 12 or 22) from the same code (here, the existing source code 14) Skeleton 1B) can be easily reproduced. In this way, source generation support means 1
In this embodiment, where the existing source code 14 matches the source code (initial source code) 25, the skeleton (reproduced skeleton) 16 reproduced by the structure analysis process in step 5 matches the skeleton 23 shown in FIG. Note that the program analysis method is well known in compiler technology and the like, so the explanation will be omitted.

When the source generation support means 15 reproduces the skeleton 16, as shown in FIG. A source code work file 17 is created that includes a source code correspondence section 92 in which information indicating which part of the source code 14 corresponds is set (step S2 in FIG. 8). In addition,
In the example of FIG. 9, each line of the source code represents one structure, but multiple lines may represent one structure.

Next, the source generation support means 15 generates the chart modified skeleton 1 created by the source generation means 5 stage 12.
3 (see FIG. 7) and the contents of the skeleton section 91 of the source code work file 17 created in step S2 of FIG. Then, after changing the chart, skeleton 1
Common character strings that exist in 3 and also exist in the reproduction skeleton 16 (i.e., the part that was not changed), character strings that exist only in the skeleton 13 after the chart change (i.e., the added part), and character strings that exist only in the reproduction skeleton 16 after the chart change Existing string (
That is, the deleted portion) is detected (step 3 in FIG. 8). Note that the character string that exists in common in the chart-changed skeleton 13 and the reproduced skeleton 1B (referred to as the first character string)
However, if a second character string that includes the first character string and is longer than the same character string exists in common in the chart-changed skeleton 13 and the regenerated skeleton 16, the first character string is a common character. The second character string, which is the longest and includes the character string of clause 1, is detected as a common character string. For example, in the case of the skeletons 13 and 16 after the chart change shown in FIG. 7 and the reproduced skeleton 16 shown in FIG. “1f()(/**” and “1f()(/**range over**/” on the playback skeleton 16
“if() (/**” included in # matches.

However, this - a string "if () (/** range over**/
/**Flag on**/) Both skeletons 13.
18, the latter character string is detected as a common character string. Of course, if a longer character string including the latter character string described above exists in both skeletons 13.1.6, that character string becomes the common character string.

As is clear from the above, in this embodiment, “if
A string consisting of three structures: () (/**range over**/”, “/**flag on**/” and “)” is detected as a common string. Also, after changing the chart, skeleton 13 The above 'if () (/**Test execution**/'' and the 7th character after "/**Flag on**)" on the same skeleton 13 only exist in skeleton 13 after changing the chart. (See Figures 7 and 9).

Now, the string comparison technology used in step S3 in Figure 8 is the UNIX "
This is a well-known technique such as "diff" command.The source generation support means 15 performs the above detection using such a character string comparison technique, thereby generating the skeleton 13 after chart change.
creates a difference information table 18 indicating which parts have been changed with respect to the original skeleton, that is, the reproduced skeleton 16 (corresponding to the skeleton 23 here) (step S4 in FIG. 8). As shown in FIG. 10, this difference information table 18 includes a skeleton part 101 in which the skeleton 13 after the chart change is placed, and the same skeleton part 101 (the skeleton 13 after the chart change above).
The source code corresponding section 102 is set with information indicating which part of the existing source code 14 each structure corresponds to or whether there is no corresponding part. A specific method for generating the skeleton section 101 in the difference information table 18 will be described below.

First, in FIG.
9, that is, a string consisting of three structures: “if () (/**range over**/2, “/**flag on**” and “), the skeleton after changing the chart. The string existing on 13 is the reproduction skeleton 1B
(See FIG. 9) If the character string is also found above, the contents of the source code correspondence part 92 in the source code work file 17 corresponding to that character string are displayed in the difference information table 18, for example, line by line.
Copy it to the source code corresponding section 102 of. Next, the first
In Figure 0, the character string "1f()()(/**Test Execution**/") in line number 6, indicated by the code 108, or the line number, 10 characters, indicated by the code 103, "1f()()",
In the case of a character string (character) that is only available in the skeleton 18 after changing the chart, specific data indicating uncorrespondence, such as Set “-1”. Finally, a character string that exists in the reproduction skeleton 16 but does not exist in the skeleton 13 after changing the chart (
Characters), that is, character strings (characters) deleted from the original chart (this is not the case in this embodiment), are not reflected in the source code correspondence section 102 of the difference information table 18.

When the source generation support means 15 creates the difference information table 18, the source code correspondence section 10 in the same table 18
2, skeleton part 1 in the same table 18
Based on the chart-changed skeleton 13 (see Fig. 10) and the existing source code 14 (see Fig. 5) placed in 01, the source code 19 after the chart change is created (step S5 in Fig. 8). . The specific operation of creating this source file 119 is as follows.

First, the source generation support means 15 generates the difference information table 1.
The source code correspondence section 102 in 8 is sequentially referred to from the beginning. If data "-1" indicating unsupported data is detected, the structure of the corresponding row (row range) in the skeleton 13 after the chart change placed in the skeleton section 101 is assumed to have been added, and the source 0 source is generated. Support means 15 is skeleton 1 after changing the above chart.
The information of the corresponding line (line range) in 3 is written as it is to the source code after chart change (source code file) 19. In contrast, “−1” in the source code correspondence unit 102
If data other than `` is detected, the skeleton 13 after chart change that is paired with the row (row range) indicated by the data is detected.
The source generation support means 15 assumes that the structure of the lines (line range) within is unchanged (that is, not added).
The information in the existing source code 14 (see Figure 5) of the row (row range) indicated by the detected data is replaced with the structure of the corresponding row (row range) in the skeleton 18 after the chart change. I will write it on the 19th. After all, in the structure of the skeleton 13 after changing the chart, parts other than the structural information of the corresponding line (line range) of the existing source code 14 (conditional expressions in structure statements, arguments in function call statements, normal comment variable declaration lines) , detailed information such as assignment and issuance) will be automatically reflected (without manual editing).

From the above, in this embodiment, the chart-modified source code 19 as shown in FIG. 11 is created. That is, after the chart change on the skeleton section 101 shown in FIG. 10, the row yang, 6, and row no.
0 has no corresponding line in the existing source code 14 (see FIG. 5) and is an additional line, so the line Nα6 and the line No. of the skeleton 13 after the chart change.

The skeleton information of 10 is written as is to the source code 19. Also, lines Nos. 7 to 9 of the skeleton 13 after the chart change on the skeleton part 101 correspond to lines Nos. 5 to 7 of the existing source code 14, respectively.
The information in lines N095 to 7 of the source code 14 (see Figure 5) is code 11 in Figure 11 of the source code 19 (see Figure 5).
(the area surrounded by the dotted line frame indicated by 1). In this way, the corresponding part of the existing source code 14 is reflected in the unchanged part of the chart, so the conditional expression (here "a>-RH") and assignment statement (here "11m1
There is no need to manually edit and input detailed information such as t-1; "), and this is particularly effective when changing a chart with only a few additions. Note that the chart has been added to part 2 (additional line). Only the detailed information setting part (the part surrounded by the dotted line frame indicated by reference numeral 112 in FIG. 11) is manually edited and inputted as before, and the source code 19 after the chart change is is completed.

The above has been explained using the source code generation support process written in C language as an example, but the present invention can also be applied to various languages with control structures (FORTRAN, PL/M, BASIC, Pa5).
It can be applied to support source code generation for programs such as CAL, etc.

Furthermore, in the embodiment described above, the existing source code 14 was explained as the source code 25 created by manually editing the skeleton 23 created from the chart 1 and information 21 by the source generation means 22. For example, the chart-modified source code 19 generated by the source generation support tool 10 shown in FIG. 2 may be used. That is, in the present invention, when a program change occurs again after the source code I9 after chart change is generated by the source generation support tool 10,
Either the source code 25 (initial source code) or the source code 19 after chart change is the existing source code 1.
It can be used as 4.

In addition, in the above embodiment, the skeleton 13 after chart change
and playback skeleton 16 (source code work file 17
The description has been made of a case in which ordinary character string comparison techniques are used to detect additions, deletions, and unchanged structures by comparing the contents of the skeleton part 91 of the text without being aware of the structure.
String comparison may be performed for each structure or for each line. Furthermore, if detailed information is not to be subjected to character string comparison, it is not necessarily necessary to generate the playback skeleton 16, and additions and deletions can be made by comparing the skeleton 13 after changing the chart and the existing source code 14. and it is also possible to detect unchanged structures.

[Effects of the Invention] As detailed above, according to the present invention, when a program change occurs, the chart-changed skeleton (Template 4 rate source) generated from the chart after the change and the existing source code can be combined. By detecting the control structure parts that have not been changed, and reflecting the existing source code information corresponding to the control structure parts that have not been changed in the corresponding structure of the skeleton after the chart change, the skeleton after the chart change It is possible to efficiently generate source code after chart changes.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing an embodiment of a source generation support system for generating new source code from a changed chart using existing source code;
Figure 2 is a block diagram of a general source generation system for generating source code from charts, Figure 3 is a diagram showing a specific example of the chart indicated by the chart information 21 in Figure 2, and Figure 4 is a block diagram of a general source generation system for generating source code from charts. Figure 5 shows the skeleton (template source) corresponding to the chart in Figure 3, Figure 5 shows the source code generated using the skeleton in Figure 4, Figure 6 shows the chart after changing the chart in Figure 1. A diagram showing a specific example of the changed chart (for the 5 chart in FIG. 3) indicated by information 11,
FIG. 7 is a skeleton corresponding to the changed chart in FIG. 6, FIG. 8 is a flowchart for explaining the operation of the source generation support means shown in FIG. 1, and FIG. 9 is a skeleton corresponding to the changed chart in FIG. FIG. 10 is a diagram showing a specific example of a difference information table created by the source generation support means, and FIG. 11 is a chart created by the source generation support means. It is a figure which shows the specific example of the source code after a change. 10... Source generation support tool, 11... Chart information after chart change, 12.22... Source generation means, 13... Skeleton after chart change, 14... Existing source code, 15... Source generation support means, 1B
... Reproduction skeleton, 17... Source code work file, 18... Difference information table, 19... Source code after chart change, 21... Chart information,
23...Skeleton, 24...Editing means, 25...
·Source code.

Claims (2)

[Claims] (1) Based on a chart showing the processing flow of the program to be created, create a template source that shows the control structure of the above program, includes structural comments corresponding to the structure, and forms the skeleton of the source code of the above program. When a new template source is generated by the source generation means based on a chart that has been changed due to a program change, the source code that corresponds to the chart before the change and the previous source code that corresponds to the chart before the change. Based on the above new template source, a control structure with no differences is detected, including structural comments, and the chart is changed by reflecting the information in the corresponding control structure of the previous source code in the corresponding control structure of the same template source. A source generation support system comprising: source generation support means for generating subsequent source code; (2) The source generation support means generates a template source corresponding to the source code from the previous source code, and includes structural comments by comparing this template source and the new template source. 1. The method of claim 1, further comprising means for detecting a control structure having no difference and reflecting information in the corresponding control structure of the previous source code in the corresponding control structure of the new template source. Source generation support system described.