JPH0749788A - Compile processing system - Google Patents

Abstract

PURPOSE:To shorten the time of the compiling work executed by a compiler of a language at the time when dependence relations between modules are distinctly prescribed in this language. CONSTITUTION:A compiler 1 is started by a command string. The compiler 1 checks the presence or the absence of an PE option for the front end processing in the command string by an FE option check part after an initial processing 11. If the FE option is designated, an FE part 13 is executed, and the compile processing of a source program 17 is started. Dependence relations between modules are checked also at this time, and the compile proceesing is aborted in the case of a failure of dependence relations. If a BE option for the back end processing is designated in the command string, a BE part 15 is executed. The BE part 15 takes an intermediate text as the input and processes it to generate an object program 20. If the FE option is not designated in the command string, the FE to generate the object program.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a compile processing method, and more particularly to a compile processing method having a function of defining a dependency relationship between modules which are compilation units.

[0002]

2. Description of the Related Art Conventionally, a compiler processing method that explicitly describes that there is a dependency between modules and compiles based on the described information is a compiler processing that does not have a function that explicitly describes the dependency. Similar to the method, it adopts a method of continuously processing up to the step of inputting a source program and generating an object program.

[0003]

However, in the above-mentioned compilation processing method, when the number of modules constituting the system is relatively small, there is no significant difference in the work efficiency in the compilation work, but the module which is a compilation unit. In the case of a large number of large-scale systems, there is a problem that a defect is discovered during compilation work, and when this is fixed, all related modules must be recompiled.

An object of the present invention is to perform a compiling process (processing of the first half of the compiler) for all modules in order to improve the efficiency of the compiling work when the above problems occur, and as a result, Is saved in the intermediate text format, and after all the defects in the dependencies have been resolved, an object program is generated from the saved intermediate text (the latter half of the compiler).
I do. This is to reduce the overall compilation time.

[0005]

A compiler processing method according to the present invention is a compilation processing method having a function of defining a dependency between modules which are compilation units.
An initial processing section that reads the command sequence that activates the compiler and checks the command sequence and performs various initial processes, and "F" for front-end processing in the command sequence.
FE option check part that checks whether the "E" option is specified, and is started when the "FE" option is specified, reads the source program and performs syntax check processing and semantic check processing, and the dependency The FE part that performs dependency processing by inputting or outputting data from the library to the source program and converting the source program to intermediate text and outputting it to the intermediate text file, and after manually defining the compile order after generating the intermediate text, execute the command A BE option check section for checking whether or not the "BE" option for backend processing is specified in the row, and "B"
The BE section that is started when the E "option is specified, reads the intermediate text from the intermediate text file, converts it into an object program, and outputs it to the object program file, and the processing of this BE section and the end processing of the compile processing In a compile processing method that is configured by including a processing unit and has a function of defining a dependency relationship between modules that are compilation units, various types of commands are read by reading a command sequence that activates the compiler and checking the command sequence. The initial processing part that performs the initial processing and "F" for the front end processing in the command string
FE option check part that checks whether the E "option is specified, and when the" FE "option is specified, the source program is read to perform syntax check processing and semantic check processing, and the dependency data FE section that performs dependency processing by inputting or outputting to the library from the library, converting the source program to intermediate text and outputting to the intermediate text file, and for starting various compilers that start the compiler by the option in the command string A command string creation unit that creates command strings in the command string text file in the order of module compilation, and a BE option check unit that checks whether the "BE" option for backend processing is specified in the command string. , "BE" The BE section that is started when an option is specified and converts the intermediate text from the intermediate text file into a read object program and outputs it to the object program file, and an end processing section that performs the end processing of the compile processing after the processing of this BE section. It is composed by including and.

[0006]

DESCRIPTION OF THE PREFERRED EMBODIMENTS Next, the present invention will be described with reference to the drawings.

FIG. 1 is a block diagram of the first embodiment of the present invention. In the embodiment shown in FIG. 1, the compiler 1 inspects and analyzes the options of the command sequence for invoking the compiler, and performs the initial processing of the compiler 11 for initializing the compiler.
And "FE" that performs front end processing in the command sequence
The FE option check unit 12 that checks whether or not an option is specified, and the source program file 17 that is started when the "FE" option is specified.
Read the source program, read the dependent data etc. defined by other modules from the library file 18 if necessary, check the syntax, check the meaning, update the dependency related data, and output the intermediate text to the intermediate text file 19. An FE unit 13 that outputs the dependency-related data to the library file 18, and a BE option check unit 14 that checks whether or not the "BE" option for back-end processing is specified in the command sequence, The BE unit 15 which is activated when the "BE" option is specified, reads the intermediate text from the intermediate text file 19 and generates an object program in the object program file 20, and the end processing unit 16 that performs the post-compilation processing. And is configured.

Next, the operation of the embodiment shown in FIG. 1 will be described. FIG. 2 is a conceptual diagram showing a module dependency as a compilation unit, and FIG. 3 is a diagram showing an example of a command sequence for activating a compiler. First, when the compiler 1 is activated by inputting the command sequence shown in FIG. 3A into the system, the initial processing unit 11 is activated, the command sequence is inspected, and the presence or absence of options is stored. After this, initial processing for compiling processing is performed, and the FE option checking unit 12 is activated. The FE option checking unit 12 checks whether the "-FE" option is specified in the command string "-". When the FE "option is not specified, the processing of the FE unit 13 is skipped, but when it is specified, the FE unit 13 is activated. F
The E section 13 inputs the source program from the source program file 17 specified by the "SOU" option of the command sequence and the dependency related information from the library file 18 specified by the "LIB" option, and performs syntax check,
The meaning is checked, the intermediate text is output to the intermediate text file 19 specified by the "IML" option, and the updated dependency related information is added to the library file 18
Output to. When the "IML" option is not specified in the command string, the intermediate text file 19 is assigned a temporary file by the compiler. Then, the BE option check unit 14 is activated. B
The E option check unit 14 displays "-B" in the command string.
E "Check if the option is specified."
BE section 1 when the -BE "option is not specified
5 is skipped, but BE is specified when specified
The section 15 is activated. The BE unit 15 inputs the intermediate text from the intermediate text file 19 designated by the "IML" option, generates an object program, and outputs the object program to the object program file 20. Since the dependency-related processing has already been completed by the FE unit 13, the order of compilation does not matter in the processing of generating an object program from the intermediate text.
Next, the termination processing unit 16 is activated, and if necessary, processing for releasing temporary files and other post-processing for the compiler is performed, and the processing is terminated.

FIG. 2 is a conceptual diagram showing a module dependency relationship. The system has three layers, and level 3 modules (c11, c12, c21, c22) are level 2 modules (b1 and b2). It shows that the module of level 2 depends on the module (a1) of level 1. At this time, the compilation order is level 1 module, level 2 module,
It will be a Level 3 module. Modules at the same level have no dependencies.

FIG. 3 is a diagram showing an example of a command sequence.
FIG. 3A is an example of the basic form of a command, and FIGS. 3B and 3C show command sequences when compiling the module shown in FIG. FIG. 3B shows the FE unit 13.
Process for all modules, check dependency,
This is to remove errors in the source program and to create an intermediate text. In FIG. 3C, the processing of the BE unit 15 is performed for all modules to generate an object program from the intermediate text. Is.

FIG. 4 is a block diagram of the second embodiment of the present invention. In the embodiment of FIG. 4, between the FE unit 13 and the BE option check unit 14 of the embodiment of FIG. A command sequence creating unit 21 for creating is provided.

In the embodiment of FIG. 4, those having the same name and the same reference numerals in the embodiment of FIG.
The E option check unit 12 displays "-F" in the command string.
When the "E" option is specified, the FE unit 13 is activated, but when the "-FE" option is not specified, the processes of the FE unit 13 and the command string creating unit 21 are skipped. The part 21 is the FE part 13
When the above process is performed, various command lines for starting the compiler, which are started after the process and start the compiler according to the options in the command string, are created in the command string text file 22. The command string text file 22 is used to activate the compiler when creating an object program from intermediate text, recompiling all modules, or modifying a part of the modules. The command strings in the command string text file are created in the order of module compilation.

FIG. 5 is a flow chart of the processing of the command string creating section 21. The command strings "-c", "-mkfe", "-mkbe",
And "-mkfbe" option are provided, and the command sequence text file is cleared by these options (step 102), the compile command sequence for generating intermediate text from the source program is generated (step 103), and the object program is generated from the intermediate text. Create a compile command sequence to execute (Step 1
04), and a compile command sequence for generating an object program from the source program is created (step 105), and in step 102, the subsequently generated command sequence is registered at the end of the command sequence text file (step 110), and the process ends. Also, step 103,
In steps 104 and 105, it is subsequently checked whether the registration switch is on (step 106). If not, it is turned on (step 107), and it is checked whether the generated command string is already registered in the command string text file (step 10).
8) If not registered, replace with the generated command string,
The subsequent texts are deleted (step 109) and the process ends. If the registration switch is turned on in step 106 and if the registration is completed in step 108, the process proceeds to step 110.

[0014]

As described above, according to the present invention, in a language in which dependent modules are explicitly defined in the source program, the order of compilation is also explicitly defined. By generating the object program after all the processing is completed, the object program generation process, that is, the process of activating the backend unit, is performed once regardless of the number of updates of the dependency relationships, which improves the efficiency of compilation work. effective. In addition, by automatically generating the command sequence for generating the object program from the intermediate text and the command sequence for compiling all modules in order,
The use of this command sequence has the effect of avoiding mistakes during compilation work.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a first embodiment of the present invention.

FIG. 2 is a conceptual diagram showing a dependency relationship between modules of a source program to which the present invention is applied.

FIG. 3 is a diagram showing an example of a command sequence for explaining the embodiment of FIG.

FIG. 4 is a configuration diagram of a second embodiment of the present invention.

FIG. 5 is a flowchart of processing of a command string creating unit according to the embodiment of FIG.

[Explanation of symbols]

 1, 2 compiler 11 initial processing unit 12 FE option check unit 13 FE unit 14 BE option check unit 15 BE unit 16 end processing unit 17 source program file 18 library file 19 intermediate text file 20 object program file 21 command sequence creation unit 22 command Column text file

Claims (2)

[Claims] 1. In a compile processing system having a function of defining a dependency between modules as a compile unit, an initial process of reading a command sequence for activating the compiler and checking the command sequence to perform various initial processes. Part and "for frontend processing in command sequence"
FE option check part that checks whether the FE "option is specified, and is started when the" FE "option is specified. It reads the source program and performs syntax check processing and semantic check processing, and the dependency The FE part that performs dependency processing by inputting or outputting data from the library to the source program and converting the source program to intermediate text and outputting it to the intermediate text file, and after manually defining the compile order after generating the intermediate text, execute the command A BE option check section for checking whether or not the "BE" option for backend processing is specified in the row, and "B"
The BE section that is started when the E "option is specified, reads the intermediate text from the intermediate text file, converts it into an object program, and outputs it to the object program file, and the processing of this BE section and the end processing of the compile processing A compilation processing method including a processing unit. 2. In a compile processing method having a function of defining a dependency between modules as a compile unit, an initial process of reading a command sequence for activating a compiler and checking the command sequence to perform various initial processes. Part and "for frontend processing in command sequence"
FE option check part that checks whether the FE "option is specified, and when the" FE "option is specified, the source program is read to perform syntax check processing and semantic check processing, and the dependency data FE section that performs dependency processing by inputting or outputting to the library from the library, converting the source program to intermediate text and outputting to the intermediate text file, and for starting various compilers that start the compiler by the option in the command string A command string creation unit that creates command strings in the command string text file in the order of module compilation, and a BE option check unit that checks whether the "BE" option for backend processing is specified in the command string. , "BE" Option part, which is started when an option is specified, converts the intermediate text from the intermediate text file into an object program and outputs it to the object program file, and an end processing part that performs the end process of the compile process after the process of this BE part. A compilation processing method characterized by including and.