JPH02148136A - System for automatically determining program parts - Google Patents

Abstract

PURPOSE:To automatically generate a post-generation skeleton by preparing a pre-generation skeleton with the input/output processing as a variable name and building parts, file names, etc., from the external into this skeleton to generate the skeleton. CONSTITUTION:A pre-generation skeleton 1 with the input/output processing as the variable name and external parts corresponding to this variable name are preliminarily prepared. Pertinent parts are built into the skeleton in accordance with a skeleton exit name, an access method, a file name, a file organization, etc., given from the external, thereby generating a post-generation skeleton 6. Thus, the number of pre-skeletons 1 is reduced to automatically generate the post-generation skeleton 6, and the burden on a user is reduced and operation and management are facilitated.

Description

[Detailed Description of the Invention] [Summary] Regarding an automatic determination method that automatically determines program parts for input/output processing, a pre-generation skeleton is prepared with input/output processing as a variable name,
The purpose of this is to generate a skeleton by incorporating parts and file names from the outside, reduce the number of skeletons before generation, reduce the burden on users, and facilitate operation and management. A pre-generation skeleton in which the processing required for this is given in advance as a variable name, a parts determination table in which information for determining the component ID etc. corresponding to the variable name of this pre-generation skeleton is stored in advance, and the above-mentioned pre-generation skeleton. For variable names, the system is equipped with a component determination mechanism that determines the corresponding component ID by referring to the component determination table in response to input information such as skeleton exit name, processing method (order, random), etc. The variable name of the pre-generation skeleton is replaced by a component ID determined by the component determination mechanism by referring to the component determination table, and is also replaced by a file name of input information.

(Industrial Application Field) The present invention relates to an automatic determination method for automatically determining program parts for input/output processing.With the automation of software production in recent years, it is desired to improve the automatic generation rate of programs. .

[Conventional technology]

In conventional program synthesis, various skeletons are prepared in advance depending on the organization of input/output files, access methods, etc.
One winning skeleton was selected from among these.

[Problems to be Solved by the Invention] Therefore, there is a problem in that it takes a long time for the user to search for a desired skeleton from among many skeletons. In addition, the number of skeletons has increased, and operational and
There was also the problem that it was difficult to manage.

The present invention prepares a pre-generation skeleton with input/output processing as a variable name, and generates a skeleton by incorporating parts and file names from the outside into this, thereby reducing the number of pre-generation skeletons and reducing the burden on the user. The purpose is to reduce the number of problems and facilitate operation and management.

[Means to solve problems]

FIG. 1 shows a basic configuration diagram of the present invention.

In FIG. 1, a pre-generation skeleton 1 is a skeleton that serves as a template in which processes necessary for input/output processing are described in advance using variable names.

Program overview manual screen 2 is a screen for inputting input information such as skeleton exit name, file name, file organization, and access method.

The component determination mechanism 3 refers to the component determination table 4 and determines the component ID of the program component corresponding to the variable name in the skeleton 1 before generation.

The automatic embedding device 5 automatically incorporates the part rD determined by the part determination mechanism 3, the file name of the input information input from the program overview manual screen 2, etc. into the variable name of the skeleton l before generation. be.

The generated skeleton 6 is a skeleton in which a part ID, a file name, etc. corresponding to a variable name are incorporated by the automatic embedding device 5.

[Effect]

As shown in FIG. 1, the present invention provides a component determination mechanism 3 that refers to a component determination table 4 based on the selected pre-generation skeleton l and the input information input from the program summary manual screen 2. The automatic embedding device 5 determines the skeleton exit name, the component ID, etc. corresponding to the access method, etc., and furthermore, the automatic embedding device 5 uses the determined component ID, etc. and the file name in the manual information to create the skeleton 1 selected above. Incorporate (replace) the variable name,
After generation, a skeleton 6 is generated.

Therefore, skeleton 1 before generation with input/output processing as variable name
Prepare an external component corresponding to this variable name in advance, incorporate the corresponding component into it according to the skeleton exit name, access method, file name, file organization, etc. given from the outside, and generate the skeleton 6. By generating, it becomes possible to reduce the number of pre-generation skeletons l and automatically generate post-generation skeletons 6.

〔Example〕

First, in FIG. 2, in the pre-generation skeleton 1, two input/output processes are described, each having the underlined part shown as a variable name. After this is generated according to this embodiment, as shown in skeleton 6, BUHINOI
Becomes HINO21 (PFNI4-Yaou Egoku). Here, the part ID “BUHINOIO” “ shown in the underlined part
BUHINO21'' is incorporated, and at the same time, the file name "Order slip F" inventory mask F" in the input information is incorporated. This can be written in an easy-to-understand manner as READ Order slip 1' READ Inventory master F.

The configuration of FIG. 2 will be explained.

In FIG. 2, a pre-generation skeleton 1 is a skeleton that is an input to the skeleton generation system, and has a variable name that indicates a place (skeleton exit) where parts for input/output processing, file names, etc. are installed.

The input screen 2-1 is a screen for inputting definition information regarding the file (file name, file identification, oven mode, access mode, processing method (order, random), processing record name, processing key item, etc.).

One component determination table 4 is created for each pre-generation skeleton 1, and contains the names (IDs) of components that perform input/output processing that can be incorporated into the skeleton exit of each pre-generation skeleton 1.
) is stored.

The input/output component automatic assembly device 5 inputs the skeleton exit name, processing method, file name, and
Input/output processing components and file names determined by referring to the component determination table 4 based on input information such as oven mode and access mode are incorporated into the pre-generation skeleton 1.

The generated skeleton 6 has input/output processing components, file names, etc. incorporated into the variable names of the pre-generated skeleton 1.

Next, the operation of the configuration shown in FIG. 2 will be explained in accordance with the order shown in the flowchart of FIG.

In FIG. 3, ■ inputs file definition information.

To do this, select the number, for example, "01" from among the "occurrence number in the skeleton and skeleton exit name" pre-displayed on the input screen 2-1 in Figure 2, and then select the file name, file identification, processing method, and processing record. This means inputting the name, processing key item name, etc. It is assumed that the skeleton 1 before generation in FIG. 2 has already been selected.

@ determines whether the processing method (nn) is "random". This is done by selecting the skeleton exit as "01", for example, as shown in the bottom line of the input screen 2-1, and then selecting the access method (order or random) for the selected input/output processing component. This means determining whether or not it has been selected. In the case of "sequential", the sequential processing component ID in the component determination table 4 is set as the determined component ID in (■).

For example, corresponding to the skeleton exit names "Ol" and "Order", the part ID "BUHIN" of the order access part shown in ■
In the case of "Ran", set the random processing part ID in the component determination table 4 as the determined part TD in ■.For example, the skeleton exit name "01" and "Ran" Correspondingly, the part ID "BtJHINO1)" of the randomly accessed part shown in (2) is set as the determined part ID.

■ Incorporates the determined part ID at the skeleton exit in the skeleton 1 before generation, which is the result of the skeleton 1 before generation in Figure 2.
This means replacing the variable name “¥HB HN n n” with 0 and 1 with the determined part ID of [phase]. For example, find “¥HBHNO1” of skeleton 1 before generation in Figure 2 using ■. After generation, the determined part ID 'BUHINOIO'' is replaced as shown by ■ in the skeleton 6.

■ replaces the input file definition information with the changeable items on the skeleton exit. This is ¥HFNnn
:File name (n n)\HRNnn :Processing record name (nn)\HKNnn :Processing key item name (n n)
This means that the description in the pre-generation skeleton 1 that is written as 0 is replaced with the input information related to the skeleton exit input from the input screen 2-1. For example, ■ "\HFN01 in the pre-generation skeleton 1 ” to the skeleton exit “01” displayed on the input screen 2-1.
After generation, the file name related to "Order slip F" is replaced as shown by ■ in the skeleton 6.

Through the above processing, the post-generation skeleton 6 is automatically generated by selecting the pre-generation skeleton 1, selecting the skeleton exit name from the input screen 2-1, and inputting the processing method, file name, etc.

The operation of a specific example of the present invention will be explained using FIG.

fll Select the one shown as the pre-generation skeleton l.

(2) Program outline (1), (2) as input information
Enter from the input screen as shown.

(3) In response to the selections and inputs in (1) and (2), the skeleton 6 is automatically generated after generation.

(3-1) For example, ■“¥HBH” in skeleton 1 before generation
Corresponding to “NOI”, “01” in the program outline (2)
In response to the input of ``transfer read'' and mode ``sequential'', the component ID ``B U HINOIO'', which is a sequential access component shown in ■, is extracted from the component determination table 4, and after generation, it is placed in ■ in the skeleton 6. Replace as shown.

Similarly, ■ in the pre-generation skeleton 1 is replaced by ■, ■, ■ in the post-generation skeleton 6 as shown.

(3-2) For example, 0"\HFN in skeleton 1 before generation
Corresponding to "0I", [phase] "Inventory master F" in the program outline (1) is taken out and replaced as shown by ■ in the skeleton 6 after generation.

FIG. 5 is an easy-to-understand description of the generated skeleton 6 shown in FIG. 4.

Figure 5 'READ order slip F' is shown in Figure 4 'BUHINOIO (PFN12-Order slip F)
"READ inventory master F, KEY Is product code ° in FIG. 5 corresponds to "BUHIN250 (PFN14-Inventory master F), (PKNI 4-Product code)" in FIG. 4.

〔Effect of the invention〕

As explained above, according to the present invention, a pre-generation skeleton l with variable names such as input/output processing components and components corresponding to the variable names are prepared in advance, and corresponding component IDs and files are set in accordance with input information. Since a configuration is adopted in which the post-generation skeleton 6 is generated by incorporating the name etc., the post-generation skeleton 6 can be automatically generated by reducing the number of pre-generation skeletons 1, reducing the burden on the user. It also allows easy operation and management. Furthermore, when selecting a skeleton, the user does not need to be aware of file organization or access methods as in the past, and can easily generate a desired skeleton.

FIG. 3 is a flowchart explaining the operation of the present invention, FIG. 4 is a detailed explanatory diagram of the present invention, and FIG.
Figure shows the skeleton after generation.

In the figure, ■ represents a skeleton before generation, 2 represents a program outline manual screen, 2-1 represents an input screen, 3 represents a parts determination mechanism, 4 represents a parts determination table, and 5 represents an automatic installation device.

Claims (1)

[Claims] In an automatic determination method that automatically determines program parts for input/output processing, there is provided a pre-generation skeleton (1) in which processes necessary for input/output processing are given in advance by variable names, and this pre-generation skeleton ( Part I corresponding to the variable name in 1)
The parts determination table (4) stores information for determining D, etc. in advance, and the variable names of the skeleton before generation (1) correspond to input information such as skeleton exit name and processing method (sequential, random). and a parts determination mechanism (3) that determines a corresponding part ID by referring to the parts determination table (4), and the parts determination mechanism determines the variable name of the selected skeleton (1) before generation. (3) is the above parts determination table (
4) An automatic program component determination method characterized in that the program component is replaced by the component ID determined with reference to 4), and is also configured to be replaced by the file name of input information.