JPH02112026A - Method for processing prolog program - Google Patents

Abstract

PURPOSE:To release an unnecessary stack used for a goal to reduce the using quantity of a stack by clearly stating the goal in a PROLOG program, to which only one solution exists or which requires only one solution. CONSTITUTION:An execution controlling section 2 reads out a predicate verb to be executed from an input section 4 and discriminates whether or not a read-out goal means 'SCUT', namely cancellation of the control information stored in a stack after the goal is executed. When the goal does not mean the 'SCUT', the section 2 fetches the program having the read-out goal at the head section from a program storing section 1. At the same time, the section 2 analyzes control information from a program, accumulates the information in a stack 3, and finds a solution by executing the goal by referring to the control information. After executing the goal, the section discriminates whether or not a next goal is designated from the input section 4 and, when no designation is made, the section completes the program process. Therefore, the quantity of stacks used for executing a predicate verb to which only one solution exists or which requires only one solution can be reduced.

Description

DETAILED DESCRIPTION OF THE INVENTION [Field of Industrial Application] The present invention relates to a method for processing a PROLOG program.

[Conventional technology]

FIG. 3 is a diagram explaining the conventional PROLOG program processing method, in which (1) is a program storage section that stores the PROLOG program (hereinafter simply referred to as a program), and (2) is a program storage section (1). (3) is a stack that stores control information interpreted from the program read by the execution control unit (2); (4) is an execution control unit that executes the program read by the execution control unit (2);
This is an input section for specifying and inputting the predicate to be executed.

Next, the operation will be explained based on the above configuration. Now, "run" is written in the program storage section (1).

Programs to which predicates "l-, 'b,"", and "P are attached are stored. When executing a specific predicate among these predicates to perform program processing, the execution control unit (1) selects the predicate (goal) to be executed from the human power unit (4).
, for example, extracts “run”, and the execution control unit (4) extracts “run”.
A program (section) with the goal run as its head
is retrieved from the program storage unit (1). At this time, the execution control unit (4) interprets control information for goal execution from the retrieved program and stores it in the stack (3).

The execution control unit (4) performs this operation every time it retrieves a program according to the specified goal, and stores control information corresponding to each goal on the stack (3).

The stack (3) that stores control information as described above cannot be solved by executing the goal corresponding to the control information (
(failure), the stack is freed from control information.

However, when obtaining a different solution by executing the same goal, it is necessary to refer to the contents of the stack (control information), so the stack cannot be released from the control information.

(Problems to be Solved by the Invention) Conventional PROLOG programs are processed in the manner described above, so when the program is executed, goals other than goals for which no solution can be obtained, for example, goals for which no other solution exists, or goals that have another solution Even after executing unnecessary goals, the stack is not freed from the control information of these goals, so the required storage area of the stack is occupied by unnecessary control information each time the goal is executed, and becomes effective. There was a problem that the stack could not be used.

The present invention has been made to solve the above-mentioned problems, and provides a PROLOG program processing method that can effectively utilize the stack without unnecessary control information occupying the stack.

[Means to solve the problem]

The PROLOG program processing method according to the present invention includes:
When each program in the PROLOG program storage section is executed by the program execution control means, the control information of the predicates constituting the program is read out to the stack and the predicates are executed based on the control information. For predicates for which there is only a single solution or for which only a single solution is required, a predicate is attached to clearly indicate this, and after these predicates are executed by the program execution control means, the stack is created after the above execution. The control information of the predicate is released.

[For production]

According to this invention, by specifying a goal in the PROLOG program for which there is only a single solution or for which only a single solution is required, the P ROLO
During the processing of a G program, unnecessary stacks used for the goal are released to reduce the stack usage.

〔Example〕

An embodiment of the present invention will be described below with reference to the drawings. 1st
In the figure, (1) is the part that stores the PROLOG program, and here - for example, run, a, b, c, p
The predicate is stored. (2) is the execution control section,
A predicate to be executed is read from the input section (4), the predicate in the program storage section (1) is referred to, and information is written and referenced in the stack (3) while executing the predicate. (
3) is a stack in which information necessary for the execution of a predicate is read and written; - For example, it shows the state immediately after execution of a predicate p in a predicate run has started. (4)
is the input section and reads the predicate to be executed.

Next, the operation of this embodiment based on the above configuration will be explained with reference to the flowchart of FIG.

First, the execution control unit (2) reads out a predicate (goal) to be executed from the input unit (4) (S-1). Next, it is determined whether the read goal is "5CUT", which means to release the control information stored in the stack after the goal is executed (S-2).
CUT", the same as the conventional program processing method,
The program having the read goal in its head is taken out from the program storage section (1) (S-3). At this time, the program interprets the control information and places it on the stack (3) (
S-4) Refer to this control information to execute the goal and find a solution (S-5).

After executing the goal, it is determined from the input section (4) whether or not the next goal has been specified, and if it has been specified, the process returns to (S-2) and the next goal is read, and if it has not been specified, the program processing ends. (S-6) Or, if it is determined that the goal is "5CUT" in (S-2), "5CUT"
Execute the predicate argument with the goal as the goal (S-7). Next, extract the program with this argument as the goal from the program storage section (1). 5-a) , Stack (3)
The control information for the goal is stacked in (S-9), the state of the stack is memorized at this time (S-10), and once the goal is executed, the control information related to this goal is released and the state before the control information is stored is stored. It returns to the stack state and stores the goal execution results again (S-11), (S-12). It is determined whether the next goal has been designated by the input section (4) (S-6). As a result, the control information that is no longer required to execute the goal is released from the stack (3).

In the above embodiment, the name 5CUT is used as the name of the predicate that saves the stack, but other names may be used. Further, regarding the stack, a plurality of stacks may be used depending on the information to be stored.

〔Effect of the invention〕

As described above, in this invention, by introducing a predicate that saves stack space, the amount of stack used is saved when executing a predicate where multiple solutions do not exist or only one solution is required. There is an effect that can be achieved.

[Brief explanation of the drawing]

FIG. 1 is a block diagram illustrating a processing method for reducing the amount of stack used in a PROLOG program according to an embodiment of the present invention, FIG. 2 is a flowchart showing the control operation of the present invention, and FIG. It is a block diagram explaining the processing method in a program. (1) Hub program storage section, (2) an execution control section for the PROLOG program, (3) a stack that stores control information during execution of the PROLOG program, and (4) an input section that reads predicates to be executed. Note that the same reference numerals in the figures indicate the same or equivalent parts.

Claims (1)

[Claims] When each program in the PROLOG program storage unit is executed by the program execution control means, the control information of the predicates constituting the program is read to the stack, and the predicates are executed based on the control information to process the PROLOG program. If there is only a single solution to the predicates of the program in the program storage section, or if only a single solution is required, a predicate that clearly indicates this is attached, and after these predicates are executed by the program execution control means. ,
A method for processing a PROLOG program, characterized in that a stack is released from control information of the predicate after execution.