JPH0540631A - Type inferring device - Google Patents

Abstract

PURPOSE:To easily infer the data types of a variable and a function by performing an inference based on a table where the substitute rules are registered in order to convert a host data type into a follower data type according to the contents of the table. CONSTITUTION:A storage means 16 stores a table where a substitute rule is registered to substitute a host data type of a hierarchical structure data type for a hollower data type that can be specified. A type inferring device 15 carries out a type inference to convert the host data type into the follower data type based on the contents of the table. Thus the substitute rule substitutes the host data type for the follower data type and also substitutes an abstruct data type of a hierarchical data structure for a more concrete follower data type as long as the data treated by a program produced by a user are limited. These substitute rules are previously inputted and defined by the users.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a type inference device, and more particularly, to compiling a program written in a programming language such as Lisp or Smalltalk that does not require a data type declaration, and converting it into another programming language. Type inference (Type Inf)
erence) type inference device.

[0002]

2. Description of the Related Art In programming languages such as C language and FORTRAN language, data types for variables on a program must be strictly declared by a data type declaration statement, and the whole program must be consistent.
Therefore, when the program is executed, the data type represented by the variable is already statically determined. For example, as shown in FIG. 9, for the variable “a”, the variable a is used after it is declared by the data type declaration statement 91 in advance that the variable a is integer type data. Similarly, with respect to the variable “b”, the variable b is used after the data type declaration statement 92 is used to declare that the variable b is character type data. By such a data type declaration statement, an area predetermined by the data type of each variable is allocated to the memory area for each variable.

On the other hand, in programming languages such as Common Lisp and Smalltalk, variables are treated as pointers to data. Therefore, it is not necessary to declare the data type for each variable. Therefore, in a program using such a programming language, the data type represented by a variable can be dynamically changed and used when the program is executed.

FIG. 10 is a diagram for explaining the data structure of variables in programming languages such as Common Lisp and Smalltalk. In programming languages such as Common Lisp and Smalltalk, variables are treated as pointers to data. Therefore, for example, as shown in FIG. 10, an integer type data variable a is designated by the pointer 93 of the variable a when the program is executed. The data type of the variable a dynamically changes depending on the data type of the end. Therefore, a data type declaration statement for each variable is not particularly required in creating a program. When the pointer 93 indicating the variable points to the integer type data 94, the variable a becomes integer type data, and the variable a
When the pointer 93 indicates the character type data 95, the variable a becomes the character type data. In this way, the data type of the variable a by the articulation reference becomes the data type of the referenced reference destination, and dynamically changes when the program is executed.

Further, although the handling of data by indirect reference in Common Lisp, Smalltalk, etc. gives flexibility to the execution of a program, the cost of accessing the value of data becomes larger than that of direct reference. For this reason, in Common Lisp, the function for declaring the data type for any variable or function and the function for inferring the data type are provided so that the compiler can statically determine the data type of the variable and compile. Attempts have been made to make additions. For example, the following documents can be cited as known documents regarding this type of data type declaration. Reference 1: R. Milner, "Aceory of Polymorphism in Programming", Journal of Computer and System Science, Volume 17, 348-375, 1978 [R.
Milner, “A Theory of Type Polymorphism in Program
ming ", Journal of Computerand System Sciences, vo
l. 17, 348-375 (1978)] Reference 2: R.I. Suzuki "Infering Type in Small Talk", Proceeding of 8th
ACM Symposium on Programming Language, 187-199, 1981 [N. Su
suki, “Inferring type in Smalltalk”, Proceeding
of 8th ACM Symposium on Principles of Programming L
anguages, 187-199 (1981)] Reference 3: A. H. Burning, "A Type Declaration and Interface System for Small Talk," Proceeding of 9th
ACM Symposium on Programming Language, pp. 133-142, 1982 [AH B
ourning “A Type Decla-ration and Interface Syste
m for Smalltalk ”, Proceeding of9th ACM Symposium
on Principles of Programming Languages, 133-142 (1
982)

[0006]

As described above, the variable by reference to the connection gives the flexibility in the execution of the program in the way of handling the data, but the access when accessing the value (data) of the variable The cost is higher than the direct reference.
Therefore, some programming languages such as Common Lisp provide a function for declaring the data type of any variable or function so that the compiler can statically determine the data type of the variable and compile it. This is as described above. However, declaring the data type for each variable is a great effort for the programming user, and the productivity of the program is also inefficient. Therefore, especially for some programming languages that do not require data type declarations, for example,
As described in the above-mentioned Literature 1, Literature 2, Literature 3, etc., code optimization called "type inference" that infers a data type from the structure in a program such as a constant assignment operation to a variable and an application function. Techniques have been developed and used.

By the way, in programming languages such as Common Lisp, there is a hierarchical relationship between data types. For example, as for the numerical value (Number), as shown in FIG. 11, as the data type, the real number and the complex number (compl) are set as the next lower data type for the highest number (number).
ex), and for real numbers, there are fixed-point decimals (rational) and floating-point numbers (float) as the next lower data types. In this way, there is a hierarchical relationship between data types. Note that in FIG. 11, each underlined data type is an abstract data type accompanied by a lower data type (subtype), and these data types are lower data types. It means that it is either.

When type inference is performed in a language in which data types have a hierarchical relationship in this way, if sufficient information for inducing an inference result cannot be obtained from the inference target program,
Depending on variables and functions, the result of type inference may result in an abstract data type. In general, such abstract data types do not provide much useful information for the optimization done during the compilation process.

On the other hand, if sufficient data type declaration is made by the user, type inference is relatively appropriately performed by the data type declaration. However, depending on the nature of the program, there are cases where it is known that only integer arithmetic is required, so even in such cases, it is troublesome to make data type declarations one by one, and productivity in program creation is increased. Can not be improved.

The present invention has been made to solve the above problems, and an object of the present invention is to compile a program written in a programming language,
Another object of the present invention is to provide a type inference device that can easily infer the data types of variables and functions when converting to another programming language.

[0011]

In order to achieve the above object, the type inference apparatus of the present invention provides a registered data type and a structure of the source program for undeclared variables and functions of the data type in the source program. 1 is a type inference apparatus that infers a data type based on a storage means for storing a table in which a replacement rule for replacing an upper data type of a hierarchical structure data type with a identifiable lower data type is registered (FIG. 1).
16) and a type inference means (15 in FIG. 1) for referring to the table and performing type inference for converting an upper data type into a lower data type from the table contents.

[0012]

In the type inference apparatus of the present invention, the storage means (1
In 6), a table in which a replacement rule for replacing the data type is registered is stored. And type inference means (15)
However, with reference to the table in which this replacement rule is registered, type inference is performed to convert the upper data type to the lower data type from the table contents. This replacement rule is a replacement rule that replaces a higher-order data type of a hierarchical structure data type with an identifiable lower-order data type, and has a hierarchical relationship when the data types handled by the program created by the user are limited. It is a conversion rule for replacing the abstract data type of the data type in the data structure with a more specific lower data type. These conversion rules are preliminarily input and defined by the user.

When the type inference means infers the data type of a variable or function whose data type has not been declared in the source program, generally, the data type already registered by the declaration such as the data type declaration statement is used. Data type inference is performed based on the structure of the source program. In this case, by applying the conversion rule, the type inference leads the inference result to the concrete data type as much as possible. As a result, like the data type registered as a declaration statement, the data type for which type inference is performed can be led to a lower specific data type, which facilitates code optimization in the compilation process. You can

[0014]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of the present invention will be specifically described below with reference to the drawings. FIG. 1 is a block diagram showing a configuration of a main part of a data type inference apparatus according to an embodiment of the present invention. In FIG. 1, 11 is a source program, 12 is a data type inference device, 13 is a data type information detection / registration mechanism, 14 is a data type storage table, 15 is a type inference mechanism, 16 is a data type replacement rule storage table, and 17 is data. It is a type substitution rule input storage mechanism.

The data type inference device 12 includes a data type information detection / registration mechanism 13, a data type storage table 14, a type inference mechanism 15, a data type replacement rule storage table 16, and
A data type replacement rule input storage mechanism 17 is provided. When the data type of the data used in the program is limited, the user first uses the data type replacement rule input storage mechanism 17 to set the rule for replacing the abstract data type with a more specific data type. Is input and registered in the data type replacement rule storage table 16. The data type substitution rule information input here is used in the process of type inference described later.

Further, when the source program 11 is input, the data type inference apparatus 12 causes the data type information detection / registration mechanism 13 to obtain information (data type declaration statement, etc.) regarding the data type in the source code of the source program 11. It is taken out and stored in the data type storage table 14. Then, the type inference mechanism 15 performs type inference processing based on the information stored in the data type storage table 14. This type inference process itself is not directly related to the present invention, and therefore a detailed description thereof will be omitted. For example, the type inference process is performed by the method shown in the above-mentioned Documents 1, 2, and 3.

When performing the type inference process for inferring such a data type, the type inference mechanism 15 performs type inference with reference to the data type replacement rule storage table 16. In the process of type inference, when a data type matching the data type registered in the data type replacement rule storage table 16 is found, the data type is more concretely selected from the abstract data type according to the registered replacement rule of the data type. Type inference is performed after performing the conversion process of the data type that replaces the specific data type.

Next, taking the case of Common Lisp as an example,
A specific example of the process of data type inference will be described. First, C
The data type declaration in ommon Lisp will be described.
The declaration for the data type of a variable is in Common Lisp:
For example, as illustrated in the following, it is performed by the proclaim form and declare form. (proclaim '(integer “counter")) ……… (defun careful (xy) (declare (integer x) (float y) (setq z (+ xy) ………) By the declaration, in this example, the data types of the variable names "counter" and x are declared as the integer type, and the data type of the variable name y is declared as the float type.

[1: Input of Data Type Replacement Rule] In the data type inference apparatus 12 of this embodiment, first, the data type replacement rule relating to data type inference must be registered in the data type replacement rule storage table 16. I don't know. Commo
In the n Lisp interpreter, the data type replacement rule is input as follows. > (Define-type-reduction 'number' fixnum) As a result, when performing type inference, "data type number is replaced by fixnum" is input as the data type replacement rule. The process of inputting such a data type replacement rule is performed by the data type replacement rule input storage mechanism 17.

FIG. 2 is a flowchart showing an example of the processing flow of the data type replacement rule input processing performed by the data type replacement rule input storage mechanism. The data type replacement rule input process will be described with reference to FIG. In this process, first, when the data type replacement rule is input in step 21,
Next, in step 22, it is checked whether the replacement data type is a subtype of the abstract data type. If the replacement data type is not a subtype of the abstract data type, it cannot be registered as a replacement rule, so an error occurs and processing proceeds to error processing. Also, if the replacement data type is a subtype of the abstract data type, it can be registered, so the process proceeds to the next step 23.
The “abstract data type” here is a data type having a subtype in the data type hierarchical structure (a data type shown with an underline in the data type hierarchical structure of FIG. 11), The "replacement data type" is a data type (subsipe) that is a replacement result.

In the next step 23, it is further determined whether or not the replacement rule is already defined. If the replacement rule is already defined in this determination, step 24
In step 24, the rule registered in the data type replacement rule storage table 16 is deleted, and then in step 25, the input replacement rule is registered in the data type replacement rule table. In this case, the update processing of the data type replacement rule already registered in the data type replacement rule storage table 16 is performed. If the replacement rule is not already defined in the determination processing of step 23, the process immediately proceeds to step 25, and the input replacement rule is registered in the data type replacement rule table. In this case, the data type replacement rule is newly registered in the data type replacement rule storage table 16.

The data type substitution rules defined and input by the data type substitution rule storage table 16 in this manner are registered in the hash table 30 in the format as shown in FIG. 3, for example.

FIG. 3 is a diagram showing an example of a hash table corresponding to the data type replacement rule storage table. As for the data type replacement rule, as shown in FIG. 3, the replacement rule 30 of each data type is registered as a replacement data type 32 associated with an abstract data type 31. For example, the abstract data type “stream” is associated with the replacement data type “file-stream”, and the abstract data type “integer” is associated with the replacement data type “fixnum”. By this data type replacement rule, the data type “integer” is replaced with a more specific data type “fixnum”.

[2: Data type inference processing] When the input processing of the data type replacement rule as described above is completed, the data type inference processing becomes possible. FIG. 4 is a diagram showing an example of the data type storage table, and FIGS. 5 and 6 are flowcharts for explaining a processing example of the data type inference processing. Next, the data type inference process will be described with reference to FIGS. The data type inference process reads the source program, detects data type information and registers it in the data type storage table, and performs type inference from the data type information, program structure, and data type replacement rules extracted from the source program. The processing is performed separately.

Source program 11 of Common Lisp
Is input to the data type inference device 12, the data type information detection / registration mechanism 13 includes, for each S expression (symbolic expression) in the source program, the expression includes data type information of variables and functions. Expression (declare expression or procl
It is determined whether or not it is an aim expression), and if it is included, the data type information is registered in the data type information storage table 40 in the hash table format as shown in FIG.

The hash table format data type information storage table 40 shown in FIG. 4 has a name field 41, a frame name field 42, a data type name field 43, and a definition type?
It is a hash table format table having a field 43. In the data type information storage table 40, the name field 41 stores information indicating the names of variables and functions. In the frame name field 42, information indicating which function or control structure the variable or function belongs to is stored so that it can be distinguished even if the names are duplicated. The data type name field 43 stores information indicating the data type name. Also, the definition type? The field 44 stores information indicating whether the data type of the variable is explicitly declared by a declaration statement.

By the way, in the case of the data type information of a function, for example, like the data type information of the name "cdr", the data type name field 43 has (function (list list) list).
Format data indicating the format of the function is stored in a format such as. In this way, the data type of the function is stored in a format such as (function (<argument data type 1><argument data type 2> ...) <return value data type>).

In addition, the definition type? The "definition type?" Information T stored in the field 44 is the data type of the variable or function whose data type is explicitly declared by a declaration statement, or the data type obtained as a result of inference. It shows whether there is. That is, the data type information detection registration mechanism 13
In the case of the data type information registered by, T is set as the information of "definition type?".

The process of detecting the data type information from the source program 11 and registering it in the data type storage table 14 is performed by the data type information detecting / registering mechanism 13. The processing of the data type information detection / registration mechanism 13 will be described with reference to FIG. In this process, first, in step 51, one top level form is input from the source file. Next, in step 52, it is determined whether the top level form in the source file is over. When the top-level form is finished, the process of storing the data type in the data type storage table here is finished, so the process proceeds to the next processing step 55 (FIG. 6). Also,
If the top level form in the source file is not the end in step 52, the top level form input in step 53 is the preclaim form or decl.
Determine whether it is a form that includes an are form,
When it is determined that the input top level form is a form including a preclaim form or a declare form, the process proceeds to step 54 and the declared data type is stored in the data type storage table. Then, returning to step 51, the processing from step 51 is repeated for the next top level form in the source file. In this way, after all the storage processing of the data types declared in the data type storage table is completed, the process proceeds to step 55, and the data type information extracted from the source program, the program structure, and the data type Perform type inference from the replacement rules. This type inference process is performed by transferring control of the process to the type inference mechanism 15.

Referring to FIG. After storing the declared data type information in the data type storage table 14, step 5
Go to 5. In step 55, first, the source file is rewound. Next, in step 56, one top level form is entered from the source file.
Next, in step 57, it is determined whether the top level form in the source file is over. If the top-level form is the end, the type inference process for this top-level form is completed, so next step 61
Proceed to. If the top level form in the source file does not end in step 57, the next step 58
In the above process, in the input top level form, the data type information regarding the variable and function definition in the form is retrieved from the data type storage table. Next, step 5
At 9, type inference is performed from the extracted data type information and the structure of the form. At this time, the abstract data type registered in the data type replacement rule table is replaced with the replacement data type to perform type inference. Then, in the next step 60, the newly type-inferred result is stored in the data type storage table.

Thus, for the current one top-level form entered in step 56, step 5
When the type inference processing of 8 to step 60 is completed, the type inference is performed on the next top level form, and the process proceeds to step 56. In step 56, the next one top level form is input from the source file, the process proceeds to the next process step 57, and the same type inference process is repeated.

When the type inference processing for all the top level forms in the source file is completed, step 5
Since the end of the top level form in the source file can be determined by the determination processing of 7, the process proceeds to step 61. Then, in step 61, it is determined whether or not the content of the data type storage table has been updated. When the content of the data type storage table is updated, the data type was changed by type inference, so type inference processing is performed again to confirm that the change due to data type inference is final. To return to step 55,
The process from is repeated. If the content of the data type storage table is not updated in the determination processing of step 61, it means that the data type has been determined by the processing of the type inference so far, and the series of processing is terminated.

Next, a specific example of the source program resulting from the type inference performed by the data type inference apparatus will be described. Figure 7
FIG. 9 is a diagram showing an example of a source program before type inference in which a data type is not declared, and FIG. 8 is a diagram showing an example of a source program resulting from type inference by a data type inference apparatus. As a result of performing type inference by the data type inference apparatus on the source program 71 before type inference shown in FIG. 7, as shown in FIG.
Includes a data type declaration form 82 for the function as a result of the type inference, and a data type declaration form 83 that indicates that the data types of the variables x, y, and z of the function are integer types.
Is added.

In the data type inference processing, first, the data type information detection / registration mechanism 13 detects the data type declared in the source program, and the data type storage table 14 is detected.
When the process of registering with is completed, the control of the process is transferred to the type inference mechanism 15. In the source program 71 of FIG. 7 in this example, since there is no data type declaration, control is immediately transferred to the process of performing type inference. The type inference mechanism 15 rewinds the source file, reads the S expressions in the source file one by one, and performs type inference processing. At this time,
The data types of variables and functions appearing in the form read from the source file are fetched from the data type storage table 14, and the type inference processing is performed from the data type information fetched from the data type storage table and the program structure. ..

In the source program 71 of FIG. 7, since the explicitly declared data type does not exist, the data type is inferred from the program structure of the function 72 defined in the source program. In the type inference process, the type inference process is performed by searching the data type substitution rule storage table 16 to determine whether or not the substitution rules for the data types to be type inferred are defined. .. If a corresponding replacement rule is found in the data type replacement rule storage table 16, the data type is replaced with the replacement data type, and the type inference process is repeated.

The data type of the unknown variable or function specified as a result of the type inference is registered in the data type storage table 14. Then, the type inference process is repeated until the change due to the data type information by the data type replacement rule storage table 16 does not occur and the data type storage table 16 converges to a specific data type. Here, as a result of type inference based on the program structure, the function 72 is a function that performs a conditional judgment involving variables x, y, and z, and the conditional judgment is a variable x, which is an argument.
The data type of the variables x, y, and z of the function is an integer type, and is a fixed-length type that is a subordinate of the integer type, because the function returns the determination result to the variable z of the argument by comparing the magnitude of y. "Fixnum" is inferred, and the data type declaration form 82 for the function and the variable x,
As a result, the data type declaration form 83 indicating that the data types of y and z are integer types is added.

Next, a modification of the data type inference apparatus according to this embodiment will be described. The above-mentioned data type replacement rule is a one-to-one replacement rule between an abstract data type and a replacement data type, as shown in FIG. 3, but the data type replacement rule changes from an abstract data type to its subtype. It does not have to be a one-to-one conversion rule of. All subtypes of abstract data types may be replaced by replacement data types.

Further, the data type replacement rule may be automatically defined from the inference result. For example, if there are only four variables used x, y, z, and n, and the result of type inference is x → integer, y → fixnum, z → fixnum, n → real, then real → A substitution rule such as fixnum, integer → fixnum may be automatically generated and stored in the data type substitution rule table to be used as a substitution rule when inferring another data type. Even in such a case, when the type inference process is performed, the abstract data type is replaced with one of the subtypes according to a predetermined data type conversion rule, and the type inference is performed. .. As a result, it is possible to convert an abstract data type into a more specific data type according to the result of type inference, without sufficiently performing data type declaration.

The features of the data type inference apparatus according to this embodiment described above can be summarized as follows. (1) A program conversion device that converts a source program into a source program of the same or another programming language, or a data type inference device that performs type inference used in a compiler that translates a source program into a machine language. (2) In this data type inference device, regarding variables and functions such as data type declaration statements existing in the source program,
A data type information detection / registration mechanism for extracting the already declared data type information is provided. (3) A data type storage table for storing and holding data type information for each variable is provided in the source program. (4) A data type having a hierarchical structure is provided with a data type substitution rule input storage mechanism for the user to input a substitution rule for substituting a specific data type with one of the subtypes. (5) A data type replacement rule storage table is provided to store and retain the data type replacement rule input by the user. (6) For a variable or function whose data type is not explicitly declared in the source code of the source program, the data type is inferred from the data type information and the program structure registered in the data type storage table. At the same time, the data type for which the replacement rule is given is replaced with the specified data type for inference.

[0040]

As described above, according to the type inference apparatus of the present invention, the table in which the substitution rule for replacing the data type is registered is stored, and the table in which this substitution rule is registered is referred to. , Inference is performed by converting the upper data type to the lower data type from the table contents, so the data type for which type inference is performed leads to a lower specific data type, similar to the data type registered as a declaration statement. This makes it possible to facilitate code optimization in the compilation process.

[Brief description of drawings]

FIG. 1 is a block diagram showing a configuration of a main part of a data type inference device according to an embodiment of the present invention,

FIG. 2 is a flowchart showing an example of a processing flow of a data type replacement rule input process performed by a data type replacement rule input storage mechanism;

FIG. 3 is a diagram showing an example of a hash table corresponding to a data type replacement rule storage table,

FIG. 4 is a diagram showing an example of a data type information storage table,

FIG. 5 is a first flowchart illustrating a processing example of data type inference processing,

FIG. 6 is a second flowchart following the first flowchart for explaining the processing example of the data type inference processing;

FIG. 7 is a diagram showing an example of a source program before type inference in which a data type is not declared.

FIG. 8 is a diagram showing an example of a source program resulting from type inference performed by a data type inference apparatus.

FIG. 9 is a diagram illustrating a data structure of a variable in a programming language that requires a data type declaration,

FIG. 10 is a diagram illustrating a data structure of variables in an object-oriented programming language,

FIG. 11 is a diagram illustrating a hierarchical structure of a number data type in Common Lisp.

[Explanation of symbols]

11 ... Source program, 12 ... Data type inference device, 1
3 ... Data type information detection registration mechanism, 14 ... Data type storage table, 15 ... Type inference mechanism, 16 ... Data type replacement rule storage table, 17 ... Data type replacement rule input storage mechanism, 3
0 ... Data type replacement rule, 40 ... Data type information storage table, 71 ... Source program before type inference, 81 ... Source program after type inference.

Claims (1)

[Claims] 1. A type inference apparatus for inferring a data type based on the registered data type and the structure of the source program for undeclared variables and functions of the data type in the source program, which is a hierarchical structure data type. Storage means for storing a table in which a substitution rule for substituting an upper data type with a identifiable lower data type is stored; and referring to the table, converting the upper data type into a lower data type from the table contents A type inference apparatus comprising a type inference means for performing type inference.