JPH01159733A - Source program generation processing system in precompiler - Google Patents

Abstract

PURPOSE:To increase the efficiency of source generation by setting a parameter in a preliminarily generated prototype without generating the corresponding prototype at every time if there are the plural same instructions. CONSTITUTION:A generating part 6 sets the parameter 61 based on an intermediate text which an analyzing part 5 obtains by analyzing a source program 3. An editing part 7 receives the parameter 61, and generates the source. Namely, it calls out the prototype corresponding to a prototype name 'n' out of a prototype table 72. When the source during being generated can not be stored in a record area 8, the editing part 71 stores data in the record area by providing a folding processing means. Thus, since the editing part 71 opens a new line automatically, the source can be edited without being conscious whether the data can be stored in the record area or not.

Description

[Detailed Description of the Invention] [Summary] Regarding a source program generation processing method in a precompiler.

Aimed at improving the efficiency of source generation.

In a precompiler that generates a source program for another compiler as a target program based on analysis information obtained by analyzing an input source program, based on the analysis information.

a generation unit that generates a source type name of a source program for the other compiler; a table that stores the source type corresponding to the source type name; and an editing unit that calls the source type from a table, and is configured to generate the current source by combining and aggregating the called source type and data.

[Industrial application field]

The present invention relates to a precompiler, and more particularly, to a precompiler.

This paper relates to a source program generation processing method in a flash compiler.

A target program obtained by compiling a source program with a certain compiler may be used as a source program for another compiler. A compiler that generates such a target program is called a precompiler.

[Conventional technology]

A precompiler generally has an analysis section that analyzes an input source program and creates analysis information such as a dictionary or intermediate text, and a generation section that generates a source program for another compiler as a target program based on this analysis information. It consists of

When this generator generates a source program for another compiler, one instruction at a time.

That is, kM collection is performed for each line of the intermediate text description.

It was generating a source (object).

FIG. 6 is an explanatory diagram of the prior art, in which C0B is used as a source.
This shows a case where an OL source is generated.

In FIG. 6, 70 is the source to be generated (COB
OL source), 8 is a record area that temporarily holds the source 70, and 4 is a file that holds the source program.

For example, if there is one transcription instruction in the analysis information such as intermediate text, the corresponding source is 5.
A source 70 is generated as shown. That is, this source 70 is rMOVEJ in response to the transfer command.
, rTOJ, and rAJ, rBJ handled by this instruction.

It is generated by combining the data "," and editing them.

1 for one instruction, that is, one line of intermediate text description.
Two sources are generated in record area 8.

Subsequently, it is transferred to file 4.

By repeating the above process for each line of the intermediate text, a source program as the target program is obtained in the file 4.

[Problem that the invention seeks to solve]

According to the prior art described above, even if there are multiple identical instructions (for example, transfer instructions), information such as rMOVEJ, etc. is set and "A" is set for each instruction each time.
. . . The process of combining data and generating sources by editing these data is repeated.

By the way, among multiple sources corresponding to multiple identical instructions obtained in this way, rMOVEJ.

The information part rTOJ is the same. Therefore,
If such an information portion is generated only once for a plurality of the same instructions, it can be used repeatedly to improve the efficiency of source generation. However, in the prior art, a source was generated for each instruction, so the processing efficiency was not necessarily good.

SUMMARY OF THE INVENTION An object of the present invention is to provide a source program generation processing method for a precompiler that improves the efficiency of source generation.

[Means for solving problems]

FIG. 1 is a diagram showing the basic structure of the present invention, and shows a compiler processing system including a precompiler according to the present invention.

In FIG. 1(A), 1 is a precompiler.

2 is a compiler, 3 is a source program, 4 is a source program for compiler 2 which is the target program of the precompiler l, 5 is an analysis section, 6 is a generation section, 61 is a parameter, 7 is a prototype handler, 71 is an editing section,
72 is a prototype table, and 8 is a record area.

A target program 4 generated based on a source program 3 in a precompiler 1 is used as a source program 4 for a compiler 2.

The analysis unit 5 analyzes the input source program 3 and creates analysis information such as a dictionary or intermediate text.

Based on this analysis information, the generation unit 6 generates a parameter 61 consisting of a constant name (prototype name) called a prototype (source type) and data, as shown in FIG. 1(B).
Set. In the generation unit 6, the source is not directly generated, but the type of the source is generated.

The editing unit 71 calls the prototype specified by the prototype name of the parameter 61 from the prototype table 72 as shown in FIG. 1(C).

Then, the called prototype and data are combined and edited to generate a source.

The generated source is held in the record area 8.

Transferred to file (4). As a result, a source program 4 is obtained.

[Effect]

A case will be described in which a COBOL source for a transcription instruction as shown in FIG. 6 is generated as a source.

Here, in response to the transfer command, rMOVE ATOB
, J, when generating a source rM.

VE (data) To (data)'' is a prototype (source type), and its prototype name (for example n) is 1
1. Also.

"A" and "B," are data. That is, when looking at multiple transfer instructions, rMOVE (data) To (
Since the information portion "data)" is common to each, it is treated as a constant, that is, a prototype, and the information portion that is not common to each is treated as data.

When there is a transcription command, the generation unit 6 generates the prototype name r
nJ is generated, and together with this, the data (for example, rAJ, rB, J) in the relevant transcription instruction is set as a parameter 61 (FIG. 1(B)).

The editing unit 71 selects the corresponding prototype rMOV from the 5 prototype table 72 according to the prototype name rnJ.
E■TO■'' is called. Then, place the first data rAJ at the position of the first ■ mark, and place the second data “B,
” in the position of the second ■ mark to obtain the source.

Similarly, for other posting instructions, the prototype name rn
J is generated, according to which a prototype rMo V
E ■ TO ■'' is called, the data is combined and edited, and the source is generated. That is.

If there are multiple identical instructions, the corresponding prototype is
It is not generated each time, but is called from the prototype table 72 created in advance.

By setting the parameter 61 in this manner, it is not necessary to repeatedly generate the information portion corresponding to the prototype even when there are a plurality of the same instructions, so that the source can be generated efficiently.

〔Example〕

(al　Explanation of one embodiment Compiler 2 is a C0BOL compiler.

An example will be described in which the precompiler 1 creates a COBOL source for a transcription instruction such as transcribing certain data rZEROJ to other data rTOKYO.

The generation unit 6 sets parameters 61 based on the intermediate text obtained by the analysis unit 5 analyzing the source program 3. At this time, the name of 1 prototype is rnJ, and the data is r
ZEROJ and rTOKYo3".

1JHffi unit 71 receives parameters 61 and generates a source. In other words, call the prototype "rMOVE ■ To ■" corresponding to the prototype name rnJ from the prototype table 72. Next, insert the first data rZBROJ at the position of the first ■ mark - the C0BOL source edited up to this point. 2, for example, as shown in FIG.

Now, record area 8 consists of 80 bytes and 9 part 72
Assume that the byte is an information part and the remaining 8 bytes are an ID part. Assume that 68 bytes are required to describe up to rMOVEZEROTOJ. In this case, the 1 normal ID section is left blank, so the data rTOKYo, J, which requires 6 bytes, does not fit into the record area 8.

Based on the editing results up to this point, the editing department 71
As described above (recognizing that the source being generated does not fit within the record area 8, the following wrapping process is performed.

That is, as shown in FIG.
After transferring up to ZEROTOJ to file (4) and clearing the record area 8 to make it blank, edit the remaining data rTOKYo, J and save it to record area 8.
Store it in. and.

It is associated with the record and becomes one source.

In this way, by providing the wrapping processing means in the 1 editing section 71, when the source does not fit in the record area 8, this is recognized and line breaks are automatically performed (wrapping is performed).
Therefore, the source can be edited without being concerned about whether the data will fit within the record area 8.

(bl Other Embodiments As shown in FIG. 4, an example in which data is continuously edited when generating a source will be described.

When generating a C0BOL source as shown in Figure 4, i
Usually, it is necessary to read the data rABJ into the record area 8 with reference to the dictionary and repeat the process of generating the source as many times as necessary.

In this embodiment, in order to distinguish it from the type of transcription instruction in the previous embodiment, an independent prototype name (for example, rn'J) is used for the source type as shown in FIG. 4, and a prototype name for continuous editing of data is used. is held in the prototype table 72.

Further, in this embodiment, the parameters 61 are set as shown in FIG. That is, since the parameter 61 needs to have a plurality of pieces of data (that is, a large amount of data), it holds only the address in the dictionary where the data is held instead of the data. This makes it possible to have all the data (actually, addresses) necessary for continuous editing with a small parameter size. Incidentally, after "address 6" corresponding to the last data rFG,J.

An end record is provided to notify the editing unit 71 of the end of continuous editing.

The generation unit 6 generates parameters as shown in FIG. 5 including the prototype name "n'". Based on this, the 1 editing unit 71 calls the corresponding prototype from the prototype table 72 and reads data from the dictionary address indicated by the address 1 to address 6 of the parameter 61. Then, these are combined and edited to generate one source, for example.

In this way, by providing an iterative processing means to continuously edit data, sources can be generated more efficiently.

Although the present invention has been described above with reference to embodiments, the present invention can be modified in various ways according to its gist.

For example, in the COBOL source, one with a subscript and one without a subscript are separately provided as a prototype,
By setting a subscript as data as a parameter, the prototype handler may automatically add this information. That is, a means for automatically adding additional information such as a designated subscript or period may be provided.

〔Effect of the invention〕

As described above, according to the present invention, when there are a plurality of identical instructions in the source program generation process in a precompiler, sources for these instructions can be efficiently generated.

[Brief explanation of the drawing]

FIG. 1 is a diagram explaining the principle of the present invention. FIG. 2 and FIG. 3 are explanatory diagrams of one embodiment. FIG. 4 and FIG. 5 are explanatory diagrams of other embodiments. FIG. 6 is an explanatory diagram of the prior art. l is a precompiler, 2 is a compiler, 3 is a source program, 4 is a source program which is a target program,
5 is an analysis section, 6 is a generation section, 7 is a prototype handler,
8 is a record area, 61 is a parameter, 71 is an editing department,
72 is a prototype table.

Claims (1)

[Scope of Claim] In a precompiler that generates a source program for another compiler as a target program based on analysis information obtained by analyzing an input source program, the precompiler generates a source program for another compiler as a target program. A generation unit that generates the type name of the source program source for (
6), a table (72) that stores the source type corresponding to the source type name, and an editing unit that calls the source type from the table (72) using the source type name. (71) A source program generation processing method in a precompiler, characterized in that the source is generated by combining and editing the type and data of the called source.