JPH0969042A - Automatic patch data creation method - Google Patents

Abstract

(57) [Summary] [Purpose] Automatically create patch data consisting of a set of objects before and after modification from a single source program. [Structure] A program source consisting of an original source and patch coding including patch statements and patch management information is compiled to generate an object program and a patch record including patch management information and a patch object, and the object program and patch record are generated. On the basis of the above, a NEW table consisting of patch management information and patch objects matching the designated patch version and an OLD table consisting of program objects and patch objects older than the designated patch version are created and A set of objects is created, and the created set of objects and the patch management information in the NEW table are combined to create patch data.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a patch data creating system for creating patch (urgent correction) data for software.

[0002]

2. Description of the Related Art Conventionally, as shown in Japanese Patent Laid-Open No. 1-201727, the automatic creation of patch data includes a modified data file which is modified at the source level and a unmodified data file. Are compared with each other, the mismatched portions are extracted, and the patch data is automatically created.

[0003]

The above-mentioned conventional method has the following problems. (1) When creating patch data, two files, one before and one after modification, are required, which complicates the process. (2) When creating different patch data for the same source file after creating patch data once, it is complicated to manage which of the two files in (1) above is added. There was a case that work mistakes occurred. An object of the present invention is to automatically create patch data consisting of a set of an object before modification and an object after modification from one source program.

[0004]

To achieve the above object, the present invention provides patch data from a program source consisting of one or more original sources and patch coding including one or more patch statements and patch management information. A patch data automatic creation method for creating, which generates a data record from the program source, an object program record, and a patch record including one or more patch statement records including a patch management information record and a patch object,
N consisting of patch management information and patch objects that match the specified patch version based on the generated object program record and patch record
An EW table, a means for creating an OLD table composed of program objects and patch objects older than a specified patch version, and the OLD table and N based on the NEW table and OLD table.
There is provided means for creating a set of objects for each corresponding address in the EW table, and creating patch data by combining the created set of objects with the patch management information in the NEW table.

[0005]

By the above means, the patch coding described at the source level is combined with the original source into one source.
When the patch data is stored in a patch file and the patch data is needed, an object can be created from the contents of this source file and the patch data can be created automatically based on this object. In addition, the complexity of data management can be avoided and the occurrence of work mistakes can be prevented.

[0006]

1 is a block diagram showing a schematic configuration of an embodiment of the present invention. The source file (101) is shown in FIG.
The program source (201) including the patch statement coded at the source level is stored. The program source (201) in the source file (101) is compiled by the compiler (102), output as an object in the format shown in FIGS. 3 and 4, and stored in the object file (103).
The patch automatic creation program (104) inputs an object from the object file (103) and creates a patch data file (105).

In addition, separately, the object file (10
It is also possible to secure 3) in the memory of the compiler and implement the patch automatic creation program (104) as a type of one function of the compiler.

FIG. 2 shows an example of the structure of a program source including a patch statement. The program source (201) including the patch statement includes the original source # 1 (202), the original source # 2 (204), the original source # 3 (206), and the patch statement # 4. Including the patch coding (207) and the patch coding including the patch statement # 5 (208)
Are added, and labels (203) and (205) that associate the patch address 211 with each other are inserted at the patch positions in the original source. This allows the compiler (102)
When creating the patch record (421) (Fig. 4),
The address corresponding to the beginning of the original source # 2 (204) is set to the address 42 of the patch record (421).
4 and the patch station of patch coding (207)
A patch record (421) is created for the length of the object of the statement # 4. Similarly, the patch record (42
1) (Fig. 4), the original source # 3 (2
06), the address corresponding to the beginning part of the patch record
The address 424 of the patch (421) is set, and the patch record (421) is created by the length of the object of the patch statement # 4 of the patch coding (208). The patch coding (207) has a patch address (21
STA that can define 1) and patch management information (212)
A PTCH (210) compiler control instruction, a patch statement (213) composed of one or a plurality of consecutive instruction words, and a compiler control instruction ENDPTCH (214) indicating the end of a set of patches. The same applies to the patch coding (208). The patch management information (212) includes the patch number, patch version, object version, revision,
It consists of creator, creation date, reason for patching, etc.

FIG. 3 shows an example of the structure of an object file including a patch record. The object file is composed of one or more data records (301), one or more program records (302), and one or more patch records (303). Program records # 1, # 2 and # 3 are original sources # 1 (202), # 2 (204) and # 3 (20
6), and patch records # 4 and # 5 correspond to patch coding (207) and (208), respectively. The order of these records may be in any order.

FIG. 4 shows an example of the record format of the program record (302) and the patch record (303). The program format record format is
Reference numeral 401 indicates a record header (402), a length (403), an address (404), and a program object (405). There are two types of patch record record formats: a patch management information record (411) containing patch management information and a patch statement record (421) containing patch objects. The patch management information record (411) is arranged first, and then one or more patch statement records (421) related to the patch management information record (411) are arranged. The patch management information record (411) includes a record header (412), patch management information (414), and a patch statement record number (413) that determines the range of patch statement records corresponding to the patch management information.
And Patch statement record (421)
Contains a record header (422), length (423), address (424) and patch object (425). These records are created by the compiler (102).

FIG. 5 shows an automatic patch creation program (10
It is an example of a table that 4) should have. The patch data created by the automatic patch creation program (104) is
A patch address, a patch object and a pre-patch object are needed. NEW for creating patch data
The table (501) and the OLD table (551) are required. The NEW table (50 shown in FIG.
1) includes patch management information (510) and patch entries (520), (521) ..., One patch entry (521) includes a patch address (531), a length (532), a patch object ( 533). The OLD table (551) shown in FIG. 5 (b).
Is the statement entry (56
1), (562) ..., One entry is composed of an address (571), a length (572), and an object (573) before applying a patch.

FIGS. 6, 7, and 8 show a patch automatic creation program (10) which is an embodiment for automatic patch creation.
It is an example of processing included in 4). FIG. 6 is a flowchart of a process of registering the patch object data of the specified patch version from the patch record (303) of the object file (103) in the NEW table (501). First, the SW (switch) is set to 0 (step 601). Next, one record of the object file is read (step 602). De-
If it is the end of the data (EOF), the process ends, and if not, the process proceeds to step 604 (step 602). Next, the record header is referenced to determine whether it is a patch statement record (step 604). If the judgment is NO, it is judged whether it is a patch management information record (step 607). If the determination is NO, the process returns to step 602, and if the determination is YES, it is determined whether the patch version specified from the outside matches (step 608). If the determination is NO,
SW is set to 0 (step 610) and step 60
Returning to step 2, if YES, SW is set to 1 (step 609), the patch management information is registered in the NEW table (step 611), and the procedure returns to step 602. If the determination in step 604 is YES, it is determined whether SW = 1 (step 605). If the determination is NO, the process returns to step 602, and if YES, the address, length, and object are stored in the NEW table. Register (Step 60
6) and returns to step 602.

FIG. 7 shows the object file (103).
Program record (302) and patch record (3)
03), the object data before the patch of the corresponding version is assigned is stored in the OLD table (551).
5 is a flowchart of a process of registering with. Here, it is assumed that the object data is read in the order of the program record and the patch record with the oldest patch version. First, one record of the object file is read (step 701). End of data (EOF)
If the determination is YES, the process ends. If the determination is NO, the record header is referenced to determine whether it is a patch statement record (step 70).
3). Next, if the determination in step 703 is no, it is determined whether it is a patch management record (step 70).
5). If the determination in step 705 is yes, the patch version is stored (step 706) and the process returns to step 701. If the determination in step 705 is no, it is determined whether it is a program record (step 7
07). If the judgment in step 707 is NO, the process returns to step 701, and if the judgment is YES, step 709.
Proceed to.

Next, if the determination in step 703 is YES and the patch statement record is found, the patch version stored in step 706 matches the patch version designated from the outside. It is determined (step 704). Step 70
If the determination in 4 is YES, the process returns to step 701,
If the determination is NO, it is determined whether the stored patch version is newer than the externally designated patch version (step 708). If the determination in step 708 is YES, and if new, return to step 701,
If the determination is NO, the process proceeds to step 709. Next, in step 709, it is determined whether the data in the NEW table and the address overlap, and the determination is N.
If O, the process returns to step 701, and if the determination is YES,
It is determined whether overlapping addresses are registered in the OLD table (step 710). Step 71
If the determination in 0 is NO, only the object portion where the addresses overlap is taken out, registered in the OLD table (step 711), and the process returns to step 701.
If the determination in step 710 is YES, the object portion whose address overlaps is registered in the already registered entry of the OLD table by overwriting (712), and the process returns to step 701.

FIG. 8 shows a NEW table (501) and an OL.
This is a process of creating a patch data file (105) from the D table (551). The patch management information of the NEW table is converted into a patch data format and output as a management information record to the patch data file (105) (801). Next, the OLD table (50
1) and a NEW table (551) corresponding patch data sets are created for each address, converted into a patch data format and output to a patch data file (105) (802).

FIG. 9 shows an example of a patch data file. The patch data file 901 stores a management information record 902 and a set record 903 of one or more patch data. The management information record 902 has a record ID 91.
1 and management information 912. The patch data set record 903 includes a record ID 913, an address 914, and O.
It consists of an object 915 extracted from the LD table and an object 916 extracted from the NEW table.

[0017]

According to the present invention, the patch coding described at the source level is stored in one source file based on the original source and the contents of the source file are used. The patch data can be easily created automatically. Further, it is possible to avoid the complexity of the processing in creating the patch data and the complexity of the data management, and it is possible to prevent the occurrence of a work error.

[Brief description of drawings]

FIG. 1 is a block diagram showing a schematic configuration of an embodiment of the present invention.

FIG. 2 is a diagram showing a configuration example of a program source including a patch statement.

FIG. 3 is a diagram showing a configuration example of an object file including a patch record.

FIG. 4 Record of program record and patch record
It is a figure which shows the example of a format.

FIG. 5 is a diagram showing an example of a table included in a patch automatic creation program.

FIG. 6 shows NE of the object data of the patch version specified from the patch record of the object file.
9 is a flowchart of a process of registering in a W table.

FIG. 7 is a flowchart of a process for registering object data before a patch of a corresponding version is assigned to an OLD table from a program record and a patch record of an object file.

FIG. 8 is a flow chart of a process for creating a patch data file from a NEW table and an OLD table.

FIG. 9 is a diagram showing an example of a patch data file.

[Explanation of symbols]

 101 Source File 102 Compiler 103 Object File 104 Patch Automatic Creation Program 105 Patch Data File 201 Source Program Including Patch Statement 202, 204, 206 Original Source 203, 205 LABEL 207, 208 Patch Coding 210, 214 Compiler Control command 213 patch statement

Claims (1)

[Claims] 1. An automatic patch data creation method for creating patch data from a program source consisting of one or more original sources and patch coding including one or more patch statements and patch management information, wherein data from the program sources is used. Means for generating a record, an object program record, and a patch record consisting of one or more patch statement records including a patch management information record and a patch object, and a patch specified based on the generated object program record and patch record N consisting of patch management information and patch objects matching the version
An EW table, a means for creating an OLD table consisting of program objects and patch objects older than a specified patch version, and the OW table based on the NEW table and the OLD table.
Automatic patch data characterized by means for creating a set of objects for each corresponding address of the LD table and the NEW table, and creating patch data by combining the created set of objects and the patch management information of the NEW table Creation method.