JPS6244841A - Execution control system for logical type program - Google Patents

Abstract

PURPOSE:To access one or more predicates registered for a variable on the basis of the substituting operation of values for a specific variably by controlling the access of chains and predicates in a stack area by a register included in a central processor. CONSTITUTION:A bind hook predicate having a function for accessing a predicate specified by the substituting operation of values for a specific variable to attain flexible programming is registered by executing a bind hook defined in a system. The 1st argument 'X' of the bind hook indicates the variable and the 2nd argument 'a(Y)' indicates the bind hook predicate for the variable X. At the access of a predicate (q), a value '1' is substituted for the variable X on the basis of the integrating processing of the argument with a section 13. Consequently, a predicate (a) is accessed by using a variable Y is its argument before the access of a predicate (r) and a section 14 is executed. Thus, the section 13 is executed as if it is a section 15.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention relates to an execution control method for a logic program written in a predicate logic programming language such as Prolog, and particularly relates to the implementation of extended functions thereof. .

[Conventional technology]

Prolog (P
A programming language called ``programming in Logic'' is known. As the name suggests, this type of programming language is based on predicate logic, and its execution control is equipped with higher-order functions not found in other programming languages, such as pattern matching and backtracking. It has the feature of allowing for much more flexible programming than other languages.

Note that the predicate logic on which the above language is based is a one-force logic in which a variable included in a predicate that indicates the nature of an object or the relationship between objects can refer only to an object.

[Problem that the invention seeks to solve]

By the way, in order to enable more flexible programming, this type of programming language has a function (hereinafter referred to as the bind hook function) that calls a prespecified predicate when a value is assigned to a specific variable. ) is required. However, since this programming language was developed based on one-stroke logic, it is originally not allowed for variables to specify predicates, and it is necessary to sacrifice execution efficiency by using functions such as backtracking. Without this, there was a problem that more flexible programming could not be achieved.

The bind hook function is a process called "registering a bind hook predicate," which specifies the variable to which a value is assigned and the predicate to be called at that time. This process is realized in two stages: ``bind hook predicate execution process'' that executes a predicate call.

These bind hooks can be created by specifying the registration of two or more bind hook predicates for the same variable, or by unifying (also called unification) between different variables for which different bind hook predicates have been registered. Because of the merging of predicates, a mechanism is required to enable invocation of two or more bind hook predicates during the execution process of bind hook predicates.

The present invention has been made in order to solve the above-mentioned problems.The present invention has been made in order to solve the above-mentioned problems. The object of the present invention is to provide a logical program execution control method that executes calls of two or more bind hook predicates in response to assignments and enables more flexible programming.

[Means for solving problems]

A logical program execution control method according to the present invention stores registration information of one or more predicates registered for the same variable in a stack area provided on the main memory of a logical program execution processing device, with the terminal end being grounded. At the same time, the pointer to the start of the chain and its variables are stored, and the chain and predicate calls in the stack area are stored using registers provided in the central processing unit of the device. By managing this, by assigning a value to a specific variable, one or more predicates registered for that variable and different variables integrated with that variable are called.

[Effect]

In the present invention, when attempting to assign a value to a variable registered with a bind hook according to the normal execution procedure in a logical program, the contents of the variable cell on the stack area are assigned to the registration information of the bind hook predicate. If it is a pointer, the pointer is saved in a register, and after the value is assigned to the variable, the bind hook predicate is called and activated based on the registration information pointed to by the pointer. At this time, a pointer to the registration information of the next bind/hook predicate on the chain is saved in a register prepared for that purpose as continuation point information at the end of the currently activated predicate. In this way, the registered bind hook predicates are called one after another until a grounding point is found, and all are executed.

〔Example〕

Hereinafter, the present invention will be explained in detail by showing examples.

FIG. 1 is a description example of bind hook predicate registration in a logic type program written in a predicate logic type programming language called Prolog. Bind-hook predicates are registered by executing a built-in predicate "bind-hook" defined in advance within the system, as shown at 11 in the figure. The first of this built-in predicate
The argument "X" indicates a variable, and the second argument "a (Y)" indicates a bind hook predicate for the variable X.

In the example of FIG. 1, in the last invocation of predicate q in clause 12, the value "1" is assigned to variable X through argument unification processing with clause 13. As a result, clause 1
Before calling predicate r in step 3, bind hook predicate a is called with variable Y as an argument, and clause 14 is executed. In other words, clause 13 will be executed as if it were clause 15. However, the caller argument Y of predicate a is not a variable in clause 13, but in clause 1
This is a variable in environment 2.

FIG. 2 shows an embodiment of the present invention relating to the registration of the bind hook predicate in FIG. 1 and the activation method of the predicate. FIG. (Q) represents the state in the stack area immediately after execution, (Q) represents the state immediately before the bind hook predicate is activated, and (d) represents the state in the stack area immediately after activation. In the figure, 21 is a stack area (21) for holding the values of variables provided in the main memory 1 of the processing device.
In the figure, the lower part is the stack bottom and the upper part is the stack top), and for each predicate call, the value of the variable in each clause (in the case of an "undefined word" indicating that no value has been assigned,
It may also be a pointer to another variable cell).

Note that a variable cell is an area corresponding to one word in the stack area.

(al is the built-in predicate “bi” in section 12 of FIG.
This is an example of the state immediately before execution of ``nd-ho'ok'', and variable cells X and Y correspond to variables X and Y in clause 12. Variable cell Assume that a pointer is stored in the variable cell V, and an "undefined word" indicating that no value has been assigned yet is stored in the variable cell V.

In the same figure (bl, the built-in predicate “bi” in section 12 of Figure 1
This is the state immediately after execution of ``nd-hook'', and the top of the stack contains pointer 2 to bind hook predicate a.
2. A pointer 23 to the environment of variables X and Y, that is, the environment of clause 12, and a pointer 24 for the hook chain described below.
Bind/hook control block 2 consisting of three pieces of information:
5 is stacked.

A chain of bind hook predicates for the same variable (
The pointer 24 for the hook chain (hereinafter referred to as the hook chain) is grounded (eg, has the value "0") because there was no previous bind hook predicate for the variable X. Furthermore, the variable cell V that stores the true value of the variable X has been changed from an "undefined word" to a boink to the bind hook control block 25.

The same figure (C1 shows a state in which “1” is assigned to variable X as a result of clause 13 being called by the call of predicate q in clause 12 in Figure 1. In the process, the true value cell V of the variable , as shown in figure fb), the value cell ■
is a pointer to the bind hook control block 25, so after transferring this pointer to the bind hook control register 26 in the central processing unit (hereinafter referred to as CPU) 2 in the logical program execution processing unit. , assigns the value "I" to variable cell V. The invocation of predicate q is clause 1
Normally, the first goal r (Z) in clause 13 would be evaluated, but according to the present invention, the binding The hook control register 26 is checked to see if a pointer to the bind hook control block 25 is stored.

In the same figure (d+ is in a state where preparation for calling the bind hook predicate a is completed because a pointer to the bind hook control block 25 is found in the bind hook control register 26.
The pointer 22 to the hook predicate a and the pointer 23 to the environment of clause 12 are loaded into the predicate call address register 27 and the call environment register 2B in the CPU 2 for the call process of the bind/hook predicate a. . Since the hook chain pointer 24 is grounded, its explanation will be omitted here. After extracting the information of the bind hook control block 25, remove the bind hook control block 25 from the top of the stack, and initialize the bind hook control register 26 that was pointing to it with a value such as "O". (In this way, bind-hook predicate a can be executed as in section 15 of Figure 1. Note that the information regarding the invocation of goal r (Z) is stored at the end of execution of bind-hook predicate a. The continuation point information may be stored in a stack for predicate call control (not shown in FIG. 2) or the like.

FIG. 3 shows a case where two bind hook predicates al and a2 are registered for the same variable X. After executing the two bind-hook built-in predicates in clause 31, when predicate q is called in the same way as in Figure 1, clause 32 is called and the bind-hook predicate is executed before goal r (Z) is evaluated. al
, a2 are both called as in clause 35.

FIG. 4 is an operational example of the registration and execution of multiple bind hook predicates in FIG. 3 according to the present invention.

Tal in the figure is the first bind-ho of node 31 in Figure 3.
Immediately before the execution of the ok built-in predicate, (bl is an example of the state immediately after its execution, which is the same as in FIG. 2 above.

rc+ in the same figure is the state immediately after the execution of the second bind-hook built-in predicate, (1 from variable cell V in bl)
A second bind/hook controller block 42 is inserted between the pointers to the first bind/hook control block 41 to form a chain between the bind/hook control blocks.

In the same figure (dl is the state immediately after assigning a value to variable X, that is, variable cell V, and the bind/hook control register 26
A pointer to the bind/hook control block 42 is stored in .

fel is a state in which the integration of the head arguments in section 32 in FIG. 3 has been completed, and preparations for calling the bind hook predicate a2 have been completed. Here, the first goal r (
Z) is the continuation point after the end of the bind hook predicate,
Assume that it has already been stored in the predicate call control stack 43 (here, it will be provided on the main memory 1),
Furthermore, as continuation point information after the end of predicate a2, predicate a1
A pointer to the bind/hook control block 41 for the predicate call control stack 43 is stored in advance.

In this way, processing of multiple bind hook predicates for the same variable can be realized.

Note that when preparing to call the last bind hook predicate on the hook chain, since the end of the hook chain is grounded, the original q (Z
) can be used to know when processing should be transferred to a call. q
(Z), there is a method to set the latest continuation point on the predicate call control stack 43 to q (Z) when the last bind hook predicate is called, and There is a method in which a hook chain that is grounded at the time of a call is temporarily stacked on the predicate call control stack 43 as a continuation point, and then ignored when taken out from the stack.

Figure 5 is an example in which two variables that have received bind hook specifications are integrated, and then, by assigning a value to one of the variables, the bind hook predicates corresponding to both variables are executed together. be.

By executing the two bind-hook built-in predicates in clause 51, bind-hook predicates are specified for variables X and Y, respectively. Next, as an invocation of predicate e from clause 51, clause 5
When integration with 2 is performed, integration is performed between variables X and Y on the calling side through variable Z, which is an argument on the called side. Then, as predicate q is called from clause 51, integration with clause 53 is performed, and the value "1" is assigned to variable X of clause 51, and the first value of clause 53 is Before evaluating the goal r (Z), bind
Hook predicate a2. al is executed, and clause 53 becomes just like clause 56.

FIG. 6 is an example of the operation when the execution of multiple bind hook predicates by integrating different variables in FIG. 5 is realized according to the present invention.

In the same figure, <a+ means that two bins are
This is the state immediately after the execution of the d-hook built-in predicate is completed, and the two bind hook control blocks 61 and 62
correspond to true variable cells v and W of variables X and Y in node 51, respectively.

FIG. 5B shows that in node 51 of FIG. 5, as a call to predicate e, node 52 is called, and as a result of integrating variables x and y, bind hook control blocks 61 and 62 are integrated,
A hook chain has been formed. bind·
The method of executing the hook predicate is the same as (dl, +e) in FIG.

As described above, multiple bind/hook predicates can be executed by providing a bind/hook control block and a chain between the blocks on the stack area, and a bind/hook control register in the CPU. I can do things. Furthermore, the runtime overhead for processing the mechanism according to the invention consists of checking the contents of the bind hook control register if all head arguments of the called clause are successfully merged, and checking the contents of the bind hook control register when the arguments are merged. There is only the overhead of checking whether the content of is a pointer to a bind hook control block, and the implementation of the bind hook function according to the present invention is faster than the case where the function is not implemented. The decrease is slight.

In addition, in the above embodiment, the method of executing double bind/hook predicates was explained based on FIG. 3 and FIG. Integration of bind hook predicates by integrating different variables for which bind hook predicates have been registered twice or more can also be performed in the same manner as in FIGS. 4 and 6.

Also, in section 35 of FIG. 3 and section 56 of FIG. 5, the execution order of the two bind hook predicates is set to
Although it is specified that the d-hook built-in predicate is executed first, when forming the hook chain in Figure 4 (C) or Figure 6 fbl, the bind hook Hill
If we form a chain in which the blocks are arranged in order from the bottom of the stack to the top of the stack, the execution of the bind-hook predicate will start from the bottom of the stack, which means that the execution of the bind-hook built-in predicate will be executed from the bottom of the stack. The oldest one will be executed first.

So far, we have explained the case where the bind/hook control block and its chain are stacked on the stack area 21 for variable cells, but it is also possible to provide these in main memory separately from the stack area 21 for variable cells. Even if it is managed on the stack area, there is no change in the explanation so far.

〔Effect of the invention〕

As explained above, according to the present invention, in the stack area provided on the main memory of the logical program execution processing device,
The registration information of one or more predicates registered for the same variable is combined and stored in a chain whose terminal end is grounded, and
By storing a pointer to the start of the chain and its variable, and managing the chain and predicate calls in the stack area using registers provided in the central processing unit of the device, access to a specific variable can be made. By assigning a value, one or more predicates registered for that variable and different variables that are integrated with that variable are called, allowing for more flexible programming without sacrificing execution efficiency. The present invention has the advantage that it is possible to provide a logical program execution control method that enables the following.

[Brief explanation of drawings]

Figure 1 shows Prolo with a built-in predicate bind-hook.
An example of a logical type program written using g, Figure 2 is the first
An embodiment of the present invention relating to a program example, FIG. 3 is an example program that executes the built-in predicate bind-hook multiple times for the same variable, and FIG. 4 is an embodiment of the present invention relating to the program example shown in FIG. Figure 5 shows the built-in predicate bind-ho
FIG. 6 is an example of a program in which variables for which OK has been executed are integrated. FIG. 6 is an embodiment of the present invention related to the program example shown in FIG. 1... Main memory, 2... Central processing unit, 21°43.
...Stack area, 26.27.28...Register. Note that the same reference numerals are used for the middle part of the figure or corresponding parts.

Claims (1)

[Claims] In a logical program execution processing device that executes a program written in a predicate logical programming language, by assigning a value to a specific variable, a function is realized that calls a predicate registered in advance for that variable. In this process, the registration information of one or more predicates registered for the same variable is stored in a stack area provided on the main memory of the device in a chain with the terminal end grounded, and the chain is Assign a value to a specific variable by storing a pointer to the start end and its variable, and managing the chain and predicate calls in the stack area using registers provided in the central processing unit of the device. 1. A logical program execution control system characterized in that an operation calls one or more predicates registered for a variable and a different variable integrated with the variable.