JP3085956B2 - Object oriented language translation processor - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Summary] The present invention relates to an object-oriented language translation processing apparatus that generates a translation program written in a predetermined language by translating a source program written in an object-oriented language. For the purpose of increasing the speed and facilitating the development of application programs, the translation processing apparatus is based on information for instructing whether to compile a source program in a dynamic binding mode or a static binding mode. A mode judging unit (11) for judging in which mode the source program is to be compiled, and a plurality of source programs when the mode judging unit (11) judges that the mode is the dynamic combination mode. Search for inheritance information of individual objects in the object is performed at the execution stage When the dynamic expansion unit (12) that expands the translation program in such a format and the mode determination unit (11) determines that the mode is the static combination mode, the individual A static expansion unit (13) that expands the translation program in a format that allows the search for the inheritance information to be executed according to the translation information.

[Industrial applications]

The present invention relates to an object-oriented language translation processing apparatus that translates a source program described in an object-oriented language to generate a translation program described in a predetermined language.

In recent years, an object-oriented language that integrates data and a procedure has been put into practical use. This language can perform various processes by sending a message with the same name, passing the message name and parameters is easier than that of the function, and the other modules are not changed by class update. There is. From now on, program modularity is high and interface strictness is no longer necessary.
There is an advantage that the programming of the application is facilitated and the extensibility is improved. In order to improve the practicality of an object-oriented language having such advantages, it is necessary to devise ways to increase the execution speed of a program written in the object-oriented language, and to facilitate the development of application programs. It is necessary to make creative efforts.

[Conventional technology]

Conventionally, execution of a program described in an object-oriented language has been performed in an interpreter format. That is, conventionally, when a program is executed, a method (procedure) and attribute data to be processed are obtained by following a class / instance relation and a super / sub relation of an object, and the processing is executed. is there. Here, the class / instance relationship indicates a relationship between a set represented by a certain concept and an element belonging to the set (upper / lower layer relationship).
The sub-relationship indicates a magnitude relation (upper / lower relation) between class-level objects.

[Problems to be solved by the invention]

However, in such a conventional technique of searching for a requested method or attribute data by tracing an object during execution of a program, it takes a long time to search for the method or attribute data.
There has been a problem that the execution speed of the program is reduced. In particular, this problem has been a serious problem in the execution of a routine business program in which the method and attribute data of the same object are searched many times.

The present invention has been made in view of such circumstances, and proposes a compile process in order to increase the execution speed of a program described in an object-oriented language. It is an object of the present invention to provide an object-oriented language translation processing device that can easily realize the translation processing.

[Means for solving the problem]

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

In the figure, reference numeral 10 denotes a translation unit which translates a source program described in an object-oriented language, and 11 denotes a mode determination unit which is set on a source program, for example, on a head description unit of the source program. To determine the dynamic and static binding modes that will result in
Reference numeral 12 denotes a dynamic expansion unit which, when the mode determination unit 11 determines that the mode is the dynamic combination mode, converts the translation program in a format such that the search for the inheritance information of the object of the source program is performed in the execution stage. The expansion unit 13 is a static expansion unit that can search for inheritance information of the object of the source program according to the translation information when the mode determination unit 11 determines that the mode is the static combination mode. To develop a translation program with
Reference numeral 20 denotes a post-translation unit, which includes a dynamic expansion unit 12 and a static expansion unit.
13 translates the translation program expanded by 13 into an execution program, 30 is an execution module that executes the execution program obtained by the post-translation unit 20, 40 is a source program file, and is an object-oriented program. A language storing a source program described in a language, 50 is a dynamic intermediate file, storing a translation program expanded by the dynamic expansion unit 12, 60 is a static intermediate file, The one that stores the translation program expanded by the expansion unit 13 and the execution program file 70 that stores the execution program translated by the post-stage translation unit 20.

[Action]

For example, suppose that a source program written in an object-oriented language has a message transmission i = patient.get ("age");

This message transmission sets the dynamic binding mode “dy
namic ", the dynamic expansion unit 12
Expands this message transmission as i = get (patient, “age”); That is, when the program is executed, “get”
Tracing the object through the procedure "pati
The dynamic binding mode that is expanded in this way can reduce the amount of compilation and speed up the compilation time.

On the other hand, when this message transmission is described with “nodynamic” that sets the static binding mode, the static expansion unit 13 directly accesses the address of “age” by referring to the compilation information. Expands to the form i = patient → age; That is, when the program is executed, it is expanded so that the "age of patient" can be directly referred to without following the object. The static binding mode expanded in this way can increase the execution speed because the object is not traced at the time of execution.

From now on, according to the present invention, at the time of developing a program, debugging is performed with priority given to compile efficiency by setting to the dynamic coupling mode, and at the time of program execution, priority is given to execution speed by setting to the static coupling mode. Can be. Therefore, the practicality of the object-oriented language can be improved.

〔Example〕

 Hereinafter, the present invention will be described in detail with reference to examples.

In an object-oriented language, a knowledge model of a target field required for executing data processing is represented by a hierarchical structure of objects as shown in FIG. These objects are configured to have attribute data and methods for the attribute data collectively, and the attribute data and methods of the upper and upper layer objects are inherited by the lower and lower layer objects. It will be configured to be.

In an object-oriented language having such a data structure, when a method activation request is issued to an object located at a lower or lower layer according to a message transmission, the object located at an upper layer or an upper layer is traced, and an object of an inheritance source is determined. You need to find it. However, if such a search process is left at the time of execution, the execution speed will be reduced. Therefore, the present invention proposes to increase the execution speed by compiling a program described in an object-oriented language and enabling direct access to a method having an activation request according to compile-time information created at that time. Is what you do.

FIG. 3 shows a configuration diagram of an embodiment when the present invention is realized by a preprocessor. In the figure, reference numeral 100 denotes a preprocessor that precompiles a program described in an object-oriented language stored in an input file,
Reference numeral 200 denotes a group of analysis routines used for executing the precompile process of the preprocessor 100, and reference numeral 300 denotes a compile that manages compile time information to be referred, updated, and registered at the time of the precompile process of the preprocessor 100. Time information module. This preprocessor 100 is used to realize a precompile process.
Scanner 101, classification unit 102, analysis unit 103, generation unit 104, and C
A preprocessor 105 will be provided. The analysis routine group 200 includes a dot expression reference analysis routine 201, a dot expression replacement analysis routine 202, a message transmission expression analysis routine 203, a designated statement analysis routine 204, and a control statement analysis routine 20 according to the syntax of the object-oriented language sentence.
5, an instance type variable declaration statement analysis routine 206 and a generated statement analysis routine 207 are provided.

Next, processing contents of the preprocessor 100 will be described. The preprocessor 100 sequentially reads the user source stored in the input file, and
Scanning is performed in step 1 to cut out parts of the object-oriented language and parts of other languages. For example, when an object-oriented language is described in the parent language C, the C language part and the object-oriented language part are separated. Then, the type of the object-oriented language sentence cut out by the classification unit 102 is classified, and the next analysis unit 103 analyzes the sentence according to the analysis routine of the classified type in the analysis routine group 200, and generates the next sentence. The unit 104 generates an expansion source including a macro sentence according to the analysis result, and stores the generated expansion source in an output file. Finally, the C preprocessor 105 (which becomes a C preprocessor because the parent language is C language) expands from the expansion source including the macro statement stored in the output file by referring to the system-defined macro definition statement. Generate the source and end the process.

At the time of processing by the analysis unit 103 and the generation unit 104, the compile time information managed by the compile time information module 300 is referred to, updated, and registered. The compile-time information includes, for example, an object name, a superclass name, an attribute information list, and a method information list in the case of object information, and includes, for example, a variable name and a class name to which the variable management table belongs. .

As described above, according to the present invention, a program described in an object-oriented language is compiled and then executed. From now on, since the attribute data of the object and the inheritance information of the method are stored as the compile time information, it is not necessary to search for the inheritance source object at the time of execution, and the execution speed is increased.

However, in the above-described method in which all the genetic processing of the inheritance information is solved by static combination at the time of compilation, there is a problem that compilation time is excessively long. Therefore, it is not suitable for the development of a user source that requires debugging processing. When this happens, the advantage of an object-oriented language with high modularity is ruined.
Therefore, the present invention proposes to have a dynamic connection mode in which genetic processing of inheritance information is entrusted at the time of execution. In this dynamic binding mode, statements written in an object-oriented language are “put” “getvst
The function is expanded to a function that executes search processing such as r "" send ".

The setting of the static binding mode is specifically realized by writing “nodynamic” in, for example, the head description section of the user source, and the setting of the dynamic binding mode is specifically, for example, the head description of the user source. This is realized by writing "dynamic" in the description part. Then, the analysis unit 103 determines whether the user source is set to “nodynamic” or “dynamic”, and according to the determination result, the generation unit 104
This will determine the deployment method of the deployment source.

By having such two modes, at the time of developing the user source, the user source to be debugged is set to the dynamic binding mode as shown in FIG. Execute the pre-compile process. And with a C compiler,
The execution program is generated by linking with the target program for which debugging has been completed, and the program is efficiently debugged. In this manner, when the debugging of the user source is completed, the user source is set to the static binding mode, and the preprocessor 100 is executed in a format giving priority to the execution speed, as shown in FIG.
Compile processing by. Then, a final executable program is generated by linking with a C compiler.

Next, according to the specific program example shown in FIG.
The processing contents of the present invention will be described. Here, the program shown in FIG. 6 uses C language as a parent language.

The program shown in the part in FIG.
Is a program that generates a patient class based on the knowledge base. It is defined that the superclass is "human", has "disease name" and "medical doctor" as attribute data, and has "create diagnosis certificate" as a method. The program shown in FIG. 6 is a program for creating three copies of a medical certificate for an AIDS patient in a medical kb.

When the program of FIG. 6 is instructed to compile under static binding mode, the preprocessor
When the precompiled C language program 100 is the program shown in FIG. 7 and is instructed to compile under the dynamic binding mode, the preprocessor 10
0 is the precompiled C language program shown in FIG. However, in the program shown in FIG. 6, since the definition part of the diagnostic certificate class is omitted,
Parts corresponding to those in FIGS. 7 and 8 are not present in FIG. The program in the part of FIG.
The program shown in FIG. 6 is precompiled into the program shown in FIGS. 7 and 8, and the program shown in FIG. 6 is precompiled into the program shown in FIGS.

Next, the precompilation processing when the part {doc.patient name = $ self.name; in FIG. 6 is in the static binding mode will be specifically described. Here, the part is a program for substituting the “name” of the attribute data of the patient class into the “patient name” of the attribute data of the diagnostic certificate class.

The portion cut out by the scanner 101 is a classification unit 102
Will be found to be dot-type replacement. Here, the dot expression replacement has a syntax of object expression = object expression; it is a so-called assignment statement. From now on, the analysis unit 103 analyzes the left and right dot expressions using the dot expression replacement analysis routine 202. First, the instance type variable is extracted from the object specification of the object expression, and it is checked whether the variable is already declared. If so, the class is checked. By this processing, it is determined that “doc” is an instance type variable belonging to the diagnostic certificate class. Next, the dot row of the object expression is analyzed to search for attribute information, and the list is stored as an analysis result. By this processing, “patient name” which is attribute data of the diagnostic certificate class is added to the list of dot analysis information.

Subsequently, the generation unit 104 generates a C program according to the analysis result. First, the variable is generated from the left side, and an instance type variable is generated to access the attribute name of the corresponding dot analysis information list. By this processing, here,
“Doc → patient name” is generated. Next, an equal sign is generated, and then the right side is expanded in the same manner as the left side. Then, a semicolon is generated, and doc → patient name = self → name; is generated. This is the part of FIG.

Next, the precompilation processing when the part {doc.print (); in FIG. 6 is in the static binding mode will be specifically described. Here, the part is a program for printing a diagnostic certificate.

The portion cut out by the scanner 101 is a classification unit 102
Is determined to be a message transmission type by the syntax analysis performed by Here, the message transmission expression is an object expression. The syntax is as follows: selector name (parameter string); From now on, the analysis unit
103 obtains the class of the message receiving object by using the message transmission expression analysis routine 203, and obtains the function definition name of the method corresponding to the selector name. Subsequently, the generation unit 104 generates a C program according to the analysis result. Specifically, it is generated by converting a message transmission expression into a function name (object expression, parameter string). By this processing, _m_1_diagnosis certificate (doc); is generated. This is the part of FIG.

On the other hand, when the parts are in the dynamic connection mode, as shown in FIG. 8, pre-compilation is performed using "put", "getvstr", and "send". Where “put”
Is a function that adds a value (third argument) to the attribute (second argument) of the object (first argument), and "getvstr" is a function that calculates the value of the attribute (second argument) of the object (first argument) , "Send" is a function for obtaining the address of the method corresponding to the selector (second argument) of the object (first argument). That is, in the dynamic binding mode, the program is developed in such a form as to search for a method or attribute data according to a general-purpose function.

As described above, when the user source is set to the static binding mode, the attribute data of the object and the inheritance information of the method are stored as compile-time information, and based on the information, are expanded into a program sequence that reflects genetic processing. You do it. From now on, at the time of execution, genetic processing of attribute data and methods will be performed at high speed. In addition, even in the case of a global method, the matching process for specifying which global method is conventionally required is unnecessary. In addition, polymorphism can be directly accessed after the class search is completed. Furthermore, genetic processing of demons and default values can be similarly accelerated.

Although the illustrated embodiment has been described above, the present invention is not limited to this. For example, as described in the application to the preprocessor, a compiler may be used. The parent language is not limited to the C language.

〔The invention's effect〕

As described above, according to the present invention, at the time of development,
Compile processing in the dynamic binding mode increases development efficiency, and in operation, compile processing in the static binding mode makes it possible to generate a program with a high execution speed, thereby improving the practicality of an object-oriented language. Become.

[Brief description of the drawings]

FIG. 1 is a diagram showing the principle of the present invention, FIG. 2 is an explanatory diagram of the hierarchical structure of an object, FIG. 3 is a diagram showing an embodiment of the present invention, and FIGS. 4 and 5 are methods for using the preprocessor of the present invention. , FIG. 6 is a specific example of a program, FIG. 7 is an explanatory diagram of a compile process of the program in FIG. 6 in a static binding mode, and FIG. 8 is a program in FIG. 6 in a dynamic binding mode. FIG. 9 is an explanatory diagram of a compiling process of FIG. In the figure, 10 is a translation unit, 11 is a mode determination unit, 12 is a dynamic expansion unit, 13 is a static expansion unit, 20 is a post-stage translation unit, 30 is an execution module, 40 is a source program file, and 50 is a dynamic intermediate File, 60 is a static intermediate file, 70 is an execution program file, 100 is a preprocessor, 101 is a scanner, 102 is a classifier, 103 is an analyzer, 104 is a generator, 105 is a C preprocessor, 200 is a group of analysis routines, 300 Is a compile-time information module.

Continuation of the front page (56) References Proceedings of the IEICE National Convention (1987), 1987-3, p. 7-51 1707 "Message passing of object-oriented language space C" Interface, 13 [1] (NO. 116) (1987-1), CQ Publishing Co., p. 188-206. No. 85− 14095

Claims (1)

(57) [Claims] 1. A translation processing apparatus for generating a translation program described in a predetermined language by translating a source program described in an object-oriented language, the translation processing apparatus comprising: A mode judging unit (11) for judging under which mode the source program is to be compiled based on information for indicating whether to compile the source program in the dynamic binding mode or the static binding mode; When the mode determination unit (11) determines that the mode is the dynamic combination mode, the translation program is formatted in such a manner that the search for the inheritance information of each object in the plurality of objects of the source program is performed in the execution stage. When the dynamic expansion unit (12) to be expanded and the mode determination unit (11) determine that the mode is the static binding mode And a static expansion unit (13) for expanding the translation program in a format in which search for inheritance information of each object in a plurality of objects of the source program can be executed according to the translation information. Language translation processor.