JPH06214792A - Message passing mechanism - Google Patents

Abstract

PURPOSE:To provide a message passing mechanism capable of preparing an application system by only main pass coding. CONSTITUTION:Message passing mechanism is constituted of a message storage means 10 receiving a brake point signal and storing it in the vicinity of a brake point, a message returning value inspecting means 11 checking whether or not a message returning value returned from an object on a reception side is the message return value which expresses data correction and a message transmitting means 12 normally executing message passing between the objects, transmitting a signal to restoring to an object state at the time of setting the brake point to the outside at the time when data correction is detected and re-activating the stored message.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a message passing mechanism, and more particularly to a message passing mechanism which facilitates realization of an object oriented programming application system.

[0002]

2. Description of the Related Art In various application systems such as an office system, a user-friendly human machine interface (HMI) screen is created. A correction routine is created to allow the user to modify the displayed data. This is a big issue. In order to deal with such a problem, the inventor has disclosed a memory type editor configuration in Japanese Patent Application No. 3-134277 "Memory type editor system" and Japanese Patent Application No. 3-66579 "Editor device".

FIG. 6 is a diagram showing an outline of an editor configuration which is a conventional technique. In the memory type editor shown in the figure, the HMI screen is created by the memory type editor 32 which is a general-purpose tool.

Specifically, the application program 31 transmits a data input request message (subroutine call) together with the item name to be displayed / input. Upon receiving this message from the application program 31, the memory type editor 32 reads out the menu / dialog box 34 prepared in advance for the item name and displays it on the screen 33 to make a data request. User 30 referring to the screen
The data value obtained from the above is returned from the memory type editor 32 to the application program 31 as a return value for the message displayed on the screen 33.

Further, as shown in FIG. 6, the storage-type editor 32 sequentially displays the data values requested to be displayed and the data acquired from the user by allocating the values on the window. Since calculation of the display position on the screen and the like are all performed by the memory type editor, the application program creator does not need to be involved in the screen design.

Further, the memory type editor 32 is used by the user 30.
It has a function to realize data modification by. Here, as shown in FIG. 6, it is assumed that the question regarding item 3 is issued from the application program 31. Normally, the user 30 should operate the menu displayed on the screen to input data. However, the memory type editor 32 allows the user 30 to modify past input data. That is, it is possible to reversely refer to the item that the user has checked / input data in the past and select the relevant correction data item on the screen to make a correction. You have to be careful
In this way, while referring to the past input screen, the application program 31 is stopped with the data input request for item 3 being issued.

The operation for the above correction is an operation peculiar to the conventional memory type editor. That is, the user 30
When the correction is instructed by the storage type editor 32, the memory type editor 32 returns to the application program 31 a special symbol that means data correction. Hereinafter, this symbol will be referred to as a "correction symbol".

For example, in FIG. 6, a correction request (correction of item 1)
Is issued by the user, and (item 3 from the application program side
It is assumed that the return value for the data input request message becomes "correction symbol". When this "correction symbol" is returned, the application program 31 needs to return the internal data state to the breakpoint and re-execute the application program 31 itself. When the application program 31 is returned to the breakpoint in this way, the application program 31 makes a request for a data item, such as item 1 or item 2, which has been inquired to the user once.

The memory type editor 32 automatically responds to the same question item as described above, without changing the user screen. That is, since a unique name is given to each data item, the data value stored in the memory type editor 32 can be used as it is. Data request order / data item name from the breakpoint is
If the same as the previous time, the memory editor only rewrites the modified data item (eg, item 1) and does no further operation. In the example of FIG. 6, even item 1
Even after modifying the above, the application program 31 finally generates a data input request for item 3, and the storage type editor 32
Displays the selection menu 35 for item 3 and waits for an instruction from the user 30.

However, if the effect of the modified data item is,
When the order of questions changes, the memory type editor 32
Restarts the question to the user 30 from the changed question item. When a data item entered in the past appears again after the order of questions changes, the data item should be displayed as the default value of the menu / dialog box to make the operation of the user easier. Ah

[0011]

However, the above conventional technique has a problem in that the application program has a function of detecting the "corrected symbol". Therefore, a routine that determines the "correction symbol" is added to all the routines that require data input of the application program, and when the "correction symbol" is detected, the routine is rewritten so as to return to the breakpoint. There is a need. This is a typical application program,
This has created the need to add routines for data modification. The code amount is not negligible in the entire application system.

[0012] The programming paradigm that we need is a memory-type editor that enables an application program to be realized only by main-path coding, which does not have coding for modification in the application program type. Is the usage environment.

The present invention has been made in view of the above points, and when using a memory type editor, an additional routine for data correction is wiped out from an application program, and the application system is coded by only the main path. The purpose is to provide a message passing mechanism that enables creation.

[0014]

FIG. 1 shows the principle configuration of the present invention. The message passing mechanism 1 of the present invention receives a breakpoint signal from a transmitting side, and a message storing means 10 for storing a message received by an object on the receiving side in the vicinity of the breakpoint and a message sent back from the object on the receiving side. Received message return value,
Message return value checking means 11 for checking whether or not the message return value is a message return value expressing a predetermined data modification time, and message passing value checking means 11 for performing message passing between objects normally. When the data correction time is detected, the message sending means 12 sends a signal for returning to the object state at the time of setting the breakpoint to the outside and restarts the message stored in the message storage means 10.
Composed of.

[0015]

According to the present invention, the breakpoint signal is received, the message received by the object is stored in the vicinity of the breakpoint, the message return value returned from the object is received, and the message return value is predetermined. Check whether it is the message return value that expresses the time when the data was modified. If the result of the check is that it is not during normal data modification, message passing between objects is realized. On the other hand, when the message return value expresses the time of data modification, it is configured to send a signal to the outside to restore the object state at the time of setting the breakpoint and restart the stored message,
Within the scope of the object-oriented programming paradigm, there is no additional routine for data modification in the application program.

[0016]

Embodiments of the present invention will be described below with reference to the drawings.

FIG. 2 shows the structure of a message passing mechanism according to an embodiment of the present invention. The message passing mechanism of the present invention receives a breakpoint signal from an object on the transmission side, stores a message received by the object in the vicinity of the breakpoint, and receives a message return value returned from the object. Then, the message return value inspection unit 110 that checks whether or not the message return value is a message return value that represents a predetermined data correction time, performs message passing between objects, and the message return value inspection unit 110 When the time of data correction is detected,
A message transmission unit 120 that transmits a signal for returning the object state at the time of setting a breakpoint to the outside and restarts the message stored in the message storage unit 100.
Composed of.

The operation will be described below.

Object 200 on the message sending side
Sends a message by designating the receiving side object 210. The designation of the receiving object 200 uses what is uniquely determined by the object, such as the object number and the object name.

The message transmission unit 120 receives this message, searches for a reception object, and transfers it to the object. Furthermore, the message transmission unit 120
Receives the return value returned by the receiving object 210 and transmits it to the transmitting object 200. In this operating range, there is no difference between the conventional message sending means and the message sending means of the present invention. It can be sufficiently realized by the conventional method.

However, in the message passing mechanism of the present invention, the operation is different when the receiving object 210 is a memory type editor. That is, the memory type editor is
From the perspective of the application program, it is a kind of object. The storage-type editor receives a data input request from the transmission-side object 200 that constitutes a part of the application program, and returns the data value input by the user to the transmission-side object 200 as a return value for the message. In normal operation, this message passing is performed as prior art message passing. However, the operation is peculiar to the present invention in the following two cases. (1) When the application program side (the sending side object in FIG. 2 corresponds to this) declares a breakpoint setting. (2) When the storage side editor (in FIG. 2, the receiving side object corresponds to this) returns the "correction symbol".

First, consider the case where the application program declares a breakpoint. In this case, the application program sets a breakpoint by calling a function (subroutine call) or sending a message to a specific object.

In the present invention, it is necessary to configure the message passing mechanism to detect this breakpoint setting in some way. When the message passing mechanism detects the occurrence of a breakpoint, it manages an object, for example, an expert system construction support system (for details, see, for example, expert system construction support system KBMS Reference Manual, published by NTT Software Corporation). )
Notify the breakpoint occurrence. Since the expert system construction support system uses objects called "frames" as a data structure, it constitutes a kind of object-oriented programming environment.

Further, the message passing mechanism is provided with a message storage unit 100 for storing a message in the vicinity where a breakpoint is set. However,
When there are a plurality of breakpoints, it is necessary to store the breakpoint identifier such as a number and the immediately following message as a pair when setting the breakpoint.

Next, consider the case where the "correction symbol" is returned from the memory type editor. As shown in FIG. 2, the message passing mechanism 1 of the present invention includes the message return value inspection unit 110, which constantly monitors whether or not the return value is the “correction symbol”.

If the "correction symbol" is returned from the receiving side object 21 (specifically, the memory type editor), the message return value inspection unit 110 reports the fact to the message transmission unit 120. Message transmitter 1
Upon receiving this report, the 20 performs two operations.

First, a system for managing objects, for example, an expert system construction support system is instructed to return the data state to a breakpoint. As a result, all the data states of the objects are returned to the breakpoint. In fact, the expert system construction support system normally has a function of restoring the data state to the previously designated breakpoint.

Second, the message transmitting unit 120 restores the data state to the breakpoint, then retrieves the message near the breakpoint stored in the message storage unit 100 and restarts it. As a result, the message activation in the restored past object state is reproduced. Therefore, the application system side is restarted,
Data input requests are successively issued to the memory type editor. The advantage of this method is that there is no need to add any routine related to data modification to the object on the application system side. In other words, the application program finishes its creation by coding only the main path.

Hereinafter, the message storage unit 10 shown in FIG.
0, the message return value inspection unit 110, and the message transmission unit 120 will be described in more detail. In addition, these configuration examples are as long as they realize the same function.
It may be implemented as software or as hardwired logic. In the present processing, this is exemplified as a processing flow.

FIG. 3 is a flow chart of the processing of the message return value inspection unit according to the embodiment of the present invention. First, the message return value inspection unit 110 determines that the receiving side object 21
It waits until the message return value arrives from 0 (step 1). Message return value is the receiving object 2
When arriving from 10, it is checked whether this is a "corrected symbol" (step 2). If it is not a "correction symbol", it does not particularly work. However, when it is a “correction symbol”, the fact is reported to the message transmitting unit 120 (step 3)).

The message storage unit 110 can be constructed by a conventional technique. For example, the message has the following form. More complex messages are possible, but the basic functionality is the same. (Function name, destination object name, slot name, argument 1, argument 2, ...) However, here, the argument is a parameter passed to the slot, but how many exist depends on the message and the destination object. Also, "Function name"
Indicates an operation for an object such as “write data” or “read data”, and it is necessary to select from the designated function names as the function names that can be used in advance.

In this embodiment, it is assumed that only the following two types of messages exist. (Slot value write destination object name slot name slot value) (Slot value read destination object name slot name) The message storage unit 110 stores this message together with the source object and the slot name. For example, the following message is stored. ((Function name destination object name slot name argument 1 argument 2 ...) Source object name Source slot name) If there are a plurality of breakpoints, this message information is stored for each breakpoint. Furthermore, when the "correction symbol" is returned and the object state returns to a certain breakpoint, it is necessary to completely erase the message memory related to the breakpoints generated after the breakpoint.

Before explaining the message transmitting section 120, the structure of the object will be briefly described. FIG. 4 is an example of an object. The object has a unique slot name, trigger function, and slot value inside the object. For simplicity, in the present example, the creation of a message in an object is assumed to occur only by trigger activation embedded in the slot. Further, for simplification of description, in this specification, the trigger function is the message itself and is one of the above-mentioned "write slot value" and "read slot value". However, this simplification does not affect the gist of the present invention.

In the example of FIG. 4, the trigger function is set only in "slot 1", and the trigger is not set in the other slots. Also, here, the setting of the breakpoint is such that when the message arrives at the object, the breakpoint identification number is assigned to the breakpoint slot in advance (a unique number is assigned to all objects).
Shall occur when is stored. In the example of FIG. 4, the breakpoint number "1" is designated.

FIG. 5 shows a flowchart of the processing of the message transmitting unit 120 according to the embodiment of the present invention. First, when the message sending unit 120 receives a message from the sending object 200 (step 101), it searches for the receiving object written in the message. If the receiving object 210 is a storage type editor (step 102), it sends a message to the storage type editor (step 103) and waits for the storage type editor to operate (step 104).

When the return value is returned from the memory type editor, the message transmitting unit 120 checks whether or not it is a "correction symbol" (step 105). If the message return value inspection unit 110 has not reported that the message transmission unit 120 is the “correction symbol”, the message transmission unit 120 returns the return value to the original transmission source object 200 (step 10).
6).

On the other hand, when the return value from the memory type editor is the "correction symbol", the message transmitting unit 120 sends an instruction to return to the breakpoint to the object management mechanism (step 107).

Further, the message corresponding to the breakpoint is read from the message storage unit 100 and activated (step 108). As a result, when the state of the application system is returned to the original state, the same message as before is activated and the system continues to operate as before. However, the memory type editor knows how far it has returned, and while gazing at the message name from the application system,
It will be watched whether the sequence is the same as the previous time.

When the receiving destination object 210 is not a storage type editor, the processing relating to the object is performed. If no breakpoint has been set for the object (step 109), the slot specified by the message is searched for and normal read / write operations are performed (steps 112, 113, 114). And
Finally, if there is a trigger function for the slot in question, that message is activated. When a breakpoint is set on the object, the object management system (eg, expert system construction support system) is instructed to set a breakpoint corresponding to the number. Report the breakpoint settings to the memory editor along with their breakpoint numbers.

In step 109, when a breakpoint is set in the breakpoint slot (step 109), the breakpoint slot is checked, and when the number is stored in the slot, the number is stored in the object management system. The corresponding breakpoint setting is instructed (step 110). Next, the setting of the breakpoint is reported to the memory type editor together with the number (step 111), and the normal read / write operation is performed.

For normal read / write operations,
If the slot value is read (step 112), the slot value of the slot is stored in the message return value storage area (step 113). On the other hand, if the slot value is written (step 112), the message argument is set to the relevant value. Write as slot value. The slot value is stored in the message return value storage area (step 114).

Next, if the trigger function is set, the trigger function is activated (step 115).

As can be seen from the flow chart described above, as long as the memory type editor does not report the "correction symbol", the same operation as the normal message passing mechanism can be realized. However, when a breakpoint exists, it is reported to the object management mechanism / memory type editor, which is different from the conventional message mechanism. In any case, setting a breakpoint,
The main feature of the present invention is that all determinations of "correction symbols" are concentrated in the message passing mechanism, which allows the application program written in object-oriented to be associated with the data correction relation by the user. There is no need to add any function.

It should be noted that, in this specification, the setting of the breakpoint is described as being performed immediately after the arrival of the message for the object. Therefore, the message generated in the vicinity of the breakpoint setting is actually the message that has been passed immediately before the breakpoint. However, depending on how you set the breakpoint,
The last message is not always desirable. For example, in the flow of FIG. 5, if a breakpoint is issued just before message creation by a trigger occurs, it is necessary to store the message immediately after the breakpoint. In the above sense, the expression “near the break point” is used in this specification. Which one to choose is of a nature to be chosen according to the preference of the person skilled in the art of designing the message passing mechanism details.

Further, the setting of the breakpoint number has been described in the present specification as being described as a concrete value in the object. However, the break point may be instructed by the application program in any form, and the break point number may be given as a serial number by the message passing mechanism itself.

[0046]

As described above, according to the message passing mechanism of the present invention, it is not necessary to describe the correction routine for the case where the user corrects the data in the application program.

Further, according to the message passing mechanism of the present invention described above, it is sufficient to describe the setting of the breakpoint as a special slot in the object, which simplifies the breakpoint processing on the application program side. .

[Brief description of drawings]

FIG. 1 is a principle configuration diagram of the present invention.

FIG. 2 is a configuration diagram of an embodiment of the present invention.

FIG. 3 is a flowchart of processing of a message return value inspection unit according to an embodiment of the present invention.

FIG. 4 is an example of an object configuration.

FIG. 5 is a flowchart of processing of a message transmission unit of the present invention.

FIG. 6 is a diagram showing a configuration of a storage editor.

[Explanation of symbols]

 1 Message Passing Mechanism 10 Message Storage Means 11 Message Return Value Checking Means 12 Message Sending Means 20, 21 Objects 100 Message Storage Unit 110 Message Return Value Checking Unit 120 Message Sending Unit 200 Sending Side Objects 210 Receiving Side Objects

Claims (1)

[Claims] 1. A message storing means for receiving a breakpoint signal from a transmitting side, storing a message received by an object on the receiving side in the vicinity of the breakpoint, and returning a message returned from the object on the receiving side. A message return value checking means for receiving a value and checking whether the message return value is a message return value expressing a predetermined data modification time, and usually message passing between objects is performed,
When the message return value checking means detects the time of data modification, the message sending means sends a signal for returning to the object state at the time of setting the breakpoint to the outside and restarts the message stored in the message storing means. A message passing mechanism characterized by being constructed.