JPH01191233A - Automatic program generating system - Google Patents

Abstract

PURPOSE:To prevent an error from going in at the time of maintenance and extension work by registering in advance a model (parts pattern) of a program, bringing a macro part in the parts pattern to replacement (macro expansion) by an actual processing object name, a data type, etc., and deforming it to the program. CONSTITUTION:By the title system, a parts pattern in which data (processing object information) and a procedure are related to each other can be registered, and also, in order to generate automatically a program for handling the data of a complicated structure, a program for handling the data of a more complicated structure is synthesized from a program for handling the data of a simple structure, based on a type constituent parts pattern. By forming a pair by the processing object information and a procedure thereto, and limiting an operation to the processing object information, for allowing such errors as the processing object information is rewritten in an unexpected place, a reference and updating are executed by an unappropriate method, to go in at the time of maintenance and extension is decreased.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a method of supporting computer program development using a calculation processing system.

[Conventional technology]

For example, Hitachi Review Vo 1.68°Nn5. r
There is an EAGLE parts library management function as described in the system development support software "EAGLE".

[Problem that the invention seeks to solve]

In the conventional example above, a program is generated by using component prototypes (called "program patterns" in the conventional example) classified by major functions such as "merging" and "aligning" and combining them with separately prepared data definitions. ing. Therefore, data (information to be processed) and procedures become independent program components, resulting in poor understandability and problems in that changes are scattered during maintenance and expansion. As a result, maintenance and maintenance errors such as updating or referencing data in inconsistent ways can occur.
It was easy to get into during expansion work.

[Means for solving problems]

In order to solve the above problem, we have made it possible to register part prototypes in which data (processing target information) and procedures are related. In addition, in order to automatically generate a program that handles data with a complex structure, it is also a means of synthesizing a program that handles data with a simple structure into a program that handles data with a more complex structure based on the mold constructor part prototype. gave.

Here, the above-mentioned "component model" refers to a template of a program in which processing object names, data types, etc. are converted into macros. In addition, "mold constructor parts prototype" is used to convert the constituent elements of processing target data into macros, and also in procedures for manipulating processing target data.
A part prototype that is a macro version of the part that should be used to manipulate the component.

[Effect]

By pairing the processing target information with the corresponding procedures and limiting the operations on the processing target information, it is possible to prevent the processing target information from being rewritten unexpectedly or being referenced or updated in an inappropriate manner. There is less room for errors to enter during maintenance and expansion. However, it is not possible to easily generate a program that handles data with a complex structure using only such program parts. It is possible to provide a means for synthesizing a program that handles data with a simple structure to a program that handles data with a more complex structure based on the mold constructor part prototype.

〔Example〕

The automatic program generation method according to the present invention is shown below in Figures 1 and 1.
Figure 2 shows a typical example of the usage of the present invention.

In FIG. 2, 21 is an input/output device for giving instructions necessary for parts generation and displaying the processing status, 22 is a processing device, and 23 is a memory for storing the part model. The device 24 is a storage device for outputting the generated program parts.

FIG. 6 is a diagram showing a typical example of generating a program using the automatic program generation method, and FIG. 3 is a diagram showing the flow of processing for automatic program generation.

In the example of FIG. 6, the program creator's instructions for transforming the part model are given by specifying the name of the part model and the value of the macro appearing in the part model from the input/output device 21, as shown in 10. It will be done.

FIG. 4 shows the detailed process flow of generation parameter acquisition (31). Further, FIG. 5 shows a screen for obtaining generation parameters.

The generation parameters are specifically given in the form of macro values, but some or all of them can be saved in advance in a file (hereinafter referred to as a "generation parameter file"), and the generation parameter file can also be used. Typically, when trying to generate multiple parts, it can be used to save the effort of inputting macro values that should be commonly given each time. If a generation parameter file is specified, it is referenced (41).

Next, examine the specified part file and create a list of required macros. At this time, if there are known macro values, they are filled in and displayed on the screen in the format shown in Figure 5, prompting users to specify macro values that are not yet filled in (42, 4).
4).

After inputting the macro value, it is checked for validity and if it is correct, it is entered in the macro list. Validity checks are, for example,
For example, eliminating special characters that are not allowed in the programming language.

By repeating the processes 44 and 45 until all macro values are filled (43), the acquisition of the generation parameters 31 is completed.

When generation parameter acquisition is completed, the part prototype file is read (33), macros are replaced, and the result is output to a file (34).

In a typical example, a part in the format of "$(<macro name>)" in the part model is a macro, as shown in 11 of FIG. This part is replaced according to the macro table created by acquiring the generation parameters. Also, in the above example,
The @ word starting with "%" indicates the nodes that make up the part model.

Although the clause will be described later, the key word does not remain in the generated program.

The embodiments of the automatic program generation method according to claim 1 have been described above.

In the automatic program generation method, as described above, it is necessary to prepare a component model in advance.

Next, the configuration of the part prototype will be described. Typically, a part prototype consists of several clauses and a type constructor description.

The target clause is the part where the data or type declaration corresponding to the information to be processed by the program is written. The procedure section is the part of the actual processing description.

FIG. 1 shows how a program is generated using a mold constructor part model and a base part model.

In FIG. 1, 201 shows a mold constructor part model, and 202 shows a base part model. Also, 203 is 201 and 202
This is a program generated based on .

As shown in Figure 1, the generation system includes normal macro expansion,
Two "%typecons" of mold tank Seiko parts model 201
Embed an appropriate part of the base component prototype in the "t" part. However, the part that describes the format for calling a procedure in the base component prototype is expanded to the format for calling a -degree procedure, and then,
Expand the procedure inline.

FIG. 7 shows an example of a mold component part model, and FIG. 8 shows an example of a base part model. Moreover, FIG. 9 shows an example of generation parameters for generating a program using these parts prototypes. FIG. 10 shows the generated program.

The mold constructor part model has a configuration as shown in FIG. The target clause describes the declaration of the data to be processed, but some of the elements that make up the data are simply written as "%typeconst" without indicating their specific form.The procedure clause contains the following:
The procedure for manipulating the data to be processed described in the target section is described, but in the part that manipulates the element marked "%typeconst", the format for calling the procedure in the base component prototype that manipulates the element is described.

The base part prototype has a configuration as shown in FIG.

In the target clause, variables are declared in the format used when embedded as an element of data with a more complex structure. A typical example is how to write the variable as an element of a structure. The procedure clause describes a procedure that receives as an argument a variable of the same type as the one described in the target clause.

When generation parameters as shown in FIG. 9 are given, the generation system first searches for a part prototype called "Frame"' according to the description in 91. In the part model shown in FIG. 7, 75 declares the part model name, and since this name matches the name "Frame", the generation system starts the generation process based on this.

71 is "%typeconst" in the target clause.Then, the search for the base part prototype begins.92゜93
is the specification of the name of the base part prototype. On the other hand, 2 in Figure 8
The two base part prototypes are "5TRING" and "P", respectively.
The name “O8ITION” is 81.82
From the description of Therefore, the contents (83, 84) of the target clauses of these two base component prototypes are sequentially embedded in 71. At this time, the generation parameter for the base part prototype is 95
．． 96 shall be adopted.

72 is "%typeconst" in the procedure clause.

Procedure call statements are generated sequentially for the two base component prototypes. In 72, “$ $ (OBJ)
" is an instruction to preferentially use the macro value given to the base part prototype in macro expansion. Therefore, 72 is " text-clear(sp
ctbl [i], text); ”,” p
position-clear(spctbl [ico,
position);''.As it is a procedure call statement, it is necessary to create a program that will be called and perform the actual processing, but instead, add a macro to the corresponding procedure (85, 86) of the base component prototype. Inline expands the expanded program.

The same is true for 73, but since this is specified as a part within the repetition by 11% 1oop'' of 74, the two base part prototypes are developed separately.

Through the above processing, the program shown in FIG. 10 is generated.

101 is generated based on 76 in FIG.
const" has been replaced with 83.84 of the base part prototype. Also, 102 is generated based on 77, and 103 and 104 are generated based on 78. Of 77,
The portion 72 is developed as 105 and 106 as a result of inline development based on the base component model. Similarly, the part 73 becomes 103.104.

As described above, this embodiment has the advantage that a program that handles data with a complex structure can be easily synthesized from a program that handles data with a simple structure.

〔Effect of the invention〕

According to the present invention, it is possible to automatically generate a program that has high understandability, maintainability, and reliability and can be used without manual modification, thereby significantly improving software productivity. Additionally, programs that handle data with complex structures can be easily and automatically generated.

[Brief explanation of the drawing]

FIG. 1 is an explanatory diagram showing how a program is generated using a mold constructor part model and a base part model in an embodiment of the present invention. FIG. 2 is a block diagram showing the configuration of an apparatus for implementing the present invention. FIG. 3 is a diagram showing the flow of processing for automatic program generation. FIG. 4 is a diagram showing a detailed process flow for obtaining generation parameters. FIG. 5 is a diagram showing a screen for obtaining generation parameters. FIG. 6 is an explanatory diagram showing a typical example of generating a program using an automatic program generation system. FIG. 7 is an illustrative diagram of a mold constructor part model, and FIG. 8 is an illustrative diagram of a base part model. FIG. 9 is an exemplary diagram of generation parameters for generating a program using the part prototypes of FIGS. 7 and 8. FIG. 10 is an exemplary diagram of a program generated based on FIGS. 7, 8, and 9. 21... Input/output device, 22... Processing device, 23...
- Storage device (parts prototype library), 24...Storage device (program parts output), 201...Mold constructor parts model, 202...Base part model, 203...201
and labor/fil 1' rabbit (Yukai 1 figure ("fil1m parishioner's house) (↓ big vulgar pa) figure 9 figure 2 figure 2 figure 5 figure 3 figure 4 figure 7 figure 5

Claims (1)

[Claims] 1. In a system that supports computer program development using a calculation processing system, a program template (hereinafter referred to as a "parts prototype") in which processing object names, data types, etc. are converted into macros is registered in advance. It is characterized by having means for transforming it into a program by replacing the macro part in the part prototype with the actual processing target name, data type, etc. (hereinafter referred to as "macro expansion") according to the instructions of the program creator. Automatic program generation method. 2. A part prototype (hereinafter referred to as "part prototype") that declares the data to be processed in a format for embedding it as an element of data with a more complex structure, and describes a procedure for receiving and processing data of the same type as the data to be processed as an argument. There is also a function to register a "base part model") and a procedure for converting the constituent elements of the processing target data into macros and manipulating the processing target data.
There is a function to register a part prototype (hereinafter referred to as "mold constructor part model") that is a macro of the part that should be operated on the component, and a function to embed the contents of the base part prototype into the mold constructor part prototype at the same time as macro expansion, and to inline By having the expansion function, when generating a program based on a mold constructor part model, you can specify the base part model to be embedded in the component part to be processed, allowing programs to handle data with complex structures. The automatic program generation method according to claim 1, wherein the program can be automatically generated.