JPH0328932A - Compiling system for extended language specifications - Google Patents

Abstract

PURPOSE:To improve the operability, the extension properties, and the maintenance properties of a system by providing a general-purpose compiler which translates a general-purpose language and a special compiler which translates an extended language to a special purpose and outputting the information en bloc after synthesizing them. CONSTITUTION:A special compiler 13 is provided to translate only the language used for a special purpose in addition to a general-purpose compiler which translates a general-purpose language. When a source program incorporating the language used to the special purpose is inputted, the compiler 12 starts the compiler 13. Then the information on the input source program, a diagnostic message, an object program, etc., are exchanged between both compilers 12 and 13 while they are performing the translating tasks. Simultaneously, both compilers translate the input source program is accordance with each partial charge. The compiler 12 synthesizes the results of translation of both compilers and outputs these synthesized information en bloc. Thus the operability is improved for users and simultaneously can easily package the extended specifications.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a compiling method for extended language specifications, and in particular, the present invention relates to a compilation method for extended language specifications, and in particular, a database operation language and a data processing language in general-purpose languages such as COBOL and PL/I. This paper relates to an extended language specification compilation method for translating an extended language specification source program in a format in which a language for special purposes such as a communication operation language is embedded. [Prior Art] Translation of general-purpose high-level languages such as COBOL and PL/I that are embedded with languages for special purposes such as database operation languages and data communication operation languages, that is, written with extended language specifications. As a conventional technique, for example, a technique described in Japanese Patent Laid-Open No. 62-216040 is known. This conventional technology includes a burric compiler and a funbaira, and performs language translation by serially dividing the work between these compilers. In addition, as another conventional technology, the functions of compilers for general-purpose high-level languages such as COBOL and PL/I are expanded so that they can handle extended language specifications. There is a known technology that makes it possible to translate general-purpose high-level languages.

Compilation methods according to these conventional techniques will be explained below with reference to the drawings.

FIG. 16 is a diagram illustrating a conventional technique using a precompiler and a compiler. In FIG. 16, 11 is a general-purpose high-level language source program written in an extended language specification, 34 is a precompiler, 35 is an intermediate source program converted by the precompiler into a format that can be processed by a compiler, and 36 is a precompiler. Diagnostic messages output by the compiler, various lists such as a list of source programs written by the user, l2 is a general-purpose high-level language compiler, l6 is the target program, 17 is a diagnostic message output by the compiler, intermediate source input by the compiler These are various lists such as a list of programs. In the prior art shown in FIG. 16, for example, a source program 11 in a general-purpose high-level language written in an extended language specification is written in a PL/I program in which a database operation language is embedded.
Assuming that this is a source program, we will explain the operation when translating this source program. The user first starts up the bricompiler 34. The precompiler 34 thereby analyzes the source program 1l written by the user, and outputs a diagnostic message 36 if there is an error in the program 11. Also, if the source program 11 is correct without errors,
The precompiler 34 converts the source program 11 into PL/
I format that can be processed by a general-purpose compiler, i.e. PL/I
The intermediate source program 35 is output. The user then starts the PL/I general-purpose compiler l2.
analyzes this intermediate source program 35, and if there is an error in the intermediate source program 35, a diagnostic message l is sent.
Outputs 7. Furthermore, if the intermediate source program 35 is correct without any errors, the PL/I general-purpose compiler l2 outputs the target program 16.

As described above, the conventional technique shown in FIG. 16 performs translation using a precompiler and a general-purpose compiler in series, and hereinafter, the method according to this conventional technique will be referred to as a precompiler method.

FIG. 17 is a diagram illustrating a compilation method according to the prior art that can handle extended language specifications. 17th
In the figure, each reference numeral is the same as in FIG. 16.

In the prior art shown in FIG. 17, for example, the source program 11 of a general-purpose high-level language written in an extended language specification is similar to the prior art shown in FIG. 16 described above.
Assuming that this is a PL/I source program with a database operation language embedded in it, we will explain the operation when translating this source program. The general-purpose compiler l2 in this prior art is a PL/I general-purpose compiler whose functions have been expanded so that it can handle the database operation language in the PL/I source program 11 in which the database operation language is embedded. This general-purpose compiler l2 is a source program l1 written by the user.
is analyzed, and if there is an error in the source program 11, a diagnostic message 17 is output, and if the source program 1l is a correct source program with no errors,
Output the target program l6.

The conventional technology shown in FIG. 17 uses a general-purpose compiler l2 whose functions have been expanded to be able to handle languages for special purposes such as a database manipulation language in a source program l in which a database manipulation language is embedded. ,Hereafter, this method based on the conventional technology will be referred to as the compiler-specific method. [Problems to be Solved by the Invention] The conventional technology using the precompiler method has the following problems. In other words, in this prior art, as explained using FIG. 16, errors discovered by the precompiler and errors discovered by the compiler are output as separate lists, making the list difficult to read. There is a problem.

Furthermore, in this prior art, the diagnostic message output by the compiler is for the intermediate source program output by the precompiler, and not for the source program written by the user. This has the problem that information such as padding characters is difficult for users to understand, and debugging efficiency cannot be improved.

Furthermore, the conventional precompiler-based technology has the problem of poor operability because it requires two job steps. This problem is solved by the above-mentioned Japanese Patent Application Laid-Open No.
This can be solved by using the technology described in Publication No. 16040, and operability can be improved. Since translation is performed on both sides, the problem arises that the time required for translation and the loss of computer resources such as CPU and storage area become large. In general, precompilers do not have detailed information about the attributes of names declared in the source program because they only analyze the part that should be processed by the precompiler itself. Therefore, the above-mentioned conventional technology has the problem that strict error checking cannot be performed in the semantic analysis process, and program defects are often not discovered until the program written by the user is executed. There is.
Additionally, since precompilers generally cannot satisfy all specifications of the target high-level language, unnatural constraints are often placed on the language specifications. For example, if a compiler has a macro function that can generate and modify a source program, the above-mentioned conventional technology can use this macro function to generate a part related to an extended language specification that is targeted by a precompiler. The problem is that it cannot be done.
Furthermore, in the conventional precompiler technology, the precompiler is used in a general-purpose high-level language (COBOL, PL/I1FORTRAN.
PASCAL, etc.) must be created in advance. Further, the conventional technology based on the compiler-specific method has the following problems.

In other words, with this conventional technology, it is difficult to implement extended specifications such as database manipulation languages in existing general-purpose high-level language compilers, and all general-purpose high-level languages that provide extended specifications (COBOL, PL/I% FORTRAN.
Similar processing for the extended specification must be implemented in a compiler (such as PASCAL, etc.), which poses a problem in that the development time for each compiler is large and wasteful.

For example, when it comes to database operation languages, the functionality of the language specifications often has to be expanded as the functionality of the database management system is expanded. In other words, in the above example, there is a problem in that the timing of the enhancement of the functionality of the database management system and the enhancement of the functionality of the compiler must be matched.6 The purpose of the present invention is to solve the problems of the prior art as described above. The purpose of this invention is to provide a method for compiling extended language specifications that improves operability for users and makes it easier for compilers to implement extended specifications.

[Means for Solving the Problems] According to the present invention, the above object is to provide a special compiler that only translates languages for special uses, separate from a general-purpose compiler that translates general-purpose languages, and to translate languages for special uses. The general-purpose compiler to which the embedded source program is input starts this special compiler, and during the translation process, the compiler exchanges information such as the input source program, diagnostic messages, target program, etc. This is achieved by translating the input source program, and having the general-purpose compiler combine the information from both translation results and output it all at once. [Operation] When a general-purpose compiler inputs a source program,
If the source program is a source program written with expanded specifications, a special compiler is started, the source program is translated while exchanging information with the special compiler, and the translation results are sent to the target program and various lists. A general-purpose compiler synthesizes and outputs only one. Therefore, the compilation method according to the present invention is
The user can treat it as if only the general-purpose compiler is running.

In addition, if multiple special compilers are required, the controller integrates these special compilers and performs all the interfaces between the general-purpose compiler and the special compiler, so the general-purpose compiler operates with only the controller in mind. This allows for flexible handling of additions and changes to extended specifications, special compilers, etc., and improves the extensibility and maintainability of the system.

Furthermore, if the language specifications for special purposes are common regardless of the type of general-purpose language in which they are embedded, this one specialized compiler can translate this common extended language specification. A compiler for a general-purpose language only needs to implement the function of interfacing with a special compiler, and does not need to have all the functions related to actually translating the extended specifications.
This makes it easy to provide a function to translate this extended specification into various general-purpose languages such as FORTRAN and PL/I. [Embodiment] Hereinafter, an embodiment of the extended language specification compilation method according to the present invention will be described in detail with reference to the drawings.

FIG. 1 is a block diagram showing the basic configuration of the first embodiment of the present invention. In FIG. 1, l1 is a source program written in an extended language specification, l2 is a general-purpose high-level language compiler (hereinafter referred to as a general-purpose compiler), 1.
3 is a special compiler that translates only the part of the extended language specification; 16 is the target program as a result of translating the source program; and 17 is various lists such as diagnostic messages, source program list, cross reference list, etc. Further, 4 is information passed from the general-purpose compiler to the special compiler, and l5 is information passed from the special compiler to the general-purpose compiler.

When a user attempts to translate a source program 11 written in the extended language specification, the user first uses the general-purpose compiler 1.
Start 2. The activated general-purpose compiler 12 takes in the source program 11 and analyzes it. When the general-purpose compiler l2 discovers a part described in the extended specification during this process, it starts the special compiler l3 and passes information l4 related to the extended specification part to the special compiler l3.

The special compiler l3 translates only the extended language specification part based on the information received from the general-purpose compiler l2, and returns information l5 of the translation results such as the target program and diagnostic messages to the general-purpose compiler 12. The general-purpose compiler l2 outputs the target program, diagnostic messages, etc. that are the results of its own translation process, and the special compiler l2.
The target program, diagnostic message, etc. returned from 3 are combined and output as a target program 16 and various lists 17.

According to the first embodiment of the present invention, the translation result is synthesized by the general-purpose compiler together with the target program and various lists and only one output is output. appears to be working. In addition, the list of diagnostic results that are output is
The output is in the same format as if it were directly obtained from the source program written by the user, making it easier for the user to understand. FIG. 2 is a block diagram showing the basic configuration of a second embodiment of the present invention, and FIG. 3 is a flow chart explaining the processing operation of the controller. In FIG. 2, 13a and 13b are special compilers, and 18 is a controller. Also, 1
4a to 14c, 15a-+5b are information sent and received between the compiler and the controller, and other codes are the first
This is the same as the case shown in the figure.

In a second embodiment of the invention shown in FIG. 2, the source program 11 includes a plurality of extended language specifications, such as a database manipulation language and a data communication manipulation language. Therefore, the second embodiment of the present invention includes special compilers 13a and 13b for translating each of these multiple extended language specifications, and these special compilers 13a and 13b and the general-purpose compiler 1
controller 1 that controls the interface between
It is equipped with 8.

When a user wants to translate a source program 1l written in the extended language specification, the user must first use a general-purpose compiler 1l.
Start 2. The activated general-purpose compiler l2 takes in the source program l1 and analyzes it. When the general-purpose compiler 12 discovers a part described in the extended specification during this process, it generates information 14a related to the extended specification part.
is passed to controller l8.

The controller 18 divides the information received from the general-purpose compiler 12 into each part of a plurality of extended specifications, edits it if necessary, activates the special compilers 13a and 13b in charge of each translation, and creates the necessary information for the translation. These compilers 13a . ]3b.

The special compilers 13a, 13b translate information regarding the given extended specification part, and send information 15b, 15c of the translation results, such as the target program and diagnostic messages, to the controller 18. The controller 18 stores these pieces of information 15b. 15c is edited and integrated if necessary, and sent to the general-purpose compiler l2 as information 15a. The general-purpose compiler 12 outputs daily programs, diagnostic messages, etc. that are the results of its own translation processing, and the controller l8.
FIG. 3 shows the processing flow of the controller 18 in the second embodiment of the present invention, which synthesizes the object program, diagnostic message, etc. sent back from the computer and outputs it as the object program l6 and various lists 17. This will be explained below.

(1) Regarding all of the information 14a received from the general-purpose compiler l2, is it information that should be passed to the special compiler 13a?Special compiler! The information to be passed to 3b is identified and classified, and the information to be passed to each special compiler is set (steps 31 to 34).

(2) Steps 33 and 34 for all information 14a
After completing the setting of the information, the special compiler 13
a, and cause the compiler 13a to perform translation processing,
The information returned from the compiler 13a is set as information to be returned to the general-purpose compiler l2 (step 35).
, 36).

(3) Similar to steps 35 and 36, special compiler 1
3b, the compiler 13b performs translation processing, and the information returned from the compiler 13b is set as information to be returned to the general-purpose compiler l2 (step 3).
7, 38).

Note that in the above-described processing flow of the controller 18 explained with reference to FIG. 3, the processing of steps 37 and 38 may be performed in parallel with steps 35 and 36. According to the second embodiment of the present invention described above, since the interface between the general-purpose compiler and the special compiler is performed by the controller, the general-purpose compiler
It only needs to operate with the controller in mind, and it can flexibly deal with additions and changes to extended specifications, special compilers, etc., and can improve the extensibility and maintainability of the system. FIG. 4 is a block diagram showing the basic configuration of the third embodiment of the present invention. 41st! In I, lla and 1lb contain common extended language specifications and are source programs written in different general-purpose languages, l2a and 12b are general-purpose compilers that translate the respective general-purpose languages, and 16a and 16b.
is the target program that is the result of translating the source program,
17a. Reference numeral 17b indicates various lists such as a diagnostic message, a source program list, a cross reference list, etc., and the other symbols are the same as in FIGS. 1 and 2. The third embodiment of the present invention shown in FIG. 4 is capable of translating a plurality of source programs written in different languages, each of which has a common special operation language inside. lla is written in the COBOL language, and the source program 1lb is written in the PL/I language, and is a source program including a database operation language having common specifications. In the example shown in FIG. 4, two types of source programs are shown, but there may be many more source programs. In this case, a general-purpose compiler may be added to match the number of source programs. When a user wants to translate a source program lla or llb written in the extended language specification, first, the user starts the general-purpose compiler 12a or 12b according to the type of general-purpose language in which the source program is written.

The general-purpose compiler 12a converts the source program 1]a into
The general-purpose compiler 12b takes in the source program llb and analyzes each of them.

When the general-purpose compiler 12a% 12b discovers a part described in the extended specification during this analysis process, it passes information 14a, l4b related to the extended specification part to the special compiler l3. At this time, the information 14a and 14b are passed to the special compiler in the same format. The special compiler l3 performs translation based on this information 14a and 14b, and returns information 15a and 15b of translation results such as the target program and diagnostic messages to the general-purpose compilers 12a and 12b, respectively. At this time, information 15
a and 15b have the same format.

The general-purpose compiler 12a% 12b synthesizes the target program, diagnostic message, etc., which is the result of its own translation process, and the target program, diagnostic message, etc. returned from the special compiler 13, and creates the target program 16a,
1 6 b, and output as various lists 17a and 17b, respectively. According to the third embodiment of the present invention described above, each general-purpose compiler only needs to implement the function of interfacing with the special compiler, and most of the functions related to translation of extended specifications are implemented only by the special compiler. I will do it. Accordingly, the third embodiment of the present invention is a COBO
It becomes possible to translate extended specifications for various general-purpose languages such as L, FORTRAN, and PL/I.

In the third embodiment of the present invention described above, there is one extended language specification included in the source program, but
The present invention can also be applied to a case where each of a plurality of source programs includes a plurality of extended language specifications. In this case, a second compiler is installed at the location of the special compiler 13 shown in FIG. Controller 1 similar to the one shown in the figure
8 and connect a plurality of special compilers to this controller 18. 6 Figure 5 is a block diagram showing the configuration of the fourth embodiment of the present invention, and Figure 6 is a PL program in which the database manipulation language SQL is embedded. A diagram showing an example of a /I program, FIG. 7 is a diagram showing an example of the content of information passed from the PL/I controller to the SQL controller, and FIG. 8 is a diagram showing an example format of information regarding the source program in FIG. Figure 9 is a diagram showing an example of the format of information regarding attributes of variables in Figure 7, Figure 10 is a diagram showing an example of the content of information passed from the SQL controller to the PL/I controller, and Figure 11 is in Figure 10. FIG. 12 is a diagram showing an example format of information regarding the diagnostic message in FIG. Figure 14 shows a format example, Figure 14 shows the relationship between the target programs generated by PL/I and the SQL compiler, Figure 15 shows PL/■
This is a flowchart explaining an overview of the processing contents of the compiler. In FIG. 5, l9 is a PL/I program in which the database operation language SQL is embedded, and 20 is a PL/I program.
/I compiler, 2l is an SQL compiler that translates SQL, 22 is a database management system, 23 is a dictionary that stores information regarding the database, and other symbols are the same as in FIG. The fourth embodiment of the present invention shown in FIG. 5 is a concrete version of the first embodiment of the present invention explained in FIG.
This fourth embodiment will be explained with reference to FIGS. 6 to 15.

PL/I with embedded SQL source program
As shown in FIG. 6, the program 19 contains variable declarations 25 in PL/I for variables used in SQL and database operations in a PL/I statement 24 written in the basic specifications. An SQL statement 26 that instructs is embedded.

This source program example is rJIS
05-1987J. When attempting to translate the PL/I program 19 configured as described above, the PL/r compiler 20 is first started. The PL/I compiler 20 takes in the source program l9, and as a result of syntax analysis, the PL/I program l9 is
When it is determined that QL is being used, the SQL compiler 2l is dynamically loaded. This loading of the SQL compiler may be performed when the compiler option of the PL/I compiler specifies that SQL is used. Then, the PL/I compiler 20 passes information l4 from the SQL statement 26 and variable declaration 25 to the SQL compiler 2l.
Generate. As shown in FIG. 7, the content of this information 14 is composed of a plurality of pieces of information 27 about the source program, a plurality of pieces of information 28 about the attributes of variables, and the like.
FIG. 8 shows an example of the format of information regarding the source program, and FIG. 9 shows an example of the format of information regarding the attributes of variables. and PL/I compiler 20
passes control to SQL compiler 2l. The SQL compiler 2l uses the information passed from the PL/I compiler 20.
Execute the analysis in step 4. During this analysis process, the SQL compiler 2l accesses the dictionary 23, which stores database definition information, etc., via the database management system 22, and checks the meaning of the SQL.
Further, the SQL compiler 21 translates SQL based on the information l4 passed from the PL/I compiler 20, and generates information l5 to be passed to the PL/I compiler 20, such as a target program and a diagnostic message. As shown in FIG. 10, the contents of the information 15 are comprised of information 29 regarding the target program, information 30 regarding the diagnostic message, information 31 regarding the mutual reference between names, and the like. An example of the format of the information 29 regarding the target program is shown in FIG. 11, an example of the format of the information 30 regarding the diagnostic message is shown in FIG. 12, and an example of the format of the information 31 regarding the mutual reference relationship between names is shown in FIG. has been done. And SQL compiler 2
l returns control to the PL/I compiler 20.

The PL/I compiler 20, as shown in FIG.
The SQL statement written in the L/I program l9. SQ
Calling the target program generated by the L compiler 21 (
CALL statement in PL/I language), PL/I
Continue translating the parts written in the language.

When this translation is completed, the PL/I compiler 20
It combines the information l5 received from the QL compiler 2l with its own translation results and outputs a target program l6 and various lists l7.

An overview of the processing contents in the aforementioned PL/I compiler 20 is shown in the form of a flowchart in FIG. 15, which will be explained below.

As shown in FIG. 15, the processing in the PL/I compiler 20 is performed by syntax analysis processing, declaration analysis processing, and object program generation and list output processing. In the syntax analysis process, after a source program is input, the SQL statement in the source program is extracted, and based on the extracted SQL statement, information to be passed to the SQL compiler is set, and the source program is converted into a C:ALL statement. This is done by converting and applying normal processing to non-SQL statements. Declaration analysis processing analyzes declaration statements in a source program, and if the declaration statement is used in an SQL statement, the SQL compiler This is the process of setting the information to be passed to.

In addition, when there is an SQL statement in the source program, the object program generation and list output processing is performed using the object program and various lists passed from the SQL compiler, and the object program and various lists generated by the own PL/I compiler. This process combines and outputs the

In the process of the PL/I compiler described above, synthesis of the target program involves outputting the target program output by the PL/r compiler 20 and the target program output by the SQL compiler 2l as separate control sections, and editing the combination thereof. Also, the PL/I compiler 20 rewrites the offset information etc. in the target program output by the SQL compiler 2l to make it the same as the target program output by itself. It may also be output as a control section.

In addition, PL/I compiler 20 and SQL compiler 2l
The information 14, 15 sent and received between the two may be transferred to each other via the main storage device, or may be transferred to each other via the external storage device.

In addition, PL/I compiler 20 and SQL compiler 2l
The control may be transferred only once, as in the case of the plurality of embodiments of the present invention described above, or may be transferred multiple times, such as during declarative analysis, syntactic analysis, and semantic analysis. You may do so.

[Effects of the Invention] As explained above, according to the present invention, the following effects can be achieved.

The user only needs to start the general-purpose compiler and there is only one job step, so it is easy to use.

By receiving information such as statement numbers from the general-purpose compiler, the diagnostic messages etc. output by the special compiler can be output in the correct format, that is, in the same format as if they were directly obtained from the source program written by the user. It becomes easy to understand for users.

Regarding the compiler's internal processing such as lexical segmentation and syntax analysis, for example, a general-purpose compiler performs all the processing and passes the result to a special compiler as an intermediate word, or the general-purpose compiler recognizes the start of an extended specification. By adopting a technique such as not performing analysis processing unconditionally up to the beginning of the next sentence and leaving it to the processing of a special compiler, unnecessary duplication of processing can be avoided. Therefore, loss of computer resources can be kept to a minimum.

Name information declared within the source program is analyzed by a general-purpose compiler and the resulting information is passed to a special compiler, or a special compiler analyzes the part described in the extended specification and then analyzes the information. By passing the resulting information to a general-purpose compiler, more rigorous error checking becomes possible during translation.

The general-purpose compiler processes all the basic specification parts, and the special compiler processes only the parts described in the extended specifications, so there are no unnatural restrictions imposed by the language specification.

Modifications to the compiler due to additions and changes to extended specifications can be localized to only modification of the special compiler.
It is possible to improve the expandability and maintainability of the system.

When handling a program that includes multiple extension specifications, by providing a controller and having the controller integrate special compilers for each extension specification, the interface that the general-purpose compiler must be aware of is the interface with the controller. This makes it easier to develop a general-purpose compiler. Even if extended specifications are added and the number of special compilers increases, the interface between the general-purpose compiler and the controller remains the same, so there is no need to modify the general-purpose controller, and even if modification is required, it will be minimal. ．． For example, the SQL language, which is a database manipulation language, is r
According to JIs X 3005-1987J standard,
COBOL. Even when embedded in existing general-purpose high-level languages such as PL/I and FORTRAN, all extended parts have the same syntax and the same semantic rules. Therefore, for such extended specifications, if only one special compiler is developed to process the extended specifications, various general-purpose compilers can implement only the function to interface with this special compiler, and this special compiler By handshaking with , this extended specification can be easily used in various general-purpose high-level languages. Therefore, it is possible to reduce the cost required for developing a compiler.

[Brief explanation of drawings]

FIG. 1 is a block diagram showing the basic configuration of the first embodiment of the present invention, FIG. 2 is a block diagram showing the basic configuration of the second embodiment of the present invention, and FIG. 3 explains the processing operation of the controller. FIG. 4 is a block diagram showing the basic configuration of the third embodiment of the present invention, FIG. 5 is a block diagram showing the configuration of the fourth embodiment of the present invention, and FIG. 6 is a database operation language SQL Figure 7 is a diagram showing an example of the content of information passed from the PL/I controller to the SQL controller, and Figure 8 is the format of the information regarding the source program in Figure 7. Figure 9 is a diagram showing an example of the format of information regarding attributes of variables in Figure 7. Figure 10 is a diagram showing an example of the content of information passed from the SQL controller to the PL/I controller. Figure 11 10 is a diagram showing an example of the format of information regarding the target program in FIG. Figure 12 is a diagram showing an example of the format of information regarding the diagnostic message in Figure 10, Figure 13 is a diagram showing an example of the format of information regarding the reference relationship between names in Figure IO, and Figure 14 is a diagram showing an example of the format of information regarding the mutual reference relationship of names in Figure 10. FIG. 15 is a flowchart outlining the processing contents of the PL/I compiler, and FIGS. 16 and 17 are block diagrams showing the configuration of the conventional technology. be. 11... Source program written and described using extended language specifications, 12... General-purpose compiler, 1
3... Special compiler, l4... Information passed from general-purpose compiler to special compiler, 15...
...Information passed from the special compiler to the general-purpose compiler,
16...Target program resulting from translation of the source program, 17...Various lists such as diagnostic messages, source program list, etc., 18...
・Controller that collectively controls the special compiler group, l9... Database operation command MrIS Q
PL/I program with embedded L, 20...
... PL/r compiler, 2] ... SQL compiler that translates SQL, 22 ... Database management system, 23 ... Dictionary that stores information about the database. Figure 6 JE21!1 Figure 3 Figure 10 Figure 7 Figure 8 Figure 9 Figure 11 Figure 12 #! Fig. 13) 1 bet o R + r < shout o water 1♂4 Fig. 16 Fig. 17

Claims (1)

[Claims] 1. In a compiler that translates a source program in a format in which extended language specifications for a special purpose are embedded in a general-purpose language and generates a target program, the general-purpose language is translated. The general-purpose compiler is provided with a general-purpose compiler that translates an extended language for a special purpose, and a special compiler that translates an extended language for a special purpose. Based on this information, the special compiler translates the part written in the language for the special purpose, sends the translation result information back to the general-purpose compiler, The compiler is
An extended language specification compilation method that combines this information with information resulting from the translation of parts written in a general-purpose language by the general-purpose compiler itself and outputs them all at once. 2. If the source program is a source program embedded with extended language specifications for multiple types of special uses, multiple special compilers that translate languages for these special uses, and these special compilers 2. The extended language specification compilation method according to claim 1, further comprising: a general-purpose controller, and wherein said controller interfaces with a general-purpose compiler that translates a general-purpose language. 3. If there are multiple types of source programs and an extended language for a special purpose with common specifications is embedded in these source programs, a special compiler that translates the language for this special purpose. of,
The extended language specification compilation method according to claim 1 or 2, characterized in that it is provided in common for a plurality of general-purpose compilers that translate the source program.