JPS62145424A - Program managing method - Google Patents

Abstract

PURPOSE:To save the time and labor for maintenance by generating a specification automatically when the source program is desired to be corrected and changed. CONSTITUTION:A terminal equipment 2 and a tablet 3 are used, the specification of the program is generated in a specification analysis system 21 by forming a processing graphic and variables on a table. Based on the generated specification, the source program is generated automatically by a program generating system 22. At the time of desiring it to correct or change, the source program is analyzed to correct the specification in the program analysis system 23 and the specification generation system 24.

Description

Detailed Description of the Invention (Industrial Application Field) This invention uses a computer connected to a storage device and an input/output device to integrate a source program and its specifications into one computer.
Regarding how to manage programs while maintaining one-to-one correspondence,
In particular, the present invention relates to a program management method that combines a method of automatically generating a source program and a method of automatically generating a program specification.

(Conventional techniques and their problems) Conventionally, as a method for automatically generating source programs,
For example, there is a method for automatically generating diagrams and source programs as shown in f7U in Japanese Patent Application Laid-open No. 159939/1982. In this method, first, a module relationship diagram (a diagram showing the connection relationships between each program module) is created using an interactive display terminal, and then a processing flow diagram (a type of processing flowchart) and an internal data definition diagram (
Create a diagram that specifies the format of data used in each process) and an interface data definition diagram (a diagram that specifies the format of arguments, common data between modules, etc.), and save their contents to a file. accumulate. Then, for each module, module relationship diagram, processing flow diagram,
Read each diagram information of internal data definition diagram and interface data definition diagram from the file, add standard sentences and symbols to generate individual sentences of the source program, and then edit these sentences according to the rules of the language. and completed the source program.

However, with the above method, it is necessary to create four types of diagrams: a module relationship diagram, a process flow diagram, an internal data definition diagram, and an interface definition diagram, which requires input time when creating one program and makes it difficult to manage specifications. It's complicated. Furthermore, program generation is divided into two stages: generation of a source program and editing thereof, making the generation process complicated and also time-consuming.

When automatically generating a source program, a person must first input the program specifications, but if this input method is complex, it will take a considerable amount of time to automatically generate the program, and it will take some skill to use it. As a result, the effectiveness of automation in improving the efficiency of source program creation work tends to be diminished.

Furthermore, in general, after the ConviewTab 1 cogram is created, it is common for some parts to be abolished or changed due to some circumstances (for example, the existence of a bug or modification of the system). In many cases, the source program itself is modified or changed, so at this point the correspondence between the specifications and the source program breaks down, and this becomes a reversal.
The specifications you originally created will no longer have any meaning. When attempting to carry out maintenance such as system modification in such a state, the work must begin with decoding the source program, which significantly impairs work efficiency.

An example of a technique for solving such problems and integrating specifications and programs is given in the literature [Hitachi Review VOL66, N
(16 (1984-6), automatic program generation system "SDL/PAD" J, in which, in addition to the automatic diagram/source program generation method of JP-A-60-159939, the reverse method is also disclosed. This book outlines a system that automatically generates module hierarchy diagrams, module input/output diagrams, module processing overview diagrams, and module processing details/internal data relationship diagrams from completed source programs.In other words, according to this system, , When a source program is terminated or changed, a specification document corresponding to the previous or changed source program is automatically generated.
It always maintains the correspondence between specifications and programs, making program management easier. However, in the program management method using this system, four types of diagrams are required, similar to the above-mentioned "diagram/source program automatic generation method," and there are many types of specifications. When modifying, four types of diagrams must be referred to frequently.For this reason, no more than a certain degree of effect can be expected in terms of reducing the time and labor required for program maintenance.

(Object of the Invention) In view of the problems of the prior art described above, an object of the present invention is to provide a program management method that further facilitates automatic generation and maintenance of source programs.

(Means for Achieving the Object) In order to achieve the above object, in the source program management method according to the present invention, when automatically generating a source program, processing diagram data and variable table data are first input for each compilation unit from an input device. are input with the same identification name, and these are stored and accumulated in the storage device. The processing diagram expresses the theoretical flow of processing by the connection relationship of figures whose meanings are defined in advance and the descriptive characters in the figures, and the processing diagram data is the data of the identification name and the shape of the figure. , the data of the descriptive characters in the figure, and the data of the connection relationship. Further, the variable table is used to define the types and types of variables used within the corresponding processing diagram. Subsequently, a desired identification name is inputted from the input device, and the processing diagram data and variable table data of the identification name are called from the storage device to generate a source program, which is stored in the storage device using the same identification name. The generation of this source program involves converting the shape data and descriptive character data within the shape for each shape one by one into source program data according to the connection order represented by the connection relationship data, and then converting the shape data and the character data described within the shape into source program data, and then assigning the predetermined variable declaration positions according to the programming language to be used. And at the position where the type of the variable is specified, this is done by converting the data of the relevant variable in the variable table into source program data. Next, when automatically generating a program specification, the desired identification name is input from the input device, the source program is retrieved from the storage device, and it is analyzed according to the rules of the programming language in which the source program is written. By doing so, the data of the source program is converted into the processing diagram data and the variable table data. Then, if necessary, the output device outputs, for example, a hard copy of the source program program using the source program data, and outputs, for example, a hard copy of the processing diagram and variable table using the processing diagram data and variable table data. I am trying to output a copy.

(Embodiment) FIG. 1 is a block diagram showing an example of a computer system for implementing a program management method according to the present invention. A series of data processing necessary for automatically generating a source program and automatically generating a program specification is executed in the computer 1 according to a predetermined processing procedure.

The operator accesses the computer 1 via the interactive display terminal 2.
In addition to being able to communicate interactively (inputting and outputting data) with the computer 1, the tablet 3 can be used to input required data into the computer 1. Of the data input from the terminal 2 and tablet 3, data regarding program specifications and variable tables, as well as automatically generated source programs, are stored and accumulated in an external hard disk device 4 connected to the computer 1. In addition, operators can output hard copies of created source programs and specifications as needed.
Output devices of a printer 5 and a plotter 6 are connected to the computer 1.

FIG. 2 is an explanatory diagram showing a system configuration for implementing the method according to the present invention. To explain the outline of this method using Figure 2, the operator first uses terminal 2 and tablet 3 to create a table of the processing diagram and the definitions of variables used therein as program specification 1. . This function is the specification analysis system 21, and its contents are shown in Figure 3.
They are an AD editor 7 and a variable table editor 8. These details are shown in FIGS. 5 and 10, respectively. Next, a program generation system 22 has a function of automatically generating a source program based on the created specifications, and its contents are the C program generator 9 shown in FIG. Details of this are shown in FIG. At this stage, the source program is completed, but if it is modified or changed, it will no longer correspond to the specifications. The functions for analyzing the source program and modifying the specifications are the program analysis system 23 and the specifications generation system 24, and the details of this process are shown in FIG. 19.

The automatic source program generation process is performed using the PAD editor 7, variable table editor 8. and a C program generator 9.

When this management program is loaded (Sl), an initial screen 10 as shown in FIG. 4 is displayed on the CRT display screen of the terminal 2. That is, along with an instruction message for tool selection, a menu, (1) PAD editor, and (2) variable table editor.

(3) C program generator and (4) End are displayed, and the operator inputs commands from the keyboard of terminal 2 and selects the necessary tool (82.83).

In processing in the PAD editor 7, the operator uses the terminal 2 and tablet 3 to input processing diagram data by assigning an identification name to each compilation unit, and this data is stored and accumulated in the hard disk device 4. In addition, in the processing in the variable and table editor 7, the operator uses the terminal 2 and tablet 3 to input variable table data that defines the types and types of variables used in the processing diagram for each compilation unit, the same as the processing diagram. This data is inputted with an identification name, and is stored and accumulated in the hard disk drive 4 in the same way as the processing diagram data described above. When selecting the C program generator 9, the operator inputs a desired identification name from the terminal 2, and in response, the processing diagram data and variable table data of the identification name are called from the hard disk drive 4. A source program is generated using these two files.

FIG. 5 is a flowchart showing in detail the processing in the PAD editor 7. On the initial screen 10 in Figure 4 (
1) When the PAD editor is selected, the system asks for the module name as a start procedure (S4). Here, the module name is the name of the source program to be created, and a compilation unit is treated as one module. At this time, for example, if "@5cttable" is input as the module name from the terminal 2, a display as shown in FIG. 7 will appear on the CRT display of the terminal 2. If the file "@5ettable" is already stored in the hard disk device 4, the function of the "lo d" command, which will be described later, is automatically activated and the file is loaded (S5).

Thereafter, the operator creates or modifies the processing diagram of "@5ettable" by interacting with the computer 1. Here, the processing diagram may be any one that can express the theoretical flow of processing using the connection relationship of figures whose meanings are defined in advance and descriptive characters within the figures, such as the well-known PAD. is used in this example.

PAD expresses the flow of processing by connecting three types of blocks. A simple rectangular block represents sequential processing, and a block with a notch at the right end of the rectangle connects to the upper right or lower right corner depending on the selection condition. A block with a vertical line at the right end of the rectangle indicates that the processing of the block connected to the right side is repeated. For example, in blocks 2 to 9 of the PAD processing diagram in FIG. 18 (△), "z = x
If the condition rZ>OJ is satisfied after performing the process ``:l:y'', processes 5 and 6 are repeated n times, and if the condition rZ>OJ is not satisfied, processes 8 and 9 are This indicates that the process of number is repeatedly executed while rZ<OJ.

The processing diagram is created or modified using the terminal 2 and the tablet 3. A menu as shown in Figure 6 is displayed on the left end of the screen of the CRT display of terminal 2.
The operator runs the stylus pen on the surface of the tablet 3 to move the cursor on the CRT screen, and selects the menu at the cursor position by pressing the stylus pen (86.87). For example, in addition to the above-mentioned "lod" (load data), commands include "ad".
d” (add diagram), “chg” (change sentences in diagram)
, °“cjeloo (delete diagram), “end” (end), “out” (plotter output), “ren” (renumber), “sav” (save data), wnd” (window (m-plane display) There are changes in areas), and processes 88 to 815 are sequentially executed while selecting these as appropriate. bs”
is a backspace, which moves the cursor back one space and deletes that character, etc., and "ret" indicates a return. In addition, the above three types of blocks in PAD are prepared as menus 11, 12, and 13, and Define (Define) for defining long sentences in another location is also available.
e) A block 14 is prepared below it. Menus 15 and 16 are for displaying the start and end marks of the processing diagram, respectively.

When the display shown in Figure 7 appears on both sides of the CRT of terminal 2,
If you select 'a d d' from the menu shown in Figure 6, select point 17 at the addition location with the cursor, and then select menu 15, the display on the CRT screen will become as shown in Figure 8. add”, select point 18 below the start mark as the additional point, and select P in menu 11.
Select AD diagram and process content "z = x * y
” from the keyboard of terminal 2. Then, the CRT
The display on the screen will be as shown in FIG. In this way,
To add, select “add” and select the point you want to add ゛・°°
, select the PAD diagram you want to add, and then type in the content to be added to it using the keyboard.By repeating this process, you can convert the theoretical flow of processing into a diagram. After completing the diagramming of the process, select "a d d" and select the last point 19 of the process flow (see Figure 18 (A)).
Select , select menu 16 and add an end mark.

By the above operations, a completed PAD diagram as shown in FIG. 18(A) is created.

Once the PAD diagram created in this way is displayed in the menu “
Select "sav" and save it on the hard disk drive 4. At this time, as the data of this PAD diagram, at least data representing the module name (save with the file name "module name, tiata", for example "@5ettable, data" in the above example),
Data representing the shape of the figure, data representing descriptive characters within the figure, and data representing the connection relationship between the figures are stored. Then select "end'" from the menu and click "Fl"!
After 815, PAD editing 7 ends. At this time, the CRT screen of the terminal 2 returns to the initial screen 10 in FIG.

FIG. 10 is a flowchart showing in detail the processing in the variable table editor 8. Initial screen 10 in Figure 4
(2) When you select the variable table editor, the system will ask you for the module name as a start procedure (816), so enter the same module name as the corresponding PAD diagram.
h. For example, if you want to create a variable table that defines the types and types of variables used in the above PAD diagram,
゛.

5ettable". If a variable table with the input name lζ is already in the hard disk drive 4, that file is loaded (S17); if not, a new file is created. When creating a new file, A display like the one shown in Figure 11 appears on the CRT screen. Also, the message displayed on this CRT (
a (add variable), c (change variable), d (delete variable), e (end).

k (print, output), 1 (load variable table),
S<Save variable table)), select the appropriate menu with the keyboard (318, 519), add variables (820), delete variables (321), change variables (8
22), Printer output of variable table (823>, Save variable table (S24), Load variable table (S
25> and the termination procedure (S26) are executed sequentially.

To create a table, first select "a" from the menu on the CRT screen. Then, the system displays a menu similar to that shown in Figure 4, and the type of variable is (1) Q.
lobal (global variable) or (21exter
nal (external variable) or (3) 1internal
(internal variable). Then, when you select (1) using the keyboard of terminal 2, the system displays a similar menu and displays whether the variable type is (1) integer (integer type), (2Hloat (real number type), or (3) c
It will ask you if it is a haracter (character type). Select (3) here and press "s str [" from the keyboard.
200], the display on the CRT screen will be the first
The result will be as shown in Figure 2.

Next, select a from the menu and select (2) external
and then select (1) 1ntcocr/υ”
n”, (2) Select float and type “x” and “y” respectively from the keyboard. Then, the display on the CRT screen will become as shown in Figure 13. In this way,
To add, select a'', select the type and type of variable you want to add, and then type in the variable you want to add from the keyboard. Repeat this process to create a variable table.

Then, a complete variable table as shown in FIG. 18(B) is completed.

Once the data in the variable table created in this way is
Select menu "S" and save on the hard disk device 4. At this time, the file name is ゛module name,
var” (in the above example “@5ettab+
e, var”). Then, menu 11
eII is selected and the variable table editor 8 is terminated through process 826. At this point, the CRT screen of the terminal 2 returns to the initial screen shown in FIG.

As described above, after creating the program specifications 1 (PAD diagram and variable table) and storing these data in the hard disk drive@4, a source program is automatically generated according to the C program generator 9. Note that although an example of programming in the C language is described below, the invention can be similarly applied to other languages such as FORTRAN.

FIG. 14 is a flowchart showing details of the processing in the C program generator 9. On the initial screen 10 in Figure 4, select (3) C program generator;
The system asks for the module name as part of the initiation procedure (327). When you input the desired module name for which you want to generate a source program, the system automatically calls the PAD diagram file and variable table file with the same module name from the hard disk drive 4 and loads them (828.829). . At this time, terminal 2
The display shown in FIG. 15 appears on the CRT screen.

The underlined part is the operator's input part, and the others are system messages. The source program automatically generated by subsequent processing will be saved with the file name ``module name, C'', but if the same file name already exists, the file name will be automatically changed to puff file name, ``bkp''. .

The backup message in FIG. 15 is for displaying this.

Next, a message to start generation (GEN[It8 to EST ST8 to IT) is displayed on the CRT screen of terminal 2 (3
30), a source program generation process in C language is performed (83go). At this time, the generated source programs are sequentially displayed on the CRT screen.

When the source program generation is completed, the CRT
On the screen is a message indicating the completion of generation (C0HPLETE)
is displayed, and the generated source program is saved in the hard disk drive 4 with the file name "Module name, C", and the processing by the C program generator 9 is ended (832). At this time, the CRT screen of terminal 2 is
Return to the initial screen shown in Figure 4.

In the C program generation process S31, as shown in FIG. 16, the figure shape data and the data of descriptive characters within the figure are generated into a source program for each figure one by one according to the connection order of data representing the connection relationship between figures in the PAD diagram data. By converting it into data (333), a source program with 08 words is generated. This process is repeated until the conversion operation for all PAD graphic data is completed (S34). At this time, at a predetermined variable declaration position and a position where a variable type is specified in the C language source program, the data of the corresponding variable in the variable table is referenced and converted to source program data, and the above generated data is converted to source program data. Insert it into the source program data.

Figure 17 shows the module name created as described above.
When generating a C source program from the PAD diagram and variable table of ``@5ettab18'',
7 is a flowchart showing a detailed example of program generation processing 831; At this time, as shown in Figure 18, (
From the PAD diagram of A> and the variable table of (B), (C
) source program is generated. Processing 835, 83
7.839 converts the variable table data into source program data, and performs other processing 835. In S37°540-852, the PAD diagram data is analyzed for each figure and converted into source program data, and the variable table is also referred to as necessary. A complete C language source program is automatically generated by such an algorithm. A hard copy of this source program can be output from the printer 5, for example.

As described above, according to the source program automatic generation Ia function of the present invention, a source program can be automatically generated very easily by simply creating a PAD diagram of the content to be processed and a table of variables used therein. can. However, if the source program generated in this way is modified or changed, for example due to the presence of a bug or system modification, the correspondence between the program specification m (PAD diagram and variable table) and the source program may be lost. be exposed. In order to effectively avoid this, the program management method according to the present invention automatically generates a program specification! It is equipped with the ability to automatically generate PAD diagrams and variable tables from modified or changed source programs, and to always maintain the correspondence between the PAD diagrams and variable tables and the source program. . Furthermore, the present invention is not limited to this, and the program specification automatic generation function can be used generally when a completed source program exists and a specification corresponding to this source program is desired.

FIG. 19 is a flowchart showing in detail the processing procedure when automatically generating a program specification using the apparatus shown in FIG. This process can be performed, for example, using the PAD editor 7 mentioned above.
, variable table editor 8゜A program prepared in advance as a tool similar to the C program generator 9°“
The operator proceeds with the process in an interactive manner with the computer 1 using the terminal 2, as in the case of automatic generation of a source program.

When the PAD diagram generator is executed, as a start procedure (853), the system asks for the file name of the source program to create a specification. For example, the automatically generated source program above, Ram “@5ettable,”
c'' has been partially changed and the changed version is stored in the hard disk drive 4, and if the operator wants the corresponding specifications, he inputs ``@5ettab+e'' from the keyboard of the terminal 2. As a result, the system retrieves the data of the corresponding C language source program from the hard disk drive W14 and loads it (35
4).

Note that the present invention is also applicable to programming languages other than the C language, as in the case of automatic source program generation described above. In addition, the PAD diagram and variable chiruba that will be automatically generated by the subsequent processing, respectively.
@5ettable, data ” and ' @5e
It is saved with the file name ``table, var'', but
If the same file name already exists, you can either change the file name (for example, automatically change it to ``file name, bk p'', like the file name of Moe's source program), or delete the file. The system is given a judgment in advance that the old file name is acceptable.The system changes or deletes the old file name accordingly.

Next, a generation start message (G[NEI?ATE 5TART) is displayed on the CRT screen of terminal 2 (S5
5) A PAD diagram and variable table generation process is performed (356). In this process 856, the above process 8
By analyzing the source program loaded in 54 line by line according to the rules of the programming language (CTa language in this case) in which the source program is written,
The data of the source program is converted one by one into data of a processing diagram (PAD in this case) representing the specifications of the source program and data of a variable table. As mentioned above, a processing diagram expresses the theoretical flow of processing by the connection relationship of figures whose meanings are defined and the descriptive characters in the figures, and therefore the processing diagram after the above conversion. The data includes at least data representing the graphic shape, data representing the descriptive characters within the graphic, and data representing the connection relationship. Furthermore, as mentioned above, the variable table defines the types and types of variables used in the source program, so the variable table data after the conversion includes at least the data representing the types of variables and the types of variables used in the source program. Contains data representing the type.

When the generation of the variable table is completed, the CR of terminal 2
7 On the screen is ' 5AVING module name, Va.
rjj" is displayed, and when the PAD diagram generation is completed, "5AVING module name, data! !
” will be displayed. For example, in the above example, ” will be displayed.
5AVING @ 5ettable, var!
! ” and '5AVING@5ettable,
data! ! ” will be displayed.

Simultaneously with these displays, the system sequentially saves the generated variable tables or PAD diagram files in the hard disk drive 4, and all generation (that is, analysis and data conversion of all lines of the C program statement loaded in step S54) is performed. When finished, a generation completion message (C
0HPLETE) is displayed on the CR7 screen of terminal 2, and the processing by the PAD diagram generator is ended (85
7. ).

In the PAD diagram and variable table generation process 856, the 20th
As shown in the figure, a C program statement is analyzed line by line according to the rules of the C language, and if the program data represents the definition of a variable, the program data is converted to the corresponding variable table data, and the processing details are If the data represents , the program data is converted into corresponding PAD diagram data (858), thereby generating a PAD diagram and a variable table. This process 858 is repeated until conversion of all C program data is completed (359).

FIG. 21 shows PAD diagram and variable table generation processing 856.
This is a flowchart without showing a specific example.

Here, from the source program in FIG. 22(A), the P to O diagram in FIG. 22(B) and the variable table in FIG. 22(C) are generated. The source program in FIG. 22(A) is the source program in FIG. 18(C) (file name "
@ 5ettablc, c”), and this time, P corresponding to the changed source program.
This is an attempt to automatically generate an AD diagram and a variable table. Processes S60 and S62.364 convert the data of the program statement that declares variables into variable table data J3, and other processes 361, 363.865 to
In step 378, the data of the program statement representing the content of the α-beat is converted into data of the PAD diagram. Using such an algorithm, a specification m (PAD diagram and variable table) representing the specifications of a completed source program is automatically generated. The operator can then output the automatically generated specifications as a hard copy from the printer 5 and plotter 6 as needed, making it easy to program while always maintaining the correspondence between the source program and the specifications. It becomes possible to make improvements.

In addition, in the above explanation, the well-known P
Although the embodiment using C language as the AD and source program language has been described in detail, the present invention can be similarly applied to other processing diagrams and programming languages, and in this case, the above-mentioned embodiment can also be applied. Similar effect to Qin.

(Effects of the Invention) As explained above, according to the present invention, a source program can be automatically generated by simply inputting a diagram representing the content of processing as a program specification and a table of variables used therein. Since the above specifications can be automatically generated when modifications or changes are made, programs can be easily modified by reviewing only the processing diagram and variable table, significantly reducing the time and effort previously spent on maintenance. It becomes possible to aim for.

[Brief explanation of drawings]

Fig. 1 is a block diagram showing an example of a computer system for implementing the present invention, Fig. 2 is an explanatory diagram showing a system configuration for implementing the invention, and Fig. 3 is an overview of the entire automatic source program generation process. Flowcharts illustrating the outline, FIGS. 4 and 6. 7, 8, 9, 11, and 12. Figures 13 and 15 are explanatory diagrams of the screen display, and Figure 5 is the PA
A flowchart of the processing in the D editor, FIG. 10 is a 70-chip diagram of the processing in the variable table editor,
Figures 14, 16, and 17 are flowcharts of processing in the C program generator, and Figure 18 is a PAD
An explanatory diagram showing an example of a diagram, a variable table, and a C language source program generated from these; Figures 19, 20, and 21 are flowcharts showing the program specification automatic generation process; Figure 22 is a C75 language source program. Source program and PAD diagram generated from it. It is an explanatory diagram showing an example of a variable table.

Claims (1)

[Claims] (1) A method of managing programs by making a one-to-one correspondence between source programs and their specifications using a computer connected to a storage device and an input/output device, and a method of automatically generating source programs. This method consists of a combination with a method of automatically generating a program specification, and the method of automatically generating a source program includes inputting processing diagram data from the input device with an identification name assigned to each compilation unit, and storing the data in the storage device. The processing diagram represents the theoretical flow of the process by the connection relationship of figures whose meanings are defined in advance and the descriptive characters in the figures, and the processing diagram data includes a step of storing the memory. including data of the identification name, data of the figure shape, data of the descriptive characters in the figure, and data of the connection relationship, and for defining the types and types of variables used in the processing diagram from the input device. inputting the data of the variable table with the same identification name as the corresponding processing diagram for each compilation unit, and storing and accumulating this in the storage device; inputting a desired identification name from the input device; generating a source program by calling the processing diagram data and variable table data of the identification name from a storage device, and storing the source program in the storage device using the same identification name; , converting the shape data and descriptive character data in the shape for each shape into source program data one by one according to the connection order represented by the connection relationship data, and specifying the predetermined variable declaration position and variable type according to the programming language to be used. This is done by converting the data of the relevant variables in the variable table into source program data, and the method for automatically generating the specifications includes inputting a desired identification name from the input device and inputting it to the storage device. extracting the source program with the identified name from , and converting the data of the source program into the processing diagram data and the variable table data by analyzing it according to the rules of the programming language in which the source program is written; A program management method, comprising: outputting the source program from the output device using the source program data, and outputting the processing scheme and variable table using the processing scheme data and variable table data. .