JPH0319032A - Function processing method - Google Patents

Abstract

(57) [Summary] This bulletin contains application data before electronic filing, so abstract data is not recorded.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a method for processing generic functions in a language processing system such as an object-oriented language processing system.

[Conventional technology]

First, we will discuss the functions of generic functions, which form the background of the technology.

A generic function is a type of function that can have multiple procedures (methods) for one function name. Here, multiple methods are defined for data types such as integer type, real number type, and when the generic function is called, the corresponding method is selected and executed according to the data type of the argument. . A second program example of the basic functions of such a generic function is shown below.

The def ■ method format 201 is a format for defining a method. Format 201, of which defwiethod (2
01a) indicates that this format is the defmethod format. ml (201b) indicates that the method defined in this format is the method of the generic function m1.

"((x cl))" (201c) indicates that the method has a formal argument X, and the actual argument to X is limited to data included in the C1 type, body-of-m 1- c
1 (201d) is a procedure defined as a method. Similarly, in the defmethod format 202, the procedure bad-of-ml is used as a method for C2 type arguments.
-c2 (202d) is defined.

The defclass format 203 is a format for defining data types. Of the formats 203, defclass (20
3a) indicates that this format is a defclass format. cl (203b) indicates that a data type named 01 is defined in this format. II()TI(
203c) indicates that the data type defined here does not have a superordinate form (described later).
-of-cl (203d) is a description of the data type structure, etc. Similarly, the defclass type 204 defines a C2 type whose upper type is the cl type. Here, the supertype refers to a type that includes the type in question. In other words, the C2 type is a part of the cl type, and data belonging to the C2 type also belongs to the cl type.

At the point when formats 201-204 are being executed.

The operation when executing the generic function call format 211 will be described. In the format 211, ml (211a) is the generic function name to be called.

objl (21l b) is an argument. argument obj
If the value of 1 is 02 type data, method 202d is executed. Methods 201d and 202d both satisfy the argument type if the value of argument obj 1 is cl type data, but method 201d is executed because a lower type is specified.

Next, we will discuss the method coupling function in the total membrane function.

Method combination is a function that selects and executes a combination of multiple methods, and is divided into three types. II quasi-method binding type, built-in method binding type, and short-form declarative method binding type.

These three types can be selected for each generic function. The default value is the standard method connection type, and the generic function m1 in FIG. 2 is also of the standard method connection type.

First, the standard method connection type will be explained using the example shown in FIG. defmethod format 205-2% Formula % The method is defined by giving an identifier.

Identifier: Method defined with before (20
5d, 206d) is called a before method and is defined without an identifier (primary method, 201d, 20
Methods to be executed before 2d) / ffi identifiers: Methods (207d, 208d) that are defined with after are called after methods,
This is the method to be executed after the primary method.

Method defined with identifier Caround (209
d, 210d) for the around method and primary method, call-next is executed during execution of the method.
The default format -method format allows other methods to be called. The operation of such a standard method combination type will be explained with reference to FIG.

Assume that when formats 201 to 210 are executed, generic function call format 212 is executed. Argument obj2 (2
If the value of 12b) is type 02 data, then the value shown in Figure 3(a)
As shown in Figure 2, we first use the c2 type specified around method (21
0d). Here, the method (201d) is an around method with the lowest type specification among the methods that satisfy the argument types.

call-next-me during method (210d) execution
When the thod format is executed, a cl type-specified around method (209d) is called, and the method (209d) is a type-specified around method next to the method (210d). call-nex during method (209d) execution
Once the t-method is executed, there are no more around methods, so we decide to call the before, primary, and after methods. First, in the before method, method 206 is selected in order from the lower type specification.
d, method 205d is called 6 Next, the primary method 202d with the lowest type specification is called, and the after method 207d and after method 208d are called in order from the ones with the highest type specification. -next method
If executed, the primary method 201d with the lowest type specification will be called next.

The value of argument obj 2 of generic function call format 212 is cl
type data, there are two methods that satisfy the argument type.
Only 09d, 205d, 201d and 207d are available. Therefore, as shown in FIG. 3(b), the around method 209d is first called and the call-next-meth
When od is executed, the before method 205d, primary method 201d, and after method 207d are called in this order.

An example of a short-form declaration method linkage type is shown in FIG. 5. Format 501 defines a method linkage operator *.

The format 502 defines that the generic function m3 performs method combination using operator books. In a generic function where an operator is defined, the primary methods that satisfy the argument types are called in order from those with lower type specifications, and the operator is applied to the response of each method. For example, if the operator is *, the book is a symbol indicating a multiplication function, so the answers of each method will be multiplied together. Note that in the short-form declaration method binding type, not only the primary method but also the around method can be used.

The functionality of the built-in method binding type is similar to that of the short declaration type. However, in the short-form declaration type, the user defines the method linkage operator using the format 501, for example, whereas the operator for the built-in method linkage type is defined by the system.

Finally, we will discuss the usage environment for generic functions.

Generic function number for object-oriented and other packaged languages.

In the process of dialogue, the program is executed while adding and modifying the definitions of types and methods. The type, method, method linkage R expression, etc. that should be referenced in controlling the generic σ number must be defined at the time of the actual function call. In the control, a process is performed each time to select a method with a matching argument type from the group of methods in the generic y word, and the selected method is
And each method call control was supposed to be done according to the method binding format.

One way to process such generic functions at high speed is to
N.C.M., Object-Oriented Programming System Language and Applications, '86 (1986) pp. 1-8 (ACM, 0b
project-oriented programming
System, Languages and Ap
plication '86 (1986) ppl-8
) is discussed in According to the above-mentioned literature, a method binding correspondence table is provided in the type list with the generic function name as the key and the method or method binding type to be applied as the value, and when a generic function call with an argument of the type occurs, the method binding correspondence table Search for the corresponding total membrane function name above and apply the value method or method combination.

Here, the method combination type is a procedure whose content corresponds to (a) the entire procedure or (b) the entire procedure in FIG.

[Problem to be solved by the invention]

The above conventional technology has the following four problems.

The second point is that the model list has a method join correspondence table, so
The problem is that it cannot handle a generic function that selects a method and performs method combination according to the type of the argument of the augend, as shown in FIG.

The second point is that the load of type definition is heavy because it is necessary to generate a method binding correspondence table when defining a type. When a new type is defined, it is necessary to determine the applicable method group for the arguments of the type for all generic functions, generate a method binding form based on the result, and register it in the method binding correspondence table. 0 For example, formats 201 to 20 in Figure 2
In the defclass format 204 after executing 3, first,
It is determined whether the methods according to Format 201 and Format 202 are applicable to the generic function m1, and based on the result that both are applicable, a method combination form as shown in FIG. 3(Q) is generated.

The third point is that when defining a generic function or adding a method, it is necessary to update multiple method join correspondence tables, and the load of defining a generic function or adding a method is heavy.For example, in Figure 2 From the time when formats 201 to 204 are executed, defmethod formats 205 to 21
As o is executed, the cl type and c2 type method join correspondence table is updated every time each expression is executed. The value of ml in the cl type method binding correspondence table is a single method as shown in Figure 3(d) when executing Format 204, and becomes a method binding form as shown in Figure 3(b) after executing Format 210. In the bc2 type method join correspondence table that must be updated, the method join form shown in Figure 3(c) must be changed to the method join form shown in Figure 3(a).

The fourth point is that type redefinition is a heavy burden. When redefining a type, it is necessary not only to recreate the method binding correspondence table for the type in question, but also to recreate the method binding correspondence table for all lower-level types.For example, formats 201 to 210 in Figure 2 If the c2 type is redefined as a type that is not a subtype of the cl type after performing
1cl, 205d, 207d, 209d) and the method group designated by type C/2 (202d, 206d).

208d, 210d), only the c2 type specified method group is available. Therefore, the method binding correspondence table for the c2 type must be changed, but if types with the c2 type as a supertype have been defined, the method binding correspondence tables for those types must also be changed.

The purpose of the present invention is the following two points.

The second point is to enable high-speed processing of generic functions that select methods based on the types of multiple arguments and determine method combinations.

The second point is to be able to quickly respond to program changes such as type definitions, redefinitions, generic function definitions, and method additions. In languages that include generic functions, such as object-oriented languages, programs are often created by adding and modifying them little by little in an interactive environment. For this reason, it is an essential requirement for language processing systems to be able to smoothly make program changes as described above.

[Means to solve the problem]

In order to achieve the purpose of point 1 above, a method binding correspondence table is provided for each generic function, and the key part is structured as a tree, and the
The layer is the type identifier of the first argument, and the second layer is the type identifier of the second argument when the first argument is the type identifier of the first layer. It is an arrangement of type identifiers.

In order to achieve the purpose of the second point above, the type identifier in the key part of the method binding correspondence table for each generic function has the version information of the type definition at the time the value format is calculated. This is what I did.

Furthermore, in order to achieve the second objective, the armor part of the method binding correspondence table for each generic function is divided into a control part and a data part.

Furthermore, in order to achieve the second objective, the armor part of the method binding correspondence table for each generic function is divided into a control part and a data part.

The above control section sets a method binding procedure that can be commonly used for a method with a specific method binding type and a specific identifier, and the data section contains applicable methods that satisfy the type identifier group of the key. This is to set candidate groups, etc.

Furthermore, the following five formats are prepared for the method combination procedure and the applicable method candidate group.

If there is only a primary method in a standard method join,
The data section is made up of a group of primary methods, and the control section is made up of a procedure (first method binding procedure) that calls the primary method specified by the lowest type (first form of chain section).

In addition, when the standard method combination does not include an around method, the data section is configured with a before method group, a primary method group, and an after method group that can be applied with the relevant argument type, and the control section is It consists of a second method binding procedure that calls the before methods in order from the method with the lowest type specification, calls the primary method with the lowest type specification, and calls the after methods in order from the method with the highest type specification. Yes (value part second format).

In addition, if a standard method combination includes around methods, the data part is the applicable around method group,
Consists of a primary method group and an after method group, provided that the above around method group is the method with the highest type specification, and the above before method group, primary method group, and after method group are used as arguments for the second method. The method that calls the method binding procedure (first
(control method) is added, and the control section is configured by a procedure (third method binding procedure) that calls the around method of the lowest type specification (value section third format).

In addition, if a built-in method combination or short-form declaration method combination does not include an around method, the data part is composed of the operator of the method combination and the applicable primary method group, and the control part is composed of the above-mentioned primary method group. This is constructed by a fourth method connection procedure that calls the above operator using the value part as an argument (value part fourth format).

Furthermore, when a built-in method combination or a short-form declaration method includes an around method, the data section is composed of the operator of the method combination, an applicable primary method group, and a around method group. However, to the above-mentioned around method group, a method (second control method) that calls the fourth method binding procedure with the above-mentioned operator and primary method group as arguments is added as the method with the highest type specification. The control section is configured by a fifth method binding procedure that calls the around method specified by the lowest type (value section fifth format).

[Effect]

When a generic function is called, it examines the type of the given argument and
Search the method binding correspondence table for the generic function. First, compare the type of the first argument with the type identifier placed in the -th layer of the key part of the method binding correspondence table, and if there is a -m type, compare the type of the second argument with the type identifier in question. The second layer type identifier located in the second layer is checked. In this way, the type of the last argument is checked, and if there is a matching key, the value for that key is set as a method binding candidate.

Next, the version information of the matching type identifier is compared with the latest version information of the type. Here, it is assumed that when a type is defined or redefined, a type identifier including version information is generated. It is also assumed that the latest type identifier is always pointed to by the type name. If the version information of all type identifiers matches the latest version information, the method binding candidate is valid.

There are five types of method combination candidates, all of which consist of a control part and a data part, and the method group in the data part is applied as an argument to the procedure of the control part to execute method combination. For example, if the generic function in question is standard method binding, the value part is in the first format, and the first method binding procedure of the control part is called using the primary method group of the data part as an argument. In the first method binding procedure, the method with the lowest type specification than the given argument is selected and called.

If there is a mismatch in the version information of the type identifier,
Since the method binding candidate in question was registered under the old type definition, the chain part in question should be re-registered and used.

To register a chain part, first, a method group that satisfies the argument type of the relevant key is determined and set as an applicable method candidate group. Next, depending on the method combination type and the type of the above-mentioned common method candidate group, one of the value part first format to value part fifth format is selected to set the chain part. Finally, set the latest type identifier in the key part.

If there is no key that matches the type of the last argument, determine the group of applicable method candidates and set the chain part in the same way as in the case of verge leak information mismatch, and then add the latest type identifier to the corresponding position of the key in the tree structure. to add.

In this way, the values set here will be used from next time onwards.

When adding a method to an already defined generic function, if the method is applicable to the key type, add it to the data part of each chain part of the method binding correspondence table of the generic function. do. When adding, the method identifier is determined and 1. For example, if it is an around method, it is
Add to method set. If there is no method group with the same identifier, change the chain part format. For example, if the chain part is the value part 2 format and you want to add an around method there, change the chain part format to the value part 3 format. By processing 0 or more, the latest method group corresponding to the type of the key part is set in the chain part of the method join correspondence table, so that malfunctions will not occur.

〔Example〕

The generic function processing method, which is an embodiment of the present invention, will be explained in the following.
This will be explained using figures.

The source program 200 of the generic function has the definition format (20
1, 205) and execution format (211, 212), and the above two formats are arranged in an arbitrary order. The definition change control program 123 receives the above definition format as input (154, 155), and generates, adds to, or modifies the generic function group 124 (156).

The generic function call control program 122 receives the above execution format and data 125 as input.
1) The program is executed while referring to the generic function group 124 (158) or adding or modifying it (157), and outputs the execution result 121 (159).

The generic function group 124 is a data structure realized on the memory of the computer, and is composed of a set of a symbol 102 indicating a generic function name, a generic function object 101, a method list 104, and a method connection correspondence table 105.

Symbol 102 points to generic function object 101. The generic function object holds a method binding type 103 and points to a ment list 104 and a method binding correspondence table 105. The method list holds all of the methods defined for the generic function in question. The method binding correspondence table uses the argument type as the key,
This is a table whose values are the processing when the relevant generic function is called. The part that corresponds to the key has a tree structure that branches in order from the first argument. For example, the first argument is A
If the first argument is type 1 (verified with 106) and the second argument is type Bl (verified with 107), the processing set to the value of A1/Bl (108) shall be performed; If the second argument is of type B2 (verified at 131), processing set to the value of A1/B2 (132) is performed. Here, in the tree structure of the key part, the type identifier 106 indicates the type of the argument. The type identifier is type name 109, version I
Dll0 and supertype 111, here the version ID refers to the cl type with respect to type 02 in the form 203, 204 of a different ID2 diagram each time the type is redefined and a type identifier is generated. It is. Each value (108) is configured by a control section (112) and a data section (113). The definition change control program 123
As shown in Figure 0, the generic function definition program 2011,
It consists of a type definition and redefinition program 2012 and a mesotho additional definition program 2013.

Next, the relationship between the generic function group 124 and the generic function program and data will be described. Definition part of a generic function program For example, the generic function name ml in the format 201 in FIG.
201b) is the generic function name m in the generic function group 124
1 (201b) becomes the symbol 102 in the generic function group 124, and can be referenced by the execution unit, for example, the generic function name m1 (211a) in the format 211 in FIG.

Data passed as an argument to a generic function, e.g. format 21
The value of the argument objl (21l b) of 1 is shown in Figure 21 (
The type identifier with the latest definition among the type identifiers, such as the data 2101 in a), is pointed to as the latest version by the type name symbol 2103 of the fan-shaped identifier, as shown in FIG. 21(b). (2104)

As shown in FIG. 6, the formats of the control section 112 and data section 113 of the chain section 108 of the method binding correspondence table 105 are divided into five types depending on the type of method binding and the type of method.

If there is only a primary method in the standard method connection type, the value part first format 601 is used. If a before method or an after method is included in addition to the primary method, but no around method is included, the value part second format 602 is used. If the data includes an Arran method, the third format 603 of the value part is used.

If there is only a primary method in the built-in method binding type or the short form method binding type, the value field fourth format 604 is used. The first to fifth method binding procedures used in the control units of the first form of the boiling part to the fifth form of the value part, which include around methods in addition to the primary method, will be explained using FIGS. 7 to 11. do.

The first method linkage procedure 701 shown in FIG. 7 takes a group of applicable primary methods as arguments and calls the method with the lowest type specification among them.

The second method binding procedure 80.1 shown in FIG. 8 takes the applicable primary method group, the before method group, and the after method group as arguments, and calls the before method group in the order of subtype specification, It calls the primary method with the lowest type specification, calls the after methods in the order of the higher type specification, and returns the value of the primary method as the result.

The third method combination procedure 901 shown in FIG. Method group and after method group are defined as method group preserving variable 1 (90
2) and calls the around method of the lowest type specification.

The fourth method binding procedure 1001 shown in FIG. 10 uses a method binding operator and a group of applicable primary methods as arguments, calls the primary methods in the order of subtype specification, and calls the operator using the chain part as an argument. be.

The fifth method combination procedure 1101 shown in FIG.
02) and calls the around method of the lowest type specification.

Data section 113 of method binding correspondence table 105 shown in FIG.
As shown in Figure 6, in addition to the methods defined in the generic function that are applicable to the key,
The first control method is set for the third format of the value section, and the second control method is set for the fifth format of the value section.

As shown in FIG. 9, the first control method 903 includes a primary method group, a before method group, and an after method group.
Reference the method group from the method group preservation variable 1 (902),
The second method binding procedure 801 is called using these as arguments.

As shown in FIG. 11, the second control method 1103 refers to the primary method group and operator from the method group storage variable 2 (1102), and uses these as arguments to control the first control method.
The fourth method binding procedure 100 shown in FIG. 10 shown in FIG.
1.

Next, function call processing by the generic function call control unit 122 will be explained using FIG. 12(a).

When a generic function is called with some arguments.

As shown in FIG. 21, the type name 2103 is obtained from the type identifier 106 for each of the one number of data 2101.
01.1202), searches for a key that matches the argument type \o9 of the corresponding rank from the -th layer of keys in the method binding correspondence table 105, and searches for keys in the next layer branching from the matched key. < (1203 to 1206), and if there is a key that matches up to the last argument, the version ID 21 of the latest version 2104 of the type name is used.
05 and the key version IDll0. If the version IDs match, use the value as is,
If they do not match, it is determined that the value is based on type information that has now been redefined and is no longer valid, the value is calculated anew, the result is registered in the chain, and the key is changed to the latest type identifier. (1210°1207.1212). The control section procedure is called using the data section of the chain section whose version information has been confirmed as an argument (1213). If there is no matching key, it is determined that no value has been registered for the relevant argument type, and a new value is added. After calculating, adding and registering the key (1207 to 1209), calling the procedure of the control section using the data section as an argument (1213), calculating the value shown in (b) in Figure 12 (1207) is a general term. Checks whether the arguments of the function object satisfy the method type specification (1222 to 1225), and collects methods for each identifier that satisfy all arguments (1226).
, the value part format shown in FIG. 6 is determined to determine the control part. Furthermore, if the value part is in the third format, the first control method 903 is added to the around method group, and if the value part is in the fifth format, the second control method 1103 is added to the around method group to form the data part (1227, 1228).

Next, type definition and redefinition program 2 shown in Figure 20
The process of 013 will be explained using FIG. If the type is defined or redefined, generate a type identifier 106;
The version ID of the latest version type identifier immediately before the type name symbol is obtained, updated, and set as the type identifier. Also, set the type identifier generated above as the latest version of the type name. The processing of the generic function definition program 2011 shown in FIG. 20 will be explained using FIG. 14. When a generic function is defined, a generic function object 101 is generated, a method connection type 103 is set, and a method list 104 is created.
The mesoto combination correspondence table 105 is initialized (empty list) and set to the symbol 102 of the generic function name.

The processing of the method addition definition program 2012 shown in FIG. 20 will be explained using FIG. 15. When a method is added to a generic function, it must be determined whether the type specifications of all arguments are satisfied for each key in the method binding correspondence table (1501~
1504), the chain part is changed for keys that satisfy <
(1505-1507), to change the chain section, first determine whether there is a method group corresponding to the identifier of the method in the data section 113 (1505), and if so, add the method there (1506); If not, the chain section format is changed, a method group corresponding to the identifier of the method is provided in the data section (1507), and the method is registered. Changing the chain type (1507) is necessary only in the three cases (1511, 1512, 1513) shown in FIG. 15(b). After completing the above process and registering the method in the method binding correspondence table 105, the method is finally added to the method list 104 (1508).

The operation will be explained below according to the input examples shown in FIGS. 4 and 5.

16th by defclass format (401, 402)
As shown in the figure (, ), the type identifiers of C1 type and C2 type (
1611 and 1612) will be generated and will be pointed to (1631 and 1632) as the latest versions by the symbols (1621 and 1622), respectively. The defmehod format (404 to 407) is evaluated, and furthermore, the calling format 411) with C1 type data and C1 type data as arguments for the generic function m2 is executed.
, when the call format 412) with C2 type data and 01 type data as arguments and the call format 413) with C2 type data and C2 type data as arguments occur, the method binding correspondence table is as shown in Figure 16. It will be generated as shown in (b). The operation when a method is stopped from being added in such a state will be described below.

When the defmethod format 408 is additionally defined, the argument type is checked for each key in the method binding correspondence table 1601, and here, only the keys of the 131st number 02 type and the second argument c2 type are searched and the chain part 1604a is updated. .

Since the chain portion 1640a already has the after method group 1605 as a component, the current method 408d is set here. Furthermore, when the defmethld format 409 is additionally defined, the chain part 1604a is updated in the same way, but since the around method group is not a component, the chain part change rule 1502 shown in FIG. 15(b) is updated. As shown in the chain part 1604b in FIG. 16(C), the chain part format is changed to the value part third format, and the relevant around method 409d is registered together with the first control method 903, which is the default around method.

Here is an example of the operation when a generic function is called.

If the generic function m2 supports arguments of type cl and arguments of type C1 (format 414), the value 1602 is retrieved, and method 4
04d The first method binding procedure 701 is called as the primer method group, and the method 404d is called from there (702).

When a C1 type argument and a 02 type argument are given to the generic function m2 (format 415), there is no corresponding key, so the more applicable method among the method group methods 404d to 409d of m2, that is, the primer method 404d and the after - Select the method 408d (1222-1226), determine the chain part format to be the second value part format 602, add a key, and register the chain part 1701 as shown in FIG. Then, referring to the chain section 1701, set the method 404d as the primary method group, set the method 408d as the after method group, set the before method group as none, call the second method binding procedure 801, and call the method 404d from there.803) Next Call method 408d to method 404
The value of d will be returned as the result.

When an argument of type 02 and an argument of type 02 are given to the generic function m2, the value 1604b is searched (format 416), method 404d, method 405d, and method 406d are the primary method group, and method 407d is the before method group.・Method 408d after method group, method 409
d and the first control method 903 as the around method group. From there, the methods 404d to 408d are saved in the method group storage variable 1 (902) along with their respective method types, and the method 409d (905), method 409d is the only proper around method here, call-n
When the ext-method format is evaluated (908 and 909), the first control method 903 will be called. In the first control method 903.

The methods 404d to 408d are restored together with their respective method types, and the second method binding procedure 801 is called using these as arguments (907).

From there, method 407d is called 802), method 405d is called 803), method 408d is called (804), and the value of method 405d is returned as a combination result.

Here is an example of the behavior when the type is redefined.

The definition of the c2 type used in the generic function m2 above is de
Assume that the fclass expression 422 is redefined as having no upper type. Then, a type identifier 1802 is generated in which the version ID is updated from the value 1 (1633) of the conventional C2 type latest version J 1612 to 2, and is set as the latest version of the C type (1801).

Here, when the generic function m2 is called with data of type c2 and data of type 02 as arguments (format 417), the value 1604b is searched from the method binding correspondence table 1601 in FIG. Identifier version ID16
33 does not match the latest version of type 02 l01803, we will need to calculate the value again, change the type identifier of the key, and register the value (1207.1212), cl
If the type is not a supertype, the methods that can be applied are the primary method 406d and the around method 409.
d, and is changed as shown in the value 1604c in FIG. 18(b). However, since this is a mismatch compared to the key in the -th layer, the value 16 is another value in the layer below this key.
03a will also be recalculated and re-registered (value 16).
03b).

In the case of short-form declaration method binding, the operations for defining a generic function, adding a method, and redefining a type are the same as in the case of standard method binding described above. The operation when a generic function is called is described below. Formats 501 to 505 in Figure 5 based on the definitions of types 01 and c2 in Figure 4
is evaluated, and then the generic function m3 is called with an argument of type cl (format 511) and called with an argument of type c2 (format 512), and the method binding correspondence table 190 in FIG.
1 will be generated. Here, when called with a cl type argument (format 513), the value 1902 is searched and the fourth method combination procedure 1001 uses the function water (multiplication) as the operator and the method 503d as the primary method group.
1002 and call method 503d from there.
), the function: is called with that value as an argument. Also, when called with an argument of type c2 (format 514),
The value 1903 is retrieved, and the fifth method combination procedure 1101 is called using function water as the operator, method 504d as the primary method group, and second control method 1103 as the around method group.

From there, the function water and method 504d are stored in method group storage variable 2 (1102), and method 505d is called. Here, method 505d is the only original around method, and when call-next-method is evaluated (1106 and 1107), the second control method 1103 will be called. In the second control method 1103,
The function water and method 504d are restored, and the fourth method connection procedure is called using these as arguments (1109), and from there, the method 504d is called (1002), and the function * is called using the values as arguments (1003).

According to this embodiment, there are the following effects. First, generic functions with multiple arguments can be processed at high speed. Second, it is possible to respond quickly to program changes, which can be divided into the following three items. The first is that there is no need to generate a method binding correspondence table when defining a new type.

2. When redefining a type, there is no need to recreate the method binding correspondence table for the relevant type or lower-level types. 3. When adding a method, add a method other than the method binding correspondence table for the generic function in question. There is no need to update the join correspondence table, and there is no need to generate a method join procedure when updating the values of the method join correspondence table. Although the above three items are now possible, when calling a generic function, if there is no key of the relevant type in the method binding correspondence table, or if the value is based on the old type definition, the value must be calculated. However, the load is low because you can select one from several pre-prepared method combination procedures and register it.

〔Effect of the invention〕

According to the present invention, there are the following effects.

The first point is that we have provided a method binding correspondence table with multiple type identifiers as keys for each generic function, so it is possible to handle generic functions that use multiple argument types to select methods and determine method binding trapezoids. This is what happened. Also, it eliminates the burden of calculating the values of the method binding correspondence table all at once at the new type definition location.
When a method is added, the method binding correspondence table can be updated only by updating the method binding correspondence table of the relevant generic function. Furthermore, since the key is in a tree structure, it is possible to search at high speed even when the number of combinations of argument types is large.

The second point is that since the above type identifier has version information of the type definition, it is possible to determine whether the version matches when referencing the value, and by this, when redefining the type, it is possible to It is no longer necessary to update the method join correspondence table all at once, and only the referenced values need to be updated in a delayed manner.

The third point is that the chain part of the method binding correspondence table is divided into a control part and a data part, so updating the chain part by adding a method can often only be done by updating the data part. be.

The fourth point is that since the second method linkage procedure is used in the control section, addition of a method in a range where there is no around method in standard method linkage can be done by simply updating the data section.

The fifth point is that the third method connection procedure is sent to the first
Since the control method is used in the data section, adding methods that include around methods using standard method binding only requires updating the data section.

The sixth point is that since the fourth method binding procedure is used in the control section, adding a method in the range where there is no around method in built-in method binding or short-form declaration method binding only requires updating the data section. That's what happened.

The seventh point is that the fifth method connection procedure is sent to the second
Since the control method is used in the data section, adding methods that include around methods through built-in method binding or short-form declaration method binding only requires updating the data portion.

[Brief explanation of drawings]

FIG. 1 shows a generic function processing scheme according to an embodiment of the present invention. FIG. 2 shows a generic function program which is the background of the technology of the present invention, and FIG. 3 is an explanatory diagram of the operation of the function program. Figure 4 is an example of a program using the standard method binding type among the functions of generic functions, and Figure 5 is an example of a program using the short form declaration type method binding type. Figure 6 shows the chain part format of the method binding correspondence table used in the generic function processing method shown in Figure 1. Figures 7 to 11 show the chain part format (first value part form) in Figure 6. 12 shows the processing flow of the first to fifth method binding procedures used in the control unit of the second to fifth value part formats. Figure 12 shows the generic function call used in the generic function processing method in Figure 1. This shows the processing flow of the control program. Figures 13 to 15 show the type definition and redefinition program, generic function definition program, and Each of the processing flows of the method definition program is shown. Fig. 16 to Fig. 19 show an example of the operation by the generic function processing method of Fig. 1.
4 shows a method combination correspondence table generated when the program example of FIG. 4 is input. FIG. 17 is a continuation of FIG. 16, and is a diagram in which a new key value has been added and registered. Figure 18 is a continuation of Figure 17,
FIG. 7 is a diagram in which a value based on a new definition is registered after a data type is redefined. FIG. 19 shows a method combination correspondence table generated when the program example shown in FIG. 5 is input. FIG. 20 shows the configuration of a definition change control program used in the generic function processing method shown in FIG. FIG. 21 is a supplementary explanatory diagram regarding data and type identifiers used in the generic function processing method of FIG. 1. Description of codes 105...Method binding correspondence table, 106...Type identifier, 110...Vergemin ID1
08... Chain part, 112... Control part, 113... Data part, 801...
...Second method connection procedure, 901...Third method connection procedure, 903...First control method, 1001...Fourth method connection procedure, 103...Second control method. Fig. Rod 4 Fig. (CIiJ, /σ (dIL child c1 9 1 Cl (N (Ol) NuSkeiP 伽−σJ, -ct) , -(≦Lshi?ctojrSunoh−o+− 0z)rν+
07 Zθ2 Cltfclass 2 tksc)-'tP;cpq-of-CI-2)
To 1l-x2 (7It2 <c'l data><c2!Chitan\n-φt7 perforation (resistant INL-πa4kIMl-cowr/yt to long fi
oru piece) Heke of Kozukatsu 7 Figure No. 7? Figure number diagram 0 Figure broom// Figure number/Otsuzu easy/? Figure (0L) Wa2/Figure

Claims (1)

[Claims] 1. A method linkage that stores a group of type identifiers that store data type definitions and a set of methods or method linkages that should be applied when one or more type identifiers and their arguments are given. A group of generic functions that have a correspondence table, a generic function call control unit that searches and executes a method or method combination form for the data type of an argument from the above method binding correspondence table when calling a generic function, and definitions and changes of types and generic functions. In the function processing method of a generic functional language consisting of a definition change control unit that executes A function processing method characterized in that a key part of an identifier is arranged in a second layer, and a tree structure is formed in which the key part is arranged for each argument. 2. In the method binding correspondence table described in claim 1, the type identifier of the key part has version information of the type definition, and when referring to the method binding correspondence table, the version information of the argument type and the key part are A function processing method characterized by checking version information. 3. In the method binding correspondence table described in claim 1, the method binding type is divided into a control part which is an execution procedure of method binding control and a data part which is an argument to be passed to the procedure. Function processing method. 4. In a generic function that is a standard method combination and does not include an around method, the method combination described in claim 3 is used as the data part of the applicable before method group, primary method group, and after method group. , the before method group, the lowest typed primary method, and the second procedure which sequentially calls the after method group.
A function processing method characterized in that a method binding procedure is used as a control part. 5. In a generic function that includes an around method in standard method combination, the method combination form described in claim 3 is
The applicable around method group, before method group, primary method group, and after method group are the data part, and the above before method group, primary method group is the method with the highest type specification for the above around method group. - Add a method that calls the second method binding procedure described in claim 4 using the method group and after method group as arguments, and use the procedure that calls the lowest type specified around method as the control. A function processing method characterized by: 6. In a generic function that does not include an around method in built-in method binding or short-form declaration method binding, the method binding form described in claim 3 is used as the operator of the method binding and the applicable primary method group. A function processing method, characterized in that the data part is a control part, and the control part is a fourth method combination procedure which is a procedure for sequentially calling the primary method group and calling the operator using the value group as an argument. 7. In a generic function that includes an around method in a built-in method combination or a short-form declaration method combination, the method combination form described in claim 3 is used as the operator of the method combination, the inapplicable primary method group, and the around method combination. - The data section is a method group, and the around method group is the method of the highest type specification, and the operator of the method combination and the applicable primary method group are used as arguments as set forth in claim 6. A function processing method in which a method that calls a four-method combination procedure is added, and the control section is a procedure that calls the around method of the lowest type specification.