JP2005346434A - Widget operation method, device, program and recording medium with this program recorded thereon - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To make operation for a widget executable as input/output using a channel provided by a tuple space type communication system having a channel generation function. <P>SOLUTION: A widget operation method is provided with a step (step S43) which newly generates a widget and a channel corresponding thereto in response to a request of program code, associates them each other and stores them, a step (step S39) for transmitting an attribute of the widget to the tuple space, a step (step S39) for changing the attribute of the widget, and a step (step S45) for closing and terminating the widget. In addition, the method is provided with a step for transmitting an argument of a function called at the occurrence of an event. <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention relates to a widget operation method for performing an operation on a widget, and more particularly to a widget operation method for performing an operation on a widget as input / output using a channel provided in a tuple space communication system.

Conventionally, a communication system using a tuple space is known. In this communication system, a communication server (switch) called a tuple space is arranged in a network, and data is input to and read from a plurality of host devices in this tuple space, so that a computer program executed in each host device Information can be shared and exchanged between them.
Also, among communication systems using a tuple space, a tuple space communication system having a function of generating a channel as a data communication path is known (see, for example, Non-Patent Document 1). In this communication system, a computer program has a function of generating a channel that has not been used in the past, and secret communication between computer programs using a newly generated channel can be realized.

  On the other hand, window systems such as X Window System, QT, and Allo Common Lisp's Common Graphics are used to draw screens called widgets such as GUI (Graphic User Interface) buttons and scroll bars in order for the computer program to operate the screen. An operation in units of components is realized (for example, see Non-Patent Document 2). The widget has a changeable attribute, and an operation such as reading or changing the attribute can be performed using an evaluation function. The window system has a function of detecting an event such as a mouse button being clicked when the mouse pointer is displayed in an area on the screen where the widget is displayed (these are collectively referred to as an event). For this reason, by setting the name of the evaluation function for each event in each widget in advance, the evaluation function corresponding to the event can be called when the event is detected, and processing corresponding to the evaluation function can be performed.

The applicant has not yet found prior art documents related to the present invention by the time of filing other than the prior art documents specified by the prior art document information described in this specification.
E. Horita and K. Mano, “Nepi: A Network Programming Language Based on the π-calculus”, in COORDINATION 96, LNCS Vol.1061, Springer, pp.424-427, 1996 Franz Inc., “Common Graphics Integrated Development Environment” in http://www.franz.com/support/documentation/6.2/doc/cgide.htm Pawel T. Wojciechowski, “Nomadic Pict Language Libraries” in http://lsrwww.epfl.ch/%7Epawel/npict-library.ps.gz

Conventionally, a program code described in a format in which evaluation functions are sequentially arranged is used for operations on widgets. However, it has been pointed out that it is difficult to write program code in this format, and it is easier to write program code in a data input / output format.
Therefore, if communication using a channel between the tuple space and the host device in the above-described tuple space communication system can be used as input / output of data for executing an operation on the widget, the latter is used for the operation on the widget. It is possible to use a program code described in the format.

  Non-Patent Document 3 discloses a method for operating a screen on a system similar to a tuple space communication system having a channel generation function. However, it does not show how to execute an operation on the widget as communication.

  The present invention has been made in view of such a situation, and an object of the present invention is to perform an operation on a widget as input / output using a channel provided by a tuple spatial communication system having a channel generation function. There is to do.

  In order to achieve such an object, according to the widget operating method of the present invention, information is shared and exchanged between host devices via a channel using a tuple space having a shared memory arranged in a network. In a tuple space communication system, a widget operation method for performing an operation on a widget, which is an object that performs processing according to an event occurring on a display screen of a host device, as an input / output using a channel, and generating a widget When requested, it creates a widget, creates a channel corresponding to the widget, keeps the widget and channel associated with each other, and is specified by this request when widget attribute reading is requested. Tuple the attributes of the widget corresponding to the selected channel A step to send in between, a step to change the attribute of the widget corresponding to the channel specified by this request when a request to change the attribute of the widget, and a tuple of arguments of the function to be called when the event occurs A step of transmitting to the space; and a step of closing and closing the widget corresponding to the channel specified by the request when the closing and closing of the widget is requested.

  The widget operating device according to the present invention is a tuple space communication system that uses a tuple space having a shared memory arranged in a network to share and exchange information between host devices via a channel. A widget operation device that performs operations on widgets, which are objects that perform processing according to events that occur on the display screen of the device, as input / output using channels, and when a widget is requested to be generated, A channel corresponding to the widget, and a widget generation / holding means for associating and holding the widget and the channel, and when the attribute reading of the widget is requested, it corresponds to the channel specified by this request Send widget attributes to tuple space Attribute read / send means, Attribute change means for changing the attribute of the widget corresponding to the channel specified by this request when the attribute change of the widget is requested, and an argument of the function called when the event occurs And an argument transmission means for transmitting to the tuple space, and a close end means for closing and closing the widget corresponding to the channel specified by the request when the close and end of the widget is requested. To do.

A widget operation program according to the present invention is a program for causing a computer constituting the host device to execute each step of the widget operation method described above.
The recording medium according to the present invention is a machine-readable recording medium in which the widget operation program is recorded.

In the present invention, in response to a request for the program code, a channel corresponding to the widget is newly generated when the widget is generated, the widget is read, the attribute of the widget is transmitted to the tuple space, the widget is read, and the attribute of the widget is set. Make changes, close the widget and exit. In addition, the argument of the function called when the event occurs is transmitted to the tuple space. As a result, an operation on the widget can be executed as input / output using the channel provided by the tuple space communication system having a channel generation function.
As a result, program codes described in a data input / output format can be used for operations on widgets. Therefore, the program code for executing the operation on the widget can be described more easily than before.

Hereinafter, an embodiment of the present invention will be described in detail with reference to the drawings.
FIG. 1 is a block diagram showing a configuration of a tuple spatial communication system having a channel generation function. The tuple space communication system shown in this figure is composed of a tuple space 2 arranged in a network 1 and a plurality of host devices 3A, 3B, 3C,..., 3N. The host devices 3A to 3N are sometimes collectively referred to as the host device 3.

Here, the tuple space 2 includes a shared memory arranged in the network 1 and a management unit that manages the shared memory. The tuple space 2 receives requests from the host apparatuses 3A to 3N, and holds and deletes data. Data held in the tuple space 2 is called a tuple.
There are two requests, a transmission request (send, a, b) and a reception request (receive, a). The first element “send” of the transmission request (send, a, b) is a symbol indicating that it is a transmission request, the second element “a” is a channel identifier that is a value representing a channel, and the third element “b” is transmission data. The first element “receive” of the reception request (receive, a) is a symbol indicating a reception request, and the second element “a” is a channel identifier.

  The tuple space 2 receives a transmission request and a reception request from each of the host devices 3 </ b> A to 3 </ b> N, and sequentially accumulates the transmission request and the reception request in the tuple space 2. Then, it is checked whether a transmission request (send, a, b) and a reception request (receive, a) having the same channel identifier a exist in the tuple space 2 at the same time. If they exist at the same time, the transmission request (send, a, b) and the reception request (receive, a) are deleted from the tuple space 2, and the transmission source host device (for example, 3A) of the transmission request (send, a, b) A transmission completion message is sent to the transmission source host device (for example, 3B) of the reception request (receive, a). If there is no transmission request having the same channel identifier a as the reception request (receive, a) in the tuple space 2, the reception message NULL is sent to the transmission source host device (eg, 3B) of the reception request (receive, a). Send.

  FIG. 2 is a block diagram illustrating a configuration example of the host device 3. The host device 3 shown in this figure includes a request transmission unit 31, a result reception unit 32, a new channel generation unit 33, a widget table unit 34, an execution unit 35 implemented on a memory, and a window system 36. Have. The execution unit 35 further includes a plurality of program code execution units 41 (41-1, 41-2), an event table 42, an evaluation function name correspondence table 43, and a plurality of event evaluation function units 44 (44-1). , 44-2). Note that in this embodiment, “widget” is synonymous with “widget” in Common Graphics of Allegro Common Lisp.

Here, the execution unit 35 and the widget table unit 34 process a list similar to the Lisp language (for example, (a b c d)). Note that a list of length 2 may be referred to as a “group”.
The program code execution unit 41, the widget table unit 34, and the event evaluation function unit 44 call the evaluation function shown below in order to process the program code expressed using the list.

Evaluation function cons: Takes data A and list B as input and returns a list with B as the first element. For example, cons ((a), (b c d)) returns (a b c d).
Evaluation function 1st: Takes a list as input, takes out the first element and returns it. For example, 1st ((a b c d)) returns a.
Evaluation function 2nd: Takes a list as input, takes out the second element and returns it. For example, 2nd ((a b c d)) returns b.
Evaluation function 3rd: Takes a list as input, takes out the third element and returns it. For example, 3rd ((a b c d)) returns c.
Evaluation function 4th: Takes a list as input, takes out its fourth element and returns it. For example, 4th ((a b c d)) returns d.

Evaluation function list1: Takes data A as input and returns a list (A) consisting of A. For example, list1 (a) returns (a).
Evaluation function list2: Takes data A and B as input and returns a list (A B) consisting of A and B. For example, list2 (a, b) returns (a b).
Evaluation function list3: Takes data A, B, C as input and returns a list (A B C) consisting of A, B, C. For example, list3 (a, b, 10) returns (a b 10).
Evaluation function list4: Takes data A, B, C, D as input and returns a list (A B C D) composed of A, B, C, D. For example, list4 (a, b, 10, “hello”) returns (a b 10 “hello”).

Evaluation function assoc: assoc (x, y) extracts the element of the key x included in the association list y. Assoc (x, y) is synonymous with (assoc x y: test 'equal) in the Lisp language. For example, assoc (a, ((ax) (by))) returns (ax).
Evaluation function substate: Same as the Lisp language subst function. That is, substate (x, y, z) replaces the value y that appears freely in the list z with the value x. For example, substate (data, a, (a b c)) returns (data b c).
Evaluation function apply: Takes the name A and data B of the evaluation function as input, calls the evaluation function A with B as an argument, and returns the value obtained as a result. apply (A, B) is synonymous with (apply 'A (list B)) in the Lisp language. For example, apply (2nd, (ab)) returns b.

The program code execution unit 41 and the event evaluation function unit 44 call the following evaluation function for widget operation.
Evaluation function make-instance: Takes a widget class as an input, generates a widget that is an instance of the class, and returns a pointer to the generated widget. The execution unit 35 handles the pointer to the widget as the widget itself. make-instance (A) is synonymous with (make-instance 'A) in Common Graphics of Allegro Common Lisp. For example, make-instance (button) generates a widget that is an instance of a button class.

Evaluation function title: Takes a widget as an argument and returns a character string representing the title attribute of the widget. title (A, B) is synonymous with (title A'B) of Common Graphics of Allegro Common Lisp. For example, title (widget) returns the title attribute of the widget widget.
Evaluation function “background”: takes a widget as an argument and returns data representing the background color attribute of the widget. background (A, B) is synonymous with (Background-color A'B) of Common Graphics of Allegro Common Lisp. For example, background (widget) returns the background color attribute of the widget widget.

Evaluation function set-data: The function name A, widget B, and data C for reading the widget attribute are taken as arguments, the attribute represented by A in B is updated to C, and C is returned. set-data (A, B, C) is synonymous with (setf (AB) 'C) in Common Graphics of Allegro Common Lisp. For example, set-data (title, widget, “Start”) changes the title attribute of the widget widget to “Start” and returns “Start”.

Evaluation function set-event: Takes event name A, widget B, and evaluation function name C as arguments, updates the evaluation function name to be called when event A occurs in widget B, and returns C. set-event (A, B, C) is synonymous with (setf (AB) ′ C) in Common Graphics of Allegro Common Lisp. For example, set-event (on-click, widget, handle-event) changes the name of the evaluation function that is called when a mouse click event occurs in the widget button drawing area to handle-event.
Evaluation function close: Takes a widget as input and closes the widget. For example, close (widget) closes the widget widget.

The request transmission unit 31 receives transmission requests or reception requests from the program code execution unit 41 and the event evaluation function unit 44, temporarily stores the contents of these requests in an internal storage area (not shown), and stores the stored requests. Transfer to the tuple space 2 via the network 1.
The result receiving unit 32 receives a transmission completion message or a received message from the tuple space 2, temporarily stores the contents of these messages in an internal storage area (not shown), and stores the stored message in the program code execution unit 41. Forward.

  The new channel generation unit 33 stores an integer in the internal variable, and upon receiving a request from the widget table unit 34, returns the stored integer to the widget table unit 34 as a channel identifier representing the new channel. At this time, the integer value stored in the internal variable is incremented by 1, and stored again in the internal variable. Therefore, when the next request is received, an integer larger by 1 than the previous time is returned as the channel identifier. The same operation is performed when a request is received from the program code execution unit 41, and a channel identifier is returned to the program code execution unit 41.

  The widget table unit 34 has an internal variable widgetTable. A variable “widgetTable” stores a list of a pair “(channel identifier widget)” in which a channel identifier and a widget are associated with each other. The widget table unit 34 has internal variables r, c, and t for temporarily storing values.

The widget table unit 34 operates in the following procedure. FIG. 3 is a flowchart showing an operation flow of the widget table unit 34.
The widget table unit 34 waits for the arrival of a request from the program code execution unit 41, and when receiving the request (step S1, YES), stores the received request in the variable r (step S2).
The evaluation function 1st (r) is evaluated, and the evaluation result is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result is stored again in the variable r (step S4).

  Here, the variable c is evaluated (step S5). As a result, when the variable c is “search” (step S6, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result is stored again in the variable r (step S7). Then, the evaluation result stored in the variable r is returned to the program code execution unit 41 as a result for the request (step S8), and the process returns to step S1. As a result, in response to a request from the program code execution unit 41, a search is made as to whether or not a set corresponding to the channel identifier r exists in the own apparatus, and if it exists, the set is stored in the program code execution unit 41. Can return.

  If the variable c is “add” as a result of evaluating the variable c in step S5 (step S9, YES), the new channel generation unit 33 is called to receive the channel identifier from the new channel generation unit 33. The value of this identifier is stored in the variable t (step S10). Then, a set “(tr)” is newly added to the variable widgetTable (step S11). Further, the variable t is returned to the program code execution unit 41 as a result of the request (step S12), and the process returns to step S1.

  Furthermore, when the variable c is “close” as a result of evaluating the variable c in step S5 (step S13, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result is set to the variable r. Store again (step S14). Then, the group having the same content as the variable r is deleted from the variable widgetTable, stored again in the variable widgetTable (step S15), and the process returns to step S1. Thereby, when the widget is closed, the pair corresponding to the widget can be deleted from the variable widgetTable.

Hereinafter, the execution unit 35 will be described.
The event table 42 is a variable eventTable that stores a doubly nested list “((event type widget) channel identifier)”. The initial value is an empty list (). Therefore, the event table 42 holds a correspondence from a set of event types and widgets to a channel identifier corresponding to the set.

  Next, the event evaluation function unit 44 transmits to the tuple space 2 an argument of the evaluation function that is called when an event that has occurred on the drawing area of the widget is detected. There are a plurality of such event evaluation function units 44 corresponding to each event on a one-to-one basis. In the present embodiment, the event evaluation function unit 44-1 corresponds to the event on-click and has the name f-on-click. The event evaluation function unit 44-2 corresponds to the event on-double-click and has the name f-on-double-click.

  When the evaluation function set-event (A, B, f-A) is evaluated and the name of the evaluation function to be called when the event A occurs in the widget B is set to f-A, the window system 36 When the event A occurs in the widget B, the event evaluation function part f-A is called using the data B representing the contents of the widget B and the event A as arguments. At this time, the event evaluation function unit f-A corresponding to the event A operates according to the following procedure. Each event evaluation function unit 44 has “widTEMP” and “data” as internal variables for storing widgets and data as arguments. Also, it has internal variables val, adrs, and ack for temporarily storing values.

FIG. 4 is a flowchart showing an operation flow of the event evaluation function unit f-A.
The variable widgetTEMP of the event evaluation function part f-A stores a widget as an argument, and the variable “data” stores data d representing the content of the event A as an argument.
The event evaluation function unit f-A evaluates the evaluation function assoc (list2 (A, widTEMP), eventTable), and stores the evaluation result in the variable val (step S21). Further, the evaluation function 2nd (val) is evaluated, and the evaluation result is stored in the variable adrs (step S22).

  Subsequently, by sending a transmission request (send, adrs, data) to the request transmission unit 31 (step S23), an argument of an evaluation function called when an event is detected is sent to the tuple space 2. Then, it waits until a transmission completion message from the tuple space 2 is sent back through the result receiving unit 32. When a transmission completion message is received (step S24, YES), NULL is returned as a return value (step S25), and the process ends.

  Next, the evaluation function name correspondence table 43 is an internal variable tailTable that stores the group “(event name event evaluation function name)”. In other words, the evaluation function name correspondence table 43 includes an event name and the name of an event evaluation function that performs transmission to a channel defined when the event occurs (for example, on-click, f-on-click, on-double). -Click and f-on-double-click). The initial value is a list of all combinations of event names and corresponding event evaluation function names.

Next, a plurality of program code execution units 41 exist, and the program codes stored in the respective program code execution units 41-1, 41-2,.
The program code execution unit 41 has an internal variable p. The internal variable p stores a channel identifier for receiving a program code, a program code, and a process definition expression called from the program code. The program code execution unit 41 also has variables com, adrs, var, val, val1, val2, val3, next, tmpWD for temporarily storing instructions and values.

  Here, the variable com is a variable for storing an instruction extracted from the program code, the variable adrs is a variable for storing a channel identifier, and the variable var is a variable for storing a variable to be included in subsequent processing. Variables, variables val, val1, val2, and val3 are variables for storing data to be transmitted to the tuple space 2 or data received from the tuple space 2, and a variable next is a variable for storing a code representing subsequent processing, a variable tmpWD Is a variable for storing the result received from the widget table unit 34.

The program code is the following list.
P: = (end)
｜ (! Chan data P)
| (? Chan var P)
｜ (? G class width_chan P)
｜ (! G close width_chan P)

  In this list, the program code (end) means an end operation. The program code (! Chan data P) means a transmission operation using a tuple spatial communication system having a channel generation function, that is, a transmission operation of transmitting data data to the channel chan and executing the subsequent processing P. The program code (? Chan var P) is a reception operation using a tuple spatial communication system having a channel generation function, that is, receives data from the channel chan and replaces the variable var included in the subsequent processing P with the data. It means the receiving operation to be executed. The program code (? G class width_chan P) means a widget generation operation. The program code (! G close width_chan P) means a closing operation of the widget.

However, for the program code (! Chan data P), when the channel chan is registered in the widget table unit 34, that is, when the group (chan widget) is in the internal variable widgetTable of the widget table unit 34, the data data is Only the following are allowed in a list format of length 3.
(Read A ret_ch)
(Write A B)
(Event A ret_ch)
Here, data (read A ret_ch) means an operation of transmitting the value of attribute A to channel ret_ch. Data (write A B) means an operation of updating the value of attribute A to the value of B. Data (event A ret_ch) means an operation of registering the occurrence of event A to be transmitted to channel ret_ch.

An example of the program code is shown.
(? G button g_chan (! G_chan list3 (write, title, “mybutton”) (! G_chan list2 (read, background, 10) (? 10 data1 (! G_chan list3 (event, on- 20 (! -10 data1 (! G close g_chan (end)))))))))

The program code execution unit 41 operates according to the following procedure. FIG. 5 is a flowchart showing an operation flow of the program code execution unit 41.
As described above, the program code is stored in the variable p. The variable p is evaluated, and the evaluation result is stored in the variable val (step S31). The variable val is evaluated. If the content of the variable val is NULL (that is, empty) (step S32, YES), the process is terminated.
On the other hand, if the content of the variable val is not NULL (step S32, NO), the evaluation function 1st (p) is evaluated, and the evaluation result is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34).

  Here, the variable com is evaluated (step S35), and the following processing is performed according to the content of the variable com. First, when the variable com is “end” (step S36, YES), an end process is performed (step S37), and the process returns to step S31. The variable com is! If YES (step S38, YES), transmission processing to the tuple space 2 is performed (step S39), and the process returns to step S31. Also, what is the variable com? If YES (step S40, YES), the reception process from the tuple space 2 is performed (step S41), and the process returns to step S31. Also, what is the variable com? When it is g (step S42, YES), a widget generation process is performed (step S43), and the process returns to step S31. The variable com is! If it is g (step S44, YES), the widget is closed (step S45), and the process returns to step S31.

Hereinafter, processing according to the contents of the variable com by the program code execution unit 41 will be further described.
First, the termination process in step S37 of FIG. 5 will be described. FIG. 6 is a flowchart showing the flow of end processing. In the termination process, the value NULL is stored in the variables p, com, adrs, val, var, next (step S51), and the process returns to step S31 in FIG.

Next, the transmission process to the tuple space 2 in step S39 in FIG. 5 will be described. 7 and 8 are flowcharts showing the flow of transmission processing to the tuple space 2.
In the transmission process to the tuple space 2, first, the evaluation functions 2nd (p) and 3rd (p) are evaluated, and the evaluation results are stored in the variables adrs and val, respectively (step S61). Further, the evaluation function 4th (p) is evaluated, and the evaluation result is stored again in the variable p (step S62).
Subsequently, a request “(“ search ”adrs)” is sent to the widget table unit 34 (step S63), and the widget table unit 34 is inquired as to whether or not a file corresponding to the channel identifier adrs exists in the own device. Wait until the result is sent back from the widget table unit 34 (step S64). When the result is received, the result is stored in the variable tmpWD (step S65).

  When the variable tmpWD is evaluated and the evaluation result is NULL, that is, when the file corresponding to the channel with the channel identifier adrs does not exist in the own apparatus (step S66, YES), a transmission request (send, By sending (adrs, val) (step S67), the variable val is sent to the tuple space 2. Then, after waiting for the transmission completion message from the tuple space 2 to be sent back through the result receiving unit 32 (step S68, YES), the process returns to step S31 in FIG.

  On the other hand, if a file corresponding to the channel of the channel identifier adrs exists in the own apparatus and the evaluation result of the variable tmpWD is not NULL, but is a pair of the channel identifier and the widget “(adrs width)” (step) (S66, NO), the evaluation function 2nd (tmpWD) is evaluated, and the evaluation result (width) is stored again in the variable tmpWD (step S69). Also, the evaluation functions 1st (val), 2nd (val), and 3rd (val) are evaluated, and the evaluation results are stored in the variables val1, val2, and val3, respectively. (Step S70).

  Here, the variable val1 is evaluated (step S71), and processing corresponding to the content of the variable val1 is performed. First, when the variable val1 is read (step S72, YES), the evaluation function apply (val2, tmpWD) is evaluated, and the evaluation result, that is, the value of the attribute val2 of the widget widget is stored again in the variable val (step S73). ). Further, by sending a transmission request (send, val3, val) to the request transmission unit 31 (step S74), the variable val (value of the attribute val2 of the widget widget) is sent to the tuple space 2. Then, after waiting for the transmission completion message from the tuple space 2 to be sent back through the result receiving unit 32 (step S75, YES), the process returns to step S31 in FIG.

  Next, when the variable val1 is write (step S76, YES), the evaluation function set-data (val2, tmpWD, val3) is evaluated, and the value of the attribute val2 of the widget widget is updated to the variable val3 (step S77), the process returns to step S31 of FIG.

  Next, when the variable val1 is other than that (step S72, NO and step S76, NO), the evaluation function cons (list2 (list2 (val2, tmpWD), val3), eventTable) is evaluated, and the evaluation result is the variable. Re-store in eventTable (step S78). Thereby, the correspondence from the evaluation value (written as ev) of the event type val2 (written as ev) and the widget widget (ev widget) to the channel val3 is held in the event table. Subsequently, the evaluation function assoc (val2, tailTable) is evaluated, and the evaluation result is stored again in the variable val3 (step S79). Then, the evaluation function 2nd (val3) is evaluated, and the evaluation result is stored again in the variable val3 (step S80). Further, the evaluation function set-event (val2, tmpWD, val3) is evaluated (step S81). As a result, the name of the evaluation function called when the event val2 occurs in the widget tmpWD is updated to val3. Finally, the process returns to step S31 in FIG.

Next, the reception process from the tuple space 2 in step S41 in FIG. 5 will be described. FIG. 9 is a flowchart showing a flow of reception processing from the tuple space 2.
In the reception process from the tuple space 2, first, the evaluation functions 2nd (p), 3rd (p), and 4th (p) are evaluated, and the evaluation results are stored in the variables adrs, var, and next, respectively (step S91). Subsequently, a reception request (receive, adrs) is sent to the tuple space 2 via the request transmission unit 31 (step S92). Then, it waits until the received message from the tuple space 2 is sent back through the result receiving unit 32. When a received message is received (step S93, YES), the value x of this received message is stored in the variable val (step S94). The evaluation function substate (val, var, next) is evaluated, the evaluation result is stored in the variable p (step S95), and the process returns to step S31 in FIG.

Next, the widget generation process in step S43 in FIG. 5 will be described. FIG. 10 is a flowchart showing the flow of the widget generation process.
In the widget generation process, first, the evaluation functions 2nd (p), 3rd (p), and 4th (p) are evaluated, and the evaluation results are stored in variables tmpWD, var, and next, respectively (step S101). The evaluation function make-instance (tmpWD) is executed to generate a widget, and the return value is stored again in the variable tmpWD (step S102).

  Subsequently, a request “(“ add ”tmpWD)” is sent to the widget table unit 34 (step S103), the generation of a new channel is requested to the widget table unit 34, and a response is sent back from the widget table unit 34. When a response is received (step S104, YES), the new channel identifier value t in this response is stored again in the variable val (step S105). Furthermore, the evaluation function subroutine (val, var, next) is evaluated, the evaluation result is stored again in the variable p (step S106), and the process returns to step S31 in FIG.

Next, the widget closing process in step S45 of FIG. 5 will be described. FIG. 11 is a flowchart showing the flow of the widget closing process.
In the widget closing process, first, the evaluation functions 3rd (p) and 4th (p) are evaluated, and the evaluation results are stored in the variables adrs and p (step S111). Subsequently, a request “(“ search ”adrs)” is sent to the widget table unit 34 (step S112), and the process waits until a result for the request is sent back from the widget table unit 34. When the result is received (step S113, YES), the result is stored in the variable tmpWD (step S114).
Subsequently, a request “(“ close ”adrs)” is sent to the widget table unit 34 (step S115). Further, the evaluation function close (tmpWD) is executed (step S116), and the process returns to step S31 in FIG.

  Next, the execution procedure of each part of the host device 3 will be described in detail with specific examples. In the internal variable p of the program code execution unit 41, a new program code (? G button g_chan (! G_chan list3 (write, title, “mybutton”)) (! G_chan list2 (read, background, 10) (? 10 data1 (! G_chan list3 (event, on-click, 20) (? 20 data2 (! -10 data1 (! g close g_chan (end)))))))).

  At this time, the program code execution unit 41 first evaluates the variable p, and evaluates the result (? G button g_chan (! G_chan list3 (write, title, “mybutton”)) (! G_chan list2 (read, background, 10) ( 10 data1 (! G_chan list3 (event, on-click, 20) (? 20 data2 (! -10 data1 (! G close g_chan (end)))))))) is stored in the variable val (FIG. 5). Step S31).

  When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result? g is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), what is the content of the variable com? Since it is g (step S42, YES), a widget generation process is performed (step S43).

  Specifically, first, the evaluation functions 2nd (p), 3rd (p), and 4th (p) are evaluated, and the evaluation results button, g_chan and (! G_chan list3 (write, title, “mybutton”) (! G_chan list2 (Read, background, 10) (? 10 data1 (! G_chan list3 (event, on-click, 20) (? 20 data2 (! -10 data1 (! G close g_chan (end))))))) Stored in variables tmpWD, var, and next (step S101 in FIG. 10).

  Next, the evaluation function make-instance (tmpWD) is executed to generate a widget of the class button, and the return value (written as “wid”) of the make-instance function is stored again in the variable tmpWD (step S102). Subsequently, a request “(“ add ”width”) is sent to the widget table unit 34 (step S103), the generation of a new channel is requested to the widget table unit 34, and a response is sent back from the widget table unit 34.

  At this time, the widget table unit 34 is waiting for the arrival of a request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ add ”width)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “add” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result wid is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “add” (step S9, YES), the new channel generation unit 33 is called.

In response to this call, the new channel generation unit 33 generates a new channel and returns a channel identifier (in this case, 0) representing the new channel to the widget table unit 34.
The widget table unit 34 receives the channel identifier from the new channel generation unit 33, and stores the value 0 of this identifier in the variable t (step S10). Then, a new set “(0 width)” is added to the variable widgetTable (step S11). Further, the value 0 is returned to the program code execution unit 41 as a result of the request (step S12), and the process returns to step S1.

  When receiving a response from the widget table unit 34 (YES in step S104 in FIG. 10), the program code execution unit 41 stores the value 0 of the response in the variable val (step S105). Then, the evaluation function substate (val, var, next) is evaluated, and the evaluation result (! 0 list3 (write, title, “mybutton”) (! 0 list2 (read, background, 10) (? 10 data1 (! 0 list3 (Event, on-click, 20) (? 20 data2 (! -10 data1 (! G close 0 (end))))))) is stored again in the variable p (step S106). This completes the widget generation process, and returns to step S31 in FIG.

  Next, the program code execution unit 41 evaluates the variable p, and evaluates the result (! 0 list3 (write, title, “mybutton”) (! 0 list2 (read, background, 10) (? 10 data1 (! 0 list3 (Event, on-click, 20) (? 20 data2 (! -10 data1 (! G close 0 (end))))))) is stored in the variable val (step S31 in FIG. 5).

  When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result! Is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), the content of the variable com is! Therefore (step S38, YES), transmission processing to the tuple space 2 is performed (step S39).

Specifically, first, the evaluation functions 2nd (p) and 3rd (p) are evaluated, and the evaluation results 0 and (write, title, “mybutton”) are stored in the variables adrs and val, respectively (step S61 in FIG. 7). ). Also, the evaluation function 4th (p) is evaluated, and the evaluation result (! 0 list2 (read, background, 10) (? 10 data1 (! 0 list3 (event, on-click, 20) (? 20 data2 (! -10 data1 (! g close 0 (end)))))) is stored again in the variable p (step S62).
Subsequently, a request “(“ search ”0)” is sent to the widget table unit 34 (step S63), and the widget table unit 34 is inquired as to whether or not a file corresponding to the channel identifier 0 exists in the own device. Wait until the result is sent back from the table unit 34.

  At this time, the widget table unit 34 waits for the arrival of a request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ search ”0)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “search” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result 0 is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “search” (step S6, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result (0, wid) is converted to the variable r. (Step S7). Then, the evaluation result (0, wiid) stored in the variable r is returned to the program code execution unit 41 as a result of the request (step S8), and the process returns to step S1.

  When receiving the result from the widget table unit 34 (step S64 in FIG. 7), the program code execution unit 41 stores the result (0, wiid) in the variable tmpWD (step S65). When the variable tmpWD is evaluated, the evaluation result is a set (0 wiid) of the channel identifier and the widget (NO in step S66), so the evaluation function 2nd (tmpWD) is evaluated and the evaluation result wid is stored again in the variable tmpWD. (Step S69). The evaluation functions 1st (val), 2nd (val), and 3rd (val) are evaluated, and the values write, title, and “mybutton” are stored in the variables val1, val2, and val3. (Step S70).

  When the variable val1 is evaluated (step S71), since the variable val1 is “write” (step S76 in FIG. 8, YES), the evaluation function set-data (val2, tmpWD, val3) is evaluated, and the value of the attribute title of the widget width Is updated to “mybutton” (step S77). Thereby, the transmission process to the tuple space 2 is terminated, and the process returns to step S31 in FIG.

  Next, the program code execution unit 41 evaluates the variable p, and evaluates the result (! 0 list2 (read, background, 10) (? 10 data1 (! 0 list3 (event, on-click, 20) (? 20 data2 (! −10 data1 (! G close 0 (end)))))) is stored in the variable val (step S31 in FIG. 5).

  When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result! Is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), the content of the variable com is! Therefore (step S38, YES), transmission processing to the tuple space 2 is performed (step S39).

Specifically, first, evaluation functions 2nd (p) and 3rd (p) are evaluated, and evaluation results 0 and (read, background, 10) are stored in variables adrs and val, respectively (step S61 in FIG. 7). Also, the evaluation function 4th (p) is evaluated, and the evaluation result (? 10 data1 (! 0 list3 (event, on-click, 20) (? 20 data2 (! -10 data1 (! G close 0 (end))) ))) Is stored again in the variable p (step S62).
Subsequently, a request “(“ search ”0)” is sent to the widget table unit 34 (step S63), and the widget table unit 34 is inquired as to whether or not a file corresponding to the channel identifier 0 exists in the own device. Wait until the result is sent back from the table unit 34.

  At this time, the widget table unit 34 waits for the arrival of a request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ search ”0)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “search” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result 0 is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “search” (step S6, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result (0, wid) is converted to the variable r. (Step S7). Then, the evaluation result (0, wiid) stored in the variable r is returned to the program code execution unit 41 as a result of the request (step S8), and the process returns to step S1.

  When receiving the result from the widget table unit 34 (step S64 in FIG. 7), the program code execution unit 41 stores the result (0, wiid) in the variable tmpWD (step S65). When the variable tmpWD is evaluated, the evaluation result is a set (0 wiid) of the channel identifier and the widget (NO in step S66), so the evaluation function 2nd (tmpWD) is evaluated and the evaluation result wid is stored again in the variable tmpWD. (Step S69). Also, the evaluation functions 1st (val), 2nd (val), and 3rd (val) are evaluated, and the values read, background, and 10 are stored in variables val1, val2, and val3. (Step S70).

  When the variable val1 is evaluated (step S71), since the variable val1 is read (step S72 in FIG. 8, YES), the evaluation function apply (val2, tmpWD) is evaluated, and the value of the evaluation result (background color attribute of wid; (color) is stored again in the variable val (step S73). Further, by sending a transmission request (send, 10, color) to the request transmission unit 31 (step S74), the color is sent to the tuple space 2. Then, it waits for the transmission completion message to be sent back.

The tuple space 2 checks whether a reception request (receive, 10) having the same channel identifier 10 as the received transmission request (send, 10, color) exists in the tuple space 2. If it exists, a transmission completion message is sent to the transmission source host apparatus 3 of the transmission request (send, 10, color), and a reception message color is transmitted to the transmission source host apparatus 3 of the reception request (receive, 10).
When the program code execution unit 41 receives a transmission completion message from the tuple space 2 via the result reception unit 32 (YES in step S75), the program code execution unit 41 ends the transmission processing to the tuple space 2 and returns to step S31 in FIG. .

Next, the program code execution unit 41 evaluates the variable p, and evaluates the evaluation result (? 10 data1 (! 0 list3 (event, on-click, 20) (? 20 data2 (! -10 data1 (! G close 0 end)))))) is stored in the variable val (step S31 in FIG. 5).
When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result? Is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), what is the content of the variable com? Therefore (step S40, YES), the reception process from the tuple space 2 is performed (step S41).

  Specifically, first, the evaluation functions 2nd (p), 3rd (p), and 4th (p) are evaluated, and the evaluation results 10, data1 and (! 0 list3 (event, on-click, 20) (? 20 data2 (! −10 data1 (! G close 0 (end)))) is stored in the variables adrs, var and next, respectively (step S91). Subsequently, a reception request (receive, 10) is sent to the tuple space 2 via the request transmission unit 31 (step S92). Then, it waits for the received message to be sent back.

  The tuple space 2 checks whether a transmission request (send, 10, color) having the same channel identifier 10 as the received reception request (receive, 10) exists in the tuple space 2. If it exists, a transmission completion message is sent to the transmission source host apparatus 3 of the transmission request (send, 10, color), and a reception message color is transmitted to the transmission source host apparatus 3 of the reception request (receive, 10).

  When the program code execution unit 41 receives the received message color from the tuple space 2 via the result receiving unit 32 (step S93, YES in FIG. 9), the program code execution unit 41 stores the value color of this received message in the variable val (step S94). ). Then, the evaluation function substate (val, var, next) is evaluated, and the evaluation result (! 0 list3 (event, on-click, 20) (? 20 data2 (! −10 color (! G close 0 (end))) )) Is stored in the variable p (step S95). Thereby, the reception process from the tuple space 2 is terminated, and the process returns to step S31 in FIG.

Next, the program code execution unit 41 evaluates the variable p, and evaluates the result (! 0 list3 (event, on-click, 20) (? 20 data2 (! -10 color (! G close 0 (end))) )) Is stored in the variable val (step S31 in FIG. 5).
When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result! Is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), the content of the variable com is! Therefore (step S38, YES), transmission processing to the tuple space 2 is performed (step S39).

Specifically, first, the evaluation functions 2nd (p) and 3rd (p) are evaluated, and the evaluation results 0 and (event, on-click, 20) are stored in the variables adrs and val, respectively (step S61 in FIG. 7). ). In addition, the evaluation function 4th (p) is evaluated, and the evaluation result (? 20 data2 (! −10 color (! G close 0 (end)))) is stored again in the variable p (step S62).
Subsequently, a request “(“ search ”0)” is sent to the widget table unit 34 (step S63), and the widget table unit 34 is inquired as to whether or not a file corresponding to the channel identifier 0 exists in the own device. Wait until the result is sent back from the table unit 34.

  At this time, the widget table unit 34 waits for the arrival of a request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ search ”0)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “search” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result 0 is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “search” (step S6, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result (0, wid) is converted to the variable r. (Step S7). Then, the evaluation result (0, wiid) stored in the variable r is returned to the program code execution unit 41 as a result of the request (step S8), and the process returns to step S1.

  When receiving the result from the widget table unit 34 (step S64 in FIG. 7), the program code execution unit 41 stores the result (0, wiid) in the variable tmpWD (step S65). When the variable tmpWD is evaluated, the evaluation result is a set (0 wiid) of the channel identifier and the widget (NO in step S66), so the evaluation function 2nd (tmpWD) is evaluated and the evaluation result wid is stored again in the variable tmpWD. (Step S69). The evaluation functions 1st (val), 2nd (val), and 3rd (val) are evaluated, and the values event, on-click, and 20 are stored in the variables val1, val2, and val3. (Step S70).

  When the variable val1 is evaluated (step S71), since the variable val1 is neither read nor write but event (step S72, NO and step S76, NO), the evaluation function cons (list2 (list2 (val2, tmpWD), val3), eventTable) is evaluated, and an evaluation value, that is, a list ((on-clock width) 20) added to the beginning of the evaluation value of the variable eventTable is stored again in the variable eventTable (step S78). Thereby, the correspondence from the evaluation value on-click of val2 which is the type of the event and the widget 20 to the channel 20 from the set (on-click widget) is held in the event table.

  Subsequently, the evaluation function assoc (val2, tailTable) is evaluated, and the evaluation value (on-click f-on-click) is stored again in the variable val3 (step S79). Then, the evaluation function 2nd (val3) is evaluated, and the evaluation value f-on-click is stored again in the variable val3 (step S80). Further, the evaluation function set-event (val2, tmpWD, val3) is evaluated (step S81). As a result, the name of the evaluation function that is called when the event on-click occurs in the widget “wid” is updated to “f-on-click”. The transmission process to the tuple space 2 is terminated, and the process returns to step S31 in FIG.

Next, the program code execution unit 41 evaluates the variable p, and stores the evaluation result (? 20 data2 (! -10 color (! G close 0 (end))) in the variable val (step S31 in FIG. 5). ).
When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result? Is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), what is the content of the variable com? Therefore (step S40, YES), the reception process from the tuple space 2 is performed (step S41).

  Specifically, first, the evaluation functions 2nd (p), 3rd (p) and 4th (p) are evaluated, and the evaluation results 20, data2 and (! −10 color (! G close 0 (end))) are respectively obtained. Store in the variables adrs, var and next (step S91). Subsequently, a reception request (receive, 20) is sent to the tuple space 2 via the request transmission unit 31 (step S92). Then, it waits for the received message to be sent back.

  The tuple space 2 checks whether a transmission request having the same channel identifier 20 as the received reception request (receive, 20) exists in the tuple space 2. If it does not exist, the value NULL is sent as a reception message to the transmission source host apparatus 3 of the reception request (receive, 20).

  When receiving the received message from the tuple space 2 via the result receiving unit 32 (step S93 in FIG. 9, YES), the program code execution unit 41 stores the value NULL of this received message in the variable val (step S94). . Then, the evaluation function “substate” (val, var, next) is evaluated, and the evaluation result (! −10 color (! G close 0 (end))) is stored in the variable p (step S95). Thereby, the reception process from the tuple space 2 is terminated, and the process returns to step S31 in FIG.

Next, the program code execution unit 41 evaluates the variable p, and stores the evaluation result (! −10 color (! G close 0 (end))) in the variable val (step S31 in FIG. 5).
When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result! Is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), the content of the variable com is! Therefore (step S38, YES), transmission processing to the tuple space 2 is performed (step S39).

Specifically, first, the evaluation functions 2nd (p) and 3rd (p) are evaluated, and the evaluation results −10 and color are stored in the variables adrs and val, respectively (step S61 in FIG. 7). Further, the evaluation function 4th (p) is evaluated, and the evaluation result (! G close 0 (end)) is stored again in the variable p (step S62).
Subsequently, a request “(“ search ”10)” is sent to the widget table unit 34 (step S63), and the widget table unit 34 is inquired as to whether or not a file corresponding to the channel identifier 10 exists in the own device. Wait until the result is sent back from the table unit 34.

  At this time, the widget table unit 34 is waiting for the arrival of the request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ search ”10)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “search” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result 10 is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “search” (step S6, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result NULL is stored again in the variable r. (Step S7). Then, the evaluation result NULL stored in the variable r is returned to the program code execution unit 41 as a result of the request (step S8), and the process returns to step S1.

  When receiving the result from the widget table unit 34 (step S64 in FIG. 7), the program code execution unit 41 stores the result NULL in the variable tmpWD (step S65). When the variable tmpWD is evaluated, the evaluation result is NULL (step S66, YES), so a transmission request (send, -10, color) is sent to the tuple space 2 via the request transmission unit 31 (step S67). Then, it waits until a transmission completion message is sent back.

The tuple space 2 checks whether there is a reception request (receive, -10) having the same channel identifier −10 as the received transmission request (send, −10, color) in the tuple space 2. If it exists, a transmission completion message is sent to the transmission source host apparatus 3 of the transmission request (send, -10, color), and a reception message color is transmitted to the transmission source host apparatus 3 of the reception request (receive, -10).
When the program code execution unit 41 receives a transmission completion message from the tuple space 2 via the result reception unit 32 (YES in step S68), the program code execution unit 41 ends the transmission processing to the tuple space 2 and returns to step S31 in FIG. .

Next, the program code execution unit 41 evaluates the variable p, and stores the evaluation result (! G close 0 (end)) in the variable val (step S31 in FIG. 5).
When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), so the evaluation function 1st (p) is evaluated and the evaluation result! g is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), the content of the variable com is! Since it is g (step S44, YES), the widget closing process is performed (step S45).

  Specifically, first, evaluation functions 3rd (p) and 4th (p) are evaluated, and evaluation results 0 and (end) are stored in variables adrs and p, respectively (step S111 in FIG. 11). Subsequently, a request “(“ search ”0)” is sent to the widget table unit 34 (step S112), and the process waits until a result for the request is sent back from the widget table unit 34.

  At this time, the widget table unit 34 waits for the arrival of a request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ search ”0)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “search” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result 0 is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “search” (step S6, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result (0, wid) is converted to the variable r. (Step S7). Then, the evaluation result (0, wiid) stored in the variable r is returned to the program code execution unit 41 as a result of the request (step S8), and the process returns to step S1.

When receiving the result from the widget table unit 34 (step S113 in FIG. 11), the program code execution unit 41 stores the result (0, wiid) in the variable tmpWD (step S114).
Subsequently, a request “(“ close ”0)” is sent to the widget table unit 34 (step S115). Also, the evaluation function close (wid) is executed (step S116), and the process returns to step S31 in FIG.

  At this time, the widget table unit 34 is waiting for the arrival of the request from the program code execution unit 41 (step S1 in FIG. 3), and stores the received request “(“ close ”0)” in the variable r (step S1). S2). Then, the evaluation function 1st (r) is evaluated, and the evaluation result “close” is stored in the variable c (step S3). Further, the evaluation function 2nd (r) is evaluated, and the evaluation result 0 is stored again in the variable r (step S4). When the variable c is evaluated (step S5), since the content of the variable c is “close” (step S13, YES), the evaluation function assoc (r, widgetTable) is evaluated, and the evaluation result (0, wid) is converted into the variable r. (Step S14). Then, the set (0, wid) having the same contents as the variable r is deleted from the variable widgetTable, stored again in the variable widgetTable (step S15), and the process returns to step S1.

Next, the program code execution unit 41 evaluates the variable p and stores the evaluation result (end) in the variable val (step S31 in FIG. 5).
When the variable val is evaluated, the content of the variable val is not NULL (step S32, NO), the evaluation function 1st (p) is evaluated, and the evaluation result end is stored in the variable com (step S33). Further, the value NULL is stored in the variables adrs, val, var, next (step S34). When the variable com is evaluated (step S35), since the content of the variable com is end (step S36, YES), an end process is performed (step S37). That is, the value NULL is stored in the variables p, com, adrs, val, var, next (step S51 in FIG. 6), and the process returns to step S31 in FIG.

  Next, the program code execution unit 41 evaluates the variable p and stores the evaluation result NULL in the variable val (step S31 in FIG. 5). When the variable val is evaluated, since the content of the variable val is NULL (step S32, YES), the process is terminated.

  When the mouse code event occurs on the widget “wid” while the program code execution unit 41 is executing the above-described processing, the window system 36 calls the event evaluation function unit “on-click” with “wid” and “NULL” as arguments.

The called event evaluation function part on-click stores the arguments wid and NULL passed from the window system 36 in variables widTEMP and data, respectively. Then, the evaluation function assoc (list2 (A, widTEMP), eventTable) is evaluated, and the evaluation result (on-click width 20) is stored in the variable val (step S21 in FIG. 4). Further, the evaluation function 2nd (val) is evaluated, and the evaluation result 20 is stored in the variable adrs (step S22).
Subsequently, by sending a transmission request (send, 20, NULL) to the request transmission unit 31 (step S23), an argument of an evaluation function called when an event is detected is sent to the tuple space 2. Then, it waits until a transmission completion message is sent back.

The tuple space 2 checks whether a reception request (receive, 20) having the same channel identifier 20 as the received transmission request (send, 20, NULL) exists in the tuple space 2. If it exists, a transmission completion message is sent to the transmission source host apparatus 3 of the transmission request (send, 20, NULL), and a reception message NULL is transmitted to the transmission source host apparatus 3 of the reception request (receive, 20).
When the event evaluation function part on-click receives the transmission completion message from the tuple space 2 via the result receiving part 32 (step S24, YES), the event evaluation function part on-click returns NULL as a return value (step S25) and ends the process.

In the present embodiment, the host device 3 is described as having a request transmission unit 31, a result reception unit 32, a new channel generation unit 33, a widget table unit 34, an execution unit 35, and a window system 36. did. However, the configuration of the host device 3 can also be understood from the viewpoint of a functional unit that implements a series of operations based on each instruction of the program code.
For example, widget generation instruction? According to g, a widget generation unit that generates a widget, newly generates a channel corresponding to the widget, and stores the widget and the channel in association with each other is realized.
Also, read attribute transmission command! By following the “read” and the “read”, an attribute read transmission unit that reads a widget corresponding to the channel specified by this request from the widget generation holding unit and transmits the attribute of the read widget to the tuple space 2 is realized.

Also, attribute change command! By following the command and write, an attribute changing unit that reads the widget corresponding to the channel specified by this command from the widget generation holding unit and changes the attribute of the read widget is realized.
Also, widget close instruction! By following g, a close end unit that closes and ends the widget corresponding to the channel specified by this request is realized.
Furthermore, an argument transmission unit that transmits an argument of a function called when an event occurs to the tuple space is realized.

In the present embodiment, the tuple space 2 and the host device 3 can be realized by a computer. The computer includes a central processing unit (CPU), a read only memory (ROM), a random access memory (RAM), a circuit for interfacing with a display device, a keyboard, an external storage device, or the network 1. It may be of a known configuration.
The CPU executes processing according to a program stored in the ROM or RAM or a command input from the keyboard. Further, the CPU can write data to the external storage device and read data from the external storage device. Further, the CPU can acquire data from the network 1 and send data to the communication network.

  In such a computer (tuple space 2 and host device 3), the program for realizing the widget operating method and apparatus of the present invention is recorded on a recording medium such as a flexible disk, a CD-ROM, a DVD-ROM, or a memory card. Supplied in the finished state. When this recording medium is inserted into the external storage device, the program written in the recording medium is read and transferred to the computer. Then, the CPU writes the read program into the RAM or the like. Thereafter, based on data input from the network 1, an external storage device, or an external input device such as a keyboard, the CPU executes the above-described processing.

It is a block diagram which shows the structure of the tuple space type | mold communication system which has a channel production | generation function. It is a block diagram which shows the example of 1 structure of a host apparatus. It is a flowchart which shows the flow of operation | movement of a widget table part. It is a flowchart which shows the flow of operation | movement of an event evaluation function part. It is a flowchart which shows the flow of operation | movement of a program code execution part. It is a flowchart which shows the flow of an end process. It is a flowchart which shows the flow of the transmission process to a tuple space. It is a flowchart following FIG. It is a flowchart which shows the flow of the reception process from a tuple space. It is a flowchart which shows the flow of the production | generation process of a widget. It is a flowchart which shows the flow of a close process of a widget.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 ... Network, 2 ... Tuple space, 3 (3A-3N) ... Host apparatus, 31 ... Request transmission part, 32 ... Result reception part, 33 ... New channel production | generation part, 34 ... Widget table part, 35 ... Execution part, 35 ... Window system, 41 (41-1, 41-2) ... Program code execution part, 42 ... Event table, 43 ... Evaluation function name correspondence table, 44 (44-1, 44-2) ... Event evaluation function part.

Claims (4)

In a tuple space communication system in which information is shared and exchanged between host devices via a channel using a tuple space having a shared memory arranged in a network, an event that occurs on the display screen of the host device A widget operation method for performing an operation on a widget, which is an object that performs a corresponding process, as an input / output using the channel,
Generating a widget when generation of a widget is requested, generating a channel corresponding to the widget, and holding the widget and the channel in association with each other;
Transmitting attribute of the widget corresponding to the channel specified by the request to the tuple space when attribute reading of the widget is requested;
When the attribute change of the widget is requested, changing the attribute of the widget corresponding to the channel specified by the request;
Sending an argument of a function to be called when the event occurs to the tuple space;
And closing and closing the widget corresponding to the channel designated by the request when closing and closing the widget is requested. In a tuple space communication system in which information is shared and exchanged between host devices via a channel using a tuple space having a shared memory arranged in a network, an event that occurs on the display screen of the host device A widget operation device that executes an operation on a widget, which is an object that performs a corresponding process, as an input / output using the channel,
A widget generation / holding unit that generates a widget when generation of a widget is requested, generates a channel corresponding to the widget, and holds the widget and the channel in association with each other;
When the attribute reading of the widget is requested, attribute reading transmitting means for transmitting the attribute of the widget corresponding to the channel specified by the request to the tuple space;
Attribute change means for changing the attribute of the widget corresponding to the channel specified by the request when the attribute change of the widget is requested;
Argument sending means for sending an argument of a function called when the event occurs to the tuple space;
And a closing end unit for closing and closing the widget corresponding to the channel designated by the request when closing and closing of the widget are requested. In a tuple space type communication system in which information is shared and exchanged between computers through a channel using a tuple space having a shared memory arranged in a network, according to an event occurring on the display screen of the computer A widget operation program that executes an operation on a widget that is an object to be processed as an input / output using the channel,
Generating a widget when generation of a widget is requested, generating a channel corresponding to the widget, and holding the widget and the channel in association with each other;
Transmitting attribute of the widget corresponding to the channel specified by the request to the tuple space when attribute reading of the widget is requested;
When the attribute change of the widget is requested, changing the attribute of the widget corresponding to the channel specified by the request;
Sending an argument of a function to be called when the event occurs to the tuple space;
A widget operation program for causing the computer to execute a step of closing and closing the widget corresponding to a channel designated by the request when closing and termination of the widget are requested. A machine-readable recording medium on which the widget operation program according to claim 3 is recorded.

Images