JP3527265B2 - Primitive source control method - Google Patents

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a source management system for managing source.

[0002]

2. Description of the Related Art Generally, in software development, an object is created by compiling a source program (source program) using a compiler, as shown in FIG. Link these objects with the linker to create an executable load module.

Primitive sources and objects are not required during program execution. Therefore, normally, only the load module is stored in the computer for execution, and the primitive source and the object are not stored. As described above, conventionally, as shown in FIG. 10B, the primitive source and the load module are managed in separate files.

[0004]

However, in software development, it is necessary to manage the primitive sources, objects, and load modules in a consistent manner. Therefore, when the source is modified, objects and load modules are recreated from the modified source.

However, since the original source, the object, and the load module were managed separately, after many years, the original source and the object were lost, the location of the original source was unknown, and there were multiple original sources. In that case, there was a problem that it would not be known which version of the load module was created from the source code.

At this time, there is a decompilation as a method of obtaining the source from the load module, but there is a problem that the source cannot be completely obtained including comments and labels.

The present invention solves these problems.
The source is compressed (or encrypted) and added to the object code part generated by compiling the source to generate an object, and the source is also compressed (or encrypted) in the executable program part generated by linking. Generate and add a load module to restore (or decrypt) the compressed (or encrypted) source source that was added at the time of modification, or to create a one-to-one source with an object or load module. The purpose is to manage the source easily and surely, and to secure confidentiality by further encrypting it.

[0008]

FIG. 1 is a block diagram showing the principle of the present invention. In FIG. 1, a compiler 1 compiles a source 2 to generate an object code part, or activates a compressor 3 to generate and add a compressed source part 31 to generate an object 5. is there.

The linker 6 links the objects 5 to generate an executable format program part, and adds the compression source part 31 to this to generate the load module 7.

The compressor 3 is for generating a compressed source section 31 in which the source 2 is compressed. The encryption device 4 is for generating an encryption source unit 41 in which the original source 2 is encrypted.

The decompressor 11 includes a compression source unit 31 added from the object 5 or the load module 7.
Is extracted and restored to generate the original source 2.

[0012] The decoder 12, the encryption source unit 4 1, which is added from the object 5, or load module 7
Is extracted and decrypted to generate the original source 2.

The loader 8 loads the load module 7 onto the main memory.

[0014]

According to the present invention, as shown in FIG. 1, an object 5 to which a compiler 1 compiles a primitive source 2 to generate an object code part and a compressed source part 31 generated by activating a compressor 3 is added. The linker 6 links the object 5 to generate an executable program part, and adds the compression source part 31 to the executable program part to generate the load module 7. The loader 8 loads only the executable program portion of the generated load module 7 onto the main memory and executes it.

Further, the decompressor 11 takes out the compressed source part 31 added from the object 5 or the load module 7 and decompresses it to generate the original source 2.

Also, instead of the compressor 3, the source 2
The encryption source 4 which encrypts the primitive source 2 or the encryption / compression source portion 32 which encrypts and compresses the source 2 is provided to the object 5 and the load module 7. I am trying to add it.

Further, the decompressor 11 takes out the attached cipher source section 41 or cipher / compression source section 32 from the object 5 or the load module 7, and decompresses or deciphers / decompresses it to generate the original source 2. I am trying.

Therefore, in the object code part generated by compiling the primitive source 2, the compressed source part 31 obtained by compressing the primitive source 2, the encrypted cipher source part 41 and the encrypted / compressed encrypted / compressed source part 32 are provided. The object 5 is added to generate the object 5, or the executable source program part generated by linking is added to the compression source part 31 and the encryption source part 4.
1 and the encryption / compression source unit 32 are added to generate the load module 7, and the compression source unit 31, the encryption source unit 41, and the encryption / compression source unit 32 are extracted from the object 5 or the load module 7 as necessary. By recovering and decoding the original source 2 to generate the original source 2, it is possible to manage the source 1 to 1 with the object 5 and the load module 7, and compress the source 2 to reduce its capacity. It is also possible to secure the confidentiality by further encrypting it so that it cannot be decrypted by a third party.

[0019]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the construction and operation of an embodiment of the present invention will be described in detail with reference to FIGS.

FIG. 2 shows a block diagram of an embodiment of the present invention.
Here, 1 to 9, 11, 12, 31, 32, 41 are
The description is omitted because it is the same as that of the same number in FIG. In FIG. 2, the external storage device 10 is an external storage device that stores the executable program 21.

The editor 13 is for modifying or creating the source 2. The input device 14 inputs various data and instructions to the OS 15. OS15 is
The operating system is a program that controls the entire system.

Next, the operation of the configuration of FIG. 2 will be described in the order from. In FIG. 2, in response to a compilation instruction from the input device 14, the compiler 1 reads the target source 2 and generates an object code portion. At this time, the compiler 1 uses the compressor 3 and the encryption device 4
, A compressed source unit 31 that compresses the primitive source 1,
Encrypted cipher source part 41, encrypted / compressed cipher
The compressed source part 32 is generated and added to generate the object 5.

In response to the instruction to link from the input device 14, the linker 6 links the target object 5 or object group to the executable program section. At this time, from the object 5 to the compression source part 31,
The encryption source unit 41 or the encryption / compression source unit 32 is read and added to the executable program unit to generate the load module 7.

In response to the execution start instruction from the input device 14, the loader 8 loads the executable program part of the load module 7 onto the main memory 9,
Start execution.

In response to a restoration instruction (or a decoding instruction) from the input device 14 for updating the source 2, the restoration device 11 (or the decoding device 12) causes the object 5 or the load module 7 to perform the restoration. The compression source unit 31, the encryption source unit 41, or the encryption / compression source unit 32 that has been added is read and restored (decrypted) to generate the original source 2.

The editor activates the editor 13 to update the restored (decoded) primitive source 2 by the designer. After the update of the primitive source 2 is completed ,,, and are executed. As described above, the source 5 is compiled to generate the object code part , and the object 5 including the compression source part 31, the encryption source part 41 or the encryption / compression source part 32 that compresses (encrypts) the source 2 is combined. To live. One or more of the object code parts of the generated object 5 are linked to generate an executable program part, and the compression source part 31, the encryption source part 41 or the encryption / compression source part 32 extracted from the object 5 to copy.

Next, referring to the flowchart of FIG.
The procedure for compiling and linking under the configuration of will be described in detail. FIG. 3A is an operation flowchart when the compressed source unit 31 obtained by compressing the primitive source 2 is added to the object 5 or the load module 7.

In step S1, the source 2 is read. This is because the compiler 1 reads the original source 2. S2 is
Compile. This is to compile the source 2 read by the compiler 1 in S1 and generate an object code part.

In step S3, a primitive source is added to the object. This adds an original source (compressed source part 31) obtained by compressing the original source 2 to the object code part generated in S2 to generate the object 5.

S4 is linked. This links one or more of the object code sections in the object 5 generated in S3 to generate an executable program section. In step S5, the compressed source of the object 5 is added to the load module 7. This is the compressed source part 3 in the object 5 in the linked executable program part.
1 is taken out and added to the executable program section to generate the load module 7.

Step S6 is executed. This is executed by the loader 8 loading the execution format program part in the load module 7 created in S5 onto the main memory 9. As described above, the primitive source is compiled to generate the object code part, and then the compressed source part 31 generated by compression is added to generate the object 5. Then, one or more of the object code parts are linked to generate an executable program part, and the compressed source part 31 is extracted from the object 5 and added.

FIG. 3B is an operation flow chart when the cipher source section 41 in which the primitive source 2 is encrypted is added to the object 5 or the load module 7. Figure 3
In (b) of S, in step S11, the source 2 is read. This is because the compiler 1 reads the original source 2.

The step S12 is to compile. This compiles the primitive source 2 read by the compiler 1 in S11 and generates an object code part. In step S13, the source 2 is encrypted.

In step S14, the encrypted source is added to the object. This is to add the source code (encryption source part 41) obtained by encrypting the source 2 in S13 to the object code part generated in S12 to generate the object 5.

S15 is linked. This is 1 for the object code part in the object 5 generated in S14.
One or more are linked to generate an executable program part.

In step S16, the encrypted source of the object 5 (encryption source section 41) is added to the load module 7. This takes out the cipher source section 41 in the object 5 to the linked execution format program section, adds it to the execution format program section, and generates the load module 7.

Step S17 is executed. This is executed by the loader 8 loading the execution format program section in the load module 7 created in S16 onto the main memory 9. As described above, the cipher source part 4 generated by compiling the primitive source to generate the object code part and then encrypting it
1 is added to generate the object 5. Subsequently, after linking one or more of the object code sections to generate an executable program section, the cipher source section 41 is extracted from the object 5 and added.

FIG. 4 shows a primitive source restore flowchart from the object / load module of the present invention.
In FIG. 4, S21 reads a load module. For this, the restorer 11 or the decoder 12 in FIG. 2 reads the load module 7.

In step S22, a designated part or one of the designated source is taken out. This takes out the compression source unit 31, the encryption source unit 41, or the encryption / compression source unit 32 of the load module 7 read in S21,
Restore, decrypt, restore / decrypt to generate the original source.

Similarly, in S25, the object is read. This is because the restorer 11 or the decoder 12 in FIG. 2 reads the object 5. In step S26, the original source is taken out. This is to take out the compression source unit 31, the encryption source unit 41, or the encryption / compression source unit 32 of the object 5 read in S25, and restore, decrypt, restore,
Decrypt to produce the original source.

A file is created in step S23 for the original source that has been extracted from the load module 7 or object 5 and restored / decoded as described above, and the file of the original original source 2 (source file) is created.

In step S24, the source file is modified. This modifies the source file created using the editor 13. Then, the processing after (A) in (a) or (b) of FIG. 3 is performed to compile and link, and the modified source source 2 is compressed, encrypted, encrypted and compressed. The source unit 41 and the encryption / compression source unit 32 are added to generate the object 5 and the load module 7.

FIG. 5 shows a data structure explanatory diagram of the present invention. This is to compile and compress the primitive sources 1, 2, 3 to create objects 1, 2, 3 and then link these three objects 1, 2, 3 to create a load module. This will be described below.

At the time of compilation: The compiler 1 generates the header part, the object code part, and the compressed source part 31 from the source 1 and arranges them as shown to create the object 1 (described in detail with reference to FIG. 6). Similarly, the objects 2 and 3 are created from the primitive sources 2 and 3.

At the time of linking: The linker 6 separately processes the header part, the object code part, and the compression source part 31 of the three objects 1, 2, and 3 to generate one load module (see FIG. 7). Details).

As described above, three objects 1, 2, 3 and one load module are created from the primitive sources 1, 2, 3. At this time, since the compressed source section 31 obtained by compressing the corresponding source is added to the objects 1, 2, 3 and the load module, respectively, the compressed source section 31 is taken out to restore the original source. It becomes possible to do.

FIG. 6 is a detailed explanatory diagram of the object of the present invention. This shows the data structure when compiling and compressing the source shown in FIG. FIG. 6A shows the header part. As shown in the figure, this header part has the relative position, size, and source name of the compressed source part obtained by compressing the source. As a result, the original source name of the compressed source part, and the relative position and size of the compressed source part are known.

FIG. 6B shows the object code part. The object code section is a compilation of the program section of the source program and is composed of a symbol section 1, a text section and a symbol section 2.

The symbol portion 1 has information indicating a name mark defined by the source and its position, and external symbols defined by the source and its type, address and length.

The text portion has information such as machine language instructions and data for the instructions and data defined in the source. The symbol part 2 has information necessary for resolving the external reference defined by the source.

FIG. 6C shows the compression source section. The compression source unit 31 is a compressed source. FIG. 7 is a detailed explanatory diagram of the load module of the present invention. This shows a data structure when a link and compression source unit 31 is added to the object of FIG. 5 or FIG. 6 to create a load module.

FIG. 7A shows the header section. As shown in the figure, this header portion has the relative position and size of the compressed source portion 31 obtained by compressing the source, and the number of linked objects of the source name. As a result, the compressed source unit 31 added to all linked objects
The original source name of, and the relative position and size of the compression source unit 31 on the load module are known.

FIG. 7B shows the execution format program section. The executable program part is a link of objects, and is composed of a symbol part 1, a text part, and a symbol part 2.

The symbol part 1 is a record consisting of the symbol part 1 of the object, and is a name mark defined in the source and information indicating its position, and an external symbol defined in the source and its type, address, and It has information such as length.

The text portion is a record in which text portions of objects are collected and edited, and has information such as machine language instructions and data for the instructions and data defined in the source.

The symbol part 2 is a record in which the symbol parts 2 of the object are collected and edited, and has information necessary for resolving the external reference defined in the source. FIG. 7C shows the compression source unit. This compression source part 31 is used for all compression source parts 31 of an object.
It is a collection of compressed source code.

Next, according to the order shown in the flowchart of FIG. 8, the operation for creating the object and the load module will be described in detail with reference to FIGS. FIG. 8A shows the processing at the time of compilation.

In FIG. 8A, in S31, the source is read. This is because the compiler 1 reads the source 1 shown in FIG. S32 starts the compiling process.

In step S33, the object code section is created. In S34, the compressor 3 is activated. In step S35, the compression source unit 31 is created. This creates a compressed source section 31 in which the activated compressor 3 compresses the primitive source 1.

In step S36, the relative position of the additional portion of the compression source portion is calculated and output. In S37, the size of the primitive source is calculated and output. S38 outputs the source name of the source.

In step S39, the symbol part 1 is output. S4
0 outputs the text part. S41 is the symbol part 2
Is output.

In step S42, the compression source section 31 is output.
Similarly, the processing is performed for the primitive sources 2 and 3. By the above-described processing of S31 to S42, as shown in FIG. 6 described above: Header portion: relative position (S36), size (S37),
Primitive source name (S38) -Symbol part 1: S39-Text part: S40-Symbol part 2: S41-Compressed source part: S42 are output respectively, and an object is created.

FIG. 8B shows the processing at the time of linking.
In FIG. 8B, S51 determines whether there is an object. This determines whether or not there is an object to be linked, which is created according to the flowchart of FIG. 8A and is shown in FIG. 6, for example. In the case of YES, the processing of S52 to S57 is performed. In the case of NO, as the link process 2, the processes of S59 to S63 are performed.

In S52, the header portion is input. S53
Enter the object code part. In S54, the link process 1 is started.

In step S55, the compression source part is read. S5
6 outputs the size of the primitive source (compressed source part). S57 outputs the source name of the source. And S5
Return to 1 and repeat for the next object to be linked.

By the above processing from YES in S51 to S57, the sizes, the source names, and the relative positions of the compressed source parts 31 of all the objects to be linked are obtained and output.

Next, in S58, the determination result in S51 is NO, and the size, the source name, and the relative position of the compression source part 31 have been found for all the objects to be linked. To do.

In S59, the header portion is created. this is,
Based on the size of the compressed source portion, the source name of the source, and the relative position obtained in S52 to S57, the header portions of FIG.

At S60, the symbol portion 1 is created. S6
1 outputs the text part. S62 is the symbol part 2
Is output.

In step S63, the compression source section is output. By the processing of S51 to S63, as shown in FIG. 7 described above, header part: S59 (relative position, size (S56), source name (S57)), symbol part 1: S60, text part : S61-Symbol part 2: S62-Compression source part: S63 is output, and the load module is created.

FIG. 9 shows a restoration flowchart of the present invention. In FIG. 9, in S71, which module is to be restored is input (module name). This means whether to restore the original source from which of the objects or load modules created according to FIG.
Enter the module name.

In S72, which source is to be restored is input (source source name). In S73, it is determined whether or not the header section is completed. This determines whether or not all the following processing has been completed for the header part of the object or load module having the module name designated in S71. YE
In the case of S, the specified source name was not found in the input and specified module names, so the process ends as an error (ERROR). On the other hand, if NO, the process proceeds to S74.

In S74, the header portion is read.
In S75, it is determined whether or not there is a match with the primitive source name specified in the header section read in S74. If YES, there is a matching source name, so S76
Proceed to. On the other hand, if NO, S73 is repeated for the next module.

In S76, the source (compressed source section 31) having the matching source name is read. In S77, restoration processing is performed. This restores the compressed source unit 31 read in S76 to generate the original source.

In step S78, the primitive source is output. As described above, based on the designated source source name of the designated module (object, load module), the corresponding compressed source unit 31 can be read out and restored to generate the original source source.

[0076]

As described above, according to the present invention,
In the object code part generated by compiling the source 2, the compressed source part 31 in which the source 2 is compressed, the encrypted cipher source part 41 and the encrypted / compressed cipher
Generate the object 5 by adding the compression source part 32,
Further, the load source 7 is generated by adding the compression source unit 31, the encryption source unit 41, and the encryption / compression source unit 32 to the executable program unit generated by linking, and the object 5 or the load module 7 is loaded as necessary. Since the compression source unit 31, the encryption source unit 41, and the encryption / compression source unit 32 extracted from the module 7 are restored and decrypted to generate the original source 2, the object 5 and the load module 7 are used. One-to-one primitive source management can be realized easily and surely, and the source 2 can be compressed to reduce its capacity, and further encrypted to ensure confidentiality by preventing it from being decrypted by a third party. You can As a result, the source can be easily restored from the object 5 or the load module 7, and the source can be modified easily and quickly.

[Brief description of drawings]

FIG. 1 is a principle configuration diagram of the present invention.

FIG. 2 is a system configuration diagram of the present invention.

FIG. 3 is a compile / link execution flowchart of the present invention.

FIG. 4 is a flowchart for restoring a source from an object / load module of the present invention.

FIG. 5 is an explanatory diagram of a data structure of the present invention.

FIG. 6 is a detailed explanatory diagram of an object of the present invention.

FIG. 7 is a detailed explanatory diagram of a load module of the present invention.

FIG. 8 is a detailed explanatory flowchart of compiling / linking according to the present invention.

FIG. 9 is a restoration flowchart of the present invention.

FIG. 10 is an explanatory diagram of a conventional technique.

[Explanation of symbols]

1: Compiler 2: Primitive source 3: Compressor 31: Compressed source part 32: Encryption / compression source section 4: Encryption device 41: Encryption source part 5: Object 6: Linker 7: Load module 8: Loader 9: Main memory 11: Restorer 12: Decoder 13: Editor

─────────────────────────────────────────────────── ─── Continuation of the front page (56) Reference JP-A-2-10403 (JP, A) (58) Fields investigated (Int.Cl. ⁷ , DB name) G06F 9/06 G06F 9/44

Claims (4)

(57) [Claims] 1. A primitive source management method for managing a primitive source, wherein the primitive source is compressed to have a one-to-one content with the primitive source.
Compressor that generates a reversible compression source part with, and the source that is generated by compiling the source
And the irreversible object code part has a one-to-one content with the source source generated by activating the compressor.
A compiler for generating an object by adding a compressed source of reversibility were generated by linking the object, the object
The contents of the executable source program that is irreversible with the above source and the above source, and has a one-to-one content with the source
And a linker that generates a load module to which the reverse compression source unit is added. 2. A restorer for extracting the compressed source section added to the object or the load module and restoring the compressed source section to generate a source exactly the same as the original source. Primitive source control method according to item 1. 3. A source control method for controlling source
In, the source source or the compressed source part that is the source compressed
Reversible by encrypting and having a one-to-one content with the original source
The cryptographic source part or the encrypted / compressed source part of
Cryptographic device and primitive source or the above cryptographic source part
Lossless with a 1: 1 content with the source source
A compressed compression source part or an encryption / compression source part
Compressor and source code source generated by compiling the source code
And in the irreversible object code part, there is the above encryption device
The original source code created by activating the encryption device and the compression device.
Reversible cipher source part that has one-to-one content with
Generate an object with encryption / compression source part added
The object created by linking the above object with the compiler.
And the executable source code that is irreversible with the source code above.
The program part may have a one-to-one content with the original source.
The reverse encryption source part or encryption / compression source part
A primitive source control method that is equipped with a linker that generates an added load module . From wherein said object or load modules, perfectly identical to the original primitive source retrieves the encrypted source unit or the encryption and compression source unit is added
4. The source control system according to claim 3, further comprising a decoder or a decoder for decoding the source and a decoder.