Procedure execution device and procedure execution method

Abstract

The objective of this invention is to allow the user to invoke a composite remote procedure by connecting remote procedures that are managed on networks in distribution with each other, or define a new remote procedure. A remote procedure client receives a procedure definition hypertext from a remote procedure server, references procedure specifications of predefined remote procedures if necessary, and defines a new remote procedure by combining the predefined procedures. The procedure definition is sent with a procedure definition request to the remote procedure server and is stored. When the defined new procedure is invoked, a procedure execution unit executes the procedure under the control of a remote procedure manager. When an argument of the procedure is a hyperlink, the procedure execution unit executes at first a procedure pointed by the hypelink, and then restarts the original procedure. When the procedure pointed by the hyperlink is a composite procedure, the procedure is executed after the composite procedure is expanded by referencing procedure definitions.

Claims

What is claimed is:

1. A procedure execution device comprising:

a client including:

an input unit that inputs a first query to retrieve a program and a parameter for executing the program; and

a first transmitter that transmits the first query and the parameter to a communication network; and

a server connected with the client by the communication network, the server including:

a receiver that receives the first query and the parameter from the first transmitter;

a message analyzer that separates the first query and the parameter;

a memory that stores a procedure and a slot, both being corresponded to the first query;

a procedure retriever that retrieves the procedure and the slot corresponding to the first query; and

a second transmitter that transmits the procedure for retrieving a program and the slot in which the parameter separated by the message analyzer is inserted.

2. A computer program that controls a computer, comprising:

a storage medium that is readable through an input unit of the computer;

an input command stored in the storage medium for causing the computer to input a first query to retrieve a program and a parameter for executing the program;

a message analyzing command stored in the storage medium for causing the computer to separate the first query and the parameter;

a reading command stored in the storage medium for causing the computer to read data that includes a procedure and a slot, both being corresponded with the first query;

a procedure retrieval command stored in the storage medium for causing the computer to retrieve the procedure and the slot corresponding to the first query;

a procedure control command stored in the storage medium for causing the computer to invoke the procedure to retrieve the program and to insert the parameter in the slot.

3. The procedure execution device of claim 1, wherein the second transmitter transmits the procedure as the first query inputted through the input unit of the client and the slot in which the parameter separated by the message analyzer is inserted as the parameter inputted through the input unit of the client.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates to a device and method that manage and execute remote procedures on the network information system that connects plural computer systems executing information processing with each other. In particular, this invention makes it possible to combine remote procedures that are located on plural computer system in distribution and executes them.

2. Description of Related Art

Recently, computer systems are used under distributed environment in many cases, and the procedures executed on the computer systems are stored and managed in distribution. Under the distributed environment, the user can invoke a procedure located on a remote computer system. However, the remote user cannot combine plural procedures managed by the computer systems and execute them at will. Under the distributed environment, it is desired that all procedures are located in distribution and these distributed procedures are combined with each other and are executed easily and effectively.

There are conventional arts related to this invention shown as follows.

Common Gateway Interface (CGI) is a standard that defines environment variables, command lines, standard input and standard output between an application program and an information server that invokes the application program so that the information server, such as a hypertext transfer protocol (HTTP) server, creates information dynamically.

However, CGI does not provide any mechanism that allows an application program to invoke a service including a remote procedure provided by another information server, such as a HTTP server.

Accordingly, it has not been possible to at will combine and use application programs invoked by an information server such as a HTTP server through an information client such as a World Wide Web (WWW) client.

Japanese Laid-Open Publication Number 6-75892 discloses a remote procedure management device. This invention comprises a remote procedure request unit, a system remote procedure execution unit, a system remote procedure manager and a system procedure preprocessor. The remote procedure request unit requests a remote procedure for the service provided by the system. The system remote procedure execution unit executes a remote procedure for the service provided by the system. The system remote procedure manager manages remote procedures by linking the system remote procedure execution unit with plural remote procedures for services provided by the system based on a remote procedure identifier that is unique within the network system. The system procedure preprocessor is invoked by a stub, which executes a remote procedure call, queries the system remote procedure manager, determines the system's remote procedure to be invoked and invokes the corresponding system remote procedure execution unit. This configuration allows a remote procedure provided by a system to be called even if the remote procedure on the system is not defined in the interface of the application service.

ANSA Information Services Framework from Architecture Projects Management Limited is a distributed system based on Common Object Request Broker Architecture (CORBA) and WWW (Rees, O., Edwards, N., Madsen, M., Beasley, M. and McClenaghan, A.: A Web of Distributed Object, The ANSA Project, Architecture Projects Management Ltd(1995)).

This system uses Internet Inter-ORB Protocol in order to transfer General Inter-ORB Protocol via IP (Internet) protocol.

This technology makes it possible to access CORBA objects from the WWW by preparing a gateway for converting HTTP to IIOP and a gateway for converting IIOP to HTTP.

Delegate is a multipurpose protocol mediation system developed by Yutaka Sato in Electrotechnical Laboratory. ("Delegate: Multipurpose Protocol Mediation System: DeleGate", Bulletin of the Electrotechnical Laboratory, Vol.59, No.6 (1995)).

DeleGate executes a protocol conversion, character code conversion, and MIME (Multipurpose Internet Mail Extension) code conversion at the time of mediation in order to provide a protocol, character code and MIME code which are suitable for the client. However, this technology does not allow the user to synthesize a desired remote procedure call by combining a plurality of DeleGate in a form of a network.

OpenDoc (trademark of Apple Co.) is a component software architecture technology provided by Apple Corporation. Basic elements that constitute Opendoc are shown in the following.

(1) document: a set of parts combined by the user or application developer.

(2) part: a structural element of a document.

(3) part editor: a user interface to display the content of a part, to operate the content or to change the content.

(4) part service: user interface to provide a function held by a part, or to operate the content of a part.

(5) part viewer: a display of the content of a part to the user.

(6) container application: an application that supports a part editor and a part service.

Opendoc is a document-oriented application building environment. In Opendoc, a document is made of plural parts, which are application modules. A document in Opendoc is made by inserting parts in the top level part. Each part accompanies a part editor that changes the state of part according to a display of the part or an event on the part.

As described above, Opendoc provides a mechanism that creates a compound document made of plural types of objects by combining parts, each of which is an independent application module. However, this technology neither exports an interface of a part under the distributed environment including Internet nor defines a new function by connecting parts in a form of a graph under the distributed environment.

OLE (Object Linking and Embedding) is a component ware based on compound document provided by Microsoft Corporation. OLE uses Component Object Model (COM) provided by Microsoft Corporation as a collaborative object environment. (OLE and COM are trademark of Microsoft Co.).

DCOM (Distributed Component Object Model, Trademark) is an application level protocol provided by Microsoft Corporation. The objective of DCOM is a remote procedure call among objects in a network distributed component system. DCOM was called Network OLE. DCOM is based on DCE-RPC of Open Software Foundation and can be used in cooperation with COM provided by Microsoft Corporation.

OLE can create an application by combining a variety of parts. OLE provides two methods to insert parts, that is, the embedding and the linking. Embedding is a method to insert a whole object into another object. Linking is a method which the body of an object outside a document referenced by an pointer in the document. However, OLE cannot create an application by designating a graph made of plural links. In other words, OLE can create a compound part having plural levels of hierarchy by iterating one level part composition that uses RPC between objects. However, OLE neither defines a pattern specifying plural level of composition at a time nor connects parts dynamically at the time of execution.

IntelligentPad is a compound media tool kit proposed by Professor Yuzuru Tanaka in Hokkaido University. IntelligentPad is a platform to create a document by combining plural pads, each of which is a media object having a metaphor of a paper.

A primitive pad provided by IntelligentPad system provides functions including input, output storing of data, geometry management of pads, data conversion, and extension of the function of a specific application and a system. The user can combines the pads on a screen so as to create a composite pad, which composes functions.

However, IntelligentPad neither exports the function of a pad on the distributed environment including Internet nor executes distributed computing by combining pads that exist in distributed environment.

As described above, by using the conventional arts, it is difficult for the user who uses remote procedure client application to define a desired service by combining plural remote procedure servers. Further, when a service is provided by combining remote procedure calls, it is difficult for the user who uses a client application to know variables assigned to each remote procedure and the execution result.

SUMMARY OF THE INVENTION

The present invention has been made in view of the above circumstances. An object of the present invention is to allow the user to invoke a composite procedure or to define a new remote procedure by combining interactively remote procedures managed in distribution on a network.

To achieve the object as embodied and broadly described herein, this invention provides a procedure execution device comprising: an input unit for inputting a first query to retrieve a program and a parameter that is necessary for executing the program; a message analyzer for separating the first query and the parameter inputted through the input unit; a storage for storing a second query and a slot to insert a parameter necessary for a program retrieved by using the second query, both the second query and the slot corresponding to the first query; a procedure retriever for retrieving the second query and the slot corresponding to the first query separated by the message analyzer; and a procedure controller for inputting the second query as the first query and for inputting the slot to which the parameter separated by the message analyzer is inserted as the parameter through the input unit.

This configuration makes it possible to store a second query related to a first query, and a slot for inserting a parameter of a program retrieved by using the second query into a storage such as a database, to synthesize the program retrieved by the first query by using the program retrieved by using the second query, and to execute the synthesized program.

The present invention further provides an information processing system including a plurality of computer systems that are connected with each other by a network and stores procedures, comprising: a storage for storing a composite procedure that is described so that an argument thereof includes location information on the network for a procedure; a call unit, when the composite procedure is executed with the location information for the procedure as an argument, for calling the procedure corresponding to the location information; a first execution unit for executing the called procedure and returning a result of the execution; and a second execution unit for receiving the result of the called procedure returned by the first execution unit and for continuing execution of the composite procedure.

This configuration allows the user to synthesize a composite procedure by assigning locations of plural procedures to arguments in order to combine them, and to execute the composite procedure by invoking the procedures located in the locations on the network specified by the assignments of the arguments.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram illustrating the configuration of the first embodiment of the present invention.

FIG. 2 shows a concept of the operations of the first embodiment.

FIG. 3 is a block diagram illustrating the configuration of the second embodiment of the present invention.

FIG. 4 shows a concept of the operations of the second embodiment.

FIG. 5 is a block diagram illustrating the configuration of the third embodiment of the present invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

[First Embodiment]

In a first embodiment, a remote procedure is defined as a hypertext created by combining plural remote procedures whose interfaces are exported by using hypertexts. One or more servers manage the definitions of remote procedures and executes the remote procedures. This embodiment explains an example that defines a procedure calculating a factorial by combining a conditional branch procedure, a multiplication procedure and a decrement procedure, and executes the defined factorial procedure.

FIG. 1 is a block diagram illustrating the configuration of the first embodiment. In FIG. 1, a remote procedure management device includes remote procedure client 100 and remote procedure server 200. Remote procedure client 100 and remote procedure server 200 are connected with each other via network that is not shown in this figure. Functions executed by remote procedure client 100 or remote procedure server 200 are implemented by software programs. The prescribed programs are stored in storage mediums 101a and 201a, and are installed beforehand in remote procedure client 100 and remote procedure server 200 through storage medium drivers 101 and 201. Generally, the remote procedure management device can includes one or more remote procedure clients 100 and one or more remote procedure servers 200.

In the following explanation, only one remote procedure server 200 stores plural definitions of procedures; however, those definitions of procedures and the procedures can be stored in plural remote procedure servers 200 and remote procedure clients 100 in distribution. Further, the remote user can creates a new procedure by combining them, and can make the created procedure execute from a remote client.

Remote procedure client 100 includes user input unit 102, hypertext input unit 103, message creator 104, message memory 105, transmitter 106, receiver 107, hypertext analyzer 108 and hypertext output unit 109.

User input unit 102 receives an input that the user input by using a keyboard, pointing device or the like, outputs a message creation request to message creator 104, and outputs an input request to hypertext input unit 103 in response to the user's input. Hypertext input unit 103 receives a hypertext and outputs it to message creator 104 in response to the input request from user input unit 102. Hypertext input unit 103 also requests of message memory 105 to output a second message and includes the output second message as a part of the hypertext in response to the input request from user input unit 102.

Message creator 104 creates a message for remote procedure server 200 in response to the message creation request from user input unit 102, and outputs the created message to transmitter 106 and message memory 105. Message memory 105 gives a number to the input message, and manages messages by using a list that is made of elements each is a pair of the message and the given number. Massage memory 105 receives a message output request that specifies a number, retrieves the message corresponding to the number in the request from the list, and outputs the retrieved message to hypertext input unit 103.

Transmitter 106 sends the message coming from message creator 104 to remote receiver 202.

Receiver 107 receives a hypertext that is a reply from remote transmitter 203, and outputs the received hypertext to hypertext analyzer 108. Hypertext analyzer 108 analyzes the hypertext coming from receiver 107, requests hypertext output unit 109 to show the hypertext to the user, and outputs a message creation information to message creator 104. The message creation information is a information of the message to be created in accordance with the message creation request from message input 102.

Hypertext output unit 109 shows a hypertext in the form of characters, images or audio data in accordance with the requests coming from the hypertext analyzer 108 and user input unit 102.

Remote procedure server 200 includes receiver 202, transmitter 203, message analyzer 204, hypertext analyzer 205, attribute creator 206, procedure specification creator 207, procedure definition creator 208, definition hypertext output unit 209, remote procedure manager 210, remote procedure containers 211(1) through 211(M), procedure execution unit 212 and procedure execution environment manager 213. "M" in the reference numeral 211(M) means an arbitrary natural number. The reference numeral 211 sometimes represents the remote procedure containers 211(1) through 211(M). In the following explanation, the reference numerals 2111, 2112 and 2113 may be also used with the suffix (1) through (m) in the same way. Each remote procedure container 211 includes attribute memory 2111, procedure specification export unit 2112 and procedure definition unit 2113.

Receiver 202 receives a message coming from remote transmitter 106 and outputs the received message to message analyzer 204. Also, receiver 202 receives the result of a procedure execution from remote transmitter 106 and outputs procedure execution unit 212. Transmitter 203 sends the result of a procedure execution and a message to remote receiver 107.

Message analyzer 204 analyzes a message coming from receiver 202 and classifies it into "procedure call message", "procedure specification export request message", "procedure definition request message" and "procedure definition hypertext output request message".

When the message is a procedure call message, message analyzer 204 extracts a parameter from the message and outputs it to remote procedure manager 210. When the message is a procedure definition request message, message analyzer 204 extracts a hypertext from the message and outputs it to hypertext analyzer 205.

When remote procedure manager 210 receives a parameter from message analyzer 204, it retrieves remote procedure container 211 that matches the query included in the parameter. Further, remote procedure manager 210 outputs a procedure definition stored in procedure definition unit 2113 of the retrieved procedure container 211 and the parameter to procedure execution unit 212 in order to make a request for the execution of the procedure.

When remote procedure manager 210 receives procedure definition and procedure specification from procedure definition creator 208 and procedure specification creator 207, respectively, it creates a new remote procedure container 211 and stores the procedure definition and the procedure specification into new procedure definition unit 2113 and procedure specification export unit 2112, respectively. Attribute memory 2111 stores a list of attributes, each is a pair of an attribute name and an attribute value. In this embodiment, attribute "name", which identifies the remote procedure container 211, is stored. Generally, attribute memory 2111 can store at least one pair of an attribute name and an attribute value. The remote procedure container 211 should be identified by designating at least one attribute.

Procedure specification export unit 2112 stores a specification that includes the following elements: a description regarding arguments of a procedure in the form of a formal language, a description regarding arguments of a procedure in the form of a natural language, a description regarding return from a procedure in the form of a formal language, a description regarding return from a procedure in the form of a natural language, and procedure call expression creation data for creating a procedure call expression. When procedure specification export unit 2112 receives a procedure specification export request, it outputs the specification in the form of a hypertext. Generally, procedure specification export unit 2112 can store any partial set that includes at least one element of the specification described above.

For example, the following is a hypertext of a procedure specification based on HTML. This hypertext shows that the procedure requires two arguments "v1" and "v2" that requests to be assigned and the query of remote procedure container 211 is "/times".

(1)

<HEAD>

<TITLE> Page for multiplication </TITLE>

</HEAD>

<H1>Page for multiplication </H1>

A page for multiplying given arguments <P>

<HR>

<FORM METHOD="GET" ACTION="/times">

First Argument: <INPUT NAME="v1" TYPE="entry"><P>

Second Argument: <INPUT NAME="v1" TYPE="entry"><P>

<INPUT TYPE="submit" VALUE="Start Function">

</FORM>

Procedure execution unit 212 executes a procedure according to a list of arguments input by message analyzer 204. During the execution of the procedure, when the other procedure container 211 is requested to execute a procedure, a message is sent through message analyzer 204.

Next, an example that defines and executes a factorial procedure is explained in detail. The factorial procedure is defined by combining a conditional branch procedure, multiplication procedure and decrement procedure. At the beginning, it is explained what procedures are contained. Here, all procedure definition units 2113 are supposed to have arguments "v1", "v2", "v3", and the like, for convenience of explanation, unless otherwise provided. We use the notation of a message as "http://host2/fname?v1=a1&v2=a2". It means that remote procedure container 211 that includes attribute memory 2111 in which the attribute value of attribute "name" is "fname" has arguments "v1" and "v2". The message also means that values "a1" and "a2" are assigned to arguments "v1" and "v2", respectively.

Procedure definition creator 208 receives a new procedure definition expression (for example, a factorial procedure definition expression) and creates remote procedure definition unit. More in detail, procedure definition creator 208 stores a procedure definition expression inputted by hypertext analyzer 205 and creates a procedure definition unit that executes the following list transformation algorithm.

(1) If the input expression is a list,

(a) Assign the head element of the list to "car".

(b) If the list consists of only the head element, return "car".

Otherwise, go to next step.

(c) For each k-th element of the list (k=2, . . . , last element), replace the right side of "=" with the result obtained by applying this algorithm to the right side of "=" and escaping special characters.

(d) Return "car?second&third". Here, "second" and "third" mean the second and third elements of the list, respectively.

(2) If the input expression is a variable, return the value assigned to the variable to procedure execution environment manager 213.

(3) If the input expression is neither a variable nor a list, return the input expression.

Next, procedures that are used for synthesizing the factorial procedure are explained. The procedures are: a conditional branch procedure, a multiplication procedure and a decrement procedure. At the beginning, remote procedure container 211(1) that contains data regarding the conditional branch procedure is explained.

Attribute memory 2111(1) of remote procedure container 211(1) stores attribute name "name" and its attribute value "if".

Procedure specification export unit 2112(1) stores the following.

(2)

<HEAD>

<TITLE> Page for conditional branch </TITLE>

</HEAD>

<H1> Page for conditional branch </H1>

A page for fork of execution according to the condition of the given conditional parameter<P>

<HR>

<FORM METHOD="get" ACTION="http://host2/if">condition: <INPUT NAME="v1" TYPE="entry"><P>

satisfied: <INPUT NAME="v2" TYPE="entry"><P>

unsatisfied: <INPUT NAME="v3" TYPE="entry"><P>

<INPUT TYPE="submit" VALUE="Start Function">

</FORM>

Procedure definition unit 2113(1) stores a procedure definition by which procedure execution unit 212 executes the procedure according to the following conditional branch algorithm.

[Step 1] A first assignment to argument "v1" is examined. If the first assignment is a string indicating decimal integer, the string is transformed into an integer and the integer is assigned as a second assignment to "v1". Then, the control goes to step 4. If the first assignment to argument "v1" is a second message including a hyperlink, the second message is inputted to transmitter 203, and the control goes to the next step.

[Step 2] Transmitter 203 outputs the message to receiver 202 corresponding to the hyperlink, and outputs a reply that comings from the receiver 202 as a result to procedure execution unit 212.

[Step 3] Procedure execution unit 212 analyzes the reply and gets a second assignment to "v1".

[Step 4] The control goes to step 9, if the second assignment to argument "v1" is integer "0". Otherwise, the control goes to step 5.

[Step 5] A first assignment to argument "v2" is examined. If the first assignment is a string indicating a decimal integer, the string is transformed into an integer and the integer is assigned as a second assignment to "v2". Then, the control goes to step 8. If the first assignment to argument "v2" is a third message including a hyperlink, the third message is inputted to transmitter 203, and the control goes to the next step.

[Step 6] Transmitter 203 outputs the third message to receiver 202 corresponding to the hyperlink, and outputs a reply that comings from the receiver 202 as a result to procedure execution unit 212.

[Step 7] Procedure execution unit 212 analyzes the reply and gets a second assignment to "v2".

[Step 8] A hypertext including the second assignment to "v2" as a result is created, and the created hypertext is outputted to transmitter 203. Then, the operation stops.

[Step 9] A first assignment to argument "v3" is examined. If the first assignment is a string indicating a decimal integer, the string is transformed into an integer and the integer is assigned as a second assignment to "v3". Then, the control goes to step 12. If the first assignment to argument "v3" is a fourth message including a hyperlink, the fourth message is input to transmitter 203.

[Step 10] Transmitter 203 outputs the fourth message to receiver 202 corresponding to the hyperlink, and outputs a reply that comings from the receiver 202 as a result to procedure execution unit 212.

[Step 11] Procedure execution unit 212 analyzes the reply and gets a second assignment to "v3".

[Step 12] A hypertext including the second assignment to "v3" as a result is created, and the created hypertext is output to transmitter 203. Then, the operation stops.

Next, remote procedure container 211(2) that stores data regarding a multiplication procedure is explained. Attribute memory 2111(2) of remote procedure container 211(2) stores an attribute in which the value of attribute name "name" is "times". Procedure definition unit 2113(2) stores a procedure definition by which procedure execution unit 212 executes the procedure according to the following multiplication algorithm. Procedure specification export unit 2112(2) has already been explained.

[Step 1] A first assignment to argument "v1" is examined. If the first assignment is a string indicating a decimal integer, the string is transformed into an integer and the integer is assigned as a second assignment to "v1". Then, the control goes to step 4. If the first assignment to argument "v1" is a second message including a hyperlink, the second message is input to transmitter 203, and the control goes to the next step.

[Step 2] Transmitter 203 outputs a message to receiver 202 corresponding to the hyperlink, and outputs a reply that comings from the receiver 202 as a result to procedure execution unit 212.

[Step 3] Procedure execution unit 212 analyzes the reply and gets a second assignment to "v1".

[Step 4] A first assignment to argument "v2" is examined. If the first assignment is a string indicating a decimal integer, the string is transformed into an integer and the integer is assigned as a second assignment to "v2". Then, the control goes to step 7. If the first assignment to argument "v2" is a third message including a hyperlink, the third message is input to transmitter 203.

[Step 5] Transmitter 203 outputs the third message to receiver 202 corresponding to the hyperlink, and outputs a reply that comings from the receiver 202 as a result to procedure execution unit 212.

[Step 6] Procedure execution unit 212 analyzes the reply and gets a second assignment to "v2".

[Step 7] A hypertext including the value obtained by multiplying the second assignment to "v2" and the second assignment to "v3" as a result is created, and the hypertext is output to transmitter 203. Then, the operation stops.

Next, remote procedure container 211(3) that stores data regarding a decrement procedure is explained. Attribute memory 2111(3) of remote procedure container 211(3) stores an attribute in which the value of attribute name "name" is "dec". Procedure definition unit 2113(3) stores a procedure definition by which procedure execution unit 212 executes the procedure according to the following decrement algorithm.

[Step 1] A first assignment to argument "v1" is examined. If the first assignment is a string indicating a decimal integer, the string is transformed into an integer and the integer is assigned as a second assignment to "v1". Then, the control goes to step 4. If the first assignment to argument "v1" is a second message including a hyperlink, the second message is input to transmitter 203, and the control goes to the next step.

[Step 2] Transmitter 203 outputs a message to receiver 202 corresponding to the hyperlink, and outputs a reply that comings from the receiver 202 as a result to procedure execution unit 212.

[Step 3] Procedure execution unit 212 analyzes the reply and gets a second assignment to "v1".

[Step 4] A hypertext including the value obtained by subtracting 1 from the second assignment to "v1" as a result is created, and the hypertext is output to transmitter 203. Then, the operation stops.

Next, the definition of a procedure is explained in detail.

When variables or values include characters ":", "/", "?", "=", "&", "%", and the like, they are respectively represented by "%3A", "%2F", "%3F", "%3D", "%26" and "%25", each of which is created by concatenating "%" and an ASCII cord of the character, as CGI defines. Generally, some methods can be used to extract a pair of an argument name and its value. For example, "("and")" can be used as a start symbol and an end symbol, respectively. Instead, an escape method, which replaces a character with another string, can be used.

In the following, it is explained that user inputs, operations of remote procedure client 100 and operations of remote procedure server 200 when a remote procedure that calculates a factorial is defined.

[Step 1] The user inputs a URL (uniform resource locator) represented by string "http://host2/define" through user input unit 102 in order to request of remote procedure server 200 to define a remote procedure.

[Step 2] Message creator 104 requests of transmitter 106 to send message "GET /define" to receiver 202 represented by "host2".

[Step 3] Transmitter 106 sends the message to receiver 202.

[Step 4] Receiver 202 inputs the received message to message analyzer 204.

[Step 5] Message analyzer 204 analyzes the message. Since the message is a definition hypertext output request, message analyzer 204 requests of definition hypertext output unit 209 to output a hypertext.

[Step 6] Definition hypertext output unit 209 output the following hypertext (3) to transmitter 203.

(4)

<HEAD>

<TITLE> Page for defining remote procedure </TITLE>

</HEAD>

<H1> Page for defining remote procedure </H1>

<HR>

<FORM METHOD="post" ACTION="/define">

Designation of attributes:

<INPUT NAME="attribute" TYPE="entry"><P>

Designation of procedure specification:

<INPUT NAME="spec" TYPE="entry"><P>

Designation of procedure definition:

<INPUT NAME="definition" TYPE="entry"><P>

<INPUT TYPE="submit" VALUE="Execution of Definition">

</FORM>

<HR>

[Step 7] Transmitter 203 outputs the hypertext (3) to receiver 107.

[Step 8] Receiver 107 analyzes the received hypertext (3) and requests of hypertext output unit 109 to display the hypertext (3).

[Step 9] Hypertext output unit 109 displays the hypertext (3) to show it to the user.

[Step 10] According to the displayed hypertext (3), the user inputs "name=factorial" as an attribute and the following procedure specification (4).

(4)

<HEAD>

<TITLE> Page for factorial </TITLE>

</HEAD>

<H1> Page for factorial </H1>

Receiving an integer or an hyperlink, and returning the factorial thereof

<HR>

<FORM METHOD="get" ACTION="/factorial">

Argument: <INPUT NAME="arg" TYPE="entry"><P>

<INPUT TYPE="submit" VALUE="start functional up">

</FORM>

<HR>

[Step 11] Next, the user inputs a procedure definition according to the following process.

[Substep a] The user inputs "http://host2/if" through a keyboard in order to get the procedure specification of a conditional branch procedure.

[Substep b] Message creator 104 requests of transmitter 106 to send message "GET /if" to receiver 202 identified by "http://host2".

[Substep c] Transmitter 106 sends the message to receiver 202.

[Substep d] Receiver 202 outputs the received message to message analyzer 204.

[Substep e] Message analyzer 204 analyzes the message (3). Since the message (3) is a procedure specification export request, message analyzer requests of remote procedure manager 210 to retrieve remote procedure container 211 whose attribute is "if" and to request of the retrieved remote procedure container 211 to export its procedure specification.

[Substep f] Remote procedure manager 210 retrieves remote procedure container 211(1) whose attribute is "if", and requests of the retrieved remote procedure container 211(1) to export its procedure specification.

[Substep g] Remote procedure container 211(1) requests of procedure specification export unit 2112(1) to export the specification.

[Substep h] Procedure specification export unit 2112(1) outputs the specification regarding the procedure definition stored by procedure definition unit 2113(1) in the form of a hypertext in response to the hypertext export request.

[Substep i] Remote procedure manager 210 returns the hypertext as a reply to receiver 107 through transmitter 203.

[Substep j] Receiver 107 inputs the received hypertext to hypertext analyzer 108.

[Substep k] Hypertext analyzer 108 analyzes the input hypertext, requests of hypertext output unit 109 to output the hypertext, and outputs message creation information to message creator 104.

[Substep l] According to the output hypertext, the user specifies "arg" as an item of condition and set "1" as an item when the condition is not satisfied. Then, the user gets a procedure specification of multiplication so as to input the expression when the condition is satisfied. At this moment, message memory 105 stores the following message.

    (5)     (http://host2/if
                v1=arg
                v2=
                v3=1
                )

    (6)     (http://host2/if
                v1=arg
                v2=(http://host2/times
                    v1=(http://host2/factorial
                       arg=(http://host2/dec
                           vi=arg
                           )
                           )
                       v2=arg
                       )
                    v3=1
                    )

    (8)     (http://host2/if
                v1=arg
                v2=(http://host2/times
                    v1=(http://host2/factorial
                       arg=(http://host2/dec
                           v1=arg
                           )
                       )
                    v2=arg
                    )
                v3=1
                )

    (15)    (http://host2/if
                v1=arg
                v2=(http://host2/times
                    v1=(http://host2/factorial
                       arg=(http://host2/dec
                           v1=arg
                           )
                    v2=arg
                    )
                v3=1
                )

    (25)    (http://host2/if
                v1=arg
                v2=(http://host2/times
                    v1=(http://host2/factorial
                    arg=(http://host2/dec
                       v1=arg
                       )
                    )
                v2=arg
                )
            )

    (39)    (http://host2/if
            v1=
            v2=url
            v3=
            )

    (41)    (http://host2/if
            v1=(http://host2/title-is
                v1=url
                v2--title
                )
            v2=url
            v3=(http://host2/find-sub
                urls=(http://host2/children
                    v1=url
                    )
                title=title
                )
            )

    (43)    (http://host2/if
                v1=urls
                v2=(http://host2/if
                    v1=(http://host2/find
                       url=(http://host2/first
                           v1=urls
                           )
                       title=title)
                       )
                    v2=(http://host2/find
                       url=(http://host2/first
                           v1=urls
                           )
                       title=title)
                       )
                    v3=(http://host2/find-sub
                       urls=(http://host2/rest
                           v1=urls
                           )
                       title=title
                       )
                    )
                v3=0
                )

    (44)    (http://host2/if
                v1=(http://host2/title-is
                    v1=url
                    v2=title
                    )
                v2=url
                v3=(http://host2/find-sub
                    urls=(http://host2/children
                       v1=url
                       )
                    title=title
                    )
    (45)    http://host2/if?
                v1=(http://host2/title-is?
                    v1=(http://host3/aaa)&
                    v2=(ccc)
                    )&
                v2=(http://host3/aaa)&
                v3=(http://host2/find-sub?
                    urls=(http://host2/children?
                       v1=(http://host3/aaa)
                       )&
                    title=(ccc)
                    )
                )

    (46)    GET /if?
                v1=(http://host2/title-is?
                    v1=(http://host3/aaa)&
                    v2=(ccc)
                    )&
                v2=(http://host3/aaa)&
                v3=(http://host2/find-sub?
                    urls=(http://host2/children
                       v1=(http://host3/aaa)
                       )&
                    title=(ccc)
                    )
                )

    (47)    v1=(http://host2/title-is?
                v1=(http://host3/aaa)&
                v2=(ccc)
                )
            v2=(http://host3/aaa)
            v3=(http://host2/find-sub?
                urls=(http://host2/children?
                    v1=(http://host3/aaa)
                    )&
                title=(ccc)
                )

    (51)    http://host2/find-sub?
                urls=(http://host2/children?
                    v1=(http://host3/aaa)
                title=(ccc)
    (52)    GET /find-sub?
                urls=(http://host2/children?
                    v1=(http://host3/aaa)
                    )&
                title=(ccc)

    (53)    urls=(http://host2/children?
                v1=(http://host3/aaa)
                )
            title=(ccc)

    (54)    (http://host2/if
                v1=urls
                v2=(http://host2/if
                    v1=(http://host2/find
                       url=(http://host2/first
                           v1=urls
                           )
                       title=title)
                       )
                    v2=(http://host2/find
                       url=(http://host2/first
                       v1=urls
                       )
                    title=title)
                    )
                v3=(http://host2/find-sub
                    urls=(http://host2/rest
                       v1=urls
                       )
                    title=title
                    )
                )
            v3=0
            )
    (55)
    (http://host2/if?
            v1=(http://host2/children?
                v1=(http://host3/aaa)
                )&
            v2=(http://host2/if?
                v1=(http://host2/find?
                    url=(http://host2/first
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc))
                    )&
                v2=(http://host2/find?
                    url=(http://host2/first?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    title=(ccc))
                    )&
                v3=(http://host2/find-sub?
                    urls=(http://host2/rest?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc)
                    )
                )&
            v3=0
            )

    (56)
    GET /if?
            v1=(http://host2/children?
                v1=(http://host3/aaa)
                )&
            v2=(http://host2/if?
                v1=(http://host2/find?
                    url=(http://host2/first
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc))
                    )&
                v2=(http://host2/find?
                    url=(http://host2/first?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    title=(ccc))
                    )&
                v3=(http://host2/find-sub?
                    urls=(http://host2/rest?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc)
                    )
                )&
            v3=0
            )

    (57)    v1=(http://host2/children?
                v1=(http://host3/aaa)
                )
            v2=(http://host2/if?
                v1=(http://host2/find?
                    url=(http://host2/first
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc))
                    )&
                v2=(http://host2/find?
                    url=(http://host2/first?
                       v1=(http://host2/chiidren?
                           v1=(http://host3/aaa)
                           )
                       )
                    title=(ccc))
                    )&
                v3=(http://host2/find-sub?
                    urls=(http://host2/rest?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc)
                    )
                )
            v3=0

    (59)    http://host2/if?
                v1=(http://host2/find?
                    url=(http://host2/first
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc))
                    )&
                v2=(http://host2/find?
                    url=(http://host2/first?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    title=(ccc))
                    )&
                v3=(http://host2/find-sub?
                    urls=(http://host2/rest?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc)
                    )

    (60)    GET /if?
                v1=(http://host2/find?
                    url=(http://host2/first
                       v1=(http://host2/children?
                           v1=(http://hosts/aaa)
                           )
                       )&
                    title=(ccc))
                    )&
                v2=(http://host2/find?
                    url=(http://host2/first?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    title=(ccc))
                    )&
                v3=(http://host2/find-sub?
                    urls=(http://host2/rest?
                       v1=(http://host2/ohildren?
                           v1=(http://host3/aaa)
                           )
                       )&
                    title=(ccc)
                    )

    (61)    v1=(http://host2/find?
                url=(http://host2/first?
                    v1=(http://host2/children?
                       v1=(http://host3/aaa)
                       )
                    )&
                title=(ccc))
                )&
            v2=(http://host2/find?
                url=(http://host2/first?
                    v1=(http://host2/children?
                       v1=(http://host3/aaa)
                       )
                    )
                title=(ccc))
                )&
            v3=(http://host2/find-sub?
                urls=(http://host2/rest?
                    v1=(http://host2/children?
                       v1=(http://host3/aaa)
                       )
                    )&
                title=(ccc)

    (62)    GET /find?
                url=(http://host2/first?
                    v1=(http://host2/children?
                       v1=(http://host3/aaa)
                       )
                    )&
                title=(ccc))

    (63)
    http://host2/if?
            v1=(http://host2/title-is?
                v1=(http://host2/first?
                    v1=(http://host2/children?
                       v1=(http://host3/aaa)
                       )
                    )&
                v2=(ccc)
                )&
            v2=(http://host2/first?
                v1=(http://host2/children?
                    v1=(http://host3/aaa)
                    )
                )&
            v3=(http://host2/find-sub?
                urls=(http://host2/children?
                    v1=(http://host2/first?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    )&
                title=(ccc)
            )

    (64)    http://host2/find-sub?
                urls=(http://host2/rest?
                    v1=(http://host2/children?
                       v1=(http://host3/aaa)
                       )
                    )&
                title=(ccc)

    (65)
    http://host2/if?
            v1=(http://host2/rest?
                v1=(http://host2/children?
                    v1=(http://host3/aaa)
                    )
                )&
            v2=(http://host2/if?
                v1=(http://host2/find?
                    url=(http://host2/first?
                       v1=(http://host2/rest?
                           v1=(http://host2/children?
                               v1=(http://host3/aaa)
                               )
                           )
                       )&
                    title=(ccc)
                    )
                )&
            v2=(http://host2/find?
                url=(http://host2/first?
                    v1=(http://host2/rest?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    )&
                title=(ccc)
                )
            )&
            v3=(http://host2/find-sub?
                urls=(http://host2/rest?
                    v1=(http://host2/rest?
                       v1=(http://host2/children?
                           v1=(http://host3/aaa)
                           )
                       )
                    )&
                title=(ccc)
                )
            )
            v3=0

• Inventors
  Horikiri, Kazunori;
• Assignee
  Fuji Xerox Co., Ltd. (Tokyo, JP)
• Published
  Jan-15-2002
• Current US Classes:
  707/3
  709/203
  719/311
  719/315
  719/330
• Application #
  986731
• International Classes
  G06F 015/16
• Field of Search
  709/201 709/202 709/203 709/217 709/230 709/231 709/310 709/311 709/314 709/315 709/316 709/328 709/329 709/330 709/331 709/332 717/4 717/2 707/3 707/4 707/5 707/101 707/100
• Examiner
  Luu; Le Hien
• Agent
  Oliff & Berridge, PLC
• US Patent References:
  5287444
  5469574
  5544316
  5748881
  5754175
  5765152
  5793966
  5826064
  5826077
  5872973
  5875332
  5887172
  5903725
  6049838