JP2771951B2 - Program creation device for reactive system - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an apparatus and a method for creating a program, and more particularly to a method and an apparatus for creating an object-oriented program in a reactive system.

[0002]

2. Description of the Related Art ATM (Automatic teller machine), P
A reactive system such as an OS terminal usually has a display device for displaying a series of panels and input devices such as buttons, a keypad, a magnetic stripe reader, etc., and displays various prompts to display appropriate prompts to the user. Let the user select an action. That is, the user generates an input event by pressing an appropriate button or key, and interacts with the reactive system by receiving information feedback from the panel.

The operation flow of this reactive system
(Operational Flow) indicates a sequence of input events to be handled and an operation routine related to the input event. Here, consider the example of FIG. P1
Denotes an input event caused by pressing the P1 button, and P2 denotes an input event generated by pressing the P2 button. The sequence of input events expected in this operation flow is P1 and P1.
2 are continuously pressed, and this pressing operation is repeated one or more times. During this operation, the loop
Two counters, a counter and a value counter, operate. Both counters are reset to zero at the entry of the loop. The loop counter is incremented by one each time the iteration is performed, and the value counter is set to P
When 1 is pressed, 2 is incremented, and when P2 is pressed, 1 is decremented. When going out of the loop N times, both counters should be N.

This operation flow has a nested and hierarchical logical structure. The lowest level is an operation corresponding to an input event, and the higher level is a composite operation in which the lowest level operations are combined in a sequential, selection, or repetition (loop) manner.

The control of the operation flow is a mechanism for verifying whether an input event matches the specification of the operation flow, and executing a specified operation routine for handling the input event. A finite state machine is usually used to control this operation flow. A finite state machine defines a state transition diagram with states and events. When a certain event occurs in a certain state, the state transits to a new state, and an operation routine related to the state transition is executed.

FIG. 15 shows the operation flow of FIG. 14 in the form of a finite state machine. This finite state machine shows three states (s0, s1, s2), two events (P1, P2), and operations related to three state transitions. It should be noted here that the event P1 is shown in two places. One is a transition from s0 to s1, which is a reset operation and an operation relating to a loop counter and a value counter. The other is a transition from s2 to s1, which is the same operation except that there is no reset operation.

Although the method using the finite state machine is useful and has been used so far, FIG.
There are several problems as can be seen from the example shown in FIG. The general problems in implementing a finite state machine are as follows.

[0008] 1. As the number of input events increases or the operation flow becomes more complex, the number of states increases exponentially. Several attempts have been made to address this, but we will not mention it here.

[0009] 2. In order for the operation routine to be able to exchange data, a global data area is required.

[0010] 3. When the operation flow is transformed into a finite state machine, the logical structure of the operation flow is lost. The operation routine for an input event includes not only processing of the event but also processing of a higher-level logical structure of the operation flow. For example, the operation related to the transition from s0 to s1 by pressing P1 in FIG.
Includes a "reset" operation that logically belongs to the loop process.
Also, an event that appears only once in the operation flow may appear multiple times in the finite state machine. Furthermore, the actions for the events that appear multiple times are slightly different depending on the respective roles in the logical structure of the operation flow.

[0011] These difficult problems have the following undesirable consequences. 1. When the number of input events increases or the operation flow becomes complicated, implementation becomes difficult. Tools used in compiler construction, such as parser generators, may help generate a list of states and events for each state. However, the perspective generally assumed by the generator renders the generated parser useless in reactive systems that must execute as soon as an event occurs.

2. Program customization requires a thorough understanding of the entire finite state machine, including the logical structure implicit in the operational flow and the data maintained by the logical structure. For example, seemingly small changes, such as moving or removing one event, may cause the event to appear in several places and all of them must be changed,
If a role in a higher logical structure is accidentally changed, it may become necessary to respond to other events. This role includes initializing some data when entering the loop. Since all data is global and no scoping mechanism is available,
It is difficult to know which part of the operation routine belongs to which logical structure of the operation flow.

Consider an example of customization that introduces a new button P3. This button P3 does not change the value of any counter. Figure 1 shows the new operation flow
As shown in FIG. 6, the button P3 is configured to be pressed instead of the button P1.

FIG. 17 shows a case where FIG. 16 is represented by a finite state machine. Here, P3 indicates that the associated transition is 2
There are two. Even though P3 does not change the value of any counter, any action on the transition to which P3 is related will change the value of the counter. This means that the person trying to customize the operation flow must have global knowledge of the structure of the entire operation flow and the role of the operation related to the event in the entire operation flow. It shows. In other words, knowing that P3 does not change the value of any counter is not enough to introduce button P3.

[0015] In addition, guidelines for the procedure for creating a structured program include structured programming.
(structured programming). this is,
In some cases, a tree structure is used to describe the flow of a program with a high degree of abstraction. However, at the stage of lowering the degree of abstraction, it does not differ from a normal programming form. Japanese Patent Application Laid-Open No. 61-67135 discloses an example using such structured programming.

There is also a software development method called Jackson System Development (hereinafter referred to as JSD). JSD is a model for software development (Modelin
g) Supports phase, network phase, and implementation phase. In this modeling phase, the concept of events is important, and what events occur in what order is expressed by a combination of sequence, loop, and selection. For example, the event tree structure shown in FIG. 18 indicates that event A or event B or C continues 0 or more times, and event D lasts. A,
B, B, C, B, C, C, B, and D are one example of an event sequence. In general, the tree of events represents a restriction on the order of events for a process. A process has data inside, and the data is changed by an event.

Such a tree-structured sequence, loop,
The node representing the selection is not tied to any action because the event is the central concept. Data is held and changed by the event process. Therefore, nodes representing sequences, loops, and selections serving as intermediate nodes are merely for indicating a group of events, and do not perform any processing or data transfer.

[0018] In the network phase of the JSD, the mutual relationship such as the input / output of a plurality of processes represented by a tree structure of separate events is represented. In the implementation phase, we consider efficient implementation in ordinary computer systems, such as implementing multiple processes in one main program and subroutine hierarchy.

As described above, even the conventional example described above does not solve any drawbacks when the operation flow is implemented in the finite state machine format.

[0020]

SUMMARY OF THE INVENTION Accordingly, an object of the present invention is to solve the drawbacks of the prior art, avoiding the complexity of actually coding (programming), reusing programs, It is an object of the present invention to provide a method and an apparatus for realizing a bottom-up design and implementation.

Specifically, it is an object of the present invention to separate the processing for the higher-level logical structure of the operation flow from the processing of the event itself. Also, operations that require access to data (operations)
The purpose is to disperse data in such a way that it is prohibited except for.

It is another object of the present invention to facilitate and simplify programming by using an apparatus capable of performing such a method.

[0023]

According to the present invention, there is provided a method for defining a common operation as an operation, a method for defining a common operation as a composite operation, and a loop composite. Component storage for storing methods that define operations specific to operations, methods that define operations specific to sequence composite operations, methods that define operations specific to selection composite operations, and methods that define operations specific to primitive operations In response to signals from the apparatus, the display means, the input means, and a signal from the input means, the object of the loop compound operation, the object of the sequence compound operation, the object of the selection compound operation, and the object of the primitive operation are provided. And flow editor means to create and modify a tree structure corresponding to the operation flow of the observed combined program, and flow browser means for displaying on the display device in an arbitrary hierarchy in response to a signal from the input means a tree structure,
A reactive method having a method for defining an operation specific to each operation, and operation editor means for allowing a user to input data handled by the operation by an input means, and extracting and combining a method required for the operation from a component storage device. -A program creation device for the system.

Here, each method controls an operation flow and data processing by issuing a message and communicating with each other. Thereby, each operation becomes a part, and programming can be performed more efficiently and easily.

Further, the method for defining the common operation as the operation includes a responder method for transferring a responder message for searching for an operation that handles data to the parent operation, and the method for defining the common operation as a composite operation. In response to a start message from the parent operation, issues a start method that issues an initial operation message, a child control message, and an end operation message, and asks the parent operation whether the operation to be executed after itself can be executed. Includes a continuation method for transferring a continuation message for requesting each operation, so that each operation can be divided into class hierarchies, and components are formed within the operation. Here, the continuation method or message is canCon
Means tinue method or message.

Further, a method unique to the loop composite operation issues an executable message asking whether the child operation can be executed in response to the child control message, and if so, emits a start message. If it does not perform the above operation, it issues a self-executable message to itself, and issues an executable message to ask whether the child operation can be executed in response to the executable message from the parent operation. It is also conceivable to include an executable method. Here, the executable method or message is
means canStart method or message.

In addition, a method unique to the sequence compound operation includes a child control method for sequentially issuing a start message to the child operation in response to the child control message, and a child operation in response to the executable message from the parent operation. An executable method for issuing an executable message for asking whether the operation is executable, and a second executable method for responding to the executable message from the child operation and inquiring whether an operation to be executed after the child operation is executable. It is also conceivable to include

In response to the child control message, the above-described method specific to the selection compound operation issues an executable message asking whether the child operation can be executed, and if so, emits a start message. If it does not perform the above operation, it issues a self-executable message to itself, and issues an executable message to ask whether the child operation can be executed in response to the executable message from the parent operation. It is also conceivable to include an executable method.

Further, the method that defines the common operation as an operation includes a responder method for transferring a responder message for searching for an operation that handles data to the parent operation, and the method specific to the primitive operation is the parent operation. In response to the start message from, the start method that issues an event handling message that calls the event handling method that handles the event as a primitive operation, and compares the expected event with the input event to determine whether it is executable. It is also conceivable to include an executable method that returns to the parent operation. Here, the responder message or method means a responder message or method. The event handling method or message means a handleEvent message.

When the action editor is an input for a loop compound operation, a method for defining an initial action for the initial action message, an end action in the end action message, and an action to be performed for each iteration,
If there is data to be handled in the loop compound operation, the user may be prompted to input the data and, in that case, a responder method that manages the data.

In the case where the operation editor is an input for a sequence compound operation and a selection compound operation, a method for defining an initial operation for the initial operation message and an end operation in the end operation message, a sequence compound operation and a selection operation If there is data to be handled by the compound operation, it is conceivable to prompt the user to input the data and, in that case, a responder method for managing the data.

Further, the operation editor includes a primitive
When inputting an operation, it is conceivable to prompt the user to input an event to be handled and a method that defines an operation corresponding to the event.

According to another aspect of the present invention, there is further provided program storage means for storing a created program including a tree structure corresponding to an operation flow and an operation object corresponding to a node of the tree structure, The flow browser means may retrieve the existing program from the program storage means and display it on the display device, and the flow editor means may be capable of instructing a change of the existing program. In this way, existing programs can be reused and programming becomes more efficient.

As still another aspect of the present invention, there are provided means for simulating a reactive system for executing the created program, and tracer means for indicating on the display device which part of the created program is being executed. It is also conceivable to have. As a result, it is possible to perform a test of the created program.

[0035]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS We begin by analyzing the system in terms of the operations that the user performs in accordance with the requirements of the reactive system. Classify the operation into primitive and composite operations.

This primitive operation represents a simple operation by a user using an input device (button, keypad). For example, as shown in FIG.
Pressing 2 is a primitive operation.

In contrast to the primitive operations which are usually explicitly stated in the system specification,
A compound operation is a logical collection of primitives or other compound operations. For example, pressing the buttons P1 and P2 sequentially as shown in FIG. 1 is a compound operation, which is a sequential combination of two primitive operations.
The operation of pressing P1 and P2 is called a member operation of the composite operation, and is described as CS1 in the figure. FIG. 1 also shows a loop compound operation (CL1). This CL1 repeatedly executes the member operation CS1. There are various types of compound operations as shown in FIG.

Considering the example of FIG. 14, let's associate operations and data with operations. Primitive operations P1 and P2 increment the value counter by 2, -1 respectively. The loop compound operation CL1 includes two counters, a loop and a value. In general, a compound operation has two operations, an initial operation and an end operation. This operation is performed at the entry of the operation and at the exit from the operation, respectively. For example, the loop composite operation CL1 has an initial operation of initializing two counters, and the end operation is empty. In addition, CL1 has a "each iteration" operation that increments the loop counter by one. FIG. 3 shows an example of a nested box type.

FIG. 4 shows a simplified version of the customized system shown in FIG. A primitive operation representing the button P3 and a selection operation including the primitive operations P1 and P3 are added. The select operation replaces the original primitive operation in the operation flow.

The operation thus recognized is modeled as an operation object,
An instance of the "Operation" class (to be precise, one of its derived classes)
Will be implemented as The compound operation object contains a reference to the operation object representing its member operation. In this way, the operation flow of the entire system is represented as a tree of operation objects, and the leaves of the tree indicate primitive operations. FIG. 5 shows a tree representation of the system of FIG.

In the present invention, a class hierarchy as shown in FIG. 6 is proposed in the above-described operation modeling. That is, an operation (Operation) class has data called event sources (eventSources), and includes an initialize method, a start method, a canStart (can start) method, a re
It has a sponder (responder) method and a computeES (event source calculation) method. This operation class is called a base class. This operation
There are primitive classes and composite classes as derived classes. Primitive classes are initialize method, start method, canStar
It has a t method, a handleEvent (event handling) method, and a computeES (event source calculation) method.
In contrast, the composite class uses the initialize method, star
t method, canContinue (can continue, can continue)
Method, initialAction (initial action method), control
It has a Children (child control) method and a finalAction (end operation) method.

The composite class further has derived classes called a Sequence class, a Selection class, and a Loop class. Sequence class,
Initialize method, canStart method, controlChildren method, com for both selection class and loop class
Has puteES method, but the sequence class is canC
It also has an ontinue method, and the loop class
It further has an hRepeat (each iteration) method.

This primitive class and sequence
Classes, selection classes, and loop classes can set their derived classes and define their own methods to perform the functions required for their operations.

As another class, ExpectedEvent
There is a (expected event) class. This indicates that the primitive class is connected but is expected to handle the event specified by the ExpectedEvent class. ExpectedEvent
The class has an isReady method. Also, ExpectedE
The vent class has two derived classes, in this case, a Buttom class and a TimeOut that correspond to the button and timeout operations required in the reactive system.
There is a (timeout) class. Since it is necessary to memorize what kind of event is handled, data such as a key code and a time are stored. Further, it has an isReady method as a derived class of the ExpectedEvent class.

The basic operation of an object-oriented system will be described below, and then an example of a system using objects having such a class hierarchy will be described to show how the system operates.

In an object-oriented system,
A plurality of objects send messages to each other, and each object performs a function as a system by performing an appropriate operation on the messages. An object is an instance of a class,
Internal method for processing messages
Are grouped according to the class hierarchy. Upon receiving the message, the object sequentially searches for the corresponding method from the group corresponding to the derived class to the group corresponding to the base class, and executes the first method found (inheritance / inheritance function). For example, in the case of the loop object in FIG. 7, there is a CL1 class which is the most derived class from the operation class, but the CL1 class has the highest priority, and a method of the loop class is used for a method not defined by the CL1 class. . In FIG. 7, the parenthesized method in the right column is used by the derived class. Looking similarly, only the responder method is used directly in the operation class. In this way, the method defined in the base class and redefined in the derived class is said to override the method of the base class, and makes the method of the base class invisible from the outside. You can call base class methods from methods.

The operation of the system shown in FIG. 8, which is a customized example of FIG. 5, will be described. In this system, objects having a hierarchical structure as shown in FIG. 9 are combined. The actual operation is different even for the same method in different classes, so note the following description.

The operation of the system starts by sequentially sending the following messages to the root of the operation tree representing the operation flow. 1) initialize message 2) computeES message 3) start message So we will start with the initialize message.

1.1 Initialize Message The initialize message is sent from the root of the operation tree representing the operation flow (Root) at the start of the system to all the leaves (Leaf) of the tree along the tree structure, and performs necessary initialization.

1.1.1 initialize sent to loop 11
Message When the initialize message is sent to the object (Loop 11), 1) The initialize method is searched in Loop 11 and Loop
Found in class. 2) The initialize method (Loop class) is executed,
During execution a) Calling the initialize method of the Composite class will cause ini
A tialize message is recursively sent to sequence 13 which is a child operation of loop 11. b) Perform CL1 class specific initialization processing. (If, CL1
CL if you don't need to do class-specific initialization
Override the initialize method in one class (overri
do not do de). In this case, initialize the Composite class
The method is executed. In FIG. 9, it is omitted because it is not necessary. )

1.1.1.1 Initialize Method of Composite Class The initialize method defined in the Composite class recursively sends an initialize message to all child operations.

1.1.2 initial sent to sequence 13
ize message initialize message is an object (sequence 13)
1) the initialize method is searched in sequence 13
Found in the Sequence class. 2) The initialize method (Sequence class) is executed, and during execution a) Calling the initialize method of the Composite class
The tialize message is sent recursively to the selection 13 and P2 (17), which are the child operations of sequence 13. b) Perform the initial setting process specific to the CS1 class.

1.1.3 Initialize Message Sent to Selection 15 If an initialize message is sent to the object (selection 15), 1) the initialize method is searched in selection 15 and Sele
Found in the ction class. 2) The initialize method (Selection class) is executed, and during execution a) Calling the initialize method of the Composite class
The tialize message is sent recursively to the selection 15 child operations P1 (19) and P3 (21). b) Perform the initialization process specific to the SL1 class.

1.1.4 P1 (19), P2 (17) and P
Initialize message sent to 3 (21) Since this is an atomic operation, an initial setting process for this operation is performed. Unless you do nothing, override the initialize method in P1, P2 and P3 classes
You don't have to.

1.2 computeES Message The event source calculation (computeES) is performed in order to know in advance the possibility that an object will be executed. The event source is, for example, an input device that generates an event that can start an operation, such as a keyboard and a keypad.

First, ES _EXIT is introduced. This ES _EXIT
As shown in FIG. 10A, is an event source that generates an event such that an operation is completed and another operation can be started. ES _ENTRY , on the other hand, is an event source that generates events that can initiate operations. For example, if the operation in FIG. 10A is a primitive operation,
_ENTRY is the event source (eg, button P1) expected by the primitive operation.

ES _EXIT and ES _ENTRY are C ₁ ... C _n
Is given by the following simultaneous equations:

[0058]

(Equation 1)

[0059]

(Equation 2)

[0060]

(Equation 3)

Further, ES _EXIT and ES _ENTRY of the selection operation composed of C ₁ ... C _n are given by the following simultaneous equations.

[0062]

(Equation 4)

[0063]

(Equation 5)

Further, a loop operation having a child operation C is as follows.

[0065]

(Equation 6)

[0066]

(Equation 7)

These simultaneous equations are bottom-up (from primitive operations to the root operation of the operation tree) and from back to top (from ES _EXIT to ES _ENTRY for any operation object, and the sequence In the case of an operation, calculation is performed from the last child operation to the first child operation. That is, the computeES message instructing the calculation of the event source includes the event source of ES _EXIT . However, ES _EXIT in the route, which is a boundary condition, is empty.

As described above, the computeES message is sent from the root of the operation tree representing the operation flow to all the leaves (Leaf) of the tree along the tree structure to calculate the event source. Although the calculation of the event source is different for each composite operation class, as will be understood from the following description, a computeES method suitable for each composite operation class is executed.

1.2.1 ComputeES Message Sent to Loop 11 When the computeES message is sent to the object (loop 11), 1) the computeES method is searched in loop 11 and loop
Found in class. 2) The computeES method (Loop class) is executed,
During execution: a) The computeES message is recursively and repetitively sent to the sequence 13 which is a child operation of the loop 11, and the event source of the sequence 13 is calculated. b) The calculation of the event source of the loop 13 is performed. See Equations 6 and 7.

1.2.2 compute sent to sequence 13
ES message computeES message is an object (sequence 13)
1) The computeES method is searched in sequence 13 and S
Found in the equence class. 2) The computeES method (Sequence class) is executed, and during execution a) the computeES message is recursively sent to the selection 15 and P2 (17), which are child operations of the sequence, and the events of selection 15 and P2 (17) -Source calculation is performed. b) Calculation of the event source of sequence 13 is performed. See Equations 1, 2, and 3.

1.2.3 ComputeES Message Sent to Selection 15 If the computeES message is sent to the object (selection 15), 1) the computeES method is searched in selection 15 and
found in the tion class. 2) The computeES method (Selection class) is executed and during execution: a) The computeES message is recursively sent to the child operations P1 (19) and P3 (21) of the selection 15,
The calculation of the event sources of P1 (19) and P3 (21) is performed. b) The calculation of the event source of selection 15 is performed.

1.2.4 P1 (19), P2 (17) and P
3 ComputeES message sent to (21) Since this is an atomic operation, the event source is calculated from the corresponding ExpectedEvent class.

1.3 start message The start message indicates the root of the operation tree (Ro
ot) to start system operation. During the execution of the start method of each operation object, a canStart message to determine the next child operation to be executed from among multiple child operations and a canContinue message to determine whether the current operation ends and returns to the parent operation It progresses while being sent.

1.3.1 Start Message Sent to Loop 11 When the start message is sent to the object (loop 11), 1) the start method is searched in the loop 11 and the start method is searched.
Found in the te class. 2) The start method (Composite class) is executed,
During execution: a) An initialAction message is sent to itself (Loop 11). i) The initialAction method is searched in loop 11 and C
Found in L1 class. ii) The initialAction method (CL1 class) is executed. b) The controlChildren message is itself (loop 11)
Sent to i) The controlChildren method is searched in Loop 11 and found in the Loop class. ii) The controlChildren method (Loop class) is executed (see 1.3.1.1). c) A finalAction message is sent to itself (Loop 11). i) The finalAction method is searched in loop 11 and CL1
Found in class. ii) The finalAction method (CL1 class) is executed.

1.3.1.1 ControlChildren Method of Loop Class The controlChildren method defined in the Loop class repeatedly performs the following. 1) Wait for the next input event. 2) Send a canStart message to sequence 13 which is a child operation of loop 11. 3) If the answer to the canStart message is 'YES', sta
Send the rt message to the sequence that is a child operation of loop 11. 4) The answer to the canStart message is 'NO' or 'NOP' (NOP
"Possible No-Operation" means that you can proceed to the next operation without doing anything. ), Send a canContinue message to yourself, and if the answer is 'YES', controlChildren
End the method execution. a) The canContinue message sent to itself is searched in loop 11 and found in the Composite class. b) The canContinue method (Composite class) is executed. 5) Otherwise, issue an error message, ignore this input event, and return to the first step.

1.3.1.2 Composite class canContinue
Method The canContinue method defined in the Composite class is
Generally, parent operation (Operation Object) canCo
Although an ntinue message is sent, "YES" is returned because there is no parent operation in loop 11.

1.3.1.3 CanStart Method of Loop Class The canStart method defined in the Loop class sends a canStart message to a child operation and returns the result.

1.3.2 start message sent to sequence 13 When the start message is sent to the object (sequence 13), 1) the start method is searched in sequence 13 and
Found in the posite class. 2) The start method (Composite class) is executed,
During execution: a) The initialAction message is itself (sequence 1
Sent to 3). i) The initialAction method is searched in sequence 13 and found in the CS1 class. ii) The initialAction method (CS1 class) is executed. b) A controlChildren message is sent to itself (sequence 13). i) The controlChildren method is searched in sequence 13 and found in the Sequence class. ii) The controlChildren method (Sequence class) is executed (see 1.3.2.1). c) The finalAction message is itself (sequence 1
Sent to 3). i) The finalAction method is searched in sequence 13 and found in the CS1 class. ii) The finalAction method (CS1 class) is executed.

1.3.2.1 Sequence class controlChildr
The en method The controlChildren method defined in the Sequence class has its own child operations, selection 15 and P2
A start message is sequentially sent to (17). Generally, Seque
The controlChildren method defined in the nce class sends a start message to all its child operations in order, sends a start message to the last child operation, and ends.

1.3.2.2 CanContinue Method of Sequence Class The canContinue method of the Sequence class is not used in this example, and will be described later in another example.

1.3.2.3 canStart Method of Sequence Class The canStart method defined in the Sequence class performs the following operation. 1) Set j = 1. 2) Send a canStart message to the j-th child operation. 3-a) If the answer is 'YES', return 'YES' as the answer to canStart. 3-b) If the answer is 'NO', return 'NO' as the answer to canStart. 3-c) When the answer is 'NOP', j = j + 1 and j becomes
If the number is smaller than the number of child operations, the process returns to step 2.
At other times, return 'NOP' as the answer to canStart.

1.3.3 Start Message Sent to Selection 15 If a start message is sent to the object (selection 15), 1) the start method is searched in selection 15 and
Found in class. 2) The start method (Composite class) is executed,
During execution: a) An initialAction message is sent to itself (selection 15). i) The initialAction method is searched in selection 15 and SL1
Found in class. ii) The initialAction method (SL1 class) is executed. b) The controlChildren message is myself (selection 15)
Sent to i) The controlChildren method is searched in selection 15 and S
Found in the election class. ii) The controlChildren method (Selection class) is executed (see 1.3.3.1). c) A finalAction message is sent to itself (selection 15). i) The finalAction method is searched in selection 15 and found in the SL1 class. ii) The finalAction method (SL1 class) is executed.

1.3.3.1 ControlChild of Selection Class
ren method The controlChildren method d defined in the Selection class is its own child operation P1 (19)
To the P3 (21), send a canStart message in order until an answer of 'YES' is returned or until the last child operation. If the answer is 'YES', send a start message to the child operation and return from the controlChildren method. 'N from all child operations
If an O 'answer is returned, issue an error message, ignore this input event, and return to the first step.
If a child operation returns 'NOP', send a canContinue message to itself (as described above, the composite class's canContinue method forwards the canContinue message to the parent operation).
Return from controlChildren method. In general,
The controlChildren method defined in the tion class applies the above steps to all of its child operations.

1.3.3.2 canStart Method of Selection Class The canStart method defined by the Selection class performs the following operation 1) Waits for the next input event. 2) Send canStart messages sequentially from the first child operation. (In this example, P1 (19) and P3 (2
1)) a) If the answer to the canStart message from the child operation is "YES", return "YES" as the answer. b) If the answer to the canStart message from the child operation is 'NOP', return 'NOP' as the answer. c) If the answer to the canStart message is 'NO', go to the next child operation. 3) If the answer to the canStart message from all child operations is 'NO', return 'NO' as the answer.

1.3.4 P1 (19), P2 (17) and P
Start message sent to 3 (21) The case where the start message is sent to a primitive operation object P1 (19), P2 (17) or P3 (21) will be described at the same time, but the execution is performed separately. . 1) The start method is searched in P1 (19), P2 (17) or P3 (21) and found in the Primitive class. 2) The start method (Primitive class) is executed,
During execution a) The handleEvent message itself (P1 (19), P1
2 (17) or P3 (21)). i) handleEvent method is P1 (19), P2 (17)
Alternatively, it is searched in P3 (21) and found in P1, P2 or P3 class. ii) The handleEvent method (P1, P2 or P3 class) is executed. The handleEvent method of the P1, P2, or P3 class performs its own processing.

1.3.4.1 canStart Method of Primitive Class The canStart method defined in the Primitive class checks whether the ExpectedEvent corresponding to itself and the current input event match (sends itself an isReady message. FIG. 6). The isReady method in the derived class of the ExpectedEvent class shown in (2) uses the stored data to make the determination.) If the match is found, 'YES' is returned; if not, 'NO' is returned as the answer.

The operation of the method related to the operation flow of each operation object has been described above. However, as described above, Sequence 13 of Sequence 13
Since we did not explain the class's canContinue method, we do it here.

FIG. 11 shows one example. In this example, the sequence operation SQ is the root,
Select operation SL as its child operation,
There are operation C and operation D. The child operations of the selection operation SL include an operation A and an operation B. sequence·
The execution order of the child operations of the operation is shown in FIG.
From the left, that is, from the selection operation SL. If operation B is skippable and may be "empty", operation C (or D)
It is described in advance that the process is performed when an event that can be started is input.

When the processing of the initialize message and the computeES message is completed and a start message is given to the root of the operation tree, a start message of the Composite class of the sequence operation is executed. This start message sends an initialAction message to itself, and the process is executed by a method of the CS1 class. In addition, a controlChildren message is sent to itself, and the controlChildren method of the Sequence class is executed (see item 1.3.2 above). This contr
The olChildren method sequentially sends start messages to child operations (see item 1.3.2.1 above).
First, here, a start message is sent to the selection operation SL ((1) in FIG. 11). Then, the initialAction is processed as described in item 1.3.3 above, and contro
Process lChildren messages. Selection class co
The ntrolChildren method sequentially sends canStart messages to child operations as described in the above item 1.3.3.1 ((2) and (3) in FIG. 11).

Here, if operation A, which is a child operation of selection operation SL, returns 'NO' and operation B returns 'NOP', co
The ntrolChildren method emits a canContinue message to itself. Then CanContinue of Composite class
The method transfers the canContinue message to the parent operation ((4) in FIG. 11).

Here, the canContinue method of the sequence operation, which is the parent operation, is searched and can be found in the Sequence class. here,
The following operation is performed.

1) When the i-th child operation is currently being executed, j = i. 2) Send a canStart message to the (j + 1) th child operation ((5) (6) in FIG. 11). 3-a) If the answer is 'YES', return 'YES' as the answer to canContinue. 3-b) If the answer is 'NO', return 'NO' as the answer for canContinue. 3-c) When the answer is 'NOP', j = j + 1 and j becomes
If the number is smaller than the number of child operations, the process returns to step 2.
At other times, canContin defined in Composite class
Call the ue method.

[0093] canContinue defined in the Composite class
Similarly, the method sends a canContinue message to the parent operation.

Next, the data flow will be described.
In addition to initiating its child operations as described above, the compound operation object has its own data, which is set and queried by the child operation object.
Since the data is encapsulated in a compound operation object, the compound operation object defines the message that the child operation sends to set or query the data. Also, to find a compound operation that contains data, the compound operation object
(Responder) method is provided.

FIG. 12 is a simplified view of a part of FIG. Here, the operation numbered 30 in each operation represents data. The loop operation object in FIG. 5 includes a value counter as shown in FIG. The handleEvent method in the primitive operation P1 sends a responder message to itself along with a parameter “Value” indicating a value counter. The Operation class of its own has a responder method. The method of this Operation class sends the responder message to the parent operation
Transfer to object. Here, it is sent to the sequence operation CS1. Since the responder method exists only in the Operation class in the sequence operation, the transfer is similarly performed to the parent operation CL1. Responder in operation CL1
A search for the method is performed, and a responder method is found in the CLoop class. This class's responder is overridden and returns a pointer to itself to indicate that it handles the parameter "Value". Then, after operation P1 has obtained a pointer to operation CL1, operation P1 can send a message for the data set to operation CL1 and increment the value counter at 2.

In this way, it can be seen that even if the customization is performed, no problem spreads around. Consider the introduction of the primitive operation P3 instead of P1 as shown in FIG. FIG. 8 shows a tree structure in which the selected object SL1 is inserted between the sequence operation CS1 and the primitive operation P1. The loop operation CL1 including the value counter is three levels above P1. In this case, if the responder method of the Operation class of the inserted selected compound operation SL1 transfers the response to the responder message from the operation P1 to the parent operation CS1, the rest is the same as described above. In this way, customization is easily performed.

It can also be seen that there is a remarkable effect on message transmission between operation objects. That is, message transmission between operation objects is performed only according to a path from the root of the operation tree to a certain operation object. More precisely, the parent operation object only has its immediate child operation objects (downward),
A child operation object can also send (upward) messages only to the immediate parent operation or its ancestor operation object. There is no message exchange between sibling operation objects. This reduces the number of operation objects affected by the primitive operation object corresponding to the user's operation, and facilitates debugging and testing.

Further, the following points also apply to simplifying debugging and testing. That is, data operated during the operation of the system can be accessed from the operation object that needs to be accessed by using a predetermined message for the operation object holding the data, and other operation The point is that it is kept localized and distributed so that it cannot be accessed from the object. Data is the lowest level of all operation objects that need to access them,
Retained in a common ancestor operation object. This is enforced by the operation object with the data being searched for by the responder message. The "vertical" arrangement of this data is
Reduce the number of operation objects that modify or reference data, making debugging and testing easier.

In the system described above, customization is facilitated, and the independence, modularity, and parts of each operation object can be increased. So, with this system,
Tools that support programming can be created more easily.

FIG. 13 shows a configuration diagram of a programming tool. The processing device 100 is connected to the component storage device 108 and the program storage device 106. It is also connected to an input / output device 104 such as a mouse, keyboard, and printer. Then, the processing result, the program, and the like are displayed on the display device 102. The component storage device 108 includes a method (e.g., a responder method) that defines a common operation as an operation and a method (e.g., a start method, ca) that defines a common operation as a composite operation.
nContinue method), a method that defines the operation specific to the loop composite operation, a method that is specific to the sequence composite operation, a loop composite operation that is specific to the selection composite operation, a sequence composite operation, a method that specifies the operation specific to the selection composite operation, and a primitive operation specific Stores methods and the like that specify the operation of. Further, the program storage device 106 stores a program processed by the processing device 100, that is, an operation tree corresponding to an operation flow and objects (including necessary methods) constituting nodes of the operation tree.

The processing device 100 takes out the method in the component storage device 108, adds necessary data and method, creates a tree structure corresponding to the operation flow, edits it, and stores it in the program storage device 106. . In addition, a program is taken out from the program storage device 106 and changed.

The processing device 100 has a flow browser 11
0, a flow editor 120, an operation editor 130, and a tracer 140.

The flow browser 110 displays the hierarchical structure (tree structure) of the operations on the display device 102. Zoom-in and zoom-out operations allow the entire structure to be displayed as detailed as necessary. For example, double-clicking a composite operation with a mouse may display child operations of the composite operation. For example, FIG.
Is displayed.

The flow editor 120 can create a tree structure corresponding to an operation flow, delete / move a specified operation object, create a new operation object, and add a new operation object to a specified position. For example, FIG.
8 to FIG. 8 can be performed.

The action editor 130 is for inputting information necessary for executing the program. That is,
Even if an operation object is used, each operation has its own process, so that data and methods corresponding to the operation object are defined. That is, the class of the most derived object is defined.

In the case of a loop compound operation, in
Specify itialAction method. In FIG. 3, it is necessary to perform a reset operation, and defines an operation of setting data handled in the loop composite operation to 0. Furthermore, for each operation to be performed for each iteration, an eachrepeat method is defined. In FIG. 3, the data loop is incremented by one. Furthermore, finalAction method is defined.
However, there is no need to specify anything in FIG. As described above, when no operation is required, it is not necessary to specify.

In the case of a sequence compound operation, an initialAction method, a finalAction method, and data are defined. However, it is not specified in FIG. 3 because it is not necessary.

The selection composite operation is the same as the sequence composite operation. In the case of an object that handles data, it is necessary to define a responder method.

In the case of a primitive operation, an event is defined in order to process the event.
In addition, it is necessary to define handleEvent method. This handleEvent method must emit a responder message to find the object that holds the data when it changes data.

In this way, one operation object is formed by defining the most derived class and combining the already stored methods belonging to each class of the object.

The tracer 140 performs a highlight display of the currently executed operation object and a display of internal data on the simulator when the reactive system is executed. Further, a break function for breaking at a designated operation object may be provided. The role of this simulator may be performed by the processing device 100 or a device connected by the input / output device 104 may be used.

In this system, the flow editor 12
0, an object which is an individual part is taken out, a tree structure as shown in FIG. 5 or FIG. 8 is created, an object of an appropriate hierarchy is displayed by the flow browser 110, and necessary data and A method may be specified. In addition, the existing program is taken out of the program storage device 106 and the flow browser 11
0 may be used to display an object of an appropriate hierarchy, and the operation editor may change the data or method to the data or method suitable for the operation.

Also, an example in which methods are defined in each class hierarchy in modeling an object has been described. However, this method may be defined if necessary in the system, or may not be defined if unnecessary.

[0114]

By using such a tool, the good points of object-oriented programming can be effectively used, and the programming can be facilitated.

Also, since the program can be visualized, the program can be easily constructed and changed.

Furthermore, the object orientation enhances the component properties. For efficiently customizing, assembling, changing, etc. these components, it is convenient if there are tools like machines. If you think about the configuration of this tool, the nature of the program is that it is only effective on a computer, and it is effective to use the above tools in terms of ease of assembly, customization, copying, deletion, etc. Therefore, the present program creation device based on the technical properties of the object of the present invention, which is a component of the program, has more effects than the mere use of a computer.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating an example of an operation.

FIG. 2 is a diagram showing types of operations.

FIG. 3 is a diagram showing details of an operation.

FIG. 4 is a diagram showing another example of the operation.

FIG. 5 is a diagram showing a tree structure of an operation.

FIG. 6 is a diagram showing a model of an object.

FIG. 7 is an example of a method included in an operation.

FIG. 8 is a diagram showing another tree structure of an operation.

FIG. 9 is a diagram showing the tree structure shown in FIG. 8 in detail.

FIG. 10 is a diagrammatic representation of the calculation of an event source.

FIG. 11 is a diagram illustrating the operation of a canContinue method.

FIG. 12 is a diagram illustrating the operation of a responder method.

FIG. 13 is a diagram illustrating a programming tool.

FIG. 14 is a diagram showing an example of an operation flow.

FIG. 15 illustrates the finite state machine of FIG.

FIG. 16 is a diagram showing another example of the operation flow.

FIG. 17 illustrates the finite state machine of FIG.

FIG. 18 is a diagram for explaining a conventional technique.

[Explanation of symbols]

 REFERENCE SIGNS LIST 100 processing device 110 flow browser 120 flow editor 130 operation editor 140 tracer 102 display device 104 input / output device 106 program storage device 108 component storage device

────────────────────────────────────────────────── ─── Continuing from the front page (72) Inventor Oshigashi Yaegashi 1623-14 Shimotsuruma, Yamato-shi, Kanagawa Prefecture IBM Japan, Ltd. Tokyo Research Laboratory (56) Reference "LECTURE NOTES ON COMPUTER SCIENCE" VOL . 707, p. 432-457 (1993) MARTIN J, “PRINCIP LES OF OBJECT-ORIENTED ANALYSIS AND DESIGN” PRENTICE-HALL (1993) CHAP. 9 (58) Field surveyed (Int.Cl. ⁶ , DB name) G06F 9/06 G06F 9/44

Claims (11)

(57) [Claims] (A) A method defining an operation common as an operation, a method defining an operation common as a compound operation, a method defining an operation unique to a loop compound operation, and an operation unique to a sequence compound operation. A method that specifies the behavior that is specific to the selection compound operation,
A component storage device for storing a method that defines an operation unique to the primitive operation; (b) display means; (c) input means; and (d) the loop composite in response to a signal from the input means. Flow editor means for creating and modifying a tree structure corresponding to the operation flow of the program by combining the object of the operation, the object of the sequence compound operation, the object of the selection compound operation, and the object of the primitive operation; A) flow browser means for displaying the tree structure on the display device in an arbitrary hierarchy in response to a signal from the input means;
(F) an action editor for allowing the user to input a method for defining an operation specific to each operation and data handled by the operation by the input means, and extracting and combining a method required for the operation from the component storage device; And a means for generating a program for a reactive system that controls an operation flow and data processing by communicating each other by issuing a message. 2. A method for defining a common operation as the operation includes a responder method for transferring a responder message for searching for an operation handling data to a parent operation, and defining a common operation as the composite operation. Method that issues an initial operation message, a child control message, and an end operation message in response to a start message from a parent operation, and whether the parent operation can execute an operation to be executed after itself. The program creation apparatus for a reactive system according to claim 1, further comprising an enable / disable method for transferring an enable / disable message for asking the user to ask the user. 3. The method specific to the loop compound operation, in response to the child control message, issues an executable message asking whether the child operation is executable. If the method is executable, the method issues a start message. If the operation does not perform any operation, in response to the child control method that issues an executable message to itself and the executable message from the parent operation,
An executable method for issuing an executable message for inquiring whether a child operation is executable. 4. A method specific to the sequence compound operation, comprising: a child control method for sequentially issuing a start message to a child operation in response to the child control message; and an executable message from a parent operation,
In response to an executable method that issues an executable message to ask whether the child operation is executable and an executable message from the child operation,
A second executable method for inquiring whether an operation to be executed after the child operation is executable. 5. A method specific to the selection compound operation, in response to the child control message, issues an executable message asking whether the child operation is executable, and if so, emits a start message. If the operation does not perform any operation, in response to the child control method that issues an executable message to itself and the executable message from the parent operation,
An executable method for issuing an executable message for inquiring whether a child operation is executable. 6. A method that defines an operation common to the operations includes a responder method for transferring a responder message for searching for an operation that handles data to a parent operation, and the method specific to the primitive operation includes:
In response to the start message from the parent operation, the start method that issues an event handling message that calls the event handling method that handles the event as a primitive operation is compared with the expected event and the input event. The program creation apparatus for a reactive system according to claim 1, further comprising: an executable method for returning whether or not to the parent operation. 7. When the operation editor is an input for the loop composite operation, an initial operation for the initial operation message, an end operation in the end operation message, and an operation to be performed for each repetition are specified. 3. The method according to claim 2, further comprising prompting the user to input a method to be executed, data to be handled in the loop compound operation, if any, and a responder method to manage the data. -A program creation device for the system. 8. The method according to claim 1, wherein the operation editor is an input for the sequence compound operation and the selected compound operation, and a method for defining an initial operation for the initial operation message and an end operation in the end operation message. 3. The system according to claim 2, wherein the user is prompted to input data, if any, handled in the sequence compound operation and the selection compound operation, and in that case, a responder method for managing the data. Programmer for active systems. 9. The operation editor according to claim 1, wherein said primitive
3. The program creating apparatus for a reactive operation according to claim 2, wherein in the case of an input about an operation, an event to be handled and a method for defining an operation for the event are prompted to be input. 10. A program storing means for storing a created program including a tree structure corresponding to an operation flow and an operation object corresponding to a node of the tree structure, wherein the flow browser means comprises: 2. The reactive system according to claim 1, wherein an existing program can be retrieved from the program storage means and displayed on the display device, and wherein the flow editor means can instruct a change of the existing program. Program creation device. 11. 請 further comprising means for simulating a reactive system for performing the creation program, and a tracer means for indicating whether the running which part of the created program to the display device
A program creation device for a reactive system according to claim 1 .