JPS6359632A - Compiler control system - Google Patents

Abstract

PURPOSE:To reduce capacities of the second intermediate text area and a dictionary memory by taking variables common to blocks and individual variables of blocks into consideration as variables and dividing a source text into blocks to execute the processing. CONSTITUTION:A designated area 4 is prepared on a dictionary memory 21 and variables common to blocks are stored there, and individual variables of blocks in a function func1 are stored in a rewritable area 5. After the compiling processing, contents of the rewritable area 5 are cleared. In the processing of a block 2, new variables common to blocks do not appear and an object concerning a function func2 is generated, and individual variables of this block are cleared after compiling. In the processing of a block 3, new variables common to blocks appear and are added to the designated area 4, and an object concerning a function func3 is generated, and individual variables of this block are cleared after compiling.

Description

[Detailed Description of the Invention] [Summary] A compiler that generates an object program compatible with a target machine from a given source text, compiles the entire source text by sequentially compiling it in block units. When compiling each block as a unit, common variables between blocks are left in the dictionary memory.

A compiler control method has been disclosed in which block individual variables are cleared in a dictionary memory after processing, and compiling processing is efficiently performed using a small-capacity main memory without using an external storage device.

[Industrial application field]

The present invention relates to a compiler control method, and particularly to a compiler control method that sequentially compiles source text in blocks.

[Conventional technology]

Conventionally, a given source text is read and an object program corresponding to a desired target machine is generated. A compiler that generates the object program has a syntax analysis phase, an optimization phase, and a code generation phase.

The system converts source text into intermediate text, optimizes the intermediate text, and then encodes the optimized intermediate text.

Figure 3 shows the general configuration of the compiler.

Reference numeral 10 denotes a pre-processor which reads the illustrated source text (JEF) 16 and creates a first intermediate text 18, and also creates an EBCplC encoded source text 17. 11 is a parsing phase, the first
A second intermediate text is created based on the intermediate text 18 while using the main memory 15. 12 is an optimization phase.

The second intermediate text is optimized while using the main memory 15. 13 is a code generation phase in which 5 main memories 1 are used for the intermediate text being optimized.
5, the object program 19 is generated. Further, 14 is a control unit that controls the entire compiler. Furthermore, 20 represents a printout regarding the object. Note that the dictionary memory according to the present invention can be considered to exist as a dictionary memory 21 in the main memory 15, as shown in FIG.

[Problem that the invention seeks to solve]

In the conventional case, a given source text was supplied as a whole to the pre-processor 10, and the compilation process was performed taking the whole into consideration. For this reason, in the conventional case, a large capacity was required for the dictionary memory 21 for storing variables and the area 22 for storing the second intermediate text.

[Means for solving problems]

The present invention solves the above points, and as a variable.

By being aware of inter-block common variables and block individual variables, the source text can be divided into blocks,
Block as unit 1 For example, in Figure 3, element 1
1, 12, and 13 are executed.

FIG. 1 shows a basic configuration diagram of the present invention. Reference numeral 16 in the figure is the source text; 1. 2. 3.・・・・・・
1-1.3-1 are inter-block common variable specification sections, 1-2.2-2.3-2 are function specification sections, 21 is a dictionary memory, and 4 is a specification area.

5 represents a rewritable area. Also ■, ■.

. . .■ represents the progress order of processing.

A given source text 16 is composed of a plurality of blocks 1, 2, 3, etc. containing at least one function.
It is divided into Then, the blocks are compiled sequentially.

In the case of the present invention, since processing proceeds in units of blocks, this is a variable required during compilation.

(i) Variables that are commonly used across multiple blocks (referred to as common variables between blocks...
...5tatic).

(ii) Variables used only for compilation processing for the block (referred to as block individual variables) These are divided into two concepts.

And regarding the common variables between blocks when compiling the blocks.

The data is stored in the specified area 4 in the dictionary memory 21, and the block individual variables are stored in the rewritable area (so to speak, a work area) in the dictionary memory 21, and then the compilation process is performed. When the compiling process is completed, the block individual variables at that time are cleared and the compiling process for the primary block is started. Naturally, at this time, the area for storing the second intermediate text is also initialized and reused.

[Effect]

The designated area 4 on the dictionary memory 21 in
is prepared and common variables between blocks are stored. Next, in relation to the function func 1, block individual variables (objects of func 1) in the function func 1 are stored in the rewritable area 5 as shown in 2 (2).

Then, after the compiling process is performed, the contents of the rewritable area 5 are cleared at (2) in FIG. 1 (the contents of the designated area 4 remain and are used in subsequent processing).

When processing block 2, no new inter-block common variables appear, as shown in Figure 9 (func).
2 objects are created.

Cleared after compilation.

Regarding the processing regarding block 3 shown in the figure.

A new inter-block common variable appears, is added to designated area 4, an object for func3 is created, and is cleared after compilation.

Since the processing is performed as described above, the dictionary method 21
The capacity of is sufficient as long as it can store inter-block common variables and block individual variables for the block being processed. Also, regarding the second intermediate text HIT area, it is not necessary to have an area for storing the entire source, and it is sufficient that the area is large enough to store one block.

〔Example〕

Figure 2 shows an example, and the symbol 1.1-1゜1-2 in Figure 3
．． 2.2-1.2-2.4, 5, 16.21 correspond to FIG. Also, var l+ var 2+ var 3. var shown in '5tatic int'
4 is a numerical value and represents an inter-block common variable according to the present invention.

"5hort", "int", "long", "uns"
igned”.

b.1. u, *p, and var3 represent block individual variables, respectively. In addition, in the case shown, the variable va
r3 is also used as a block individual variable in block 2.

When block l is accepted, inter-block common variable var
1 and var 2 are stored on the designated area 4.

Also, in the function main defined in block 1, as a block individual variable, (i) 5hort
If the variable a is an int, (ii) a normal int (
(iii) long in
Since the variable l is given as t, each of these variables a and b.

l is stored in the rewritable area 5. Under this state, the compilation process for block 1 is performed, and when it is completed, variables a, b, and 1 are cleared, and the contents of the second intermediate text area 22 are also initialized.

In response to processing regarding block 2, Pro.

Common variables var3 and var4 are given.

It is added on the designated area 4. Also, as a block individual variable for block 2, (i) unsign
A variable U is given as edint, (ii) a variable *p is given as a normal int, and (iii) a variable var 3 is given as a long int, and these are stored in the rewritable area 5.

〔Effect of the invention〕

As described above, according to the present invention, it is possible to use a relatively small capacity second intermediate text area and dictionary memory.

[Brief explanation of drawings]

FIG. 1 shows the principle configuration of the present invention, FIG. 2 shows an embodiment of the invention, and FIG. 3 shows the configuration of a compiler. In the figure, 1, 2.3... are blocks, respectively, and 1-1
゜2-1.3-1 are respectively inter-block common variable specification parts, 4 is a specification area, 5 is a rewritable area, 10 is a preprocessor, 11 is a syntax analysis phase, 12 is an optimization phase, 13 is the code generation phase. Reference numeral 16 represents a source text, 19 an object program, 21 a dictionary memory, and 22 a second intermediate text area. Patent Applicant: Usatsuk Electronic Industry Co., Ltd. Representative Patent Attorney Mori 1) Hiroshi (and 2 others) Funnomichi Imitation Zuto Mizoho Sword 3 Kuchi

Claims (1)

[Claims] A parsing phase (11) comprising a preprocessor (10) that reads a given source text (16) and parsing the read source text; Optimization phase (12) in which the intermediate text obtained by 11) is optimized.
and a code generation phase (13) in which the encoded intermediate text is coded in a form compatible with the target machine, and a compiler that generates an object program (19) from the given source text. , the source text (16) consisting of a plurality of blocks (1, 2, 3) including at least one function is configured to be compiled in units of blocks, and is a processing target. The inter-block common variables (var1, etc.) defined in the block are stored in the dictionary memory (21).
The block individual variables (a,
b, etc.) in the rewritable area (5) on the dictionary memory (21).
) and compile processing for the block to be processed using the variables in the predetermined specified area (4) and the variables in the rewritable area (5). The second process executes the above-mentioned predetermined designated area (
and a third process that leaves the variables in 4) and clears the variables in the rewritable area (5), and takes over the first process for the next block. Compiler control method.