JP2005215862A - Automatic build instruction document generating method, and program and system therefor - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To automatically generate build instruction document which causes no incorrectness in build order of a source program having a mutual reference relation with an execution-form program and designates correct build order at a time of build when the generation of the execution-form program is blocked. <P>SOLUTION: All the programs constituting a source program group 10 and each line of program composition information are searched by automatic processing by an automatic program generating device 2 to detect the presence or absence of reference of each program to another execution-form program. When it is detected that the reference to the execution-form program is made, each program is sorted in sequence order so that a reference object program may be located preceding the program, to which the reference is detected to be made, to make the sequence order of the sorted program the conversion order of each program, and the build instruction document is automatically generated. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  The present invention is to specify a conversion order of each program when converting a plurality of programs and program configuration information constituting a source program group having a relation to refer to each other at the time of building into a series of executable programs. The present invention relates to an automatic creation method of a build instruction, a build instruction automatic creation program, a program automatic generation device with a build instruction creation function, and a program execution system including the program automatic generation device.

  A program automatic generation device that automatically generates a source program group as an intermediate product between design information and an executable program based on the design information, and a build device that converts the source program group into an executable program are already known. It is.

  When converting a source program group that refers to an executable program to each other at the time of building into an executable program, a program in the source program group or a program that has not yet been converted into an executable program is included in the program configuration information. If it is referenced, normal conversion processing cannot be performed, so a build instruction that specifies the conversion order of each program that makes up the source program group is created in advance, and the source program group is assigned to each program according to the instructions in this build instruction sheet. It is necessary to convert it into an executable program every time. For example, when a main program that calls a subprogram is converted to an executable program, if the main program is converted to an executable program before the subprogram is converted to an executable program, it corresponds to the subprogram. Since there is no executable program to be converted, there is a problem that an error occurs in the conversion work of the main program into the executable program and the conversion work stops.

  Conventionally, this build instruction has been created manually or by manually rewriting a part using a template prepared in advance, so that it is correct due to a description error due to manual work. There are cases where the build order cannot be specified, and there is a problem that the efficiency of labor costs is hindered by the presence of manual work.

  In particular, in recent development environments for large-scale program groups, many main programs and subprograms are often independently developed at multiple bases, and it is difficult to create build instructions by relying on human resources. It is becoming difficult because of the cost.

  A technique for rearranging the build order of programs is to analyze the functions in the source program and specify the order in which the source programs are converted into executable programs by rearranging the functions in the order of execution frequency. Although proposed as Patent Document 1, this is merely for the purpose of shortening the time required for execution of the executable program, and has a relationship of referring to the executable program at the time of building. It does not take into account the mutual reference relationship of certain source programs. Therefore, as described above, there is a possibility that the compile operation itself may be hindered due to the failure to specify the build order.

  Note that the automatic program generation device itself that generates a source program based on design information is a well-known technique as disclosed in, for example, Citation 2, and is used in the field of CASE tools, automatic program generation devices, and the like. It is used frequently.

JP 2000-56983 A Japanese Patent Laid-Open No. 8-328841

  Accordingly, an object of the present invention is to improve the inconveniences of the above-described prior art and to make a build order of source programs that have a relationship of referring to each of the executable programs at the time of build, which is a manual description error, particularly, obstructing creation of the executable program. Build instruction automatic creation method, build instruction automatic creation program, program automatic generation device with build instruction creation function, which can automatically generate a build instruction that specifies the correct build order without illiciting An object of the present invention is to provide a program execution system provided with this automatic program generation device.

The method for automatically creating a build instruction according to the present invention converts a plurality of programs constituting a group of source programs having a relationship of referring to executable programs at the time of building into a series of executable programs. In order to achieve the above-mentioned problem, in particular, all the programs and programs that constitute the source program group by the automatic program generation device that generates the source program based on the design information. Search each line of configuration information to detect the presence or absence of references to other executable programs in each program,
When a reference to another executable program is detected, the respective programs are sorted so that the program to be referenced is positioned before the program from which the reference is detected, and the order of the sorted programs is changed. A build instruction is generated as the conversion order of each program.

A program that does not require reference to another executable program can be converted into an executable program alone, and a program that requires reference to another executable program can be referred to as an executable program. It must be converted to an executable program before it can be converted.
Therefore, all the programs constituting the source program group and each line of the program configuration information are searched by the program automatic generation device, the presence / absence of reference to other executable programs in each program is detected, and the program from which the reference is detected is detected. Also sort each program so that the program to be referenced is located first, generate a build instruction using the sorted program order as the conversion order of each program, and in the order specified in this build instruction. If the conversion work from the source program to the executable program, that is, the so-called compiling work is performed, the conversion process can be achieved reliably.

For example, the sorting operation for positioning the program to be referred to before the program in which the reference is detected includes, for example, searching all the lines constituting the source program group and each line of the program configuration information to refer to other programs in each program. After detecting the presence or absence of
Identify programs that can be built independently and programs that require reference to other executable programs, and each program can be built independently, programs referenced as executable programs when building other programs, This can be realized by rearranging the programs that require reference to other executable programs at the time of building.

  As described above, the conversion process is ensured by converting the program that is referred to as the executable program when building the other program to the executable program before the program that requires the reference of the other executable program. Can be achieved.

More specifically, this sorting work is performed by searching all lines constituting the source program group and each line of the program configuration information and detecting the presence or absence of other executable program references at the time of building each program.
When a reference to another executable program is detected, a value representing each of the program in which the reference of the other executable program is detected and the program to be referred to is set as one record and the first file and the second When a reference to another executable program is not detected while writing to a file, a value symbolizing the program is written as one record only to the second file,
A first record writing step of reading records one by one in order from the top of the first file and writing them to a third file, and a value that symbolizes the program to be referred to included in this record. The second record writing step is executed to read the record having as the second record from the second file and writing it as the next one record to the third file, and then writing to the third file in the second record writing step. It is determined whether or not the record includes a value that symbolizes the reference target program. If the value that symbolizes the reference target program is included, the second record writing process is repeatedly executed, while the reference target If no value representing the program is included, the record from the first file is read. , A reference destination file generating step of repeatedly executing the said first record writing step and the second record writing process,
A record of a value that symbolizes a single buildable program that is extracted from the record written in the second file by reversely extracting a record that does not store a value that symbolizes the reference target program and writing it to the build order list file. In the writing process, the value that symbolizes the reference target program of the record that stores the value that symbolizes the reference target program is extracted from the record written in the third file by going backwards in the order of writing and build order. A process of writing a value symbolizing a reference destination program to be written to a list file, and extracting a value symbolizing a program of a record written to the third file by going backwards in the order of writing and writing to the build order list file The process of exporting values that symbolize
This can be reliably realized by executing, as an internal process of the automatic program generation device, the build order list file generation step for deleting duplication of values symbolizing the program in order from the top of the build order list file.

In this case, the value that symbolizes the program written in the value writing process that symbolizes the independently buildable program is the value that represents the program that can be independently built, and the value writing process that symbolizes the reference destination program. The value that symbolizes the program written in is a value that symbolizes the program that is referred to as an executable program in another program at the time of building, and is further written in the value writing process that symbolizes the program The value that symbolizes includes a value that symbolizes a program that needs to refer to another executable program at the time of build, and complements a value that symbolizes a program that has not been written at the present time.
Therefore, the program that can be built independently by deleting duplicate values that symbolize the program in order from the top of the build order list file, a program that is referred to as an executable program by other programs at the time of build, and build It is possible to convert all the programs constituting the source program group into executable programs without breaking the arrangement of programs that sometimes require reference to other executable programs, and avoiding duplication.

In order to achieve the same problem as described above, a program for automatically creating a build instruction according to the present invention includes a processor of an automatic program generation device that generates a source program group based on design information.
Search each program and each line of the program configuration information that constitutes the source program group, and refer to programs that can be built independently, programs that are referenced as executable programs when building other programs, and other executable programs that are built when building Discriminating means for discriminating into necessary programs, a program capable of independently building each program, a program referenced as an executable program when building another program, and a reference to another executable program when building A build instruction creating means for generating a build instruction by sorting in the order of programs to be executed.

In this case, the discriminating means refers to a program that can independently build each of the programs constituting the source program group, a program that is referred to as an executable program at the time of building another program, and a reference to another executable program at the time of building. Based on the results of the discrimination, the build instruction creation means discriminates it from the required program, the program that can build each program independently, the program referenced as an executable program when building other programs, A build instruction is generated by sorting in order of programs that require reference to other executable programs.
Specific internal processing executed by the processor of the automatic program generation device is as described above.

  In order to achieve the same problem as described above, the program automatic generation apparatus with a build instruction creation function according to the present invention is a program that can be independently built by searching each line of the source program group and each line of the program configuration information. Discrimination means for discriminating between a program that is referred to as an executable program at the time of building another program and a program that requires reference to another executable program at the time of building, and a program that can independently build each of the discriminated programs And a build instruction creation means for generating a build instruction by sorting in order of a program that is referred to as an executable program at the time of building another program and a program that requires reference to another executable program at the time of building It has the structure characterized by this.

  As described above, the discrimination means discriminates each program into a program that can be built independently, a program that is referred to as an executable program when building another program, and a program that requires reference to another executable program when building. Based on the discrimination result, the build instruction creation means can refer to programs that can build each program independently, programs that are referred to as executable programs when building other programs, and references to other executable programs when building. Build instructions are generated by sorting in the order of required programs.

  The automatic program generation device with a build instruction creation function further includes an arrangement for specifying the arrangement of the executable program based on the generated build instruction and the layout design information of the executable program input to the automatic program generator. A placement instruction automatic generation function for automatically generating instructions can be provided.

  Since the build instruction is automatically generated by the internal processing of the automatic program generation device, after the build instruction is generated, the build instruction that determines the layout of the executable program and the layout design information that specifies the storage location of the executable program are included. Based on this, it is possible to automatically generate an arrangement instruction for specifying the arrangement of the executable program.

A program execution system according to the present invention includes a business specification data storage device that stores design information required for generating a source program group and layout design information of an executable program, and design information stored in the business specification data storage device. An automatic program generation device that generates a source program group based on the program, a program that constitutes the source program group, a build instruction that specifies the order in which program configuration information is converted into an executable program, and the source program group A build device that generates an executable program, an automatic product storage device that stores the program automatic generation device and a program group generated by the build device, and an execution device that stores and executes the executable program A program execution system that achieves the same tasks as above Because, in particular,
The program automatic generation device searches for each program constituting the source program group and each line of the program configuration information to independently build a program that can be built and a program that is referred to as an executable program at the time of building other programs and other programs at the time of building. Discriminating means for discriminating programs that need to be referred to executable programs, programs that can build each discriminated program independently, programs that are referenced as executable programs when building other programs, and others that are built Build instruction creation means for generating a build instruction by sorting in the order of the program that requires reference to the executable program, and the program is automatically input from the generated build instruction and the business specification data storage device to the program automatic generation device. The executable program And a placement instruction automatic generation function for automatically generating a layout instruction form based on the total information specifying the placement of the executable program,
The execution device is configured to store and execute an execution format program stored in the automatic product storage device based on the arrangement instruction.

In other words, this program execution system is a program execution system constructed by combining a business specification data storage device, a build device, an automatic product storage device, and an execution device with the automatic program generation device with a build instruction creation function according to the present invention. System.
The business specification data storage device stores design information required for generating a source program group and layout design information for an executable program, and the program automatic generation device reads the information to generate a source program group. Store in automatic product storage.
Furthermore, the program automatic generation device discriminating means searches for each program constituting the source program group and each line of the program configuration information, and a program that can be independently built and a program that is referred to as an executable program when building another program And a program that requires reference to another executable program at the time of build, and the build instruction creation means of the program automatic generation device sorts the program to generate a build instruction, which is stored in the automatic product storage device. Store.
Then, after the build instruction is generated, the automatic layout instruction generation function of the automatic program generation device is activated, and the layout design input from the build instruction stored in the automatic product storage device and the business specification data storage device An arrangement instruction is automatically generated based on the information and stored in the automatic product storage device.
On the other hand, the build apparatus sequentially converts each program of the source program group in accordance with the instructions in the build instruction document to create an executable program, and stores the executable program in the automatic product storage device.
Finally, the execution device stores the execution format program stored in the automatic product storage device according to the arrangement instruction, and executes the execution format program.

The present invention searches for all the programs constituting the source program group and each line of the program configuration information at the time when the source program group is generated by the automatic program generation device, and stores other executable programs at the time of building each program. When the presence or absence of a reference is detected and a reference to another executable program is detected, each program is sorted so that the program to be referenced is positioned before the program for which the reference is detected. The build instructions are generated with the order of the selected programs as the conversion order of each program, so creation of executable programs is hindered by references to executable programs that have not yet been converted to executable programs. Problems are resolved, and the software is run in the order specified in the build instructions. Only performs conversion operations into executable program from the scan program group can be converted to reliably executable program to all the programs constituting the source programs.
In addition, the functions required to generate the build instructions are implemented in the automatic program generation device, eliminating the problem of description errors due to manual work, reducing labor, and improving the efficiency of labor costs. Can also be achieved.

  FIG. 1 shows a configuration of a program execution system mainly composed of an automatic program generation apparatus with a build instruction creation function incorporating a build instruction automatic creation program for realizing an automatic creation method of a build instruction according to the present invention. It is the functional block diagram shown about the outline.

  As shown in FIG. 1, the program execution system 1 includes a program automatic generation device 2 with a build instruction creation function (hereinafter simply referred to as an automatic program generation device), a business specification data storage device 3, an automatic product storage device 4, and the like. It is comprised by the build apparatus 5 and the execution apparatus 6.

  However, the business specification data storage device 3 and the automatic product storage device 4 may be configured by a single storage device, and the automatic program generation device 2 and the build device 5 may also be configured by a single computer. Is possible.

  The business specification data storage device 3 stores common part data 7 and business specification data 8 as design information required for generating a source program group, and layout information data 9 which is layout design information of an execution format program. . Of the design information, the common part data 7 is design information common to various business operations, and the business specification data 8 is design information unique to the business operations. Further, the arrangement information data 9 is a final execution format obtained by the build apparatus 5 converting the source program group 10 generated by the automatic program generation apparatus 2 based on the common component data 7 and the business specification data 8 by the compiling work. This is layout design information for specifying in what method and where the program 11 is placed in the execution device 6.

  The automatic program generation device 2 includes a source program group 10 generated by itself, in addition to an automatic programming function similar to the conventional one that automatically generates a source program group 10 based on common part data 7 and business specification data 8 as design information. Discrimination means for searching each program line and distinguishing it into a program that can be built independently, a program that is referenced as an executable program when building another program, and a program that requires reference to another executable program when building , Sorted programs can be built independently, programs that are referred to as executable programs when building other programs, and programs that require reference to other executable programs when building Build instructions to generate And an arrangement instruction for automatically generating an arrangement instruction 13 for specifying the arrangement of the execution program 11 based on the generated build instruction 12 and the arrangement information data 9 read from the business specification data storage device 3. Equipped with automatic document generation function.

  The automatic product storage device 4 is a storage device for storing the source program group 10, the build instruction 12 and the arrangement instruction 13 generated by the automatic program generation device 2.

  The build device 5 converts each program of the source program group 10 into the execution format program 11 in the specified order in accordance with the instructions of the build instruction sheet 12 stored in the automatic product storage device 4. This execution format program 11 is also stored in the automatic product storage device 4 together with the source program group 10, the build instruction 12 and the arrangement instruction 13 generated by the automatic program generation device 2.

  Finally, the execution device 6 stores the execution format program 11 stored in the automatic product storage device 4 in the memory in the execution device 6 in accordance with the instruction of the arrangement instruction sheet 13 and executes this execution format program.

  FIG. 2 is a flowchart showing the overall processing flow in the program execution system 1.

  First, the common component data 7, work specification data 8, and arrangement information data 9 prepared in advance are stored in the work specification data storage device 3 (step A1 to step A3).

Next, the automatic program generation device 2 is activated to read the common component data 7 and the business specification data 8 from the business specification data storage device 3, and the automatic program generation function of the automatic program generation device 2 is activated. A source program group 10 is automatically generated based on the business specification data 8. This automatic program generation function is known.
The generated source program group 10, the build instruction sheet 12, and the arrangement instruction sheet 13 are stored in the automatic product storage device 4 (step A4).

  Since the arrangement instruction 13 is automatically generated when the source program group 10 is generated by the automatic program generation device 2, an artificial description error related to the creation of the arrangement instruction 13 can be prevented.

  Next, the build device 5 is activated, and each program of the source program group 10 is converted into the executable program 11 in the specified order in accordance with the instructions of the build instruction sheet 12 stored in the automatic product storage device 4. The executable program 11 converted by this conversion work is also stored in the automatic product storage device 4 together with the source program group 10, the build instruction 12 and the arrangement instruction 13 generated by the automatic program generation device 2 (step A5). ).

  Next, the execution device 6 stores the execution format program 11 stored in the automatic product storage device 4 in the execution device 6 according to the instruction of the arrangement instruction 13 (step A6). Finally, the execution device 6 The execution format program 11 is executed (step A7).

  Here, a specific example of the processing operation of the discriminating unit and the build instruction creating unit in the automatic program generation device 2 will be described in detail with reference to the flowchart of FIG. 3 and the conceptual diagrams of FIGS.

  Among these, the flowchart of FIG. 3 shows the main part of step A4 in FIG. 2, that is, the process related to the automatic creation of the build instruction sheet 12. Regarding the known process related to the automatic program generation of the source program group 10, The explanation is omitted.

  FIG. 4 is a list showing an example of the source program group 10 having a relationship of referring to the executable program generated at the time of building generated by the automatic program generation device 2, and for each program constituting the source program group 10. The detailed description of the contents is omitted, and the programs are represented by program names a, b, c,... As values symbolizing the programs. For example, regarding the source programs a and c on the first line in FIG. 4, a is a program referred to by a, and c is a program to be referenced referenced by a. There is no program to be referenced in the source program b on the second line in FIG. The meanings of descriptions relating to other programs are the same as above.

  5, 6, and 7 schematically show the structure of the first, second, and third files used when writing the program name that is a value that represents the program. Here, each of these files is referred to as a reference list A, B, C.

  FIG. 8 shows an outline of the structure of a build order list file that finally functions as the build instruction sheet 12. Here, this file is called a build order list.

  These reference destination lists A, B, and C and the build order list are actually temporary storage files built in the automatic program generation apparatus 2. Among these, the build order list is the build order list. When processing related to the automatic creation of the instruction sheet 12 is completed, it is stored and stored in the business specification data storage device 3 as the build instruction sheet 12.

  Next, a specific processing operation will be described with reference to FIG.

First, during the execution of the processing of the above-described step A4 for automatically generating the source program group 10 using the automatic program generation device 2, the program configuration information such as a source program or makefile that refers to another executable program at the time of building is described. When the generation of a row is detected, a reference destination as shown in FIG. 5 is made up with a program name symbolizing a program from which a reference to another executable program is detected and a program name symbolizing a reference target program as one record. It outputs to each of the list A and the reference list B as shown in FIG.
If no reference to another executable program is detected, the program name symbolizing the program is output only to the reference list B as one record.
Since these processes are performed every time a set of source programs as a source of one executable program is generated, as a result, the processes are performed for all programs constituting the source program group 10 ( Step B1).

  Therefore, for example, when the source programs a and c on the first line in FIG. 4 are generated, the first lines of the reference destination list A and the reference destination list B are shown in FIG. 5 and FIG. Thus, program names a and c are written, respectively. Next, the source program b on the second line in FIG. 4 is generated. In this case, since there is no program to be referred to, only the second line of the reference list B is as shown in FIG. The program name b is written (writing to the reference list A is not performed). Then, the source program c on the third line in FIG. 4 is generated. In this case as well, there is no program to be referred to, so that only the third line of the reference list B is shown in FIG. Program name c is written out. When the source programs d and b on the fourth line in FIG. 4 are generated, the second line of the reference destination list A and the fourth line of the reference destination list B are shown in FIG. 5 and FIG. Thus, the program names d and b are written, respectively. As a result of searching for all the programs in the source program group 10 and repeatedly executing such processing, the source program group 10 as shown in FIG. 4 is finally referred to as shown in FIGS. The destination lists A and B are obtained.

  When the program name writing process for the reference list A and B is completed in this way, the records are read one by one from the top of the reference list A and the reference list C as shown in FIG. The first record writing process (step B2) to be written to the record, and the record having the program name symbolizing the program to be referenced contained in this record is read from the reference list B and the next one record in the reference list C After the second record writing process (step B3) to be written out as a record, whether or not the record written in the reference list C in the second record writing process includes a program name symbolizing the program to be referred to. Is determined (step B4).

  If the program name symbolizing the reference target program is included, the second record writing step (step B3) is repeatedly executed in the same manner as described above, while the program name symbolizing the reference target program is included. If not, the first record writing process (step B2) and the second record writing process (step B3) until the reading of records from the reference destination list A, which is performed once in the process of step B2, is completed. ) Is repeatedly executed as a reference file generation step.

Therefore, for example, in the examples of the reference destination lists A and B shown in FIGS. 5 and 6, first, the record of the first row is read from the top of the reference destination list A, and the program names a and c are referred to. It is written in the first row of the list C as shown in FIG. 7 (first record writing step). Since this record includes the program name c to be referenced, a record having the program name c as the program name to be referenced is read from the third row of the reference list B, and this program name c is written in the second row of the reference destination list C as shown in FIG. 7 (second record writing step). Since the record of the reference target program is not included in the record of the third row of the reference destination list B read here, the second record writing process is temporarily ended, and the reference destination list A starts from the reference destination list A again. When two lines of records are read, the program names d and b are written in the third line of the reference list C as shown in FIG. 7 (first record writing step). A record having the name b as the program name is read from the second line of the reference list B, and this program name b is written in the fourth line of the reference list C as shown in FIG. (Second record writing process). Since the record of the reference target program name is not included in the record in the second row of the reference destination list B read here, the second record writing process is temporarily ended, and the reference destination list A starts from the reference destination list A. Three lines of records are read.
In the example of FIG. 5, since only one program is referred to, the second record writing process is executed only once each time. In other words, in the situation where there is one program on the left side in FIG. 5 and a plurality of programs on the right side are continuously described in the right column. In this case, the second record writing process in step B3 is repeatedly executed for the number of references.

  As a result of repeatedly executing the reference destination file generation step in this way, finally, in this example, a reference destination list C as shown in FIG. 7 is obtained.

  Next, the discriminating means and the build instruction creating means extract only records that do not store the program name to be referred to from the records written in the reference destination list B, and reverse these records in the order of writing. A value writing process symbolizing a single buildable program to be sequentially written in the build order list as shown in FIG. 8 is executed (step B5).

  Therefore, for example, in the example of the reference destination list B shown in FIG. 6, the records of the second row, the third row, the sixth row, and the seventh row are extracted, and the program name b, stored in these records, As shown in FIG. 8, c, f, and g are reversed in the order of writing and in the order of g, f, c, and b, as shown in FIG. It will be written in 4 lines. As is clear from the reference destination list B in FIG. 6, these programs are programs that can be independently converted into an executable program without requiring reference to another executable program. In this way, first, program names representing programs that can be independently built are discriminated and stored at the top of the build order list.

  Next, the discriminating means and the build instruction creating means extract only the record storing the program name symbolizing the program to be referred to from the record written in the reference destination list C, and the reference target program name is extracted. A process of writing a value representing a reference destination program to be written in the build order list by going backward in the order of writing is executed (step B6).

  Therefore, for example, in the example of the reference destination list C shown in FIG. 7, the records of the first row, the third row, and the fifth row are extracted, and the program names c and b of the reference targets stored in these records are extracted. , F are reversed in the order of writing, and are written in the fifth, sixth, and seventh lines of the build order list as shown in FIG. 8 in the order of f, b, and c. As is clear from the reference list C in FIG. 7, these programs are programs that are referred to by other programs, and these programs are referred to unless they are first converted into executable programs. Cannot be converted into an executable program. In this way, in the build order list shown in FIG. 8, a program name group representing a program that can be independently built is followed by a program to be executed before another program that is a reference source. A group of program names to be discriminated is memorized.

  Next, the discriminating means and the build instruction creating means extract all program names representing the records written in the reference destination list C, go back in the order of writing, and represent values representing the programs to be written in the build order list. The writing process is executed (step B7).

  Therefore, for example, in the example of the reference destination list C shown in FIG. 7, all the records of the first row, the second row, the third row, the fourth row, the fifth row, and the sixth row are extracted. The program names a, c, d, b, e, and f stored in the record are reversed in the order of writing, and the build is performed in the order of f, e, b, d, c, and a as shown in FIG. The data is written in the eighth, ninth, tenth, eleventh, twelfth, and thirteenth rows of the order list. As is clear from the build order list of FIG. 8, at the stage where the process of writing values that symbolize this program is completed, a group of program names that symbolize a program that can be independently built and other programs that serve as reference sources Next to the program name group that symbolizes the program to be executed before, all the program names including the program names of programs that need to refer to other programs are partially duplicated, and the build order list It will be stored in the table without omission.

  And finally, the build instruction creation means is referred to by other program groups and program name groups that do not require reference to other programs by removing duplicate program names from the top of the build order list. Delete the duplicate program names from the build order list without losing the order of the program names and other program names that need to be referenced by other programs. A build order list file generation step is executed in which the contents of the table are stored in the business specification data storage device 3 as the build instruction sheet 12 (step B8).

  Therefore, for example, in the example of the build order list shown in FIG. 8, the records in the fifth and eighth lines that overlap with the program name c stored in the second line are deleted and stored in the third line. The records in the seventh and twelfth lines that overlap with the program name c are deleted, the records in the sixth and tenth lines that overlap with the program name b stored in the fourth line are deleted, and finally, Program names g, f, c, b left in the first, second, third, fourth, ninth, eleventh, and thirteenth rows of the build order list shown in FIG. , E, d, a as shown in FIG. 9, the first row, second row, third row, fourth row, fifth row, sixth row, seventh row of the build order list. The build order list is used as the build instruction sheet 12.

  In this way, the conversion order of the program specified by the build instruction 12 is always referred to more than the program that requires reference in the relationship between the program that requires reference to another program and the program to be referenced. Sorting is performed so that the target program is positioned first, and each program of the source program group 10 can be sequentially converted into an executable program according to the build instruction 12.

  For example, as can be seen from the source program group 10 shown in FIG. 4 and the build order list shown in FIG. 9, in this example, the program a in the first line of the source program group 10 requires reference to the program c. The program d in the fourth line of the source program 10 requires reference to the program b, and the program e in the fifth line of the source program group 10 requires reference to the program f. In the build order list of FIG. The program c to be referred to precedes the program a that requires reference, the program b to be referred to precedes the program d that requires reference, and the program e that requires reference In addition, the program f to be referred to is positioned first, and the relationship between these is not lost.

  Next, another embodiment of the program execution system to which the present invention is applied will be briefly described with reference to FIG.

  In addition to the components of the program execution system 1 shown in FIG. 1, the program execution system 22 is further provided with a build start instruction device 23. The build start instruction device 23 executes the build date and time (execute the source program group). In addition to the build instruction 12 and the arrangement instruction 13 described above, the execution date is instructed by inputting the date and time converted into the format program) and the version number (a value representing the generation of the source program group and the executable program). Furthermore, version information 24 including the build date and version number is generated, and this version information 24 is stored in the automatic product storage device 4 together with the build instruction 12 and the arrangement instruction 13.

  The present invention can be applied to a purpose of automatically determining the build order of a large number of programs having complicated interdependencies.

It is the functional block diagram shown about the outline of the structure of the program execution system to which this invention is applied. It is the flowchart which showed the flow of the whole process in a program execution system. It is the flowchart shown about the automatic creation process of the build instruction document performed by the processor of a program automatic generation apparatus. An example of a group of source programs generated by the automatic program generation device is shown in a list. It is the conceptual diagram which showed the outline of the structure of the reference destination list A (1st file) used when writing out the value which symbolizes a program. It is the conceptual diagram which showed the outline of the structure of the reference destination list B (2nd file) used when writing the value which symbolizes a program. It is the conceptual diagram which showed the outline of the structure of the reference destination list C (3rd file) used when writing the value which symbolizes a program. It is the conceptual diagram which showed the outline of the structure of a build order list file (build order list). It is the conceptual diagram which showed an example of the build order list file (build order list) finally obtained. It is the functional block diagram shown about the other structural example of the program execution system to which this invention is applied.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 Program execution system 2 Program automatic generation apparatus with a build instruction preparation function 3 Business specification data storage apparatus 4 Automatic product storage apparatus 5 Build apparatus 6 Execution apparatus 7 Common part data (Design information required for generation of source program group) )
8 Business specification data (design information required for generating source programs)
9 Placement information data (placement design information)
10 Source Program Group 11 Executable Program 12 Build Instruction 13 Placement Instruction 22 Program Execution System 23 Build Start Instructing Device 24 Version Information A Reference List (First File)
B Reference list (second file)
C Reference list (third file)

Claims (7)

Method for automatically creating a build instruction for designating the conversion order of each program when converting a plurality of programs constituting a group of source programs that refer to each other at the time of building into an executable program group Because
The program automatic generation device that generates the source program group based on the design information searches all lines of the source program group and each line of the program configuration information to find other executable programs in each program at the time of build. Detect the presence of references,
When the reference of the executable program is detected, the sorting order of the programs is sorted so that the program to be referenced is positioned before the program in which the reference is detected. A method for automatically creating a build instruction characterized by generating a build instruction as a conversion order of each program. After searching all the programs constituting the source program group and each line of the program configuration information to detect the presence or absence of other executable programs in each program at the time of build,
A program that can be built independently and a program that requires reference to another executable program at the time of building are identified, and each of the programs is referred to as an executable program that can be built independently or when another program is built. 2. The method for automatically creating a build instruction according to claim 1, wherein sorting is performed in the order of a program to be executed and a program that requires reference to another executable program at the time of building. After searching all the programs constituting the source program group and each line of the program configuration information to detect the presence or absence of other executable programs in each program at the time of build,
When a program reference is detected, a value representing each of the program in which the program reference is detected and the program to be referenced is written as one record in the first file and the second file, while the program reference is written. Is not detected, the value representing the program is written as one record only in the second file,
A first record writing step of reading records one by one in order from the top of the first file and writing them to a third file, and a value that symbolizes the program to be referred to included in this record. The second record writing step for reading the record having the second record from the second file and writing it as the next record to the third file, and then writing the record to the third file in the second record writing step. It is determined whether or not a value that symbolizes the reference target program is included in the written record, and if the value that symbolizes the reference target program is included, the second record writing step is repeatedly executed, If no value representing the referenced program is included, the record is read from the first file. Until finished, the referenced file generating step of repeatedly executing the said first record writing step and the second record writing process,
A value that symbolizes a program that can be independently built that is extracted from the record written in the second file by reversely extracting a record that does not store a value that symbolizes the reference target program and writing it to the build order list file. And writing and extracting the values symbolizing the program to be referenced from the records written in the third file by going backward in the order of writing. A process of writing a value symbolizing a reference program to be written to the sequential list file and a value symbolizing the program of the record written to the third file are extracted by going backwards in the order of writing and written to the build order list file. The process of writing values that symbolize the program,
Executing a build order list file generation step for removing duplication of values symbolizing the program in order from the top of the build order list file;
3. The value symbolizing the program is sorted so that the value symbolizing the program to be referred to is positioned before the value symbolizing the program from which the reference is detected. How to automatically create build instructions. A processor of an automatic program generation device that generates a source program and program configuration information based on design information,
A program that can be independently built by searching each line constituting the source program and program configuration information, a program that is referred to as an executable program at the time of building another program, and a reference to another executable program at the time of building is required Discriminating means for discriminating between programs, programs that can be built independently in the order of the programs, programs that are referenced as executable programs when building other programs, and references to other executable programs when building A build instruction automatic creation program for functioning as a build instruction creation means for generating a build instruction by sorting in order of programs to be executed. An automatic program generation device that generates a source program and program configuration information based on design information,
A program that can be independently built by searching each line constituting the source program and program configuration information, a program that is referred to as an executable program at the time of building another program, and a reference to another executable program at the time of building is required Discriminating means for discriminating between programs, a program capable of independently building each discriminated program, a program referenced as an executable program when building another program, and a reference to another executable program when building And a build instruction creation function-equipped automatic program generation device, comprising: build instruction creation means for generating a build instruction by sorting in order of programs to be executed.   Provided with a layout instruction automatic generation function that automatically generates a layout instruction that specifies the layout of an executable program based on the generated build instruction and the layout design information of the executable program input to the program automatic generation device 6. The program automatic generation apparatus with a build instruction creation function according to claim 5, A business specification data storage device for storing design information required for generating a source program group and layout design information for an executable program, and generating a source program group based on the design information stored in the business specification data storage device Automatic program generating apparatus for executing the program, and a build apparatus for generating the executable program based on the build instruction specifying the order of converting the program constituting the source program group and the program configuration information into the executable program, and the source program group A program execution system comprising: an automatic product storage device that stores a program group generated by the program automatic generation device and the build device; and an execution device that stores and executes the execution format program,
The program automatic generation device searches for each program constituting the source program group and program configuration information to independently build a program, a program that is referred to as an executable program at the time of building another program, and another execution at the time of build Discriminating means for discriminating into programs that need to refer to formal programs, programs that can build each discriminated program independently, programs that are referenced as executable programs when building other programs, and other executions when building Build instruction creation means for generating a build instruction by sorting in order of programs that require reference to formal programs, and execution of the generated build instruction and the business specification data storage device input to the automatic program generator Format program layout design information And a placement instruction automatic generation function for automatically generating a layout instruction for specifying the arrangement of the executable program on the basis of,
The execution device is configured to store and execute an execution format program stored in the automatic product storage device based on the arrangement instruction.

Images