JPS6310239A - Patch production system for high-level language - Google Patents

Abstract

PURPOSE:To omit change of a load module by producing a patch based on an additional source program in order to attain the program maintenance at the level of a high-level language. CONSTITUTION:A multiplex compiling control means 3 actuates a compiling means 4 to compile an original source program OPGM1 and then an additional source program APGM2 when these programs are received. The APGM2 is interpreted for each command. In a substitute command mode a code set on an original object program 6 is retrieved by an additional compiling means 5. A start address is set to a start pointer 10 and then a next pointer 11 and a jump instruction is produced to an address shown by a patch pointer 9 and written to an additional object program 8. Then an object code obtained from a source code set on the APGM2 is written to the program 8. The program 8 is defined as an object patch in an end mode.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a high-level language batch generation method, and more particularly to a high-level language punch generation method in a child computer system.

[Conventional technology]

Conventionally, in this type of high-level language patch generation method, FOR
If you want to modify or change a part of a program created in a high-level language such as TRAN, C0BOL, or PL/1, you may want to manually rewrite the source program written in the high-level language, or create an object when the source program is compiled. Print out the list of programs,
A method has been used in which a person directly creates a patch (referring to an additional object program with modified or changed parts, hereinafter the same) while comparing the object program with the original source program.

[Problem that the invention seeks to solve]

In the conventional high-level language batch generation method described above, when directly modifying a source program written in a high-level language, the data is expanded in memory when a new source program is compiled and when an old source program is compiled. A change occurs in the address assignment of the object program.

For this reason, there are differences in the operating environment of programs related to computer hardware and operating systems, and when a problem occurs, when considering the difference between a new source program and an old source program, it is difficult to simply look at the changes in the source program. The problem is that source program version control and program maintenance become complicated because the new and old source programs must be considered as different versions of the program and maintained in terms of program maintenance. be.

Furthermore, it is necessary to replace the old load module with a load module created by a new source program (generally containing a large amount of information), which has the disadvantage that the computer system may be forced to stop. .

Also, when creating a punch while referring to an object program that is the result of compiling a source program, create a patch because the object program format depends on the computer hardware. The drawback is that it requires advanced knowledge of hardware and requires a large number of man-hours to create.

In view of the above-mentioned points, an object of the present invention is to use a high-level language in the same way as when directly modifying a source program when modifying or changing a part of a source program created in a high-level language. The purpose of the present invention is to provide a high-level language punch generation method that can easily generate patches.

[Means for solving problems]

The high-level language punch generation method of the present invention is a compiling means that generates from an original source program an original object program in which line number information of the source code of the original source program is added to the object code, and an address file in which address information is stored. and additional compiling means for manually generating an additional source program containing at least one of an address command, a replacement command, and a deletion command, and generating an additional object program by referring to the original object program and the address file.

[Effect]

In the high-level language punch generation method of the present invention, the compiling means creates an original object program and an address file from the original source program, and the additional compiling means inputs an additional source program and refers to the original object program and address file. Create additional object programs.

〔Example〕

Next, the present invention will be explained with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of an embodiment of a high-level language patch generation method according to the present invention. The high-level language patch generation method of this embodiment uses an original source program 1, which is a source program to be modified, created in a high-level language, and a source program to be modified, which includes modification instructions, created in a high-level language. A certain additional source program 2, a multiple compile control means 3 that controls the entire high-level language patch generation method of this embodiment, and an original source program 1 are compiled to create an original object program 6 and an address file 7. a compiling means 4; an additional compiling means 5 for inputting the additional source program 2 and generating an additional object program 8 by referring to the original object program 6 and address file 7; The original object program 6 has the source line number (SLN) of the corresponding source code in the original source program l written in the object code, and the address information (
Unique names such as variable names and label names of the original source program l and the original object program 6 corresponding to this unique name
Information with the addresses inside as a table. ), an additional object program 8 to be generated by the high-level language patch generation method of this embodiment, and a pointer on the memory (not shown) required when creating the additional object program 8. Patch pointer which is area 9. Start pointer 10 and next pointer 1
It is composed of 1.

In addition, in FIG. 1, the original source program 1. in this embodiment is shown. As an example of the additional source program 21 original object program 6 and additional object program 8,
Each example program is shown when FORTRAN is used as the high-level language.

Here, the new commands used in the example program of additional source program 2 include the address command *MULTIC, which describes the start address of the patch area with a variable name (AREAI in this example), and the original source program 1.
Indicate the source code to be replaced by the source line number above, followed by the replacement command *REPLACE, which writes one or more source codes to replace, and specify the source code to be deleted in the original source program l by the source line number. Delete command IDELF.

There are TE and an end command *ENDMULT that declares the end of additional compilation.

Referring to FIG. 2, the processing of the multiplex compilation control means 3 consists of an original source program compiling step 31 and an additional source program compiling step 32.

Referring to FIG. 3, the processing of the compiling means 4 consists of an original object program creation step 41 and an address file creation step 42.

Referring to FIG. 4, the processing of the additional compiling means 5 is as follows:
Additional source program input step 51, address file reading step 52, and command interpretation step 5
3, address command determination step 54, replacement command determination step 55, and deletion command determination step 5.
6, an end command determination step 57, a patch pointer cent step 61, an original source code modification step 71, an additional object code creation step 72,
The original source code deletion step 81 is performed.

Next, the operation of the high-level language patch generation method of this embodiment configured as described above will be explained.

When the original source program 1 and the additional source program 2 are given, the multiple compilation control means 3 first operates the compiling means 4 to compile the original source program 1 (step 31).

That is, the original source program 1 is compiled to create the original object program 6 (step 41).
). During this process, address information is accumulated, and when the compilation is completed, the accumulated address information is written to the address file 7 (step 42).

Next, the multiple compilation control means 3 operates the additional compiling means 5 to compile the additional source program 2 (step 32).

That is, first, additional source program 2 is loaded (
Step 51), address information is read from the address file 7 (Step 52).

The additional source program 2 read in step 51 is interpreted for each command (step 5
3).

Based on the interpretation at step 53, it is determined whether the command is the address command *MULUTIC (step 54).

If the determination is that it is an address command, the punch area start address on the additional object program 8 is placed in the patch pointer 9 (step 61), and control returns to step 53 to interpret the next command.

If it is not an address command as determined in step 7, step 54,
The command interpreted in step 53 is the replacement command *R
It is determined whether it is EPLACE (step 55
).

If it is a replacement command in this judgment, one or more object codes in the original object program 6 corresponding to the source code of the source line number (7 in the example program) on the original source program 1 indicated by the replacement command are additionally compiled. The address of the first object code of the one or more object codes (hereinafter referred to as start address) is set in the start pointer 10. In addition, the start address of one or more object codes in the original object program 6 corresponding to the source code of the source line number (8 in the example program) next to the source line number on the original source program 1 indicated by the replacement command is It is set to pointer 11. Furthermore, a jump instruction to the address indicated by the patch pointer 9 is created as the object code of the address indicated by the start pointer IO, and is written to the additional object program 8 (step 71).

Next, the source code following the replacement command on the additional source program 2 is compiled, and the created object code is placed in the area indicated by the punch pointer 9 and written to the additional object program 8. At this time, address information is used to compile variables and labels defined in the original source program l on the additional source program 2. Also, the value of punch pointer 9 is
Every time the object code on the additional object program 8 is created, it is updated to indicate the start address of the next unused punch area. When all the source code following one substitution command has been compiled, the next pointer 1
A jump instruction to the object code on the original object program 6 indicated by 1 is created in the punch area indicated by the patch pointer 9 and written to the additional object program 8. At this time as well, the value of punch pointer 9 is updated to the address of the next unused patch area (step 72).

When this process is finished, control returns to the process of step 53.

If it is determined in step 55 that it is not a replacement command, the command interpreted in step 53 is the deletion command 'kDE'.
It is determined whether it is LETE (step 56).

If this determination is a deletion command, one or more object codes in the original object program 6 corresponding to the source code of the source line number (10 in the example program) on the original source program 1 indicated by the deletion command are additionally compiled. The start address of the one or more object codes is searched by the means 5, and the start address of the one or more object codes is set to the start pointer 10, and the source code of the source line number (11 in the example program) next to the source line number on the original source program 1 indicated by the deletion command is added. The start address of one or more object codes on the original object program 6 corresponding to is set in the next pointer 11. Furthermore, a jump instruction to the address indicated by the next pointer 11 is created as the object code of the address indicated by the start pointer 10 and written to the additional object program 8 (step 81), and control returns to the process of step 53.

If it is determined in step 56 that it is not a deletion command, the command interpreted in step 53 is an end command *END.
It is determined whether it is MULT (step 57).

If it is determined that the command is an end command, the processing of the additional compiling means 5 is completed, and the additional object program 8 at this point becomes the target punch.

If the judgment in step 57 is that it is not an end command, the command cannot be interpreted (comment command, incorrect command, etc.)
Therefore, control returns to step 53 to interpret the next command.

〔Effect of the invention〕

As explained above, the present invention is capable of generating batches based on additional source programs created in a high-level language, so that it is as easy as directly modifying a source program without requiring advanced knowledge of computer hardware. This has the effect of allowing batches to be created and program maintenance to be performed at a high-level language level.

In addition, since it is possible to easily modify or change a part of a source program in a batch rather than modifying the source program, version control of the source program is not complicated, and loads that require the computer system to be stopped This has the effect of eliminating the need to change modules.

Furthermore, by saving the additional source program and using it to create the next version of the source program, program resources can be reused.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the configuration of an embodiment of the present invention, FIG. 2 is a flowchart showing the processing of the multiple compilation control means in FIG. 1, and FIG. 3 is a flow chart showing the processing of the compiling means in FIG. 1. FIG. 4 is a flowchart showing the processing of the additional compiling means in FIG. In the figure, l...Original source program, 2...Additional source program, 3...Multiple compilation control means, 4...Compiling means, 5...Additional compilation means, 6...Original object program , 7...Address file, 8...Additional object program.

Claims (1)

[Scope of Claims] Compilation means for generating an address file storing address information and an original object program in which line number information of the source code of the original source program is added to the object code from the original source program, and at least an address command. , additional compiling means for inputting an additional source program containing either a replacement command or a deletion command and generating an additional object program by referring to the original object program and the address file; Language patch generation method.